// Code generated by protoc-gen-go-grpc. DO NOT EDIT.

package service

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.
const _ = grpc.SupportPackageIsVersion6

// RPCClient is the client API for RPC 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 RPCClient interface {
	KeyGenerate(ctx context.Context, in *KeyGenerateRequest, opts ...grpc.CallOption) (*KeyGenerateResponse, error)
	Keys(ctx context.Context, in *KeysRequest, opts ...grpc.CallOption) (*KeysResponse, error)
	Key(ctx context.Context, in *KeyRequest, opts ...grpc.CallOption) (*KeyResponse, error)
	KeyImport(ctx context.Context, in *KeyImportRequest, opts ...grpc.CallOption) (*KeyImportResponse, error)
	KeyExport(ctx context.Context, in *KeyExportRequest, opts ...grpc.CallOption) (*KeyExportResponse, error)
	KeyRemove(ctx context.Context, in *KeyRemoveRequest, opts ...grpc.CallOption) (*KeyRemoveResponse, error)
	Sign(ctx context.Context, in *SignRequest, opts ...grpc.CallOption) (*SignResponse, error)
	SignFile(ctx context.Context, opts ...grpc.CallOption) (RPC_SignFileClient, error)
	SignStream(ctx context.Context, opts ...grpc.CallOption) (RPC_SignStreamClient, error)
	Verify(ctx context.Context, in *VerifyRequest, opts ...grpc.CallOption) (*VerifyResponse, error)
	VerifyFile(ctx context.Context, opts ...grpc.CallOption) (RPC_VerifyFileClient, error)
	VerifyStream(ctx context.Context, opts ...grpc.CallOption) (RPC_VerifyStreamClient, error)
	VerifyDetached(ctx context.Context, in *VerifyDetachedRequest, opts ...grpc.CallOption) (*VerifyDetachedResponse, error)
	VerifyDetachedFile(ctx context.Context, opts ...grpc.CallOption) (RPC_VerifyDetachedFileClient, error)
	VerifyDetachedStream(ctx context.Context, opts ...grpc.CallOption) (RPC_VerifyDetachedStreamClient, error)
	Encrypt(ctx context.Context, in *EncryptRequest, opts ...grpc.CallOption) (*EncryptResponse, error)
	EncryptStream(ctx context.Context, opts ...grpc.CallOption) (RPC_EncryptStreamClient, error)
	EncryptFile(ctx context.Context, opts ...grpc.CallOption) (RPC_EncryptFileClient, error)
	Decrypt(ctx context.Context, in *DecryptRequest, opts ...grpc.CallOption) (*DecryptResponse, error)
	DecryptStream(ctx context.Context, opts ...grpc.CallOption) (RPC_DecryptStreamClient, error)
	DecryptFile(ctx context.Context, opts ...grpc.CallOption) (RPC_DecryptFileClient, error)
	Sigchain(ctx context.Context, in *SigchainRequest, opts ...grpc.CallOption) (*SigchainResponse, error)
	Statement(ctx context.Context, in *StatementRequest, opts ...grpc.CallOption) (*StatementResponse, error)
	StatementCreate(ctx context.Context, in *StatementCreateRequest, opts ...grpc.CallOption) (*StatementCreateResponse, error)
	StatementRevoke(ctx context.Context, in *StatementRevokeRequest, opts ...grpc.CallOption) (*StatementRevokeResponse, error)
	User(ctx context.Context, in *UserRequest, opts ...grpc.CallOption) (*UserResponse, error)
	UserSearch(ctx context.Context, in *UserSearchRequest, opts ...grpc.CallOption) (*UserSearchResponse, error)
	UserService(ctx context.Context, in *UserServiceRequest, opts ...grpc.CallOption) (*UserServiceResponse, error)
	UserSign(ctx context.Context, in *UserSignRequest, opts ...grpc.CallOption) (*UserSignResponse, error)
	UserAdd(ctx context.Context, in *UserAddRequest, opts ...grpc.CallOption) (*UserAddResponse, error)
	Search(ctx context.Context, in *SearchRequest, opts ...grpc.CallOption) (*SearchResponse, error)
	Secret(ctx context.Context, in *SecretRequest, opts ...grpc.CallOption) (*SecretResponse, error)
	SecretSave(ctx context.Context, in *SecretSaveRequest, opts ...grpc.CallOption) (*SecretSaveResponse, error)
	SecretRemove(ctx context.Context, in *SecretRemoveRequest, opts ...grpc.CallOption) (*SecretRemoveResponse, error)
	Secrets(ctx context.Context, in *SecretsRequest, opts ...grpc.CallOption) (*SecretsResponse, error)
	Pull(ctx context.Context, in *PullRequest, opts ...grpc.CallOption) (*PullResponse, error)
	Push(ctx context.Context, in *PushRequest, opts ...grpc.CallOption) (*PushResponse, error)
	Wormhole(ctx context.Context, opts ...grpc.CallOption) (RPC_WormholeClient, error)
	// These requests do not need auth.
	// BEGIN NO AUTH
	AuthSetup(ctx context.Context, in *AuthSetupRequest, opts ...grpc.CallOption) (*AuthSetupResponse, error)
	AuthVault(ctx context.Context, in *AuthVaultRequest, opts ...grpc.CallOption) (*AuthVaultResponse, error)
	AuthUnlock(ctx context.Context, in *AuthUnlockRequest, opts ...grpc.CallOption) (*AuthUnlockResponse, error)
	AuthLock(ctx context.Context, in *AuthLockRequest, opts ...grpc.CallOption) (*AuthLockResponse, error)
	AuthReset(ctx context.Context, in *AuthResetRequest, opts ...grpc.CallOption) (*AuthResetResponse, error)
	AuthRecover(ctx context.Context, in *AuthRecoverRequest, opts ...grpc.CallOption) (*AuthRecoverResponse, error)
	RuntimeStatus(ctx context.Context, in *RuntimeStatusRequest, opts ...grpc.CallOption) (*RuntimeStatusResponse, error)
	Rand(ctx context.Context, in *RandRequest, opts ...grpc.CallOption) (*RandResponse, error)
	RandPassword(ctx context.Context, in *RandPasswordRequest, opts ...grpc.CallOption) (*RandPasswordResponse, error)
	// Auth (edit)
	AuthProvision(ctx context.Context, in *AuthProvisionRequest, opts ...grpc.CallOption) (*AuthProvisionResponse, error)
	AuthDeprovision(ctx context.Context, in *AuthDeprovisionRequest, opts ...grpc.CallOption) (*AuthDeprovisionResponse, error)
	AuthProvisions(ctx context.Context, in *AuthProvisionsRequest, opts ...grpc.CallOption) (*AuthProvisionsResponse, error)
	AuthPasswordChange(ctx context.Context, in *AuthPasswordChangeRequest, opts ...grpc.CallOption) (*AuthPasswordChangeResponse, error)
	// Vault
	VaultAuth(ctx context.Context, in *VaultAuthRequest, opts ...grpc.CallOption) (*VaultAuthResponse, error)
	VaultSync(ctx context.Context, in *VaultSyncRequest, opts ...grpc.CallOption) (*VaultSyncResponse, error)
	VaultUnsync(ctx context.Context, in *VaultUnsyncRequest, opts ...grpc.CallOption) (*VaultUnsyncResponse, error)
	VaultStatus(ctx context.Context, in *VaultStatusRequest, opts ...grpc.CallOption) (*VaultStatusResponse, error)
	VaultUpdate(ctx context.Context, in *VaultUpdateRequest, opts ...grpc.CallOption) (*VaultUpdateResponse, error)
	// DB
	Collections(ctx context.Context, in *CollectionsRequest, opts ...grpc.CallOption) (*CollectionsResponse, error)
	Documents(ctx context.Context, in *DocumentsRequest, opts ...grpc.CallOption) (*DocumentsResponse, error)
	DocumentDelete(ctx context.Context, in *DocumentDeleteRequest, opts ...grpc.CallOption) (*DocumentDeleteResponse, error)
	// Config
	ConfigGet(ctx context.Context, in *ConfigGetRequest, opts ...grpc.CallOption) (*ConfigGetResponse, error)
	ConfigSet(ctx context.Context, in *ConfigSetRequest, opts ...grpc.CallOption) (*ConfigSetResponse, error)
	// Admin
	AdminSignURL(ctx context.Context, in *AdminSignURLRequest, opts ...grpc.CallOption) (*AdminSignURLResponse, error)
	AdminCheck(ctx context.Context, in *AdminCheckRequest, opts ...grpc.CallOption) (*AdminCheckResponse, error)
	// Channels
	Channels(ctx context.Context, in *ChannelsRequest, opts ...grpc.CallOption) (*ChannelsResponse, error)
	ChannelCreate(ctx context.Context, in *ChannelCreateRequest, opts ...grpc.CallOption) (*ChannelCreateResponse, error)
	ChannelInvite(ctx context.Context, in *ChannelInviteRequest, opts ...grpc.CallOption) (*ChannelInviteResponse, error)
	ChannelLeave(ctx context.Context, in *ChannelLeaveRequest, opts ...grpc.CallOption) (*ChannelLeaveResponse, error)
	ChannelRead(ctx context.Context, in *ChannelReadRequest, opts ...grpc.CallOption) (*ChannelReadResponse, error)
	// Follow
	Follow(ctx context.Context, in *FollowRequest, opts ...grpc.CallOption) (*FollowResponse, error)
	Follows(ctx context.Context, in *FollowsRequest, opts ...grpc.CallOption) (*FollowsResponse, error)
	// Messages
	MessagePrepare(ctx context.Context, in *MessagePrepareRequest, opts ...grpc.CallOption) (*MessagePrepareResponse, error)
	MessageCreate(ctx context.Context, in *MessageCreateRequest, opts ...grpc.CallOption) (*MessageCreateResponse, error)
	Messages(ctx context.Context, in *MessagesRequest, opts ...grpc.CallOption) (*MessagesResponse, error)
	// Relay
	Relay(ctx context.Context, in *RelayRequest, opts ...grpc.CallOption) (RPC_RelayClient, error)
}

type rPCClient struct {
	cc grpc.ClientConnInterface
}

func NewRPCClient(cc grpc.ClientConnInterface) RPCClient {
	return &rPCClient{cc}
}

func (c *rPCClient) KeyGenerate(ctx context.Context, in *KeyGenerateRequest, opts ...grpc.CallOption) (*KeyGenerateResponse, error) {
	out := new(KeyGenerateResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/KeyGenerate", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) Keys(ctx context.Context, in *KeysRequest, opts ...grpc.CallOption) (*KeysResponse, error) {
	out := new(KeysResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/Keys", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) Key(ctx context.Context, in *KeyRequest, opts ...grpc.CallOption) (*KeyResponse, error) {
	out := new(KeyResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/Key", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) KeyImport(ctx context.Context, in *KeyImportRequest, opts ...grpc.CallOption) (*KeyImportResponse, error) {
	out := new(KeyImportResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/KeyImport", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) KeyExport(ctx context.Context, in *KeyExportRequest, opts ...grpc.CallOption) (*KeyExportResponse, error) {
	out := new(KeyExportResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/KeyExport", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) KeyRemove(ctx context.Context, in *KeyRemoveRequest, opts ...grpc.CallOption) (*KeyRemoveResponse, error) {
	out := new(KeyRemoveResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/KeyRemove", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) Sign(ctx context.Context, in *SignRequest, opts ...grpc.CallOption) (*SignResponse, error) {
	out := new(SignResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/Sign", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) SignFile(ctx context.Context, opts ...grpc.CallOption) (RPC_SignFileClient, error) {
	stream, err := c.cc.NewStream(ctx, &_RPC_serviceDesc.Streams[0], "/service.RPC/SignFile", opts...)
	if err != nil {
		return nil, err
	}
	x := &rPCSignFileClient{stream}
	return x, nil
}

type RPC_SignFileClient interface {
	Send(*SignFileInput) error
	Recv() (*SignFileOutput, error)
	grpc.ClientStream
}

type rPCSignFileClient struct {
	grpc.ClientStream
}

func (x *rPCSignFileClient) Send(m *SignFileInput) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *rPCClient) SignStream(ctx context.Context, opts ...grpc.CallOption) (RPC_SignStreamClient, error) {
	stream, err := c.cc.NewStream(ctx, &_RPC_serviceDesc.Streams[1], "/service.RPC/SignStream", opts...)
	if err != nil {
		return nil, err
	}
	x := &rPCSignStreamClient{stream}
	return x, nil
}

type RPC_SignStreamClient interface {
	Send(*SignInput) error
	Recv() (*SignOutput, error)
	grpc.ClientStream
}

type rPCSignStreamClient struct {
	grpc.ClientStream
}

func (x *rPCSignStreamClient) Send(m *SignInput) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *rPCClient) Verify(ctx context.Context, in *VerifyRequest, opts ...grpc.CallOption) (*VerifyResponse, error) {
	out := new(VerifyResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/Verify", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) VerifyFile(ctx context.Context, opts ...grpc.CallOption) (RPC_VerifyFileClient, error) {
	stream, err := c.cc.NewStream(ctx, &_RPC_serviceDesc.Streams[2], "/service.RPC/VerifyFile", opts...)
	if err != nil {
		return nil, err
	}
	x := &rPCVerifyFileClient{stream}
	return x, nil
}

type RPC_VerifyFileClient interface {
	Send(*VerifyFileInput) error
	Recv() (*VerifyFileOutput, error)
	grpc.ClientStream
}

type rPCVerifyFileClient struct {
	grpc.ClientStream
}

func (x *rPCVerifyFileClient) Send(m *VerifyFileInput) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *rPCClient) VerifyStream(ctx context.Context, opts ...grpc.CallOption) (RPC_VerifyStreamClient, error) {
	stream, err := c.cc.NewStream(ctx, &_RPC_serviceDesc.Streams[3], "/service.RPC/VerifyStream", opts...)
	if err != nil {
		return nil, err
	}
	x := &rPCVerifyStreamClient{stream}
	return x, nil
}

type RPC_VerifyStreamClient interface {
	Send(*VerifyInput) error
	Recv() (*VerifyOutput, error)
	grpc.ClientStream
}

type rPCVerifyStreamClient struct {
	grpc.ClientStream
}

func (x *rPCVerifyStreamClient) Send(m *VerifyInput) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *rPCClient) VerifyDetached(ctx context.Context, in *VerifyDetachedRequest, opts ...grpc.CallOption) (*VerifyDetachedResponse, error) {
	out := new(VerifyDetachedResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/VerifyDetached", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) VerifyDetachedFile(ctx context.Context, opts ...grpc.CallOption) (RPC_VerifyDetachedFileClient, error) {
	stream, err := c.cc.NewStream(ctx, &_RPC_serviceDesc.Streams[4], "/service.RPC/VerifyDetachedFile", opts...)
	if err != nil {
		return nil, err
	}
	x := &rPCVerifyDetachedFileClient{stream}
	return x, nil
}

type RPC_VerifyDetachedFileClient interface {
	Send(*VerifyDetachedFileInput) error
	CloseAndRecv() (*VerifyDetachedResponse, error)
	grpc.ClientStream
}

type rPCVerifyDetachedFileClient struct {
	grpc.ClientStream
}

func (x *rPCVerifyDetachedFileClient) Send(m *VerifyDetachedFileInput) error {
	return x.ClientStream.SendMsg(m)
}

func (x *rPCVerifyDetachedFileClient) CloseAndRecv() (*VerifyDetachedResponse, error) {
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	m := new(VerifyDetachedResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *rPCClient) VerifyDetachedStream(ctx context.Context, opts ...grpc.CallOption) (RPC_VerifyDetachedStreamClient, error) {
	stream, err := c.cc.NewStream(ctx, &_RPC_serviceDesc.Streams[5], "/service.RPC/VerifyDetachedStream", opts...)
	if err != nil {
		return nil, err
	}
	x := &rPCVerifyDetachedStreamClient{stream}
	return x, nil
}

type RPC_VerifyDetachedStreamClient interface {
	Send(*VerifyDetachedInput) error
	CloseAndRecv() (*VerifyDetachedResponse, error)
	grpc.ClientStream
}

type rPCVerifyDetachedStreamClient struct {
	grpc.ClientStream
}

func (x *rPCVerifyDetachedStreamClient) Send(m *VerifyDetachedInput) error {
	return x.ClientStream.SendMsg(m)
}

func (x *rPCVerifyDetachedStreamClient) CloseAndRecv() (*VerifyDetachedResponse, error) {
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	m := new(VerifyDetachedResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *rPCClient) Encrypt(ctx context.Context, in *EncryptRequest, opts ...grpc.CallOption) (*EncryptResponse, error) {
	out := new(EncryptResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/Encrypt", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) EncryptStream(ctx context.Context, opts ...grpc.CallOption) (RPC_EncryptStreamClient, error) {
	stream, err := c.cc.NewStream(ctx, &_RPC_serviceDesc.Streams[6], "/service.RPC/EncryptStream", opts...)
	if err != nil {
		return nil, err
	}
	x := &rPCEncryptStreamClient{stream}
	return x, nil
}

type RPC_EncryptStreamClient interface {
	Send(*EncryptInput) error
	Recv() (*EncryptOutput, error)
	grpc.ClientStream
}

type rPCEncryptStreamClient struct {
	grpc.ClientStream
}

func (x *rPCEncryptStreamClient) Send(m *EncryptInput) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *rPCClient) EncryptFile(ctx context.Context, opts ...grpc.CallOption) (RPC_EncryptFileClient, error) {
	stream, err := c.cc.NewStream(ctx, &_RPC_serviceDesc.Streams[7], "/service.RPC/EncryptFile", opts...)
	if err != nil {
		return nil, err
	}
	x := &rPCEncryptFileClient{stream}
	return x, nil
}

type RPC_EncryptFileClient interface {
	Send(*EncryptFileInput) error
	Recv() (*EncryptFileOutput, error)
	grpc.ClientStream
}

type rPCEncryptFileClient struct {
	grpc.ClientStream
}

func (x *rPCEncryptFileClient) Send(m *EncryptFileInput) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *rPCClient) Decrypt(ctx context.Context, in *DecryptRequest, opts ...grpc.CallOption) (*DecryptResponse, error) {
	out := new(DecryptResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/Decrypt", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) DecryptStream(ctx context.Context, opts ...grpc.CallOption) (RPC_DecryptStreamClient, error) {
	stream, err := c.cc.NewStream(ctx, &_RPC_serviceDesc.Streams[8], "/service.RPC/DecryptStream", opts...)
	if err != nil {
		return nil, err
	}
	x := &rPCDecryptStreamClient{stream}
	return x, nil
}

type RPC_DecryptStreamClient interface {
	Send(*DecryptInput) error
	Recv() (*DecryptOutput, error)
	grpc.ClientStream
}

type rPCDecryptStreamClient struct {
	grpc.ClientStream
}

func (x *rPCDecryptStreamClient) Send(m *DecryptInput) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *rPCClient) DecryptFile(ctx context.Context, opts ...grpc.CallOption) (RPC_DecryptFileClient, error) {
	stream, err := c.cc.NewStream(ctx, &_RPC_serviceDesc.Streams[9], "/service.RPC/DecryptFile", opts...)
	if err != nil {
		return nil, err
	}
	x := &rPCDecryptFileClient{stream}
	return x, nil
}

type RPC_DecryptFileClient interface {
	Send(*DecryptFileInput) error
	Recv() (*DecryptFileOutput, error)
	grpc.ClientStream
}

type rPCDecryptFileClient struct {
	grpc.ClientStream
}

func (x *rPCDecryptFileClient) Send(m *DecryptFileInput) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *rPCClient) Sigchain(ctx context.Context, in *SigchainRequest, opts ...grpc.CallOption) (*SigchainResponse, error) {
	out := new(SigchainResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/Sigchain", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) Statement(ctx context.Context, in *StatementRequest, opts ...grpc.CallOption) (*StatementResponse, error) {
	out := new(StatementResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/Statement", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) StatementCreate(ctx context.Context, in *StatementCreateRequest, opts ...grpc.CallOption) (*StatementCreateResponse, error) {
	out := new(StatementCreateResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/StatementCreate", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) StatementRevoke(ctx context.Context, in *StatementRevokeRequest, opts ...grpc.CallOption) (*StatementRevokeResponse, error) {
	out := new(StatementRevokeResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/StatementRevoke", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) User(ctx context.Context, in *UserRequest, opts ...grpc.CallOption) (*UserResponse, error) {
	out := new(UserResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/User", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) UserSearch(ctx context.Context, in *UserSearchRequest, opts ...grpc.CallOption) (*UserSearchResponse, error) {
	out := new(UserSearchResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/UserSearch", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) UserService(ctx context.Context, in *UserServiceRequest, opts ...grpc.CallOption) (*UserServiceResponse, error) {
	out := new(UserServiceResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/UserService", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) UserSign(ctx context.Context, in *UserSignRequest, opts ...grpc.CallOption) (*UserSignResponse, error) {
	out := new(UserSignResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/UserSign", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) UserAdd(ctx context.Context, in *UserAddRequest, opts ...grpc.CallOption) (*UserAddResponse, error) {
	out := new(UserAddResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/UserAdd", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) Search(ctx context.Context, in *SearchRequest, opts ...grpc.CallOption) (*SearchResponse, error) {
	out := new(SearchResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/Search", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) Secret(ctx context.Context, in *SecretRequest, opts ...grpc.CallOption) (*SecretResponse, error) {
	out := new(SecretResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/Secret", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) SecretSave(ctx context.Context, in *SecretSaveRequest, opts ...grpc.CallOption) (*SecretSaveResponse, error) {
	out := new(SecretSaveResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/SecretSave", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) SecretRemove(ctx context.Context, in *SecretRemoveRequest, opts ...grpc.CallOption) (*SecretRemoveResponse, error) {
	out := new(SecretRemoveResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/SecretRemove", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) Secrets(ctx context.Context, in *SecretsRequest, opts ...grpc.CallOption) (*SecretsResponse, error) {
	out := new(SecretsResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/Secrets", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) Pull(ctx context.Context, in *PullRequest, opts ...grpc.CallOption) (*PullResponse, error) {
	out := new(PullResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/Pull", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) Push(ctx context.Context, in *PushRequest, opts ...grpc.CallOption) (*PushResponse, error) {
	out := new(PushResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/Push", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) Wormhole(ctx context.Context, opts ...grpc.CallOption) (RPC_WormholeClient, error) {
	stream, err := c.cc.NewStream(ctx, &_RPC_serviceDesc.Streams[10], "/service.RPC/Wormhole", opts...)
	if err != nil {
		return nil, err
	}
	x := &rPCWormholeClient{stream}
	return x, nil
}

type RPC_WormholeClient interface {
	Send(*WormholeInput) error
	Recv() (*WormholeOutput, error)
	grpc.ClientStream
}

type rPCWormholeClient struct {
	grpc.ClientStream
}

func (x *rPCWormholeClient) Send(m *WormholeInput) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *rPCClient) AuthSetup(ctx context.Context, in *AuthSetupRequest, opts ...grpc.CallOption) (*AuthSetupResponse, error) {
	out := new(AuthSetupResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/AuthSetup", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) AuthVault(ctx context.Context, in *AuthVaultRequest, opts ...grpc.CallOption) (*AuthVaultResponse, error) {
	out := new(AuthVaultResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/AuthVault", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) AuthUnlock(ctx context.Context, in *AuthUnlockRequest, opts ...grpc.CallOption) (*AuthUnlockResponse, error) {
	out := new(AuthUnlockResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/AuthUnlock", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) AuthLock(ctx context.Context, in *AuthLockRequest, opts ...grpc.CallOption) (*AuthLockResponse, error) {
	out := new(AuthLockResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/AuthLock", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) AuthReset(ctx context.Context, in *AuthResetRequest, opts ...grpc.CallOption) (*AuthResetResponse, error) {
	out := new(AuthResetResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/AuthReset", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) AuthRecover(ctx context.Context, in *AuthRecoverRequest, opts ...grpc.CallOption) (*AuthRecoverResponse, error) {
	out := new(AuthRecoverResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/AuthRecover", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) RuntimeStatus(ctx context.Context, in *RuntimeStatusRequest, opts ...grpc.CallOption) (*RuntimeStatusResponse, error) {
	out := new(RuntimeStatusResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/RuntimeStatus", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) Rand(ctx context.Context, in *RandRequest, opts ...grpc.CallOption) (*RandResponse, error) {
	out := new(RandResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/Rand", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) RandPassword(ctx context.Context, in *RandPasswordRequest, opts ...grpc.CallOption) (*RandPasswordResponse, error) {
	out := new(RandPasswordResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/RandPassword", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) AuthProvision(ctx context.Context, in *AuthProvisionRequest, opts ...grpc.CallOption) (*AuthProvisionResponse, error) {
	out := new(AuthProvisionResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/AuthProvision", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) AuthDeprovision(ctx context.Context, in *AuthDeprovisionRequest, opts ...grpc.CallOption) (*AuthDeprovisionResponse, error) {
	out := new(AuthDeprovisionResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/AuthDeprovision", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) AuthProvisions(ctx context.Context, in *AuthProvisionsRequest, opts ...grpc.CallOption) (*AuthProvisionsResponse, error) {
	out := new(AuthProvisionsResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/AuthProvisions", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) AuthPasswordChange(ctx context.Context, in *AuthPasswordChangeRequest, opts ...grpc.CallOption) (*AuthPasswordChangeResponse, error) {
	out := new(AuthPasswordChangeResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/AuthPasswordChange", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) VaultAuth(ctx context.Context, in *VaultAuthRequest, opts ...grpc.CallOption) (*VaultAuthResponse, error) {
	out := new(VaultAuthResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/VaultAuth", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) VaultSync(ctx context.Context, in *VaultSyncRequest, opts ...grpc.CallOption) (*VaultSyncResponse, error) {
	out := new(VaultSyncResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/VaultSync", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) VaultUnsync(ctx context.Context, in *VaultUnsyncRequest, opts ...grpc.CallOption) (*VaultUnsyncResponse, error) {
	out := new(VaultUnsyncResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/VaultUnsync", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) VaultStatus(ctx context.Context, in *VaultStatusRequest, opts ...grpc.CallOption) (*VaultStatusResponse, error) {
	out := new(VaultStatusResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/VaultStatus", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) VaultUpdate(ctx context.Context, in *VaultUpdateRequest, opts ...grpc.CallOption) (*VaultUpdateResponse, error) {
	out := new(VaultUpdateResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/VaultUpdate", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) Collections(ctx context.Context, in *CollectionsRequest, opts ...grpc.CallOption) (*CollectionsResponse, error) {
	out := new(CollectionsResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/Collections", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) Documents(ctx context.Context, in *DocumentsRequest, opts ...grpc.CallOption) (*DocumentsResponse, error) {
	out := new(DocumentsResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/Documents", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) DocumentDelete(ctx context.Context, in *DocumentDeleteRequest, opts ...grpc.CallOption) (*DocumentDeleteResponse, error) {
	out := new(DocumentDeleteResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/DocumentDelete", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) ConfigGet(ctx context.Context, in *ConfigGetRequest, opts ...grpc.CallOption) (*ConfigGetResponse, error) {
	out := new(ConfigGetResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/ConfigGet", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) ConfigSet(ctx context.Context, in *ConfigSetRequest, opts ...grpc.CallOption) (*ConfigSetResponse, error) {
	out := new(ConfigSetResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/ConfigSet", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) AdminSignURL(ctx context.Context, in *AdminSignURLRequest, opts ...grpc.CallOption) (*AdminSignURLResponse, error) {
	out := new(AdminSignURLResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/AdminSignURL", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) AdminCheck(ctx context.Context, in *AdminCheckRequest, opts ...grpc.CallOption) (*AdminCheckResponse, error) {
	out := new(AdminCheckResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/AdminCheck", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) Channels(ctx context.Context, in *ChannelsRequest, opts ...grpc.CallOption) (*ChannelsResponse, error) {
	out := new(ChannelsResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/Channels", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) ChannelCreate(ctx context.Context, in *ChannelCreateRequest, opts ...grpc.CallOption) (*ChannelCreateResponse, error) {
	out := new(ChannelCreateResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/ChannelCreate", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) ChannelInvite(ctx context.Context, in *ChannelInviteRequest, opts ...grpc.CallOption) (*ChannelInviteResponse, error) {
	out := new(ChannelInviteResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/ChannelInvite", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) ChannelLeave(ctx context.Context, in *ChannelLeaveRequest, opts ...grpc.CallOption) (*ChannelLeaveResponse, error) {
	out := new(ChannelLeaveResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/ChannelLeave", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) ChannelRead(ctx context.Context, in *ChannelReadRequest, opts ...grpc.CallOption) (*ChannelReadResponse, error) {
	out := new(ChannelReadResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/ChannelRead", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) Follow(ctx context.Context, in *FollowRequest, opts ...grpc.CallOption) (*FollowResponse, error) {
	out := new(FollowResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/Follow", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) Follows(ctx context.Context, in *FollowsRequest, opts ...grpc.CallOption) (*FollowsResponse, error) {
	out := new(FollowsResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/Follows", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) MessagePrepare(ctx context.Context, in *MessagePrepareRequest, opts ...grpc.CallOption) (*MessagePrepareResponse, error) {
	out := new(MessagePrepareResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/MessagePrepare", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) MessageCreate(ctx context.Context, in *MessageCreateRequest, opts ...grpc.CallOption) (*MessageCreateResponse, error) {
	out := new(MessageCreateResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/MessageCreate", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) Messages(ctx context.Context, in *MessagesRequest, opts ...grpc.CallOption) (*MessagesResponse, error) {
	out := new(MessagesResponse)
	err := c.cc.Invoke(ctx, "/service.RPC/Messages", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCClient) Relay(ctx context.Context, in *RelayRequest, opts ...grpc.CallOption) (RPC_RelayClient, error) {
	stream, err := c.cc.NewStream(ctx, &_RPC_serviceDesc.Streams[11], "/service.RPC/Relay", opts...)
	if err != nil {
		return nil, err
	}
	x := &rPCRelayClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type RPC_RelayClient interface {
	Recv() (*RelayOutput, error)
	grpc.ClientStream
}

type rPCRelayClient struct {
	grpc.ClientStream
}

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

// RPCServer is the server API for RPC service.
// All implementations must embed UnimplementedRPCServer
// for forward compatibility
type RPCServer interface {
	KeyGenerate(context.Context, *KeyGenerateRequest) (*KeyGenerateResponse, error)
	Keys(context.Context, *KeysRequest) (*KeysResponse, error)
	Key(context.Context, *KeyRequest) (*KeyResponse, error)
	KeyImport(context.Context, *KeyImportRequest) (*KeyImportResponse, error)
	KeyExport(context.Context, *KeyExportRequest) (*KeyExportResponse, error)
	KeyRemove(context.Context, *KeyRemoveRequest) (*KeyRemoveResponse, error)
	Sign(context.Context, *SignRequest) (*SignResponse, error)
	SignFile(RPC_SignFileServer) error
	SignStream(RPC_SignStreamServer) error
	Verify(context.Context, *VerifyRequest) (*VerifyResponse, error)
	VerifyFile(RPC_VerifyFileServer) error
	VerifyStream(RPC_VerifyStreamServer) error
	VerifyDetached(context.Context, *VerifyDetachedRequest) (*VerifyDetachedResponse, error)
	VerifyDetachedFile(RPC_VerifyDetachedFileServer) error
	VerifyDetachedStream(RPC_VerifyDetachedStreamServer) error
	Encrypt(context.Context, *EncryptRequest) (*EncryptResponse, error)
	EncryptStream(RPC_EncryptStreamServer) error
	EncryptFile(RPC_EncryptFileServer) error
	Decrypt(context.Context, *DecryptRequest) (*DecryptResponse, error)
	DecryptStream(RPC_DecryptStreamServer) error
	DecryptFile(RPC_DecryptFileServer) error
	Sigchain(context.Context, *SigchainRequest) (*SigchainResponse, error)
	Statement(context.Context, *StatementRequest) (*StatementResponse, error)
	StatementCreate(context.Context, *StatementCreateRequest) (*StatementCreateResponse, error)
	StatementRevoke(context.Context, *StatementRevokeRequest) (*StatementRevokeResponse, error)
	User(context.Context, *UserRequest) (*UserResponse, error)
	UserSearch(context.Context, *UserSearchRequest) (*UserSearchResponse, error)
	UserService(context.Context, *UserServiceRequest) (*UserServiceResponse, error)
	UserSign(context.Context, *UserSignRequest) (*UserSignResponse, error)
	UserAdd(context.Context, *UserAddRequest) (*UserAddResponse, error)
	Search(context.Context, *SearchRequest) (*SearchResponse, error)
	Secret(context.Context, *SecretRequest) (*SecretResponse, error)
	SecretSave(context.Context, *SecretSaveRequest) (*SecretSaveResponse, error)
	SecretRemove(context.Context, *SecretRemoveRequest) (*SecretRemoveResponse, error)
	Secrets(context.Context, *SecretsRequest) (*SecretsResponse, error)
	Pull(context.Context, *PullRequest) (*PullResponse, error)
	Push(context.Context, *PushRequest) (*PushResponse, error)
	Wormhole(RPC_WormholeServer) error
	// These requests do not need auth.
	// BEGIN NO AUTH
	AuthSetup(context.Context, *AuthSetupRequest) (*AuthSetupResponse, error)
	AuthVault(context.Context, *AuthVaultRequest) (*AuthVaultResponse, error)
	AuthUnlock(context.Context, *AuthUnlockRequest) (*AuthUnlockResponse, error)
	AuthLock(context.Context, *AuthLockRequest) (*AuthLockResponse, error)
	AuthReset(context.Context, *AuthResetRequest) (*AuthResetResponse, error)
	AuthRecover(context.Context, *AuthRecoverRequest) (*AuthRecoverResponse, error)
	RuntimeStatus(context.Context, *RuntimeStatusRequest) (*RuntimeStatusResponse, error)
	Rand(context.Context, *RandRequest) (*RandResponse, error)
	RandPassword(context.Context, *RandPasswordRequest) (*RandPasswordResponse, error)
	// Auth (edit)
	AuthProvision(context.Context, *AuthProvisionRequest) (*AuthProvisionResponse, error)
	AuthDeprovision(context.Context, *AuthDeprovisionRequest) (*AuthDeprovisionResponse, error)
	AuthProvisions(context.Context, *AuthProvisionsRequest) (*AuthProvisionsResponse, error)
	AuthPasswordChange(context.Context, *AuthPasswordChangeRequest) (*AuthPasswordChangeResponse, error)
	// Vault
	VaultAuth(context.Context, *VaultAuthRequest) (*VaultAuthResponse, error)
	VaultSync(context.Context, *VaultSyncRequest) (*VaultSyncResponse, error)
	VaultUnsync(context.Context, *VaultUnsyncRequest) (*VaultUnsyncResponse, error)
	VaultStatus(context.Context, *VaultStatusRequest) (*VaultStatusResponse, error)
	VaultUpdate(context.Context, *VaultUpdateRequest) (*VaultUpdateResponse, error)
	// DB
	Collections(context.Context, *CollectionsRequest) (*CollectionsResponse, error)
	Documents(context.Context, *DocumentsRequest) (*DocumentsResponse, error)
	DocumentDelete(context.Context, *DocumentDeleteRequest) (*DocumentDeleteResponse, error)
	// Config
	ConfigGet(context.Context, *ConfigGetRequest) (*ConfigGetResponse, error)
	ConfigSet(context.Context, *ConfigSetRequest) (*ConfigSetResponse, error)
	// Admin
	AdminSignURL(context.Context, *AdminSignURLRequest) (*AdminSignURLResponse, error)
	AdminCheck(context.Context, *AdminCheckRequest) (*AdminCheckResponse, error)
	// Channels
	Channels(context.Context, *ChannelsRequest) (*ChannelsResponse, error)
	ChannelCreate(context.Context, *ChannelCreateRequest) (*ChannelCreateResponse, error)
	ChannelInvite(context.Context, *ChannelInviteRequest) (*ChannelInviteResponse, error)
	ChannelLeave(context.Context, *ChannelLeaveRequest) (*ChannelLeaveResponse, error)
	ChannelRead(context.Context, *ChannelReadRequest) (*ChannelReadResponse, error)
	// Follow
	Follow(context.Context, *FollowRequest) (*FollowResponse, error)
	Follows(context.Context, *FollowsRequest) (*FollowsResponse, error)
	// Messages
	MessagePrepare(context.Context, *MessagePrepareRequest) (*MessagePrepareResponse, error)
	MessageCreate(context.Context, *MessageCreateRequest) (*MessageCreateResponse, error)
	Messages(context.Context, *MessagesRequest) (*MessagesResponse, error)
	// Relay
	Relay(*RelayRequest, RPC_RelayServer) error
	mustEmbedUnimplementedRPCServer()
}

// UnimplementedRPCServer must be embedded to have forward compatible implementations.
type UnimplementedRPCServer struct {
}

func (*UnimplementedRPCServer) KeyGenerate(context.Context, *KeyGenerateRequest) (*KeyGenerateResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method KeyGenerate not implemented")
}
func (*UnimplementedRPCServer) Keys(context.Context, *KeysRequest) (*KeysResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Keys not implemented")
}
func (*UnimplementedRPCServer) Key(context.Context, *KeyRequest) (*KeyResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Key not implemented")
}
func (*UnimplementedRPCServer) KeyImport(context.Context, *KeyImportRequest) (*KeyImportResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method KeyImport not implemented")
}
func (*UnimplementedRPCServer) KeyExport(context.Context, *KeyExportRequest) (*KeyExportResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method KeyExport not implemented")
}
func (*UnimplementedRPCServer) KeyRemove(context.Context, *KeyRemoveRequest) (*KeyRemoveResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method KeyRemove not implemented")
}
func (*UnimplementedRPCServer) Sign(context.Context, *SignRequest) (*SignResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Sign not implemented")
}
func (*UnimplementedRPCServer) SignFile(RPC_SignFileServer) error {
	return status.Errorf(codes.Unimplemented, "method SignFile not implemented")
}
func (*UnimplementedRPCServer) SignStream(RPC_SignStreamServer) error {
	return status.Errorf(codes.Unimplemented, "method SignStream not implemented")
}
func (*UnimplementedRPCServer) Verify(context.Context, *VerifyRequest) (*VerifyResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Verify not implemented")
}
func (*UnimplementedRPCServer) VerifyFile(RPC_VerifyFileServer) error {
	return status.Errorf(codes.Unimplemented, "method VerifyFile not implemented")
}
func (*UnimplementedRPCServer) VerifyStream(RPC_VerifyStreamServer) error {
	return status.Errorf(codes.Unimplemented, "method VerifyStream not implemented")
}
func (*UnimplementedRPCServer) VerifyDetached(context.Context, *VerifyDetachedRequest) (*VerifyDetachedResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method VerifyDetached not implemented")
}
func (*UnimplementedRPCServer) VerifyDetachedFile(RPC_VerifyDetachedFileServer) error {
	return status.Errorf(codes.Unimplemented, "method VerifyDetachedFile not implemented")
}
func (*UnimplementedRPCServer) VerifyDetachedStream(RPC_VerifyDetachedStreamServer) error {
	return status.Errorf(codes.Unimplemented, "method VerifyDetachedStream not implemented")
}
func (*UnimplementedRPCServer) Encrypt(context.Context, *EncryptRequest) (*EncryptResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Encrypt not implemented")
}
func (*UnimplementedRPCServer) EncryptStream(RPC_EncryptStreamServer) error {
	return status.Errorf(codes.Unimplemented, "method EncryptStream not implemented")
}
func (*UnimplementedRPCServer) EncryptFile(RPC_EncryptFileServer) error {
	return status.Errorf(codes.Unimplemented, "method EncryptFile not implemented")
}
func (*UnimplementedRPCServer) Decrypt(context.Context, *DecryptRequest) (*DecryptResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Decrypt not implemented")
}
func (*UnimplementedRPCServer) DecryptStream(RPC_DecryptStreamServer) error {
	return status.Errorf(codes.Unimplemented, "method DecryptStream not implemented")
}
func (*UnimplementedRPCServer) DecryptFile(RPC_DecryptFileServer) error {
	return status.Errorf(codes.Unimplemented, "method DecryptFile not implemented")
}
func (*UnimplementedRPCServer) Sigchain(context.Context, *SigchainRequest) (*SigchainResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Sigchain not implemented")
}
func (*UnimplementedRPCServer) Statement(context.Context, *StatementRequest) (*StatementResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Statement not implemented")
}
func (*UnimplementedRPCServer) StatementCreate(context.Context, *StatementCreateRequest) (*StatementCreateResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StatementCreate not implemented")
}
func (*UnimplementedRPCServer) StatementRevoke(context.Context, *StatementRevokeRequest) (*StatementRevokeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StatementRevoke not implemented")
}
func (*UnimplementedRPCServer) User(context.Context, *UserRequest) (*UserResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method User not implemented")
}
func (*UnimplementedRPCServer) UserSearch(context.Context, *UserSearchRequest) (*UserSearchResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UserSearch not implemented")
}
func (*UnimplementedRPCServer) UserService(context.Context, *UserServiceRequest) (*UserServiceResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UserService not implemented")
}
func (*UnimplementedRPCServer) UserSign(context.Context, *UserSignRequest) (*UserSignResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UserSign not implemented")
}
func (*UnimplementedRPCServer) UserAdd(context.Context, *UserAddRequest) (*UserAddResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UserAdd not implemented")
}
func (*UnimplementedRPCServer) Search(context.Context, *SearchRequest) (*SearchResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Search not implemented")
}
func (*UnimplementedRPCServer) Secret(context.Context, *SecretRequest) (*SecretResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Secret not implemented")
}
func (*UnimplementedRPCServer) SecretSave(context.Context, *SecretSaveRequest) (*SecretSaveResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SecretSave not implemented")
}
func (*UnimplementedRPCServer) SecretRemove(context.Context, *SecretRemoveRequest) (*SecretRemoveResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SecretRemove not implemented")
}
func (*UnimplementedRPCServer) Secrets(context.Context, *SecretsRequest) (*SecretsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Secrets not implemented")
}
func (*UnimplementedRPCServer) Pull(context.Context, *PullRequest) (*PullResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Pull not implemented")
}
func (*UnimplementedRPCServer) Push(context.Context, *PushRequest) (*PushResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Push not implemented")
}
func (*UnimplementedRPCServer) Wormhole(RPC_WormholeServer) error {
	return status.Errorf(codes.Unimplemented, "method Wormhole not implemented")
}
func (*UnimplementedRPCServer) AuthSetup(context.Context, *AuthSetupRequest) (*AuthSetupResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AuthSetup not implemented")
}
func (*UnimplementedRPCServer) AuthVault(context.Context, *AuthVaultRequest) (*AuthVaultResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AuthVault not implemented")
}
func (*UnimplementedRPCServer) AuthUnlock(context.Context, *AuthUnlockRequest) (*AuthUnlockResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AuthUnlock not implemented")
}
func (*UnimplementedRPCServer) AuthLock(context.Context, *AuthLockRequest) (*AuthLockResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AuthLock not implemented")
}
func (*UnimplementedRPCServer) AuthReset(context.Context, *AuthResetRequest) (*AuthResetResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AuthReset not implemented")
}
func (*UnimplementedRPCServer) AuthRecover(context.Context, *AuthRecoverRequest) (*AuthRecoverResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AuthRecover not implemented")
}
func (*UnimplementedRPCServer) RuntimeStatus(context.Context, *RuntimeStatusRequest) (*RuntimeStatusResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RuntimeStatus not implemented")
}
func (*UnimplementedRPCServer) Rand(context.Context, *RandRequest) (*RandResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Rand not implemented")
}
func (*UnimplementedRPCServer) RandPassword(context.Context, *RandPasswordRequest) (*RandPasswordResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RandPassword not implemented")
}
func (*UnimplementedRPCServer) AuthProvision(context.Context, *AuthProvisionRequest) (*AuthProvisionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AuthProvision not implemented")
}
func (*UnimplementedRPCServer) AuthDeprovision(context.Context, *AuthDeprovisionRequest) (*AuthDeprovisionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AuthDeprovision not implemented")
}
func (*UnimplementedRPCServer) AuthProvisions(context.Context, *AuthProvisionsRequest) (*AuthProvisionsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AuthProvisions not implemented")
}
func (*UnimplementedRPCServer) AuthPasswordChange(context.Context, *AuthPasswordChangeRequest) (*AuthPasswordChangeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AuthPasswordChange not implemented")
}
func (*UnimplementedRPCServer) VaultAuth(context.Context, *VaultAuthRequest) (*VaultAuthResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method VaultAuth not implemented")
}
func (*UnimplementedRPCServer) VaultSync(context.Context, *VaultSyncRequest) (*VaultSyncResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method VaultSync not implemented")
}
func (*UnimplementedRPCServer) VaultUnsync(context.Context, *VaultUnsyncRequest) (*VaultUnsyncResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method VaultUnsync not implemented")
}
func (*UnimplementedRPCServer) VaultStatus(context.Context, *VaultStatusRequest) (*VaultStatusResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method VaultStatus not implemented")
}
func (*UnimplementedRPCServer) VaultUpdate(context.Context, *VaultUpdateRequest) (*VaultUpdateResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method VaultUpdate not implemented")
}
func (*UnimplementedRPCServer) Collections(context.Context, *CollectionsRequest) (*CollectionsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Collections not implemented")
}
func (*UnimplementedRPCServer) Documents(context.Context, *DocumentsRequest) (*DocumentsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Documents not implemented")
}
func (*UnimplementedRPCServer) DocumentDelete(context.Context, *DocumentDeleteRequest) (*DocumentDeleteResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DocumentDelete not implemented")
}
func (*UnimplementedRPCServer) ConfigGet(context.Context, *ConfigGetRequest) (*ConfigGetResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ConfigGet not implemented")
}
func (*UnimplementedRPCServer) ConfigSet(context.Context, *ConfigSetRequest) (*ConfigSetResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ConfigSet not implemented")
}
func (*UnimplementedRPCServer) AdminSignURL(context.Context, *AdminSignURLRequest) (*AdminSignURLResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AdminSignURL not implemented")
}
func (*UnimplementedRPCServer) AdminCheck(context.Context, *AdminCheckRequest) (*AdminCheckResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AdminCheck not implemented")
}
func (*UnimplementedRPCServer) Channels(context.Context, *ChannelsRequest) (*ChannelsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Channels not implemented")
}
func (*UnimplementedRPCServer) ChannelCreate(context.Context, *ChannelCreateRequest) (*ChannelCreateResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ChannelCreate not implemented")
}
func (*UnimplementedRPCServer) ChannelInvite(context.Context, *ChannelInviteRequest) (*ChannelInviteResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ChannelInvite not implemented")
}
func (*UnimplementedRPCServer) ChannelLeave(context.Context, *ChannelLeaveRequest) (*ChannelLeaveResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ChannelLeave not implemented")
}
func (*UnimplementedRPCServer) ChannelRead(context.Context, *ChannelReadRequest) (*ChannelReadResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ChannelRead not implemented")
}
func (*UnimplementedRPCServer) Follow(context.Context, *FollowRequest) (*FollowResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Follow not implemented")
}
func (*UnimplementedRPCServer) Follows(context.Context, *FollowsRequest) (*FollowsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Follows not implemented")
}
func (*UnimplementedRPCServer) MessagePrepare(context.Context, *MessagePrepareRequest) (*MessagePrepareResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MessagePrepare not implemented")
}
func (*UnimplementedRPCServer) MessageCreate(context.Context, *MessageCreateRequest) (*MessageCreateResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MessageCreate not implemented")
}
func (*UnimplementedRPCServer) Messages(context.Context, *MessagesRequest) (*MessagesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Messages not implemented")
}
func (*UnimplementedRPCServer) Relay(*RelayRequest, RPC_RelayServer) error {
	return status.Errorf(codes.Unimplemented, "method Relay not implemented")
}
func (*UnimplementedRPCServer) mustEmbedUnimplementedRPCServer() {}

func RegisterRPCServer(s *grpc.Server, srv RPCServer) {
	s.RegisterService(&_RPC_serviceDesc, srv)
}

func _RPC_KeyGenerate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(KeyGenerateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).KeyGenerate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/KeyGenerate",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).KeyGenerate(ctx, req.(*KeyGenerateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_Keys_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(KeysRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).Keys(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/Keys",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).Keys(ctx, req.(*KeysRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_Key_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(KeyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).Key(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/Key",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).Key(ctx, req.(*KeyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_KeyImport_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(KeyImportRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).KeyImport(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/KeyImport",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).KeyImport(ctx, req.(*KeyImportRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_KeyExport_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(KeyExportRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).KeyExport(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/KeyExport",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).KeyExport(ctx, req.(*KeyExportRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_KeyRemove_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(KeyRemoveRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).KeyRemove(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/KeyRemove",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).KeyRemove(ctx, req.(*KeyRemoveRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_Sign_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SignRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).Sign(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/Sign",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).Sign(ctx, req.(*SignRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_SignFile_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(RPCServer).SignFile(&rPCSignFileServer{stream})
}

type RPC_SignFileServer interface {
	Send(*SignFileOutput) error
	Recv() (*SignFileInput, error)
	grpc.ServerStream
}

type rPCSignFileServer struct {
	grpc.ServerStream
}

func (x *rPCSignFileServer) Send(m *SignFileOutput) error {
	return x.ServerStream.SendMsg(m)
}

func (x *rPCSignFileServer) Recv() (*SignFileInput, error) {
	m := new(SignFileInput)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _RPC_SignStream_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(RPCServer).SignStream(&rPCSignStreamServer{stream})
}

type RPC_SignStreamServer interface {
	Send(*SignOutput) error
	Recv() (*SignInput, error)
	grpc.ServerStream
}

type rPCSignStreamServer struct {
	grpc.ServerStream
}

func (x *rPCSignStreamServer) Send(m *SignOutput) error {
	return x.ServerStream.SendMsg(m)
}

func (x *rPCSignStreamServer) Recv() (*SignInput, error) {
	m := new(SignInput)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _RPC_Verify_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(VerifyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).Verify(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/Verify",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).Verify(ctx, req.(*VerifyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_VerifyFile_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(RPCServer).VerifyFile(&rPCVerifyFileServer{stream})
}

type RPC_VerifyFileServer interface {
	Send(*VerifyFileOutput) error
	Recv() (*VerifyFileInput, error)
	grpc.ServerStream
}

type rPCVerifyFileServer struct {
	grpc.ServerStream
}

func (x *rPCVerifyFileServer) Send(m *VerifyFileOutput) error {
	return x.ServerStream.SendMsg(m)
}

func (x *rPCVerifyFileServer) Recv() (*VerifyFileInput, error) {
	m := new(VerifyFileInput)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _RPC_VerifyStream_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(RPCServer).VerifyStream(&rPCVerifyStreamServer{stream})
}

type RPC_VerifyStreamServer interface {
	Send(*VerifyOutput) error
	Recv() (*VerifyInput, error)
	grpc.ServerStream
}

type rPCVerifyStreamServer struct {
	grpc.ServerStream
}

func (x *rPCVerifyStreamServer) Send(m *VerifyOutput) error {
	return x.ServerStream.SendMsg(m)
}

func (x *rPCVerifyStreamServer) Recv() (*VerifyInput, error) {
	m := new(VerifyInput)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _RPC_VerifyDetached_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(VerifyDetachedRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).VerifyDetached(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/VerifyDetached",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).VerifyDetached(ctx, req.(*VerifyDetachedRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_VerifyDetachedFile_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(RPCServer).VerifyDetachedFile(&rPCVerifyDetachedFileServer{stream})
}

type RPC_VerifyDetachedFileServer interface {
	SendAndClose(*VerifyDetachedResponse) error
	Recv() (*VerifyDetachedFileInput, error)
	grpc.ServerStream
}

type rPCVerifyDetachedFileServer struct {
	grpc.ServerStream
}

func (x *rPCVerifyDetachedFileServer) SendAndClose(m *VerifyDetachedResponse) error {
	return x.ServerStream.SendMsg(m)
}

func (x *rPCVerifyDetachedFileServer) Recv() (*VerifyDetachedFileInput, error) {
	m := new(VerifyDetachedFileInput)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _RPC_VerifyDetachedStream_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(RPCServer).VerifyDetachedStream(&rPCVerifyDetachedStreamServer{stream})
}

type RPC_VerifyDetachedStreamServer interface {
	SendAndClose(*VerifyDetachedResponse) error
	Recv() (*VerifyDetachedInput, error)
	grpc.ServerStream
}

type rPCVerifyDetachedStreamServer struct {
	grpc.ServerStream
}

func (x *rPCVerifyDetachedStreamServer) SendAndClose(m *VerifyDetachedResponse) error {
	return x.ServerStream.SendMsg(m)
}

func (x *rPCVerifyDetachedStreamServer) Recv() (*VerifyDetachedInput, error) {
	m := new(VerifyDetachedInput)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _RPC_Encrypt_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EncryptRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).Encrypt(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/Encrypt",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).Encrypt(ctx, req.(*EncryptRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_EncryptStream_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(RPCServer).EncryptStream(&rPCEncryptStreamServer{stream})
}

type RPC_EncryptStreamServer interface {
	Send(*EncryptOutput) error
	Recv() (*EncryptInput, error)
	grpc.ServerStream
}

type rPCEncryptStreamServer struct {
	grpc.ServerStream
}

func (x *rPCEncryptStreamServer) Send(m *EncryptOutput) error {
	return x.ServerStream.SendMsg(m)
}

func (x *rPCEncryptStreamServer) Recv() (*EncryptInput, error) {
	m := new(EncryptInput)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _RPC_EncryptFile_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(RPCServer).EncryptFile(&rPCEncryptFileServer{stream})
}

type RPC_EncryptFileServer interface {
	Send(*EncryptFileOutput) error
	Recv() (*EncryptFileInput, error)
	grpc.ServerStream
}

type rPCEncryptFileServer struct {
	grpc.ServerStream
}

func (x *rPCEncryptFileServer) Send(m *EncryptFileOutput) error {
	return x.ServerStream.SendMsg(m)
}

func (x *rPCEncryptFileServer) Recv() (*EncryptFileInput, error) {
	m := new(EncryptFileInput)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _RPC_Decrypt_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DecryptRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).Decrypt(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/Decrypt",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).Decrypt(ctx, req.(*DecryptRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_DecryptStream_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(RPCServer).DecryptStream(&rPCDecryptStreamServer{stream})
}

type RPC_DecryptStreamServer interface {
	Send(*DecryptOutput) error
	Recv() (*DecryptInput, error)
	grpc.ServerStream
}

type rPCDecryptStreamServer struct {
	grpc.ServerStream
}

func (x *rPCDecryptStreamServer) Send(m *DecryptOutput) error {
	return x.ServerStream.SendMsg(m)
}

func (x *rPCDecryptStreamServer) Recv() (*DecryptInput, error) {
	m := new(DecryptInput)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _RPC_DecryptFile_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(RPCServer).DecryptFile(&rPCDecryptFileServer{stream})
}

type RPC_DecryptFileServer interface {
	Send(*DecryptFileOutput) error
	Recv() (*DecryptFileInput, error)
	grpc.ServerStream
}

type rPCDecryptFileServer struct {
	grpc.ServerStream
}

func (x *rPCDecryptFileServer) Send(m *DecryptFileOutput) error {
	return x.ServerStream.SendMsg(m)
}

func (x *rPCDecryptFileServer) Recv() (*DecryptFileInput, error) {
	m := new(DecryptFileInput)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _RPC_Sigchain_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SigchainRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).Sigchain(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/Sigchain",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).Sigchain(ctx, req.(*SigchainRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_Statement_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StatementRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).Statement(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/Statement",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).Statement(ctx, req.(*StatementRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_StatementCreate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StatementCreateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).StatementCreate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/StatementCreate",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).StatementCreate(ctx, req.(*StatementCreateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_StatementRevoke_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StatementRevokeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).StatementRevoke(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/StatementRevoke",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).StatementRevoke(ctx, req.(*StatementRevokeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_User_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UserRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).User(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/User",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).User(ctx, req.(*UserRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_UserSearch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UserSearchRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).UserSearch(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/UserSearch",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).UserSearch(ctx, req.(*UserSearchRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_UserService_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UserServiceRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).UserService(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/UserService",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).UserService(ctx, req.(*UserServiceRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_UserSign_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UserSignRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).UserSign(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/UserSign",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).UserSign(ctx, req.(*UserSignRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_UserAdd_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UserAddRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).UserAdd(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/UserAdd",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).UserAdd(ctx, req.(*UserAddRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_Search_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SearchRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).Search(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/Search",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).Search(ctx, req.(*SearchRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_Secret_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SecretRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).Secret(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/Secret",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).Secret(ctx, req.(*SecretRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_SecretSave_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SecretSaveRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).SecretSave(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/SecretSave",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).SecretSave(ctx, req.(*SecretSaveRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_SecretRemove_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SecretRemoveRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).SecretRemove(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/SecretRemove",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).SecretRemove(ctx, req.(*SecretRemoveRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_Secrets_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SecretsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).Secrets(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/Secrets",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).Secrets(ctx, req.(*SecretsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_Pull_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PullRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).Pull(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/Pull",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).Pull(ctx, req.(*PullRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_Push_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PushRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).Push(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/Push",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).Push(ctx, req.(*PushRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_Wormhole_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(RPCServer).Wormhole(&rPCWormholeServer{stream})
}

type RPC_WormholeServer interface {
	Send(*WormholeOutput) error
	Recv() (*WormholeInput, error)
	grpc.ServerStream
}

type rPCWormholeServer struct {
	grpc.ServerStream
}

func (x *rPCWormholeServer) Send(m *WormholeOutput) error {
	return x.ServerStream.SendMsg(m)
}

func (x *rPCWormholeServer) Recv() (*WormholeInput, error) {
	m := new(WormholeInput)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _RPC_AuthSetup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AuthSetupRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).AuthSetup(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/AuthSetup",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).AuthSetup(ctx, req.(*AuthSetupRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_AuthVault_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AuthVaultRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).AuthVault(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/AuthVault",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).AuthVault(ctx, req.(*AuthVaultRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_AuthUnlock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AuthUnlockRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).AuthUnlock(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/AuthUnlock",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).AuthUnlock(ctx, req.(*AuthUnlockRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_AuthLock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AuthLockRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).AuthLock(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/AuthLock",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).AuthLock(ctx, req.(*AuthLockRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_AuthReset_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AuthResetRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).AuthReset(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/AuthReset",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).AuthReset(ctx, req.(*AuthResetRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_AuthRecover_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AuthRecoverRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).AuthRecover(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/AuthRecover",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).AuthRecover(ctx, req.(*AuthRecoverRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_RuntimeStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RuntimeStatusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).RuntimeStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/RuntimeStatus",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).RuntimeStatus(ctx, req.(*RuntimeStatusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_Rand_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RandRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).Rand(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/Rand",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).Rand(ctx, req.(*RandRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_RandPassword_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RandPasswordRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).RandPassword(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/RandPassword",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).RandPassword(ctx, req.(*RandPasswordRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_AuthProvision_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AuthProvisionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).AuthProvision(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/AuthProvision",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).AuthProvision(ctx, req.(*AuthProvisionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_AuthDeprovision_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AuthDeprovisionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).AuthDeprovision(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/AuthDeprovision",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).AuthDeprovision(ctx, req.(*AuthDeprovisionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_AuthProvisions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AuthProvisionsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).AuthProvisions(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/AuthProvisions",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).AuthProvisions(ctx, req.(*AuthProvisionsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_AuthPasswordChange_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AuthPasswordChangeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).AuthPasswordChange(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/AuthPasswordChange",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).AuthPasswordChange(ctx, req.(*AuthPasswordChangeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_VaultAuth_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(VaultAuthRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).VaultAuth(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/VaultAuth",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).VaultAuth(ctx, req.(*VaultAuthRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_VaultSync_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(VaultSyncRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).VaultSync(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/VaultSync",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).VaultSync(ctx, req.(*VaultSyncRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_VaultUnsync_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(VaultUnsyncRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).VaultUnsync(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/VaultUnsync",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).VaultUnsync(ctx, req.(*VaultUnsyncRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_VaultStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(VaultStatusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).VaultStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/VaultStatus",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).VaultStatus(ctx, req.(*VaultStatusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_VaultUpdate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(VaultUpdateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).VaultUpdate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/VaultUpdate",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).VaultUpdate(ctx, req.(*VaultUpdateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_Collections_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CollectionsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).Collections(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/Collections",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).Collections(ctx, req.(*CollectionsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_Documents_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DocumentsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).Documents(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/Documents",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).Documents(ctx, req.(*DocumentsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_DocumentDelete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DocumentDeleteRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).DocumentDelete(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/DocumentDelete",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).DocumentDelete(ctx, req.(*DocumentDeleteRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_ConfigGet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ConfigGetRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).ConfigGet(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/ConfigGet",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).ConfigGet(ctx, req.(*ConfigGetRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_ConfigSet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ConfigSetRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).ConfigSet(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/ConfigSet",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).ConfigSet(ctx, req.(*ConfigSetRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_AdminSignURL_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AdminSignURLRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).AdminSignURL(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/AdminSignURL",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).AdminSignURL(ctx, req.(*AdminSignURLRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_AdminCheck_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AdminCheckRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).AdminCheck(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/AdminCheck",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).AdminCheck(ctx, req.(*AdminCheckRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_Channels_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ChannelsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).Channels(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/Channels",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).Channels(ctx, req.(*ChannelsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_ChannelCreate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ChannelCreateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).ChannelCreate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/ChannelCreate",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).ChannelCreate(ctx, req.(*ChannelCreateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_ChannelInvite_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ChannelInviteRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).ChannelInvite(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/ChannelInvite",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).ChannelInvite(ctx, req.(*ChannelInviteRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_ChannelLeave_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ChannelLeaveRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).ChannelLeave(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/ChannelLeave",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).ChannelLeave(ctx, req.(*ChannelLeaveRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_ChannelRead_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ChannelReadRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).ChannelRead(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/ChannelRead",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).ChannelRead(ctx, req.(*ChannelReadRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_Follow_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(FollowRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).Follow(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/Follow",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).Follow(ctx, req.(*FollowRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_Follows_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(FollowsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).Follows(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/Follows",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).Follows(ctx, req.(*FollowsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_MessagePrepare_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MessagePrepareRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).MessagePrepare(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/MessagePrepare",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).MessagePrepare(ctx, req.(*MessagePrepareRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_MessageCreate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MessageCreateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).MessageCreate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/MessageCreate",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).MessageCreate(ctx, req.(*MessageCreateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_Messages_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MessagesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCServer).Messages(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.RPC/Messages",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCServer).Messages(ctx, req.(*MessagesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPC_Relay_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(RelayRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(RPCServer).Relay(m, &rPCRelayServer{stream})
}

type RPC_RelayServer interface {
	Send(*RelayOutput) error
	grpc.ServerStream
}

type rPCRelayServer struct {
	grpc.ServerStream
}

func (x *rPCRelayServer) Send(m *RelayOutput) error {
	return x.ServerStream.SendMsg(m)
}

var _RPC_serviceDesc = grpc.ServiceDesc{
	ServiceName: "service.RPC",
	HandlerType: (*RPCServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "KeyGenerate",
			Handler:    _RPC_KeyGenerate_Handler,
		},
		{
			MethodName: "Keys",
			Handler:    _RPC_Keys_Handler,
		},
		{
			MethodName: "Key",
			Handler:    _RPC_Key_Handler,
		},
		{
			MethodName: "KeyImport",
			Handler:    _RPC_KeyImport_Handler,
		},
		{
			MethodName: "KeyExport",
			Handler:    _RPC_KeyExport_Handler,
		},
		{
			MethodName: "KeyRemove",
			Handler:    _RPC_KeyRemove_Handler,
		},
		{
			MethodName: "Sign",
			Handler:    _RPC_Sign_Handler,
		},
		{
			MethodName: "Verify",
			Handler:    _RPC_Verify_Handler,
		},
		{
			MethodName: "VerifyDetached",
			Handler:    _RPC_VerifyDetached_Handler,
		},
		{
			MethodName: "Encrypt",
			Handler:    _RPC_Encrypt_Handler,
		},
		{
			MethodName: "Decrypt",
			Handler:    _RPC_Decrypt_Handler,
		},
		{
			MethodName: "Sigchain",
			Handler:    _RPC_Sigchain_Handler,
		},
		{
			MethodName: "Statement",
			Handler:    _RPC_Statement_Handler,
		},
		{
			MethodName: "StatementCreate",
			Handler:    _RPC_StatementCreate_Handler,
		},
		{
			MethodName: "StatementRevoke",
			Handler:    _RPC_StatementRevoke_Handler,
		},
		{
			MethodName: "User",
			Handler:    _RPC_User_Handler,
		},
		{
			MethodName: "UserSearch",
			Handler:    _RPC_UserSearch_Handler,
		},
		{
			MethodName: "UserService",
			Handler:    _RPC_UserService_Handler,
		},
		{
			MethodName: "UserSign",
			Handler:    _RPC_UserSign_Handler,
		},
		{
			MethodName: "UserAdd",
			Handler:    _RPC_UserAdd_Handler,
		},
		{
			MethodName: "Search",
			Handler:    _RPC_Search_Handler,
		},
		{
			MethodName: "Secret",
			Handler:    _RPC_Secret_Handler,
		},
		{
			MethodName: "SecretSave",
			Handler:    _RPC_SecretSave_Handler,
		},
		{
			MethodName: "SecretRemove",
			Handler:    _RPC_SecretRemove_Handler,
		},
		{
			MethodName: "Secrets",
			Handler:    _RPC_Secrets_Handler,
		},
		{
			MethodName: "Pull",
			Handler:    _RPC_Pull_Handler,
		},
		{
			MethodName: "Push",
			Handler:    _RPC_Push_Handler,
		},
		{
			MethodName: "AuthSetup",
			Handler:    _RPC_AuthSetup_Handler,
		},
		{
			MethodName: "AuthVault",
			Handler:    _RPC_AuthVault_Handler,
		},
		{
			MethodName: "AuthUnlock",
			Handler:    _RPC_AuthUnlock_Handler,
		},
		{
			MethodName: "AuthLock",
			Handler:    _RPC_AuthLock_Handler,
		},
		{
			MethodName: "AuthReset",
			Handler:    _RPC_AuthReset_Handler,
		},
		{
			MethodName: "AuthRecover",
			Handler:    _RPC_AuthRecover_Handler,
		},
		{
			MethodName: "RuntimeStatus",
			Handler:    _RPC_RuntimeStatus_Handler,
		},
		{
			MethodName: "Rand",
			Handler:    _RPC_Rand_Handler,
		},
		{
			MethodName: "RandPassword",
			Handler:    _RPC_RandPassword_Handler,
		},
		{
			MethodName: "AuthProvision",
			Handler:    _RPC_AuthProvision_Handler,
		},
		{
			MethodName: "AuthDeprovision",
			Handler:    _RPC_AuthDeprovision_Handler,
		},
		{
			MethodName: "AuthProvisions",
			Handler:    _RPC_AuthProvisions_Handler,
		},
		{
			MethodName: "AuthPasswordChange",
			Handler:    _RPC_AuthPasswordChange_Handler,
		},
		{
			MethodName: "VaultAuth",
			Handler:    _RPC_VaultAuth_Handler,
		},
		{
			MethodName: "VaultSync",
			Handler:    _RPC_VaultSync_Handler,
		},
		{
			MethodName: "VaultUnsync",
			Handler:    _RPC_VaultUnsync_Handler,
		},
		{
			MethodName: "VaultStatus",
			Handler:    _RPC_VaultStatus_Handler,
		},
		{
			MethodName: "VaultUpdate",
			Handler:    _RPC_VaultUpdate_Handler,
		},
		{
			MethodName: "Collections",
			Handler:    _RPC_Collections_Handler,
		},
		{
			MethodName: "Documents",
			Handler:    _RPC_Documents_Handler,
		},
		{
			MethodName: "DocumentDelete",
			Handler:    _RPC_DocumentDelete_Handler,
		},
		{
			MethodName: "ConfigGet",
			Handler:    _RPC_ConfigGet_Handler,
		},
		{
			MethodName: "ConfigSet",
			Handler:    _RPC_ConfigSet_Handler,
		},
		{
			MethodName: "AdminSignURL",
			Handler:    _RPC_AdminSignURL_Handler,
		},
		{
			MethodName: "AdminCheck",
			Handler:    _RPC_AdminCheck_Handler,
		},
		{
			MethodName: "Channels",
			Handler:    _RPC_Channels_Handler,
		},
		{
			MethodName: "ChannelCreate",
			Handler:    _RPC_ChannelCreate_Handler,
		},
		{
			MethodName: "ChannelInvite",
			Handler:    _RPC_ChannelInvite_Handler,
		},
		{
			MethodName: "ChannelLeave",
			Handler:    _RPC_ChannelLeave_Handler,
		},
		{
			MethodName: "ChannelRead",
			Handler:    _RPC_ChannelRead_Handler,
		},
		{
			MethodName: "Follow",
			Handler:    _RPC_Follow_Handler,
		},
		{
			MethodName: "Follows",
			Handler:    _RPC_Follows_Handler,
		},
		{
			MethodName: "MessagePrepare",
			Handler:    _RPC_MessagePrepare_Handler,
		},
		{
			MethodName: "MessageCreate",
			Handler:    _RPC_MessageCreate_Handler,
		},
		{
			MethodName: "Messages",
			Handler:    _RPC_Messages_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "SignFile",
			Handler:       _RPC_SignFile_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "SignStream",
			Handler:       _RPC_SignStream_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "VerifyFile",
			Handler:       _RPC_VerifyFile_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "VerifyStream",
			Handler:       _RPC_VerifyStream_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "VerifyDetachedFile",
			Handler:       _RPC_VerifyDetachedFile_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "VerifyDetachedStream",
			Handler:       _RPC_VerifyDetachedStream_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "EncryptStream",
			Handler:       _RPC_EncryptStream_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "EncryptFile",
			Handler:       _RPC_EncryptFile_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "DecryptStream",
			Handler:       _RPC_DecryptStream_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "DecryptFile",
			Handler:       _RPC_DecryptFile_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "Wormhole",
			Handler:       _RPC_Wormhole_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "Relay",
			Handler:       _RPC_Relay_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "rpc.proto",
}
