gotypes.d.ts

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

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

declare global {

    // wshrpc.AIAttachedFile
    type AIAttachedFile = {
        name: string;
        type: string;
        size: number;
        data64: string;
    };

    // wconfig.AIModeConfigType
    type AIModeConfigType = {
        "display:name": string;
        "display:order"?: number;
        "display:icon"?: string;
        "display:description"?: string;
        "ai:provider"?: string;
        "ai:apitype"?: string;
        "ai:model"?: string;
        "ai:thinkinglevel"?: string;
        "ai:verbosity"?: string;
        "ai:endpoint"?: string;
        "ai:proxyurl"?: string;
        "ai:azureapiversion"?: string;
        "ai:apitoken"?: string;
        "ai:apitokensecretname"?: string;
        "ai:azureresourcename"?: string;
        "ai:azuredeployment"?: string;
        "ai:capabilities"?: string[];
        "ai:switchcompat"?: string[];
        "waveai:cloud"?: boolean;
        "waveai:premium"?: boolean;
    };

    // wconfig.AIModeConfigUpdate
    type AIModeConfigUpdate = {
        configs: {[key: string]: AIModeConfigType};
    };

    // wshrpc.ActivityDisplayType
    type ActivityDisplayType = {
        width: number;
        height: number;
        dpr: number;
        internal?: boolean;
    };

    // wshrpc.ActivityUpdate
    type ActivityUpdate = {
        fgminutes?: number;
        activeminutes?: number;
        openminutes?: number;
        waveaifgminutes?: number;
        waveaiactiveminutes?: number;
        numtabs?: number;
        newtab?: number;
        numblocks?: number;
        numwindows?: number;
        numws?: number;
        numwsnamed?: number;
        numsshconn?: number;
        numwslconn?: number;
        nummagnify?: number;
        termcommandsrun?: number;
        numpanics?: number;
        numaireqs?: number;
        startup?: number;
        shutdown?: number;
        settabtheme?: number;
        buildtime?: string;
        displays?: ActivityDisplayType[];
        renderers?: {[key: string]: number};
        blocks?: {[key: string]: number};
        wshcmds?: {[key: string]: number};
        conn?: {[key: string]: number};
    };

    // wshrpc.AiMessageData
    type AiMessageData = {
        message?: string;
    };

    // wshrpc.AppInfo
    type AppInfo = {
        appid: string;
        modtime: number;
        manifest?: AppManifest;
    };

    // wshrpc.AppManifest
    type AppManifest = {
        appmeta: AppMeta;
        configschema: {[key: string]: any};
        dataschema: {[key: string]: any};
        secrets: {[key: string]: SecretMeta};
    };

    // wshrpc.AppMeta
    type AppMeta = {
        title: string;
        shortdesc: string;
        icon: string;
        iconcolor: string;
    };

    // wconfig.BackgroundConfigType
    type BackgroundConfigType = {
        bg?: string;
        "bg:opacity"?: number;
        "bg:blendmode"?: string;
        "bg:bordercolor"?: string;
        "bg:activebordercolor"?: string;
        "display:name": string;
        "display:order"?: number;
    };

    // baseds.Badge
    type Badge = {
        badgeid: string;
        icon: string;
        color?: string;
        priority: number;
        pidlinked?: boolean;
    };

    // baseds.BadgeEvent
    type BadgeEvent = {
        oref: string;
        clear?: boolean;
        clearall?: boolean;
        clearbyid?: string;
        badge?: Badge;
    };

    // waveobj.Block
    type Block = WaveObj & {
        parentoref?: string;
        runtimeopts?: RuntimeOpts;
        stickers?: StickerType[];
        subblockids?: string[];
        jobid?: string;
    };

    // blockcontroller.BlockControllerRuntimeStatus
    type BlockControllerRuntimeStatus = {
        blockid: string;
        version: number;
        shellprocstatus?: string;
        shellprocconnname?: string;
        shellprocexitcode: number;
        tsunamiport?: number;
    };

    // waveobj.BlockDef
    type BlockDef = {
        files?: {[key: string]: FileDef};
        meta?: MetaType;
    };

    // wshrpc.BlockInfoData
    type BlockInfoData = {
        blockid: string;
        tabid: string;
        workspaceid: string;
        block: Block;
        files: WaveFileInfo[];
    };

    // wshrpc.BlockJobStatusData
    type BlockJobStatusData = {
        blockid: string;
        jobid: string;
        status?: null | "init" | "connected" | "disconnected" | "done";
        versionts: number;
        donereason?: string;
        startuperror?: string;
        cmdexitts?: number;
        cmdexitcode?: number;
        cmdexitsignal?: string;
    };

    // wshrpc.BlocksListEntry
    type BlocksListEntry = {
        windowid: string;
        workspaceid: string;
        tabid: string;
        blockid: string;
        meta: MetaType;
    };

    // wshrpc.BlocksListRequest
    type BlocksListRequest = {
        windowid?: string;
        workspaceid?: string;
    };

    // wshrpc.BuilderStatusData
    type BuilderStatusData = {
        status: string;
        port?: number;
        exitcode?: number;
        errormsg?: string;
        version: number;
        manifest?: AppManifest;
        secretbindings?: {[key: string]: string};
        secretbindingscomplete: boolean;
    };

    // waveobj.Client
    type Client = WaveObj & {
        windowids: string[];
        tosagreed?: number;
        hasoldhistory?: boolean;
        tempoid?: string;
        installid?: string;
    };

    // workspaceservice.CloseTabRtnType
    type CloseTabRtnType = {
        closewindow?: boolean;
        newactivetabid?: string;
    };

    // wshrpc.CommandAuthenticateJobManagerData
    type CommandAuthenticateJobManagerData = {
        jobid: string;
        jobauthtoken: string;
    };

    // wshrpc.CommandAuthenticateRtnData
    type CommandAuthenticateRtnData = {
        routeid: string;
        env?: {[key: string]: string};
        initscripttext?: string;
        rpccontext?: RpcContext;
    };

    // wshrpc.CommandAuthenticateToJobData
    type CommandAuthenticateToJobData = {
        jobaccesstoken: string;
    };

    // wshrpc.CommandAuthenticateTokenData
    type CommandAuthenticateTokenData = {
        token: string;
    };

    // wshrpc.CommandBadgeWatchPidData
    type CommandBadgeWatchPidData = {
        pid: number;
        oref: ORef;
        badgeid: string;
    };

    // wshrpc.CommandBlockInputData
    type CommandBlockInputData = {
        blockid: string;
        inputdata64?: string;
        signame?: string;
        termsize?: TermSize;
    };

    // wshrpc.CommandCaptureBlockScreenshotData
    type CommandCaptureBlockScreenshotData = {
        blockid: string;
    };

    // wshrpc.CommandCheckGoVersionRtnData
    type CommandCheckGoVersionRtnData = {
        gostatus: string;
        gopath: string;
        goversion: string;
        errorstring?: string;
    };

    // wshrpc.CommandConnServerInitData
    type CommandConnServerInitData = {
        clientid: string;
    };

    // wshrpc.CommandControllerAppendOutputData
    type CommandControllerAppendOutputData = {
        blockid: string;
        data64: string;
    };

    // wshrpc.CommandControllerResyncData
    type CommandControllerResyncData = {
        forcerestart?: boolean;
        tabid: string;
        blockid: string;
        rtopts?: RuntimeOpts;
    };

    // wshrpc.CommandCreateBlockData
    type CommandCreateBlockData = {
        tabid: string;
        blockdef: BlockDef;
        rtopts?: RuntimeOpts;
        magnified?: boolean;
        ephemeral?: boolean;
        focused?: boolean;
        targetblockid?: string;
        targetaction?: string;
    };

    // wshrpc.CommandCreateSubBlockData
    type CommandCreateSubBlockData = {
        parentblockid: string;
        blockdef: BlockDef;
    };

    // wshrpc.CommandDebugTermData
    type CommandDebugTermData = {
        blockid: string;
        size: number;
    };

    // wshrpc.CommandDebugTermRtnData
    type CommandDebugTermRtnData = {
        offset: number;
        data64: string;
    };

    // wshrpc.CommandDeleteAppFileData
    type CommandDeleteAppFileData = {
        appid: string;
        filename: string;
    };

    // wshrpc.CommandDeleteBlockData
    type CommandDeleteBlockData = {
        blockid: string;
    };

    // wshrpc.CommandDeleteFileData
    type CommandDeleteFileData = {
        path: string;
        recursive: boolean;
    };

    // wshrpc.CommandDisposeData
    type CommandDisposeData = {
        routeid: string;
    };

    // wshrpc.CommandElectronDecryptData
    type CommandElectronDecryptData = {
        ciphertext: string;
    };

    // wshrpc.CommandElectronDecryptRtnData
    type CommandElectronDecryptRtnData = {
        plaintext: string;
        storagebackend: string;
    };

    // wshrpc.CommandElectronEncryptData
    type CommandElectronEncryptData = {
        plaintext: string;
    };

    // wshrpc.CommandElectronEncryptRtnData
    type CommandElectronEncryptRtnData = {
        ciphertext: string;
        storagebackend: string;
    };

    // wshrpc.CommandEventReadHistoryData
    type CommandEventReadHistoryData = {
        event: string;
        scope: string;
        maxitems: number;
    };

    // wshrpc.CommandFileCopyData
    type CommandFileCopyData = {
        srcuri: string;
        desturi: string;
        opts?: FileCopyOpts;
    };

    // wshrpc.CommandFileRestoreBackupData
    type CommandFileRestoreBackupData = {
        backupfilepath: string;
        restoretofilename: string;
    };

    // wshrpc.CommandFileStreamData
    type CommandFileStreamData = {
        info: FileInfo;
        byterange?: string;
        streammeta: StreamMeta;
    };

    // wshrpc.CommandGetMetaData
    type CommandGetMetaData = {
        oref: ORef;
    };

    // wshrpc.CommandGetRTInfoData
    type CommandGetRTInfoData = {
        oref: ORef;
    };

    // wshrpc.CommandGetTempDirData
    type CommandGetTempDirData = {
        filename?: string;
    };

    // wshrpc.CommandGetWaveAIChatData
    type CommandGetWaveAIChatData = {
        chatid: string;
    };

    // wshrpc.CommandJobCmdExitedData
    type CommandJobCmdExitedData = {
        jobid: string;
        exitcode?: number;
        exitsignal?: string;
        exiterr?: string;
        exitts?: number;
    };

    // wshrpc.CommandJobConnectRtnData
    type CommandJobConnectRtnData = {
        seq: number;
        streamdone?: boolean;
        streamerror?: string;
        hasexited?: boolean;
        exitcode?: number;
        exitsignal?: string;
        exiterr?: string;
    };

    // wshrpc.CommandJobControllerAttachJobData
    type CommandJobControllerAttachJobData = {
        jobid: string;
        blockid: string;
    };

    // wshrpc.CommandJobControllerStartJobData
    type CommandJobControllerStartJobData = {
        connname: string;
        jobkind: string;
        cmd: string;
        args: string[];
        env: {[key: string]: string};
        termsize?: TermSize;
    };

    // wshrpc.CommandJobInputData
    type CommandJobInputData = {
        jobid: string;
        inputsessionid?: string;
        seqnum?: number;
        inputdata64?: string;
        signame?: string;
        termsize?: TermSize;
    };

    // wshrpc.CommandJobPrepareConnectData
    type CommandJobPrepareConnectData = {
        streammeta: StreamMeta;
        seq: number;
        termsize: TermSize;
    };

    // wshrpc.CommandJobStartStreamData
    type CommandJobStartStreamData = object;

    // wshrpc.CommandListAllAppFilesData
    type CommandListAllAppFilesData = {
        appid: string;
    };

    // wshrpc.CommandListAllAppFilesRtnData
    type CommandListAllAppFilesRtnData = {
        path: string;
        absolutepath: string;
        parentdir?: string;
        entries: DirEntryOut[];
        entrycount: number;
        totalentries: number;
        truncated?: boolean;
    };

    // wshrpc.CommandMakeDraftFromLocalData
    type CommandMakeDraftFromLocalData = {
        localappid: string;
    };

    // wshrpc.CommandMakeDraftFromLocalRtnData
    type CommandMakeDraftFromLocalRtnData = {
        draftappid: string;
    };

    // wshrpc.CommandMessageData
    type CommandMessageData = {
        message: string;
    };

    // wshrpc.CommandPublishAppData
    type CommandPublishAppData = {
        appid: string;
    };

    // wshrpc.CommandPublishAppRtnData
    type CommandPublishAppRtnData = {
        publishedappid: string;
    };

    // wshrpc.CommandReadAppFileData
    type CommandReadAppFileData = {
        appid: string;
        filename: string;
    };

    // wshrpc.CommandReadAppFileRtnData
    type CommandReadAppFileRtnData = {
        data64: string;
        notfound?: boolean;
        modts?: number;
    };

    // wshrpc.CommandRemoteDisconnectFromJobManagerData
    type CommandRemoteDisconnectFromJobManagerData = {
        jobid: string;
    };

    // wshrpc.CommandRemoteFileMultiInfoData
    type CommandRemoteFileMultiInfoData = {
        cwd: string;
        paths: string[];
    };

    // wshrpc.CommandRemoteFileStreamData
    type CommandRemoteFileStreamData = {
        path: string;
        byterange?: string;
        streammeta: StreamMeta;
    };

    // wshrpc.CommandRemoteListEntriesData
    type CommandRemoteListEntriesData = {
        path: string;
        opts?: FileListOpts;
    };

    // wshrpc.CommandRemoteListEntriesRtnData
    type CommandRemoteListEntriesRtnData = {
        fileinfo?: FileInfo[];
    };

    // wshrpc.CommandRemoteProcessListData
    type CommandRemoteProcessListData = {
        widgetid?: string;
        sortby?: string;
        sortdesc?: boolean;
        start?: number;
        limit?: number;
        textsearch?: string;
        lastpidorder?: boolean;
        keepalive?: boolean;
    };

    // wshrpc.CommandRemoteProcessSignalData
    type CommandRemoteProcessSignalData = {
        pid: number;
        signal: string;
    };

    // wshrpc.CommandRemoteReconnectToJobManagerData
    type CommandRemoteReconnectToJobManagerData = {
        jobid: string;
        jobauthtoken: string;
        mainserverjwttoken: string;
        jobmanagerpid: number;
        jobmanagerstartts: number;
    };

    // wshrpc.CommandRemoteReconnectToJobManagerRtnData
    type CommandRemoteReconnectToJobManagerRtnData = {
        success: boolean;
        jobmanagergone: boolean;
        error?: string;
    };

    // wshrpc.CommandRemoteStartJobData
    type CommandRemoteStartJobData = {
        cmd: string;
        args: string[];
        env: {[key: string]: string};
        termsize: TermSize;
        streammeta?: StreamMeta;
        jobauthtoken: string;
        jobid: string;
        mainserverjwttoken: string;
        clientid: string;
        publickeybase64: string;
    };

    // wshrpc.CommandRemoteTerminateJobManagerData
    type CommandRemoteTerminateJobManagerData = {
        jobid: string;
        jobmanagerpid: number;
        jobmanagerstartts: number;
    };

    // wshrpc.CommandRenameAppFileData
    type CommandRenameAppFileData = {
        appid: string;
        fromfilename: string;
        tofilename: string;
    };

    // wshrpc.CommandResolveIdsData
    type CommandResolveIdsData = {
        blockid: string;
        ids: string[];
    };

    // wshrpc.CommandResolveIdsRtnData
    type CommandResolveIdsRtnData = {
        resolvedids: {[key: string]: ORef};
    };

    // wshrpc.CommandRestartBuilderAndWaitData
    type CommandRestartBuilderAndWaitData = {
        builderid: string;
    };

    // wshrpc.CommandSetMetaData
    type CommandSetMetaData = {
        oref: ORef;
        meta: MetaType;
    };

    // wshrpc.CommandSetRTInfoData
    type CommandSetRTInfoData = {
        oref: ORef;
        data: ObjRTInfo;
        delete?: boolean;
    };

    // wshrpc.CommandStartBuilderData
    type CommandStartBuilderData = {
        builderid: string;
    };

    // wshrpc.CommandStartJobData
    type CommandStartJobData = {
        cmd: string;
        args: string[];
        env: {[key: string]: string};
        termsize: TermSize;
        streammeta?: StreamMeta;
    };

    // wshrpc.CommandStartJobRtnData
    type CommandStartJobRtnData = {
        cmdpid: number;
        cmdstartts: number;
        jobmanagerpid: number;
        jobmanagerstartts: number;
    };

    // wshrpc.CommandStreamAckData
    type CommandStreamAckData = {
        id: string;
        seq: number;
        rwnd: number;
        fin?: boolean;
        delay?: number;
        cancel?: boolean;
        error?: string;
    };

    // wshrpc.CommandStreamData
    type CommandStreamData = {
        id: string;
        seq: number;
        data64?: string;
        eof?: boolean;
        error?: string;
    };

    // wshrpc.CommandTermGetScrollbackLinesData
    type CommandTermGetScrollbackLinesData = {
        linestart: number;
        lineend: number;
        lastcommand: boolean;
    };

    // wshrpc.CommandTermGetScrollbackLinesRtnData
    type CommandTermGetScrollbackLinesRtnData = {
        totallines: number;
        linestart: number;
        lines: string[];
        lastupdated: number;
    };

    // wshrpc.CommandVarData
    type CommandVarData = {
        key: string;
        val?: string;
        remove?: boolean;
        zoneid: string;
        filename: string;
    };

    // wshrpc.CommandVarResponseData
    type CommandVarResponseData = {
        key: string;
        val: string;
        exists: boolean;
    };

    // wshrpc.CommandWaitForRouteData
    type CommandWaitForRouteData = {
        routeid: string;
        waitms: number;
    };

    // wshrpc.CommandWaveAIAddContextData
    type CommandWaveAIAddContextData = {
        files?: AIAttachedFile[];
        text?: string;
        submit?: boolean;
        newchat?: boolean;
    };

    // wshrpc.CommandWaveAIGetToolDiffData
    type CommandWaveAIGetToolDiffData = {
        chatid: string;
        toolcallid: string;
    };

    // wshrpc.CommandWaveAIGetToolDiffRtnData
    type CommandWaveAIGetToolDiffRtnData = {
        originalcontents64: string;
        modifiedcontents64: string;
    };

    // wshrpc.CommandWaveAIToolApproveData
    type CommandWaveAIToolApproveData = {
        toolcallid: string;
        approval?: string;
    };

    // wshrpc.CommandWaveFileReadStreamData
    type CommandWaveFileReadStreamData = {
        zoneid: string;
        name: string;
        streammeta: StreamMeta;
    };

    // wshrpc.CommandWebSelectorData
    type CommandWebSelectorData = {
        workspaceid: string;
        blockid: string;
        tabid: string;
        selector: string;
        opts?: WebSelectorOpts;
    };

    // wshrpc.CommandWriteAppFileData
    type CommandWriteAppFileData = {
        appid: string;
        filename: string;
        data64: string;
    };

    // wshrpc.CommandWriteAppGoFileData
    type CommandWriteAppGoFileData = {
        appid: string;
        data64: string;
    };

    // wshrpc.CommandWriteAppGoFileRtnData
    type CommandWriteAppGoFileRtnData = {
        data64: string;
    };

    // wshrpc.CommandWriteAppSecretBindingsData
    type CommandWriteAppSecretBindingsData = {
        appid: string;
        bindings: {[key: string]: string};
    };

    // wshrpc.CommandWriteTempFileData
    type CommandWriteTempFileData = {
        filename: string;
        data64: string;
    };

    // wconfig.ConfigError
    type ConfigError = {
        file: string;
        err: string;
    };

    // wshrpc.ConnConfigRequest
    type ConnConfigRequest = {
        host: string;
        metamaptype: MetaType;
    };

    // wshrpc.ConnExtData
    type ConnExtData = {
        connname: string;
        logblockid?: string;
    };

    // wconfig.ConnKeywords
    type ConnKeywords = {
        "conn:wshenabled"?: boolean;
        "conn:askbeforewshinstall"?: boolean;
        "conn:wshpath"?: string;
        "conn:shellpath"?: string;
        "conn:ignoresshconfig"?: boolean;
        "display:hidden"?: boolean;
        "display:order"?: number;
        "term:*"?: boolean;
        "term:fontsize"?: number;
        "term:fontfamily"?: string;
        "term:theme"?: string;
        "term:durable"?: boolean;
        "cmd:env"?: {[key: string]: string};
        "cmd:initscript"?: string;
        "cmd:initscript.sh"?: string;
        "cmd:initscript.bash"?: string;
        "cmd:initscript.zsh"?: string;
        "cmd:initscript.pwsh"?: string;
        "cmd:initscript.fish"?: string;
        "ssh:user"?: string;
        "ssh:hostname"?: string;
        "ssh:port"?: string;
        "ssh:identityfile"?: string[];
        "ssh:passwordsecretname"?: string;
        "ssh:batchmode"?: boolean;
        "ssh:pubkeyauthentication"?: boolean;
        "ssh:passwordauthentication"?: boolean;
        "ssh:kbdinteractiveauthentication"?: boolean;
        "ssh:preferredauthentications"?: string[];
        "ssh:addkeystoagent"?: boolean;
        "ssh:identityagent"?: string;
        "ssh:identitiesonly"?: boolean;
        "ssh:proxyjump"?: string[];
        "ssh:userknownhostsfile"?: string[];
        "ssh:globalknownhostsfile"?: string[];
    };

    // wshrpc.ConnRequest
    type ConnRequest = {
        host: string;
        keywords?: ConnKeywords;
        logblockid?: string;
    };

    // wshrpc.ConnStatus
    type ConnStatus = {
        status: string;
        connhealthstatus?: string;
        wshenabled: boolean;
        connection: string;
        connected: boolean;
        hasconnected: boolean;
        activeconnnum: number;
        error?: string;
        wsherror?: string;
        nowshreason?: string;
        wshversion?: string;
        lastactivitybeforestalledtime?: number;
        keepalivesenttime?: number;
    };

    // wshrpc.CpuDataRequest
    type CpuDataRequest = {
        id: string;
        count: number;
    };

    // wshrpc.DirEntryOut
    type DirEntryOut = {
        name: string;
        dir?: boolean;
        symlink?: boolean;
        size?: number;
        mode: string;
        modified: string;
        modifiedtime: string;
    };

    // vdom.DomRect
    type DomRect = {
        top: number;
        left: number;
        right: number;
        bottom: number;
        width: number;
        height: number;
    };

    // wshrpc.FetchSuggestionsData
    type FetchSuggestionsData = {
        suggestiontype: string;
        query: string;
        widgetid: string;
        reqnum: number;
        "file:cwd"?: string;
        "file:dironly"?: boolean;
        "file:connection"?: string;
    };

    // wshrpc.FetchSuggestionsResponse
    type FetchSuggestionsResponse = {
        reqnum: number;
        suggestions: SuggestionType[];
    };

    // wshrpc.FileCopyOpts
    type FileCopyOpts = {
        overwrite?: boolean;
        recursive?: boolean;
        merge?: boolean;
        timeout?: number;
    };

    // wshrpc.FileData
    type FileData = {
        info?: FileInfo;
        data64?: string;
        entries?: FileInfo[];
        at?: FileDataAt;
    };

    // wshrpc.FileDataAt
    type FileDataAt = {
        offset: number;
        size?: number;
    };

    // waveobj.FileDef
    type FileDef = {
        content?: string;
        meta?: {[key: string]: any};
    };

    // wshrpc.FileInfo
    type FileInfo = {
        path: string;
        dir?: string;
        name?: string;
        staterror?: string;
        notfound?: boolean;
        opts?: FileOpts;
        size?: number;
        meta?: {[key: string]: any};
        mode?: number;
        modestr?: string;
        modtime?: number;
        isdir?: boolean;
        supportsmkdir?: boolean;
        mimetype?: string;
        readonly?: boolean;
    };

    // wshrpc.FileListData
    type FileListData = {
        path: string;
        opts?: FileListOpts;
    };

    // wshrpc.FileListOpts
    type FileListOpts = {
        all?: boolean;
        offset?: number;
        limit?: number;
    };

    // wshrpc.FileOpts
    type FileOpts = {
        maxsize?: number;
        circular?: boolean;
        ijson?: boolean;
        ijsonbudget?: number;
        truncate?: boolean;
        append?: boolean;
    };

    // wshrpc.FocusedBlockData
    type FocusedBlockData = {
        blockid: string;
        viewtype: string;
        controller: string;
        connname: string;
        blockmeta: MetaType;
        termjobstatus?: BlockJobStatusData;
        connstatus?: ConnStatus;
        termshellintegrationstatus?: string;
        termlastcommand?: string;
    };

    // wconfig.FullConfigType
    type FullConfigType = {
        settings: SettingsType;
        mimetypes: {[key: string]: MimeTypeConfigType};
        defaultwidgets: {[key: string]: WidgetConfigType};
        widgets: {[key: string]: WidgetConfigType};
        presets: {[key: string]: MetaType};
        backgrounds: {[key: string]: BackgroundConfigType};
        termthemes: {[key: string]: TermThemeType};
        connections: {[key: string]: ConnKeywords};
        bookmarks: {[key: string]: WebBookmark};
        waveai: {[key: string]: AIModeConfigType};
        configerrors: ConfigError[];
        version: string;
        buildtime: string;
    };

    // waveobj.Job
    type Job = WaveObj & {
        connection: string;
        jobkind: string;
        cmd: string;
        cmdargs?: string[];
        cmdenv?: {[key: string]: string};
        jobauthtoken: string;
        attachedblockid?: string;
        waveversion?: string;
        terminateonreconnect?: boolean;
        jobmanagerstatus: string;
        jobmanagerdonereason?: string;
        jobmanagerstartuperror?: string;
        jobmanagerpid?: number;
        jobmanagerstartts?: number;
        cmdpid?: number;
        cmdstartts?: number;
        cmdtermsize: TermSize;
        cmdexitts?: number;
        cmdexitcode?: number;
        cmdexitsignal?: string;
        cmdexiterror?: string;
        streamdone?: boolean;
        streamerror?: string;
    };

    // wshrpc.JobManagerStatusUpdate
    type JobManagerStatusUpdate = {
        jobid: string;
        jobmanagerstatus: string;
    };

    // waveobj.LayoutActionData
    type LayoutActionData = {
        actiontype: string;
        actionid: string;
        blockid: string;
        nodesize?: number;
        indexarr?: number[];
        focused: boolean;
        magnified: boolean;
        ephemeral: boolean;
        targetblockid?: string;
        position?: string;
    };

    // waveobj.LayoutState
    type LayoutState = WaveObj & {
        rootnode?: any;
        magnifiednodeid?: string;
        focusednodeid?: string;
        leaforder?: LeafOrderEntry[];
        pendingbackendactions?: LayoutActionData[];
    };

    // waveobj.LeafOrderEntry
    type LeafOrderEntry = {
        nodeid: string;
        blockid: string;
    };

    // waveobj.MetaTSType
    type MetaType = {
        view?: string;
        controller?: string;
        file?: string;
        url?: string;
        pinnedurl?: string;
        connection?: string;
        edit?: boolean;
        history?: string[];
        "history:forward"?: string[];
        "display:name"?: string;
        "display:order"?: number;
        icon?: string;
        "icon:color"?: string;
        "frame:*"?: boolean;
        frame?: boolean;
        "frame:bordercolor"?: string;
        "frame:activebordercolor"?: string;
        "frame:title"?: string;
        "frame:icon"?: string;
        "frame:text"?: string;
        "cmd:*"?: boolean;
        cmd?: string;
        "cmd:interactive"?: boolean;
        "cmd:login"?: boolean;
        "cmd:persistent"?: boolean;
        "cmd:runonstart"?: boolean;
        "cmd:clearonstart"?: boolean;
        "cmd:runonce"?: boolean;
        "cmd:closeonexit"?: boolean;
        "cmd:closeonexitforce"?: boolean;
        "cmd:closeonexitdelay"?: number;
        "cmd:nowsh"?: boolean;
        "cmd:args"?: string[];
        "cmd:shell"?: boolean;
        "cmd:allowconnchange"?: boolean;
        "cmd:jwt"?: boolean;
        "cmd:env"?: {[key: string]: string};
        "cmd:cwd"?: string;
        "cmd:initscript"?: string;
        "cmd:initscript.sh"?: string;
        "cmd:initscript.bash"?: string;
        "cmd:initscript.zsh"?: string;
        "cmd:initscript.pwsh"?: string;
        "cmd:initscript.fish"?: string;
        "ai:*"?: boolean;
        "ai:preset"?: string;
        "ai:apitype"?: string;
        "ai:baseurl"?: string;
        "ai:apitoken"?: string;
        "ai:name"?: string;
        "ai:model"?: string;
        "ai:orgid"?: string;
        "ai:apiversion"?: string;
        "ai:maxtokens"?: number;
        "ai:timeoutms"?: number;
        "aifilediff:chatid"?: string;
        "aifilediff:toolcallid"?: string;
        "editor:*"?: boolean;
        "editor:minimapenabled"?: boolean;
        "editor:stickyscrollenabled"?: boolean;
        "editor:wordwrap"?: boolean;
        "editor:fontsize"?: number;
        "graph:*"?: boolean;
        "graph:numpoints"?: number;
        "graph:metrics"?: string[];
        "sysinfo:type"?: string;
        "tab:flagcolor"?: string;
        "tab:background"?: string;
        "bg:*"?: boolean;
        bg?: string;
        "bg:opacity"?: number;
        "bg:blendmode"?: string;
        "bg:bordercolor"?: string;
        "bg:activebordercolor"?: string;
        "layout:vtabbarwidth"?: number;
        "layout:widgetsvisible"?: boolean;
        "waveai:panelopen"?: boolean;
        "waveai:panelwidth"?: number;
        "waveai:model"?: string;
        "waveai:chatid"?: string;
        "waveai:widgetcontext"?: boolean;
        "term:*"?: boolean;
        "term:fontsize"?: number;
        "term:fontfamily"?: string;
        "term:mode"?: string;
        "term:theme"?: string;
        "term:localshellpath"?: string;
        "term:localshellopts"?: string[];
        "term:scrollback"?: number;
        "term:vdomblockid"?: string;
        "term:vdomtoolbarblockid"?: string;
        "term:transparency"?: number;
        "term:allowbracketedpaste"?: boolean;
        "term:shiftenternewline"?: boolean;
        "term:macoptionismeta"?: boolean;
        "term:cursor"?: string;
        "term:cursorblink"?: boolean;
        "term:conndebug"?: string;
        "term:bellsound"?: boolean;
        "term:bellindicator"?: boolean;
        "term:osc52"?: string;
        "term:durable"?: boolean;
        "web:zoom"?: number;
        "web:hidenav"?: boolean;
        "web:partition"?: string;
        "web:useragenttype"?: string;
        "markdown:fontsize"?: number;
        "markdown:fixedfontsize"?: number;
        "tsunami:*"?: boolean;
        "tsunami:sdkreplacepath"?: string;
        "tsunami:apppath"?: string;
        "tsunami:appid"?: string;
        "tsunami:scaffoldpath"?: string;
        "tsunami:env"?: {[key: string]: string};
        "vdom:*"?: boolean;
        "vdom:initialized"?: boolean;
        "vdom:correlationid"?: string;
        "vdom:route"?: string;
        "vdom:persist"?: boolean;
        "onboarding:githubstar"?: boolean;
        "onboarding:lastversion"?: string;
        count?: number;
    };

    // tsgenmeta.MethodMeta
    type MethodMeta = {
        Desc: string;
        ArgNames: string[];
        ReturnDesc: string;
    };

    // wconfig.MimeTypeConfigType
    type MimeTypeConfigType = {
        icon: string;
        color: string;
    };

    // waveobj.ORef
    type ORef = string;

    // waveobj.ObjRTInfo
    type ObjRTInfo = {
        "tsunami:appmeta"?: AppMeta;
        "tsunami:schemas"?: any;
        "shell:hascurcwd"?: boolean;
        "shell:state"?: string;
        "shell:type"?: string;
        "shell:version"?: string;
        "shell:uname"?: string;
        "shell:integration"?: boolean;
        "shell:omz"?: boolean;
        "shell:comp"?: string;
        "shell:inputempty"?: boolean;
        "shell:lastcmd"?: string;
        "shell:lastcmdexitcode"?: number;
        "builder:layout"?: {[key: string]: number};
        "builder:appid"?: string;
        "builder:env"?: {[key: string]: string};
        "waveai:chatid"?: string;
        "waveai:mode"?: string;
        "waveai:maxoutputtokens"?: number;
    };

    // wshrpc.PathCommandData
    type PathCommandData = {
        pathtype: string;
        open: boolean;
        openexternal: boolean;
        tabid: string;
    };

    // waveobj.Point
    type Point = {
        x: number;
        y: number;
    };

    // wshrpc.ProcessInfo
    type ProcessInfo = {
        pid: number;
        ppid?: number;
        command?: string;
        status?: string;
        user?: string;
        mem: number;
        mempct: number;
        cpu: number;
        numthreads: number;
        gone?: boolean;
    };

    // wshrpc.ProcessListResponse
    type ProcessListResponse = {
        processes: ProcessInfo[];
        summary: ProcessSummary;
        ts: number;
        hascpu?: boolean;
        platform?: string;
        totalcount?: number;
        filteredcount?: number;
    };

    // wshrpc.ProcessSummary
    type ProcessSummary = {
        total: number;
        load1?: number;
        load5?: number;
        load15?: number;
        memtotal?: number;
        memused?: number;
        memfree?: number;
        numcpu?: number;
        cpusum?: number;
    };

    // uctypes.RateLimitInfo
    type RateLimitInfo = {
        req: number;
        reqlimit: number;
        preq: number;
        preqlimit: number;
        resetepoch: number;
        unknown?: boolean;
    };

    // wshrpc.RemoteInfo
    type RemoteInfo = {
        clientarch: string;
        clientos: string;
        clientversion: string;
        shell: string;
        homedir: string;
    };

    // wshrpc.RestartBuilderAndWaitResult
    type RestartBuilderAndWaitResult = {
        success: boolean;
        errormessage?: string;
        buildoutput: string;
    };

    // wshrpc.RpcContext
    type RpcContext = {
        sockname?: string;
        routeid: string;
        procroute?: boolean;
        blockid?: string;
        conn?: string;
        isrouter?: boolean;
    };

    // wshutil.RpcMessage
    type RpcMessage = {
        command?: string;
        reqid?: string;
        resid?: string;
        timeout?: number;
        route?: string;
        source?: string;
        cont?: boolean;
        cancel?: boolean;
        error?: string;
        datatype?: string;
        data?: any;
    };

    // wshrpc.RpcOpts
    type RpcOpts = {
        timeout?: number;
        noresponse?: boolean;
        route?: string;
    };

    // waveobj.RuntimeOpts
    type RuntimeOpts = {
        termsize?: TermSize;
        winsize?: WinSize;
    };

    // wshrpc.SecretMeta
    type SecretMeta = {
        desc: string;
        optional: boolean;
    };

    // wconfig.SettingsType
    type SettingsType = {
        "app:*"?: boolean;
        "app:globalhotkey"?: string;
        "app:dismissarchitecturewarning"?: boolean;
        "app:defaultnewblock"?: string;
        "app:showoverlayblocknums"?: boolean;
        "app:ctrlvpaste"?: boolean;
        "app:confirmquit"?: boolean;
        "app:hideaibutton"?: boolean;
        "app:disablectrlshiftarrows"?: boolean;
        "app:disablectrlshiftdisplay"?: boolean;
        "app:focusfollowscursor"?: string;
        "app:tabbar"?: string;
        "feature:waveappbuilder"?: boolean;
        "ai:*"?: boolean;
        "ai:preset"?: string;
        "ai:apitype"?: string;
        "ai:baseurl"?: string;
        "ai:apitoken"?: string;
        "ai:name"?: string;
        "ai:model"?: string;
        "ai:orgid"?: string;
        "ai:apiversion"?: string;
        "ai:maxtokens"?: number;
        "ai:timeoutms"?: number;
        "ai:proxyurl"?: string;
        "ai:fontsize"?: number;
        "ai:fixedfontsize"?: number;
        "waveai:showcloudmodes"?: boolean;
        "waveai:defaultmode"?: string;
        "term:*"?: boolean;
        "term:fontsize"?: number;
        "term:fontfamily"?: string;
        "term:theme"?: string;
        "term:disablewebgl"?: boolean;
        "term:localshellpath"?: string;
        "term:localshellopts"?: string[];
        "term:gitbashpath"?: string;
        "term:scrollback"?: number;
        "term:copyonselect"?: boolean;
        "term:transparency"?: number;
        "term:allowbracketedpaste"?: boolean;
        "term:shiftenternewline"?: boolean;
        "term:macoptionismeta"?: boolean;
        "term:cursor"?: string;
        "term:cursorblink"?: boolean;
        "term:bellsound"?: boolean;
        "term:bellindicator"?: boolean;
        "term:osc52"?: string;
        "term:durable"?: boolean;
        "term:showsplitbuttons"?: boolean;
        "term:trimtrailingwhitespace"?: boolean;
        "editor:minimapenabled"?: boolean;
        "editor:stickyscrollenabled"?: boolean;
        "editor:wordwrap"?: boolean;
        "editor:fontsize"?: number;
        "editor:inlinediff"?: boolean;
        "web:*"?: boolean;
        "web:openlinksinternally"?: boolean;
        "web:defaulturl"?: string;
        "web:defaultsearch"?: string;
        "autoupdate:*"?: boolean;
        "autoupdate:enabled"?: boolean;
        "autoupdate:intervalms"?: number;
        "autoupdate:installonquit"?: boolean;
        "autoupdate:channel"?: string;
        "markdown:fontsize"?: number;
        "markdown:fixedfontsize"?: number;
        "preview:showhiddenfiles"?: boolean;
        "preview:defaultsort"?: string;
        "tab:preset"?: string;
        "tab:confirmclose"?: boolean;
        "tab:background"?: string;
        "widget:*"?: boolean;
        "widget:showhelp"?: boolean;
        "window:*"?: boolean;
        "window:fullscreenonlaunch"?: boolean;
        "window:transparent"?: boolean;
        "window:blur"?: boolean;
        "window:visualeffectstate"?: string;
        "window:opacity"?: number;
        "window:bgcolor"?: string;
        "window:reducedmotion"?: boolean;
        "window:tilegapsize"?: number;
        "window:showmenubar"?: boolean;
        "window:nativetitlebar"?: boolean;
        "window:disablehardwareacceleration"?: boolean;
        "window:maxtabcachesize"?: number;
        "window:magnifiedblockopacity"?: number;
        "window:magnifiedblocksize"?: number;
        "window:magnifiedblockblurprimarypx"?: number;
        "window:magnifiedblockblursecondarypx"?: number;
        "window:confirmclose"?: boolean;
        "window:savelastwindow"?: boolean;
        "window:dimensions"?: string;
        "window:zoom"?: number;
        "telemetry:*"?: boolean;
        "telemetry:enabled"?: boolean;
        "conn:*"?: boolean;
        "conn:askbeforewshinstall"?: boolean;
        "conn:wshenabled"?: boolean;
        "conn:localhostdisplayname"?: string;
        "debug:*"?: boolean;
        "debug:pprofport"?: number;
        "debug:pprofmemprofilerate"?: number;
        "debug:webglstatus"?: boolean;
        "tsunami:*"?: boolean;
        "tsunami:scaffoldpath"?: string;
        "tsunami:sdkreplacepath"?: string;
        "tsunami:sdkversion"?: string;
        "tsunami:gopath"?: string;
    };

    // waveobj.StickerClickOptsType
    type StickerClickOptsType = {
        sendinput?: string;
        createblock?: BlockDef;
    };

    // waveobj.StickerDisplayOptsType
    type StickerDisplayOptsType = {
        icon: string;
        imgsrc: string;
        svgblob?: string;
    };

    // waveobj.StickerType
    type StickerType = {
        stickertype: string;
        style: {[key: string]: any};
        clickopts?: StickerClickOptsType;
        display: StickerDisplayOptsType;
    };

    // wshrpc.StreamMeta
    type StreamMeta = {
        id: string;
        rwnd: number;
        readerrouteid: string;
        writerrouteid: string;
    };

    // wps.SubscriptionRequest
    type SubscriptionRequest = {
        event: string;
        scopes?: string[];
        allscopes?: boolean;
    };

    // wshrpc.SuggestionType
    type SuggestionType = {
        type: string;
        suggestionid: string;
        display: string;
        subtext?: string;
        icon?: string;
        iconcolor?: string;
        iconsrc?: string;
        matchpos?: number[];
        submatchpos?: number[];
        score?: number;
        "file:mimetype"?: string;
        "file:path"?: string;
        "file:name"?: string;
        "url:url"?: string;
    };

    // telemetrydata.TEvent
    type TEvent = {
        uuid?: string;
        ts?: number;
        tslocal?: string;
        event: string;
        props: TEventProps;
    };

    // telemetrydata.TEventProps
    type TEventProps = {
        "client:arch"?: string;
        "client:version"?: string;
        "client:initial_version"?: string;
        "client:buildtime"?: string;
        "client:osrelease"?: string;
        "client:isdev"?: boolean;
        "client:packagetype"?: string;
        "client:macos"?: string;
        "cohort:month"?: string;
        "cohort:isoweek"?: string;
        "autoupdate:channel"?: string;
        "autoupdate:enabled"?: boolean;
        "localshell:type"?: string;
        "localshell:version"?: string;
        "loc:countrycode"?: string;
        "loc:regioncode"?: string;
        "settings:customwidgets"?: number;
        "settings:customaipresets"?: number;
        "settings:customsettings"?: number;
        "settings:customaimodes"?: number;
        "settings:secretscount"?: number;
        "settings:transparent"?: boolean;
        "activity:activeminutes"?: number;
        "activity:fgminutes"?: number;
        "activity:openminutes"?: number;
        "activity:waveaiactiveminutes"?: number;
        "activity:waveaifgminutes"?: number;
        "activity:termcommandsrun"?: number;
        "activity:termcommands:remote"?: number;
        "activity:termcommands:durable"?: number;
        "activity:termcommands:wsl"?: number;
        "app:firstday"?: boolean;
        "app:firstlaunch"?: boolean;
        "action:initiator"?: "keyboard" | "mouse";
        "action:type"?: string;
        "debug:panictype"?: string;
        "block:view"?: string;
        "block:controller"?: string;
        "ai:backendtype"?: string;
        "ai:local"?: boolean;
        "wsh:cmd"?: string;
        "wsh:errorcount"?: number;
        "wsh:count"?: number;
        "conn:conntype"?: string;
        "conn:wsherrorcode"?: string;
        "conn:errorcode"?: string;
        "conn:suberrorcode"?: string;
        "conn:contexterror"?: boolean;
        "onboarding:feature"?: "waveai" | "durable" | "magnify" | "wsh";
        "onboarding:version"?: string;
        "onboarding:githubstar"?: "already" | "star" | "later";
        "onboarding:page"?: string;
        "display:height"?: number;
        "display:width"?: number;
        "display:dpr"?: number;
        "display:count"?: number;
        "display:all"?: any;
        "count:blocks"?: number;
        "count:tabs"?: number;
        "count:windows"?: number;
        "count:workspaces"?: number;
        "count:sshconn"?: number;
        "count:wslconn"?: number;
        "count:jobs"?: number;
        "count:jobsconnected"?: number;
        "count:views"?: {[key: string]: number};
        "waveai:apitype"?: string;
        "waveai:model"?: string;
        "waveai:chatid"?: string;
        "waveai:stepnum"?: number;
        "waveai:inputtokens"?: number;
        "waveai:outputtokens"?: number;
        "waveai:nativewebsearchcount"?: number;
        "waveai:requestcount"?: number;
        "waveai:toolusecount"?: number;
        "waveai:tooluseerrorcount"?: number;
        "waveai:tooldetail"?: {[key: string]: number};
        "waveai:premiumreq"?: number;
        "waveai:proxyreq"?: number;
        "waveai:haderror"?: boolean;
        "waveai:imagecount"?: number;
        "waveai:pdfcount"?: number;
        "waveai:textdoccount"?: number;
        "waveai:textlen"?: number;
        "waveai:firstbytems"?: number;
        "waveai:requestdurms"?: number;
        "waveai:widgetaccess"?: boolean;
        "waveai:thinkinglevel"?: string;
        "waveai:mode"?: string;
        "waveai:provider"?: string;
        "waveai:islocal"?: boolean;
        "waveai:feedback"?: "good" | "bad";
        "waveai:action"?: string;
        "job:donereason"?: string;
        "job:kind"?: string;
        $set?: TEventUserProps;
        $set_once?: TEventUserProps;
    };

    // telemetrydata.TEventUserProps
    type TEventUserProps = {
        "client:arch"?: string;
        "client:version"?: string;
        "client:initial_version"?: string;
        "client:buildtime"?: string;
        "client:osrelease"?: string;
        "client:isdev"?: boolean;
        "client:packagetype"?: string;
        "client:macos"?: string;
        "cohort:month"?: string;
        "cohort:isoweek"?: string;
        "autoupdate:channel"?: string;
        "autoupdate:enabled"?: boolean;
        "localshell:type"?: string;
        "localshell:version"?: string;
        "loc:countrycode"?: string;
        "loc:regioncode"?: string;
        "settings:customwidgets"?: number;
        "settings:customaipresets"?: number;
        "settings:customsettings"?: number;
        "settings:customaimodes"?: number;
        "settings:secretscount"?: number;
        "settings:transparent"?: boolean;
    };

    // waveobj.Tab
    type Tab = WaveObj & {
        name: string;
        layoutstate: string;
        blockids: string[];
    };

    // waveobj.TermSize
    type TermSize = {
        rows: number;
        cols: number;
    };

    // wconfig.TermThemeType
    type TermThemeType = {
        "display:name": string;
        "display:order": number;
        black: string;
        red: string;
        green: string;
        yellow: string;
        blue: string;
        magenta: string;
        cyan: string;
        white: string;
        brightBlack: string;
        brightRed: string;
        brightGreen: string;
        brightYellow: string;
        brightBlue: string;
        brightMagenta: string;
        brightCyan: string;
        brightWhite: string;
        gray: string;
        cmdtext: string;
        foreground: string;
        selectionBackground: string;
        background: string;
        cursor: string;
    };

    // wshrpc.TimeSeriesData
    type TimeSeriesData = {
        ts: number;
        values: {[key: string]: number};
    };

    // uctypes.UIChat
    type UIChat = {
        chatid: string;
        apitype: string;
        model: string;
        apiversion: string;
        messages: UIMessage[];
    };

    // waveobj.UIContext
    type UIContext = {
        windowid: string;
        activetabid: string;
    };

    // uctypes.UIMessage
    type UIMessage = {
        id: string;
        role: string;
        metadata?: any;
        parts?: UIMessagePart[];
    };

    // uctypes.UIMessagePart
    type UIMessagePart = {
        type: string;
        text?: string;
        state?: string;
        toolCallId?: string;
        input?: any;
        output?: any;
        errorText?: string;
        providerExecuted?: boolean;
        sourceId?: string;
        url?: string;
        title?: string;
        filename?: string;
        mediaType?: string;
        id?: string;
        data?: any;
        providerMetadata?: {[key: string]: any};
    };

    // userinput.UserInputRequest
    type UserInputRequest = {
        requestid: string;
        querytext: string;
        responsetype: string;
        title: string;
        markdown: boolean;
        timeoutms: number;
        checkboxmsg: string;
        publictext: boolean;
        oklabel?: string;
        cancellabel?: string;
    };

    // userinput.UserInputResponse
    type UserInputResponse = {
        type: string;
        requestid: string;
        text?: string;
        confirm?: boolean;
        errormsg?: string;
        checkboxstat?: boolean;
    };

    // vdom.VDomAsyncInitiationRequest
    type VDomAsyncInitiationRequest = {
        type: "asyncinitiationrequest";
        ts: number;
        blockid?: string;
    };

    // vdom.VDomBackendOpts
    type VDomBackendOpts = {
        closeonctrlc?: boolean;
        globalkeyboardevents?: boolean;
        globalstyles?: boolean;
    };

    // vdom.VDomBackendUpdate
    type VDomBackendUpdate = {
        type: "backendupdate";
        ts: number;
        blockid: string;
        opts?: VDomBackendOpts;
        haswork?: boolean;
        renderupdates?: VDomRenderUpdate[];
        transferelems?: VDomTransferElem[];
        statesync?: VDomStateSync[];
        refoperations?: VDomRefOperation[];
        messages?: VDomMessage[];
    };

    // vdom.VDomBinding
    type VDomBinding = {
        type: "binding";
        bind: string;
    };

    // vdom.VDomCreateContext
    type VDomCreateContext = {
        type: "createcontext";
        ts: number;
        meta?: MetaType;
        target?: VDomTarget;
        persist?: boolean;
    };

    // vdom.VDomElem
    type VDomElem = {
        waveid?: string;
        tag: string;
        props?: {[key: string]: any};
        children?: VDomElem[];
        text?: string;
    };

    // vdom.VDomEvent
    type VDomEvent = {
        waveid: string;
        eventtype: string;
        globaleventtype?: string;
        targetvalue?: string;
        targetchecked?: boolean;
        targetname?: string;
        targetid?: string;
        keydata?: WaveKeyboardEvent;
        mousedata?: WavePointerData;
    };

    // vdom.VDomFrontendUpdate
    type VDomFrontendUpdate = {
        type: "frontendupdate";
        ts: number;
        blockid: string;
        correlationid?: string;
        dispose?: boolean;
        resync?: boolean;
        rendercontext?: VDomRenderContext;
        events?: VDomEvent[];
        statesync?: VDomStateSync[];
        refupdates?: VDomRefUpdate[];
        messages?: VDomMessage[];
    };

    // vdom.VDomFunc
    type VDomFunc = {
        type: "func";
        stoppropagation?: boolean;
        preventdefault?: boolean;
        globalevent?: string;
        #keys?: string[];
    };

    // vdom.VDomMessage
    type VDomMessage = {
        messagetype: string;
        message: string;
        stacktrace?: string;
        params?: any[];
    };

    // vdom.VDomRef
    type VDomRef = {
        type: "ref";
        refid: string;
        trackposition?: boolean;
        position?: VDomRefPosition;
        hascurrent?: boolean;
    };

    // vdom.VDomRefOperation
    type VDomRefOperation = {
        refid: string;
        op: string;
        params?: any[];
        outputref?: string;
    };

    // vdom.VDomRefPosition
    type VDomRefPosition = {
        offsetheight: number;
        offsetwidth: number;
        scrollheight: number;
        scrollwidth: number;
        scrolltop: number;
        boundingclientrect: DomRect;
    };

    // vdom.VDomRefUpdate
    type VDomRefUpdate = {
        refid: string;
        hascurrent: boolean;
        position?: VDomRefPosition;
    };

    // vdom.VDomRenderContext
    type VDomRenderContext = {
        blockid: string;
        focused: boolean;
        width: number;
        height: number;
        rootrefid: string;
        background?: boolean;
    };

    // vdom.VDomRenderUpdate
    type VDomRenderUpdate = {
        updatetype: "root"|"append"|"replace"|"remove"|"insert";
        waveid?: string;
        vdomwaveid?: string;
        vdom?: VDomElem;
        index?: number;
    };

    // vdom.VDomStateSync
    type VDomStateSync = {
        atom: string;
        value: any;
    };

    // vdom.VDomTarget
    type VDomTarget = {
        newblock?: boolean;
        magnified?: boolean;
        toolbar?: VDomTargetToolbar;
    };

    // vdom.VDomTargetToolbar
    type VDomTargetToolbar = {
        toolbar: boolean;
        height?: string;
    };

    // vdom.VDomTransferElem
    type VDomTransferElem = {
        waveid?: string;
        tag: string;
        props?: {[key: string]: any};
        children?: string[];
        text?: string;
    };

    // wshrpc.VDomUrlRequestData
    type VDomUrlRequestData = {
        method: string;
        url: string;
        headers: {[key: string]: string};
        body?: string;
    };

    // wshrpc.VDomUrlRequestResponse
    type VDomUrlRequestResponse = {
        statuscode?: number;
        headers?: {[key: string]: string};
        body?: string;
    };

    type WSCommandType = {
        wscommand: string;
    } & ( WSRpcCommand );

    // eventbus.WSEventType
    type WSEventType = {
        eventtype: string;
        oref?: string;
        data: any;
    };

    // wps.WSFileEventData
    type WSFileEventData = {
        zoneid: string;
        filename: string;
        fileop: string;
        data64: string;
    };

    // webcmd.WSRpcCommand
    type WSRpcCommand = {
        wscommand: "rpc";
        message: RpcMessage;
    };

    // wconfig.WatcherUpdate
    type WatcherUpdate = {
        fullconfig: FullConfigType;
    };


    // filestore.WaveFile
    type WaveFile = {
        zoneid: string;
        name: string;
        opts: FileOpts;
        createdts: number;
        size: number;
        modts: number;
        meta: {[key: string]: any};
    };

    // wshrpc.WaveFileInfo
    type WaveFileInfo = {
        zoneid: string;
        name: string;
        opts: FileOpts;
        createdts: number;
        size: number;
        modts: number;
        meta: {[key: string]: any};
    };

    // wshrpc.WaveInfoData
    type WaveInfoData = {
        version: string;
        clientid: string;
        buildtime: string;
        configdir: string;
        datadir: string;
    };

    // vdom.WaveKeyboardEvent
    type WaveKeyboardEvent = {
        type: "keydown"|"keyup"|"keypress"|"unknown";
        key: string;
        code: string;
        repeat?: boolean;
        location?: number;
        shift?: boolean;
        control?: boolean;
        alt?: boolean;
        meta?: boolean;
        cmd?: boolean;
        option?: boolean;
    };

    // wshrpc.WaveNotificationOptions
    type WaveNotificationOptions = {
        title?: string;
        body?: string;
        silent?: boolean;
    };

    // waveobj.WaveObj
    type WaveObj = {
        otype: string;
        oid: string;
        version: number;
        meta: MetaType;
    };

    // waveobj.WaveObjUpdate
    type WaveObjUpdate = {
        updatetype: string;
        otype: string;
        oid: string;
        obj?: WaveObj;
    };

    // vdom.WavePointerData
    type WavePointerData = {
        button: number;
        buttons: number;
        clientx?: number;
        clienty?: number;
        pagex?: number;
        pagey?: number;
        screenx?: number;
        screeny?: number;
        movementx?: number;
        movementy?: number;
        shift?: boolean;
        control?: boolean;
        alt?: boolean;
        meta?: boolean;
        cmd?: boolean;
        option?: boolean;
    };

    // waveobj.Window
    type WaveWindow = WaveObj & {
        workspaceid: string;
        isnew?: boolean;
        pos: Point;
        winsize: WinSize;
        lastfocusts: number;
    };

    // wconfig.WebBookmark
    type WebBookmark = {
        url: string;
        title?: string;
        icon?: string;
        iconcolor?: string;
        iconurl?: string;
        "display:order"?: number;
    };

    // service.WebCallType
    type WebCallType = {
        service: string;
        method: string;
        uicontext?: UIContext;
        args: any[];
    };

    // service.WebReturnType
    type WebReturnType = {
        success?: boolean;
        error?: string;
        data?: any;
        updates?: WaveObjUpdate[];
    };

    // wshrpc.WebSelectorOpts
    type WebSelectorOpts = {
        all?: boolean;
        inner?: boolean;
    };

    // wconfig.WidgetConfigType
    type WidgetConfigType = {
        "display:order"?: number;
        "display:hidden"?: boolean;
        icon?: string;
        color?: string;
        label?: string;
        description?: string;
        workspaces?: string[];
        magnified?: boolean;
        blockdef: BlockDef;
    };

    // waveobj.WinSize
    type WinSize = {
        width: number;
        height: number;
    };

    // waveobj.Workspace
    type Workspace = WaveObj & {
        name?: string;
        icon?: string;
        color?: string;
        tabids: string[];
        activetabid: string;
    };

    // wshrpc.WorkspaceInfoData
    type WorkspaceInfoData = {
        windowid: string;
        workspacedata: Workspace;
    };

    // waveobj.WorkspaceListEntry
    type WorkspaceListEntry = {
        workspaceid: string;
        windowid: string;
    };

    // wshrpc.WshServerCommandMeta
    type WshServerCommandMeta = {
        commandtype: string;
    };

}

export {}