Variable fbConst

fb: {
    ApiCallError: typeof ApiCallError;
    artwork: {
        getAvailableArtwork: (
            path: string,
        ) => Promise<ArtworkGetAvailableArtworkResponse>;
        getAvailableTypes: (
            path?: string,
        ) => Promise<ArtworkGetAvailableTypesResponse>;
        getBatch: (
            paths: string[],
            type?: AlbumArtType,
        ) => Promise<ArtworkGetBatchResponse>;
        getByPath: (
            path: string,
            type?: AlbumArtType,
        ) => Promise<ArtworkGetByPathResponse>;
        getByPlaylistItem: (
            playlist: PlaylistRef,
            index: number,
            type?: AlbumArtType,
        ) => Promise<ArtworkGetByPlaylistItemResponse>;
        getCurrent: (type?: AlbumArtType) => Promise<ArtworkGetCurrentResponse>;
        getFb2kUrl: (
            type?: AlbumArtType,
            options?: Pick<ArtworkGetFb2kUrlParams, "maxSize">,
        ) => Promise<ArtworkGetFb2kUrlResponse>;
        getFb2kUrlByPath: (
            path: string,
            type?: AlbumArtType,
            options?: Pick<ArtworkGetFb2kUrlByPathParams, "maxSize">,
        ) => Promise<ArtworkGetFb2kUrlByPathResponse>;
        getFb2kUrlByPathBatch: (
            items: string[] | ArtworkBatchItem[],
            opts?: { maxSize?: number; type?: AlbumArtType },
        ) => Promise<ArtworkGetFb2kUrlByPathBatchResponse>;
        getFolderImages: (
            directory: string,
        ) => Promise<ArtworkGetFolderImagesResponse>;
        getForTrack: (
            path: string,
            type?: AlbumArtType,
            options?: ArtworkOptions,
        ) => Promise<ArtworkGetForTrackResponse>;
        getLyrics: (path?: string) => Promise<ArtworkGetLyricsResponse>;
        getMetadata: (path?: string) => Promise<ArtworkGetMetadataResponse>;
        withMaxSize: (url: string, maxSize?: number) => string;
    };
    audio: {
        analyzeBPM: (path: string) => Promise<AudioAnalyzeBPMResponse>;
        cancelDecodePcm: (taskId: string) => Promise<AudioCancelDecodePcmResponse>;
        cancelFullWaveform: (
            taskId: string,
        ) => Promise<AudioCancelFullWaveformResponse>;
        decodePcm: (path: string, opts?: DecodePcmOptions) => Promise<PcmBuffer>;
        generateFullWaveform: (
            path: string,
            opts?: FullWaveformOptions & { signal?: AbortSignal; timeout?: number },
        ) => Promise<FullWaveformResult>;
        getOutputInfo: () => Promise<AudioGetOutputInfoResponse>;
        getPcmDebugState: () => Promise<AudioGetPcmDebugStateResponse>;
        getSpectrum: (
            options?: AudioGetSpectrumParams,
        ) => Promise<AudioGetSpectrumResponse>;
        getSpectrumDebugState: () => Promise<AudioGetSpectrumDebugStateResponse>;
        getStreamInfo: () => Promise<AudioGetStreamInfoResponse>;
        getWaveform: (
            pathOrOpts?: string | AudioGetWaveformParams,
            opts?: AudioGetWaveformParams,
        ) => Promise<AudioGetWaveformResponse>;
        isVisualizationAvailable: () => Promise<
            AudioIsVisualizationAvailableResponse,
        >;
        setChannelMode: (
            mode: NonNullable<"default" | "back" | "front" | "mono" | undefined>,
        ) => Promise<AudioSetChannelModeResponse>;
        subscribeSpectrum: SpectrumSubscribeFunction;
        subscribeStream: (opts?: PcmStreamOptions) => PcmStream;
        unsubscribeStream: (
            subscriptionId?: string,
        ) => Promise<AudioUnsubscribeStreamResponse>;
    };
    canPlay: (
        track: ContainerTrack,
        limits?: MediaVideoDecodingLimits,
    ) => Promise<MediaCanPlayResult>;
    clipboard: {
        read: () => Promise<ClipboardReadResponse>;
        write: (text: string) => Promise<ClipboardWriteResponse>;
        writeFiles: (paths: string[]) => Promise<ClipboardWriteFilesResponse>;
        writeHTML: (
            html: string,
            plainText?: string,
        ) => Promise<ClipboardWriteHTMLResponse>;
    };
    config: {
        export: () => Promise<ConfigExportResponse>;
        get: (key: string, defaultValue?: JsonValue) => Promise<ConfigGetResponse>;
        getActiveDspPreset: () => Promise<ConfigGetActiveDspPresetResponse>;
        getAdvancedConfig: (
            parentGuid?: string,
        ) => Promise<ConfigGetAdvancedConfigResponse>;
        getAdvancedConfigValue: (
            guid: string,
        ) => Promise<ConfigGetAdvancedConfigValueResponse>;
        getAll: () => Promise<ConfigGetAllResponse>;
        getComponents: () => Promise<ConfigGetComponentsResponse>;
        getCursorFollowPlayback: () => Promise<
            ConfigGetCursorFollowPlaybackResponse,
        >;
        getDspPresets: () => Promise<ConfigGetDspPresetsResponse>;
        getLibraryFilePatterns: () => Promise<
            ConfigGetLibraryFilePatternsResponse,
        >;
        getLibraryStatus: () => Promise<ConfigGetLibraryStatusResponse>;
        getOutputConfig: () => Promise<ConfigGetOutputConfigResponse>;
        getOutputDevices: () => Promise<ConfigGetOutputDevicesResponse>;
        getPlaybackFollowCursor: () => Promise<
            ConfigGetPlaybackFollowCursorResponse,
        >;
        getPreferencesPages: () => Promise<ConfigGetPreferencesPagesResponse>;
        getPreferencesStandardGuids: () => Promise<
            ConfigGetPreferencesStandardGuidsResponse,
        >;
        getReplaygainMode: () => Promise<ConfigGetReplaygainModeResponse>;
        getVersionInfo: () => Promise<ConfigGetVersionInfoResponse>;
        remove: (key: string) => Promise<ConfigRemoveResponse>;
        resetAdvancedConfig: (
            guid: string,
        ) => Promise<ConfigResetAdvancedConfigResponse>;
        set: (key: string, value: JsonValue) => Promise<ConfigSetResponse>;
        setActiveDspPreset: (
            index: number,
        ) => Promise<ConfigSetActiveDspPresetResponse>;
        setAdvancedConfigValue: (
            guid: string,
            value: JsonValue,
        ) => Promise<ConfigSetAdvancedConfigValueResponse>;
        setCursorFollowPlayback: (
            enabled: boolean,
        ) => Promise<ConfigSetCursorFollowPlaybackResponse>;
        setOutputBuffer: {
            (ms: number): Promise<ConfigSetOutputBufferResponse>;
            (
                opts: ConfigSetOutputBufferParams,
            ): Promise<ConfigSetOutputBufferResponse>;
        };
        setOutputDevice: (
            outputId: string,
            deviceId: string,
        ) => Promise<ConfigSetOutputDeviceResponse>;
        setPlaybackFollowCursor: (
            enabled: boolean,
        ) => Promise<ConfigSetPlaybackFollowCursorResponse>;
        setReplaygainMode: (
            mode: ReplaygainSourceMode | ReplaygainSourceModeName,
        ) => Promise<ConfigSetReplaygainModeResponse>;
        showLibraryPreferences: () => Promise<
            ConfigShowLibraryPreferencesResponse,
        >;
    };
    console: {
        error: (
            message: string,
            ...args: JsonValue[],
        ) => Promise<ConsoleErrorResponse>;
        log: (
            message: string,
            ...args: JsonValue[],
        ) => Promise<ConsoleLogResponse>;
        warn: (
            message: string,
            ...args: JsonValue[],
        ) => Promise<ConsoleWarnResponse>;
    };
    cursor: {
        isHidden: () => Promise<CursorIsHiddenResponse>;
        setHidden: (hidden: boolean) => Promise<CursorSetHiddenResponse>;
    };
    dialog: {
        confirm: (opts?: DialogConfirmParams) => Promise<DialogConfirmResponse>;
        openFile: (opts?: DialogOpenFileParams) => Promise<DialogOpenFileResponse>;
        openFolder: (
            opts?: DialogOpenFolderParams,
        ) => Promise<DialogOpenFolderResponse>;
        saveFile: (opts?: DialogSaveFileParams) => Promise<DialogSaveFileResponse>;
    };
    discovery: {
        executeContextMenuByPath: (
            opts: DiscoveryExecuteContextMenuByPathParams,
        ) => Promise<DiscoveryExecuteContextMenuByPathResponse>;
        executeContextMenuCommand: (
            opts: DiscoveryExecuteContextMenuCommandParams,
        ) => Promise<DiscoveryExecuteContextMenuCommandResponse>;
        executeMainMenuCommand: (
            guid: string,
            subGuid?: string,
        ) => Promise<DiscoveryExecuteMainMenuCommandResponse>;
        getAllServices: () => Promise<DiscoveryGetAllServicesResponse>;
        getComponents: () => Promise<DiscoveryGetComponentsResponse>;
        getContextMenuCommands: (
            opts?: DiscoveryGetContextMenuCommandsParams,
        ) => Promise<DiscoveryGetContextMenuCommandsResponse>;
        getContextMenuTree: () => Promise<DiscoveryGetContextMenuTreeResponse>;
        getDspEntries: () => Promise<DiscoveryGetDspEntriesResponse>;
        getInputFormats: () => Promise<DiscoveryGetInputFormatsResponse>;
        getMainMenuCommands: (
            opts?: DiscoveryGetMainMenuCommandsParams,
        ) => Promise<DiscoveryGetMainMenuCommandsResponse>;
        getMainMenuGroups: () => Promise<DiscoveryGetMainMenuGroupsResponse>;
        getOutputDevices: () => Promise<DiscoveryGetOutputDevicesResponse>;
        getPreferencePages: () => Promise<DiscoveryGetPreferencePagesResponse>;
        getUIElements: () => Promise<DiscoveryGetUIElementsResponse>;
        searchCommands: (
            query: string,
            opts?: Omit<DiscoverySearchCommandsParams, "query">,
        ) => Promise<DiscoverySearchCommandsResponse>;
    };
    dnd: {
        applyDragToken: (dataTransfer: DataTransfer, token: string) => void;
        getCapabilities: () => Promise<DndGetCapabilitiesResponse>;
        getPaths: () => string[];
        getPathsAsync: (sessionId?: string) => Promise<DndGetPathsAsyncResponse>;
        getResolvedPaths: () => (string | null)[];
        hasFiles: () => boolean;
        onDragEnded: (
            handler: (payload: DndDragEndedPayload) => void,
        ) => () => void;
        prepareDrag: (paths: string[]) => Promise<DndPrepareDragResponse>;
        startDrag: (_type?: string) => Promise<DndStartDragResponse>;
    };
    dsp: {
        addDsp: (guid: string, position?: number) => Promise<DspAddDspResponse>;
        applyPreset: (
            indexOrName: string | number,
        ) => Promise<DspApplyPresetResponse>;
        getAvailable: () => Promise<DspGetAvailableResponse>;
        getChain: () => Promise<DspGetChainResponse>;
        getPresets: () => Promise<DspGetPresetsResponse>;
        moveDsp: (from: number, to: number) => Promise<DspMoveDspResponse>;
        removeDsp: (index: number) => Promise<DspRemoveDspResponse>;
        setChain: (
            dsps: readonly Pick<DspChainSpec, "guid">[],
        ) => Promise<DspSetChainResponse>;
    };
    event: {
        emit: (
            eventName: string,
            payload?: JsonValue,
            excludeSelf?: boolean,
        ) => Promise<EventEmitResponse>;
        emitTo: (
            eventName: string,
            payload: JsonValue,
            targetWindowId: string,
        ) => Promise<EventEmitToResponse>;
    };
    file: {
        cancelOp: (operationId: string) => Promise<FileCancelOpResponse>;
        copy: (
            source: string,
            destination: string,
            opts?: Omit<FileCopyParams, "source" | "destination">,
        ) => Promise<FileCopyResponse>;
        copyAsync: (
            items: FileOpEntry[],
            opts?: FileOpAsyncOptions,
        ) => Promise<FileCopyAsyncResponse>;
        delete: (
            path: string,
            opts?: Omit<FileDeleteParams, "path">,
        ) => Promise<FileDeleteResponse>;
        deleteAsync: (
            paths: string[],
            opts?: FileDeleteAsyncOptions,
        ) => Promise<FileDeleteAsyncResponse>;
        exists: (path: string) => Promise<FileExistsResponse>;
        getInfo: (path: string) => Promise<FileGetInfoResponse>;
        list: (
            path: string,
            opts?: Omit<FileListParams, "path">,
        ) => Promise<FileListResponse>;
        mkdir: (path: string) => Promise<FileMkdirResponse>;
        move: (source: string, destination: string) => Promise<FileMoveResponse>;
        moveAsync: (
            items: FileOpEntry[],
            opts?: FileOpAsyncOptions,
        ) => Promise<FileMoveAsyncResponse>;
        read: (
            path: string,
            opts?: Omit<FileReadParams, "path">,
        ) => Promise<FileReadResponse>;
        readBinary: (path: string) => Promise<Uint8Array<ArrayBufferLike>>;
        rename: (path: string, newName: string) => Promise<FileRenameResponse>;
        write: (
            path: string,
            content: string,
            opts?: Omit<FileWriteParams, "content" | "path">,
        ) => Promise<FileWriteResponse>;
        writeBinary: (
            path: string,
            bytes: ArrayBuffer | Uint8Array<ArrayBufferLike>,
            opts?: FileBinaryWriteOptions,
        ) => Promise<FileWriteResponse>;
        writeDataUrl: (
            path: string,
            dataUrl: string,
            opts?: FileBinaryWriteOptions,
        ) => Promise<FileWriteResponse>;
    };
    http: {
        abort: (requestId: string) => Promise<HttpAbortResponse>;
        delete: {
            (url: string, body?: JsonValue): Promise<HttpGetResponse>;
            (
                url: string,
                body: JsonValue,
                opts: HttpBinaryRequestOptions,
            ): Promise<HttpBinaryResponse>;
            (
                url: string,
                body: JsonValue,
                opts: HttpRequestOptions,
            ): Promise<HttpGetResponse>;
        };
        disableDefaultDownloadLogger: () => void;
        download: (
            url: string,
            saveTo: string,
            opts?: HttpDownloadOptions,
        ) => Promise<HttpDownloadResponse>;
        get: {
            (url: string): Promise<HttpGetResponse>;
            (
                url: string,
                opts: HttpBinaryRequestOptions,
            ): Promise<HttpBinaryResponse>;
            (url: string, opts: HttpRequestOptions): Promise<HttpGetResponse>;
        };
        head: (
            url: string,
            opts?: Omit<HttpRequestOptions, "responseType">,
        ) => Promise<HttpHeadResponse>;
        patch: {
            (url: string, body?: JsonValue): Promise<HttpGetResponse>;
            (
                url: string,
                body: JsonValue,
                opts: HttpBinaryRequestOptions,
            ): Promise<HttpBinaryResponse>;
            (
                url: string,
                body: JsonValue,
                opts: HttpRequestOptions,
            ): Promise<HttpGetResponse>;
        };
        post: {
            (url: string, body?: JsonValue): Promise<HttpGetResponse>;
            (
                url: string,
                body: JsonValue,
                opts: HttpBinaryRequestOptions,
            ): Promise<HttpBinaryResponse>;
            (
                url: string,
                body: JsonValue,
                opts: HttpRequestOptions,
            ): Promise<HttpGetResponse>;
        };
        put: {
            (url: string, body?: JsonValue): Promise<HttpGetResponse>;
            (
                url: string,
                body: JsonValue,
                opts: HttpBinaryRequestOptions,
            ): Promise<HttpBinaryResponse>;
            (
                url: string,
                body: JsonValue,
                opts: HttpRequestOptions,
            ): Promise<HttpGetResponse>;
        };
        request: {
            (url: string): Promise<HttpGetSuccess>;
            (url: string, opts: HttpBinaryRequestOptions): Promise<HttpBinarySuccess>;
            (url: string, opts: HttpRequestOptions): Promise<HttpGetSuccess>;
        };
    };
    invoke: <TResp = unknown>(
        method: string,
        params?: object,
    ) => Promise<TResp>;
    isAvailable: () => boolean;
    jitQueue: {
        clear: () => Promise<JitQueueClearResponse>;
        enqueueNext: (
            opts: JitQueueEnqueueNextParams,
        ) => Promise<JitQueueEnqueueNextResponse>;
        getState: () => Promise<JitQueueGetStateResponse>;
        notifyEmpty: () => Promise<JitQueueNotifyEmptyResponse>;
        playNow: (opts: JitQueuePlayNowParams) => Promise<JitQueuePlayNowResponse>;
        preloadBatch: (
            opts: JitQueuePreloadBatchParams,
        ) => Promise<JitQueuePreloadBatchResponse>;
        skip: () => Promise<JitQueueSkipResponse>;
        stop: (opts?: JitQueueStopParams) => Promise<JitQueueStopResponse>;
    };
    jitSession: {
        adoptNative: (
            params: JitSessionAdoptNativeParams,
        ) => Promise<JitSessionAdoptNativeResponse>;
        claimControl: (
            params: JitSessionClaimControlParams,
        ) => Promise<JitSessionClaimControlResponse>;
        create: (
            params: JitSessionCreateParams,
        ) => Promise<JitSessionCreateResponse>;
        discover: () => Promise<JitSessionDiscoverResponse>;
        getCapabilities: () => Promise<JitSessionGetCapabilitiesResponse>;
        getNativeContext: (
            params: JitSessionGetNativeContextParams,
        ) => Promise<JitSessionGetNativeContextResponse>;
        getOperation: (
            params: JitSessionGetOperationParams,
        ) => Promise<JitSessionGetOperationResponse>;
        getState: (
            params: JitSessionGetStateParams,
        ) => Promise<JitSessionGetStateResponse>;
        play: (params: JitSessionPlayParams) => Promise<JitSessionPlayResponse>;
        playNative: (
            params: JitSessionPlayNativeParams,
        ) => Promise<JitSessionPlayNativeResponse>;
        prepareAdoption: (
            params: JitSessionPrepareAdoptionParams,
        ) => Promise<JitSessionPrepareAdoptionResponse>;
        release: (
            params: JitSessionReleaseParams,
        ) => Promise<JitSessionReleaseResponse>;
        setNativeNext: (
            params: JitSessionSetNativeNextParams,
        ) => Promise<JitSessionSetNativeNextResponse>;
        setNativeQueue: (
            params: JitSessionSetNativeQueueParams,
        ) => Promise<JitSessionSetNativeQueueResponse>;
        setNext: (
            params: JitSessionSetNextParams,
        ) => Promise<JitSessionSetNextResponse>;
        skip: (params: JitSessionSkipParams) => Promise<JitSessionSkipResponse>;
        stop: (params: JitSessionStopParams) => Promise<JitSessionStopResponse>;
    };
    JitSessionClient: typeof JitSessionClient;
    keyboard: {
        getRegisteredHotkeys: () => Promise<
            KeyboardGetRegisteredHotkeysResponse,
        >;
        registerHotkey: (
            key: string,
            action: string,
            opts?: Omit<KeyboardRegisterHotkeyParams, "key" | "action">,
        ) => Promise<KeyboardRegisterHotkeyResponse>;
        registerShortcut: (
            key: string,
            action: string,
        ) => Promise<KeyboardRegisterShortcutResponse>;
        setReservedKeys: (
            keys: string[],
            options?: { all?: boolean },
        ) => Promise<KeyboardSetReservedKeysResponse>;
        unregisterHotkey: (
            opts: KeyboardUnregisterHotkeyParams,
        ) => Promise<KeyboardUnregisterHotkeyResponse>;
    };
    library: {
        addToPlaylist: (
            paths: string[],
            playlist?: PlaylistRef,
        ) => Promise<LibraryAddToPlaylistResponse>;
        browseDirectory: (
            path: string,
            includeFiles?: boolean,
        ) => Promise<LibraryBrowseDirectoryResponse>;
        browseTree: (
            params: LibraryBrowseTreeParams,
        ) => Promise<LibraryBrowseTreeResponse>;
        enumerateDirectories: (
            options?: LibraryEnumerateDirectoriesOptions,
        ) => AsyncGenerator<
            LibraryDirectoryBatch,
            LibraryEnumerateDirectoriesSummary,
            void,
        >;
        enumerateFieldValues: (
            field: string,
            options?: LibraryEnumerateFieldValuesOptions,
        ) => Promise<LibraryGetFieldValuesResponse>;
        enumerateTracks: (
            options?: LibraryEnumerateTracksOptions,
        ) => AsyncGenerator<
            LibraryEnumerateTracksPage,
            LibraryEnumerateTracksSummary,
            void,
        >;
        enumerateTree: (
            options: LibraryEnumerateTreeOptions,
        ) => AsyncGenerator<LibraryTreeBatch, LibraryEnumerateTreeSummary, void>;
        getAlbums: (
            options?: number | LibraryGetAlbumsParams,
        ) => Promise<LibraryGetAlbumsResponse>;
        getAlbumTracks: (
            album: string,
            albumArtist: string,
            options?: Pick<LibraryGetAlbumTracksParams, "albumId">,
        ) => Promise<LibraryGetAlbumTracksResponse>;
        getAll: (
            start?: number,
            count?: number,
            opts?: Pick<LibraryGetAllParams, "useCache" | "asyncResult"> & {
                timeout?: number;
            },
        ) => Promise<ApiFailure | LibraryPagedTracksResponse>;
        getArtistAlbums: (
            artist: string,
            limit?: number,
            options?: Omit<LibraryGetArtistAlbumsParams, "artist" | "limit">,
        ) => Promise<LibraryGetArtistAlbumsResponse>;
        getArtists: (
            limit?: number,
            options?: Omit<LibraryGetArtistsParams, "limit">,
        ) => Promise<LibraryGetArtistsResponse>;
        getArtistTracks: (
            artist: string,
            limit?: number,
        ) => Promise<LibraryGetArtistTracksResponse>;
        getByPath: (path: string) => Promise<LibraryGetByPathResponse>;
        getCacheStats: () => Promise<LibraryGetCacheStatsResponse>;
        getChanges: (
            params?: LibraryGetChangesParams,
        ) => Promise<LibraryGetChangesResponse>;
        getCount: () => Promise<LibraryGetCountResponse>;
        getFieldValues: (
            field: string,
            limit?: number,
            separator?: string,
        ) => Promise<LibraryGetFieldValuesResponse>;
        getGenres: () => Promise<LibraryGetGenresResponse>;
        getRandomTracks: (
            count?: number,
        ) => Promise<LibraryGetRandomTracksResponse>;
        getRecentlyAdded: (
            limit?: number,
            sortBy?: "added" | "modified",
        ) => Promise<LibraryGetRecentlyAddedResponse>;
        getRoots: () => Promise<LibraryGetRootsResponse>;
        getStats: () => Promise<LibraryGetStatsResponse>;
        getStatus: () => Promise<LibraryGetStatusResponse>;
        getTracks: (
            handles: string[],
            fields?: string[],
        ) => Promise<LibraryGetTracksResponse>;
        invalidateCache: () => Promise<LibraryInvalidateCacheResponse>;
        isEnabled: () => Promise<LibraryIsEnabledResponse>;
        query: (
            query: string,
            sort?: string,
            limit?: number,
            fields?: string[],
        ) => Promise<LibraryQueryResponse>;
        refresh: () => Promise<LibraryRefreshResponse>;
        rescan: () => Promise<LibraryRescanResponse>;
        search: (
            query: string,
            limit?: number,
            options?: Omit<LibrarySearchParams, "limit" | "query">,
        ) => Promise<LibrarySearchResponse>;
    };
    log: {
        clear: () => Promise<LogClearResponse>;
        read: (lines?: number) => Promise<LogReadResponse>;
        write: (
            message: string,
            opts?: LogWriteParams,
        ) => Promise<LogWriteResponse>;
    };
    lyrics: {
        exists: (
            path: string,
            options?: Omit<LyricsExistsParams, "path">,
        ) => Promise<LyricsExistsResponse>;
        get: (
            path?: string,
            options?: Omit<LyricsGetParams, "path">,
        ) => Promise<LyricsGetResponse>;
        save: (
            path: string,
            lyricsText: string,
            opts?: LyricsSaveOptions,
        ) => Promise<LyricsSaveResponse>;
    };
    media: {
        canPlay: (
            track: ContainerTrack,
            limits?: MediaVideoDecodingLimits,
        ) => Promise<MediaCanPlayResult>;
        getContainerInfo: (path: string) => Promise<MediaGetContainerInfoResponse>;
        getStreamUrl: (path: string) => Promise<MediaGetStreamUrlResponse>;
    };
    MediaElementFollower: typeof MediaElementFollower;
    menu: {
        close: (reason?: string) => Promise<MenuCloseResponse>;
        getContextMenu: (
            opts?: MenuGetContextMenuParams,
        ) => Promise<MenuGetContextMenuResponse>;
        getMainMenu: (
            root?: string,
            opts?: Omit<MenuGetMainMenuParams, "root">,
        ) => Promise<MenuGetMainMenuResponse>;
        popup: (
            items: MenuPopupItem[],
            position?: MenuPopupPosition,
            opts?: MenuPopupOptions,
        ) => Promise<string | null>;
        runContextCommand: (
            command: string,
            opts?: Omit<MenuRunContextCommandParams, "command">,
        ) => Promise<MenuRunContextCommandResponse>;
        runContextCommandById: (
            id: number,
            opts?: Omit<MenuRunContextCommandByIdParams, "id">,
        ) => Promise<MenuRunContextCommandByIdResponse>;
        runMainMenuCommand: (
            command: string,
            opts?: Omit<MenuRunMainMenuCommandParams, "command">,
        ) => Promise<MenuRunMainMenuCommandResponse>;
        show: (
            items: MenuPopupItem[],
            position?: MenuPopupPosition,
            opts?: MenuPopupOptions,
        ) => Promise<MenuShowResponse>;
        showNativePopup: (
            opts?: MenuShowNativePopupParams,
        ) => Promise<MenuShowNativePopupResponse>;
    };
    metadata: {
        cancelProbe: (
            operationId: string,
        ) => Promise<MetadataCancelProbeResponse>;
        disableDefaultLogger: () => void;
        embedArtwork: (
            path: string,
            opts: Omit<MetadataEmbedArtworkParams, "path" | "target"> & {
                target?: string | string[];
            },
        ) => Promise<MetadataEmbedArtworkResponse>;
        embedArtworkBytes: (
            path: string,
            bytes: ArrayBuffer | Uint8Array<ArrayBufferLike>,
            opts?: MetadataArtworkBytesOptions,
        ) => Promise<MetadataEmbedArtworkResponse>;
        embedArtworkFromDataUrl: (
            path: string,
            dataUrl: string,
            opts?: MetadataArtworkBytesOptions,
        ) => Promise<MetadataEmbedArtworkResponse>;
        probeBatchAsync: (
            paths: string[],
            opts?: Omit<MetadataProbeBatchAsyncParams, "paths">,
        ) => Promise<MetadataProbeBatchAsyncResponse>;
        read: (
            path: string,
            opts?: Omit<MetadataReadParams, "path">,
        ) => Promise<MetadataReadResponse>;
        readBatch: (paths: string[]) => Promise<MetadataReadBatchResponse>;
        readByPath: (
            path: string,
            opts?: Omit<MetadataReadByPathParams, "path">,
        ) => Promise<MetadataReadByPathResponse>;
        readRaw: (
            path: string,
            opts?: Omit<MetadataReadRawParams, "path">,
        ) => Promise<MetadataReadRawResponse>;
        removeEmbeddedArt: (
            path: string,
            opts?: Omit<MetadataRemoveEmbeddedArtParams, "path">,
        ) => Promise<MetadataRemoveEmbeddedArtResponse>;
        removeField: (
            path: string,
            field: string,
            opts?: Omit<MetadataRemoveFieldParams, "path" | "tags">,
        ) => Promise<MetadataRemoveFieldResponse>;
        removeTag: (
            path: string,
            tags: string[],
            opts?: Omit<MetadataRemoveTagParams, "path" | "tags">,
        ) => Promise<MetadataRemoveTagResponse>;
        write: (
            path: string,
            tags: JsonObject,
            opts?: Omit<MetadataWriteParams, "path" | "tags">,
        ) => Promise<MetadataWriteResponse>;
        writeBatch: (
            items: MetadataWriteBatchItem[],
        ) => Promise<MetadataWriteBatchResponse>;
    };
    misc: {
        exit: () => Promise<MiscExitResponse>;
        getComponentPath: () => Promise<MiscGetComponentPathResponse>;
        getFoobarPath: () => Promise<MiscGetFoobarPathResponse>;
        getProfilePath: () => Promise<MiscGetProfilePathResponse>;
        restart: () => Promise<MiscRestartResponse>;
        showConsole: () => Promise<MiscShowConsoleResponse>;
        showLibrarySearch: (
            query?: string,
        ) => Promise<MiscShowLibrarySearchResponse>;
        showPopupMessage: (
            message: string,
            title?: string,
        ) => Promise<MiscShowPopupMessageResponse>;
        showPreferences: () => Promise<MiscShowPreferencesResponse>;
    };
    notification: {
        hide: () => Promise<UiHideNotificationResponse>;
        show: (
            opts: UiShowNotificationParams,
        ) => Promise<UiShowNotificationResponse>;
        showCustomMenu: (
            opts: UiShowCustomMenuParams,
        ) => Promise<UiShowCustomMenuResponse>;
        showToast: (opts: UiShowToastParams) => Promise<UiShowToastResponse>;
    };
    off: (event: string, handler: RawEventHandler) => void;
    on: {
        <K extends FBEventName>(
            event: K,
            handler: FBEventHandler<K>,
        ): () => void;
        (event: string, handler: RawEventHandler): () => void;
    };
    once: {
        <K extends FBEventName>(
            event: K,
            handler: FBEventHandler<K>,
        ): () => void;
        (event: string, handler: RawEventHandler): () => void;
    };
    output: {
        getDevices: () => Promise<OutputGetDevicesResponse>;
        getEntries: () => Promise<OutputGetEntriesResponse>;
        getSettings: () => Promise<OutputGetSettingsResponse>;
    };
    panel: {
        getConfig: () => Promise<PanelGetConfigResponse>;
        setConfig: (opts: PanelSetConfigParams) => Promise<PanelSetConfigResponse>;
    };
    PlaybackClock: typeof PlaybackClock;
    playcount: {
        get: (path: string) => Promise<PlaycountGetResponse>;
        getBatch: (paths: string[]) => Promise<PlaycountGetBatchResponse>;
        getStats: () => Promise<PlaycountGetStatsResponse>;
        set: (path: string, count: number) => Promise<PlaycountSetResponse>;
    };
    player: {
        getCurrentTrack: () => Promise<PlaybackGetCurrentTrackResponse>;
        getCurrentTrackIndex: (
            includeTrackInfo?: boolean,
        ) => Promise<PlaybackGetCurrentTrackIndexResponse>;
        getOrder: () => Promise<PlaybackGetPlaybackOrderResponse>;
        getPlayingPlaylist: () => Promise<PlaybackGetPlayingPlaylistResponse>;
        getPosition: () => Promise<PlaybackGetPositionResponse>;
        getState: () => Promise<PlaybackGetStateResponse>;
        getStopAfterCurrent: () => Promise<PlaybackGetStopAfterCurrentResponse>;
        getVolume: () => Promise<PlaybackGetVolumeResponse>;
        mute: (muted?: boolean) => Promise<PlaybackMuteResponse>;
        next: () => Promise<PlaybackNextResponse>;
        pause: () => Promise<PlaybackPauseResponse>;
        play: () => Promise<PlaybackPlayResponse>;
        playPath: (path: string) => Promise<PlaybackPlayPathResponse>;
        playPaths: {
            (
                paths: string[],
                startIndex?: number,
            ): Promise<PlaybackPlayPathsResponse>;
            (
                paths: string[],
                opts: { replace?: boolean; startIndex?: number },
            ): Promise<PlaybackPlayPathsResponse>;
        };
        playPause: () => Promise<PlaybackPlayPauseResponse>;
        prev: () => Promise<PlaybackPreviousResponse>;
        random: () => Promise<PlaybackRandomResponse>;
        seek: (seconds: number) => Promise<PlaybackSetPositionResponse>;
        setOrder: (
            order: number | PlaybackOrder,
        ) => Promise<PlaybackSetPlaybackOrderResponse>;
        setStopAfterCurrent: (
            enabled: boolean,
        ) => Promise<PlaybackSetStopAfterCurrentResponse>;
        setVolume: (volume: number) => Promise<PlaybackSetVolumeResponse>;
        stop: () => Promise<PlaybackStopResponse>;
        toggle: () => Promise<PlaybackPlayOrPauseResponse>;
        toggleMute: () => Promise<PlaybackToggleMuteResponse>;
        toggleStopAfterCurrent: () => Promise<
            PlaybackToggleStopAfterCurrentResponse,
        >;
        volumeDown: () => Promise<PlaybackVolumeDownResponse>;
        volumeUp: () => Promise<PlaybackVolumeUpResponse>;
    };
    playlist: {
        add: (
            playlist: PlaylistRef,
            paths: string[],
        ) => Promise<PlaylistAddPathsResponse>;
        addAsync: (
            playlist: PlaylistRef,
            paths: string[],
        ) => Promise<PlaylistAddPathsAsyncResponse>;
        addHandles: (
            playlist: PlaylistRef,
            handles: PlaylistHandleRef[],
        ) => Promise<PlaylistAddHandlesResponse>;
        addSequential: (
            playlist: PlaylistRef,
            paths: string[],
        ) => Promise<PlaylistAddPathsSequentialResponse>;
        clear: (playlist: PlaylistRef) => Promise<PlaylistClearResponse>;
        convertToAutoplaylist: (
            playlist: PlaylistRef,
            query: string,
            sort?: string,
            keepSorted?: boolean,
        ) => Promise<PlaylistConvertToAutoplaylistResponse>;
        create: (
            name: string,
            options?: Omit<PlaylistCreateParams, "name">,
        ) => Promise<PlaylistCreateResponse>;
        createAutoplaylist: (
            name: string,
            query: string,
            sort?: string,
            keepSorted?: boolean,
        ) => Promise<PlaylistCreateAutoplaylistResponse>;
        createManagedAutoplaylist: (
            name: string,
            query: string,
            sort?: string,
            keepSorted?: boolean,
        ) => Promise<PlaylistCreateManagedAutoplaylistResponse>;
        deselectAll: (
            playlist: PlaylistRef,
        ) => Promise<PlaylistDeselectAllResponse>;
        duplicate: (
            playlist: PlaylistRef,
            name?: string,
        ) => Promise<PlaylistDuplicateResponse>;
        focusTrack: (
            playlist: PlaylistRef,
            trackIndex: number,
        ) => Promise<PlaylistFocusTrackResponse>;
        getActive: () => Promise<PlaylistGetActiveResponse>;
        getAll: () => Promise<PlaylistGetAllResponse>;
        getAutoplaylistConfig: (
            playlist: PlaylistRef,
        ) => Promise<PlaylistGetAutoplaylistConfigResponse>;
        getAutoplaylistInfo: (
            playlist: PlaylistRef,
        ) => Promise<PlaylistGetAutoplaylistInfoResponse>;
        getAutoplaylistQuery: (
            playlist: PlaylistRef,
        ) => Promise<PlaylistGetAutoplaylistQueryResponse>;
        getAvailableColumns: () => Promise<PlaylistGetAvailableColumnsResponse>;
        getCount: (
            playlist: PlaylistRef,
        ) => Promise<PlaylistGetTrackCountResponse>;
        getFocused: (
            playlist: PlaylistRef,
        ) => Promise<PlaylistGetFocusedTrackResponse>;
        getFocusTrack: (
            playlist: PlaylistRef,
        ) => Promise<PlaylistGetFocusTrackResponse>;
        getGroupRuns: (
            patterns: string[],
            playlist?: PlaylistRef,
        ) => Promise<PlaylistGetGroupRunsResponse>;
        getLockInfo: (
            playlist: PlaylistRef,
        ) => Promise<PlaylistGetLockInfoResponse>;
        getMatchingRows: (
            query: string,
            playlist?: PlaylistRef,
        ) => Promise<PlaylistGetMatchingRowsResponse>;
        getPlaying: () => Promise<PlaylistGetPlayingResponse>;
        getPlaylistCount: () => Promise<PlaylistGetCountResponse>;
        getSelectedTracks: (
            playlist: PlaylistRef,
        ) => Promise<PlaylistGetSelectedTracksResponse>;
        getSelection: (
            playlist: PlaylistRef,
        ) => Promise<PlaylistGetSelectionResponse>;
        getTracks: (
            playlist: PlaylistRef,
            start?: number,
            count?: number,
            formats?: Record<string, string>,
            fields?: string[],
        ) => Promise<PlaylistGetTracksResponse>;
        getTracksAt: (
            playlist: PlaylistRef,
            rows: readonly number[],
            formats?: Record<string, string>,
            fields?: string[],
        ) => Promise<PlaylistGetTracksAtResponse>;
        getTracksPage: (
            playlist: PlaylistRef,
            start?: number,
            count?: number,
            formats?: Record<string, string>,
            fields?: string[],
        ) => Promise<PlaylistGetTracksResponse>;
        insertTracks: (
            playlist: PlaylistRef,
            insertIndex: number,
            handles: PlaylistHandleRef[],
            expectedVersion?: string,
        ) => Promise<PlaylistInsertTracksResponse>;
        isAutoplaylist: (
            playlist: PlaylistRef,
        ) => Promise<PlaylistIsAutoplaylistResponse>;
        isLocked: (playlist: PlaylistRef) => Promise<PlaylistIsLockedResponse>;
        moveTracks: (
            playlist: PlaylistRef,
            indices: number[],
            delta: number,
            expectedVersion?: string,
        ) => Promise<PlaylistMoveTracksResponse>;
        onAutoplaylistConfigChanged: (
            callback: (event: PlaylistAutoplaylistConfigChangedPayload) => void,
        ) => () => void;
        onAutoplaylistUIResult: (
            callback: (event: PlaylistAutoplaylistUIResultPayload) => void,
        ) => () => void;
        playTrack: (
            playlist: PlaylistRef,
            trackIndex: number,
            options?: Omit<
                PlaylistPlayTrackParams,
                "index"
                | "playlist"
                | "playlistGuid",
            >,
        ) => Promise<PlaylistPlayTrackResponse>;
        redo: (playlist: PlaylistRef) => Promise<PlaylistRedoResponse>;
        remove: (playlist: PlaylistRef) => Promise<PlaylistRemoveResponse>;
        removeAutoplaylist: (
            playlist: PlaylistRef,
        ) => Promise<PlaylistRemoveAutoplaylistResponse>;
        removeSelectedTracks: (
            playlist: PlaylistRef,
        ) => Promise<PlaylistRemoveSelectedTracksResponse>;
        removeTracks: (
            playlist: PlaylistRef,
            indices: number[],
            expectedVersion?: string,
        ) => Promise<PlaylistRemoveTracksResponse>;
        rename: (
            playlist: PlaylistRef,
            name: string,
        ) => Promise<PlaylistRenameResponse>;
        reorder: (
            playlist: PlaylistRef,
            order: number[],
            expectedVersion?: string,
        ) => Promise<PlaylistReorderResponse>;
        reorderPlaylists: (
            order: readonly string[] | readonly number[],
        ) => Promise<PlaylistReorderPlaylistsResponse>;
        replaceAllAndPlay: (
            options: PlaylistReplaceAllAndPlayParams,
        ) => Promise<PlaylistReplaceAllAndPlayResponse>;
        reverse: (playlist: PlaylistRef) => Promise<PlaylistReverseResponse>;
        selectAll: (playlist: PlaylistRef) => Promise<PlaylistSelectAllResponse>;
        setActive: (playlist: PlaylistRef) => Promise<PlaylistSetActiveResponse>;
        setAutoplaylistConfig: (
            playlist: PlaylistRef,
            options: Omit<
                PlaylistSetAutoplaylistConfigParams,
                "playlist"
                | "playlistGuid",
            >,
        ) => Promise<PlaylistSetAutoplaylistConfigResponse>;
        setFocused: (
            playlist: PlaylistRef,
            trackIndex: number,
            expectedVersion?: string,
        ) => Promise<PlaylistSetFocusedTrackResponse>;
        setSelection: (
            playlist: PlaylistRef,
            indices: number[],
            clearOthers?: boolean,
            expectedVersion?: string,
        ) => Promise<PlaylistSetSelectionResponse>;
        showAutoplaylistUI: (
            playlist: PlaylistRef,
        ) => Promise<PlaylistShowAutoplaylistUIResponse>;
        shuffle: (playlist: PlaylistRef) => Promise<PlaylistShuffleResponse>;
        sort: (
            playlist: PlaylistRef,
            pattern: string,
            descending?: boolean,
            selectedOnly?: boolean,
        ) => Promise<PlaylistSortResponse>;
        undo: (playlist: PlaylistRef) => Promise<PlaylistUndoResponse>;
    };
    port: {
        connect: (name: string) => Promise<PortConnectResponse>;
        disconnect: (portId: string) => Promise<PortDisconnectResponse>;
        getPorts: (name?: string) => Promise<PortGetPortsResponse>;
        onConnect: (handler: (data: unknown) => void) => () => void;
        onDisconnect: (handler: (data: unknown) => void) => () => void;
        onMessage: (handler: (data: unknown) => void) => () => void;
        postMessage: (
            portId: string,
            message: JsonValue,
        ) => Promise<PortPostMessageResponse>;
        postMessageTo: (
            portId: string,
            targetPortId: string,
            message: JsonValue,
        ) => Promise<PortPostMessageToResponse>;
    };
    queue: {
        add: (opts: QueueAddParams) => Promise<QueueAddResponse>;
        addPaths: (
            paths: string[],
            opts?: Omit<QueueAddPathsParams, "paths">,
        ) => Promise<QueueAddPathsResponse>;
        clear: () => Promise<QueueClearResponse>;
        flush: () => Promise<QueueFlushResponse>;
        get: () => Promise<QueueGetResponse>;
        getCount: () => Promise<QueueGetCountResponse>;
        insertNext: (
            entries: (string | QueueListRef)[],
            position?: number,
            expectedVersion?: string,
        ) => Promise<QueueInsertNextResponse>;
        moveToTop: (
            index: number,
            expectedVersion?: string,
        ) => Promise<QueueMoveToTopResponse>;
        playNow: (
            index?: number,
            expectedVersion?: string,
        ) => Promise<QueuePlayNowResponse>;
        remove: (
            target: number | number[],
            expectedVersion?: string,
        ) => Promise<QueueRemoveResponse>;
        setContents: (
            items: QueueContentRef[],
            expectedVersion?: string,
        ) => Promise<QueueSetContentsResponse>;
    };
    rating: {
        get: (
            path: string,
            opts?: { cueIndex?: number },
        ) => Promise<RatingGetResponse>;
        set: (
            path: string,
            rating: number,
            opts?: { cueIndex?: number },
        ) => Promise<RatingSetResponse>;
    };
    ready: () => Promise<void>;
    replaygain: {
        clear: (paths: string[]) => Promise<ReplaygainClearResponse>;
        get: (paths: string | string[]) => Promise<ReplaygainGetResponse>;
        getMode: () => Promise<ReplaygainGetModeResponse>;
        getPreamp: () => Promise<ReplaygainGetPreampResponse>;
        getSettings: () => Promise<ReplaygainGetSettingsResponse>;
        scan: (
            paths: string[],
            opts?: { mode?: "track" | "album" },
        ) => Promise<ReplaygainScanResponse>;
        setMode: (
            sourceMode: NonNullable<
                "auto"
                | "none"
                | "track"
                | "album"
                | "byPlaybackOrder"
                | undefined,
            >,
            processingMode?: "gain" | "none" | "peak" | "gain_and_peak",
        ) => Promise<ReplaygainSetModeResponse>;
        setPreamp: (
            withRg?: number,
            withoutRg?: number,
        ) => Promise<ReplaygainSetPreampResponse>;
    };
    selection: {
        get: (opts?: SelectionGetParams) => Promise<SelectionGetResponse>;
        getType: () => Promise<SelectionGetTypeResponse>;
        getViewerMode: () => Promise<SelectionGetViewerModeResponse>;
        getViewingTrack: (
            opts?: SelectionGetViewingTrackParams,
        ) => Promise<SelectionGetViewingTrackResponse>;
        set: (handles: string[]) => Promise<SelectionSetResponse>;
        setPlaylistTracking: (
            mode?: NonNullable<"playlist" | "selection" | undefined>,
        ) => Promise<SelectionSetPlaylistTrackingResponse>;
    };
    sharedState: {
        delete: (key: string) => Promise<StateDeleteResponse>;
        get: (key: string) => Promise<StateGetResponse>;
        keys: (pattern?: string) => Promise<StateKeysResponse>;
        onChange: (handler: (data: unknown) => void) => () => void;
        onDelete: (handler: (data: unknown) => void) => () => void;
        set: (
            key: string,
            value: JsonValue,
            silent?: boolean,
            ttlMs?: number,
        ) => Promise<StateSetResponse>;
    };
    shell: {
        exec: (
            command: string,
            options?: Omit<ShellExecParams, "command">,
        ) => Promise<ShellExecResponse>;
        openExternal: (url: string) => Promise<ShellOpenExternalResponse>;
        openWith: (path: string) => Promise<ShellOpenWithResponse>;
        showInExplorer: (path: string) => Promise<ShellShowInExplorerResponse>;
        spawn: (
            executable: string,
            options?: Omit<ShellSpawnParams, "executable">,
        ) => Promise<ShellSpawnResponse>;
    };
    state: ReactiveState;
    system: {
        getApisByNamespace: (
            namespace: string,
        ) => Promise<SystemGetApisByNamespaceResponse>;
        getApiStats: () => Promise<SystemGetApiStatsResponse>;
        getDPI: () => Promise<SystemGetDPIResponse>;
        getLocale: () => Promise<SystemGetLocaleResponse>;
        getRegisteredPlugins: () => Promise<SystemGetRegisteredPluginsResponse>;
        getTheme: () => Promise<SystemGetThemeResponse>;
        isPluginRegistered: (
            namespace: string,
        ) => Promise<SystemIsPluginRegisteredResponse>;
        listApis: (
            includeInternal?: boolean,
            includeExternal?: boolean,
        ) => Promise<SystemListAvailableApisResponse>;
        searchApis: (query: string) => Promise<SystemSearchApisResponse>;
    };
    taskbar: {
        flash: (opts?: TaskbarFlashParams) => Promise<TaskbarFlashResponse>;
        setOverlayIcon: (
            opts?: TaskbarSetOverlayIconParams,
        ) => Promise<TaskbarSetOverlayIconResponse>;
        setProgress: (
            opts: TaskbarSetProgressParams,
        ) => Promise<TaskbarSetProgressResponse>;
        setThumbnailButtons: (
            buttons: ThumbnailButton[],
        ) => Promise<TaskbarSetThumbnailButtonsResponse>;
        updateButton: (
            opts: TaskbarUpdateButtonParams,
        ) => Promise<TaskbarUpdateButtonResponse>;
    };
    titleformat: {
        eval: (
            pattern: string,
            path?: string,
        ) => Promise<TitleformatEvalResponse>;
        evalBatch: (
            pattern: string,
            paths: string[],
        ) => Promise<TitleformatEvalBatchResponse>;
        evalFields: (
            path: string,
            fields: TitleformatFieldMap,
        ) => Promise<TitleformatEvalFieldsResponse>;
        evalFieldsBatch: (
            paths: string[],
            fields: TitleformatFieldMap,
        ) => Promise<TitleformatEvalFieldsBatchResponse>;
        getBuiltinFields: () => Promise<TitleformatGetBuiltinFieldsResponse>;
    };
    tray: {
        appendMenuItems: (
            items: TrayMenuItem[],
            position?: TrayMenuPosition,
        ) => Promise<TrayAppendMenuItemsResponse>;
        clearMenuItems: (
            position?: TrayMenuPosition,
        ) => Promise<TrayClearMenuItemsResponse>;
        create: (
            opts?: { icon?: string | null; tooltip?: string },
        ) => Promise<TrayCreateResponse>;
        destroy: () => Promise<TrayDestroyResponse>;
        getMenuItems: () => Promise<TrayGetMenuItemsResponse>;
        isVisible: () => Promise<TrayIsVisibleResponse>;
        removeMenuItems: (ids: string[]) => Promise<TrayRemoveMenuItemsResponse>;
        setClickAction: (
            action: "event" | "toggleMainWindow",
        ) => Promise<TraySetClickActionResponse>;
        setCloseToTray: (enabled: boolean) => Promise<TraySetCloseToTrayResponse>;
        setContextMenu: (
            items: TrayMenuItem[],
            config?: TrayMenuConfig,
        ) => Promise<TraySetContextMenuResponse>;
        setIcon: (icon?: string | null) => Promise<TraySetIconResponse>;
        setMenuItemState: (
            id: string,
            state: { checked?: boolean; enabled?: boolean },
        ) => Promise<TraySetMenuItemStateResponse>;
        setMenuZones: (
            zones: Omit<TraySetMenuZonesParams, "config">,
            config?: TrayMenuConfig,
        ) => Promise<TraySetMenuZonesResponse>;
        setMinimizeToTray: (
            enabled: boolean,
        ) => Promise<TraySetMinimizeToTrayResponse>;
        setTooltip: (tooltip: string) => Promise<TraySetTooltipResponse>;
        showBalloon: (
            opts: {
                icon?: "error" | "info" | "warning";
                message: string;
                title: string;
            },
        ) => Promise<TrayShowBalloonResponse>;
    };
    ui: {
        blur: () => Promise<WindowBlurResponse>;
        broadcast: (message: JsonValue) => Promise<WindowBroadcastResponse>;
        cancelClose: () => Promise<WindowCancelCloseResponse>;
        center: () => Promise<WindowCenterResponse>;
        clearClickThroughExcludeRegions: (
            windowId?: string,
        ) => Promise<WindowClearClickThroughExcludeRegionsResponse>;
        clearDragRegions: () => Promise<WindowClearDragRegionsResponse>;
        clearNoDragRegions: () => Promise<WindowClearNoDragRegionsResponse>;
        close: () => Promise<WindowCloseResponse>;
        closeAllPopups: () => Promise<WindowCloseAllPopupsResponse>;
        closePopup: (windowId: string) => Promise<WindowClosePopupResponse>;
        confirmClose: () => Promise<WindowConfirmCloseResponse>;
        createPopup: (
            opts: WindowCreatePopupOptions,
        ) => Promise<WindowCreatePopupResponse>;
        enterFullscreen: (
            windowId?: string,
        ) => Promise<WindowEnterFullscreenResponse>;
        exitFullscreen: (
            windowId?: string,
        ) => Promise<WindowExitFullscreenResponse>;
        flash: (opts: WindowFlashParams) => Promise<WindowFlashResponse>;
        flashTaskbar: (count?: number) => Promise<WindowFlashTaskbarResponse>;
        focus: (windowId?: string) => Promise<WindowFocusResponse>;
        getAllWindows: () => Promise<WindowListResponse>;
        getBackdropPolicy: (
            windowId?: string,
        ) => Promise<WindowGetBackdropPolicyResponse>;
        getBounds: () => Promise<WindowGetBoundsResponse>;
        getCaptionButtonsWidth: () => Promise<
            WindowGetCaptionButtonsWidthResponse,
        >;
        getCornerPreference: () => Promise<WindowGetCornerPreferenceResponse>;
        getCurrentWindowId: () => Promise<WindowGetCurrentWindowIdResponse>;
        getDevServerConfig: () => Promise<WindowGetDevServerConfigResponse>;
        getDpiScale: () => Promise<WindowGetDpiScaleResponse>;
        getMaxSize: (windowId?: string) => Promise<WindowGetMaxSizeResponse>;
        getMinSize: (windowId?: string) => Promise<WindowGetMinSizeResponse>;
        getMode: () => Promise<WindowGetModeResponse>;
        getPopupBehavior: (
            windowId?: string,
        ) => Promise<WindowGetPopupBehaviorResponse>;
        getState: () => Promise<WindowGetStateResponse>;
        getTitle: () => Promise<WindowGetTitleResponse>;
        getTitlebarHeight: () => Promise<WindowGetTitlebarHeightResponse>;
        getTitlebarInfo: () => Promise<WindowGetTitlebarInfoResponse>;
        getZoom: () => Promise<WindowGetZoomResponse>;
        hasSavedBounds: () => Promise<WindowHasSavedBoundsResponse>;
        isAlwaysOnTop: () => Promise<WindowIsAlwaysOnTopResponse>;
        isClickThrough: (
            windowId?: string,
        ) => Promise<WindowIsClickThroughResponse>;
        isFullscreen: (windowId?: string) => Promise<WindowIsFullscreenResponse>;
        isMaximized: () => Promise<WindowIsMaximizedResponse>;
        isMinimized: () => Promise<WindowIsMinimizedResponse>;
        isResizable: (windowId?: string) => Promise<WindowIsResizableResponse>;
        maximize: () => Promise<WindowMaximizeResponse>;
        minimize: () => Promise<WindowMinimizeResponse>;
        refreshWebView: () => Promise<WindowRefreshWebViewResponse>;
        reload: () => Promise<WindowReloadResponse>;
        resetZoom: () => Promise<WindowResetZoomResponse>;
        restore: () => Promise<WindowRestoreResponse>;
        sendMessage: (
            targetWindowId: string,
            message: JsonValue,
        ) => Promise<WindowSendMessageResponse>;
        setAcrylic: (
            opts: WindowSetAcrylicParams,
        ) => Promise<WindowSetAcrylicResponse>;
        setAlwaysOnTop: (
            enabled: boolean,
        ) => Promise<WindowSetAlwaysOnTopResponse>;
        setBackdropPolicy: (
            __namedParameters: WindowBackdropPolicyPatch & { windowId?: string },
        ) => Promise<WindowSetBackdropPolicyResponse>;
        setBackgroundTransparency: (
            opts: WindowSetBackgroundTransparencyParams,
        ) => Promise<WindowSetBackgroundTransparencyResponse>;
        setBlur: (opts: WindowSetBlurParams) => Promise<WindowSetBlurResponse>;
        setBounds: (
            __namedParameters: WindowSetBoundsParams,
        ) => Promise<WindowSetBoundsResponse>;
        setClickThrough: (
            opts: WindowSetClickThroughParams,
        ) => Promise<WindowSetClickThroughResponse>;
        setClickThroughExcludeRegions: (
            opts: WindowSetClickThroughExcludeRegionsParams,
        ) => Promise<WindowSetClickThroughExcludeRegionsResponse>;
        setCornerPreference: (
            mode: string,
        ) => Promise<WindowSetCornerPreferenceResponse>;
        setDarkMode: (
            enabled: boolean,
            windowId?: string,
        ) => Promise<WindowSetDarkModeResponse>;
        setDevServerConfig: (
            opts: WindowSetDevServerConfigParams,
        ) => Promise<WindowSetDevServerConfigResponse>;
        setDragRegions: (
            regions: WindowRegion[],
        ) => Promise<WindowSetDragRegionsResponse>;
        setFrameless: (
            frameless: boolean,
            windowId?: string,
        ) => Promise<WindowSetFramelessResponse>;
        setFullscreen: (
            enabled: boolean,
            windowId?: string,
        ) => Promise<WindowSetFullscreenResponse>;
        setMaximizeButtonRegion: (
            region?: WindowRegion,
        ) => Promise<WindowSetMaximizeButtonRegionResponse>;
        setMaxSize: (
            width: number,
            height: number,
            windowId?: string,
        ) => Promise<WindowSetMaxSizeResponse>;
        setMica: (opts?: WindowSetMicaParams) => Promise<WindowSetMicaResponse>;
        setMicaEffect: (
            opts?: WindowSetMicaEffectParams,
        ) => Promise<WindowSetMicaEffectResponse>;
        setMinSize: (
            width: number,
            height: number,
            windowId?: string,
        ) => Promise<WindowSetMinSizeResponse>;
        setNoDragRegions: (
            regions: WindowRegion[],
        ) => Promise<WindowSetNoDragRegionsResponse>;
        setPopupBehavior: (
            opts: WindowSetPopupBehaviorOptions,
        ) => Promise<WindowSetPopupBehaviorResponse>;
        setPosition: (x: number, y: number) => Promise<WindowSetPositionResponse>;
        setResizable: (
            resizable: boolean,
            windowId?: string,
        ) => Promise<WindowSetResizableResponse>;
        setSize: (width: number, height: number) => Promise<WindowSetSizeResponse>;
        setTitle: (title: string) => Promise<WindowSetTitleResponse>;
        setTitlebarHeight: (
            height: number,
        ) => Promise<WindowSetTitlebarHeightResponse>;
        setZoom: (zoom: number) => Promise<WindowSetZoomResponse>;
        setZoomForDpi: (dpi?: number) => Promise<WindowSetZoomForDpiResponse>;
        showContextMenu: (
            x?: number,
            y?: number,
        ) => Promise<UiShowContextMenuResponse>;
        showSystemMenu: (
            x: number,
            y: number,
            w?: number,
            h?: number,
        ) => Promise<WindowShowSystemMenuResponse>;
        startDrag: () => Promise<WindowStartDragResponse>;
        startResize: (edge: string) => Promise<WindowStartResizeResponse>;
        toggleAlwaysOnTop: () => Promise<WindowToggleAlwaysOnTopResponse>;
        toggleFullscreen: (
            windowId?: string,
        ) => Promise<WindowToggleFullscreenResponse>;
        toggleMaximize: () => Promise<WindowToggleMaximizeResponse>;
    };
    unwrap: {
        <R extends { success: boolean }>(response: R): Extract<R>;
        <R extends { success: boolean }, K extends string | number | symbol>(
            response: R,
            key: K,
        ): Extract<R, { success: true }>[K];
    };
    utils: {
        echo: (message: string) => Promise<TestEchoResponse>;
        formatTitle: (
            pattern: string,
            path?: string,
        ) => Promise<TitleformatEvalResponse>;
        getFileInfo: (path: string) => Promise<MetadataReadResponse>;
        ping: () => Promise<TestPingResponse>;
    };
    webview: { getSource: () => Promise<WebviewGetSourceResponse> };
} = ...