@voquill/desktop-native-apis 0.1.0

package/dist/bindings.js

@@ -0,0 +1,1027 @@
+// This file was generated by [tauri-specta](https://github.com/oscartbeaumont/tauri-specta). Do not edit this file manually.
+/** user-defined commands **/
+export const commands = {
+    async userGetOne() {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("user_get_one") };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async userSetOne(user) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("user_set_one", { user }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async userPreferencesGet(args) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("user_preferences_get", { args }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async startGoogleSignIn() {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("start_google_sign_in") };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async startEnterpriseOidcSignIn(gatewayUrl, providerId) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("start_enterprise_oidc_sign_in", { gatewayUrl, providerId }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async userPreferencesSet(preferences) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("user_preferences_set", { preferences }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async listMicrophones() {
+        return await TAURI_INVOKE("list_microphones");
+    },
+    async listGpus() {
+        return await TAURI_INVOKE("list_gpus");
+    },
+    async getScreenVisibleArea() {
+        return await TAURI_INVOKE("get_screen_visible_area");
+    },
+    async getMonitorAtCursor() {
+        return await TAURI_INVOKE("get_monitor_at_cursor");
+    },
+    async checkMicrophonePermission() {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("check_microphone_permission") };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async requestMicrophonePermission() {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("request_microphone_permission") };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async checkAccessibilityPermission() {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("check_accessibility_permission") };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async requestAccessibilityPermission() {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("request_accessibility_permission") };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async getCurrentAppInfo() {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("get_current_app_info") };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async appTargetUpsert(args) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("app_target_upsert", { args }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async appTargetList() {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("app_target_list") };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async pairedRemoteDeviceUpsert(args) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("paired_remote_device_upsert", { args }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async pairedRemoteDeviceList() {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("paired_remote_device_list") };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async pairedRemoteDeviceDelete(args) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("paired_remote_device_delete", { args }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async remoteReceiverStart(args) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("remote_receiver_start", { args }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async remoteReceiverStop() {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("remote_receiver_stop") };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async remoteReceiverStatus() {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("remote_receiver_status") };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async remoteSenderDeliverFinalText(args) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("remote_sender_deliver_final_text", { args }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async remoteSenderPairWithReceiver(args) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("remote_sender_pair_with_receiver", { args }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async startRecording(args) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("start_recording", { args }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async stopRecording() {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("stop_recording") };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async storeTranscriptionAudio(id, samples, sampleRate) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("store_transcription_audio", { id, samples, sampleRate }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async storageUploadData(args) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("storage_upload_data", { args }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async storageGetDownloadUrl(path) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("storage_get_download_url", { path }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async surfaceMainWindow() {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("surface_main_window") };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async setPillWindowSize(size) {
+        await TAURI_INVOKE("set_pill_window_size", { size });
+    },
+    async paste(text, keybind) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("paste", { text, keybind }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async copyToClipboard(text) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("copy_to_clipboard", { text }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async transcriptionCreate(transcription) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("transcription_create", { transcription }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async transcriptionList(limit, offset) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("transcription_list", { limit, offset }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async transcriptionDelete(id) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("transcription_delete", { id }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async transcriptionUpdate(transcription) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("transcription_update", { transcription }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async transcriptionAudioLoad(id) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("transcription_audio_load", { id }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async purgeStaleTranscriptionAudio() {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("purge_stale_transcription_audio") };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async exportTranscription(id) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("export_transcription", { id }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async exportDiagnostics(diagnosticsInfo) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("export_diagnostics", { diagnosticsInfo }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async termCreate(term) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("term_create", { term }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async termUpdate(term) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("term_update", { term }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async termList() {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("term_list") };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async termDelete(id) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("term_delete", { id }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async hotkeyList() {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("hotkey_list") };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async hotkeySave(hotkey) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("hotkey_save", { hotkey }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async hotkeyDelete(id) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("hotkey_delete", { id }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async setTrayTitle(title) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("set_tray_title", { title }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async setMenuIcon(variant) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("set_menu_icon", { variant }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async setTrayVisible(visible) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("set_tray_visible", { visible }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async apiKeyCreate(apiKey) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("api_key_create", { apiKey }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async apiKeyList() {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("api_key_list") };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async apiKeyDelete(id) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("api_key_delete", { id }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async apiKeyUpdate(request) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("api_key_update", { request }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async toneUpsert(tone) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("tone_upsert", { tone }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async toneList() {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("tone_list") };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async toneGet(id) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("tone_get", { id }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async toneDelete(id) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("tone_delete", { id }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async clearLocalData() {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("clear_local_data") };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async setPhase(phase) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("set_phase", { phase }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async setPillVisibility(visibility) {
+        await TAURI_INVOKE("set_pill_visibility", { visibility });
+    },
+    async notifyPillStyleInfo(count, name) {
+        await TAURI_INVOKE("notify_pill_style_info", { count, name });
+    },
+    async syncNativePillAssistant(payload) {
+        await TAURI_INVOKE("sync_native_pill_assistant", { payload });
+    },
+    async startKeyListener() {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("start_key_listener") };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async stopKeyListener() {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("stop_key_listener") };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async syncHotkeyCombos(combos) {
+        await TAURI_INVOKE("sync_hotkey_combos", { combos });
+    },
+    async syncCompositorHotkeys(bindings) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("sync_compositor_hotkeys", { bindings }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async resetKeyListenerState() {
+        await TAURI_INVOKE("reset_key_listener_state");
+    },
+    async playAudio(clip) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("play_audio", { clip }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async getTextFieldInfo() {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("get_text_field_info") };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async getScreenContext() {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("get_screen_context") };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async getSelectedText() {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("get_selected_text") };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async gatherAccessibilityDump() {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("gather_accessibility_dump") };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async getFocusedFieldInfo() {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("get_focused_field_info") };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async writeAccessibilityFields(entries) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("write_accessibility_fields", { entries }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async focusAccessibilityField(target) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("focus_accessibility_field", { target }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async readAccessibilityFieldValues(fields) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("read_accessibility_field_values", { fields }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async checkFocusedPasteTarget() {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("check_focused_paste_target") };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    /**
+     * - macOS:  ~/Library/Application Support/com.voquill.desktop/enterprise.json
+     * - Linux:  ~/.config/com.voquill.desktop/enterprise.json
+     * - Windows: C:\Users\<User>\AppData\Roaming\com.voquill.desktop\enterprise.json
+     */
+    async readEnterpriseTarget() {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("read_enterprise_target") };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async runTerminalCommand(command) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("run_terminal_command", { command }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async getHotkeyStrategy() {
+        return await TAURI_INVOKE("get_hotkey_strategy");
+    },
+    async supportsAppDetection() {
+        return await TAURI_INVOKE("supports_app_detection");
+    },
+    async supportsPasteKeybinds() {
+        return await TAURI_INVOKE("supports_paste_keybinds");
+    },
+    async getNativeSetupStatus() {
+        return await TAURI_INVOKE("get_native_setup_status");
+    },
+    async runNativeSetup() {
+        return await TAURI_INVOKE("run_native_setup");
+    },
+    async getKeyboardLanguage() {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("get_keyboard_language") };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async conversationCreate(conversation) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("conversation_create", { conversation }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async conversationList() {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("conversation_list") };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async conversationUpdate(conversation) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("conversation_update", { conversation }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async conversationDelete(id) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("conversation_delete", { id }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async chatMessageCreate(message) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("chat_message_create", { message }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async chatMessageList(conversationId) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("chat_message_list", { conversationId }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async chatMessageUpdate(message) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("chat_message_update", { message }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async chatMessageDeleteMany(ids) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("chat_message_delete_many", { ids }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    /**
+     * Returns `true` when the running app bundle can be updated in-place.
+     * On macOS this checks whether the process can write to the directory that
+     * contains the `.app` bundle (typically `/Applications`).
+     * Non-macOS platforms always return `true`.
+     */
+    async checkAppLocationWritable() {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("check_app_location_writable") };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    /**
+     * Downloads a `.pkg` installer to a temp directory and opens it with
+     * macOS Installer.app. This is used as a fallback when the normal in-place
+     * updater cannot write to the app's install location.
+     */
+    async downloadAndOpenMacInstaller(url) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("download_and_open_mac_installer", { url }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async getSystemVolume() {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("get_system_volume") };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    },
+    async setSystemVolume(volume) {
+        try {
+            return { status: "ok", data: await TAURI_INVOKE("set_system_volume", { volume }) };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            else
+                return { status: "error", error: e };
+        }
+    }
+};
+/** tauri-specta globals **/
+import { invoke as TAURI_INVOKE, } from "@tauri-apps/api/core";
+import * as TAURI_API_EVENT from "@tauri-apps/api/event";
+function __makeEvents__(mappings) {
+    return new Proxy({}, {
+        get: (_, event) => {
+            const name = mappings[event];
+            return new Proxy((() => { }), {
+                apply: (_, __, [window]) => ({
+                    listen: (arg) => window.listen(name, arg),
+                    once: (arg) => window.once(name, arg),
+                    emit: (arg) => window.emit(name, arg),
+                }),
+                get: (_, command) => {
+                    switch (command) {
+                        case "listen":
+                            return (arg) => TAURI_API_EVENT.listen(name, arg);
+                        case "once":
+                            return (arg) => TAURI_API_EVENT.once(name, arg);
+                        case "emit":
+                            return (arg) => TAURI_API_EVENT.emit(name, arg);
+                    }
+                },
+            });
+        },
+    });
+}