From d7a83ec03e6176ef089a55e5420d023670e28828 Mon Sep 17 00:00:00 2001 From: Mikhail Iudin Date: Wed, 12 Jun 2024 21:11:17 +0200 Subject: [PATCH] Fix proto gen --- clientlibrary/service/service.pb.go | 3422 +++++++++++++++++++++++++++ 1 file changed, 3422 insertions(+) diff --git a/clientlibrary/service/service.pb.go b/clientlibrary/service/service.pb.go index 89b3573a25..687fbc7c9b 100644 --- a/clientlibrary/service/service.pb.go +++ b/clientlibrary/service/service.pb.go @@ -6037,3 +6037,3425 @@ type MessageHandler interface { func CommandMobile(cmd string, data []byte, callback MessageHandler) { CommandAsync(cmd, data, callback.Handle) } + +type ClientCommandsHandlerProxy struct { + client ClientCommandsHandler + interceptors []func(ctx context.Context, req any, methodName string, actualCall func(ctx context.Context, req any) (any, error)) (any, error) +} + +func (h *ClientCommandsHandlerProxy) AppGetVersion(ctx context.Context, req *pb.RpcAppGetVersionRequest) *pb.RpcAppGetVersionResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.AppGetVersion(ctx, req.(*pb.RpcAppGetVersionRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "AppGetVersion", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcAppGetVersionResponse) +} +func (h *ClientCommandsHandlerProxy) AppSetDeviceState(ctx context.Context, req *pb.RpcAppSetDeviceStateRequest) *pb.RpcAppSetDeviceStateResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.AppSetDeviceState(ctx, req.(*pb.RpcAppSetDeviceStateRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "AppSetDeviceState", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcAppSetDeviceStateResponse) +} +func (h *ClientCommandsHandlerProxy) AppShutdown(ctx context.Context, req *pb.RpcAppShutdownRequest) *pb.RpcAppShutdownResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.AppShutdown(ctx, req.(*pb.RpcAppShutdownRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "AppShutdown", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcAppShutdownResponse) +} +func (h *ClientCommandsHandlerProxy) WalletCreate(ctx context.Context, req *pb.RpcWalletCreateRequest) *pb.RpcWalletCreateResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.WalletCreate(ctx, req.(*pb.RpcWalletCreateRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "WalletCreate", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcWalletCreateResponse) +} +func (h *ClientCommandsHandlerProxy) WalletRecover(ctx context.Context, req *pb.RpcWalletRecoverRequest) *pb.RpcWalletRecoverResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.WalletRecover(ctx, req.(*pb.RpcWalletRecoverRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "WalletRecover", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcWalletRecoverResponse) +} +func (h *ClientCommandsHandlerProxy) WalletConvert(ctx context.Context, req *pb.RpcWalletConvertRequest) *pb.RpcWalletConvertResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.WalletConvert(ctx, req.(*pb.RpcWalletConvertRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "WalletConvert", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcWalletConvertResponse) +} +func (h *ClientCommandsHandlerProxy) AccountLocalLinkNewChallenge(ctx context.Context, req *pb.RpcAccountLocalLinkNewChallengeRequest) *pb.RpcAccountLocalLinkNewChallengeResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.AccountLocalLinkNewChallenge(ctx, req.(*pb.RpcAccountLocalLinkNewChallengeRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "AccountLocalLinkNewChallenge", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcAccountLocalLinkNewChallengeResponse) +} +func (h *ClientCommandsHandlerProxy) AccountLocalLinkSolveChallenge(ctx context.Context, req *pb.RpcAccountLocalLinkSolveChallengeRequest) *pb.RpcAccountLocalLinkSolveChallengeResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.AccountLocalLinkSolveChallenge(ctx, req.(*pb.RpcAccountLocalLinkSolveChallengeRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "AccountLocalLinkSolveChallenge", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcAccountLocalLinkSolveChallengeResponse) +} +func (h *ClientCommandsHandlerProxy) WalletCreateSession(ctx context.Context, req *pb.RpcWalletCreateSessionRequest) *pb.RpcWalletCreateSessionResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.WalletCreateSession(ctx, req.(*pb.RpcWalletCreateSessionRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "WalletCreateSession", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcWalletCreateSessionResponse) +} +func (h *ClientCommandsHandlerProxy) WalletCloseSession(ctx context.Context, req *pb.RpcWalletCloseSessionRequest) *pb.RpcWalletCloseSessionResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.WalletCloseSession(ctx, req.(*pb.RpcWalletCloseSessionRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "WalletCloseSession", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcWalletCloseSessionResponse) +} +func (h *ClientCommandsHandlerProxy) WorkspaceCreate(ctx context.Context, req *pb.RpcWorkspaceCreateRequest) *pb.RpcWorkspaceCreateResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.WorkspaceCreate(ctx, req.(*pb.RpcWorkspaceCreateRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "WorkspaceCreate", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcWorkspaceCreateResponse) +} +func (h *ClientCommandsHandlerProxy) WorkspaceOpen(ctx context.Context, req *pb.RpcWorkspaceOpenRequest) *pb.RpcWorkspaceOpenResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.WorkspaceOpen(ctx, req.(*pb.RpcWorkspaceOpenRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "WorkspaceOpen", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcWorkspaceOpenResponse) +} +func (h *ClientCommandsHandlerProxy) WorkspaceObjectAdd(ctx context.Context, req *pb.RpcWorkspaceObjectAddRequest) *pb.RpcWorkspaceObjectAddResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.WorkspaceObjectAdd(ctx, req.(*pb.RpcWorkspaceObjectAddRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "WorkspaceObjectAdd", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcWorkspaceObjectAddResponse) +} +func (h *ClientCommandsHandlerProxy) WorkspaceObjectListAdd(ctx context.Context, req *pb.RpcWorkspaceObjectListAddRequest) *pb.RpcWorkspaceObjectListAddResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.WorkspaceObjectListAdd(ctx, req.(*pb.RpcWorkspaceObjectListAddRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "WorkspaceObjectListAdd", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcWorkspaceObjectListAddResponse) +} +func (h *ClientCommandsHandlerProxy) WorkspaceObjectListRemove(ctx context.Context, req *pb.RpcWorkspaceObjectListRemoveRequest) *pb.RpcWorkspaceObjectListRemoveResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.WorkspaceObjectListRemove(ctx, req.(*pb.RpcWorkspaceObjectListRemoveRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "WorkspaceObjectListRemove", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcWorkspaceObjectListRemoveResponse) +} +func (h *ClientCommandsHandlerProxy) WorkspaceSelect(ctx context.Context, req *pb.RpcWorkspaceSelectRequest) *pb.RpcWorkspaceSelectResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.WorkspaceSelect(ctx, req.(*pb.RpcWorkspaceSelectRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "WorkspaceSelect", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcWorkspaceSelectResponse) +} +func (h *ClientCommandsHandlerProxy) WorkspaceGetCurrent(ctx context.Context, req *pb.RpcWorkspaceGetCurrentRequest) *pb.RpcWorkspaceGetCurrentResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.WorkspaceGetCurrent(ctx, req.(*pb.RpcWorkspaceGetCurrentRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "WorkspaceGetCurrent", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcWorkspaceGetCurrentResponse) +} +func (h *ClientCommandsHandlerProxy) WorkspaceGetAll(ctx context.Context, req *pb.RpcWorkspaceGetAllRequest) *pb.RpcWorkspaceGetAllResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.WorkspaceGetAll(ctx, req.(*pb.RpcWorkspaceGetAllRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "WorkspaceGetAll", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcWorkspaceGetAllResponse) +} +func (h *ClientCommandsHandlerProxy) WorkspaceSetInfo(ctx context.Context, req *pb.RpcWorkspaceSetInfoRequest) *pb.RpcWorkspaceSetInfoResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.WorkspaceSetInfo(ctx, req.(*pb.RpcWorkspaceSetInfoRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "WorkspaceSetInfo", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcWorkspaceSetInfoResponse) +} +func (h *ClientCommandsHandlerProxy) WorkspaceExport(ctx context.Context, req *pb.RpcWorkspaceExportRequest) *pb.RpcWorkspaceExportResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.WorkspaceExport(ctx, req.(*pb.RpcWorkspaceExportRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "WorkspaceExport", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcWorkspaceExportResponse) +} +func (h *ClientCommandsHandlerProxy) AccountRecover(ctx context.Context, req *pb.RpcAccountRecoverRequest) *pb.RpcAccountRecoverResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.AccountRecover(ctx, req.(*pb.RpcAccountRecoverRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "AccountRecover", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcAccountRecoverResponse) +} +func (h *ClientCommandsHandlerProxy) AccountCreate(ctx context.Context, req *pb.RpcAccountCreateRequest) *pb.RpcAccountCreateResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.AccountCreate(ctx, req.(*pb.RpcAccountCreateRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "AccountCreate", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcAccountCreateResponse) +} +func (h *ClientCommandsHandlerProxy) AccountDelete(ctx context.Context, req *pb.RpcAccountDeleteRequest) *pb.RpcAccountDeleteResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.AccountDelete(ctx, req.(*pb.RpcAccountDeleteRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "AccountDelete", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcAccountDeleteResponse) +} +func (h *ClientCommandsHandlerProxy) AccountRevertDeletion(ctx context.Context, req *pb.RpcAccountRevertDeletionRequest) *pb.RpcAccountRevertDeletionResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.AccountRevertDeletion(ctx, req.(*pb.RpcAccountRevertDeletionRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "AccountRevertDeletion", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcAccountRevertDeletionResponse) +} +func (h *ClientCommandsHandlerProxy) AccountSelect(ctx context.Context, req *pb.RpcAccountSelectRequest) *pb.RpcAccountSelectResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.AccountSelect(ctx, req.(*pb.RpcAccountSelectRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "AccountSelect", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcAccountSelectResponse) +} +func (h *ClientCommandsHandlerProxy) AccountEnableLocalNetworkSync(ctx context.Context, req *pb.RpcAccountEnableLocalNetworkSyncRequest) *pb.RpcAccountEnableLocalNetworkSyncResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.AccountEnableLocalNetworkSync(ctx, req.(*pb.RpcAccountEnableLocalNetworkSyncRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "AccountEnableLocalNetworkSync", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcAccountEnableLocalNetworkSyncResponse) +} +func (h *ClientCommandsHandlerProxy) AccountStop(ctx context.Context, req *pb.RpcAccountStopRequest) *pb.RpcAccountStopResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.AccountStop(ctx, req.(*pb.RpcAccountStopRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "AccountStop", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcAccountStopResponse) +} +func (h *ClientCommandsHandlerProxy) AccountMove(ctx context.Context, req *pb.RpcAccountMoveRequest) *pb.RpcAccountMoveResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.AccountMove(ctx, req.(*pb.RpcAccountMoveRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "AccountMove", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcAccountMoveResponse) +} +func (h *ClientCommandsHandlerProxy) AccountConfigUpdate(ctx context.Context, req *pb.RpcAccountConfigUpdateRequest) *pb.RpcAccountConfigUpdateResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.AccountConfigUpdate(ctx, req.(*pb.RpcAccountConfigUpdateRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "AccountConfigUpdate", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcAccountConfigUpdateResponse) +} +func (h *ClientCommandsHandlerProxy) AccountRecoverFromLegacyExport(ctx context.Context, req *pb.RpcAccountRecoverFromLegacyExportRequest) *pb.RpcAccountRecoverFromLegacyExportResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.AccountRecoverFromLegacyExport(ctx, req.(*pb.RpcAccountRecoverFromLegacyExportRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "AccountRecoverFromLegacyExport", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcAccountRecoverFromLegacyExportResponse) +} +func (h *ClientCommandsHandlerProxy) AccountChangeNetworkConfigAndRestart(ctx context.Context, req *pb.RpcAccountChangeNetworkConfigAndRestartRequest) *pb.RpcAccountChangeNetworkConfigAndRestartResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.AccountChangeNetworkConfigAndRestart(ctx, req.(*pb.RpcAccountChangeNetworkConfigAndRestartRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "AccountChangeNetworkConfigAndRestart", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcAccountChangeNetworkConfigAndRestartResponse) +} +func (h *ClientCommandsHandlerProxy) SpaceDelete(ctx context.Context, req *pb.RpcSpaceDeleteRequest) *pb.RpcSpaceDeleteResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.SpaceDelete(ctx, req.(*pb.RpcSpaceDeleteRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "SpaceDelete", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcSpaceDeleteResponse) +} +func (h *ClientCommandsHandlerProxy) SpaceInviteGenerate(ctx context.Context, req *pb.RpcSpaceInviteGenerateRequest) *pb.RpcSpaceInviteGenerateResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.SpaceInviteGenerate(ctx, req.(*pb.RpcSpaceInviteGenerateRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "SpaceInviteGenerate", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcSpaceInviteGenerateResponse) +} +func (h *ClientCommandsHandlerProxy) SpaceInviteGetCurrent(ctx context.Context, req *pb.RpcSpaceInviteGetCurrentRequest) *pb.RpcSpaceInviteGetCurrentResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.SpaceInviteGetCurrent(ctx, req.(*pb.RpcSpaceInviteGetCurrentRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "SpaceInviteGetCurrent", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcSpaceInviteGetCurrentResponse) +} +func (h *ClientCommandsHandlerProxy) SpaceInviteRevoke(ctx context.Context, req *pb.RpcSpaceInviteRevokeRequest) *pb.RpcSpaceInviteRevokeResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.SpaceInviteRevoke(ctx, req.(*pb.RpcSpaceInviteRevokeRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "SpaceInviteRevoke", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcSpaceInviteRevokeResponse) +} +func (h *ClientCommandsHandlerProxy) SpaceInviteView(ctx context.Context, req *pb.RpcSpaceInviteViewRequest) *pb.RpcSpaceInviteViewResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.SpaceInviteView(ctx, req.(*pb.RpcSpaceInviteViewRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "SpaceInviteView", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcSpaceInviteViewResponse) +} +func (h *ClientCommandsHandlerProxy) SpaceJoin(ctx context.Context, req *pb.RpcSpaceJoinRequest) *pb.RpcSpaceJoinResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.SpaceJoin(ctx, req.(*pb.RpcSpaceJoinRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "SpaceJoin", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcSpaceJoinResponse) +} +func (h *ClientCommandsHandlerProxy) SpaceJoinCancel(ctx context.Context, req *pb.RpcSpaceJoinCancelRequest) *pb.RpcSpaceJoinCancelResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.SpaceJoinCancel(ctx, req.(*pb.RpcSpaceJoinCancelRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "SpaceJoinCancel", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcSpaceJoinCancelResponse) +} +func (h *ClientCommandsHandlerProxy) SpaceStopSharing(ctx context.Context, req *pb.RpcSpaceStopSharingRequest) *pb.RpcSpaceStopSharingResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.SpaceStopSharing(ctx, req.(*pb.RpcSpaceStopSharingRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "SpaceStopSharing", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcSpaceStopSharingResponse) +} +func (h *ClientCommandsHandlerProxy) SpaceRequestApprove(ctx context.Context, req *pb.RpcSpaceRequestApproveRequest) *pb.RpcSpaceRequestApproveResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.SpaceRequestApprove(ctx, req.(*pb.RpcSpaceRequestApproveRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "SpaceRequestApprove", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcSpaceRequestApproveResponse) +} +func (h *ClientCommandsHandlerProxy) SpaceRequestDecline(ctx context.Context, req *pb.RpcSpaceRequestDeclineRequest) *pb.RpcSpaceRequestDeclineResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.SpaceRequestDecline(ctx, req.(*pb.RpcSpaceRequestDeclineRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "SpaceRequestDecline", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcSpaceRequestDeclineResponse) +} +func (h *ClientCommandsHandlerProxy) SpaceLeaveApprove(ctx context.Context, req *pb.RpcSpaceLeaveApproveRequest) *pb.RpcSpaceLeaveApproveResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.SpaceLeaveApprove(ctx, req.(*pb.RpcSpaceLeaveApproveRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "SpaceLeaveApprove", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcSpaceLeaveApproveResponse) +} +func (h *ClientCommandsHandlerProxy) SpaceMakeShareable(ctx context.Context, req *pb.RpcSpaceMakeShareableRequest) *pb.RpcSpaceMakeShareableResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.SpaceMakeShareable(ctx, req.(*pb.RpcSpaceMakeShareableRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "SpaceMakeShareable", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcSpaceMakeShareableResponse) +} +func (h *ClientCommandsHandlerProxy) SpaceParticipantRemove(ctx context.Context, req *pb.RpcSpaceParticipantRemoveRequest) *pb.RpcSpaceParticipantRemoveResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.SpaceParticipantRemove(ctx, req.(*pb.RpcSpaceParticipantRemoveRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "SpaceParticipantRemove", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcSpaceParticipantRemoveResponse) +} +func (h *ClientCommandsHandlerProxy) SpaceParticipantPermissionsChange(ctx context.Context, req *pb.RpcSpaceParticipantPermissionsChangeRequest) *pb.RpcSpaceParticipantPermissionsChangeResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.SpaceParticipantPermissionsChange(ctx, req.(*pb.RpcSpaceParticipantPermissionsChangeRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "SpaceParticipantPermissionsChange", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcSpaceParticipantPermissionsChangeResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectOpen(ctx context.Context, req *pb.RpcObjectOpenRequest) *pb.RpcObjectOpenResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectOpen(ctx, req.(*pb.RpcObjectOpenRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectOpen", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectOpenResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectClose(ctx context.Context, req *pb.RpcObjectCloseRequest) *pb.RpcObjectCloseResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectClose(ctx, req.(*pb.RpcObjectCloseRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectClose", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectCloseResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectShow(ctx context.Context, req *pb.RpcObjectShowRequest) *pb.RpcObjectShowResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectShow(ctx, req.(*pb.RpcObjectShowRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectShow", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectShowResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectCreate(ctx context.Context, req *pb.RpcObjectCreateRequest) *pb.RpcObjectCreateResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectCreate(ctx, req.(*pb.RpcObjectCreateRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectCreate", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectCreateResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectCreateBookmark(ctx context.Context, req *pb.RpcObjectCreateBookmarkRequest) *pb.RpcObjectCreateBookmarkResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectCreateBookmark(ctx, req.(*pb.RpcObjectCreateBookmarkRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectCreateBookmark", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectCreateBookmarkResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectCreateFromUrl(ctx context.Context, req *pb.RpcObjectCreateFromUrlRequest) *pb.RpcObjectCreateFromUrlResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectCreateFromUrl(ctx, req.(*pb.RpcObjectCreateFromUrlRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectCreateFromUrl", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectCreateFromUrlResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectCreateSet(ctx context.Context, req *pb.RpcObjectCreateSetRequest) *pb.RpcObjectCreateSetResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectCreateSet(ctx, req.(*pb.RpcObjectCreateSetRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectCreateSet", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectCreateSetResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectGraph(ctx context.Context, req *pb.RpcObjectGraphRequest) *pb.RpcObjectGraphResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectGraph(ctx, req.(*pb.RpcObjectGraphRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectGraph", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectGraphResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectSearch(ctx context.Context, req *pb.RpcObjectSearchRequest) *pb.RpcObjectSearchResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectSearch(ctx, req.(*pb.RpcObjectSearchRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectSearch", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectSearchResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectSearchWithMeta(ctx context.Context, req *pb.RpcObjectSearchWithMetaRequest) *pb.RpcObjectSearchWithMetaResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectSearchWithMeta(ctx, req.(*pb.RpcObjectSearchWithMetaRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectSearchWithMeta", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectSearchWithMetaResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectSearchSubscribe(ctx context.Context, req *pb.RpcObjectSearchSubscribeRequest) *pb.RpcObjectSearchSubscribeResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectSearchSubscribe(ctx, req.(*pb.RpcObjectSearchSubscribeRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectSearchSubscribe", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectSearchSubscribeResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectSubscribeIds(ctx context.Context, req *pb.RpcObjectSubscribeIdsRequest) *pb.RpcObjectSubscribeIdsResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectSubscribeIds(ctx, req.(*pb.RpcObjectSubscribeIdsRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectSubscribeIds", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectSubscribeIdsResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectGroupsSubscribe(ctx context.Context, req *pb.RpcObjectGroupsSubscribeRequest) *pb.RpcObjectGroupsSubscribeResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectGroupsSubscribe(ctx, req.(*pb.RpcObjectGroupsSubscribeRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectGroupsSubscribe", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectGroupsSubscribeResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectSearchUnsubscribe(ctx context.Context, req *pb.RpcObjectSearchUnsubscribeRequest) *pb.RpcObjectSearchUnsubscribeResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectSearchUnsubscribe(ctx, req.(*pb.RpcObjectSearchUnsubscribeRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectSearchUnsubscribe", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectSearchUnsubscribeResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectSetDetails(ctx context.Context, req *pb.RpcObjectSetDetailsRequest) *pb.RpcObjectSetDetailsResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectSetDetails(ctx, req.(*pb.RpcObjectSetDetailsRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectSetDetails", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectSetDetailsResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectDuplicate(ctx context.Context, req *pb.RpcObjectDuplicateRequest) *pb.RpcObjectDuplicateResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectDuplicate(ctx, req.(*pb.RpcObjectDuplicateRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectDuplicate", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectDuplicateResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectSetObjectType(ctx context.Context, req *pb.RpcObjectSetObjectTypeRequest) *pb.RpcObjectSetObjectTypeResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectSetObjectType(ctx, req.(*pb.RpcObjectSetObjectTypeRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectSetObjectType", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectSetObjectTypeResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectSetLayout(ctx context.Context, req *pb.RpcObjectSetLayoutRequest) *pb.RpcObjectSetLayoutResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectSetLayout(ctx, req.(*pb.RpcObjectSetLayoutRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectSetLayout", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectSetLayoutResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectSetInternalFlags(ctx context.Context, req *pb.RpcObjectSetInternalFlagsRequest) *pb.RpcObjectSetInternalFlagsResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectSetInternalFlags(ctx, req.(*pb.RpcObjectSetInternalFlagsRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectSetInternalFlags", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectSetInternalFlagsResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectSetIsFavorite(ctx context.Context, req *pb.RpcObjectSetIsFavoriteRequest) *pb.RpcObjectSetIsFavoriteResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectSetIsFavorite(ctx, req.(*pb.RpcObjectSetIsFavoriteRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectSetIsFavorite", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectSetIsFavoriteResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectSetIsArchived(ctx context.Context, req *pb.RpcObjectSetIsArchivedRequest) *pb.RpcObjectSetIsArchivedResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectSetIsArchived(ctx, req.(*pb.RpcObjectSetIsArchivedRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectSetIsArchived", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectSetIsArchivedResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectSetSource(ctx context.Context, req *pb.RpcObjectSetSourceRequest) *pb.RpcObjectSetSourceResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectSetSource(ctx, req.(*pb.RpcObjectSetSourceRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectSetSource", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectSetSourceResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectWorkspaceSetDashboard(ctx context.Context, req *pb.RpcObjectWorkspaceSetDashboardRequest) *pb.RpcObjectWorkspaceSetDashboardResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectWorkspaceSetDashboard(ctx, req.(*pb.RpcObjectWorkspaceSetDashboardRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectWorkspaceSetDashboard", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectWorkspaceSetDashboardResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectListDuplicate(ctx context.Context, req *pb.RpcObjectListDuplicateRequest) *pb.RpcObjectListDuplicateResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectListDuplicate(ctx, req.(*pb.RpcObjectListDuplicateRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectListDuplicate", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectListDuplicateResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectListDelete(ctx context.Context, req *pb.RpcObjectListDeleteRequest) *pb.RpcObjectListDeleteResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectListDelete(ctx, req.(*pb.RpcObjectListDeleteRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectListDelete", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectListDeleteResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectListSetIsArchived(ctx context.Context, req *pb.RpcObjectListSetIsArchivedRequest) *pb.RpcObjectListSetIsArchivedResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectListSetIsArchived(ctx, req.(*pb.RpcObjectListSetIsArchivedRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectListSetIsArchived", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectListSetIsArchivedResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectListSetIsFavorite(ctx context.Context, req *pb.RpcObjectListSetIsFavoriteRequest) *pb.RpcObjectListSetIsFavoriteResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectListSetIsFavorite(ctx, req.(*pb.RpcObjectListSetIsFavoriteRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectListSetIsFavorite", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectListSetIsFavoriteResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectListSetObjectType(ctx context.Context, req *pb.RpcObjectListSetObjectTypeRequest) *pb.RpcObjectListSetObjectTypeResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectListSetObjectType(ctx, req.(*pb.RpcObjectListSetObjectTypeRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectListSetObjectType", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectListSetObjectTypeResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectListSetDetails(ctx context.Context, req *pb.RpcObjectListSetDetailsRequest) *pb.RpcObjectListSetDetailsResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectListSetDetails(ctx, req.(*pb.RpcObjectListSetDetailsRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectListSetDetails", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectListSetDetailsResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectApplyTemplate(ctx context.Context, req *pb.RpcObjectApplyTemplateRequest) *pb.RpcObjectApplyTemplateResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectApplyTemplate(ctx, req.(*pb.RpcObjectApplyTemplateRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectApplyTemplate", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectApplyTemplateResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectToSet(ctx context.Context, req *pb.RpcObjectToSetRequest) *pb.RpcObjectToSetResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectToSet(ctx, req.(*pb.RpcObjectToSetRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectToSet", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectToSetResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectToCollection(ctx context.Context, req *pb.RpcObjectToCollectionRequest) *pb.RpcObjectToCollectionResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectToCollection(ctx, req.(*pb.RpcObjectToCollectionRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectToCollection", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectToCollectionResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectShareByLink(ctx context.Context, req *pb.RpcObjectShareByLinkRequest) *pb.RpcObjectShareByLinkResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectShareByLink(ctx, req.(*pb.RpcObjectShareByLinkRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectShareByLink", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectShareByLinkResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectUndo(ctx context.Context, req *pb.RpcObjectUndoRequest) *pb.RpcObjectUndoResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectUndo(ctx, req.(*pb.RpcObjectUndoRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectUndo", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectUndoResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectRedo(ctx context.Context, req *pb.RpcObjectRedoRequest) *pb.RpcObjectRedoResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectRedo(ctx, req.(*pb.RpcObjectRedoRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectRedo", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectRedoResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectListExport(ctx context.Context, req *pb.RpcObjectListExportRequest) *pb.RpcObjectListExportResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectListExport(ctx, req.(*pb.RpcObjectListExportRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectListExport", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectListExportResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectBookmarkFetch(ctx context.Context, req *pb.RpcObjectBookmarkFetchRequest) *pb.RpcObjectBookmarkFetchResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectBookmarkFetch(ctx, req.(*pb.RpcObjectBookmarkFetchRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectBookmarkFetch", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectBookmarkFetchResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectToBookmark(ctx context.Context, req *pb.RpcObjectToBookmarkRequest) *pb.RpcObjectToBookmarkResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectToBookmark(ctx, req.(*pb.RpcObjectToBookmarkRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectToBookmark", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectToBookmarkResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectImport(ctx context.Context, req *pb.RpcObjectImportRequest) *pb.RpcObjectImportResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectImport(ctx, req.(*pb.RpcObjectImportRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectImport", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectImportResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectImportList(ctx context.Context, req *pb.RpcObjectImportListRequest) *pb.RpcObjectImportListResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectImportList(ctx, req.(*pb.RpcObjectImportListRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectImportList", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectImportListResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectImportNotionValidateToken(ctx context.Context, req *pb.RpcObjectImportNotionValidateTokenRequest) *pb.RpcObjectImportNotionValidateTokenResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectImportNotionValidateToken(ctx, req.(*pb.RpcObjectImportNotionValidateTokenRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectImportNotionValidateToken", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectImportNotionValidateTokenResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectImportUseCase(ctx context.Context, req *pb.RpcObjectImportUseCaseRequest) *pb.RpcObjectImportUseCaseResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectImportUseCase(ctx, req.(*pb.RpcObjectImportUseCaseRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectImportUseCase", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectImportUseCaseResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectImportExperience(ctx context.Context, req *pb.RpcObjectImportExperienceRequest) *pb.RpcObjectImportExperienceResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectImportExperience(ctx, req.(*pb.RpcObjectImportExperienceRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectImportExperience", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectImportExperienceResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectCollectionAdd(ctx context.Context, req *pb.RpcObjectCollectionAddRequest) *pb.RpcObjectCollectionAddResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectCollectionAdd(ctx, req.(*pb.RpcObjectCollectionAddRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectCollectionAdd", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectCollectionAddResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectCollectionRemove(ctx context.Context, req *pb.RpcObjectCollectionRemoveRequest) *pb.RpcObjectCollectionRemoveResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectCollectionRemove(ctx, req.(*pb.RpcObjectCollectionRemoveRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectCollectionRemove", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectCollectionRemoveResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectCollectionSort(ctx context.Context, req *pb.RpcObjectCollectionSortRequest) *pb.RpcObjectCollectionSortResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectCollectionSort(ctx, req.(*pb.RpcObjectCollectionSortRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectCollectionSort", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectCollectionSortResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectCreateRelation(ctx context.Context, req *pb.RpcObjectCreateRelationRequest) *pb.RpcObjectCreateRelationResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectCreateRelation(ctx, req.(*pb.RpcObjectCreateRelationRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectCreateRelation", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectCreateRelationResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectCreateRelationOption(ctx context.Context, req *pb.RpcObjectCreateRelationOptionRequest) *pb.RpcObjectCreateRelationOptionResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectCreateRelationOption(ctx, req.(*pb.RpcObjectCreateRelationOptionRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectCreateRelationOption", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectCreateRelationOptionResponse) +} +func (h *ClientCommandsHandlerProxy) RelationListRemoveOption(ctx context.Context, req *pb.RpcRelationListRemoveOptionRequest) *pb.RpcRelationListRemoveOptionResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.RelationListRemoveOption(ctx, req.(*pb.RpcRelationListRemoveOptionRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "RelationListRemoveOption", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcRelationListRemoveOptionResponse) +} +func (h *ClientCommandsHandlerProxy) RelationOptions(ctx context.Context, req *pb.RpcRelationOptionsRequest) *pb.RpcRelationOptionsResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.RelationOptions(ctx, req.(*pb.RpcRelationOptionsRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "RelationOptions", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcRelationOptionsResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectRelationAdd(ctx context.Context, req *pb.RpcObjectRelationAddRequest) *pb.RpcObjectRelationAddResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectRelationAdd(ctx, req.(*pb.RpcObjectRelationAddRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectRelationAdd", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectRelationAddResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectRelationDelete(ctx context.Context, req *pb.RpcObjectRelationDeleteRequest) *pb.RpcObjectRelationDeleteResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectRelationDelete(ctx, req.(*pb.RpcObjectRelationDeleteRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectRelationDelete", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectRelationDeleteResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectRelationAddFeatured(ctx context.Context, req *pb.RpcObjectRelationAddFeaturedRequest) *pb.RpcObjectRelationAddFeaturedResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectRelationAddFeatured(ctx, req.(*pb.RpcObjectRelationAddFeaturedRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectRelationAddFeatured", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectRelationAddFeaturedResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectRelationRemoveFeatured(ctx context.Context, req *pb.RpcObjectRelationRemoveFeaturedRequest) *pb.RpcObjectRelationRemoveFeaturedResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectRelationRemoveFeatured(ctx, req.(*pb.RpcObjectRelationRemoveFeaturedRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectRelationRemoveFeatured", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectRelationRemoveFeaturedResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectRelationListAvailable(ctx context.Context, req *pb.RpcObjectRelationListAvailableRequest) *pb.RpcObjectRelationListAvailableResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectRelationListAvailable(ctx, req.(*pb.RpcObjectRelationListAvailableRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectRelationListAvailable", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectRelationListAvailableResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectCreateObjectType(ctx context.Context, req *pb.RpcObjectCreateObjectTypeRequest) *pb.RpcObjectCreateObjectTypeResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectCreateObjectType(ctx, req.(*pb.RpcObjectCreateObjectTypeRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectCreateObjectType", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectCreateObjectTypeResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectTypeRelationAdd(ctx context.Context, req *pb.RpcObjectTypeRelationAddRequest) *pb.RpcObjectTypeRelationAddResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectTypeRelationAdd(ctx, req.(*pb.RpcObjectTypeRelationAddRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectTypeRelationAdd", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectTypeRelationAddResponse) +} +func (h *ClientCommandsHandlerProxy) ObjectTypeRelationRemove(ctx context.Context, req *pb.RpcObjectTypeRelationRemoveRequest) *pb.RpcObjectTypeRelationRemoveResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ObjectTypeRelationRemove(ctx, req.(*pb.RpcObjectTypeRelationRemoveRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ObjectTypeRelationRemove", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcObjectTypeRelationRemoveResponse) +} +func (h *ClientCommandsHandlerProxy) HistoryShowVersion(ctx context.Context, req *pb.RpcHistoryShowVersionRequest) *pb.RpcHistoryShowVersionResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.HistoryShowVersion(ctx, req.(*pb.RpcHistoryShowVersionRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "HistoryShowVersion", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcHistoryShowVersionResponse) +} +func (h *ClientCommandsHandlerProxy) HistoryGetVersions(ctx context.Context, req *pb.RpcHistoryGetVersionsRequest) *pb.RpcHistoryGetVersionsResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.HistoryGetVersions(ctx, req.(*pb.RpcHistoryGetVersionsRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "HistoryGetVersions", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcHistoryGetVersionsResponse) +} +func (h *ClientCommandsHandlerProxy) HistorySetVersion(ctx context.Context, req *pb.RpcHistorySetVersionRequest) *pb.RpcHistorySetVersionResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.HistorySetVersion(ctx, req.(*pb.RpcHistorySetVersionRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "HistorySetVersion", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcHistorySetVersionResponse) +} +func (h *ClientCommandsHandlerProxy) HistoryDiffVersions(ctx context.Context, req *pb.RpcHistoryDiffVersionsRequest) *pb.RpcHistoryDiffVersionsResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.HistoryDiffVersions(ctx, req.(*pb.RpcHistoryDiffVersionsRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "HistoryDiffVersions", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcHistoryDiffVersionsResponse) +} +func (h *ClientCommandsHandlerProxy) FileOffload(ctx context.Context, req *pb.RpcFileOffloadRequest) *pb.RpcFileOffloadResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.FileOffload(ctx, req.(*pb.RpcFileOffloadRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "FileOffload", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcFileOffloadResponse) +} +func (h *ClientCommandsHandlerProxy) FileSpaceOffload(ctx context.Context, req *pb.RpcFileSpaceOffloadRequest) *pb.RpcFileSpaceOffloadResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.FileSpaceOffload(ctx, req.(*pb.RpcFileSpaceOffloadRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "FileSpaceOffload", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcFileSpaceOffloadResponse) +} +func (h *ClientCommandsHandlerProxy) FileListOffload(ctx context.Context, req *pb.RpcFileListOffloadRequest) *pb.RpcFileListOffloadResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.FileListOffload(ctx, req.(*pb.RpcFileListOffloadRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "FileListOffload", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcFileListOffloadResponse) +} +func (h *ClientCommandsHandlerProxy) FileUpload(ctx context.Context, req *pb.RpcFileUploadRequest) *pb.RpcFileUploadResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.FileUpload(ctx, req.(*pb.RpcFileUploadRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "FileUpload", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcFileUploadResponse) +} +func (h *ClientCommandsHandlerProxy) FileDownload(ctx context.Context, req *pb.RpcFileDownloadRequest) *pb.RpcFileDownloadResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.FileDownload(ctx, req.(*pb.RpcFileDownloadRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "FileDownload", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcFileDownloadResponse) +} +func (h *ClientCommandsHandlerProxy) FileDrop(ctx context.Context, req *pb.RpcFileDropRequest) *pb.RpcFileDropResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.FileDrop(ctx, req.(*pb.RpcFileDropRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "FileDrop", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcFileDropResponse) +} +func (h *ClientCommandsHandlerProxy) FileSpaceUsage(ctx context.Context, req *pb.RpcFileSpaceUsageRequest) *pb.RpcFileSpaceUsageResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.FileSpaceUsage(ctx, req.(*pb.RpcFileSpaceUsageRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "FileSpaceUsage", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcFileSpaceUsageResponse) +} +func (h *ClientCommandsHandlerProxy) FileNodeUsage(ctx context.Context, req *pb.RpcFileNodeUsageRequest) *pb.RpcFileNodeUsageResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.FileNodeUsage(ctx, req.(*pb.RpcFileNodeUsageRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "FileNodeUsage", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcFileNodeUsageResponse) +} +func (h *ClientCommandsHandlerProxy) NavigationListObjects(ctx context.Context, req *pb.RpcNavigationListObjectsRequest) *pb.RpcNavigationListObjectsResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.NavigationListObjects(ctx, req.(*pb.RpcNavigationListObjectsRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "NavigationListObjects", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcNavigationListObjectsResponse) +} +func (h *ClientCommandsHandlerProxy) NavigationGetObjectInfoWithLinks(ctx context.Context, req *pb.RpcNavigationGetObjectInfoWithLinksRequest) *pb.RpcNavigationGetObjectInfoWithLinksResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.NavigationGetObjectInfoWithLinks(ctx, req.(*pb.RpcNavigationGetObjectInfoWithLinksRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "NavigationGetObjectInfoWithLinks", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcNavigationGetObjectInfoWithLinksResponse) +} +func (h *ClientCommandsHandlerProxy) TemplateCreateFromObject(ctx context.Context, req *pb.RpcTemplateCreateFromObjectRequest) *pb.RpcTemplateCreateFromObjectResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.TemplateCreateFromObject(ctx, req.(*pb.RpcTemplateCreateFromObjectRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "TemplateCreateFromObject", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcTemplateCreateFromObjectResponse) +} +func (h *ClientCommandsHandlerProxy) TemplateClone(ctx context.Context, req *pb.RpcTemplateCloneRequest) *pb.RpcTemplateCloneResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.TemplateClone(ctx, req.(*pb.RpcTemplateCloneRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "TemplateClone", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcTemplateCloneResponse) +} +func (h *ClientCommandsHandlerProxy) TemplateExportAll(ctx context.Context, req *pb.RpcTemplateExportAllRequest) *pb.RpcTemplateExportAllResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.TemplateExportAll(ctx, req.(*pb.RpcTemplateExportAllRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "TemplateExportAll", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcTemplateExportAllResponse) +} +func (h *ClientCommandsHandlerProxy) LinkPreview(ctx context.Context, req *pb.RpcLinkPreviewRequest) *pb.RpcLinkPreviewResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.LinkPreview(ctx, req.(*pb.RpcLinkPreviewRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "LinkPreview", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcLinkPreviewResponse) +} +func (h *ClientCommandsHandlerProxy) UnsplashSearch(ctx context.Context, req *pb.RpcUnsplashSearchRequest) *pb.RpcUnsplashSearchResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.UnsplashSearch(ctx, req.(*pb.RpcUnsplashSearchRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "UnsplashSearch", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcUnsplashSearchResponse) +} +func (h *ClientCommandsHandlerProxy) UnsplashDownload(ctx context.Context, req *pb.RpcUnsplashDownloadRequest) *pb.RpcUnsplashDownloadResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.UnsplashDownload(ctx, req.(*pb.RpcUnsplashDownloadRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "UnsplashDownload", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcUnsplashDownloadResponse) +} +func (h *ClientCommandsHandlerProxy) GalleryDownloadManifest(ctx context.Context, req *pb.RpcGalleryDownloadManifestRequest) *pb.RpcGalleryDownloadManifestResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.GalleryDownloadManifest(ctx, req.(*pb.RpcGalleryDownloadManifestRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "GalleryDownloadManifest", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcGalleryDownloadManifestResponse) +} +func (h *ClientCommandsHandlerProxy) GalleryDownloadIndex(ctx context.Context, req *pb.RpcGalleryDownloadIndexRequest) *pb.RpcGalleryDownloadIndexResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.GalleryDownloadIndex(ctx, req.(*pb.RpcGalleryDownloadIndexRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "GalleryDownloadIndex", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcGalleryDownloadIndexResponse) +} +func (h *ClientCommandsHandlerProxy) BlockUpload(ctx context.Context, req *pb.RpcBlockUploadRequest) *pb.RpcBlockUploadResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockUpload(ctx, req.(*pb.RpcBlockUploadRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockUpload", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockUploadResponse) +} +func (h *ClientCommandsHandlerProxy) BlockReplace(ctx context.Context, req *pb.RpcBlockReplaceRequest) *pb.RpcBlockReplaceResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockReplace(ctx, req.(*pb.RpcBlockReplaceRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockReplace", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockReplaceResponse) +} +func (h *ClientCommandsHandlerProxy) BlockCreate(ctx context.Context, req *pb.RpcBlockCreateRequest) *pb.RpcBlockCreateResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockCreate(ctx, req.(*pb.RpcBlockCreateRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockCreate", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockCreateResponse) +} +func (h *ClientCommandsHandlerProxy) BlockSplit(ctx context.Context, req *pb.RpcBlockSplitRequest) *pb.RpcBlockSplitResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockSplit(ctx, req.(*pb.RpcBlockSplitRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockSplit", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockSplitResponse) +} +func (h *ClientCommandsHandlerProxy) BlockMerge(ctx context.Context, req *pb.RpcBlockMergeRequest) *pb.RpcBlockMergeResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockMerge(ctx, req.(*pb.RpcBlockMergeRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockMerge", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockMergeResponse) +} +func (h *ClientCommandsHandlerProxy) BlockCopy(ctx context.Context, req *pb.RpcBlockCopyRequest) *pb.RpcBlockCopyResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockCopy(ctx, req.(*pb.RpcBlockCopyRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockCopy", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockCopyResponse) +} +func (h *ClientCommandsHandlerProxy) BlockPaste(ctx context.Context, req *pb.RpcBlockPasteRequest) *pb.RpcBlockPasteResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockPaste(ctx, req.(*pb.RpcBlockPasteRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockPaste", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockPasteResponse) +} +func (h *ClientCommandsHandlerProxy) BlockCut(ctx context.Context, req *pb.RpcBlockCutRequest) *pb.RpcBlockCutResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockCut(ctx, req.(*pb.RpcBlockCutRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockCut", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockCutResponse) +} +func (h *ClientCommandsHandlerProxy) BlockSetFields(ctx context.Context, req *pb.RpcBlockSetFieldsRequest) *pb.RpcBlockSetFieldsResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockSetFields(ctx, req.(*pb.RpcBlockSetFieldsRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockSetFields", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockSetFieldsResponse) +} +func (h *ClientCommandsHandlerProxy) BlockExport(ctx context.Context, req *pb.RpcBlockExportRequest) *pb.RpcBlockExportResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockExport(ctx, req.(*pb.RpcBlockExportRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockExport", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockExportResponse) +} +func (h *ClientCommandsHandlerProxy) BlockSetCarriage(ctx context.Context, req *pb.RpcBlockSetCarriageRequest) *pb.RpcBlockSetCarriageResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockSetCarriage(ctx, req.(*pb.RpcBlockSetCarriageRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockSetCarriage", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockSetCarriageResponse) +} +func (h *ClientCommandsHandlerProxy) BlockPreview(ctx context.Context, req *pb.RpcBlockPreviewRequest) *pb.RpcBlockPreviewResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockPreview(ctx, req.(*pb.RpcBlockPreviewRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockPreview", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockPreviewResponse) +} +func (h *ClientCommandsHandlerProxy) BlockListDelete(ctx context.Context, req *pb.RpcBlockListDeleteRequest) *pb.RpcBlockListDeleteResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockListDelete(ctx, req.(*pb.RpcBlockListDeleteRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockListDelete", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockListDeleteResponse) +} +func (h *ClientCommandsHandlerProxy) BlockListMoveToExistingObject(ctx context.Context, req *pb.RpcBlockListMoveToExistingObjectRequest) *pb.RpcBlockListMoveToExistingObjectResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockListMoveToExistingObject(ctx, req.(*pb.RpcBlockListMoveToExistingObjectRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockListMoveToExistingObject", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockListMoveToExistingObjectResponse) +} +func (h *ClientCommandsHandlerProxy) BlockListMoveToNewObject(ctx context.Context, req *pb.RpcBlockListMoveToNewObjectRequest) *pb.RpcBlockListMoveToNewObjectResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockListMoveToNewObject(ctx, req.(*pb.RpcBlockListMoveToNewObjectRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockListMoveToNewObject", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockListMoveToNewObjectResponse) +} +func (h *ClientCommandsHandlerProxy) BlockListConvertToObjects(ctx context.Context, req *pb.RpcBlockListConvertToObjectsRequest) *pb.RpcBlockListConvertToObjectsResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockListConvertToObjects(ctx, req.(*pb.RpcBlockListConvertToObjectsRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockListConvertToObjects", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockListConvertToObjectsResponse) +} +func (h *ClientCommandsHandlerProxy) BlockListSetFields(ctx context.Context, req *pb.RpcBlockListSetFieldsRequest) *pb.RpcBlockListSetFieldsResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockListSetFields(ctx, req.(*pb.RpcBlockListSetFieldsRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockListSetFields", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockListSetFieldsResponse) +} +func (h *ClientCommandsHandlerProxy) BlockListDuplicate(ctx context.Context, req *pb.RpcBlockListDuplicateRequest) *pb.RpcBlockListDuplicateResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockListDuplicate(ctx, req.(*pb.RpcBlockListDuplicateRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockListDuplicate", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockListDuplicateResponse) +} +func (h *ClientCommandsHandlerProxy) BlockListSetBackgroundColor(ctx context.Context, req *pb.RpcBlockListSetBackgroundColorRequest) *pb.RpcBlockListSetBackgroundColorResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockListSetBackgroundColor(ctx, req.(*pb.RpcBlockListSetBackgroundColorRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockListSetBackgroundColor", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockListSetBackgroundColorResponse) +} +func (h *ClientCommandsHandlerProxy) BlockListSetAlign(ctx context.Context, req *pb.RpcBlockListSetAlignRequest) *pb.RpcBlockListSetAlignResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockListSetAlign(ctx, req.(*pb.RpcBlockListSetAlignRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockListSetAlign", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockListSetAlignResponse) +} +func (h *ClientCommandsHandlerProxy) BlockListSetVerticalAlign(ctx context.Context, req *pb.RpcBlockListSetVerticalAlignRequest) *pb.RpcBlockListSetVerticalAlignResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockListSetVerticalAlign(ctx, req.(*pb.RpcBlockListSetVerticalAlignRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockListSetVerticalAlign", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockListSetVerticalAlignResponse) +} +func (h *ClientCommandsHandlerProxy) BlockListTurnInto(ctx context.Context, req *pb.RpcBlockListTurnIntoRequest) *pb.RpcBlockListTurnIntoResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockListTurnInto(ctx, req.(*pb.RpcBlockListTurnIntoRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockListTurnInto", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockListTurnIntoResponse) +} +func (h *ClientCommandsHandlerProxy) BlockTextSetText(ctx context.Context, req *pb.RpcBlockTextSetTextRequest) *pb.RpcBlockTextSetTextResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockTextSetText(ctx, req.(*pb.RpcBlockTextSetTextRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockTextSetText", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockTextSetTextResponse) +} +func (h *ClientCommandsHandlerProxy) BlockTextSetColor(ctx context.Context, req *pb.RpcBlockTextSetColorRequest) *pb.RpcBlockTextSetColorResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockTextSetColor(ctx, req.(*pb.RpcBlockTextSetColorRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockTextSetColor", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockTextSetColorResponse) +} +func (h *ClientCommandsHandlerProxy) BlockTextSetStyle(ctx context.Context, req *pb.RpcBlockTextSetStyleRequest) *pb.RpcBlockTextSetStyleResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockTextSetStyle(ctx, req.(*pb.RpcBlockTextSetStyleRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockTextSetStyle", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockTextSetStyleResponse) +} +func (h *ClientCommandsHandlerProxy) BlockTextSetChecked(ctx context.Context, req *pb.RpcBlockTextSetCheckedRequest) *pb.RpcBlockTextSetCheckedResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockTextSetChecked(ctx, req.(*pb.RpcBlockTextSetCheckedRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockTextSetChecked", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockTextSetCheckedResponse) +} +func (h *ClientCommandsHandlerProxy) BlockTextSetIcon(ctx context.Context, req *pb.RpcBlockTextSetIconRequest) *pb.RpcBlockTextSetIconResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockTextSetIcon(ctx, req.(*pb.RpcBlockTextSetIconRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockTextSetIcon", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockTextSetIconResponse) +} +func (h *ClientCommandsHandlerProxy) BlockTextListSetColor(ctx context.Context, req *pb.RpcBlockTextListSetColorRequest) *pb.RpcBlockTextListSetColorResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockTextListSetColor(ctx, req.(*pb.RpcBlockTextListSetColorRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockTextListSetColor", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockTextListSetColorResponse) +} +func (h *ClientCommandsHandlerProxy) BlockTextListSetMark(ctx context.Context, req *pb.RpcBlockTextListSetMarkRequest) *pb.RpcBlockTextListSetMarkResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockTextListSetMark(ctx, req.(*pb.RpcBlockTextListSetMarkRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockTextListSetMark", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockTextListSetMarkResponse) +} +func (h *ClientCommandsHandlerProxy) BlockTextListSetStyle(ctx context.Context, req *pb.RpcBlockTextListSetStyleRequest) *pb.RpcBlockTextListSetStyleResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockTextListSetStyle(ctx, req.(*pb.RpcBlockTextListSetStyleRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockTextListSetStyle", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockTextListSetStyleResponse) +} +func (h *ClientCommandsHandlerProxy) BlockTextListClearStyle(ctx context.Context, req *pb.RpcBlockTextListClearStyleRequest) *pb.RpcBlockTextListClearStyleResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockTextListClearStyle(ctx, req.(*pb.RpcBlockTextListClearStyleRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockTextListClearStyle", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockTextListClearStyleResponse) +} +func (h *ClientCommandsHandlerProxy) BlockTextListClearContent(ctx context.Context, req *pb.RpcBlockTextListClearContentRequest) *pb.RpcBlockTextListClearContentResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockTextListClearContent(ctx, req.(*pb.RpcBlockTextListClearContentRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockTextListClearContent", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockTextListClearContentResponse) +} +func (h *ClientCommandsHandlerProxy) BlockFileSetName(ctx context.Context, req *pb.RpcBlockFileSetNameRequest) *pb.RpcBlockFileSetNameResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockFileSetName(ctx, req.(*pb.RpcBlockFileSetNameRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockFileSetName", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockFileSetNameResponse) +} +func (h *ClientCommandsHandlerProxy) BlockFileSetTargetObjectId(ctx context.Context, req *pb.RpcBlockFileSetTargetObjectIdRequest) *pb.RpcBlockFileSetTargetObjectIdResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockFileSetTargetObjectId(ctx, req.(*pb.RpcBlockFileSetTargetObjectIdRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockFileSetTargetObjectId", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockFileSetTargetObjectIdResponse) +} +func (h *ClientCommandsHandlerProxy) BlockImageSetName(ctx context.Context, req *pb.RpcBlockImageSetNameRequest) *pb.RpcBlockImageSetNameResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockImageSetName(ctx, req.(*pb.RpcBlockImageSetNameRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockImageSetName", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockImageSetNameResponse) +} +func (h *ClientCommandsHandlerProxy) BlockVideoSetName(ctx context.Context, req *pb.RpcBlockVideoSetNameRequest) *pb.RpcBlockVideoSetNameResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockVideoSetName(ctx, req.(*pb.RpcBlockVideoSetNameRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockVideoSetName", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockVideoSetNameResponse) +} +func (h *ClientCommandsHandlerProxy) BlockFileCreateAndUpload(ctx context.Context, req *pb.RpcBlockFileCreateAndUploadRequest) *pb.RpcBlockFileCreateAndUploadResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockFileCreateAndUpload(ctx, req.(*pb.RpcBlockFileCreateAndUploadRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockFileCreateAndUpload", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockFileCreateAndUploadResponse) +} +func (h *ClientCommandsHandlerProxy) BlockFileListSetStyle(ctx context.Context, req *pb.RpcBlockFileListSetStyleRequest) *pb.RpcBlockFileListSetStyleResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockFileListSetStyle(ctx, req.(*pb.RpcBlockFileListSetStyleRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockFileListSetStyle", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockFileListSetStyleResponse) +} +func (h *ClientCommandsHandlerProxy) BlockDataviewViewCreate(ctx context.Context, req *pb.RpcBlockDataviewViewCreateRequest) *pb.RpcBlockDataviewViewCreateResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockDataviewViewCreate(ctx, req.(*pb.RpcBlockDataviewViewCreateRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockDataviewViewCreate", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockDataviewViewCreateResponse) +} +func (h *ClientCommandsHandlerProxy) BlockDataviewViewDelete(ctx context.Context, req *pb.RpcBlockDataviewViewDeleteRequest) *pb.RpcBlockDataviewViewDeleteResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockDataviewViewDelete(ctx, req.(*pb.RpcBlockDataviewViewDeleteRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockDataviewViewDelete", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockDataviewViewDeleteResponse) +} +func (h *ClientCommandsHandlerProxy) BlockDataviewViewUpdate(ctx context.Context, req *pb.RpcBlockDataviewViewUpdateRequest) *pb.RpcBlockDataviewViewUpdateResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockDataviewViewUpdate(ctx, req.(*pb.RpcBlockDataviewViewUpdateRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockDataviewViewUpdate", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockDataviewViewUpdateResponse) +} +func (h *ClientCommandsHandlerProxy) BlockDataviewViewSetActive(ctx context.Context, req *pb.RpcBlockDataviewViewSetActiveRequest) *pb.RpcBlockDataviewViewSetActiveResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockDataviewViewSetActive(ctx, req.(*pb.RpcBlockDataviewViewSetActiveRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockDataviewViewSetActive", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockDataviewViewSetActiveResponse) +} +func (h *ClientCommandsHandlerProxy) BlockDataviewViewSetPosition(ctx context.Context, req *pb.RpcBlockDataviewViewSetPositionRequest) *pb.RpcBlockDataviewViewSetPositionResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockDataviewViewSetPosition(ctx, req.(*pb.RpcBlockDataviewViewSetPositionRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockDataviewViewSetPosition", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockDataviewViewSetPositionResponse) +} +func (h *ClientCommandsHandlerProxy) BlockDataviewSetSource(ctx context.Context, req *pb.RpcBlockDataviewSetSourceRequest) *pb.RpcBlockDataviewSetSourceResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockDataviewSetSource(ctx, req.(*pb.RpcBlockDataviewSetSourceRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockDataviewSetSource", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockDataviewSetSourceResponse) +} +func (h *ClientCommandsHandlerProxy) BlockDataviewRelationAdd(ctx context.Context, req *pb.RpcBlockDataviewRelationAddRequest) *pb.RpcBlockDataviewRelationAddResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockDataviewRelationAdd(ctx, req.(*pb.RpcBlockDataviewRelationAddRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockDataviewRelationAdd", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockDataviewRelationAddResponse) +} +func (h *ClientCommandsHandlerProxy) BlockDataviewRelationDelete(ctx context.Context, req *pb.RpcBlockDataviewRelationDeleteRequest) *pb.RpcBlockDataviewRelationDeleteResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockDataviewRelationDelete(ctx, req.(*pb.RpcBlockDataviewRelationDeleteRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockDataviewRelationDelete", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockDataviewRelationDeleteResponse) +} +func (h *ClientCommandsHandlerProxy) BlockDataviewRelationListAvailable(ctx context.Context, req *pb.RpcBlockDataviewRelationListAvailableRequest) *pb.RpcBlockDataviewRelationListAvailableResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockDataviewRelationListAvailable(ctx, req.(*pb.RpcBlockDataviewRelationListAvailableRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockDataviewRelationListAvailable", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockDataviewRelationListAvailableResponse) +} +func (h *ClientCommandsHandlerProxy) BlockDataviewGroupOrderUpdate(ctx context.Context, req *pb.RpcBlockDataviewGroupOrderUpdateRequest) *pb.RpcBlockDataviewGroupOrderUpdateResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockDataviewGroupOrderUpdate(ctx, req.(*pb.RpcBlockDataviewGroupOrderUpdateRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockDataviewGroupOrderUpdate", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockDataviewGroupOrderUpdateResponse) +} +func (h *ClientCommandsHandlerProxy) BlockDataviewObjectOrderUpdate(ctx context.Context, req *pb.RpcBlockDataviewObjectOrderUpdateRequest) *pb.RpcBlockDataviewObjectOrderUpdateResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockDataviewObjectOrderUpdate(ctx, req.(*pb.RpcBlockDataviewObjectOrderUpdateRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockDataviewObjectOrderUpdate", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockDataviewObjectOrderUpdateResponse) +} +func (h *ClientCommandsHandlerProxy) BlockDataviewObjectOrderMove(ctx context.Context, req *pb.RpcBlockDataviewObjectOrderMoveRequest) *pb.RpcBlockDataviewObjectOrderMoveResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockDataviewObjectOrderMove(ctx, req.(*pb.RpcBlockDataviewObjectOrderMoveRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockDataviewObjectOrderMove", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockDataviewObjectOrderMoveResponse) +} +func (h *ClientCommandsHandlerProxy) BlockDataviewCreateFromExistingObject(ctx context.Context, req *pb.RpcBlockDataviewCreateFromExistingObjectRequest) *pb.RpcBlockDataviewCreateFromExistingObjectResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockDataviewCreateFromExistingObject(ctx, req.(*pb.RpcBlockDataviewCreateFromExistingObjectRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockDataviewCreateFromExistingObject", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockDataviewCreateFromExistingObjectResponse) +} +func (h *ClientCommandsHandlerProxy) BlockDataviewFilterAdd(ctx context.Context, req *pb.RpcBlockDataviewFilterAddRequest) *pb.RpcBlockDataviewFilterAddResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockDataviewFilterAdd(ctx, req.(*pb.RpcBlockDataviewFilterAddRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockDataviewFilterAdd", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockDataviewFilterAddResponse) +} +func (h *ClientCommandsHandlerProxy) BlockDataviewFilterRemove(ctx context.Context, req *pb.RpcBlockDataviewFilterRemoveRequest) *pb.RpcBlockDataviewFilterRemoveResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockDataviewFilterRemove(ctx, req.(*pb.RpcBlockDataviewFilterRemoveRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockDataviewFilterRemove", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockDataviewFilterRemoveResponse) +} +func (h *ClientCommandsHandlerProxy) BlockDataviewFilterReplace(ctx context.Context, req *pb.RpcBlockDataviewFilterReplaceRequest) *pb.RpcBlockDataviewFilterReplaceResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockDataviewFilterReplace(ctx, req.(*pb.RpcBlockDataviewFilterReplaceRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockDataviewFilterReplace", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockDataviewFilterReplaceResponse) +} +func (h *ClientCommandsHandlerProxy) BlockDataviewFilterSort(ctx context.Context, req *pb.RpcBlockDataviewFilterSortRequest) *pb.RpcBlockDataviewFilterSortResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockDataviewFilterSort(ctx, req.(*pb.RpcBlockDataviewFilterSortRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockDataviewFilterSort", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockDataviewFilterSortResponse) +} +func (h *ClientCommandsHandlerProxy) BlockDataviewSortAdd(ctx context.Context, req *pb.RpcBlockDataviewSortAddRequest) *pb.RpcBlockDataviewSortAddResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockDataviewSortAdd(ctx, req.(*pb.RpcBlockDataviewSortAddRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockDataviewSortAdd", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockDataviewSortAddResponse) +} +func (h *ClientCommandsHandlerProxy) BlockDataviewSortRemove(ctx context.Context, req *pb.RpcBlockDataviewSortRemoveRequest) *pb.RpcBlockDataviewSortRemoveResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockDataviewSortRemove(ctx, req.(*pb.RpcBlockDataviewSortRemoveRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockDataviewSortRemove", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockDataviewSortRemoveResponse) +} +func (h *ClientCommandsHandlerProxy) BlockDataviewSortReplace(ctx context.Context, req *pb.RpcBlockDataviewSortReplaceRequest) *pb.RpcBlockDataviewSortReplaceResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockDataviewSortReplace(ctx, req.(*pb.RpcBlockDataviewSortReplaceRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockDataviewSortReplace", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockDataviewSortReplaceResponse) +} +func (h *ClientCommandsHandlerProxy) BlockDataviewSortSort(ctx context.Context, req *pb.RpcBlockDataviewSortSSortRequest) *pb.RpcBlockDataviewSortSSortResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockDataviewSortSort(ctx, req.(*pb.RpcBlockDataviewSortSSortRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockDataviewSortSort", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockDataviewSortSSortResponse) +} +func (h *ClientCommandsHandlerProxy) BlockDataviewViewRelationAdd(ctx context.Context, req *pb.RpcBlockDataviewViewRelationAddRequest) *pb.RpcBlockDataviewViewRelationAddResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockDataviewViewRelationAdd(ctx, req.(*pb.RpcBlockDataviewViewRelationAddRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockDataviewViewRelationAdd", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockDataviewViewRelationAddResponse) +} +func (h *ClientCommandsHandlerProxy) BlockDataviewViewRelationRemove(ctx context.Context, req *pb.RpcBlockDataviewViewRelationRemoveRequest) *pb.RpcBlockDataviewViewRelationRemoveResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockDataviewViewRelationRemove(ctx, req.(*pb.RpcBlockDataviewViewRelationRemoveRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockDataviewViewRelationRemove", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockDataviewViewRelationRemoveResponse) +} +func (h *ClientCommandsHandlerProxy) BlockDataviewViewRelationReplace(ctx context.Context, req *pb.RpcBlockDataviewViewRelationReplaceRequest) *pb.RpcBlockDataviewViewRelationReplaceResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockDataviewViewRelationReplace(ctx, req.(*pb.RpcBlockDataviewViewRelationReplaceRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockDataviewViewRelationReplace", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockDataviewViewRelationReplaceResponse) +} +func (h *ClientCommandsHandlerProxy) BlockDataviewViewRelationSort(ctx context.Context, req *pb.RpcBlockDataviewViewRelationSortRequest) *pb.RpcBlockDataviewViewRelationSortResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockDataviewViewRelationSort(ctx, req.(*pb.RpcBlockDataviewViewRelationSortRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockDataviewViewRelationSort", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockDataviewViewRelationSortResponse) +} +func (h *ClientCommandsHandlerProxy) BlockTableCreate(ctx context.Context, req *pb.RpcBlockTableCreateRequest) *pb.RpcBlockTableCreateResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockTableCreate(ctx, req.(*pb.RpcBlockTableCreateRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockTableCreate", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockTableCreateResponse) +} +func (h *ClientCommandsHandlerProxy) BlockTableExpand(ctx context.Context, req *pb.RpcBlockTableExpandRequest) *pb.RpcBlockTableExpandResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockTableExpand(ctx, req.(*pb.RpcBlockTableExpandRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockTableExpand", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockTableExpandResponse) +} +func (h *ClientCommandsHandlerProxy) BlockTableRowCreate(ctx context.Context, req *pb.RpcBlockTableRowCreateRequest) *pb.RpcBlockTableRowCreateResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockTableRowCreate(ctx, req.(*pb.RpcBlockTableRowCreateRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockTableRowCreate", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockTableRowCreateResponse) +} +func (h *ClientCommandsHandlerProxy) BlockTableRowDelete(ctx context.Context, req *pb.RpcBlockTableRowDeleteRequest) *pb.RpcBlockTableRowDeleteResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockTableRowDelete(ctx, req.(*pb.RpcBlockTableRowDeleteRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockTableRowDelete", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockTableRowDeleteResponse) +} +func (h *ClientCommandsHandlerProxy) BlockTableRowDuplicate(ctx context.Context, req *pb.RpcBlockTableRowDuplicateRequest) *pb.RpcBlockTableRowDuplicateResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockTableRowDuplicate(ctx, req.(*pb.RpcBlockTableRowDuplicateRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockTableRowDuplicate", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockTableRowDuplicateResponse) +} +func (h *ClientCommandsHandlerProxy) BlockTableRowSetHeader(ctx context.Context, req *pb.RpcBlockTableRowSetHeaderRequest) *pb.RpcBlockTableRowSetHeaderResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockTableRowSetHeader(ctx, req.(*pb.RpcBlockTableRowSetHeaderRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockTableRowSetHeader", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockTableRowSetHeaderResponse) +} +func (h *ClientCommandsHandlerProxy) BlockTableColumnCreate(ctx context.Context, req *pb.RpcBlockTableColumnCreateRequest) *pb.RpcBlockTableColumnCreateResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockTableColumnCreate(ctx, req.(*pb.RpcBlockTableColumnCreateRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockTableColumnCreate", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockTableColumnCreateResponse) +} +func (h *ClientCommandsHandlerProxy) BlockTableColumnMove(ctx context.Context, req *pb.RpcBlockTableColumnMoveRequest) *pb.RpcBlockTableColumnMoveResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockTableColumnMove(ctx, req.(*pb.RpcBlockTableColumnMoveRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockTableColumnMove", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockTableColumnMoveResponse) +} +func (h *ClientCommandsHandlerProxy) BlockTableColumnDelete(ctx context.Context, req *pb.RpcBlockTableColumnDeleteRequest) *pb.RpcBlockTableColumnDeleteResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockTableColumnDelete(ctx, req.(*pb.RpcBlockTableColumnDeleteRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockTableColumnDelete", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockTableColumnDeleteResponse) +} +func (h *ClientCommandsHandlerProxy) BlockTableColumnDuplicate(ctx context.Context, req *pb.RpcBlockTableColumnDuplicateRequest) *pb.RpcBlockTableColumnDuplicateResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockTableColumnDuplicate(ctx, req.(*pb.RpcBlockTableColumnDuplicateRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockTableColumnDuplicate", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockTableColumnDuplicateResponse) +} +func (h *ClientCommandsHandlerProxy) BlockTableRowListFill(ctx context.Context, req *pb.RpcBlockTableRowListFillRequest) *pb.RpcBlockTableRowListFillResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockTableRowListFill(ctx, req.(*pb.RpcBlockTableRowListFillRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockTableRowListFill", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockTableRowListFillResponse) +} +func (h *ClientCommandsHandlerProxy) BlockTableRowListClean(ctx context.Context, req *pb.RpcBlockTableRowListCleanRequest) *pb.RpcBlockTableRowListCleanResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockTableRowListClean(ctx, req.(*pb.RpcBlockTableRowListCleanRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockTableRowListClean", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockTableRowListCleanResponse) +} +func (h *ClientCommandsHandlerProxy) BlockTableColumnListFill(ctx context.Context, req *pb.RpcBlockTableColumnListFillRequest) *pb.RpcBlockTableColumnListFillResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockTableColumnListFill(ctx, req.(*pb.RpcBlockTableColumnListFillRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockTableColumnListFill", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockTableColumnListFillResponse) +} +func (h *ClientCommandsHandlerProxy) BlockTableSort(ctx context.Context, req *pb.RpcBlockTableSortRequest) *pb.RpcBlockTableSortResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockTableSort(ctx, req.(*pb.RpcBlockTableSortRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockTableSort", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockTableSortResponse) +} +func (h *ClientCommandsHandlerProxy) BlockCreateWidget(ctx context.Context, req *pb.RpcBlockCreateWidgetRequest) *pb.RpcBlockCreateWidgetResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockCreateWidget(ctx, req.(*pb.RpcBlockCreateWidgetRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockCreateWidget", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockCreateWidgetResponse) +} +func (h *ClientCommandsHandlerProxy) BlockWidgetSetTargetId(ctx context.Context, req *pb.RpcBlockWidgetSetTargetIdRequest) *pb.RpcBlockWidgetSetTargetIdResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockWidgetSetTargetId(ctx, req.(*pb.RpcBlockWidgetSetTargetIdRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockWidgetSetTargetId", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockWidgetSetTargetIdResponse) +} +func (h *ClientCommandsHandlerProxy) BlockWidgetSetLayout(ctx context.Context, req *pb.RpcBlockWidgetSetLayoutRequest) *pb.RpcBlockWidgetSetLayoutResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockWidgetSetLayout(ctx, req.(*pb.RpcBlockWidgetSetLayoutRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockWidgetSetLayout", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockWidgetSetLayoutResponse) +} +func (h *ClientCommandsHandlerProxy) BlockWidgetSetLimit(ctx context.Context, req *pb.RpcBlockWidgetSetLimitRequest) *pb.RpcBlockWidgetSetLimitResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockWidgetSetLimit(ctx, req.(*pb.RpcBlockWidgetSetLimitRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockWidgetSetLimit", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockWidgetSetLimitResponse) +} +func (h *ClientCommandsHandlerProxy) BlockWidgetSetViewId(ctx context.Context, req *pb.RpcBlockWidgetSetViewIdRequest) *pb.RpcBlockWidgetSetViewIdResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockWidgetSetViewId(ctx, req.(*pb.RpcBlockWidgetSetViewIdRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockWidgetSetViewId", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockWidgetSetViewIdResponse) +} +func (h *ClientCommandsHandlerProxy) BlockLinkCreateWithObject(ctx context.Context, req *pb.RpcBlockLinkCreateWithObjectRequest) *pb.RpcBlockLinkCreateWithObjectResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockLinkCreateWithObject(ctx, req.(*pb.RpcBlockLinkCreateWithObjectRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockLinkCreateWithObject", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockLinkCreateWithObjectResponse) +} +func (h *ClientCommandsHandlerProxy) BlockLinkListSetAppearance(ctx context.Context, req *pb.RpcBlockLinkListSetAppearanceRequest) *pb.RpcBlockLinkListSetAppearanceResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockLinkListSetAppearance(ctx, req.(*pb.RpcBlockLinkListSetAppearanceRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockLinkListSetAppearance", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockLinkListSetAppearanceResponse) +} +func (h *ClientCommandsHandlerProxy) BlockBookmarkFetch(ctx context.Context, req *pb.RpcBlockBookmarkFetchRequest) *pb.RpcBlockBookmarkFetchResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockBookmarkFetch(ctx, req.(*pb.RpcBlockBookmarkFetchRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockBookmarkFetch", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockBookmarkFetchResponse) +} +func (h *ClientCommandsHandlerProxy) BlockBookmarkCreateAndFetch(ctx context.Context, req *pb.RpcBlockBookmarkCreateAndFetchRequest) *pb.RpcBlockBookmarkCreateAndFetchResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockBookmarkCreateAndFetch(ctx, req.(*pb.RpcBlockBookmarkCreateAndFetchRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockBookmarkCreateAndFetch", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockBookmarkCreateAndFetchResponse) +} +func (h *ClientCommandsHandlerProxy) BlockRelationSetKey(ctx context.Context, req *pb.RpcBlockRelationSetKeyRequest) *pb.RpcBlockRelationSetKeyResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockRelationSetKey(ctx, req.(*pb.RpcBlockRelationSetKeyRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockRelationSetKey", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockRelationSetKeyResponse) +} +func (h *ClientCommandsHandlerProxy) BlockRelationAdd(ctx context.Context, req *pb.RpcBlockRelationAddRequest) *pb.RpcBlockRelationAddResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockRelationAdd(ctx, req.(*pb.RpcBlockRelationAddRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockRelationAdd", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockRelationAddResponse) +} +func (h *ClientCommandsHandlerProxy) BlockDivListSetStyle(ctx context.Context, req *pb.RpcBlockDivListSetStyleRequest) *pb.RpcBlockDivListSetStyleResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockDivListSetStyle(ctx, req.(*pb.RpcBlockDivListSetStyleRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockDivListSetStyle", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockDivListSetStyleResponse) +} +func (h *ClientCommandsHandlerProxy) BlockLatexSetText(ctx context.Context, req *pb.RpcBlockLatexSetTextRequest) *pb.RpcBlockLatexSetTextResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BlockLatexSetText(ctx, req.(*pb.RpcBlockLatexSetTextRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BlockLatexSetText", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBlockLatexSetTextResponse) +} +func (h *ClientCommandsHandlerProxy) ProcessCancel(ctx context.Context, req *pb.RpcProcessCancelRequest) *pb.RpcProcessCancelResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.ProcessCancel(ctx, req.(*pb.RpcProcessCancelRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "ProcessCancel", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcProcessCancelResponse) +} +func (h *ClientCommandsHandlerProxy) LogSend(ctx context.Context, req *pb.RpcLogSendRequest) *pb.RpcLogSendResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.LogSend(ctx, req.(*pb.RpcLogSendRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "LogSend", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcLogSendResponse) +} +func (h *ClientCommandsHandlerProxy) DebugStat(ctx context.Context, req *pb.RpcDebugStatRequest) *pb.RpcDebugStatResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.DebugStat(ctx, req.(*pb.RpcDebugStatRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "DebugStat", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcDebugStatResponse) +} +func (h *ClientCommandsHandlerProxy) DebugTree(ctx context.Context, req *pb.RpcDebugTreeRequest) *pb.RpcDebugTreeResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.DebugTree(ctx, req.(*pb.RpcDebugTreeRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "DebugTree", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcDebugTreeResponse) +} +func (h *ClientCommandsHandlerProxy) DebugTreeHeads(ctx context.Context, req *pb.RpcDebugTreeHeadsRequest) *pb.RpcDebugTreeHeadsResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.DebugTreeHeads(ctx, req.(*pb.RpcDebugTreeHeadsRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "DebugTreeHeads", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcDebugTreeHeadsResponse) +} +func (h *ClientCommandsHandlerProxy) DebugSpaceSummary(ctx context.Context, req *pb.RpcDebugSpaceSummaryRequest) *pb.RpcDebugSpaceSummaryResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.DebugSpaceSummary(ctx, req.(*pb.RpcDebugSpaceSummaryRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "DebugSpaceSummary", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcDebugSpaceSummaryResponse) +} +func (h *ClientCommandsHandlerProxy) DebugStackGoroutines(ctx context.Context, req *pb.RpcDebugStackGoroutinesRequest) *pb.RpcDebugStackGoroutinesResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.DebugStackGoroutines(ctx, req.(*pb.RpcDebugStackGoroutinesRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "DebugStackGoroutines", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcDebugStackGoroutinesResponse) +} +func (h *ClientCommandsHandlerProxy) DebugExportLocalstore(ctx context.Context, req *pb.RpcDebugExportLocalstoreRequest) *pb.RpcDebugExportLocalstoreResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.DebugExportLocalstore(ctx, req.(*pb.RpcDebugExportLocalstoreRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "DebugExportLocalstore", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcDebugExportLocalstoreResponse) +} +func (h *ClientCommandsHandlerProxy) DebugPing(ctx context.Context, req *pb.RpcDebugPingRequest) *pb.RpcDebugPingResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.DebugPing(ctx, req.(*pb.RpcDebugPingRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "DebugPing", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcDebugPingResponse) +} +func (h *ClientCommandsHandlerProxy) DebugSubscriptions(ctx context.Context, req *pb.RpcDebugSubscriptionsRequest) *pb.RpcDebugSubscriptionsResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.DebugSubscriptions(ctx, req.(*pb.RpcDebugSubscriptionsRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "DebugSubscriptions", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcDebugSubscriptionsResponse) +} +func (h *ClientCommandsHandlerProxy) DebugOpenedObjects(ctx context.Context, req *pb.RpcDebugOpenedObjectsRequest) *pb.RpcDebugOpenedObjectsResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.DebugOpenedObjects(ctx, req.(*pb.RpcDebugOpenedObjectsRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "DebugOpenedObjects", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcDebugOpenedObjectsResponse) +} +func (h *ClientCommandsHandlerProxy) MetricsSetParameters(ctx context.Context, req *pb.RpcMetricsSetParametersRequest) *pb.RpcMetricsSetParametersResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.MetricsSetParameters(ctx, req.(*pb.RpcMetricsSetParametersRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "MetricsSetParameters", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcMetricsSetParametersResponse) +} +func (h *ClientCommandsHandlerProxy) NotificationList(ctx context.Context, req *pb.RpcNotificationListRequest) *pb.RpcNotificationListResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.NotificationList(ctx, req.(*pb.RpcNotificationListRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "NotificationList", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcNotificationListResponse) +} +func (h *ClientCommandsHandlerProxy) NotificationReply(ctx context.Context, req *pb.RpcNotificationReplyRequest) *pb.RpcNotificationReplyResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.NotificationReply(ctx, req.(*pb.RpcNotificationReplyRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "NotificationReply", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcNotificationReplyResponse) +} +func (h *ClientCommandsHandlerProxy) NotificationTest(ctx context.Context, req *pb.RpcNotificationTestRequest) *pb.RpcNotificationTestResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.NotificationTest(ctx, req.(*pb.RpcNotificationTestRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "NotificationTest", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcNotificationTestResponse) +} +func (h *ClientCommandsHandlerProxy) MembershipGetStatus(ctx context.Context, req *pb.RpcMembershipGetStatusRequest) *pb.RpcMembershipGetStatusResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.MembershipGetStatus(ctx, req.(*pb.RpcMembershipGetStatusRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "MembershipGetStatus", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcMembershipGetStatusResponse) +} +func (h *ClientCommandsHandlerProxy) MembershipIsNameValid(ctx context.Context, req *pb.RpcMembershipIsNameValidRequest) *pb.RpcMembershipIsNameValidResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.MembershipIsNameValid(ctx, req.(*pb.RpcMembershipIsNameValidRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "MembershipIsNameValid", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcMembershipIsNameValidResponse) +} +func (h *ClientCommandsHandlerProxy) MembershipRegisterPaymentRequest(ctx context.Context, req *pb.RpcMembershipRegisterPaymentRequestRequest) *pb.RpcMembershipRegisterPaymentRequestResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.MembershipRegisterPaymentRequest(ctx, req.(*pb.RpcMembershipRegisterPaymentRequestRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "MembershipRegisterPaymentRequest", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcMembershipRegisterPaymentRequestResponse) +} +func (h *ClientCommandsHandlerProxy) MembershipGetPortalLinkUrl(ctx context.Context, req *pb.RpcMembershipGetPortalLinkUrlRequest) *pb.RpcMembershipGetPortalLinkUrlResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.MembershipGetPortalLinkUrl(ctx, req.(*pb.RpcMembershipGetPortalLinkUrlRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "MembershipGetPortalLinkUrl", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcMembershipGetPortalLinkUrlResponse) +} +func (h *ClientCommandsHandlerProxy) MembershipGetVerificationEmailStatus(ctx context.Context, req *pb.RpcMembershipGetVerificationEmailStatusRequest) *pb.RpcMembershipGetVerificationEmailStatusResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.MembershipGetVerificationEmailStatus(ctx, req.(*pb.RpcMembershipGetVerificationEmailStatusRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "MembershipGetVerificationEmailStatus", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcMembershipGetVerificationEmailStatusResponse) +} +func (h *ClientCommandsHandlerProxy) MembershipGetVerificationEmail(ctx context.Context, req *pb.RpcMembershipGetVerificationEmailRequest) *pb.RpcMembershipGetVerificationEmailResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.MembershipGetVerificationEmail(ctx, req.(*pb.RpcMembershipGetVerificationEmailRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "MembershipGetVerificationEmail", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcMembershipGetVerificationEmailResponse) +} +func (h *ClientCommandsHandlerProxy) MembershipVerifyEmailCode(ctx context.Context, req *pb.RpcMembershipVerifyEmailCodeRequest) *pb.RpcMembershipVerifyEmailCodeResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.MembershipVerifyEmailCode(ctx, req.(*pb.RpcMembershipVerifyEmailCodeRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "MembershipVerifyEmailCode", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcMembershipVerifyEmailCodeResponse) +} +func (h *ClientCommandsHandlerProxy) MembershipFinalize(ctx context.Context, req *pb.RpcMembershipFinalizeRequest) *pb.RpcMembershipFinalizeResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.MembershipFinalize(ctx, req.(*pb.RpcMembershipFinalizeRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "MembershipFinalize", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcMembershipFinalizeResponse) +} +func (h *ClientCommandsHandlerProxy) MembershipGetTiers(ctx context.Context, req *pb.RpcMembershipGetTiersRequest) *pb.RpcMembershipGetTiersResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.MembershipGetTiers(ctx, req.(*pb.RpcMembershipGetTiersRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "MembershipGetTiers", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcMembershipGetTiersResponse) +} +func (h *ClientCommandsHandlerProxy) MembershipVerifyAppStoreReceipt(ctx context.Context, req *pb.RpcMembershipVerifyAppStoreReceiptRequest) *pb.RpcMembershipVerifyAppStoreReceiptResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.MembershipVerifyAppStoreReceipt(ctx, req.(*pb.RpcMembershipVerifyAppStoreReceiptRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "MembershipVerifyAppStoreReceipt", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcMembershipVerifyAppStoreReceiptResponse) +} +func (h *ClientCommandsHandlerProxy) NameServiceUserAccountGet(ctx context.Context, req *pb.RpcNameServiceUserAccountGetRequest) *pb.RpcNameServiceUserAccountGetResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.NameServiceUserAccountGet(ctx, req.(*pb.RpcNameServiceUserAccountGetRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "NameServiceUserAccountGet", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcNameServiceUserAccountGetResponse) +} +func (h *ClientCommandsHandlerProxy) NameServiceResolveName(ctx context.Context, req *pb.RpcNameServiceResolveNameRequest) *pb.RpcNameServiceResolveNameResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.NameServiceResolveName(ctx, req.(*pb.RpcNameServiceResolveNameRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "NameServiceResolveName", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcNameServiceResolveNameResponse) +} +func (h *ClientCommandsHandlerProxy) NameServiceResolveAnyId(ctx context.Context, req *pb.RpcNameServiceResolveAnyIdRequest) *pb.RpcNameServiceResolveAnyIdResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.NameServiceResolveAnyId(ctx, req.(*pb.RpcNameServiceResolveAnyIdRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "NameServiceResolveAnyId", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcNameServiceResolveAnyIdResponse) +} +func (h *ClientCommandsHandlerProxy) BroadcastPayloadEvent(ctx context.Context, req *pb.RpcBroadcastPayloadEventRequest) *pb.RpcBroadcastPayloadEventResponse { + actualCall := func(ctx context.Context, req any) (any, error) { + return h.client.BroadcastPayloadEvent(ctx, req.(*pb.RpcBroadcastPayloadEventRequest)), nil + } + for _, interceptor := range h.interceptors { + toCall := actualCall + currentInterceptor := interceptor + actualCall = func(ctx context.Context, req any) (any, error) { + return currentInterceptor(ctx, req, "BroadcastPayloadEvent", toCall) + } + } + call, _ := actualCall(ctx, req) + return call.(*pb.RpcBroadcastPayloadEventResponse) +}