waveterm/frontend/app/store/wshclientapi.ts

// Copyright 2025, Command Line Inc.
// SPDX-License-Identifier: Apache-2.0

// generated by cmd/generate/main-generatets.go

import { WshClient } from "./wshclient";

// WshServerCommandToDeclMap
class RpcApiType {
    // command "activity" [call]
    ActivityCommand(client: WshClient, data: ActivityUpdate, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("activity", data, opts);
    }

    // command "aisendmessage" [call]
    AiSendMessageCommand(client: WshClient, data: AiMessageData, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("aisendmessage", data, opts);
    }

    // command "authenticate" [call]
    AuthenticateCommand(client: WshClient, data: string, opts?: RpcOpts): Promise<CommandAuthenticateRtnData> {
        return client.wshRpcCall("authenticate", data, opts);
    }

    // command "authenticatetoken" [call]
    AuthenticateTokenCommand(client: WshClient, data: CommandAuthenticateTokenData, opts?: RpcOpts): Promise<CommandAuthenticateRtnData> {
        return client.wshRpcCall("authenticatetoken", data, opts);
    }

    // command "blockinfo" [call]
    BlockInfoCommand(client: WshClient, data: string, opts?: RpcOpts): Promise<BlockInfoData> {
        return client.wshRpcCall("blockinfo", data, opts);
    }

    // command "blockslist" [call]
    BlocksListCommand(client: WshClient, data: BlocksListRequest, opts?: RpcOpts): Promise<BlocksListEntry[]> {
        return client.wshRpcCall("blockslist", data, opts);
    }

    // command "captureblockscreenshot" [call]
    CaptureBlockScreenshotCommand(client: WshClient, data: CommandCaptureBlockScreenshotData, opts?: RpcOpts): Promise<string> {
        return client.wshRpcCall("captureblockscreenshot", data, opts);
    }

    // command "checkgoversion" [call]
    CheckGoVersionCommand(client: WshClient, opts?: RpcOpts): Promise<CommandCheckGoVersionRtnData> {
        return client.wshRpcCall("checkgoversion", null, opts);
    }

    // command "connconnect" [call]
    ConnConnectCommand(client: WshClient, data: ConnRequest, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("connconnect", data, opts);
    }

    // command "conndisconnect" [call]
    ConnDisconnectCommand(client: WshClient, data: string, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("conndisconnect", data, opts);
    }

    // command "connensure" [call]
    ConnEnsureCommand(client: WshClient, data: ConnExtData, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("connensure", data, opts);
    }

    // command "connlist" [call]
    ConnListCommand(client: WshClient, opts?: RpcOpts): Promise<string[]> {
        return client.wshRpcCall("connlist", null, opts);
    }

    // command "connlistaws" [call]
    ConnListAWSCommand(client: WshClient, opts?: RpcOpts): Promise<string[]> {
        return client.wshRpcCall("connlistaws", null, opts);
    }

    // command "connreinstallwsh" [call]
    ConnReinstallWshCommand(client: WshClient, data: ConnExtData, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("connreinstallwsh", data, opts);
    }

    // command "connstatus" [call]
    ConnStatusCommand(client: WshClient, opts?: RpcOpts): Promise<ConnStatus[]> {
        return client.wshRpcCall("connstatus", null, opts);
    }

    // command "connupdatewsh" [call]
    ConnUpdateWshCommand(client: WshClient, data: RemoteInfo, opts?: RpcOpts): Promise<boolean> {
        return client.wshRpcCall("connupdatewsh", data, opts);
    }

    // command "controllerappendoutput" [call]
    ControllerAppendOutputCommand(client: WshClient, data: CommandControllerAppendOutputData, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("controllerappendoutput", data, opts);
    }

    // command "controllerinput" [call]
    ControllerInputCommand(client: WshClient, data: CommandBlockInputData, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("controllerinput", data, opts);
    }

    // command "controllerresync" [call]
    ControllerResyncCommand(client: WshClient, data: CommandControllerResyncData, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("controllerresync", data, opts);
    }

    // command "controllerstop" [call]
    ControllerStopCommand(client: WshClient, data: string, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("controllerstop", data, opts);
    }

    // command "createblock" [call]
    CreateBlockCommand(client: WshClient, data: CommandCreateBlockData, opts?: RpcOpts): Promise<ORef> {
        return client.wshRpcCall("createblock", data, opts);
    }

    // command "createsubblock" [call]
    CreateSubBlockCommand(client: WshClient, data: CommandCreateSubBlockData, opts?: RpcOpts): Promise<ORef> {
        return client.wshRpcCall("createsubblock", data, opts);
    }

    // command "deleteappfile" [call]
    DeleteAppFileCommand(client: WshClient, data: CommandDeleteAppFileData, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("deleteappfile", data, opts);
    }

    // command "deleteblock" [call]
    DeleteBlockCommand(client: WshClient, data: CommandDeleteBlockData, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("deleteblock", data, opts);
    }

    // command "deletebuilder" [call]
    DeleteBuilderCommand(client: WshClient, data: string, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("deletebuilder", data, opts);
    }

    // command "deletesubblock" [call]
    DeleteSubBlockCommand(client: WshClient, data: CommandDeleteBlockData, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("deletesubblock", data, opts);
    }

    // command "dismisswshfail" [call]
    DismissWshFailCommand(client: WshClient, data: string, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("dismisswshfail", data, opts);
    }

    // command "dispose" [call]
    DisposeCommand(client: WshClient, data: CommandDisposeData, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("dispose", data, opts);
    }

    // command "disposesuggestions" [call]
    DisposeSuggestionsCommand(client: WshClient, data: string, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("disposesuggestions", data, opts);
    }

    // command "electrondecrypt" [call]
    ElectronDecryptCommand(client: WshClient, data: CommandElectronDecryptData, opts?: RpcOpts): Promise<CommandElectronDecryptRtnData> {
        return client.wshRpcCall("electrondecrypt", data, opts);
    }

    // command "electronencrypt" [call]
    ElectronEncryptCommand(client: WshClient, data: CommandElectronEncryptData, opts?: RpcOpts): Promise<CommandElectronEncryptRtnData> {
        return client.wshRpcCall("electronencrypt", data, opts);
    }

    // command "eventpublish" [call]
    EventPublishCommand(client: WshClient, data: WaveEvent, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("eventpublish", data, opts);
    }

    // command "eventreadhistory" [call]
    EventReadHistoryCommand(client: WshClient, data: CommandEventReadHistoryData, opts?: RpcOpts): Promise<WaveEvent[]> {
        return client.wshRpcCall("eventreadhistory", data, opts);
    }

    // command "eventrecv" [call]
    EventRecvCommand(client: WshClient, data: WaveEvent, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("eventrecv", data, opts);
    }

    // command "eventsub" [call]
    EventSubCommand(client: WshClient, data: SubscriptionRequest, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("eventsub", data, opts);
    }

    // command "eventunsub" [call]
    EventUnsubCommand(client: WshClient, data: string, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("eventunsub", data, opts);
    }

    // command "eventunsuball" [call]
    EventUnsubAllCommand(client: WshClient, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("eventunsuball", null, opts);
    }

    // command "fetchsuggestions" [call]
    FetchSuggestionsCommand(client: WshClient, data: FetchSuggestionsData, opts?: RpcOpts): Promise<FetchSuggestionsResponse> {
        return client.wshRpcCall("fetchsuggestions", data, opts);
    }

    // command "fileappend" [call]
    FileAppendCommand(client: WshClient, data: FileData, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("fileappend", data, opts);
    }

    // command "fileappendijson" [call]
    FileAppendIJsonCommand(client: WshClient, data: CommandAppendIJsonData, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("fileappendijson", data, opts);
    }

    // command "filecopy" [call]
    FileCopyCommand(client: WshClient, data: CommandFileCopyData, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("filecopy", data, opts);
    }

    // command "filecreate" [call]
    FileCreateCommand(client: WshClient, data: FileData, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("filecreate", data, opts);
    }

    // command "filedelete" [call]
    FileDeleteCommand(client: WshClient, data: CommandDeleteFileData, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("filedelete", data, opts);
    }

    // command "fileinfo" [call]
    FileInfoCommand(client: WshClient, data: FileData, opts?: RpcOpts): Promise<FileInfo> {
        return client.wshRpcCall("fileinfo", data, opts);
    }

    // command "filejoin" [call]
    FileJoinCommand(client: WshClient, data: string[], opts?: RpcOpts): Promise<FileInfo> {
        return client.wshRpcCall("filejoin", data, opts);
    }

    // command "filelist" [call]
    FileListCommand(client: WshClient, data: FileListData, opts?: RpcOpts): Promise<FileInfo[]> {
        return client.wshRpcCall("filelist", data, opts);
    }

    // command "fileliststream" [responsestream]
	FileListStreamCommand(client: WshClient, data: FileListData, opts?: RpcOpts): AsyncGenerator<CommandRemoteListEntriesRtnData, void, boolean> {
        return client.wshRpcStream("fileliststream", data, opts);
    }

    // command "filemkdir" [call]
    FileMkdirCommand(client: WshClient, data: FileData, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("filemkdir", data, opts);
    }

    // command "filemove" [call]
    FileMoveCommand(client: WshClient, data: CommandFileCopyData, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("filemove", data, opts);
    }

    // command "fileread" [call]
    FileReadCommand(client: WshClient, data: FileData, opts?: RpcOpts): Promise<FileData> {
        return client.wshRpcCall("fileread", data, opts);
    }

    // command "filereadstream" [responsestream]
	FileReadStreamCommand(client: WshClient, data: FileData, opts?: RpcOpts): AsyncGenerator<FileData, void, boolean> {
        return client.wshRpcStream("filereadstream", data, opts);
    }

    // command "filerestorebackup" [call]
    FileRestoreBackupCommand(client: WshClient, data: CommandFileRestoreBackupData, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("filerestorebackup", data, opts);
    }

    // command "filesharecapability" [call]
    FileShareCapabilityCommand(client: WshClient, data: string, opts?: RpcOpts): Promise<FileShareCapability> {
        return client.wshRpcCall("filesharecapability", data, opts);
    }

    // command "filestreamtar" [responsestream]
	FileStreamTarCommand(client: WshClient, data: CommandRemoteStreamTarData, opts?: RpcOpts): AsyncGenerator<Packet, void, boolean> {
        return client.wshRpcStream("filestreamtar", data, opts);
    }

    // command "filewrite" [call]
    FileWriteCommand(client: WshClient, data: FileData, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("filewrite", data, opts);
    }

    // command "focuswindow" [call]
    FocusWindowCommand(client: WshClient, data: string, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("focuswindow", data, opts);
    }

    // command "getbuilderoutput" [call]
    GetBuilderOutputCommand(client: WshClient, data: string, opts?: RpcOpts): Promise<string[]> {
        return client.wshRpcCall("getbuilderoutput", data, opts);
    }

    // command "getbuilderstatus" [call]
    GetBuilderStatusCommand(client: WshClient, data: string, opts?: RpcOpts): Promise<BuilderStatusData> {
        return client.wshRpcCall("getbuilderstatus", data, opts);
    }

    // command "getfullconfig" [call]
    GetFullConfigCommand(client: WshClient, opts?: RpcOpts): Promise<FullConfigType> {
        return client.wshRpcCall("getfullconfig", null, opts);
    }

    // command "getmeta" [call]
    GetMetaCommand(client: WshClient, data: CommandGetMetaData, opts?: RpcOpts): Promise<MetaType> {
        return client.wshRpcCall("getmeta", data, opts);
    }

    // command "getrtinfo" [call]
    GetRTInfoCommand(client: WshClient, data: CommandGetRTInfoData, opts?: RpcOpts): Promise<ObjRTInfo> {
        return client.wshRpcCall("getrtinfo", data, opts);
    }

    // command "getsecrets" [call]
    GetSecretsCommand(client: WshClient, data: string[], opts?: RpcOpts): Promise<{[key: string]: string}> {
        return client.wshRpcCall("getsecrets", data, opts);
    }

    // command "getsecretslinuxstoragebackend" [call]
    GetSecretsLinuxStorageBackendCommand(client: WshClient, opts?: RpcOpts): Promise<string> {
        return client.wshRpcCall("getsecretslinuxstoragebackend", null, opts);
    }

    // command "getsecretsnames" [call]
    GetSecretsNamesCommand(client: WshClient, opts?: RpcOpts): Promise<string[]> {
        return client.wshRpcCall("getsecretsnames", null, opts);
    }

    // command "gettab" [call]
    GetTabCommand(client: WshClient, data: string, opts?: RpcOpts): Promise<Tab> {
        return client.wshRpcCall("gettab", data, opts);
    }

    // command "gettempdir" [call]
    GetTempDirCommand(client: WshClient, data: CommandGetTempDirData, opts?: RpcOpts): Promise<string> {
        return client.wshRpcCall("gettempdir", data, opts);
    }

    // command "getupdatechannel" [call]
    GetUpdateChannelCommand(client: WshClient, opts?: RpcOpts): Promise<string> {
        return client.wshRpcCall("getupdatechannel", null, opts);
    }

    // command "getvar" [call]
    GetVarCommand(client: WshClient, data: CommandVarData, opts?: RpcOpts): Promise<CommandVarResponseData> {
        return client.wshRpcCall("getvar", data, opts);
    }

    // command "getwaveaichat" [call]
    GetWaveAIChatCommand(client: WshClient, data: CommandGetWaveAIChatData, opts?: RpcOpts): Promise<UIChat> {
        return client.wshRpcCall("getwaveaichat", data, opts);
    }

    // command "getwaveairatelimit" [call]
    GetWaveAIRateLimitCommand(client: WshClient, opts?: RpcOpts): Promise<RateLimitInfo> {
        return client.wshRpcCall("getwaveairatelimit", null, opts);
    }

    // command "listallappfiles" [call]
    ListAllAppFilesCommand(client: WshClient, data: CommandListAllAppFilesData, opts?: RpcOpts): Promise<CommandListAllAppFilesRtnData> {
        return client.wshRpcCall("listallappfiles", data, opts);
    }

    // command "listallapps" [call]
    ListAllAppsCommand(client: WshClient, opts?: RpcOpts): Promise<AppInfo[]> {
        return client.wshRpcCall("listallapps", null, opts);
    }

    // command "listalleditableapps" [call]
    ListAllEditableAppsCommand(client: WshClient, opts?: RpcOpts): Promise<AppInfo[]> {
        return client.wshRpcCall("listalleditableapps", null, opts);
    }

    // command "makedraftfromlocal" [call]
    MakeDraftFromLocalCommand(client: WshClient, data: CommandMakeDraftFromLocalData, opts?: RpcOpts): Promise<CommandMakeDraftFromLocalRtnData> {
        return client.wshRpcCall("makedraftfromlocal", data, opts);
    }

    // command "message" [call]
    MessageCommand(client: WshClient, data: CommandMessageData, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("message", data, opts);
    }

    // command "notify" [call]
    NotifyCommand(client: WshClient, data: WaveNotificationOptions, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("notify", data, opts);
    }

    // command "path" [call]
    PathCommand(client: WshClient, data: PathCommandData, opts?: RpcOpts): Promise<string> {
        return client.wshRpcCall("path", data, opts);
    }

    // command "publishapp" [call]
    PublishAppCommand(client: WshClient, data: CommandPublishAppData, opts?: RpcOpts): Promise<CommandPublishAppRtnData> {
        return client.wshRpcCall("publishapp", data, opts);
    }

    // command "readappfile" [call]
    ReadAppFileCommand(client: WshClient, data: CommandReadAppFileData, opts?: RpcOpts): Promise<CommandReadAppFileRtnData> {
        return client.wshRpcCall("readappfile", data, opts);
    }

    // command "recordtevent" [call]
    RecordTEventCommand(client: WshClient, data: TEvent, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("recordtevent", data, opts);
    }

    // command "remotefilecopy" [call]
    RemoteFileCopyCommand(client: WshClient, data: CommandFileCopyData, opts?: RpcOpts): Promise<boolean> {
        return client.wshRpcCall("remotefilecopy", data, opts);
    }

    // command "remotefiledelete" [call]
    RemoteFileDeleteCommand(client: WshClient, data: CommandDeleteFileData, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("remotefiledelete", data, opts);
    }

    // command "remotefileinfo" [call]
    RemoteFileInfoCommand(client: WshClient, data: string, opts?: RpcOpts): Promise<FileInfo> {
        return client.wshRpcCall("remotefileinfo", data, opts);
    }

    // command "remotefilejoin" [call]
    RemoteFileJoinCommand(client: WshClient, data: string[], opts?: RpcOpts): Promise<FileInfo> {
        return client.wshRpcCall("remotefilejoin", data, opts);
    }

    // command "remotefilemove" [call]
    RemoteFileMoveCommand(client: WshClient, data: CommandFileCopyData, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("remotefilemove", data, opts);
    }

    // command "remotefiletouch" [call]
    RemoteFileTouchCommand(client: WshClient, data: string, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("remotefiletouch", data, opts);
    }

    // command "remotegetinfo" [call]
    RemoteGetInfoCommand(client: WshClient, opts?: RpcOpts): Promise<RemoteInfo> {
        return client.wshRpcCall("remotegetinfo", null, opts);
    }

    // command "remoteinstallrcfiles" [call]
    RemoteInstallRcFilesCommand(client: WshClient, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("remoteinstallrcfiles", null, opts);
    }

    // command "remotelistentries" [responsestream]
	RemoteListEntriesCommand(client: WshClient, data: CommandRemoteListEntriesData, opts?: RpcOpts): AsyncGenerator<CommandRemoteListEntriesRtnData, void, boolean> {
        return client.wshRpcStream("remotelistentries", data, opts);
    }

    // command "remotemkdir" [call]
    RemoteMkdirCommand(client: WshClient, data: string, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("remotemkdir", data, opts);
    }

    // command "remotestreamcpudata" [responsestream]
	RemoteStreamCpuDataCommand(client: WshClient, opts?: RpcOpts): AsyncGenerator<TimeSeriesData, void, boolean> {
        return client.wshRpcStream("remotestreamcpudata", null, opts);
    }

    // command "remotestreamfile" [responsestream]
	RemoteStreamFileCommand(client: WshClient, data: CommandRemoteStreamFileData, opts?: RpcOpts): AsyncGenerator<FileData, void, boolean> {
        return client.wshRpcStream("remotestreamfile", data, opts);
    }

    // command "remotetarstream" [responsestream]
	RemoteTarStreamCommand(client: WshClient, data: CommandRemoteStreamTarData, opts?: RpcOpts): AsyncGenerator<Packet, void, boolean> {
        return client.wshRpcStream("remotetarstream", data, opts);
    }

    // command "remotewritefile" [call]
    RemoteWriteFileCommand(client: WshClient, data: FileData, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("remotewritefile", data, opts);
    }

    // command "renameappfile" [call]
    RenameAppFileCommand(client: WshClient, data: CommandRenameAppFileData, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("renameappfile", data, opts);
    }

    // command "resolveids" [call]
    ResolveIdsCommand(client: WshClient, data: CommandResolveIdsData, opts?: RpcOpts): Promise<CommandResolveIdsRtnData> {
        return client.wshRpcCall("resolveids", data, opts);
    }

    // command "restartbuilderandwait" [call]
    RestartBuilderAndWaitCommand(client: WshClient, data: CommandRestartBuilderAndWaitData, opts?: RpcOpts): Promise<RestartBuilderAndWaitResult> {
        return client.wshRpcCall("restartbuilderandwait", data, opts);
    }

    // command "routeannounce" [call]
    RouteAnnounceCommand(client: WshClient, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("routeannounce", null, opts);
    }

    // command "routeunannounce" [call]
    RouteUnannounceCommand(client: WshClient, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("routeunannounce", null, opts);
    }

    // command "sendtelemetry" [call]
    SendTelemetryCommand(client: WshClient, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("sendtelemetry", null, opts);
    }

    // command "setconfig" [call]
    SetConfigCommand(client: WshClient, data: SettingsType, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("setconfig", data, opts);
    }

    // command "setconnectionsconfig" [call]
    SetConnectionsConfigCommand(client: WshClient, data: ConnConfigRequest, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("setconnectionsconfig", data, opts);
    }

    // command "setmeta" [call]
    SetMetaCommand(client: WshClient, data: CommandSetMetaData, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("setmeta", data, opts);
    }

    // command "setrtinfo" [call]
    SetRTInfoCommand(client: WshClient, data: CommandSetRTInfoData, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("setrtinfo", data, opts);
    }

    // command "setsecrets" [call]
    SetSecretsCommand(client: WshClient, data: {[key: string]: string}, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("setsecrets", data, opts);
    }

    // command "setvar" [call]
    SetVarCommand(client: WshClient, data: CommandVarData, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("setvar", data, opts);
    }

    // command "setview" [call]
    SetViewCommand(client: WshClient, data: CommandBlockSetViewData, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("setview", data, opts);
    }

    // command "startbuilder" [call]
    StartBuilderCommand(client: WshClient, data: CommandStartBuilderData, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("startbuilder", data, opts);
    }

    // command "stopbuilder" [call]
    StopBuilderCommand(client: WshClient, data: string, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("stopbuilder", data, opts);
    }

    // command "streamcpudata" [responsestream]
	StreamCpuDataCommand(client: WshClient, data: CpuDataRequest, opts?: RpcOpts): AsyncGenerator<TimeSeriesData, void, boolean> {
        return client.wshRpcStream("streamcpudata", data, opts);
    }

    // command "streamtest" [responsestream]
	StreamTestCommand(client: WshClient, opts?: RpcOpts): AsyncGenerator<number, void, boolean> {
        return client.wshRpcStream("streamtest", null, opts);
    }

    // command "streamwaveai" [responsestream]
	StreamWaveAiCommand(client: WshClient, data: WaveAIStreamRequest, opts?: RpcOpts): AsyncGenerator<WaveAIPacketType, void, boolean> {
        return client.wshRpcStream("streamwaveai", data, opts);
    }

    // command "termgetscrollbacklines" [call]
    TermGetScrollbackLinesCommand(client: WshClient, data: CommandTermGetScrollbackLinesData, opts?: RpcOpts): Promise<CommandTermGetScrollbackLinesRtnData> {
        return client.wshRpcCall("termgetscrollbacklines", data, opts);
    }

    // command "test" [call]
    TestCommand(client: WshClient, data: string, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("test", data, opts);
    }

    // command "vdomasyncinitiation" [call]
    VDomAsyncInitiationCommand(client: WshClient, data: VDomAsyncInitiationRequest, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("vdomasyncinitiation", data, opts);
    }

    // command "vdomcreatecontext" [call]
    VDomCreateContextCommand(client: WshClient, data: VDomCreateContext, opts?: RpcOpts): Promise<ORef> {
        return client.wshRpcCall("vdomcreatecontext", data, opts);
    }

    // command "vdomrender" [responsestream]
	VDomRenderCommand(client: WshClient, data: VDomFrontendUpdate, opts?: RpcOpts): AsyncGenerator<VDomBackendUpdate, void, boolean> {
        return client.wshRpcStream("vdomrender", data, opts);
    }

    // command "vdomurlrequest" [responsestream]
	VDomUrlRequestCommand(client: WshClient, data: VDomUrlRequestData, opts?: RpcOpts): AsyncGenerator<VDomUrlRequestResponse, void, boolean> {
        return client.wshRpcStream("vdomurlrequest", data, opts);
    }

    // command "waitforroute" [call]
    WaitForRouteCommand(client: WshClient, data: CommandWaitForRouteData, opts?: RpcOpts): Promise<boolean> {
        return client.wshRpcCall("waitforroute", data, opts);
    }

    // command "waveaiaddcontext" [call]
    WaveAIAddContextCommand(client: WshClient, data: CommandWaveAIAddContextData, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("waveaiaddcontext", data, opts);
    }

    // command "waveaienabletelemetry" [call]
    WaveAIEnableTelemetryCommand(client: WshClient, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("waveaienabletelemetry", null, opts);
    }

    // command "waveaigettooldiff" [call]
    WaveAIGetToolDiffCommand(client: WshClient, data: CommandWaveAIGetToolDiffData, opts?: RpcOpts): Promise<CommandWaveAIGetToolDiffRtnData> {
        return client.wshRpcCall("waveaigettooldiff", data, opts);
    }

    // command "waveaitoolapprove" [call]
    WaveAIToolApproveCommand(client: WshClient, data: CommandWaveAIToolApproveData, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("waveaitoolapprove", data, opts);
    }

    // command "waveinfo" [call]
    WaveInfoCommand(client: WshClient, opts?: RpcOpts): Promise<WaveInfoData> {
        return client.wshRpcCall("waveinfo", null, opts);
    }

    // command "webselector" [call]
    WebSelectorCommand(client: WshClient, data: CommandWebSelectorData, opts?: RpcOpts): Promise<string[]> {
        return client.wshRpcCall("webselector", data, opts);
    }

    // command "workspacelist" [call]
    WorkspaceListCommand(client: WshClient, opts?: RpcOpts): Promise<WorkspaceInfoData[]> {
        return client.wshRpcCall("workspacelist", null, opts);
    }

    // command "writeappfile" [call]
    WriteAppFileCommand(client: WshClient, data: CommandWriteAppFileData, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("writeappfile", data, opts);
    }

    // command "writeappgofile" [call]
    WriteAppGoFileCommand(client: WshClient, data: CommandWriteAppGoFileData, opts?: RpcOpts): Promise<CommandWriteAppGoFileRtnData> {
        return client.wshRpcCall("writeappgofile", data, opts);
    }

    // command "writeappsecretbindings" [call]
    WriteAppSecretBindingsCommand(client: WshClient, data: CommandWriteAppSecretBindingsData, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("writeappsecretbindings", data, opts);
    }

    // command "writetempfile" [call]
    WriteTempFileCommand(client: WshClient, data: CommandWriteTempFileData, opts?: RpcOpts): Promise<string> {
        return client.wshRpcCall("writetempfile", data, opts);
    }

    // command "wshactivity" [call]
    WshActivityCommand(client: WshClient, data: {[key: string]: number}, opts?: RpcOpts): Promise<void> {
        return client.wshRpcCall("wshactivity", data, opts);
    }

    // command "wsldefaultdistro" [call]
    WslDefaultDistroCommand(client: WshClient, opts?: RpcOpts): Promise<string> {
        return client.wshRpcCall("wsldefaultdistro", null, opts);
    }

    // command "wsllist" [call]
    WslListCommand(client: WshClient, opts?: RpcOpts): Promise<string[]> {
        return client.wshRpcCall("wsllist", null, opts);
    }

    // command "wslstatus" [call]
    WslStatusCommand(client: WshClient, opts?: RpcOpts): Promise<ConnStatus[]> {
        return client.wshRpcCall("wslstatus", null, opts);
    }

}

export const RpcApi = new RpcApiType();