accounttypes.pb.go

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

package accounttypes

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"
	_ "berty.tech/berty/v2/go/pkg/messengertypes"
	protocoltypes "berty.tech/berty/v2/go/pkg/protocoltypes"
	pushtypes "berty.tech/berty/v2/go/pkg/pushtypes"
)

// 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 NetworkConfigPreset int32

const (
	NetworkConfigPreset_NetPresetUndefined     NetworkConfigPreset = 0
	NetworkConfigPreset_NetPresetPerformance   NetworkConfigPreset = 1
	NetworkConfigPreset_NetPresetFullAnonymity NetworkConfigPreset = 2
)

var NetworkConfigPreset_name = map[int32]string{
	0: "Undefined",
	1: "Performance",
	2: "FullAnonymity",
}

var NetworkConfigPreset_value = map[string]int32{
	"Undefined":     0,
	"Performance":   1,
	"FullAnonymity": 2,
}

func (x NetworkConfigPreset) String() string {
	return proto.EnumName(NetworkConfigPreset_name, int32(x))
}

func (NetworkConfigPreset) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_5d43f30c8e455603, []int{0}
}

type NetworkConfig_Flag int32

const (
	NetworkConfig_Undefined NetworkConfig_Flag = 0
	NetworkConfig_Disabled  NetworkConfig_Flag = 1
	NetworkConfig_Enabled   NetworkConfig_Flag = 2
)

var NetworkConfig_Flag_name = map[int32]string{
	0: "Undefined",
	1: "Disabled",
	2: "Enabled",
}

var NetworkConfig_Flag_value = map[string]int32{
	"Undefined": 0,
	"Disabled":  1,
	"Enabled":   2,
}

func (x NetworkConfig_Flag) String() string {
	return proto.EnumName(NetworkConfig_Flag_name, int32(x))
}

func (NetworkConfig_Flag) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_5d43f30c8e455603, []int{14, 0}
}

type NetworkConfig_TorFlag int32

const (
	NetworkConfig_TorUndefined NetworkConfig_TorFlag = 0
	NetworkConfig_TorDisabled  NetworkConfig_TorFlag = 1
	NetworkConfig_TorOptional  NetworkConfig_TorFlag = 2
	NetworkConfig_TorRequired  NetworkConfig_TorFlag = 3
)

var NetworkConfig_TorFlag_name = map[int32]string{
	0: "TorUndefined",
	1: "TorDisabled",
	2: "TorOptional",
	3: "TorRequired",
}

var NetworkConfig_TorFlag_value = map[string]int32{
	"TorUndefined": 0,
	"TorDisabled":  1,
	"TorOptional":  2,
	"TorRequired":  3,
}

func (x NetworkConfig_TorFlag) String() string {
	return proto.EnumName(NetworkConfig_TorFlag_name, int32(x))
}

func (NetworkConfig_TorFlag) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_5d43f30c8e455603, []int{14, 1}
}

type NetworkConfig_DHTFlag int32

const (
	NetworkConfig_DHTUndefined  NetworkConfig_DHTFlag = 0
	NetworkConfig_DHTDisabled   NetworkConfig_DHTFlag = 1
	NetworkConfig_DHTClient     NetworkConfig_DHTFlag = 2
	NetworkConfig_DHTServer     NetworkConfig_DHTFlag = 3
	NetworkConfig_DHTAuto       NetworkConfig_DHTFlag = 4
	NetworkConfig_DHTAutoServer NetworkConfig_DHTFlag = 5
)

var NetworkConfig_DHTFlag_name = map[int32]string{
	0: "DHTUndefined",
	1: "DHTDisabled",
	2: "DHTClient",
	3: "DHTServer",
	4: "DHTAuto",
	5: "DHTAutoServer",
}

var NetworkConfig_DHTFlag_value = map[string]int32{
	"DHTUndefined":  0,
	"DHTDisabled":   1,
	"DHTClient":     2,
	"DHTServer":     3,
	"DHTAuto":       4,
	"DHTAutoServer": 5,
}

func (x NetworkConfig_DHTFlag) String() string {
	return proto.EnumName(NetworkConfig_DHTFlag_name, int32(x))
}

func (NetworkConfig_DHTFlag) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_5d43f30c8e455603, []int{14, 2}
}

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_5d43f30c8e455603, []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"`
	NetworkConfig        *NetworkConfig `protobuf:"bytes,4,opt,name=network_config,json=networkConfig,proto3" json:"network_config,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_5d43f30c8e455603, []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 ""
}

func (m *OpenAccount_Request) GetNetworkConfig() *NetworkConfig {
	if m != nil {
		return m.NetworkConfig
	}
	return nil
}

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_5d43f30c8e455603, []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_5d43f30c8e455603, []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_5d43f30c8e455603, []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_5d43f30c8e455603, []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_5d43f30c8e455603, []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_5d43f30c8e455603, []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_5d43f30c8e455603, []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_5d43f30c8e455603, []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_5d43f30c8e455603, []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_5d43f30c8e455603, []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_5d43f30c8e455603, []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_5d43f30c8e455603, []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_5d43f30c8e455603, []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_5d43f30c8e455603, []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_5d43f30c8e455603, []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_5d43f30c8e455603, []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_5d43f30c8e455603, []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_5d43f30c8e455603, []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"`
	NetworkConfig        *NetworkConfig `protobuf:"bytes,6,opt,name=network_config,json=networkConfig,proto3" json:"network_config,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_5d43f30c8e455603, []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 ""
}

func (m *ImportAccount_Request) GetNetworkConfig() *NetworkConfig {
	if m != nil {
		return m.NetworkConfig
	}
	return nil
}

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_5d43f30c8e455603, []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 ImportAccountWithProgress struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

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

func (m *ImportAccountWithProgress) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ImportAccountWithProgress.Merge(m, src)
}

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

func (m *ImportAccountWithProgress) XXX_DiscardUnknown() {
	xxx_messageInfo_ImportAccountWithProgress.DiscardUnknown(m)
}

var xxx_messageInfo_ImportAccountWithProgress proto.InternalMessageInfo

type ImportAccountWithProgress_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"`
	NetworkConfig        *NetworkConfig `protobuf:"bytes,6,opt,name=network_config,json=networkConfig,proto3" json:"network_config,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

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

func (m *ImportAccountWithProgress_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ImportAccountWithProgress_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 *ImportAccountWithProgress_Request) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ImportAccountWithProgress_Request.Merge(m, src)
}

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

func (m *ImportAccountWithProgress_Request) XXX_DiscardUnknown() {
	xxx_messageInfo_ImportAccountWithProgress_Request.DiscardUnknown(m)
}

var xxx_messageInfo_ImportAccountWithProgress_Request proto.InternalMessageInfo

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

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

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

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

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

func (m *ImportAccountWithProgress_Request) GetNetworkConfig() *NetworkConfig {
	if m != nil {
		return m.NetworkConfig
	}
	return nil
}

type ImportAccountWithProgress_Reply struct {
	Progress             *protocoltypes.Progress `protobuf:"bytes,1,opt,name=progress,proto3" json:"progress,omitempty"`
	AccountMetadata      *AccountMetadata        `protobuf:"bytes,2,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 *ImportAccountWithProgress_Reply) Reset()         { *m = ImportAccountWithProgress_Reply{} }
func (m *ImportAccountWithProgress_Reply) String() string { return proto.CompactTextString(m) }
func (*ImportAccountWithProgress_Reply) ProtoMessage()    {}
func (*ImportAccountWithProgress_Reply) Descriptor() ([]byte, []int) {
	return fileDescriptor_5d43f30c8e455603, []int{8, 1}
}

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

func (m *ImportAccountWithProgress_Reply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ImportAccountWithProgress_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 *ImportAccountWithProgress_Reply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ImportAccountWithProgress_Reply.Merge(m, src)
}

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

func (m *ImportAccountWithProgress_Reply) XXX_DiscardUnknown() {
	xxx_messageInfo_ImportAccountWithProgress_Reply.DiscardUnknown(m)
}

var xxx_messageInfo_ImportAccountWithProgress_Reply proto.InternalMessageInfo

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

func (m *ImportAccountWithProgress_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_5d43f30c8e455603, []int{9}
}

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"`
	NetworkConfig        *NetworkConfig `protobuf:"bytes,5,opt,name=network_config,json=networkConfig,proto3" json:"network_config,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_5d43f30c8e455603, []int{9, 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 ""
}

func (m *CreateAccount_Request) GetNetworkConfig() *NetworkConfig {
	if m != nil {
		return m.NetworkConfig
	}
	return nil
}

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_5d43f30c8e455603, []int{9, 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_5d43f30c8e455603, []int{10}
}

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_5d43f30c8e455603, []int{10, 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_5d43f30c8e455603, []int{10, 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_5d43f30c8e455603, []int{11}
}

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_5d43f30c8e455603, []int{11, 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_5d43f30c8e455603, []int{11, 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_5d43f30c8e455603, []int{11, 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_5d43f30c8e455603, []int{12}
}

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_5d43f30c8e455603, []int{12, 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_5d43f30c8e455603, []int{12, 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_5d43f30c8e455603, []int{12, 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 ""
}

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

func (m *GetUsername) Reset()         { *m = GetUsername{} }
func (m *GetUsername) String() string { return proto.CompactTextString(m) }
func (*GetUsername) ProtoMessage()    {}
func (*GetUsername) Descriptor() ([]byte, []int) {
	return fileDescriptor_5d43f30c8e455603, []int{13}
}

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

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

func (m *GetUsername) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetUsername.Merge(m, src)
}

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

func (m *GetUsername) XXX_DiscardUnknown() {
	xxx_messageInfo_GetUsername.DiscardUnknown(m)
}

var xxx_messageInfo_GetUsername proto.InternalMessageInfo

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

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

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

func (m *GetUsername_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetUsername_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 *GetUsername_Request) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetUsername_Request.Merge(m, src)
}

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

func (m *GetUsername_Request) XXX_DiscardUnknown() {
	xxx_messageInfo_GetUsername_Request.DiscardUnknown(m)
}

var xxx_messageInfo_GetUsername_Request proto.InternalMessageInfo

type GetUsername_Reply struct {
	Username             string   `protobuf:"bytes,1,opt,name=username,proto3" json:"username,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

func (m *GetUsername_Reply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetUsername_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 *GetUsername_Reply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetUsername_Reply.Merge(m, src)
}

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

func (m *GetUsername_Reply) XXX_DiscardUnknown() {
	xxx_messageInfo_GetUsername_Reply.DiscardUnknown(m)
}

var xxx_messageInfo_GetUsername_Reply proto.InternalMessageInfo

func (m *GetUsername_Reply) GetUsername() string {
	if m != nil {
		return m.Username
	}
	return ""
}

type NetworkConfig struct {
	Bootstrap                  []string              `protobuf:"bytes,1,rep,name=bootstrap,proto3" json:"bootstrap,omitempty"`
	Rendezvous                 []string              `protobuf:"bytes,2,rep,name=rendezvous,proto3" json:"rendezvous,omitempty"`
	StaticRelay                []string              `protobuf:"bytes,3,rep,name=static_relay,json=staticRelay,proto3" json:"static_relay,omitempty"`
	DHT                        NetworkConfig_DHTFlag `protobuf:"varint,4,opt,name=dht,proto3,enum=berty.account.v1.NetworkConfig_DHTFlag" json:"dht,omitempty"`
	BluetoothLE                NetworkConfig_Flag    `protobuf:"varint,5,opt,name=bluetooth_le,json=bluetoothLe,proto3,enum=berty.account.v1.NetworkConfig_Flag" json:"bluetooth_le,omitempty"`
	AppleMultipeerConnectivity NetworkConfig_Flag    `protobuf:"varint,6,opt,name=apple_multipeer_connectivity,json=appleMultipeerConnectivity,proto3,enum=berty.account.v1.NetworkConfig_Flag" json:"apple_multipeer_connectivity,omitempty"`
	AndroidNearby              NetworkConfig_Flag    `protobuf:"varint,7,opt,name=android_nearby,json=androidNearby,proto3,enum=berty.account.v1.NetworkConfig_Flag" json:"android_nearby,omitempty"`
	Tor                        NetworkConfig_TorFlag `protobuf:"varint,8,opt,name=tor,proto3,enum=berty.account.v1.NetworkConfig_TorFlag" json:"tor,omitempty"`
	MDNS                       NetworkConfig_Flag    `protobuf:"varint,9,opt,name=mdns,proto3,enum=berty.account.v1.NetworkConfig_Flag" json:"mdns,omitempty"`
	ShowDefaultServices        NetworkConfig_Flag    `protobuf:"varint,10,opt,name=show_default_services,json=showDefaultServices,proto3,enum=berty.account.v1.NetworkConfig_Flag" json:"show_default_services,omitempty"`
	XXX_NoUnkeyedLiteral       struct{}              `json:"-"`
	XXX_unrecognized           []byte                `json:"-"`
	XXX_sizecache              int32                 `json:"-"`
}

func (m *NetworkConfig) Reset()         { *m = NetworkConfig{} }
func (m *NetworkConfig) String() string { return proto.CompactTextString(m) }
func (*NetworkConfig) ProtoMessage()    {}
func (*NetworkConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_5d43f30c8e455603, []int{14}
}

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

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

func (m *NetworkConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NetworkConfig.Merge(m, src)
}

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

func (m *NetworkConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_NetworkConfig.DiscardUnknown(m)
}

var xxx_messageInfo_NetworkConfig proto.InternalMessageInfo

func (m *NetworkConfig) GetBootstrap() []string {
	if m != nil {
		return m.Bootstrap
	}
	return nil
}

func (m *NetworkConfig) GetRendezvous() []string {
	if m != nil {
		return m.Rendezvous
	}
	return nil
}

func (m *NetworkConfig) GetStaticRelay() []string {
	if m != nil {
		return m.StaticRelay
	}
	return nil
}

func (m *NetworkConfig) GetDHT() NetworkConfig_DHTFlag {
	if m != nil {
		return m.DHT
	}
	return NetworkConfig_DHTUndefined
}

func (m *NetworkConfig) GetBluetoothLE() NetworkConfig_Flag {
	if m != nil {
		return m.BluetoothLE
	}
	return NetworkConfig_Undefined
}

func (m *NetworkConfig) GetAppleMultipeerConnectivity() NetworkConfig_Flag {
	if m != nil {
		return m.AppleMultipeerConnectivity
	}
	return NetworkConfig_Undefined
}

func (m *NetworkConfig) GetAndroidNearby() NetworkConfig_Flag {
	if m != nil {
		return m.AndroidNearby
	}
	return NetworkConfig_Undefined
}

func (m *NetworkConfig) GetTor() NetworkConfig_TorFlag {
	if m != nil {
		return m.Tor
	}
	return NetworkConfig_TorUndefined
}

func (m *NetworkConfig) GetMDNS() NetworkConfig_Flag {
	if m != nil {
		return m.MDNS
	}
	return NetworkConfig_Undefined
}

func (m *NetworkConfig) GetShowDefaultServices() NetworkConfig_Flag {
	if m != nil {
		return m.ShowDefaultServices
	}
	return NetworkConfig_Undefined
}

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

func (m *NetworkConfigSet) Reset()         { *m = NetworkConfigSet{} }
func (m *NetworkConfigSet) String() string { return proto.CompactTextString(m) }
func (*NetworkConfigSet) ProtoMessage()    {}
func (*NetworkConfigSet) Descriptor() ([]byte, []int) {
	return fileDescriptor_5d43f30c8e455603, []int{15}
}

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

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

func (m *NetworkConfigSet) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NetworkConfigSet.Merge(m, src)
}

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

func (m *NetworkConfigSet) XXX_DiscardUnknown() {
	xxx_messageInfo_NetworkConfigSet.DiscardUnknown(m)
}

var xxx_messageInfo_NetworkConfigSet proto.InternalMessageInfo

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

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

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

func (m *NetworkConfigSet_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_NetworkConfigSet_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 *NetworkConfigSet_Request) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NetworkConfigSet_Request.Merge(m, src)
}

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

func (m *NetworkConfigSet_Request) XXX_DiscardUnknown() {
	xxx_messageInfo_NetworkConfigSet_Request.DiscardUnknown(m)
}

var xxx_messageInfo_NetworkConfigSet_Request proto.InternalMessageInfo

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

func (m *NetworkConfigSet_Request) GetConfig() *NetworkConfig {
	if m != nil {
		return m.Config
	}
	return nil
}

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

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

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

func (m *NetworkConfigSet_Reply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_NetworkConfigSet_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 *NetworkConfigSet_Reply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NetworkConfigSet_Reply.Merge(m, src)
}

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

func (m *NetworkConfigSet_Reply) XXX_DiscardUnknown() {
	xxx_messageInfo_NetworkConfigSet_Reply.DiscardUnknown(m)
}

var xxx_messageInfo_NetworkConfigSet_Reply proto.InternalMessageInfo

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

func (m *NetworkConfigGet) Reset()         { *m = NetworkConfigGet{} }
func (m *NetworkConfigGet) String() string { return proto.CompactTextString(m) }
func (*NetworkConfigGet) ProtoMessage()    {}
func (*NetworkConfigGet) Descriptor() ([]byte, []int) {
	return fileDescriptor_5d43f30c8e455603, []int{16}
}

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

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

func (m *NetworkConfigGet) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NetworkConfigGet.Merge(m, src)
}

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

func (m *NetworkConfigGet) XXX_DiscardUnknown() {
	xxx_messageInfo_NetworkConfigGet.DiscardUnknown(m)
}

var xxx_messageInfo_NetworkConfigGet proto.InternalMessageInfo

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

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

func (m *NetworkConfigGet_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_NetworkConfigGet_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 *NetworkConfigGet_Request) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NetworkConfigGet_Request.Merge(m, src)
}

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

func (m *NetworkConfigGet_Request) XXX_DiscardUnknown() {
	xxx_messageInfo_NetworkConfigGet_Request.DiscardUnknown(m)
}

var xxx_messageInfo_NetworkConfigGet_Request proto.InternalMessageInfo

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

type NetworkConfigGet_Reply struct {
	DefaultConfig        *NetworkConfig `protobuf:"bytes,1,opt,name=default_config,json=defaultConfig,proto3" json:"default_config,omitempty"`
	CurrentConfig        *NetworkConfig `protobuf:"bytes,2,opt,name=current_config,json=currentConfig,proto3" json:"current_config,omitempty"`
	CustomConfigExists   bool           `protobuf:"varint,3,opt,name=custom_config_exists,json=customConfigExists,proto3" json:"custom_config_exists,omitempty"`
	DefaultBootstrap     []string       `protobuf:"bytes,4,rep,name=default_bootstrap,json=defaultBootstrap,proto3" json:"default_bootstrap,omitempty"`
	DefaultRendezvous    []string       `protobuf:"bytes,5,rep,name=default_rendezvous,json=defaultRendezvous,proto3" json:"default_rendezvous,omitempty"`
	DefaultStaticRelay   []string       `protobuf:"bytes,6,rep,name=default_static_relay,json=defaultStaticRelay,proto3" json:"default_static_relay,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

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

func (m *NetworkConfigGet_Reply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_NetworkConfigGet_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 *NetworkConfigGet_Reply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NetworkConfigGet_Reply.Merge(m, src)
}

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

func (m *NetworkConfigGet_Reply) XXX_DiscardUnknown() {
	xxx_messageInfo_NetworkConfigGet_Reply.DiscardUnknown(m)
}

var xxx_messageInfo_NetworkConfigGet_Reply proto.InternalMessageInfo

func (m *NetworkConfigGet_Reply) GetDefaultConfig() *NetworkConfig {
	if m != nil {
		return m.DefaultConfig
	}
	return nil
}

func (m *NetworkConfigGet_Reply) GetCurrentConfig() *NetworkConfig {
	if m != nil {
		return m.CurrentConfig
	}
	return nil
}

func (m *NetworkConfigGet_Reply) GetCustomConfigExists() bool {
	if m != nil {
		return m.CustomConfigExists
	}
	return false
}

func (m *NetworkConfigGet_Reply) GetDefaultBootstrap() []string {
	if m != nil {
		return m.DefaultBootstrap
	}
	return nil
}

func (m *NetworkConfigGet_Reply) GetDefaultRendezvous() []string {
	if m != nil {
		return m.DefaultRendezvous
	}
	return nil
}

func (m *NetworkConfigGet_Reply) GetDefaultStaticRelay() []string {
	if m != nil {
		return m.DefaultStaticRelay
	}
	return nil
}

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

func (m *NetworkConfigGetPreset) Reset()         { *m = NetworkConfigGetPreset{} }
func (m *NetworkConfigGetPreset) String() string { return proto.CompactTextString(m) }
func (*NetworkConfigGetPreset) ProtoMessage()    {}
func (*NetworkConfigGetPreset) Descriptor() ([]byte, []int) {
	return fileDescriptor_5d43f30c8e455603, []int{17}
}

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

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

func (m *NetworkConfigGetPreset) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NetworkConfigGetPreset.Merge(m, src)
}

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

func (m *NetworkConfigGetPreset) XXX_DiscardUnknown() {
	xxx_messageInfo_NetworkConfigGetPreset.DiscardUnknown(m)
}

var xxx_messageInfo_NetworkConfigGetPreset proto.InternalMessageInfo

type NetworkConfigGetPreset_Request struct {
	Preset                 NetworkConfigPreset `protobuf:"varint,1,opt,name=preset,proto3,enum=berty.account.v1.NetworkConfigPreset" json:"preset,omitempty"`
	HasBluetoothPermission bool                `protobuf:"varint,2,opt,name=has_bluetooth_permission,json=hasBluetoothPermission,proto3" json:"has_bluetooth_permission,omitempty"`
	XXX_NoUnkeyedLiteral   struct{}            `json:"-"`
	XXX_unrecognized       []byte              `json:"-"`
	XXX_sizecache          int32               `json:"-"`
}

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

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

func (m *NetworkConfigGetPreset_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_NetworkConfigGetPreset_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 *NetworkConfigGetPreset_Request) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NetworkConfigGetPreset_Request.Merge(m, src)
}

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

func (m *NetworkConfigGetPreset_Request) XXX_DiscardUnknown() {
	xxx_messageInfo_NetworkConfigGetPreset_Request.DiscardUnknown(m)
}

var xxx_messageInfo_NetworkConfigGetPreset_Request proto.InternalMessageInfo

func (m *NetworkConfigGetPreset_Request) GetPreset() NetworkConfigPreset {
	if m != nil {
		return m.Preset
	}
	return NetworkConfigPreset_NetPresetUndefined
}

func (m *NetworkConfigGetPreset_Request) GetHasBluetoothPermission() bool {
	if m != nil {
		return m.HasBluetoothPermission
	}
	return false
}

type NetworkConfigGetPreset_Reply struct {
	Config               *NetworkConfig `protobuf:"bytes,1,opt,name=config,proto3" json:"config,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

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

func (m *NetworkConfigGetPreset_Reply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_NetworkConfigGetPreset_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 *NetworkConfigGetPreset_Reply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NetworkConfigGetPreset_Reply.Merge(m, src)
}

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

func (m *NetworkConfigGetPreset_Reply) XXX_DiscardUnknown() {
	xxx_messageInfo_NetworkConfigGetPreset_Reply.DiscardUnknown(m)
}

var xxx_messageInfo_NetworkConfigGetPreset_Reply proto.InternalMessageInfo

func (m *NetworkConfigGetPreset_Reply) GetConfig() *NetworkConfig {
	if m != nil {
		return m.Config
	}
	return nil
}

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

func (m *PushReceive) Reset()         { *m = PushReceive{} }
func (m *PushReceive) String() string { return proto.CompactTextString(m) }
func (*PushReceive) ProtoMessage()    {}
func (*PushReceive) Descriptor() ([]byte, []int) {
	return fileDescriptor_5d43f30c8e455603, []int{18}
}

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

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

func (m *PushReceive) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PushReceive.Merge(m, src)
}

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

func (m *PushReceive) XXX_DiscardUnknown() {
	xxx_messageInfo_PushReceive.DiscardUnknown(m)
}

var xxx_messageInfo_PushReceive proto.InternalMessageInfo

type PushReceive_Request struct {
	Payload              string                         `protobuf:"bytes,1,opt,name=payload,proto3" json:"payload,omitempty"`
	TokenType            pushtypes.PushServiceTokenType `protobuf:"varint,2,opt,name=token_type,json=tokenType,proto3,enum=berty.push.v1.PushServiceTokenType" json:"token_type,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                       `json:"-"`
	XXX_unrecognized     []byte                         `json:"-"`
	XXX_sizecache        int32                          `json:"-"`
}

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

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

func (m *PushReceive_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PushReceive_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 *PushReceive_Request) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PushReceive_Request.Merge(m, src)
}

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

func (m *PushReceive_Request) XXX_DiscardUnknown() {
	xxx_messageInfo_PushReceive_Request.DiscardUnknown(m)
}

var xxx_messageInfo_PushReceive_Request proto.InternalMessageInfo

func (m *PushReceive_Request) GetPayload() string {
	if m != nil {
		return m.Payload
	}
	return ""
}

func (m *PushReceive_Request) GetTokenType() pushtypes.PushServiceTokenType {
	if m != nil {
		return m.TokenType
	}
	return pushtypes.PushServiceTokenType_PushTokenUndefined
}

type PushReceive_Reply struct {
	PushData             *pushtypes.DecryptedPush `protobuf:"bytes,1,opt,name=push_data,json=pushData,proto3" json:"push_data,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
	XXX_unrecognized     []byte                   `json:"-"`
	XXX_sizecache        int32                    `json:"-"`
}

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

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

func (m *PushReceive_Reply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PushReceive_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 *PushReceive_Reply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PushReceive_Reply.Merge(m, src)
}

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

func (m *PushReceive_Reply) XXX_DiscardUnknown() {
	xxx_messageInfo_PushReceive_Reply.DiscardUnknown(m)
}

var xxx_messageInfo_PushReceive_Reply proto.InternalMessageInfo

func (m *PushReceive_Reply) GetPushData() *pushtypes.DecryptedPush {
	if m != nil {
		return m.PushData
	}
	return nil
}

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

func (m *PushPlatformTokenRegister) Reset()         { *m = PushPlatformTokenRegister{} }
func (m *PushPlatformTokenRegister) String() string { return proto.CompactTextString(m) }
func (*PushPlatformTokenRegister) ProtoMessage()    {}
func (*PushPlatformTokenRegister) Descriptor() ([]byte, []int) {
	return fileDescriptor_5d43f30c8e455603, []int{19}
}

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

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

func (m *PushPlatformTokenRegister) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PushPlatformTokenRegister.Merge(m, src)
}

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

func (m *PushPlatformTokenRegister) XXX_DiscardUnknown() {
	xxx_messageInfo_PushPlatformTokenRegister.DiscardUnknown(m)
}

var xxx_messageInfo_PushPlatformTokenRegister proto.InternalMessageInfo

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

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

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

func (m *PushPlatformTokenRegister_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PushPlatformTokenRegister_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 *PushPlatformTokenRegister_Request) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PushPlatformTokenRegister_Request.Merge(m, src)
}

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

func (m *PushPlatformTokenRegister_Request) XXX_DiscardUnknown() {
	xxx_messageInfo_PushPlatformTokenRegister_Request.DiscardUnknown(m)
}

var xxx_messageInfo_PushPlatformTokenRegister_Request proto.InternalMessageInfo

func (m *PushPlatformTokenRegister_Request) GetReceiver() *protocoltypes.PushServiceReceiver {
	if m != nil {
		return m.Receiver
	}
	return nil
}

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

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

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

func (m *PushPlatformTokenRegister_Reply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PushPlatformTokenRegister_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 *PushPlatformTokenRegister_Reply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PushPlatformTokenRegister_Reply.Merge(m, src)
}

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

func (m *PushPlatformTokenRegister_Reply) XXX_DiscardUnknown() {
	xxx_messageInfo_PushPlatformTokenRegister_Reply.DiscardUnknown(m)
}

var xxx_messageInfo_PushPlatformTokenRegister_Reply proto.InternalMessageInfo

func init() {
	proto.RegisterEnum("berty.account.v1.NetworkConfigPreset", NetworkConfigPreset_name, NetworkConfigPreset_value)
	proto.RegisterEnum("berty.account.v1.NetworkConfig_Flag", NetworkConfig_Flag_name, NetworkConfig_Flag_value)
	proto.RegisterEnum("berty.account.v1.NetworkConfig_TorFlag", NetworkConfig_TorFlag_name, NetworkConfig_TorFlag_value)
	proto.RegisterEnum("berty.account.v1.NetworkConfig_DHTFlag", NetworkConfig_DHTFlag_name, NetworkConfig_DHTFlag_value)
	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((*ImportAccountWithProgress)(nil), "berty.account.v1.ImportAccountWithProgress")
	proto.RegisterType((*ImportAccountWithProgress_Request)(nil), "berty.account.v1.ImportAccountWithProgress.Request")
	proto.RegisterType((*ImportAccountWithProgress_Reply)(nil), "berty.account.v1.ImportAccountWithProgress.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")
	proto.RegisterType((*GetUsername)(nil), "berty.account.v1.GetUsername")
	proto.RegisterType((*GetUsername_Request)(nil), "berty.account.v1.GetUsername.Request")
	proto.RegisterType((*GetUsername_Reply)(nil), "berty.account.v1.GetUsername.Reply")
	proto.RegisterType((*NetworkConfig)(nil), "berty.account.v1.NetworkConfig")
	proto.RegisterType((*NetworkConfigSet)(nil), "berty.account.v1.NetworkConfigSet")
	proto.RegisterType((*NetworkConfigSet_Request)(nil), "berty.account.v1.NetworkConfigSet.Request")
	proto.RegisterType((*NetworkConfigSet_Reply)(nil), "berty.account.v1.NetworkConfigSet.Reply")
	proto.RegisterType((*NetworkConfigGet)(nil), "berty.account.v1.NetworkConfigGet")
	proto.RegisterType((*NetworkConfigGet_Request)(nil), "berty.account.v1.NetworkConfigGet.Request")
	proto.RegisterType((*NetworkConfigGet_Reply)(nil), "berty.account.v1.NetworkConfigGet.Reply")
	proto.RegisterType((*NetworkConfigGetPreset)(nil), "berty.account.v1.NetworkConfigGetPreset")
	proto.RegisterType((*NetworkConfigGetPreset_Request)(nil), "berty.account.v1.NetworkConfigGetPreset.Request")
	proto.RegisterType((*NetworkConfigGetPreset_Reply)(nil), "berty.account.v1.NetworkConfigGetPreset.Reply")
	proto.RegisterType((*PushReceive)(nil), "berty.account.v1.PushReceive")
	proto.RegisterType((*PushReceive_Request)(nil), "berty.account.v1.PushReceive.Request")
	proto.RegisterType((*PushReceive_Reply)(nil), "berty.account.v1.PushReceive.Reply")
	proto.RegisterType((*PushPlatformTokenRegister)(nil), "berty.account.v1.PushPlatformTokenRegister")
	proto.RegisterType((*PushPlatformTokenRegister_Request)(nil), "berty.account.v1.PushPlatformTokenRegister.Request")
	proto.RegisterType((*PushPlatformTokenRegister_Reply)(nil), "berty.account.v1.PushPlatformTokenRegister.Reply")
}

func init() { proto.RegisterFile("accounttypes.proto", fileDescriptor_5d43f30c8e455603) }

var fileDescriptor_5d43f30c8e455603 = []byte{
	// 2012 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x59, 0xcd, 0x6f, 0x23, 0x49,
	0x15, 0xa7, 0x6d, 0x27, 0xb6, 0x9f, 0x63, 0xc7, 0x5b, 0x1b, 0x82, 0xb7, 0x19, 0x26, 0x59, 0xcf,
	0xcc, 0x12, 0xf6, 0xc3, 0xc9, 0x78, 0x0e, 0xc3, 0x1e, 0x46, 0x62, 0x1c, 0xe7, 0x63, 0xb4, 0x99,
	0x4c, 0xe8, 0x78, 0xc4, 0x82, 0x90, 0x5a, 0x1d, 0xf7, 0x8b, 0xdd, 0xa4, 0xdd, 0xdd, 0x54, 0x97,
	0xb3, 0x78, 0x2e, 0x48, 0x8b, 0xb8, 0x44, 0x02, 0x71, 0x5a, 0x71, 0x99, 0x23, 0xe2, 0x04, 0x17,
	0x6e, 0xfb, 0x07, 0x00, 0x37, 0x90, 0x38, 0x70, 0x62, 0x40, 0xb9, 0xf0, 0x4f, 0x20, 0x84, 0xaa,
	0xba, 0xba, 0xdd, 0xed, 0x38, 0xfe, 0x98, 0xd9, 0x41, 0x48, 0x9c, 0x5c, 0xf5, 0xea, 0xbd, 0xdf,
	0xfb, 0xaa, 0x7a, 0xf5, 0xaa, 0x0d, 0xc4, 0x68, 0xb7, 0xdd, 0xbe, 0xc3, 0xd8, 0xc0, 0x43, 0xbf,
	0xe6, 0x51, 0x97, 0xb9, 0xa4, 0x7c, 0x82, 0x94, 0x0d, 0x6a, 0x72, 0xa5, 0x76, 0x7e, 0x57, 0x5d,
	0xe9, 0xb8, 0x1d, 0x57, 0x2c, 0x6e, 0xf2, 0x51, 0xc0, 0xa7, 0x2e, 0x7b, 0x7d, 0xbf, 0x1b, 0x13,
	0x54, 0xdf, 0x14, 0x3f, 0x6d, 0xd7, 0x8e, 0x13, 0x57, 0x7a, 0xe8, 0xfb, 0xe8, 0x74, 0x38, 0xe6,
	0x90, 0x5a, 0x44, 0x4a, 0xdb, 0xae, 0x89, 0xc1, 0xb4, 0xfa, 0x17, 0x05, 0x0a, 0x4f, 0x3c, 0x74,
	0x1e, 0x06, 0x3a, 0xd5, 0xcf, 0x15, 0xc8, 0x6a, 0xf8, 0xc3, 0x3e, 0xfa, 0x8c, 0x10, 0xc8, 0x18,
	0xb4, 0xe3, 0x57, 0x94, 0xf5, 0xf4, 0x46, 0x5e, 0x13, 0x63, 0xf2, 0x3e, 0x80, 0x34, 0x4f, 0xb7,
	0xcc, 0x4a, 0x6a, 0x5d, 0xd9, 0xc8, 0x37, 0x8a, 0x97, 0x2f, 0xd6, 0xf2, 0x12, 0xe0, 0x51, 0x53,
	0xcb, 0x4b, 0x86, 0x47, 0x26, 0xb9, 0x03, 0x25, 0xdb, 0xed, 0x74, 0x90, 0xea, 0xa7, 0x96, 0xcd,
	0x90, 0xfa, 0x95, 0x34, 0x97, 0xd0, 0x8a, 0x01, 0x75, 0x37, 0x20, 0x92, 0x5d, 0x28, 0x39, 0xc8,
	0x3e, 0x71, 0xe9, 0x99, 0xde, 0x76, 0x9d, 0x53, 0xab, 0x53, 0xc9, 0xac, 0x2b, 0x1b, 0x85, 0xfa,
	0x5a, 0x6d, 0x34, 0x20, 0xb5, 0xc3, 0x80, 0x6f, 0x5b, 0xb0, 0x69, 0x45, 0x27, 0x3e, 0x55, 0xb3,
	0xb0, 0xa0, 0xa1, 0x67, 0x0f, 0xaa, 0x7f, 0x52, 0xe0, 0x2b, 0x31, 0xaf, 0xbe, 0x63, 0xb1, 0xee,
	0x11, 0x75, 0x3b, 0x14, 0x7d, 0x5f, 0xa5, 0xff, 0x7d, 0x07, 0xd5, 0x6f, 0x49, 0xc3, 0xc8, 0x7d,
	0xc8, 0x79, 0xd2, 0x90, 0x8a, 0x22, 0x7c, 0xfc, 0xaa, 0xf4, 0x31, 0xcc, 0x20, 0x77, 0x32, 0xb4,
	0x55, 0x8b, 0x98, 0xab, 0x55, 0x58, 0xda, 0xb6, 0x5d, 0x1f, 0xc3, 0x3c, 0xe5, 0x23, 0x2f, 0x86,
	0x5e, 0x77, 0xa0, 0x12, 0xe7, 0x49, 0x78, 0x1d, 0xe3, 0x7f, 0x75, 0x63, 0xfe, 0xa5, 0xc0, 0xb2,
	0x54, 0xf2, 0x18, 0x99, 0x61, 0x1a, 0xcc, 0x18, 0x89, 0x9b, 0x32, 0x25, 0x6e, 0x04, 0x32, 0x8e,
	0xd1, 0xc3, 0x20, 0xbe, 0x9a, 0x18, 0x0b, 0x84, 0x73, 0x83, 0x19, 0x54, 0x6f, 0x5b, 0x66, 0x10,
	0x47, 0x89, 0x20, 0xa8, 0xdb, 0x02, 0x21, 0x18, 0x5a, 0x26, 0xf9, 0x1a, 0x80, 0xd7, 0x3f, 0xb1,
	0xad, 0xb6, 0x7e, 0x86, 0x03, 0xb1, 0x5f, 0xf2, 0x5a, 0x3e, 0xa0, 0x7c, 0x84, 0x03, 0xb2, 0x06,
	0x05, 0xdb, 0xf0, 0x99, 0xee, 0x7a, 0xe8, 0xa0, 0x59, 0x59, 0x58, 0x57, 0x36, 0xd2, 0x1a, 0x70,
	0xd2, 0x13, 0x41, 0x21, 0xb7, 0xa0, 0xd8, 0xa6, 0x68, 0x30, 0xcb, 0x75, 0x74, 0xd3, 0x60, 0x58,
	0x59, 0x14, 0x2c, 0x4b, 0x21, 0xb1, 0x69, 0x30, 0x24, 0x2b, 0xb0, 0x80, 0x94, 0xba, 0xb4, 0x92,
	0x15, 0xf8, 0xc1, 0xa4, 0x6a, 0xc0, 0xd2, 0x81, 0xe5, 0x33, 0xe9, 0x58, 0x22, 0xb6, 0xbb, 0x61,
	0x6c, 0x1f, 0x40, 0x4e, 0x7a, 0x1b, 0x6c, 0xaf, 0x42, 0xfd, 0xed, 0xab, 0x9b, 0x79, 0x24, 0x86,
	0x5a, 0x24, 0x52, 0xfd, 0x36, 0x14, 0x9b, 0x68, 0x23, 0x8b, 0xf2, 0x7d, 0x7f, 0xb8, 0x6b, 0xe7,
	0x8a, 0xf4, 0x70, 0x77, 0xfc, 0x33, 0x05, 0xc5, 0x47, 0x3d, 0xcf, 0xa5, 0xa1, 0xe1, 0xea, 0xbf,
	0x95, 0x97, 0x04, 0x25, 0x6f, 0xc3, 0x52, 0xc8, 0x1d, 0x4b, 0x63, 0x41, 0xd2, 0x0e, 0x79, 0x36,
	0xd7, 0xa0, 0x70, 0x62, 0xb4, 0xcf, 0xfa, 0x9e, 0xee, 0x19, 0xac, 0x2b, 0x8f, 0x05, 0x04, 0xa4,
	0x23, 0x83, 0x75, 0xa3, 0xc3, 0x97, 0x89, 0x1d, 0xbe, 0xab, 0xc7, 0x69, 0x61, 0xb6, 0x7a, 0xb1,
	0xf8, 0x52, 0xf5, 0xe2, 0x69, 0x98, 0xad, 0x03, 0x28, 0x87, 0xfe, 0xf4, 0x64, 0x32, 0xe4, 0x89,
	0x98, 0x21, 0x6b, 0xcb, 0x46, 0x92, 0x50, 0xfd, 0x4d, 0x1a, 0xde, 0x4a, 0x44, 0x3a, 0x71, 0x12,
	0xff, 0xef, 0xa3, 0xfe, 0x73, 0xe5, 0x55, 0x0b, 0xd0, 0xd8, 0x7c, 0xa5, 0x5e, 0x3a, 0x5f, 0xbf,
	0x4f, 0x41, 0x71, 0x9b, 0x1f, 0xfb, 0xe8, 0xb4, 0xfd, 0xed, 0x75, 0xe6, 0x28, 0x4c, 0x41, 0x7a,
	0x62, 0x0a, 0x32, 0xb3, 0xa5, 0x60, 0xe1, 0x7f, 0x69, 0xe3, 0xff, 0x22, 0x05, 0xc5, 0xa7, 0x9e,
	0x19, 0x0b, 0xe4, 0xaf, 0x5f, 0x67, 0x20, 0xbf, 0xc8, 0x0b, 0xe3, 0x75, 0x85, 0xe4, 0xb7, 0x0a,
	0xac, 0xec, 0x21, 0xdb, 0xd3, 0x8e, 0xb6, 0xf9, 0x9d, 0x81, 0x0e, 0xd2, 0x87, 0xa6, 0x49, 0x13,
	0x97, 0xc6, 0x85, 0x32, 0xd4, 0x9d, 0x45, 0x87, 0x51, 0x0b, 0xc3, 0x4b, 0xa3, 0x7e, 0x55, 0xe5,
	0x38, 0xb4, 0x9a, 0x10, 0xaf, 0xed, 0x38, 0x8c, 0x0e, 0xb4, 0x10, 0x42, 0xbd, 0x07, 0x0b, 0x82,
	0xc2, 0xaf, 0x31, 0x71, 0xa0, 0x82, 0xa0, 0x6b, 0xc1, 0x84, 0x53, 0x7b, 0x86, 0x69, 0x52, 0x19,
	0xda, 0x60, 0x52, 0xfd, 0x5d, 0x0a, 0x0a, 0x07, 0x6e, 0xe7, 0xd4, 0xb2, 0x91, 0xab, 0x88, 0xdb,
	0xf9, 0xcb, 0x54, 0x68, 0xe7, 0xce, 0xa8, 0x9d, 0xef, 0x5d, 0xb5, 0x33, 0x06, 0x22, 0xcd, 0x93,
	0x94, 0xa1, 0x81, 0x7f, 0x50, 0x20, 0x2b, 0x89, 0x5f, 0x40, 0xff, 0x40, 0x20, 0x13, 0x2b, 0x7a,
	0x62, 0xcc, 0x69, 0xbe, 0xf5, 0x0c, 0x45, 0xba, 0xd3, 0x9a, 0x18, 0x73, 0xda, 0x99, 0xe5, 0x98,
	0xb2, 0xc8, 0x89, 0x31, 0xa7, 0x31, 0xab, 0x17, 0x36, 0x01, 0x62, 0x4c, 0x56, 0x61, 0xd1, 0x36,
	0x18, 0xfa, 0x4c, 0xdc, 0xfe, 0x39, 0x4d, 0xce, 0x38, 0x2f, 0x52, 0xea, 0x57, 0x72, 0x81, 0x3c,
	0x1f, 0x57, 0x1f, 0x40, 0x61, 0x0f, 0xd9, 0x53, 0x1f, 0x29, 0x37, 0x25, 0x1e, 0xb4, 0x5b, 0x61,
	0xcc, 0x54, 0xc8, 0xf5, 0xe5, 0xba, 0xcc, 0x43, 0x34, 0xaf, 0x5e, 0x64, 0xa1, 0x98, 0x38, 0xb0,
	0xe4, 0x06, 0xe4, 0x4f, 0x5c, 0x97, 0xf9, 0x8c, 0x1a, 0x9e, 0xec, 0x4f, 0x87, 0x04, 0x72, 0x13,
	0x80, 0xa2, 0x63, 0xe2, 0xb3, 0x73, 0xb7, 0xef, 0x57, 0x52, 0x62, 0x39, 0x46, 0xe1, 0x87, 0xc7,
	0x67, 0x06, 0xb3, 0xda, 0x3a, 0x45, 0xdb, 0x18, 0xc8, 0x52, 0x53, 0x08, 0x68, 0x1a, 0x27, 0x91,
	0x06, 0xa4, 0xcd, 0x2e, 0x13, 0x81, 0x29, 0xd5, 0xbf, 0x3e, 0xa5, 0x7e, 0xd4, 0x9a, 0xfb, 0xad,
	0x5d, 0xdb, 0xe8, 0x34, 0xb2, 0x97, 0x2f, 0xd6, 0xd2, 0xcd, 0xfd, 0x96, 0xc6, 0x85, 0xc9, 0xc7,
	0xb0, 0x74, 0x62, 0xf7, 0x91, 0xb9, 0x2e, 0xeb, 0xea, 0x36, 0x8a, 0x88, 0x96, 0xea, 0xb7, 0xa7,
	0x81, 0x09, 0xa4, 0xe5, 0xcb, 0x17, 0x6b, 0x85, 0x46, 0x28, 0x7d, 0xb0, 0xa3, 0x15, 0x22, 0xa8,
	0x03, 0x24, 0xa7, 0x70, 0xc3, 0xf0, 0x3c, 0x1b, 0xf5, 0x5e, 0xdf, 0x66, 0x96, 0x87, 0x48, 0x79,
	0xc1, 0x73, 0xb0, 0xcd, 0xac, 0x73, 0x8b, 0x0d, 0x44, 0x9e, 0x66, 0xd4, 0xa4, 0xa9, 0x02, 0xe9,
	0x71, 0x08, 0xb4, 0x1d, 0xc3, 0x21, 0x1f, 0x41, 0xc9, 0x70, 0x4c, 0xea, 0x5a, 0xa6, 0xee, 0xa0,
	0x41, 0x4f, 0x06, 0x22, 0xd7, 0xb3, 0x22, 0x17, 0xa5, 0xec, 0xa1, 0x10, 0x25, 0x1f, 0x42, 0x9a,
	0xb9, 0x54, 0xec, 0x8b, 0x19, 0x42, 0xda, 0x72, 0xa9, 0x00, 0xe1, 0x32, 0xa4, 0x01, 0x99, 0x9e,
	0xe9, 0xf8, 0x95, 0xfc, 0x1c, 0x11, 0xcc, 0x5d, 0xbe, 0x58, 0xcb, 0x3c, 0x6e, 0x1e, 0x1e, 0x6b,
	0x42, 0x96, 0x7c, 0x0c, 0x5f, 0xf6, 0xbb, 0xee, 0x27, 0xba, 0x89, 0xa7, 0x46, 0xdf, 0x66, 0xba,
	0x8f, 0xf4, 0xdc, 0x6a, 0xa3, 0x5f, 0x81, 0x39, 0x5c, 0x7a, 0x93, 0x43, 0x34, 0x03, 0x84, 0x63,
	0x09, 0x50, 0xdd, 0x82, 0x0c, 0x5f, 0x24, 0x45, 0xc8, 0x3f, 0x75, 0x4c, 0x3c, 0xb5, 0x1c, 0x34,
	0xcb, 0x5f, 0x22, 0x4b, 0x90, 0x6b, 0x5a, 0xbe, 0x71, 0x62, 0xa3, 0x59, 0x56, 0x48, 0x01, 0xb2,
	0x3b, 0x4e, 0x30, 0x49, 0x55, 0x0f, 0x21, 0x2b, 0xfd, 0x23, 0x65, 0x58, 0x6a, 0xb9, 0x34, 0x2e,
	0xb7, 0x0c, 0x85, 0x96, 0x4b, 0x63, 0xa2, 0x01, 0xe1, 0x89, 0xc7, 0xfb, 0x6e, 0xc3, 0x2e, 0xa7,
	0x24, 0x81, 0x1f, 0x21, 0x8b, 0xa2, 0x59, 0x4e, 0x57, 0x7f, 0x00, 0x59, 0xb9, 0x05, 0x39, 0x5e,
	0x73, 0xbf, 0x35, 0x82, 0xd7, 0xdc, 0x6f, 0xc5, 0xf0, 0x8a, 0x90, 0x6f, 0xee, 0xb7, 0xb6, 0x6d,
	0x0b, 0x1d, 0x56, 0x4e, 0xc9, 0x29, 0xf7, 0x06, 0x69, 0x39, 0xcd, 0x0d, 0x6d, 0xee, 0xb7, 0x1e,
	0xf6, 0x99, 0x5b, 0xce, 0x90, 0x37, 0xa0, 0x28, 0x27, 0x72, 0x7d, 0xa1, 0xfa, 0x33, 0x05, 0xca,
	0x89, 0xc8, 0x1c, 0x23, 0x53, 0xbd, 0x97, 0xbd, 0xc7, 0xee, 0xc3, 0xa2, 0xbc, 0xaa, 0x53, 0xb3,
	0x5d, 0xd5, 0x92, 0x7d, 0xd8, 0xb8, 0xff, 0x2a, 0x3d, 0x62, 0xcf, 0x1e, 0xbe, 0xc2, 0x7b, 0xe0,
	0xaf, 0x51, 0x11, 0xdf, 0x85, 0x52, 0xb8, 0x55, 0xa4, 0x85, 0xca, 0x8c, 0xcd, 0x84, 0x14, 0x93,
	0xa5, 0x6a, 0x17, 0x4a, 0xed, 0x3e, 0xa5, 0xe8, 0x44, 0x38, 0x33, 0x7a, 0x5a, 0x94, 0x62, 0x12,
	0x67, 0x0b, 0x56, 0xda, 0x7d, 0x9f, 0xb9, 0x3d, 0x09, 0xa3, 0xe3, 0x8f, 0x2c, 0x9f, 0x05, 0x2f,
	0xea, 0x9c, 0x46, 0x82, 0xb5, 0x80, 0x77, 0x47, 0xac, 0x90, 0xf7, 0xe0, 0x8d, 0xd0, 0x83, 0x61,
	0xb1, 0x0c, 0x3a, 0xdb, 0xb2, 0x5c, 0x68, 0x44, 0x35, 0xf3, 0x03, 0x20, 0x21, 0x73, 0xac, 0x76,
	0x2e, 0x08, 0xee, 0x10, 0x46, 0x1b, 0x96, 0xd0, 0x2d, 0x58, 0x89, 0x0e, 0x52, 0xbc, 0x94, 0x2e,
	0x0a, 0x81, 0x10, 0xea, 0x78, 0x58, 0x51, 0xab, 0x7f, 0x57, 0x60, 0x75, 0x34, 0x4f, 0x47, 0x14,
	0x7d, 0x64, 0xea, 0xa7, 0xb1, 0x36, 0xe8, 0x01, 0x2c, 0x7a, 0x82, 0x2a, 0xc2, 0x5d, 0xaa, 0xdf,
	0x99, 0x12, 0xa6, 0x00, 0x42, 0x93, 0x42, 0xe4, 0x9b, 0x50, 0xe9, 0x1a, 0xbe, 0x3e, 0xac, 0xbb,
	0x1e, 0xd2, 0x9e, 0xe5, 0xfb, 0x96, 0xeb, 0x88, 0xb8, 0xe7, 0xb4, 0xd5, 0xae, 0xe1, 0x47, 0x85,
	0xf5, 0x28, 0x5a, 0x8d, 0xbf, 0xfb, 0x17, 0xe7, 0x4b, 0xb8, 0x64, 0xaf, 0x7e, 0xae, 0x40, 0xe1,
	0xa8, 0xef, 0x77, 0x35, 0x6c, 0xa3, 0x75, 0x8e, 0x6a, 0x67, 0xe8, 0x55, 0x05, 0xb2, 0x9e, 0x31,
	0xb0, 0x5d, 0x43, 0xee, 0x40, 0x2d, 0x9c, 0x92, 0x06, 0x00, 0x73, 0xcf, 0xd0, 0xd1, 0xd9, 0xc0,
	0x0b, 0x2e, 0xec, 0x52, 0xfd, 0x56, 0xd8, 0xe6, 0xf7, 0xfd, 0xae, 0x68, 0xf1, 0xfb, 0x7e, 0x57,
	0x56, 0x9b, 0x16, 0xe7, 0x6d, 0x0d, 0x3c, 0xd4, 0xf2, 0x2c, 0x1c, 0xaa, 0x8d, 0xd0, 0xf4, 0x0f,
	0x21, 0xcf, 0x65, 0xf4, 0x58, 0x57, 0x76, 0x63, 0x04, 0xab, 0x89, 0x6d, 0x3a, 0xf0, 0x18, 0x9a,
	0xc2, 0xd2, 0x1c, 0x27, 0x37, 0x79, 0x27, 0xe6, 0xc3, 0x5b, 0x9c, 0x72, 0x64, 0x1b, 0xec, 0xd4,
	0xa5, 0x3d, 0xa1, 0x47, 0xc3, 0x0e, 0x6f, 0xa3, 0xa8, 0xfa, 0x78, 0xe8, 0x49, 0x03, 0x72, 0x34,
	0xf0, 0x8f, 0x4a, 0x0d, 0xef, 0x8c, 0x7b, 0x94, 0x0c, 0x2d, 0x96, 0xd1, 0xa0, 0x5a, 0x24, 0x17,
	0x9d, 0xdd, 0x77, 0x3f, 0x53, 0xe0, 0xcd, 0x31, 0xd9, 0x24, 0x77, 0x12, 0x95, 0x54, 0x5d, 0xbd,
	0x78, 0xbe, 0x4e, 0x0e, 0xc3, 0xed, 0x12, 0xad, 0x90, 0x6f, 0x40, 0xe1, 0x08, 0x29, 0x37, 0xd7,
	0x70, 0xda, 0x58, 0x56, 0xd4, 0xca, 0xc5, 0xf3, 0xf5, 0x95, 0x88, 0x31, 0xb6, 0x46, 0x3e, 0x80,
	0xe2, 0x6e, 0xdf, 0xb6, 0x1f, 0x3a, 0xae, 0x33, 0xe8, 0x59, 0x6c, 0x50, 0x4e, 0xa9, 0xea, 0xc5,
	0xf3, 0xf5, 0xd5, 0x88, 0x39, 0xb1, 0x5a, 0xff, 0x6c, 0x19, 0x4a, 0xb2, 0x3e, 0x48, 0x37, 0xc8,
	0x77, 0x13, 0x5f, 0x02, 0xc9, 0x98, 0x7d, 0x19, 0x5b, 0xae, 0x45, 0xfd, 0xcd, 0x34, 0x36, 0x9e,
	0xb6, 0x1f, 0x5f, 0xfb, 0x39, 0x8e, 0xdc, 0x9d, 0x28, 0x1f, 0x67, 0x8d, 0x54, 0x6e, 0xce, 0x23,
	0xe2, 0xd9, 0x83, 0x2d, 0x85, 0x7c, 0x3f, 0xf9, 0xf9, 0x8c, 0xbc, 0x73, 0x15, 0x22, 0xbe, 0x1e,
	0xa9, 0xba, 0x3d, 0x95, 0x8f, 0xbb, 0xf7, 0xa9, 0x72, 0xfd, 0x97, 0x37, 0x52, 0x9f, 0x0c, 0x31,
	0xd6, 0xc3, 0xad, 0xb9, 0x64, 0x22, 0x17, 0xe3, 0x5f, 0xa5, 0xc6, 0xb9, 0x18, 0x5f, 0x9f, 0xe4,
	0xe2, 0x08, 0x1f, 0x77, 0x51, 0x1f, 0xf9, 0x20, 0x45, 0xc6, 0xf4, 0x37, 0x09, 0x86, 0x08, 0xff,
	0xce, 0x74, 0x46, 0xa9, 0x20, 0xf1, 0xcd, 0x64, 0x9c, 0x82, 0x04, 0xc3, 0x24, 0x05, 0xa3, 0x8c,
	0x5c, 0xc1, 0x4f, 0x95, 0x09, 0x5f, 0x65, 0xc8, 0xbd, 0x29, 0x20, 0x63, 0xd3, 0x74, 0x77, 0x3e,
	0xa1, 0x20, 0x4f, 0xfa, 0xc8, 0xc7, 0x86, 0x71, 0x8e, 0x26, 0x18, 0x26, 0x39, 0x3a, 0xca, 0x28,
	0x23, 0x99, 0x78, 0x84, 0x8f, 0x53, 0x90, 0x60, 0x98, 0xa4, 0x60, 0x94, 0x91, 0x2b, 0x60, 0xe3,
	0x9f, 0xb4, 0xa4, 0x36, 0xf3, 0x63, 0x35, 0x50, 0xf7, 0xfe, 0x3c, 0x8f, 0x5b, 0x5e, 0x9e, 0x62,
	0x4f, 0xca, 0x71, 0xe5, 0x29, 0xf9, 0xe2, 0xbc, 0xb6, 0x3c, 0x5d, 0x79, 0x98, 0x72, 0xe8, 0xd8,
	0xeb, 0x6d, 0x1c, 0x74, 0x6c, 0x79, 0x12, 0x74, 0x92, 0x8d, 0x43, 0x77, 0xaf, 0xf6, 0x92, 0xe4,
	0xdd, 0x29, 0xf7, 0xed, 0x31, 0x0e, 0xed, 0xdf, 0x98, 0x89, 0x77, 0x9c, 0xa6, 0xbd, 0x19, 0x34,
	0xed, 0xcd, 0xa1, 0x69, 0x2f, 0xd2, 0xf4, 0xec, 0xba, 0x3e, 0x87, 0x6c, 0x4d, 0xc7, 0x08, 0x38,
	0x23, 0xad, 0xb5, 0x39, 0x24, 0x64, 0xaa, 0x62, 0x1d, 0xc8, 0xb8, 0x54, 0xc5, 0x96, 0x27, 0xa5,
	0x2a, 0xc9, 0xc6, 0xa1, 0x7f, 0xa2, 0x4c, 0xe8, 0x10, 0xc6, 0x15, 0x88, 0x6b, 0x99, 0x27, 0x15,
	0x88, 0x49, 0x42, 0x9e, 0x3d, 0x68, 0xd4, 0xff, 0x78, 0x79, 0x53, 0xf9, 0xf3, 0xe5, 0x4d, 0xe5,
	0x1f, 0x97, 0x37, 0x95, 0xef, 0xdd, 0x0e, 0xe4, 0x19, 0xb6, 0xbb, 0x9b, 0x62, 0xb8, 0xd9, 0x71,
	0x37, 0xbd, 0xb3, 0xce, 0x66, 0xfc, 0xdf, 0xc3, 0x93, 0x45, 0xd1, 0x99, 0xdc, 0xfb, 0x4f, 0x00,
	0x00, 0x00, 0xff, 0xff, 0x14, 0x0f, 0x74, 0x8b, 0x54, 0x1c, 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)
	// ImportAccountWithProgress is similar to ImportAccount, but also streams the progress.
	ImportAccountWithProgress(ctx context.Context, in *ImportAccountWithProgress_Request, opts ...grpc.CallOption) (AccountService_ImportAccountWithProgressClient, 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)
	// GetUsername returns the name of the device/user using Android/iOS/universal API
	GetUsername(ctx context.Context, in *GetUsername_Request, opts ...grpc.CallOption) (*GetUsername_Reply, error)
	// NetworkConfigSet
	NetworkConfigSet(ctx context.Context, in *NetworkConfigSet_Request, opts ...grpc.CallOption) (*NetworkConfigSet_Reply, error)
	// NetworkConfigGet
	NetworkConfigGet(ctx context.Context, in *NetworkConfigGet_Request, opts ...grpc.CallOption) (*NetworkConfigGet_Reply, error)
	// NetworkConfigGetPreset
	NetworkConfigGetPreset(ctx context.Context, in *NetworkConfigGetPreset_Request, opts ...grpc.CallOption) (*NetworkConfigGetPreset_Reply, error)
	// PushReceive
	PushReceive(ctx context.Context, in *PushReceive_Request, opts ...grpc.CallOption) (*PushReceive_Reply, error)
	// PushPlatformTokenRegister
	PushPlatformTokenRegister(ctx context.Context, in *PushPlatformTokenRegister_Request, opts ...grpc.CallOption) (*PushPlatformTokenRegister_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) ImportAccountWithProgress(ctx context.Context, in *ImportAccountWithProgress_Request, opts ...grpc.CallOption) (AccountService_ImportAccountWithProgressClient, error) {
	stream, err := c.cc.NewStream(ctx, &_AccountService_serviceDesc.Streams[2], "/berty.account.v1.AccountService/ImportAccountWithProgress", opts...)
	if err != nil {
		return nil, err
	}
	x := &accountServiceImportAccountWithProgressClient{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_ImportAccountWithProgressClient interface {
	Recv() (*ImportAccountWithProgress_Reply, error)
	grpc.ClientStream
}

type accountServiceImportAccountWithProgressClient struct {
	grpc.ClientStream
}

func (x *accountServiceImportAccountWithProgressClient) Recv() (*ImportAccountWithProgress_Reply, error) {
	m := new(ImportAccountWithProgress_Reply)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, 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
}

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

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

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

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

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

func (c *accountServiceClient) PushPlatformTokenRegister(ctx context.Context, in *PushPlatformTokenRegister_Request, opts ...grpc.CallOption) (*PushPlatformTokenRegister_Reply, error) {
	out := new(PushPlatformTokenRegister_Reply)
	err := c.cc.Invoke(ctx, "/berty.account.v1.AccountService/PushPlatformTokenRegister", 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)
	// ImportAccountWithProgress is similar to ImportAccount, but also streams the progress.
	ImportAccountWithProgress(*ImportAccountWithProgress_Request, AccountService_ImportAccountWithProgressServer) 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)
	// GetUsername returns the name of the device/user using Android/iOS/universal API
	GetUsername(context.Context, *GetUsername_Request) (*GetUsername_Reply, error)
	// NetworkConfigSet
	NetworkConfigSet(context.Context, *NetworkConfigSet_Request) (*NetworkConfigSet_Reply, error)
	// NetworkConfigGet
	NetworkConfigGet(context.Context, *NetworkConfigGet_Request) (*NetworkConfigGet_Reply, error)
	// NetworkConfigGetPreset
	NetworkConfigGetPreset(context.Context, *NetworkConfigGetPreset_Request) (*NetworkConfigGetPreset_Reply, error)
	// PushReceive
	PushReceive(context.Context, *PushReceive_Request) (*PushReceive_Reply, error)
	// PushPlatformTokenRegister
	PushPlatformTokenRegister(context.Context, *PushPlatformTokenRegister_Request) (*PushPlatformTokenRegister_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) ImportAccountWithProgress(req *ImportAccountWithProgress_Request, srv AccountService_ImportAccountWithProgressServer) error {
	return status.Errorf(codes.Unimplemented, "method ImportAccountWithProgress 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 (*UnimplementedAccountServiceServer) GetUsername(ctx context.Context, req *GetUsername_Request) (*GetUsername_Reply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetUsername not implemented")
}

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

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

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

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

func (*UnimplementedAccountServiceServer) PushPlatformTokenRegister(ctx context.Context, req *PushPlatformTokenRegister_Request) (*PushPlatformTokenRegister_Reply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PushPlatformTokenRegister 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_ImportAccountWithProgress_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ImportAccountWithProgress_Request)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AccountServiceServer).ImportAccountWithProgress(m, &accountServiceImportAccountWithProgressServer{stream})
}

type AccountService_ImportAccountWithProgressServer interface {
	Send(*ImportAccountWithProgress_Reply) error
	grpc.ServerStream
}

type accountServiceImportAccountWithProgressServer struct {
	grpc.ServerStream
}

func (x *accountServiceImportAccountWithProgressServer) Send(m *ImportAccountWithProgress_Reply) error {
	return x.ServerStream.SendMsg(m)
}

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

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

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

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

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

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

func _AccountService_PushPlatformTokenRegister_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PushPlatformTokenRegister_Request)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AccountServiceServer).PushPlatformTokenRegister(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/berty.account.v1.AccountService/PushPlatformTokenRegister",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AccountServiceServer).PushPlatformTokenRegister(ctx, req.(*PushPlatformTokenRegister_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,
		},
		{
			MethodName: "GetUsername",
			Handler:    _AccountService_GetUsername_Handler,
		},
		{
			MethodName: "NetworkConfigSet",
			Handler:    _AccountService_NetworkConfigSet_Handler,
		},
		{
			MethodName: "NetworkConfigGet",
			Handler:    _AccountService_NetworkConfigGet_Handler,
		},
		{
			MethodName: "NetworkConfigGetPreset",
			Handler:    _AccountService_NetworkConfigGetPreset_Handler,
		},
		{
			MethodName: "PushReceive",
			Handler:    _AccountService_PushReceive_Handler,
		},
		{
			MethodName: "PushPlatformTokenRegister",
			Handler:    _AccountService_PushPlatformTokenRegister_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "OpenAccountWithProgress",
			Handler:       _AccountService_OpenAccountWithProgress_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "CloseAccountWithProgress",
			Handler:       _AccountService_CloseAccountWithProgress_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ImportAccountWithProgress",
			Handler:       _AccountService_ImportAccountWithProgress_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "accounttypes.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 m.NetworkConfig != nil {
		{
			size, err := m.NetworkConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintAccounttypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.LoggerFilters) > 0 {
		i -= len(m.LoggerFilters)
		copy(dAtA[i:], m.LoggerFilters)
		i = encodeVarintAccounttypes(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 = encodeVarintAccounttypes(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 = encodeVarintAccounttypes(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 = encodeVarintAccounttypes(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 = encodeVarintAccounttypes(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 = encodeVarintAccounttypes(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 = encodeVarintAccounttypes(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 = encodeVarintAccounttypes(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 = encodeVarintAccounttypes(dAtA, i, uint64(len(m.Error)))
		i--
		dAtA[i] = 0x3a
	}
	if m.CreationDate != 0 {
		i = encodeVarintAccounttypes(dAtA, i, uint64(m.CreationDate))
		i--
		dAtA[i] = 0x30
	}
	if m.LastOpened != 0 {
		i = encodeVarintAccounttypes(dAtA, i, uint64(m.LastOpened))
		i--
		dAtA[i] = 0x28
	}
	if len(m.PublicKey) > 0 {
		i -= len(m.PublicKey)
		copy(dAtA[i:], m.PublicKey)
		i = encodeVarintAccounttypes(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 = encodeVarintAccounttypes(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 = encodeVarintAccounttypes(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 = encodeVarintAccounttypes(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 = encodeVarintAccounttypes(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 = encodeVarintAccounttypes(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 m.NetworkConfig != nil {
		{
			size, err := m.NetworkConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintAccounttypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if len(m.LoggerFilters) > 0 {
		i -= len(m.LoggerFilters)
		copy(dAtA[i:], m.LoggerFilters)
		i = encodeVarintAccounttypes(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 = encodeVarintAccounttypes(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 = encodeVarintAccounttypes(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 = encodeVarintAccounttypes(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 = encodeVarintAccounttypes(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 = encodeVarintAccounttypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *ImportAccountWithProgress_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 m.NetworkConfig != nil {
		{
			size, err := m.NetworkConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintAccounttypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if len(m.LoggerFilters) > 0 {
		i -= len(m.LoggerFilters)
		copy(dAtA[i:], m.LoggerFilters)
		i = encodeVarintAccounttypes(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 = encodeVarintAccounttypes(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 = encodeVarintAccounttypes(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 = encodeVarintAccounttypes(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 = encodeVarintAccounttypes(dAtA, i, uint64(len(m.AccountID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *ImportAccountWithProgress_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 = encodeVarintAccounttypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Progress != nil {
		{
			size, err := m.Progress.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintAccounttypes(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 m.NetworkConfig != nil {
		{
			size, err := m.NetworkConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintAccounttypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if len(m.LoggerFilters) > 0 {
		i -= len(m.LoggerFilters)
		copy(dAtA[i:], m.LoggerFilters)
		i = encodeVarintAccounttypes(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 = encodeVarintAccounttypes(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 = encodeVarintAccounttypes(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 = encodeVarintAccounttypes(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 = encodeVarintAccounttypes(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 = encodeVarintAccounttypes(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 = encodeVarintAccounttypes(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 = encodeVarintAccounttypes(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 = encodeVarintAccounttypes(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 = encodeVarintAccounttypes(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 = encodeVarintAccounttypes(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 = encodeVarintAccounttypes(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 = encodeVarintAccounttypes(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 = encodeVarintAccounttypes(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 = encodeVarintAccounttypes(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 = encodeVarintAccounttypes(dAtA, i, uint64(m.Time))
		i--
		dAtA[i] = 0x30
	}
	if len(m.Kind) > 0 {
		i -= len(m.Kind)
		copy(dAtA[i:], m.Kind)
		i = encodeVarintAccounttypes(dAtA, i, uint64(len(m.Kind)))
		i--
		dAtA[i] = 0x2a
	}
	if m.Size_ != 0 {
		i = encodeVarintAccounttypes(dAtA, i, uint64(m.Size_))
		i--
		dAtA[i] = 0x20
	}
	if len(m.Path) > 0 {
		i -= len(m.Path)
		copy(dAtA[i:], m.Path)
		i = encodeVarintAccounttypes(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 = encodeVarintAccounttypes(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 = encodeVarintAccounttypes(dAtA, i, uint64(len(m.AccountID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

func (m *GetUsername_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.Username) > 0 {
		i -= len(m.Username)
		copy(dAtA[i:], m.Username)
		i = encodeVarintAccounttypes(dAtA, i, uint64(len(m.Username)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *NetworkConfig) 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.ShowDefaultServices != 0 {
		i = encodeVarintAccounttypes(dAtA, i, uint64(m.ShowDefaultServices))
		i--
		dAtA[i] = 0x50
	}
	if m.MDNS != 0 {
		i = encodeVarintAccounttypes(dAtA, i, uint64(m.MDNS))
		i--
		dAtA[i] = 0x48
	}
	if m.Tor != 0 {
		i = encodeVarintAccounttypes(dAtA, i, uint64(m.Tor))
		i--
		dAtA[i] = 0x40
	}
	if m.AndroidNearby != 0 {
		i = encodeVarintAccounttypes(dAtA, i, uint64(m.AndroidNearby))
		i--
		dAtA[i] = 0x38
	}
	if m.AppleMultipeerConnectivity != 0 {
		i = encodeVarintAccounttypes(dAtA, i, uint64(m.AppleMultipeerConnectivity))
		i--
		dAtA[i] = 0x30
	}
	if m.BluetoothLE != 0 {
		i = encodeVarintAccounttypes(dAtA, i, uint64(m.BluetoothLE))
		i--
		dAtA[i] = 0x28
	}
	if m.DHT != 0 {
		i = encodeVarintAccounttypes(dAtA, i, uint64(m.DHT))
		i--
		dAtA[i] = 0x20
	}
	if len(m.StaticRelay) > 0 {
		for iNdEx := len(m.StaticRelay) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.StaticRelay[iNdEx])
			copy(dAtA[i:], m.StaticRelay[iNdEx])
			i = encodeVarintAccounttypes(dAtA, i, uint64(len(m.StaticRelay[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Rendezvous) > 0 {
		for iNdEx := len(m.Rendezvous) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Rendezvous[iNdEx])
			copy(dAtA[i:], m.Rendezvous[iNdEx])
			i = encodeVarintAccounttypes(dAtA, i, uint64(len(m.Rendezvous[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Bootstrap) > 0 {
		for iNdEx := len(m.Bootstrap) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Bootstrap[iNdEx])
			copy(dAtA[i:], m.Bootstrap[iNdEx])
			i = encodeVarintAccounttypes(dAtA, i, uint64(len(m.Bootstrap[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *NetworkConfigSet_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 m.Config != nil {
		{
			size, err := m.Config.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintAccounttypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.AccountID) > 0 {
		i -= len(m.AccountID)
		copy(dAtA[i:], m.AccountID)
		i = encodeVarintAccounttypes(dAtA, i, uint64(len(m.AccountID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

func (m *NetworkConfigGet_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.DefaultStaticRelay) > 0 {
		for iNdEx := len(m.DefaultStaticRelay) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.DefaultStaticRelay[iNdEx])
			copy(dAtA[i:], m.DefaultStaticRelay[iNdEx])
			i = encodeVarintAccounttypes(dAtA, i, uint64(len(m.DefaultStaticRelay[iNdEx])))
			i--
			dAtA[i] = 0x32
		}
	}
	if len(m.DefaultRendezvous) > 0 {
		for iNdEx := len(m.DefaultRendezvous) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.DefaultRendezvous[iNdEx])
			copy(dAtA[i:], m.DefaultRendezvous[iNdEx])
			i = encodeVarintAccounttypes(dAtA, i, uint64(len(m.DefaultRendezvous[iNdEx])))
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.DefaultBootstrap) > 0 {
		for iNdEx := len(m.DefaultBootstrap) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.DefaultBootstrap[iNdEx])
			copy(dAtA[i:], m.DefaultBootstrap[iNdEx])
			i = encodeVarintAccounttypes(dAtA, i, uint64(len(m.DefaultBootstrap[iNdEx])))
			i--
			dAtA[i] = 0x22
		}
	}
	if m.CustomConfigExists {
		i--
		if m.CustomConfigExists {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if m.CurrentConfig != nil {
		{
			size, err := m.CurrentConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintAccounttypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.DefaultConfig != nil {
		{
			size, err := m.DefaultConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintAccounttypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *NetworkConfigGetPreset_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 m.HasBluetoothPermission {
		i--
		if m.HasBluetoothPermission {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if m.Preset != 0 {
		i = encodeVarintAccounttypes(dAtA, i, uint64(m.Preset))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *NetworkConfigGetPreset_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.Config != nil {
		{
			size, err := m.Config.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintAccounttypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *PushReceive_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 m.TokenType != 0 {
		i = encodeVarintAccounttypes(dAtA, i, uint64(m.TokenType))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Payload) > 0 {
		i -= len(m.Payload)
		copy(dAtA[i:], m.Payload)
		i = encodeVarintAccounttypes(dAtA, i, uint64(len(m.Payload)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *PushReceive_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.PushData != nil {
		{
			size, err := m.PushData.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintAccounttypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *PushPlatformTokenRegister_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 m.Receiver != nil {
		{
			size, err := m.Receiver.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintAccounttypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *PushPlatformTokenRegister_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 encodeVarintAccounttypes(dAtA []byte, offset int, v uint64) int {
	offset -= sovAccounttypes(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 + sovAccounttypes(uint64(l))
		}
	}
	l = len(m.AccountID)
	if l > 0 {
		n += 1 + l + sovAccounttypes(uint64(l))
	}
	l = len(m.LoggerFilters)
	if l > 0 {
		n += 1 + l + sovAccounttypes(uint64(l))
	}
	if m.NetworkConfig != nil {
		l = m.NetworkConfig.Size()
		n += 1 + l + sovAccounttypes(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 + sovAccounttypes(uint64(l))
		}
	}
	l = len(m.AccountID)
	if l > 0 {
		n += 1 + l + sovAccounttypes(uint64(l))
	}
	l = len(m.LoggerFilters)
	if l > 0 {
		n += 1 + l + sovAccounttypes(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 + sovAccounttypes(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 + sovAccounttypes(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 + sovAccounttypes(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovAccounttypes(uint64(l))
	}
	l = len(m.AvatarCID)
	if l > 0 {
		n += 1 + l + sovAccounttypes(uint64(l))
	}
	l = len(m.PublicKey)
	if l > 0 {
		n += 1 + l + sovAccounttypes(uint64(l))
	}
	if m.LastOpened != 0 {
		n += 1 + sovAccounttypes(uint64(m.LastOpened))
	}
	if m.CreationDate != 0 {
		n += 1 + sovAccounttypes(uint64(m.CreationDate))
	}
	l = len(m.Error)
	if l > 0 {
		n += 1 + l + sovAccounttypes(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 + sovAccounttypes(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 + sovAccounttypes(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 + sovAccounttypes(uint64(l))
	}
	l = len(m.AccountName)
	if l > 0 {
		n += 1 + l + sovAccounttypes(uint64(l))
	}
	l = len(m.BackupPath)
	if l > 0 {
		n += 1 + l + sovAccounttypes(uint64(l))
	}
	if len(m.Args) > 0 {
		for _, s := range m.Args {
			l = len(s)
			n += 1 + l + sovAccounttypes(uint64(l))
		}
	}
	l = len(m.LoggerFilters)
	if l > 0 {
		n += 1 + l + sovAccounttypes(uint64(l))
	}
	if m.NetworkConfig != nil {
		l = m.NetworkConfig.Size()
		n += 1 + l + sovAccounttypes(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 + sovAccounttypes(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ImportAccountWithProgress) 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 *ImportAccountWithProgress_Request) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.AccountID)
	if l > 0 {
		n += 1 + l + sovAccounttypes(uint64(l))
	}
	l = len(m.AccountName)
	if l > 0 {
		n += 1 + l + sovAccounttypes(uint64(l))
	}
	l = len(m.BackupPath)
	if l > 0 {
		n += 1 + l + sovAccounttypes(uint64(l))
	}
	if len(m.Args) > 0 {
		for _, s := range m.Args {
			l = len(s)
			n += 1 + l + sovAccounttypes(uint64(l))
		}
	}
	l = len(m.LoggerFilters)
	if l > 0 {
		n += 1 + l + sovAccounttypes(uint64(l))
	}
	if m.NetworkConfig != nil {
		l = m.NetworkConfig.Size()
		n += 1 + l + sovAccounttypes(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ImportAccountWithProgress_Reply) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Progress != nil {
		l = m.Progress.Size()
		n += 1 + l + sovAccounttypes(uint64(l))
	}
	if m.AccountMetadata != nil {
		l = m.AccountMetadata.Size()
		n += 1 + l + sovAccounttypes(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 + sovAccounttypes(uint64(l))
	}
	l = len(m.AccountName)
	if l > 0 {
		n += 1 + l + sovAccounttypes(uint64(l))
	}
	if len(m.Args) > 0 {
		for _, s := range m.Args {
			l = len(s)
			n += 1 + l + sovAccounttypes(uint64(l))
		}
	}
	l = len(m.LoggerFilters)
	if l > 0 {
		n += 1 + l + sovAccounttypes(uint64(l))
	}
	if m.NetworkConfig != nil {
		l = m.NetworkConfig.Size()
		n += 1 + l + sovAccounttypes(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 + sovAccounttypes(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 + sovAccounttypes(uint64(l))
	}
	l = len(m.AccountName)
	if l > 0 {
		n += 1 + l + sovAccounttypes(uint64(l))
	}
	l = len(m.AvatarCID)
	if l > 0 {
		n += 1 + l + sovAccounttypes(uint64(l))
	}
	l = len(m.PublicKey)
	if l > 0 {
		n += 1 + l + sovAccounttypes(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 + sovAccounttypes(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 + sovAccounttypes(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 + sovAccounttypes(uint64(l))
	}
	l = len(m.Maddr)
	if l > 0 {
		n += 1 + l + sovAccounttypes(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 + sovAccounttypes(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 + sovAccounttypes(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovAccounttypes(uint64(l))
	}
	l = len(m.Path)
	if l > 0 {
		n += 1 + l + sovAccounttypes(uint64(l))
	}
	if m.Size_ != 0 {
		n += 1 + sovAccounttypes(uint64(m.Size_))
	}
	l = len(m.Kind)
	if l > 0 {
		n += 1 + l + sovAccounttypes(uint64(l))
	}
	if m.Time != 0 {
		n += 1 + sovAccounttypes(uint64(m.Time))
	}
	if m.Latest {
		n += 2
	}
	l = len(m.Errs)
	if l > 0 {
		n += 1 + l + sovAccounttypes(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GetUsername) 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 *GetUsername_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 *GetUsername_Reply) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Username)
	if l > 0 {
		n += 1 + l + sovAccounttypes(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *NetworkConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Bootstrap) > 0 {
		for _, s := range m.Bootstrap {
			l = len(s)
			n += 1 + l + sovAccounttypes(uint64(l))
		}
	}
	if len(m.Rendezvous) > 0 {
		for _, s := range m.Rendezvous {
			l = len(s)
			n += 1 + l + sovAccounttypes(uint64(l))
		}
	}
	if len(m.StaticRelay) > 0 {
		for _, s := range m.StaticRelay {
			l = len(s)
			n += 1 + l + sovAccounttypes(uint64(l))
		}
	}
	if m.DHT != 0 {
		n += 1 + sovAccounttypes(uint64(m.DHT))
	}
	if m.BluetoothLE != 0 {
		n += 1 + sovAccounttypes(uint64(m.BluetoothLE))
	}
	if m.AppleMultipeerConnectivity != 0 {
		n += 1 + sovAccounttypes(uint64(m.AppleMultipeerConnectivity))
	}
	if m.AndroidNearby != 0 {
		n += 1 + sovAccounttypes(uint64(m.AndroidNearby))
	}
	if m.Tor != 0 {
		n += 1 + sovAccounttypes(uint64(m.Tor))
	}
	if m.MDNS != 0 {
		n += 1 + sovAccounttypes(uint64(m.MDNS))
	}
	if m.ShowDefaultServices != 0 {
		n += 1 + sovAccounttypes(uint64(m.ShowDefaultServices))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *NetworkConfigSet) 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 *NetworkConfigSet_Request) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.AccountID)
	if l > 0 {
		n += 1 + l + sovAccounttypes(uint64(l))
	}
	if m.Config != nil {
		l = m.Config.Size()
		n += 1 + l + sovAccounttypes(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *NetworkConfigSet_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 *NetworkConfigGet) 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 *NetworkConfigGet_Request) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.AccountID)
	if l > 0 {
		n += 1 + l + sovAccounttypes(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *NetworkConfigGet_Reply) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.DefaultConfig != nil {
		l = m.DefaultConfig.Size()
		n += 1 + l + sovAccounttypes(uint64(l))
	}
	if m.CurrentConfig != nil {
		l = m.CurrentConfig.Size()
		n += 1 + l + sovAccounttypes(uint64(l))
	}
	if m.CustomConfigExists {
		n += 2
	}
	if len(m.DefaultBootstrap) > 0 {
		for _, s := range m.DefaultBootstrap {
			l = len(s)
			n += 1 + l + sovAccounttypes(uint64(l))
		}
	}
	if len(m.DefaultRendezvous) > 0 {
		for _, s := range m.DefaultRendezvous {
			l = len(s)
			n += 1 + l + sovAccounttypes(uint64(l))
		}
	}
	if len(m.DefaultStaticRelay) > 0 {
		for _, s := range m.DefaultStaticRelay {
			l = len(s)
			n += 1 + l + sovAccounttypes(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *NetworkConfigGetPreset) 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 *NetworkConfigGetPreset_Request) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Preset != 0 {
		n += 1 + sovAccounttypes(uint64(m.Preset))
	}
	if m.HasBluetoothPermission {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *PushReceive) 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 *PushReceive_Request) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Payload)
	if l > 0 {
		n += 1 + l + sovAccounttypes(uint64(l))
	}
	if m.TokenType != 0 {
		n += 1 + sovAccounttypes(uint64(m.TokenType))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *PushPlatformTokenRegister) 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 *PushPlatformTokenRegister_Request) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Receiver != nil {
		l = m.Receiver.Size()
		n += 1 + l + sovAccounttypes(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *PushPlatformTokenRegister_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 sovAccounttypes(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}

func sozAccounttypes(x uint64) (n int) {
	return sovAccounttypes(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 ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: 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 ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LoggerFilters = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NetworkConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NetworkConfig == nil {
				m.NetworkConfig = &NetworkConfig{}
			}
			if err := m.NetworkConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: 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 ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LoggerFilters = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: 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 := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: 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 := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
				}
				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 ErrIntOverflowAccounttypes
				}
				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 ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Error = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: 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 := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: 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 ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AccountID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: 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 ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LoggerFilters = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NetworkConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NetworkConfig == nil {
				m.NetworkConfig = &NetworkConfig{}
			}
			if err := m.NetworkConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 *ImportAccountWithProgress) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ImportAccountWithProgress: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ImportAccountWithProgress: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 *ImportAccountWithProgress_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 ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: 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 ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LoggerFilters = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NetworkConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NetworkConfig == nil {
				m.NetworkConfig = &NetworkConfig{}
			}
			if err := m.NetworkConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 *ImportAccountWithProgress_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 ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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
		case 2:
			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 ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: 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 ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LoggerFilters = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NetworkConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NetworkConfig == nil {
				m.NetworkConfig = &NetworkConfig{}
			}
			if err := m.NetworkConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: 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 ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PublicKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: 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 := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Maddr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: 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 := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
				}
				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 ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 ErrIntOverflowAccounttypes
				}
				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 ErrIntOverflowAccounttypes
				}
				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 ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Errs = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 *GetUsername) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetUsername: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetUsername: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 *GetUsername_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 ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: 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 := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 *GetUsername_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 ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 Username", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Username = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 *NetworkConfig) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: NetworkConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NetworkConfig: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Bootstrap", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Bootstrap = append(m.Bootstrap, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Rendezvous", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Rendezvous = append(m.Rendezvous, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StaticRelay", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StaticRelay = append(m.StaticRelay, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DHT", wireType)
			}
			m.DHT = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DHT |= NetworkConfig_DHTFlag(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BluetoothLE", wireType)
			}
			m.BluetoothLE = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BluetoothLE |= NetworkConfig_Flag(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AppleMultipeerConnectivity", wireType)
			}
			m.AppleMultipeerConnectivity = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AppleMultipeerConnectivity |= NetworkConfig_Flag(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AndroidNearby", wireType)
			}
			m.AndroidNearby = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AndroidNearby |= NetworkConfig_Flag(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tor", wireType)
			}
			m.Tor = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Tor |= NetworkConfig_TorFlag(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MDNS", wireType)
			}
			m.MDNS = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MDNS |= NetworkConfig_Flag(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ShowDefaultServices", wireType)
			}
			m.ShowDefaultServices = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ShowDefaultServices |= NetworkConfig_Flag(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 *NetworkConfigSet) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: NetworkConfigSet: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NetworkConfigSet: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 *NetworkConfigSet_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 ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: 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 ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 Config", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Config == nil {
				m.Config = &NetworkConfig{}
			}
			if err := m.Config.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 *NetworkConfigSet_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 ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 *NetworkConfigGet) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: NetworkConfigGet: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NetworkConfigGet: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 *NetworkConfigGet_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 ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: 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 ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AccountID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 *NetworkConfigGet_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 ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 DefaultConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DefaultConfig == nil {
				m.DefaultConfig = &NetworkConfig{}
			}
			if err := m.DefaultConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CurrentConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CurrentConfig == nil {
				m.CurrentConfig = &NetworkConfig{}
			}
			if err := m.CurrentConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CustomConfigExists", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.CustomConfigExists = bool(v != 0)
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DefaultBootstrap", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DefaultBootstrap = append(m.DefaultBootstrap, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DefaultRendezvous", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DefaultRendezvous = append(m.DefaultRendezvous, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DefaultStaticRelay", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DefaultStaticRelay = append(m.DefaultStaticRelay, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 *NetworkConfigGetPreset) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: NetworkConfigGetPreset: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NetworkConfigGetPreset: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 *NetworkConfigGetPreset_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 ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Preset", wireType)
			}
			m.Preset = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Preset |= NetworkConfigPreset(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field HasBluetoothPermission", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.HasBluetoothPermission = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 *NetworkConfigGetPreset_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 ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 Config", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Config == nil {
				m.Config = &NetworkConfig{}
			}
			if err := m.Config.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 *PushReceive) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: PushReceive: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PushReceive: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 *PushReceive_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 ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Payload", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Payload = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TokenType", wireType)
			}
			m.TokenType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TokenType |= pushtypes.PushServiceTokenType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 *PushReceive_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 ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 PushData", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.PushData == nil {
				m.PushData = &pushtypes.DecryptedPush{}
			}
			if err := m.PushData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 *PushPlatformTokenRegister) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: PushPlatformTokenRegister: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PushPlatformTokenRegister: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 *PushPlatformTokenRegister_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 ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Receiver", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Receiver == nil {
				m.Receiver = &protocoltypes.PushServiceReceiver{}
			}
			if err := m.Receiver.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 *PushPlatformTokenRegister_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 ErrIntOverflowAccounttypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 := skipAccounttypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAccounttypes
			}
			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 skipAccounttypes(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, ErrIntOverflowAccounttypes
			}
			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, ErrIntOverflowAccounttypes
				}
				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, ErrIntOverflowAccounttypes
				}
				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, ErrInvalidLengthAccounttypes
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupAccounttypes
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthAccounttypes
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthAccounttypes        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowAccounttypes          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupAccounttypes = fmt.Errorf("proto: unexpected end of group")
)