// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.5.1
// - protoc             (unknown)
// source: accounttypes/accounttypes.proto

package accounttypes

import (
	context "context"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
)

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
// Requires gRPC-Go v1.64.0 or later.
const _ = grpc.SupportPackageIsVersion9

const (
	AccountService_OpenAccount_FullMethodName               = "/berty.account.v1.AccountService/OpenAccount"
	AccountService_OpenAccountWithProgress_FullMethodName   = "/berty.account.v1.AccountService/OpenAccountWithProgress"
	AccountService_CloseAccount_FullMethodName              = "/berty.account.v1.AccountService/CloseAccount"
	AccountService_CloseAccountWithProgress_FullMethodName  = "/berty.account.v1.AccountService/CloseAccountWithProgress"
	AccountService_ListAccounts_FullMethodName              = "/berty.account.v1.AccountService/ListAccounts"
	AccountService_DeleteAccount_FullMethodName             = "/berty.account.v1.AccountService/DeleteAccount"
	AccountService_ImportAccount_FullMethodName             = "/berty.account.v1.AccountService/ImportAccount"
	AccountService_ImportAccountWithProgress_FullMethodName = "/berty.account.v1.AccountService/ImportAccountWithProgress"
	AccountService_CreateAccount_FullMethodName             = "/berty.account.v1.AccountService/CreateAccount"
	AccountService_UpdateAccount_FullMethodName             = "/berty.account.v1.AccountService/UpdateAccount"
	AccountService_GetGRPCListenerAddrs_FullMethodName      = "/berty.account.v1.AccountService/GetGRPCListenerAddrs"
	AccountService_LogfileList_FullMethodName               = "/berty.account.v1.AccountService/LogfileList"
	AccountService_StreamLogfile_FullMethodName             = "/berty.account.v1.AccountService/StreamLogfile"
	AccountService_GetUsername_FullMethodName               = "/berty.account.v1.AccountService/GetUsername"
	AccountService_NetworkConfigSet_FullMethodName          = "/berty.account.v1.AccountService/NetworkConfigSet"
	AccountService_NetworkConfigGet_FullMethodName          = "/berty.account.v1.AccountService/NetworkConfigGet"
	AccountService_NetworkConfigGetPreset_FullMethodName    = "/berty.account.v1.AccountService/NetworkConfigGetPreset"
	AccountService_PushReceive_FullMethodName               = "/berty.account.v1.AccountService/PushReceive"
	AccountService_PushPlatformTokenRegister_FullMethodName = "/berty.account.v1.AccountService/PushPlatformTokenRegister"
	AccountService_AppStoragePut_FullMethodName             = "/berty.account.v1.AccountService/AppStoragePut"
	AccountService_AppStorageGet_FullMethodName             = "/berty.account.v1.AccountService/AppStorageGet"
	AccountService_AppStorageRemove_FullMethodName          = "/berty.account.v1.AccountService/AppStorageRemove"
	AccountService_GetOpenedAccount_FullMethodName          = "/berty.account.v1.AccountService/GetOpenedAccount"
)

// AccountServiceClient is the client API for AccountService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type AccountServiceClient interface {
	// OpenAccount starts a Berty node.
	OpenAccount(ctx context.Context, in *OpenAccount_Request, opts ...grpc.CallOption) (*OpenAccount_Reply, error)
	// OpenAccountWithProgress is similar to OpenAccount, but also streams the progress.
	OpenAccountWithProgress(ctx context.Context, in *OpenAccountWithProgress_Request, opts ...grpc.CallOption) (grpc.ServerStreamingClient[OpenAccountWithProgress_Reply], error)
	// CloseAccount closes the currently opened account.
	CloseAccount(ctx context.Context, in *CloseAccount_Request, opts ...grpc.CallOption) (*CloseAccount_Reply, error)
	// CloseAccountWithProgress is similar to CloseAccount, but also streams the progress.
	CloseAccountWithProgress(ctx context.Context, in *CloseAccountWithProgress_Request, opts ...grpc.CallOption) (grpc.ServerStreamingClient[CloseAccountWithProgress_Reply], error)
	// ListAccounts retrieves a list of local accounts.
	ListAccounts(ctx context.Context, in *ListAccounts_Request, opts ...grpc.CallOption) (*ListAccounts_Reply, error)
	// DeleteAccount deletes an account.
	DeleteAccount(ctx context.Context, in *DeleteAccount_Request, opts ...grpc.CallOption) (*DeleteAccount_Reply, error)
	// ImportAccount imports existing data.
	ImportAccount(ctx context.Context, in *ImportAccount_Request, opts ...grpc.CallOption) (*ImportAccount_Reply, error)
	// ImportAccountWithProgress is similar to ImportAccount, but also streams the progress.
	ImportAccountWithProgress(ctx context.Context, in *ImportAccountWithProgress_Request, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ImportAccountWithProgress_Reply], error)
	// CreateAccount creates a new account.
	CreateAccount(ctx context.Context, in *CreateAccount_Request, opts ...grpc.CallOption) (*CreateAccount_Reply, error)
	// UpdateAccount update account's metadata.
	UpdateAccount(ctx context.Context, in *UpdateAccount_Request, opts ...grpc.CallOption) (*UpdateAccount_Reply, error)
	// GetGRPCListenerAddrs return current listeners addrs available on this bridge.
	GetGRPCListenerAddrs(ctx context.Context, in *GetGRPCListenerAddrs_Request, opts ...grpc.CallOption) (*GetGRPCListenerAddrs_Reply, error)
	// LogfileList returns a list of logfiles that can be used with Tyber.
	LogfileList(ctx context.Context, in *LogfileList_Request, opts ...grpc.CallOption) (*LogfileList_Reply, error)
	// StreamLogfile stream the lastest log file for the given account
	StreamLogfile(ctx context.Context, in *StreamLogfile_Request, opts ...grpc.CallOption) (grpc.ServerStreamingClient[StreamLogfile_Reply], error)
	// GetUsername returns the name of the device/user using Android/iOS/universal API
	GetUsername(ctx context.Context, in *GetUsername_Request, opts ...grpc.CallOption) (*GetUsername_Reply, error)
	// NetworkConfigSet
	NetworkConfigSet(ctx context.Context, in *NetworkConfigSet_Request, opts ...grpc.CallOption) (*NetworkConfigSet_Reply, error)
	// NetworkConfigGet
	NetworkConfigGet(ctx context.Context, in *NetworkConfigGet_Request, opts ...grpc.CallOption) (*NetworkConfigGet_Reply, error)
	// NetworkConfigGetPreset
	NetworkConfigGetPreset(ctx context.Context, in *NetworkConfigGetPreset_Request, opts ...grpc.CallOption) (*NetworkConfigGetPreset_Reply, error)
	// PushReceive
	PushReceive(ctx context.Context, in *PushReceive_Request, opts ...grpc.CallOption) (*PushReceive_Reply, error)
	// PushPlatformTokenRegister
	PushPlatformTokenRegister(ctx context.Context, in *PushPlatformTokenRegister_Request, opts ...grpc.CallOption) (*PushPlatformTokenRegister_Reply, error)
	// AppStoragePut puts a value by key in a storage secured by the device enclave if possible
	AppStoragePut(ctx context.Context, in *AppStoragePut_Request, opts ...grpc.CallOption) (*AppStoragePut_Reply, error)
	// AppStorageGet gets a value by key in a storage secured by the device enclave if possible
	AppStorageGet(ctx context.Context, in *AppStorageGet_Request, opts ...grpc.CallOption) (*AppStorageGet_Reply, error)
	// AppStorageRemove removes a value by key in a storage secured by the device enclave if possible
	AppStorageRemove(ctx context.Context, in *AppStorageRemove_Request, opts ...grpc.CallOption) (*AppStorageRemove_Reply, error)
	// GetOpenedAccount returns details of the opened account
	GetOpenedAccount(ctx context.Context, in *GetOpenedAccount_Request, opts ...grpc.CallOption) (*GetOpenedAccount_Reply, error)
}

type accountServiceClient struct {
	cc grpc.ClientConnInterface
}

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

func (c *accountServiceClient) OpenAccount(ctx context.Context, in *OpenAccount_Request, opts ...grpc.CallOption) (*OpenAccount_Reply, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(OpenAccount_Reply)
	err := c.cc.Invoke(ctx, AccountService_OpenAccount_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *accountServiceClient) OpenAccountWithProgress(ctx context.Context, in *OpenAccountWithProgress_Request, opts ...grpc.CallOption) (grpc.ServerStreamingClient[OpenAccountWithProgress_Reply], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &AccountService_ServiceDesc.Streams[0], AccountService_OpenAccountWithProgress_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[OpenAccountWithProgress_Request, OpenAccountWithProgress_Reply]{ClientStream: stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type AccountService_OpenAccountWithProgressClient = grpc.ServerStreamingClient[OpenAccountWithProgress_Reply]

func (c *accountServiceClient) CloseAccount(ctx context.Context, in *CloseAccount_Request, opts ...grpc.CallOption) (*CloseAccount_Reply, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CloseAccount_Reply)
	err := c.cc.Invoke(ctx, AccountService_CloseAccount_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *accountServiceClient) CloseAccountWithProgress(ctx context.Context, in *CloseAccountWithProgress_Request, opts ...grpc.CallOption) (grpc.ServerStreamingClient[CloseAccountWithProgress_Reply], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &AccountService_ServiceDesc.Streams[1], AccountService_CloseAccountWithProgress_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[CloseAccountWithProgress_Request, CloseAccountWithProgress_Reply]{ClientStream: stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type AccountService_CloseAccountWithProgressClient = grpc.ServerStreamingClient[CloseAccountWithProgress_Reply]

func (c *accountServiceClient) ListAccounts(ctx context.Context, in *ListAccounts_Request, opts ...grpc.CallOption) (*ListAccounts_Reply, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListAccounts_Reply)
	err := c.cc.Invoke(ctx, AccountService_ListAccounts_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *accountServiceClient) DeleteAccount(ctx context.Context, in *DeleteAccount_Request, opts ...grpc.CallOption) (*DeleteAccount_Reply, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DeleteAccount_Reply)
	err := c.cc.Invoke(ctx, AccountService_DeleteAccount_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *accountServiceClient) ImportAccount(ctx context.Context, in *ImportAccount_Request, opts ...grpc.CallOption) (*ImportAccount_Reply, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ImportAccount_Reply)
	err := c.cc.Invoke(ctx, AccountService_ImportAccount_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *accountServiceClient) ImportAccountWithProgress(ctx context.Context, in *ImportAccountWithProgress_Request, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ImportAccountWithProgress_Reply], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &AccountService_ServiceDesc.Streams[2], AccountService_ImportAccountWithProgress_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[ImportAccountWithProgress_Request, ImportAccountWithProgress_Reply]{ClientStream: stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type AccountService_ImportAccountWithProgressClient = grpc.ServerStreamingClient[ImportAccountWithProgress_Reply]

func (c *accountServiceClient) CreateAccount(ctx context.Context, in *CreateAccount_Request, opts ...grpc.CallOption) (*CreateAccount_Reply, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CreateAccount_Reply)
	err := c.cc.Invoke(ctx, AccountService_CreateAccount_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *accountServiceClient) UpdateAccount(ctx context.Context, in *UpdateAccount_Request, opts ...grpc.CallOption) (*UpdateAccount_Reply, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(UpdateAccount_Reply)
	err := c.cc.Invoke(ctx, AccountService_UpdateAccount_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *accountServiceClient) GetGRPCListenerAddrs(ctx context.Context, in *GetGRPCListenerAddrs_Request, opts ...grpc.CallOption) (*GetGRPCListenerAddrs_Reply, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetGRPCListenerAddrs_Reply)
	err := c.cc.Invoke(ctx, AccountService_GetGRPCListenerAddrs_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *accountServiceClient) LogfileList(ctx context.Context, in *LogfileList_Request, opts ...grpc.CallOption) (*LogfileList_Reply, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(LogfileList_Reply)
	err := c.cc.Invoke(ctx, AccountService_LogfileList_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *accountServiceClient) StreamLogfile(ctx context.Context, in *StreamLogfile_Request, opts ...grpc.CallOption) (grpc.ServerStreamingClient[StreamLogfile_Reply], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &AccountService_ServiceDesc.Streams[3], AccountService_StreamLogfile_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[StreamLogfile_Request, StreamLogfile_Reply]{ClientStream: stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type AccountService_StreamLogfileClient = grpc.ServerStreamingClient[StreamLogfile_Reply]

func (c *accountServiceClient) GetUsername(ctx context.Context, in *GetUsername_Request, opts ...grpc.CallOption) (*GetUsername_Reply, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetUsername_Reply)
	err := c.cc.Invoke(ctx, AccountService_GetUsername_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *accountServiceClient) NetworkConfigSet(ctx context.Context, in *NetworkConfigSet_Request, opts ...grpc.CallOption) (*NetworkConfigSet_Reply, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(NetworkConfigSet_Reply)
	err := c.cc.Invoke(ctx, AccountService_NetworkConfigSet_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *accountServiceClient) NetworkConfigGet(ctx context.Context, in *NetworkConfigGet_Request, opts ...grpc.CallOption) (*NetworkConfigGet_Reply, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(NetworkConfigGet_Reply)
	err := c.cc.Invoke(ctx, AccountService_NetworkConfigGet_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *accountServiceClient) NetworkConfigGetPreset(ctx context.Context, in *NetworkConfigGetPreset_Request, opts ...grpc.CallOption) (*NetworkConfigGetPreset_Reply, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(NetworkConfigGetPreset_Reply)
	err := c.cc.Invoke(ctx, AccountService_NetworkConfigGetPreset_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *accountServiceClient) PushReceive(ctx context.Context, in *PushReceive_Request, opts ...grpc.CallOption) (*PushReceive_Reply, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(PushReceive_Reply)
	err := c.cc.Invoke(ctx, AccountService_PushReceive_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *accountServiceClient) PushPlatformTokenRegister(ctx context.Context, in *PushPlatformTokenRegister_Request, opts ...grpc.CallOption) (*PushPlatformTokenRegister_Reply, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(PushPlatformTokenRegister_Reply)
	err := c.cc.Invoke(ctx, AccountService_PushPlatformTokenRegister_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *accountServiceClient) AppStoragePut(ctx context.Context, in *AppStoragePut_Request, opts ...grpc.CallOption) (*AppStoragePut_Reply, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(AppStoragePut_Reply)
	err := c.cc.Invoke(ctx, AccountService_AppStoragePut_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *accountServiceClient) AppStorageGet(ctx context.Context, in *AppStorageGet_Request, opts ...grpc.CallOption) (*AppStorageGet_Reply, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(AppStorageGet_Reply)
	err := c.cc.Invoke(ctx, AccountService_AppStorageGet_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *accountServiceClient) AppStorageRemove(ctx context.Context, in *AppStorageRemove_Request, opts ...grpc.CallOption) (*AppStorageRemove_Reply, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(AppStorageRemove_Reply)
	err := c.cc.Invoke(ctx, AccountService_AppStorageRemove_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *accountServiceClient) GetOpenedAccount(ctx context.Context, in *GetOpenedAccount_Request, opts ...grpc.CallOption) (*GetOpenedAccount_Reply, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetOpenedAccount_Reply)
	err := c.cc.Invoke(ctx, AccountService_GetOpenedAccount_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// AccountServiceServer is the server API for AccountService service.
// All implementations must embed UnimplementedAccountServiceServer
// for forward compatibility.
type AccountServiceServer interface {
	// OpenAccount starts a Berty node.
	OpenAccount(context.Context, *OpenAccount_Request) (*OpenAccount_Reply, error)
	// OpenAccountWithProgress is similar to OpenAccount, but also streams the progress.
	OpenAccountWithProgress(*OpenAccountWithProgress_Request, grpc.ServerStreamingServer[OpenAccountWithProgress_Reply]) error
	// CloseAccount closes the currently opened account.
	CloseAccount(context.Context, *CloseAccount_Request) (*CloseAccount_Reply, error)
	// CloseAccountWithProgress is similar to CloseAccount, but also streams the progress.
	CloseAccountWithProgress(*CloseAccountWithProgress_Request, grpc.ServerStreamingServer[CloseAccountWithProgress_Reply]) error
	// ListAccounts retrieves a list of local accounts.
	ListAccounts(context.Context, *ListAccounts_Request) (*ListAccounts_Reply, error)
	// DeleteAccount deletes an account.
	DeleteAccount(context.Context, *DeleteAccount_Request) (*DeleteAccount_Reply, error)
	// ImportAccount imports existing data.
	ImportAccount(context.Context, *ImportAccount_Request) (*ImportAccount_Reply, error)
	// ImportAccountWithProgress is similar to ImportAccount, but also streams the progress.
	ImportAccountWithProgress(*ImportAccountWithProgress_Request, grpc.ServerStreamingServer[ImportAccountWithProgress_Reply]) error
	// CreateAccount creates a new account.
	CreateAccount(context.Context, *CreateAccount_Request) (*CreateAccount_Reply, error)
	// UpdateAccount update account's metadata.
	UpdateAccount(context.Context, *UpdateAccount_Request) (*UpdateAccount_Reply, error)
	// GetGRPCListenerAddrs return current listeners addrs available on this bridge.
	GetGRPCListenerAddrs(context.Context, *GetGRPCListenerAddrs_Request) (*GetGRPCListenerAddrs_Reply, error)
	// LogfileList returns a list of logfiles that can be used with Tyber.
	LogfileList(context.Context, *LogfileList_Request) (*LogfileList_Reply, error)
	// StreamLogfile stream the lastest log file for the given account
	StreamLogfile(*StreamLogfile_Request, grpc.ServerStreamingServer[StreamLogfile_Reply]) error
	// GetUsername returns the name of the device/user using Android/iOS/universal API
	GetUsername(context.Context, *GetUsername_Request) (*GetUsername_Reply, error)
	// NetworkConfigSet
	NetworkConfigSet(context.Context, *NetworkConfigSet_Request) (*NetworkConfigSet_Reply, error)
	// NetworkConfigGet
	NetworkConfigGet(context.Context, *NetworkConfigGet_Request) (*NetworkConfigGet_Reply, error)
	// NetworkConfigGetPreset
	NetworkConfigGetPreset(context.Context, *NetworkConfigGetPreset_Request) (*NetworkConfigGetPreset_Reply, error)
	// PushReceive
	PushReceive(context.Context, *PushReceive_Request) (*PushReceive_Reply, error)
	// PushPlatformTokenRegister
	PushPlatformTokenRegister(context.Context, *PushPlatformTokenRegister_Request) (*PushPlatformTokenRegister_Reply, error)
	// AppStoragePut puts a value by key in a storage secured by the device enclave if possible
	AppStoragePut(context.Context, *AppStoragePut_Request) (*AppStoragePut_Reply, error)
	// AppStorageGet gets a value by key in a storage secured by the device enclave if possible
	AppStorageGet(context.Context, *AppStorageGet_Request) (*AppStorageGet_Reply, error)
	// AppStorageRemove removes a value by key in a storage secured by the device enclave if possible
	AppStorageRemove(context.Context, *AppStorageRemove_Request) (*AppStorageRemove_Reply, error)
	// GetOpenedAccount returns details of the opened account
	GetOpenedAccount(context.Context, *GetOpenedAccount_Request) (*GetOpenedAccount_Reply, error)
	mustEmbedUnimplementedAccountServiceServer()
}

// UnimplementedAccountServiceServer must be embedded to have
// forward compatible implementations.
//
// NOTE: this should be embedded by value instead of pointer to avoid a nil
// pointer dereference when methods are called.
type UnimplementedAccountServiceServer struct{}

func (UnimplementedAccountServiceServer) OpenAccount(context.Context, *OpenAccount_Request) (*OpenAccount_Reply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method OpenAccount not implemented")
}
func (UnimplementedAccountServiceServer) OpenAccountWithProgress(*OpenAccountWithProgress_Request, grpc.ServerStreamingServer[OpenAccountWithProgress_Reply]) error {
	return status.Errorf(codes.Unimplemented, "method OpenAccountWithProgress not implemented")
}
func (UnimplementedAccountServiceServer) CloseAccount(context.Context, *CloseAccount_Request) (*CloseAccount_Reply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CloseAccount not implemented")
}
func (UnimplementedAccountServiceServer) CloseAccountWithProgress(*CloseAccountWithProgress_Request, grpc.ServerStreamingServer[CloseAccountWithProgress_Reply]) error {
	return status.Errorf(codes.Unimplemented, "method CloseAccountWithProgress not implemented")
}
func (UnimplementedAccountServiceServer) ListAccounts(context.Context, *ListAccounts_Request) (*ListAccounts_Reply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListAccounts not implemented")
}
func (UnimplementedAccountServiceServer) DeleteAccount(context.Context, *DeleteAccount_Request) (*DeleteAccount_Reply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteAccount not implemented")
}
func (UnimplementedAccountServiceServer) ImportAccount(context.Context, *ImportAccount_Request) (*ImportAccount_Reply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ImportAccount not implemented")
}
func (UnimplementedAccountServiceServer) ImportAccountWithProgress(*ImportAccountWithProgress_Request, grpc.ServerStreamingServer[ImportAccountWithProgress_Reply]) error {
	return status.Errorf(codes.Unimplemented, "method ImportAccountWithProgress not implemented")
}
func (UnimplementedAccountServiceServer) CreateAccount(context.Context, *CreateAccount_Request) (*CreateAccount_Reply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateAccount not implemented")
}
func (UnimplementedAccountServiceServer) UpdateAccount(context.Context, *UpdateAccount_Request) (*UpdateAccount_Reply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateAccount not implemented")
}
func (UnimplementedAccountServiceServer) GetGRPCListenerAddrs(context.Context, *GetGRPCListenerAddrs_Request) (*GetGRPCListenerAddrs_Reply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetGRPCListenerAddrs not implemented")
}
func (UnimplementedAccountServiceServer) LogfileList(context.Context, *LogfileList_Request) (*LogfileList_Reply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method LogfileList not implemented")
}
func (UnimplementedAccountServiceServer) StreamLogfile(*StreamLogfile_Request, grpc.ServerStreamingServer[StreamLogfile_Reply]) error {
	return status.Errorf(codes.Unimplemented, "method StreamLogfile not implemented")
}
func (UnimplementedAccountServiceServer) GetUsername(context.Context, *GetUsername_Request) (*GetUsername_Reply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetUsername not implemented")
}
func (UnimplementedAccountServiceServer) NetworkConfigSet(context.Context, *NetworkConfigSet_Request) (*NetworkConfigSet_Reply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method NetworkConfigSet not implemented")
}
func (UnimplementedAccountServiceServer) NetworkConfigGet(context.Context, *NetworkConfigGet_Request) (*NetworkConfigGet_Reply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method NetworkConfigGet not implemented")
}
func (UnimplementedAccountServiceServer) NetworkConfigGetPreset(context.Context, *NetworkConfigGetPreset_Request) (*NetworkConfigGetPreset_Reply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method NetworkConfigGetPreset not implemented")
}
func (UnimplementedAccountServiceServer) PushReceive(context.Context, *PushReceive_Request) (*PushReceive_Reply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PushReceive not implemented")
}
func (UnimplementedAccountServiceServer) PushPlatformTokenRegister(context.Context, *PushPlatformTokenRegister_Request) (*PushPlatformTokenRegister_Reply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PushPlatformTokenRegister not implemented")
}
func (UnimplementedAccountServiceServer) AppStoragePut(context.Context, *AppStoragePut_Request) (*AppStoragePut_Reply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AppStoragePut not implemented")
}
func (UnimplementedAccountServiceServer) AppStorageGet(context.Context, *AppStorageGet_Request) (*AppStorageGet_Reply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AppStorageGet not implemented")
}
func (UnimplementedAccountServiceServer) AppStorageRemove(context.Context, *AppStorageRemove_Request) (*AppStorageRemove_Reply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AppStorageRemove not implemented")
}
func (UnimplementedAccountServiceServer) GetOpenedAccount(context.Context, *GetOpenedAccount_Request) (*GetOpenedAccount_Reply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetOpenedAccount not implemented")
}
func (UnimplementedAccountServiceServer) mustEmbedUnimplementedAccountServiceServer() {}
func (UnimplementedAccountServiceServer) testEmbeddedByValue()                        {}

// UnsafeAccountServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to AccountServiceServer will
// result in compilation errors.
type UnsafeAccountServiceServer interface {
	mustEmbedUnimplementedAccountServiceServer()
}

func RegisterAccountServiceServer(s grpc.ServiceRegistrar, srv AccountServiceServer) {
	// If the following call pancis, it indicates UnimplementedAccountServiceServer was
	// embedded by pointer and is nil.  This will cause panics if an
	// unimplemented method is ever invoked, so we test this at initialization
	// time to prevent it from happening at runtime later due to I/O.
	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
		t.testEmbeddedByValue()
	}
	s.RegisterService(&AccountService_ServiceDesc, srv)
}

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

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

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type AccountService_OpenAccountWithProgressServer = grpc.ServerStreamingServer[OpenAccountWithProgress_Reply]

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

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

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type AccountService_CloseAccountWithProgressServer = grpc.ServerStreamingServer[CloseAccountWithProgress_Reply]

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

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

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

func _AccountService_ImportAccountWithProgress_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ImportAccountWithProgress_Request)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AccountServiceServer).ImportAccountWithProgress(m, &grpc.GenericServerStream[ImportAccountWithProgress_Request, ImportAccountWithProgress_Reply]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type AccountService_ImportAccountWithProgressServer = grpc.ServerStreamingServer[ImportAccountWithProgress_Reply]

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

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

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

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

func _AccountService_StreamLogfile_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(StreamLogfile_Request)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AccountServiceServer).StreamLogfile(m, &grpc.GenericServerStream[StreamLogfile_Request, StreamLogfile_Reply]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type AccountService_StreamLogfileServer = grpc.ServerStreamingServer[StreamLogfile_Reply]

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

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

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

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

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

func _AccountService_PushPlatformTokenRegister_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PushPlatformTokenRegister_Request)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AccountServiceServer).PushPlatformTokenRegister(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AccountService_PushPlatformTokenRegister_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AccountServiceServer).PushPlatformTokenRegister(ctx, req.(*PushPlatformTokenRegister_Request))
	}
	return interceptor(ctx, in, info, handler)
}

func _AccountService_AppStoragePut_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AppStoragePut_Request)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AccountServiceServer).AppStoragePut(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AccountService_AppStoragePut_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AccountServiceServer).AppStoragePut(ctx, req.(*AppStoragePut_Request))
	}
	return interceptor(ctx, in, info, handler)
}

func _AccountService_AppStorageGet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AppStorageGet_Request)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AccountServiceServer).AppStorageGet(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AccountService_AppStorageGet_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AccountServiceServer).AppStorageGet(ctx, req.(*AppStorageGet_Request))
	}
	return interceptor(ctx, in, info, handler)
}

func _AccountService_AppStorageRemove_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AppStorageRemove_Request)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AccountServiceServer).AppStorageRemove(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AccountService_AppStorageRemove_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AccountServiceServer).AppStorageRemove(ctx, req.(*AppStorageRemove_Request))
	}
	return interceptor(ctx, in, info, handler)
}

func _AccountService_GetOpenedAccount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetOpenedAccount_Request)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AccountServiceServer).GetOpenedAccount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AccountService_GetOpenedAccount_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AccountServiceServer).GetOpenedAccount(ctx, req.(*GetOpenedAccount_Request))
	}
	return interceptor(ctx, in, info, handler)
}

// AccountService_ServiceDesc is the grpc.ServiceDesc for AccountService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var AccountService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "berty.account.v1.AccountService",
	HandlerType: (*AccountServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "OpenAccount",
			Handler:    _AccountService_OpenAccount_Handler,
		},
		{
			MethodName: "CloseAccount",
			Handler:    _AccountService_CloseAccount_Handler,
		},
		{
			MethodName: "ListAccounts",
			Handler:    _AccountService_ListAccounts_Handler,
		},
		{
			MethodName: "DeleteAccount",
			Handler:    _AccountService_DeleteAccount_Handler,
		},
		{
			MethodName: "ImportAccount",
			Handler:    _AccountService_ImportAccount_Handler,
		},
		{
			MethodName: "CreateAccount",
			Handler:    _AccountService_CreateAccount_Handler,
		},
		{
			MethodName: "UpdateAccount",
			Handler:    _AccountService_UpdateAccount_Handler,
		},
		{
			MethodName: "GetGRPCListenerAddrs",
			Handler:    _AccountService_GetGRPCListenerAddrs_Handler,
		},
		{
			MethodName: "LogfileList",
			Handler:    _AccountService_LogfileList_Handler,
		},
		{
			MethodName: "GetUsername",
			Handler:    _AccountService_GetUsername_Handler,
		},
		{
			MethodName: "NetworkConfigSet",
			Handler:    _AccountService_NetworkConfigSet_Handler,
		},
		{
			MethodName: "NetworkConfigGet",
			Handler:    _AccountService_NetworkConfigGet_Handler,
		},
		{
			MethodName: "NetworkConfigGetPreset",
			Handler:    _AccountService_NetworkConfigGetPreset_Handler,
		},
		{
			MethodName: "PushReceive",
			Handler:    _AccountService_PushReceive_Handler,
		},
		{
			MethodName: "PushPlatformTokenRegister",
			Handler:    _AccountService_PushPlatformTokenRegister_Handler,
		},
		{
			MethodName: "AppStoragePut",
			Handler:    _AccountService_AppStoragePut_Handler,
		},
		{
			MethodName: "AppStorageGet",
			Handler:    _AccountService_AppStorageGet_Handler,
		},
		{
			MethodName: "AppStorageRemove",
			Handler:    _AccountService_AppStorageRemove_Handler,
		},
		{
			MethodName: "GetOpenedAccount",
			Handler:    _AccountService_GetOpenedAccount_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "OpenAccountWithProgress",
			Handler:       _AccountService_OpenAccountWithProgress_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "CloseAccountWithProgress",
			Handler:       _AccountService_CloseAccountWithProgress_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ImportAccountWithProgress",
			Handler:       _AccountService_ImportAccountWithProgress_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "StreamLogfile",
			Handler:       _AccountService_StreamLogfile_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "accounttypes/accounttypes.proto",
}
