@edenapp/client 0.0.0-stage → 0.15.0

package/dist/index.cjs

@@ -0,0 +1,470 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  appbus: () => appbusCommands,
+  appearance: () => appearanceCommands,
+  associations: () => associationsCommands,
+  contextMenu: () => contextMenuCommands,
+  daemon: () => daemonCommands,
+  db: () => dbCommands,
+  event: () => eventCommands,
+  file: () => fileCommands,
+  filePicker: () => filePickerCommands,
+  fs: () => fsCommands,
+  i18n: () => i18nCommands,
+  notification: () => notificationCommands,
+  operation: () => operationCommands,
+  package: () => packageCommands,
+  process: () => processCommands,
+  session: () => sessionCommands,
+  settings: () => settingsCommands,
+  stream: () => streamCommands,
+  system: () => systemCommands,
+  toCommandStream: () => toCommandStream,
+  user: () => userCommands,
+  view: () => viewCommands,
+  volume: () => volumeCommands
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/runtime.ts
+function getEdenAPI() {
+  const runtime = globalThis;
+  const api = runtime.window?.edenAPI ?? runtime.worker?.edenAPI;
+  if (!api) {
+    throw new Error(
+      "@edenapp/client requires an Eden frontend or backend runtime"
+    );
+  }
+  return api;
+}
+
+// src/invoke.ts
+async function invoke(command, args, submission) {
+  return getEdenAPI().shellCommand(command, args, submission);
+}
+
+// src/streams.ts
+function toCommandStream(reader) {
+  const next = () => reader.next();
+  const cancel = () => reader.cancel();
+  return {
+    handle: reader.handle,
+    next,
+    cancel,
+    [Symbol.asyncIterator]: () => ({
+      next,
+      return: async () => {
+        await cancel();
+        return { done: true, value: void 0 };
+      }
+    })
+  };
+}
+async function openStream(command, args) {
+  return toCommandStream(await invoke(command, args));
+}
+
+// src/subscriptions.ts
+async function subscribe(event, callback) {
+  return getEdenAPI().subscribe(event, callback);
+}
+function unsubscribe(event, callback) {
+  getEdenAPI().unsubscribe(event, callback);
+}
+
+// src/commands.generated.ts
+var appbusCommands = {
+  /**
+   * Connect to another app's service
+   * Creates MessageChannel and transfers ports directly to both apps
+   * Requires "appbus/connect" permission
+   */
+  ["connect"]: (targetAppId, serviceName) => invoke("appbus/connect", { ["targetAppId"]: targetAppId, ["serviceName"]: serviceName }),
+  /**
+   * List all available services
+   * No permission required
+   */
+  ["list"]: () => invoke("appbus/list", {}),
+  /**
+   * List services by app ID
+   * No permission required
+   */
+  ["listByApp"]: (appId) => invoke("appbus/list-by-app", { ["appId"]: appId }),
+  /**
+   * Register a service that this app exposes
+   * Requires "appbus/expose" permission
+   */
+  ["register"]: (serviceName, options) => invoke("appbus/register", { ["serviceName"]: serviceName, ["description"]: options?.["description"], ["allowedClients"]: options?.["allowedClients"] }),
+  /**
+   * Unregister a service
+   * Requires "appbus/expose" permission
+   */
+  ["unregister"]: (serviceName) => invoke("appbus/unregister", { ["serviceName"]: serviceName })
+};
+var appearanceCommands = {
+  ["getPresets"]: () => invoke("appearance/get-presets", {}),
+  ["getWallpaper"]: () => invoke("appearance/get-wallpaper", {}),
+  ["setWallpaper"]: (wallpaper) => invoke("appearance/set-wallpaper", { ["wallpaper"]: wallpaper }),
+  ["subscribe"]: (event, callback) => subscribe(`appearance/${event}`, callback),
+  ["unsubscribe"]: (event, callback) => unsubscribe(`appearance/${event}`, callback)
+};
+var associationsCommands = {
+  ["get"]: (key) => invoke("associations/get", { ["key"]: key }),
+  ["list"]: (options) => invoke("associations/list", { ["kindPrefix"]: options?.["kindPrefix"] }),
+  ["remove"]: (key) => invoke("associations/remove", { ["key"]: key }),
+  ["set"]: (key, appId, kind, options) => invoke("associations/set", { ["key"]: key, ["appId"]: appId, ["kind"]: kind, ["label"]: options?.["label"] })
+};
+var contextMenuCommands = {
+  ["close"]: (options) => invoke("context-menu/close", { ["requestId"]: options?.["requestId"] }),
+  ["open"]: (position, items, options) => invoke("context-menu/open", { ["position"]: position, ["items"]: items, ["title"]: options?.["title"] }),
+  ["registerDisplay"]: () => invoke("context-menu/register-display", {}),
+  ["resolve"]: (requestId, reason, options) => invoke("context-menu/resolve", { ["requestId"]: requestId, ["reason"]: reason, ["itemId"]: options?.["itemId"] }),
+  ["subscribe"]: (event, callback) => subscribe(`context-menu/${event}`, callback),
+  ["unsubscribe"]: (event, callback) => unsubscribe(`context-menu/${event}`, callback)
+};
+var daemonCommands = {
+  ["disable"]: (appId) => invoke("daemon/disable", { ["appId"]: appId }),
+  ["enable"]: (appId) => invoke("daemon/enable", { ["appId"]: appId }),
+  ["list"]: () => invoke("daemon/list", {}),
+  ["restart"]: (appId, options) => invoke("daemon/restart", { ["appId"]: appId }, options?.submission),
+  ["start"]: (appId, options) => invoke("daemon/start", { ["appId"]: appId }, options?.submission),
+  ["stop"]: (appId, options) => invoke("daemon/stop", { ["appId"]: appId }, options?.submission),
+  ["updateDefinition"]: (definition) => invoke("daemon/update-definition", { ["definition"]: definition }),
+  ["subscribe"]: (event, callback) => subscribe(`daemon/${event}`, callback),
+  ["unsubscribe"]: (event, callback) => unsubscribe(`daemon/${event}`, callback)
+};
+var dbCommands = {
+  /**
+   * Clear all keys (scoped to caller's app)
+   */
+  ["clear"]: () => invoke("db/clear", {}),
+  /**
+   * Clear all keys in any app's namespace (superuser only)
+   */
+  ["clearSu"]: (appId) => invoke("db/clear/su", { ["appId"]: appId }),
+  /**
+   * Delete a key from database (scoped to caller's app)
+   */
+  ["delete"]: (key) => invoke("db/delete", { ["key"]: key }),
+  /**
+   * Delete a key from any app's namespace (superuser only)
+   */
+  ["deleteSu"]: (appId, key) => invoke("db/delete/su", { ["appId"]: appId, ["key"]: key }),
+  /**
+   * Get a value from database (scoped to caller's app)
+   */
+  ["get"]: (key) => invoke("db/get", { ["key"]: key }),
+  /**
+   * Get a value from any app's namespace (superuser only)
+   */
+  ["getSu"]: (appId, key) => invoke("db/get/su", { ["appId"]: appId, ["key"]: key }),
+  /**
+   * Check if a key exists (scoped to caller's app)
+   */
+  ["has"]: (key) => invoke("db/has", { ["key"]: key }),
+  /**
+   * Check if a key exists in any app's namespace (superuser only)
+   */
+  ["hasSu"]: (appId, key) => invoke("db/has/su", { ["appId"]: appId, ["key"]: key }),
+  /**
+   * List all keys (scoped to caller's app)
+   */
+  ["list"]: () => invoke("db/list", {}),
+  /**
+   * List all keys in any app's namespace (superuser only)
+   */
+  ["listSu"]: (appId) => invoke("db/list/su", { ["appId"]: appId }),
+  /**
+   * Set a value in database (scoped to caller's app)
+   */
+  ["set"]: (key, value) => invoke("db/set", { ["key"]: key, ["value"]: value }),
+  /**
+   * Set a value in any app's namespace (superuser only)
+   */
+  ["setSu"]: (appId, key, value) => invoke("db/set/su", { ["appId"]: appId, ["key"]: key, ["value"]: value })
+};
+var eventCommands = {
+  ["exists"]: (eventName) => invoke("event/exists", { ["eventName"]: eventName }),
+  ["subscribe"]: (eventName, options) => invoke("event/subscribe", { ["eventName"]: eventName, ["operation"]: options?.["operation"] }),
+  ["unsubscribe"]: (eventName, options) => invoke("event/unsubscribe", { ["eventName"]: eventName, ["operation"]: options?.["operation"] })
+};
+var fileCommands = {
+  /**
+   * Get all file type associations
+   */
+  ["getAssociations"]: () => invoke("file/get-associations", {}),
+  /**
+   * Get the default handler app for a file path
+   */
+  ["getHandler"]: (location) => invoke("file/get-handler", { ["location"]: location }),
+  /**
+   * Get all apps that can handle a specific file path
+   */
+  ["getSupportedHandlers"]: (location) => invoke("file/get-supported-handlers", { ["location"]: location }),
+  /**
+   * Open a file with its default handler
+   */
+  ["open"]: (location, options) => invoke("file/open", { ["location"]: location }, options?.submission),
+  /**
+   * Open a file with a specific app
+   */
+  ["openWith"]: (location, appId, options) => invoke("file/open-with", { ["location"]: location, ["appId"]: appId }, options?.submission),
+  /**
+   * Remove user preference for a file path (revert to default)
+   */
+  ["removeDefaultHandler"]: (location) => invoke("file/remove-default-handler", { ["location"]: location }),
+  /**
+   * Set user preference for a file path's default handler
+   */
+  ["setDefaultHandler"]: (location, appId) => invoke("file/set-default-handler", { ["location"]: location, ["appId"]: appId }),
+  ["subscribe"]: (event, callback) => subscribe(`file/${event}`, callback),
+  ["unsubscribe"]: (event, callback) => unsubscribe(`file/${event}`, callback)
+};
+var filePickerCommands = {
+  ["close"]: (options) => invoke("file-picker/close", { ["requestId"]: options?.["requestId"] }),
+  ["open"]: (mode, options) => invoke("file-picker/open", { ["mode"]: mode, ["selection"]: options?.["selection"], ["multiple"]: options?.["multiple"], ["title"]: options?.["title"], ["initialLocation"]: options?.["initialLocation"], ["allowedVolumes"]: options?.["allowedVolumes"], ["suggestedName"]: options?.["suggestedName"], ["filters"]: options?.["filters"], ["confirmLabel"]: options?.["confirmLabel"], ["canCreateDirectories"]: options?.["canCreateDirectories"], ["overwritePrompt"]: options?.["overwritePrompt"] }),
+  ["registerDisplay"]: () => invoke("file-picker/register-display", {}),
+  ["resolve"]: (requestId, reason, options) => invoke("file-picker/resolve", { ["requestId"]: requestId, ["reason"]: reason, ["locations"]: options?.["locations"] }),
+  ["subscribe"]: (event, callback) => subscribe(`file-picker/${event}`, callback),
+  ["unsubscribe"]: (event, callback) => unsubscribe(`file-picker/${event}`, callback)
+};
+var fsCommands = {
+  ["accessScope"]: (volume) => invoke("fs/access-scope", { ["volume"]: volume }),
+  ["close"]: (handle) => invoke("fs/close", { ["handle"]: handle }),
+  ["cp"]: (from, to, options) => invoke("fs/cp", { ["from"]: from, ["to"]: to, ["overwrite"]: options?.["overwrite"] }, options?.submission),
+  ["delete"]: (location, options) => invoke("fs/delete", { ["location"]: location }, options?.submission),
+  ["exists"]: (location) => invoke("fs/exists", { ["location"]: location }),
+  ["lstat"]: (location) => invoke("fs/lstat", { ["location"]: location }),
+  ["mkdir"]: (location) => invoke("fs/mkdir", { ["location"]: location }),
+  ["mv"]: (from, to, options) => invoke("fs/mv", { ["from"]: from, ["to"]: to, ["overwrite"]: options?.["overwrite"] }, options?.submission),
+  ["open"]: (location, options) => invoke("fs/open", { ["location"]: location, ["mode"]: options?.["mode"] }),
+  ["read"]: (location, options) => invoke("fs/read", { ["location"]: location, ["encoding"]: options?.["encoding"] }),
+  ["readBinary"]: (location) => invoke("fs/read-binary", { ["location"]: location }),
+  ["readdir"]: (location) => invoke("fs/readdir", { ["location"]: location }),
+  ["resolve"]: (location) => invoke("fs/resolve", { ["location"]: location }),
+  ["search"]: (location, pattern, options) => openStream("fs/search", { ["location"]: location, ["pattern"]: pattern, ["limit"]: options?.["limit"] }),
+  ["stat"]: (location) => invoke("fs/stat", { ["location"]: location }),
+  /**
+   * Move a Home item to Trash.
+   */
+  ["trash"]: (location, options) => invoke("fs/trash", { ["location"]: location }, options?.submission),
+  /**
+   * Permanently delete one Trash item.
+   */
+  ["trashDelete"]: (id, options) => invoke("fs/trash-delete", { ["id"]: id }, options?.submission),
+  /**
+   * Permanently delete every Trash item visible to the caller.
+   */
+  ["trashEmpty"]: (options) => invoke("fs/trash-empty", {}, options?.submission),
+  /**
+   * List Trash items from folders the caller can access, newest first.
+   */
+  ["trashEntries"]: () => invoke("fs/trash-entries", {}),
+  /**
+   * Restore a Trash item to its original location or another destination.
+   */
+  ["trashRestore"]: (id, options) => invoke("fs/trash-restore", { ["id"]: id, ["location"]: options?.["location"] }, options?.submission),
+  ["unwatch"]: (watchId) => invoke("fs/unwatch", { ["watchId"]: watchId }),
+  ["watch"]: (location) => invoke("fs/watch", { ["location"]: location }),
+  ["write"]: (location, content, options) => invoke("fs/write", { ["location"]: location, ["content"]: content, ["encoding"]: options?.["encoding"] }),
+  ["writeBinary"]: (location, content) => invoke("fs/write-binary", { ["location"]: location, ["content"]: content }),
+  ["subscribe"]: (event, callback) => subscribe(`fs/${event}`, callback),
+  ["unsubscribe"]: (event, callback) => unsubscribe(`fs/${event}`, callback)
+};
+var i18nCommands = {
+  ["getCommon"]: (locale) => invoke("i18n/get-common", { ["locale"]: locale }),
+  ["getLocale"]: () => invoke("i18n/get-locale", {}),
+  ["subscribe"]: (event, callback) => subscribe(`i18n/${event}`, callback),
+  ["unsubscribe"]: (event, callback) => unsubscribe(`i18n/${event}`, callback)
+};
+var notificationCommands = {
+  /**
+   * Report a notification action click from the toaster.
+   */
+  ["actionClicked"]: (notificationId, actionId) => invoke("notification/action-clicked", { ["notificationId"]: notificationId, ["actionId"]: actionId }),
+  /**
+   * Report a notification dismissal from the toaster.
+   */
+  ["dismissed"]: (notificationId) => invoke("notification/dismissed", { ["notificationId"]: notificationId }),
+  /**
+   * Push a new notification to subscribers.
+   */
+  ["push"]: (title, message, options) => invoke("notification/push", { ["title"]: title, ["message"]: message, ["timeout"]: options?.["timeout"], ["type"]: options?.["type"], ["actions"]: options?.["actions"] }),
+  /**
+   * Register the notification display provider.
+   */
+  ["registerDisplay"]: () => invoke("notification/register-display", {}),
+  ["subscribe"]: (event, callback) => subscribe(`notification/${event}`, callback),
+  ["unsubscribe"]: (event, callback) => unsubscribe(`notification/${event}`, callback)
+};
+var operationCommands = {
+  ["cancel"]: (handle) => invoke("operation/cancel", { ["handle"]: handle }),
+  ["get"]: (handle) => invoke("operation/get", { ["handle"]: handle }),
+  ["list"]: () => invoke("operation/list", {}),
+  ["subscribe"]: (event, callback) => subscribe(`operation/${event}`, callback),
+  ["unsubscribe"]: (event, callback) => unsubscribe(`operation/${event}`, callback)
+};
+var packageCommands = {
+  ["get"]: (packageId) => invoke("package/get", { ["packageId"]: packageId }),
+  ["getIcon"]: (packageId) => invoke("package/get-icon", { ["packageId"]: packageId }),
+  ["getInfo"]: (location) => invoke("package/get-info", { ["location"]: location }),
+  ["getSize"]: (packageId) => invoke("package/get-size", { ["packageId"]: packageId }),
+  ["install"]: (source, options) => invoke("package/install", { ["source"]: source, ["replace"]: options?.["replace"] }, options?.submission),
+  ["isHotReloadEnabled"]: (packageId) => invoke("package/is-hot-reload-enabled", { ["packageId"]: packageId }),
+  ["list"]: (options) => invoke("package/list", { ["showHidden"]: options?.["showHidden"], ["showRestricted"]: options?.["showRestricted"] }),
+  ["self"]: () => invoke("package/self", {}),
+  ["toggleHotReload"]: (packageId) => invoke("package/toggle-hot-reload", { ["packageId"]: packageId }),
+  ["uninstall"]: (packageId, options) => invoke("package/uninstall", { ["packageId"]: packageId }, options?.submission),
+  ["subscribe"]: (event, callback) => subscribe(`package/${event}`, callback),
+  ["unsubscribe"]: (event, callback) => unsubscribe(`package/${event}`, callback)
+};
+var processCommands = {
+  ["exit"]: (options) => invoke("process/exit", {}, options?.submission),
+  ["launch"]: (appId, options) => invoke("process/launch", { ["appId"]: appId, ["bounds"]: options?.["bounds"] }, options?.submission),
+  ["list"]: (options) => invoke("process/list", { ["showHidden"]: options?.["showHidden"] }),
+  ["metrics"]: (options) => invoke("process/metrics", { ["showHidden"]: options?.["showHidden"], ["pollingTimeoutMs"]: options?.["pollingTimeoutMs"], ["waitForAccurateCpu"]: options?.["waitForAccurateCpu"] }),
+  ["stop"]: (appId, options) => invoke("process/stop", { ["appId"]: appId }, options?.submission),
+  ["subscribe"]: (event, callback) => subscribe(`process/${event}`, callback),
+  ["unsubscribe"]: (event, callback) => unsubscribe(`process/${event}`, callback)
+};
+var sessionCommands = {
+  ["getCurrent"]: () => invoke("session/get-current", {}),
+  ["login"]: (username, password, options) => invoke("session/login", { ["username"]: username, ["password"]: password }, options?.submission),
+  ["logout"]: (options) => invoke("session/logout", {}, options?.submission),
+  ["subscribe"]: (event, callback) => subscribe(`session/${event}`, callback),
+  ["unsubscribe"]: (event, callback) => unsubscribe(`session/${event}`, callback)
+};
+var settingsCommands = {
+  ["action"]: (panelId, actionId, options) => invoke("settings/action", { ["panelId"]: panelId, ["actionId"]: actionId, ["invocation"]: options?.["invocation"] }),
+  /**
+   * Get a setting value (scoped to caller's app)
+   */
+  ["get"]: (key, options) => invoke("settings/get", { ["key"]: key, ["appId"]: options?.["appId"] }),
+  /**
+   * Get all settings with values (scoped to caller's app)
+   */
+  ["getAll"]: () => invoke("settings/get-all", {}),
+  /**
+   * Get all settings with values for any app (superuser only)
+   * @param showRestricted - If true, includes settings the current user cannot access (hidden by default)
+   */
+  ["getAllSu"]: (appId, options) => invoke("settings/get-all/su", { ["appId"]: appId, ["showRestricted"]: options?.["showRestricted"] }),
+  /**
+   * Get a setting from any app's namespace (superuser only)
+   */
+  ["getSu"]: (appId, key) => invoke("settings/get/su", { ["appId"]: appId, ["key"]: key }),
+  /**
+   * List all settings keys (scoped to caller's app)
+   */
+  ["list"]: () => invoke("settings/list", {}),
+  /**
+   * List all settings in any app's namespace (superuser only)
+   * @param showRestricted - If true, includes settings the current user cannot access (hidden by default)
+   */
+  ["listSu"]: (appId, options) => invoke("settings/list/su", { ["appId"]: appId, ["showRestricted"]: options?.["showRestricted"] }),
+  ["panel"]: (panelId) => invoke("settings/panel", { ["panelId"]: panelId }),
+  ["panels"]: () => invoke("settings/panels", {}),
+  /**
+   * Reset a setting to default (scoped to caller's app)
+   */
+  ["reset"]: (key, options) => invoke("settings/reset", { ["key"]: key, ["schema"]: options?.["schema"] }),
+  /**
+   * Reset a setting for any app (superuser only)
+   */
+  ["resetSu"]: (appId, key, options) => invoke("settings/reset/su", { ["appId"]: appId, ["key"]: key, ["schema"]: options?.["schema"] }),
+  /**
+   * Set a setting value (scoped to caller's app)
+   */
+  ["set"]: (key, value) => invoke("settings/set", { ["key"]: key, ["value"]: value }),
+  /**
+   * Set a setting in any app's namespace (superuser only)
+   */
+  ["setSu"]: (appId, key, value) => invoke("settings/set/su", { ["appId"]: appId, ["key"]: key, ["value"]: value }),
+  ["subscribe"]: (event, callback) => subscribe(`settings/${event}`, callback),
+  ["unsubscribe"]: (event, callback) => unsubscribe(`settings/${event}`, callback)
+};
+var streamCommands = {
+  /**
+   * Return credit for chunks that the caller consumed from its stream.
+   * Stream readers send this automatically.
+   */
+  ["ack"]: (handle, count) => invoke("stream/ack", { ["handle"]: handle, ["count"]: count }),
+  /**
+   * Stop a stream that the caller opened.
+   */
+  ["cancel"]: (handle) => invoke("stream/cancel", { ["handle"]: handle })
+};
+var systemCommands = {
+  /**
+   * Get consumer-controlled product branding for SDK-owned interfaces.
+   */
+  ["branding"]: () => invoke("system/branding", {}),
+  ["info"]: () => invoke("system/info", {}),
+  ["power"]: (action, options) => invoke("system/power", { ["action"]: action }, options?.submission),
+  ["powerCapabilities"]: () => invoke("system/power-capabilities", {})
+};
+var userCommands = {
+  ["changePassword"]: (currentPassword, newPassword) => invoke("user/change-password", { ["currentPassword"]: currentPassword, ["newPassword"]: newPassword }),
+  ["create"]: (name, password, options) => invoke("user/create", { ["name"]: name, ["password"]: password, ["username"]: options?.["username"], ["role"]: options?.["role"], ["grants"]: options?.["grants"], ["directoryRestriction"]: options?.["directoryRestriction"] }),
+  ["delete"]: (username) => invoke("user/delete", { ["username"]: username }),
+  ["getDefault"]: () => invoke("user/get-default", {}),
+  ["grantOptions"]: () => invoke("user/grant-options", {}),
+  ["hasGrant"]: (grant) => invoke("user/has-grant", { ["grant"]: grant }),
+  ["list"]: () => invoke("user/list", {}),
+  ["setDefault"]: (username) => invoke("user/set-default", { ["username"]: username }),
+  ["setPassword"]: (username, password) => invoke("user/set-password", { ["username"]: username, ["password"]: password }),
+  ["update"]: (username, options) => invoke("user/update", { ["username"]: username, ["name"]: options?.["name"], ["role"]: options?.["role"], ["grants"]: options?.["grants"], ["directoryRestriction"]: options?.["directoryRestriction"] }),
+  ["subscribe"]: (event, callback) => subscribe(`user/${event}`, callback),
+  ["unsubscribe"]: (event, callback) => unsubscribe(`user/${event}`, callback)
+};
+var viewCommands = {
+  ["endDrag"]: () => invoke("view/end-drag", {}),
+  ["endResize"]: () => invoke("view/end-resize", {}),
+  ["expandTile"]: (direction) => invoke("view/expand-tile", { ["direction"]: direction }),
+  ["focus"]: () => invoke("view/focus", {}),
+  ["focusView"]: (appId) => invoke("view/focus-view", { ["appId"]: appId }),
+  ["getInterfaceScale"]: () => invoke("view/get-interface-scale", {}),
+  ["globalMouseup"]: () => invoke("view/global-mouseup", {}),
+  ["setInterfaceScale"]: (scale) => invoke("view/set-interface-scale", { ["scale"]: scale }),
+  ["setViewVisibility"]: (appId, visible) => invoke("view/set-view-visibility", { ["appId"]: appId, ["visible"]: visible }),
+  ["setVisibility"]: (visible) => invoke("view/set-visibility", { ["visible"]: visible }),
+  ["startDrag"]: (startX, startY) => invoke("view/start-drag", { ["startX"]: startX, ["startY"]: startY }),
+  ["startResize"]: (startX, startY, options) => invoke("view/start-resize", { ["startX"]: startX, ["startY"]: startY, ["direction"]: options?.["direction"] }),
+  ["swapTile"]: (direction) => invoke("view/swap-tile", { ["direction"]: direction }),
+  ["tileLayoutState"]: () => invoke("view/tile-layout-state", {}),
+  ["toggleMode"]: (options) => invoke("view/toggle-mode", { ["mode"]: options?.["mode"] }),
+  ["toggleViewMode"]: (appId, options) => invoke("view/toggle-view-mode", { ["appId"]: appId, ["mode"]: options?.["mode"] }),
+  ["updateBounds"]: (bounds) => invoke("view/update-bounds", { ["bounds"]: bounds }),
+  ["updateGlobalBounds"]: (bounds, windowSize) => invoke("view/update-global-bounds", { ["bounds"]: bounds, ["windowSize"]: windowSize }),
+  ["updateViewBounds"]: (appId, bounds) => invoke("view/update-view-bounds", { ["appId"]: appId, ["bounds"]: bounds }),
+  ["windowSize"]: () => invoke("view/window-size", {}),
+  ["subscribe"]: (event, callback) => subscribe(`view/${event}`, callback),
+  ["unsubscribe"]: (event, callback) => unsubscribe(`view/${event}`, callback)
+};
+var volumeCommands = {
+  ["eject"]: (volume, options) => invoke("volume/eject", { ["volume"]: volume }, options?.submission),
+  ["list"]: () => invoke("volume/list", {}),
+  ["subscribe"]: (event, callback) => subscribe(`volume/${event}`, callback),
+  ["unsubscribe"]: (event, callback) => unsubscribe(`volume/${event}`, callback)
+};
+//# sourceMappingURL=index.cjs.map