accounttypes.pb.go

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

package accounttypes

import (
	protocoltypes "berty.tech/weshnet/pkg/protocoltypes"
	pushtypes "berty.tech/weshnet/pkg/pushtypes"
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	io "io"
	math "math"
	math_bits "math/bits"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

type 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_5aee2114ef53980b, []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_5aee2114ef53980b, []int{19, 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_5aee2114ef53980b, []int{19, 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_5aee2114ef53980b, []int{19, 2}
}

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

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

var xxx_messageInfo_AppStoragePut proto.InternalMessageInfo

type AppStoragePut_Request struct {
	Key                  string   `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Value                []byte   `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	Global               bool     `protobuf:"varint,3,opt,name=global,proto3" json:"global,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *AppStoragePut_Request) Reset()         { *m = AppStoragePut_Request{} }
func (m *AppStoragePut_Request) String() string { return proto.CompactTextString(m) }
func (*AppStoragePut_Request) ProtoMessage()    {}
func (*AppStoragePut_Request) Descriptor() ([]byte, []int) {
	return fileDescriptor_5aee2114ef53980b, []int{0, 0}
}
func (m *AppStoragePut_Request) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AppStoragePut_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AppStoragePut_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 *AppStoragePut_Request) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AppStoragePut_Request.Merge(m, src)
}
func (m *AppStoragePut_Request) XXX_Size() int {
	return m.Size()
}
func (m *AppStoragePut_Request) XXX_DiscardUnknown() {
	xxx_messageInfo_AppStoragePut_Request.DiscardUnknown(m)
}

var xxx_messageInfo_AppStoragePut_Request proto.InternalMessageInfo

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

func (m *AppStoragePut_Request) GetValue() []byte {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *AppStoragePut_Request) GetGlobal() bool {
	if m != nil {
		return m.Global
	}
	return false
}

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

func (m *AppStoragePut_Reply) Reset()         { *m = AppStoragePut_Reply{} }
func (m *AppStoragePut_Reply) String() string { return proto.CompactTextString(m) }
func (*AppStoragePut_Reply) ProtoMessage()    {}
func (*AppStoragePut_Reply) Descriptor() ([]byte, []int) {
	return fileDescriptor_5aee2114ef53980b, []int{0, 1}
}
func (m *AppStoragePut_Reply) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AppStoragePut_Reply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AppStoragePut_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 *AppStoragePut_Reply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AppStoragePut_Reply.Merge(m, src)
}
func (m *AppStoragePut_Reply) XXX_Size() int {
	return m.Size()
}
func (m *AppStoragePut_Reply) XXX_DiscardUnknown() {
	xxx_messageInfo_AppStoragePut_Reply.DiscardUnknown(m)
}

var xxx_messageInfo_AppStoragePut_Reply proto.InternalMessageInfo

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

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

var xxx_messageInfo_AppStorageGet proto.InternalMessageInfo

type AppStorageGet_Request struct {
	Key                  string   `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Global               bool     `protobuf:"varint,2,opt,name=global,proto3" json:"global,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *AppStorageGet_Request) Reset()         { *m = AppStorageGet_Request{} }
func (m *AppStorageGet_Request) String() string { return proto.CompactTextString(m) }
func (*AppStorageGet_Request) ProtoMessage()    {}
func (*AppStorageGet_Request) Descriptor() ([]byte, []int) {
	return fileDescriptor_5aee2114ef53980b, []int{1, 0}
}
func (m *AppStorageGet_Request) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AppStorageGet_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AppStorageGet_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 *AppStorageGet_Request) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AppStorageGet_Request.Merge(m, src)
}
func (m *AppStorageGet_Request) XXX_Size() int {
	return m.Size()
}
func (m *AppStorageGet_Request) XXX_DiscardUnknown() {
	xxx_messageInfo_AppStorageGet_Request.DiscardUnknown(m)
}

var xxx_messageInfo_AppStorageGet_Request proto.InternalMessageInfo

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

func (m *AppStorageGet_Request) GetGlobal() bool {
	if m != nil {
		return m.Global
	}
	return false
}

type AppStorageGet_Reply struct {
	Value                []byte   `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *AppStorageGet_Reply) Reset()         { *m = AppStorageGet_Reply{} }
func (m *AppStorageGet_Reply) String() string { return proto.CompactTextString(m) }
func (*AppStorageGet_Reply) ProtoMessage()    {}
func (*AppStorageGet_Reply) Descriptor() ([]byte, []int) {
	return fileDescriptor_5aee2114ef53980b, []int{1, 1}
}
func (m *AppStorageGet_Reply) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AppStorageGet_Reply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AppStorageGet_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 *AppStorageGet_Reply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AppStorageGet_Reply.Merge(m, src)
}
func (m *AppStorageGet_Reply) XXX_Size() int {
	return m.Size()
}
func (m *AppStorageGet_Reply) XXX_DiscardUnknown() {
	xxx_messageInfo_AppStorageGet_Reply.DiscardUnknown(m)
}

var xxx_messageInfo_AppStorageGet_Reply proto.InternalMessageInfo

func (m *AppStorageGet_Reply) GetValue() []byte {
	if m != nil {
		return m.Value
	}
	return nil
}

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

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

var xxx_messageInfo_AppStorageRemove proto.InternalMessageInfo

type AppStorageRemove_Request struct {
	Key                  string   `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Global               bool     `protobuf:"varint,2,opt,name=global,proto3" json:"global,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *AppStorageRemove_Request) Reset()         { *m = AppStorageRemove_Request{} }
func (m *AppStorageRemove_Request) String() string { return proto.CompactTextString(m) }
func (*AppStorageRemove_Request) ProtoMessage()    {}
func (*AppStorageRemove_Request) Descriptor() ([]byte, []int) {
	return fileDescriptor_5aee2114ef53980b, []int{2, 0}
}
func (m *AppStorageRemove_Request) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AppStorageRemove_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AppStorageRemove_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 *AppStorageRemove_Request) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AppStorageRemove_Request.Merge(m, src)
}
func (m *AppStorageRemove_Request) XXX_Size() int {
	return m.Size()
}
func (m *AppStorageRemove_Request) XXX_DiscardUnknown() {
	xxx_messageInfo_AppStorageRemove_Request.DiscardUnknown(m)
}

var xxx_messageInfo_AppStorageRemove_Request proto.InternalMessageInfo

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

func (m *AppStorageRemove_Request) GetGlobal() bool {
	if m != nil {
		return m.Global
	}
	return false
}

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

func (m *AppStorageRemove_Reply) Reset()         { *m = AppStorageRemove_Reply{} }
func (m *AppStorageRemove_Reply) String() string { return proto.CompactTextString(m) }
func (*AppStorageRemove_Reply) ProtoMessage()    {}
func (*AppStorageRemove_Reply) Descriptor() ([]byte, []int) {
	return fileDescriptor_5aee2114ef53980b, []int{2, 1}
}
func (m *AppStorageRemove_Reply) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AppStorageRemove_Reply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AppStorageRemove_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 *AppStorageRemove_Reply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AppStorageRemove_Reply.Merge(m, src)
}
func (m *AppStorageRemove_Reply) XXX_Size() int {
	return m.Size()
}
func (m *AppStorageRemove_Reply) XXX_DiscardUnknown() {
	xxx_messageInfo_AppStorageRemove_Reply.DiscardUnknown(m)
}

var xxx_messageInfo_AppStorageRemove_Reply proto.InternalMessageInfo

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

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

var xxx_messageInfo_GetOpenedAccount proto.InternalMessageInfo

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

func (m *GetOpenedAccount_Request) Reset()         { *m = GetOpenedAccount_Request{} }
func (m *GetOpenedAccount_Request) String() string { return proto.CompactTextString(m) }
func (*GetOpenedAccount_Request) ProtoMessage()    {}
func (*GetOpenedAccount_Request) Descriptor() ([]byte, []int) {
	return fileDescriptor_5aee2114ef53980b, []int{3, 0}
}
func (m *GetOpenedAccount_Request) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetOpenedAccount_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetOpenedAccount_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 *GetOpenedAccount_Request) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetOpenedAccount_Request.Merge(m, src)
}
func (m *GetOpenedAccount_Request) XXX_Size() int {
	return m.Size()
}
func (m *GetOpenedAccount_Request) XXX_DiscardUnknown() {
	xxx_messageInfo_GetOpenedAccount_Request.DiscardUnknown(m)
}

var xxx_messageInfo_GetOpenedAccount_Request proto.InternalMessageInfo

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

func (m *GetOpenedAccount_Reply) Reset()         { *m = GetOpenedAccount_Reply{} }
func (m *GetOpenedAccount_Reply) String() string { return proto.CompactTextString(m) }
func (*GetOpenedAccount_Reply) ProtoMessage()    {}
func (*GetOpenedAccount_Reply) Descriptor() ([]byte, []int) {
	return fileDescriptor_5aee2114ef53980b, []int{3, 1}
}
func (m *GetOpenedAccount_Reply) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetOpenedAccount_Reply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetOpenedAccount_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 *GetOpenedAccount_Reply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetOpenedAccount_Reply.Merge(m, src)
}
func (m *GetOpenedAccount_Reply) XXX_Size() int {
	return m.Size()
}
func (m *GetOpenedAccount_Reply) XXX_DiscardUnknown() {
	xxx_messageInfo_GetOpenedAccount_Reply.DiscardUnknown(m)
}

var xxx_messageInfo_GetOpenedAccount_Reply proto.InternalMessageInfo

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

func (m *GetOpenedAccount_Reply) GetListeners() []string {
	if m != nil {
		return m.Listeners
	}
	return nil
}

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_5aee2114ef53980b, []int{4}
}
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"`
	SessionKind          string         `protobuf:"bytes,5,opt,name=session_kind,json=sessionKind,proto3" json:"session_kind,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_5aee2114ef53980b, []int{4, 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
}

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

type OpenAccount_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 *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_5aee2114ef53980b, []int{4, 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

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

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_5aee2114ef53980b, []int{5}
}
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"`
	SessionKind          string   `protobuf:"bytes,4,opt,name=session_kind,json=sessionKind,proto3" json:"session_kind,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_5aee2114ef53980b, []int{5, 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 ""
}

func (m *OpenAccountWithProgress_Request) GetSessionKind() string {
	if m != nil {
		return m.SessionKind
	}
	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_5aee2114ef53980b, []int{5, 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_5aee2114ef53980b, []int{6}
}
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_5aee2114ef53980b, []int{6, 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_5aee2114ef53980b, []int{6, 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_5aee2114ef53980b, []int{7}
}
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_5aee2114ef53980b, []int{7, 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_5aee2114ef53980b, []int{7, 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_5aee2114ef53980b, []int{8}
}
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_5aee2114ef53980b, []int{9}
}
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_5aee2114ef53980b, []int{9, 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_5aee2114ef53980b, []int{9, 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_5aee2114ef53980b, []int{10}
}
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_5aee2114ef53980b, []int{10, 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_5aee2114ef53980b, []int{10, 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_5aee2114ef53980b, []int{11}
}
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"`
	SessionKind          string         `protobuf:"bytes,7,opt,name=session_kind,json=sessionKind,proto3" json:"session_kind,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_5aee2114ef53980b, []int{11, 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
}

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

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

func (m *ImportAccount_Reply) Reset()         { *m = ImportAccount_Reply{} }
func (m *ImportAccount_Reply) String() string { return proto.CompactTextString(m) }
func (*ImportAccount_Reply) ProtoMessage()    {}
func (*ImportAccount_Reply) Descriptor() ([]byte, []int) {
	return fileDescriptor_5aee2114ef53980b, []int{11, 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_5aee2114ef53980b, []int{12}
}
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"`
	SessionKind          string         `protobuf:"bytes,7,opt,name=session_kind,json=sessionKind,proto3" json:"session_kind,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_5aee2114ef53980b, []int{12, 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
}

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

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_5aee2114ef53980b, []int{12, 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_5aee2114ef53980b, []int{13}
}
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"`
	NetworkConfig        *NetworkConfig `protobuf:"bytes,3,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_5aee2114ef53980b, []int{13, 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) 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_5aee2114ef53980b, []int{13, 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_5aee2114ef53980b, []int{14}
}
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_5aee2114ef53980b, []int{14, 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_5aee2114ef53980b, []int{14, 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_5aee2114ef53980b, []int{15}
}
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_5aee2114ef53980b, []int{15, 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_5aee2114ef53980b, []int{15, 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_5aee2114ef53980b, []int{15, 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_5aee2114ef53980b, []int{16}
}
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_5aee2114ef53980b, []int{16, 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_5aee2114ef53980b, []int{16, 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_5aee2114ef53980b, []int{16, 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 StreamLogfile struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_StreamLogfile proto.InternalMessageInfo

type StreamLogfile_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 *StreamLogfile_Request) Reset()         { *m = StreamLogfile_Request{} }
func (m *StreamLogfile_Request) String() string { return proto.CompactTextString(m) }
func (*StreamLogfile_Request) ProtoMessage()    {}
func (*StreamLogfile_Request) Descriptor() ([]byte, []int) {
	return fileDescriptor_5aee2114ef53980b, []int{17, 0}
}
func (m *StreamLogfile_Request) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *StreamLogfile_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_StreamLogfile_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 *StreamLogfile_Request) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StreamLogfile_Request.Merge(m, src)
}
func (m *StreamLogfile_Request) XXX_Size() int {
	return m.Size()
}
func (m *StreamLogfile_Request) XXX_DiscardUnknown() {
	xxx_messageInfo_StreamLogfile_Request.DiscardUnknown(m)
}

var xxx_messageInfo_StreamLogfile_Request proto.InternalMessageInfo

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

type StreamLogfile_Reply struct {
	Line                 string   `protobuf:"bytes,1,opt,name=line,proto3" json:"line,omitempty"`
	FileName             string   `protobuf:"bytes,2,opt,name=fileName,proto3" json:"fileName,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *StreamLogfile_Reply) Reset()         { *m = StreamLogfile_Reply{} }
func (m *StreamLogfile_Reply) String() string { return proto.CompactTextString(m) }
func (*StreamLogfile_Reply) ProtoMessage()    {}
func (*StreamLogfile_Reply) Descriptor() ([]byte, []int) {
	return fileDescriptor_5aee2114ef53980b, []int{17, 1}
}
func (m *StreamLogfile_Reply) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *StreamLogfile_Reply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_StreamLogfile_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 *StreamLogfile_Reply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StreamLogfile_Reply.Merge(m, src)
}
func (m *StreamLogfile_Reply) XXX_Size() int {
	return m.Size()
}
func (m *StreamLogfile_Reply) XXX_DiscardUnknown() {
	xxx_messageInfo_StreamLogfile_Reply.DiscardUnknown(m)
}

var xxx_messageInfo_StreamLogfile_Reply proto.InternalMessageInfo

func (m *StreamLogfile_Reply) GetLine() string {
	if m != nil {
		return m.Line
	}
	return ""
}

func (m *StreamLogfile_Reply) GetFileName() string {
	if m != nil {
		return m.FileName
	}
	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_5aee2114ef53980b, []int{18}
}
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_5aee2114ef53980b, []int{18, 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_5aee2114ef53980b, []int{18, 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"`
	AllowUnsecureGRPCConnections NetworkConfig_Flag    `protobuf:"varint,11,opt,name=allow_unsecure_grpc_connections,json=allowUnsecureGrpcConnections,proto3,enum=berty.account.v1.NetworkConfig_Flag" json:"allow_unsecure_grpc_connections,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_5aee2114ef53980b, []int{19}
}
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
}

func (m *NetworkConfig) GetAllowUnsecureGRPCConnections() NetworkConfig_Flag {
	if m != nil {
		return m.AllowUnsecureGRPCConnections
	}
	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_5aee2114ef53980b, []int{20}
}
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_5aee2114ef53980b, []int{20, 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_5aee2114ef53980b, []int{20, 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_5aee2114ef53980b, []int{21}
}
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_5aee2114ef53980b, []int{21, 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_5aee2114ef53980b, []int{21, 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_5aee2114ef53980b, []int{22}
}
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_5aee2114ef53980b, []int{22, 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_5aee2114ef53980b, []int{22, 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_5aee2114ef53980b, []int{23}
}
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=weshnet.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_5aee2114ef53980b, []int{23, 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"`
	Push                 *pushtypes.FormatedPush  `protobuf:"bytes,2,opt,name=push,proto3" json:"push,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_5aee2114ef53980b, []int{23, 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
}

func (m *PushReceive_Reply) GetPush() *pushtypes.FormatedPush {
	if m != nil {
		return m.Push
	}
	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_5aee2114ef53980b, []int{24}
}
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_5aee2114ef53980b, []int{24, 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_5aee2114ef53980b, []int{24, 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((*AppStoragePut)(nil), "berty.account.v1.AppStoragePut")
	proto.RegisterType((*AppStoragePut_Request)(nil), "berty.account.v1.AppStoragePut.Request")
	proto.RegisterType((*AppStoragePut_Reply)(nil), "berty.account.v1.AppStoragePut.Reply")
	proto.RegisterType((*AppStorageGet)(nil), "berty.account.v1.AppStorageGet")
	proto.RegisterType((*AppStorageGet_Request)(nil), "berty.account.v1.AppStorageGet.Request")
	proto.RegisterType((*AppStorageGet_Reply)(nil), "berty.account.v1.AppStorageGet.Reply")
	proto.RegisterType((*AppStorageRemove)(nil), "berty.account.v1.AppStorageRemove")
	proto.RegisterType((*AppStorageRemove_Request)(nil), "berty.account.v1.AppStorageRemove.Request")
	proto.RegisterType((*AppStorageRemove_Reply)(nil), "berty.account.v1.AppStorageRemove.Reply")
	proto.RegisterType((*GetOpenedAccount)(nil), "berty.account.v1.GetOpenedAccount")
	proto.RegisterType((*GetOpenedAccount_Request)(nil), "berty.account.v1.GetOpenedAccount.Request")
	proto.RegisterType((*GetOpenedAccount_Reply)(nil), "berty.account.v1.GetOpenedAccount.Reply")
	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((*StreamLogfile)(nil), "berty.account.v1.StreamLogfile")
	proto.RegisterType((*StreamLogfile_Request)(nil), "berty.account.v1.StreamLogfile.Request")
	proto.RegisterType((*StreamLogfile_Reply)(nil), "berty.account.v1.StreamLogfile.Reply")
	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/accounttypes.proto", fileDescriptor_5aee2114ef53980b) }

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

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

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

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

func (m *AppStoragePut_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.Global {
		i--
		if m.Global {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if len(m.Value) > 0 {
		i -= len(m.Value)
		copy(dAtA[i:], m.Value)
		i = encodeVarintAccounttypes(dAtA, i, uint64(len(m.Value)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Key) > 0 {
		i -= len(m.Key)
		copy(dAtA[i:], m.Key)
		i = encodeVarintAccounttypes(dAtA, i, uint64(len(m.Key)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

func (m *AppStorageGet_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.Global {
		i--
		if m.Global {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if len(m.Key) > 0 {
		i -= len(m.Key)
		copy(dAtA[i:], m.Key)
		i = encodeVarintAccounttypes(dAtA, i, uint64(len(m.Key)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *AppStorageRemove_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.Global {
		i--
		if m.Global {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if len(m.Key) > 0 {
		i -= len(m.Key)
		copy(dAtA[i:], m.Key)
		i = encodeVarintAccounttypes(dAtA, i, uint64(len(m.Key)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *GetOpenedAccount_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.Listeners) > 0 {
		for iNdEx := len(m.Listeners) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Listeners[iNdEx])
			copy(dAtA[i:], m.Listeners[iNdEx])
			i = encodeVarintAccounttypes(dAtA, i, uint64(len(m.Listeners[iNdEx])))
			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 *OpenAccount) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

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

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

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

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

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

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

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

func (m *StreamLogfile_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.FileName) > 0 {
		i -= len(m.FileName)
		copy(dAtA[i:], m.FileName)
		i = encodeVarintAccounttypes(dAtA, i, uint64(len(m.FileName)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Line) > 0 {
		i -= len(m.Line)
		copy(dAtA[i:], m.Line)
		i = encodeVarintAccounttypes(dAtA, i, uint64(len(m.Line)))
		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.AllowUnsecureGRPCConnections != 0 {
		i = encodeVarintAccounttypes(dAtA, i, uint64(m.AllowUnsecureGRPCConnections))
		i--
		dAtA[i] = 0x58
	}
	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.Push != nil {
		{
			size, err := m.Push.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintAccounttypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	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 *AppStoragePut) 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 *AppStoragePut_Request) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovAccounttypes(uint64(l))
	}
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovAccounttypes(uint64(l))
	}
	if m.Global {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *AppStoragePut_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 *AppStorageGet) 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 *AppStorageGet_Request) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovAccounttypes(uint64(l))
	}
	if m.Global {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

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

func (m *AppStorageRemove_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 *GetOpenedAccount) 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 *GetOpenedAccount_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 *GetOpenedAccount_Reply) 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 len(m.Listeners) > 0 {
		for _, s := range m.Listeners {
			l = len(s)
			n += 1 + l + sovAccounttypes(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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))
	}
	l = len(m.SessionKind)
	if l > 0 {
		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.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 *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))
	}
	l = len(m.SessionKind)
	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))
	}
	l = len(m.SessionKind)
	if l > 0 {
		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))
	}
	l = len(m.SessionKind)
	if l > 0 {
		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 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 *StreamLogfile) 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 *StreamLogfile_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 *StreamLogfile_Reply) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Line)
	if l > 0 {
		n += 1 + l + sovAccounttypes(uint64(l))
	}
	l = len(m.FileName)
	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.AllowUnsecureGRPCConnections != 0 {
		n += 1 + sovAccounttypes(uint64(m.AllowUnsecureGRPCConnections))
	}
	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.Push != nil {
		l = m.Push.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 *AppStoragePut) Unmarshal(dAtA []byte) 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: AppStoragePut: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AppStoragePut: 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 *AppStoragePut_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 Key", 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.Key = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...)
			if m.Value == nil {
				m.Value = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Global", 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.Global = 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 *AppStoragePut_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 *AppStorageGet) Unmarshal(dAtA []byte) 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: AppStorageGet: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AppStorageGet: 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 *AppStorageGet_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 Key", 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.Key = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Global", 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.Global = 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 *AppStorageGet_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 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthAccounttypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthAccounttypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...)
			if m.Value == nil {
				m.Value = []byte{}
			}
			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 *AppStorageRemove) Unmarshal(dAtA []byte) 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: AppStorageRemove: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AppStorageRemove: 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 *AppStorageRemove_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 Key", 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.Key = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Global", 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.Global = 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 *AppStorageRemove_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 *GetOpenedAccount) Unmarshal(dAtA []byte) 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: GetOpenedAccount: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetOpenedAccount: 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 *GetOpenedAccount_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 *GetOpenedAccount_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 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 Listeners", 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.Listeners = append(m.Listeners, 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 *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
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SessionKind", 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.SessionKind = 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 *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 {
		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 *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
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SessionKind", 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.SessionKind = 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
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SessionKind", 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.SessionKind = 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 *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
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SessionKind", 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.SessionKind = 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 *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 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 *StreamLogfile) Unmarshal(dAtA []byte) 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: StreamLogfile: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StreamLogfile: 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 *StreamLogfile_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 *StreamLogfile_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 Line", 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.Line = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FileName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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.FileName = 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
				}
			}
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AllowUnsecureGRPCConnections", wireType)
			}
			m.AllowUnsecureGRPCConnections = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccounttypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AllowUnsecureGRPCConnections |= 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
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Push", 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.Push == nil {
				m.Push = &pushtypes.FormatedPush{}
			}
			if err := m.Push.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")
)