@edenapp/client 0.0.0-stage → 0.15.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Dariusz Majnert
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,116 @@
-# Temporary Holding Version
+# @edenapp/client
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Typed system commands and event subscriptions for Eden frontend and backend apps.
+
+Start with the [Eden handbook](https://github.com/b0czek/eden/blob/main/docs/README.md)
+for complete app and consumer workflows.
+
+```sh
+npm install @edenapp/client
+```
+
+```ts
+import { db, fs, system } from "@edenapp/client";
+
+const location = { volume: "home", path: "/notes.txt" };
+await fs.write(location, "Hello", { encoding: "utf8" });
+const stats = await fs.stat(location);
+await db.set("theme", "dark");
+const { value } = await db.get("theme");
+const info = await system.info();
+```
+
+Use a namespace import when local names overlap:
+
+```ts
+import * as eden from "@edenapp/client";
+
+await eden.db.get("theme");
+await eden.package.list();
+```
+
+## Arguments and results
+
+Each command becomes a method on its namespace. Hyphens and slashes become
+camelCase: `fs/read-binary` is `fs.readBinary`, `db/get/su` is `db.getSu`, and
+`file-picker/open` is `filePicker.open`.
+
+Required top-level fields become positional arguments in declaration order.
+Optional fields go in a final optional options object. Nested values retain
+their structure. Commands without public arguments take no arguments.
+
+```ts
+await fs.stat(location);
+await fs.write(location, "contents", { encoding: "utf8" });
+await eden.process.list({ showHidden: true });
+await system.info();
+```
+
+Methods return Promises with typed command results. Responses such
+as `{ value }` keep their structure. Operation commands return controls for
+progress, completion, and cancellation:
+
+```ts
+const copy = await fs.cp(
+  { volume: "home", path: "/notes.txt" },
+  { volume: "home", path: "/backup.txt" },
+  { overwrite: true, submission: { requestKey: "backup-notes" } },
+);
+const stop = await copy.watch((snapshot) => console.log(snapshot));
+try {
+  await copy.result();
+} finally {
+  stop();
+}
+```
+
+`submission` is available for operation commands. Use its `requestKey` to prevent duplicate submissions.
+See [IPC operations](../../docs/ipc-architecture.md#operations).
+
+File reads accept locations for one-shot access or plain handles returned by
+`fs.open`. See [file handles](../../docs/filesystem.md#file-handles)
+for repeated reads, close, and safe-removal lifetimes.
+
+## Event subscriptions
+
+Domains that declare events expose `subscribe` and `unsubscribe`. Event names
+are local to the domain: `settings/panels-changed` becomes
+`settings.subscribe("panels-changed", callback)`. Callback payloads are inferred
+from the selected event.
+
+```ts
+import { settings } from "@edenapp/client";
+import type { EventData } from "@edenapp/types";
+
+const handleChanged = (event: EventData<"settings/panels-changed">) => {
+  console.log(event.reason, event.panelId);
+};
+
+await settings.subscribe("panels-changed", handleChanged);
+
+// When the owner is disposed, remove the same callback reference.
+settings.unsubscribe("panels-changed", handleChanged);
+```
+
+`subscribe` returns `Promise<void>` and rejects if setup fails. `unsubscribe`
+returns immediately and stops local delivery synchronously; remote cleanup
+follows asynchronously. It can be called while setup is still pending. Register
+component cleanup before awaiting setup so disposal always removes the listener.
+Removing one callback leaves other listeners for the event active.
+
+## Frontend and backend
+
+The same imports work in both runtimes. Methods use the frontend's
+`window.edenAPI` or the backend's `worker.edenAPI`. Include the client in your
+app bundle; for a Node backend, bundle its entry with dependencies:
+
+```sh
+esbuild src/backend.ts --bundle --platform=node --format=esm --outfile=dist/backend.js
+```
+
+Calling a method requires the host's injected API.
+AppBus, launch helpers, and operation restoration use the injected APIs directly.
+
+For development in this repository, regenerate the client with
+`pnpm --filter @edenapp/sdk run codegen`, then build it with
+`pnpm --filter @edenapp/client run build`.

package/dist/commands.generated.d.ts

@@ -0,0 +1,447 @@
+/**
+ * AUTO-GENERATED FILE - DO NOT EDIT
+ *
+ * Typed app client generated from command and event declarations
+ * Generated by scripts/codegen
+ * Run 'pnpm run codegen' to regenerate.
+ */
+import type { CommandArgs, CommandResult, CommandStream, EventData, OperationSubmission } from "@edenapp/types";
+declare const appbusCommands: {
+    /**
+     * Connect to another app's service
+     * Creates MessageChannel and transfers ports directly to both apps
+     * Requires "appbus/connect" permission
+     */
+    connect: (targetAppId: CommandArgs<"appbus/connect">["targetAppId"], serviceName: CommandArgs<"appbus/connect">["serviceName"]) => Promise<CommandResult<"appbus/connect">>;
+    /**
+     * List all available services
+     * No permission required
+     */
+    list: () => Promise<CommandResult<"appbus/list">>;
+    /**
+     * List services by app ID
+     * No permission required
+     */
+    listByApp: (appId: CommandArgs<"appbus/list-by-app">["appId"]) => Promise<CommandResult<"appbus/list-by-app">>;
+    /**
+     * Register a service that this app exposes
+     * Requires "appbus/expose" permission
+     */
+    register: (serviceName: CommandArgs<"appbus/register">["serviceName"], options?: Pick<CommandArgs<"appbus/register">, "description" | "allowedClients">) => Promise<CommandResult<"appbus/register">>;
+    /**
+     * Unregister a service
+     * Requires "appbus/expose" permission
+     */
+    unregister: (serviceName: CommandArgs<"appbus/unregister">["serviceName"]) => Promise<CommandResult<"appbus/unregister">>;
+};
+export { appbusCommands as appbus };
+declare const appearanceCommands: {
+    getPresets: () => Promise<CommandResult<"appearance/get-presets">>;
+    getWallpaper: () => Promise<CommandResult<"appearance/get-wallpaper">>;
+    setWallpaper: (wallpaper: CommandArgs<"appearance/set-wallpaper">["wallpaper"]) => Promise<CommandResult<"appearance/set-wallpaper">>;
+    subscribe: <E extends "wallpaper-changed">(event: E, callback: (data: EventData<`appearance/${E}`>) => void) => Promise<void>;
+    unsubscribe: <E extends "wallpaper-changed">(event: E, callback: (data: EventData<`appearance/${E}`>) => void) => void;
+};
+export { appearanceCommands as appearance };
+declare const associationsCommands: {
+    get: (key: CommandArgs<"associations/get">["key"]) => Promise<CommandResult<"associations/get">>;
+    list: (options?: Pick<CommandArgs<"associations/list">, "kindPrefix">) => Promise<CommandResult<"associations/list">>;
+    remove: (key: CommandArgs<"associations/remove">["key"]) => Promise<CommandResult<"associations/remove">>;
+    set: (key: CommandArgs<"associations/set">["key"], appId: CommandArgs<"associations/set">["appId"], kind: CommandArgs<"associations/set">["kind"], options?: Pick<CommandArgs<"associations/set">, "label">) => Promise<CommandResult<"associations/set">>;
+};
+export { associationsCommands as associations };
+declare const contextMenuCommands: {
+    close: (options?: Pick<CommandArgs<"context-menu/close">, "requestId">) => Promise<CommandResult<"context-menu/close">>;
+    open: (position: CommandArgs<"context-menu/open">["position"], items: CommandArgs<"context-menu/open">["items"], options?: Pick<CommandArgs<"context-menu/open">, "title">) => Promise<CommandResult<"context-menu/open">>;
+    registerDisplay: () => Promise<CommandResult<"context-menu/register-display">>;
+    resolve: (requestId: CommandArgs<"context-menu/resolve">["requestId"], reason: CommandArgs<"context-menu/resolve">["reason"], options?: Pick<CommandArgs<"context-menu/resolve">, "itemId">) => Promise<CommandResult<"context-menu/resolve">>;
+    subscribe: <E extends "closed" | "opened">(event: E, callback: (data: EventData<`context-menu/${E}`>) => void) => Promise<void>;
+    unsubscribe: <E extends "closed" | "opened">(event: E, callback: (data: EventData<`context-menu/${E}`>) => void) => void;
+};
+export { contextMenuCommands as contextMenu };
+declare const daemonCommands: {
+    disable: (appId: CommandArgs<"daemon/disable">["appId"]) => Promise<CommandResult<"daemon/disable">>;
+    enable: (appId: CommandArgs<"daemon/enable">["appId"]) => Promise<CommandResult<"daemon/enable">>;
+    list: () => Promise<CommandResult<"daemon/list">>;
+    restart: (appId: CommandArgs<"daemon/restart">["appId"], options?: {
+        submission?: OperationSubmission;
+    }) => Promise<CommandResult<"daemon/restart">>;
+    start: (appId: CommandArgs<"daemon/start">["appId"], options?: {
+        submission?: OperationSubmission;
+    }) => Promise<CommandResult<"daemon/start">>;
+    stop: (appId: CommandArgs<"daemon/stop">["appId"], options?: {
+        submission?: OperationSubmission;
+    }) => Promise<CommandResult<"daemon/stop">>;
+    updateDefinition: (definition: CommandArgs<"daemon/update-definition">["definition"]) => Promise<CommandResult<"daemon/update-definition">>;
+    subscribe: <E extends "changed">(event: E, callback: (data: EventData<`daemon/${E}`>) => void) => Promise<void>;
+    unsubscribe: <E extends "changed">(event: E, callback: (data: EventData<`daemon/${E}`>) => void) => void;
+};
+export { daemonCommands as daemon };
+declare const dbCommands: {
+    /**
+     * Clear all keys (scoped to caller's app)
+     */
+    clear: () => Promise<CommandResult<"db/clear">>;
+    /**
+     * Clear all keys in any app's namespace (superuser only)
+     */
+    clearSu: (appId: CommandArgs<"db/clear/su">["appId"]) => Promise<CommandResult<"db/clear/su">>;
+    /**
+     * Delete a key from database (scoped to caller's app)
+     */
+    delete: (key: CommandArgs<"db/delete">["key"]) => Promise<CommandResult<"db/delete">>;
+    /**
+     * Delete a key from any app's namespace (superuser only)
+     */
+    deleteSu: (appId: CommandArgs<"db/delete/su">["appId"], key: CommandArgs<"db/delete/su">["key"]) => Promise<CommandResult<"db/delete/su">>;
+    /**
+     * Get a value from database (scoped to caller's app)
+     */
+    get: (key: CommandArgs<"db/get">["key"]) => Promise<CommandResult<"db/get">>;
+    /**
+     * Get a value from any app's namespace (superuser only)
+     */
+    getSu: (appId: CommandArgs<"db/get/su">["appId"], key: CommandArgs<"db/get/su">["key"]) => Promise<CommandResult<"db/get/su">>;
+    /**
+     * Check if a key exists (scoped to caller's app)
+     */
+    has: (key: CommandArgs<"db/has">["key"]) => Promise<CommandResult<"db/has">>;
+    /**
+     * Check if a key exists in any app's namespace (superuser only)
+     */
+    hasSu: (appId: CommandArgs<"db/has/su">["appId"], key: CommandArgs<"db/has/su">["key"]) => Promise<CommandResult<"db/has/su">>;
+    /**
+     * List all keys (scoped to caller's app)
+     */
+    list: () => Promise<CommandResult<"db/list">>;
+    /**
+     * List all keys in any app's namespace (superuser only)
+     */
+    listSu: (appId: CommandArgs<"db/list/su">["appId"]) => Promise<CommandResult<"db/list/su">>;
+    /**
+     * Set a value in database (scoped to caller's app)
+     */
+    set: (key: CommandArgs<"db/set">["key"], value: CommandArgs<"db/set">["value"]) => Promise<CommandResult<"db/set">>;
+    /**
+     * Set a value in any app's namespace (superuser only)
+     */
+    setSu: (appId: CommandArgs<"db/set/su">["appId"], key: CommandArgs<"db/set/su">["key"], value: CommandArgs<"db/set/su">["value"]) => Promise<CommandResult<"db/set/su">>;
+};
+export { dbCommands as db };
+declare const eventCommands: {
+    exists: (eventName: CommandArgs<"event/exists">["eventName"]) => Promise<CommandResult<"event/exists">>;
+    subscribe: (eventName: CommandArgs<"event/subscribe">["eventName"], options?: Pick<CommandArgs<"event/subscribe">, "operation">) => Promise<CommandResult<"event/subscribe">>;
+    unsubscribe: (eventName: CommandArgs<"event/unsubscribe">["eventName"], options?: Pick<CommandArgs<"event/unsubscribe">, "operation">) => Promise<CommandResult<"event/unsubscribe">>;
+};
+export { eventCommands as event };
+declare const fileCommands: {
+    /**
+     * Get all file type associations
+     */
+    getAssociations: () => Promise<CommandResult<"file/get-associations">>;
+    /**
+     * Get the default handler app for a file path
+     */
+    getHandler: (location: CommandArgs<"file/get-handler">["location"]) => Promise<CommandResult<"file/get-handler">>;
+    /**
+     * Get all apps that can handle a specific file path
+     */
+    getSupportedHandlers: (location: CommandArgs<"file/get-supported-handlers">["location"]) => Promise<CommandResult<"file/get-supported-handlers">>;
+    /**
+     * Open a file with its default handler
+     */
+    open: (location: CommandArgs<"file/open">["location"], options?: {
+        submission?: OperationSubmission;
+    }) => Promise<CommandResult<"file/open">>;
+    /**
+     * Open a file with a specific app
+     */
+    openWith: (location: CommandArgs<"file/open-with">["location"], appId: CommandArgs<"file/open-with">["appId"], options?: {
+        submission?: OperationSubmission;
+    }) => Promise<CommandResult<"file/open-with">>;
+    /**
+     * Remove user preference for a file path (revert to default)
+     */
+    removeDefaultHandler: (location: CommandArgs<"file/remove-default-handler">["location"]) => Promise<CommandResult<"file/remove-default-handler">>;
+    /**
+     * Set user preference for a file path's default handler
+     */
+    setDefaultHandler: (location: CommandArgs<"file/set-default-handler">["location"], appId: CommandArgs<"file/set-default-handler">["appId"]) => Promise<CommandResult<"file/set-default-handler">>;
+    subscribe: <E extends "opened">(event: E, callback: (data: EventData<`file/${E}`>) => void) => Promise<void>;
+    unsubscribe: <E extends "opened">(event: E, callback: (data: EventData<`file/${E}`>) => void) => void;
+};
+export { fileCommands as file };
+declare const filePickerCommands: {
+    close: (options?: Pick<CommandArgs<"file-picker/close">, "requestId">) => Promise<CommandResult<"file-picker/close">>;
+    open: (mode: CommandArgs<"file-picker/open">["mode"], options?: Pick<CommandArgs<"file-picker/open">, "selection" | "multiple" | "title" | "initialLocation" | "allowedVolumes" | "suggestedName" | "filters" | "confirmLabel" | "canCreateDirectories" | "overwritePrompt">) => Promise<CommandResult<"file-picker/open">>;
+    registerDisplay: () => Promise<CommandResult<"file-picker/register-display">>;
+    resolve: (requestId: CommandArgs<"file-picker/resolve">["requestId"], reason: CommandArgs<"file-picker/resolve">["reason"], options?: Pick<CommandArgs<"file-picker/resolve">, "locations">) => Promise<CommandResult<"file-picker/resolve">>;
+    subscribe: <E extends "closed" | "opened">(event: E, callback: (data: EventData<`file-picker/${E}`>) => void) => Promise<void>;
+    unsubscribe: <E extends "closed" | "opened">(event: E, callback: (data: EventData<`file-picker/${E}`>) => void) => void;
+};
+export { filePickerCommands as filePicker };
+declare const fsCommands: {
+    accessScope: (volume: CommandArgs<"fs/access-scope">["volume"]) => Promise<CommandResult<"fs/access-scope">>;
+    close: (handle: CommandArgs<"fs/close">["handle"]) => Promise<CommandResult<"fs/close">>;
+    cp: (from: CommandArgs<"fs/cp">["from"], to: CommandArgs<"fs/cp">["to"], options?: Pick<CommandArgs<"fs/cp">, "overwrite"> & {
+        submission?: OperationSubmission;
+    }) => Promise<CommandResult<"fs/cp">>;
+    delete: (location: CommandArgs<"fs/delete">["location"], options?: {
+        submission?: OperationSubmission;
+    }) => Promise<CommandResult<"fs/delete">>;
+    exists: (location: CommandArgs<"fs/exists">["location"]) => Promise<CommandResult<"fs/exists">>;
+    lstat: (location: CommandArgs<"fs/lstat">["location"]) => Promise<CommandResult<"fs/lstat">>;
+    mkdir: (location: CommandArgs<"fs/mkdir">["location"]) => Promise<CommandResult<"fs/mkdir">>;
+    mv: (from: CommandArgs<"fs/mv">["from"], to: CommandArgs<"fs/mv">["to"], options?: Pick<CommandArgs<"fs/mv">, "overwrite"> & {
+        submission?: OperationSubmission;
+    }) => Promise<CommandResult<"fs/mv">>;
+    open: (location: CommandArgs<"fs/open">["location"], options?: Pick<CommandArgs<"fs/open">, "mode">) => Promise<CommandResult<"fs/open">>;
+    read: (location: CommandArgs<"fs/read">["location"], options?: Pick<CommandArgs<"fs/read">, "encoding">) => Promise<CommandResult<"fs/read">>;
+    readBinary: (location: CommandArgs<"fs/read-binary">["location"]) => Promise<CommandResult<"fs/read-binary">>;
+    readdir: (location: CommandArgs<"fs/readdir">["location"]) => Promise<CommandResult<"fs/readdir">>;
+    resolve: (location: CommandArgs<"fs/resolve">["location"]) => Promise<CommandResult<"fs/resolve">>;
+    search: (location: CommandArgs<"fs/search">["location"], pattern: CommandArgs<"fs/search">["pattern"], options?: Pick<CommandArgs<"fs/search">, "limit">) => Promise<CommandStream<"fs/search">>;
+    stat: (location: CommandArgs<"fs/stat">["location"]) => Promise<CommandResult<"fs/stat">>;
+    /**
+     * Move a Home item to Trash.
+     */
+    trash: (location: CommandArgs<"fs/trash">["location"], options?: {
+        submission?: OperationSubmission;
+    }) => Promise<CommandResult<"fs/trash">>;
+    /**
+     * Permanently delete one Trash item.
+     */
+    trashDelete: (id: CommandArgs<"fs/trash-delete">["id"], options?: {
+        submission?: OperationSubmission;
+    }) => Promise<CommandResult<"fs/trash-delete">>;
+    /**
+     * Permanently delete every Trash item visible to the caller.
+     */
+    trashEmpty: (options?: {
+        submission?: OperationSubmission;
+    }) => Promise<CommandResult<"fs/trash-empty">>;
+    /**
+     * List Trash items from folders the caller can access, newest first.
+     */
+    trashEntries: () => Promise<CommandResult<"fs/trash-entries">>;
+    /**
+     * Restore a Trash item to its original location or another destination.
+     */
+    trashRestore: (id: CommandArgs<"fs/trash-restore">["id"], options?: Pick<CommandArgs<"fs/trash-restore">, "location"> & {
+        submission?: OperationSubmission;
+    }) => Promise<CommandResult<"fs/trash-restore">>;
+    unwatch: (watchId: CommandArgs<"fs/unwatch">["watchId"]) => Promise<CommandResult<"fs/unwatch">>;
+    watch: (location: CommandArgs<"fs/watch">["location"]) => Promise<CommandResult<"fs/watch">>;
+    write: (location: CommandArgs<"fs/write">["location"], content: CommandArgs<"fs/write">["content"], options?: Pick<CommandArgs<"fs/write">, "encoding">) => Promise<CommandResult<"fs/write">>;
+    writeBinary: (location: CommandArgs<"fs/write-binary">["location"], content: CommandArgs<"fs/write-binary">["content"]) => Promise<CommandResult<"fs/write-binary">>;
+    subscribe: <E extends "changed" | "trash-changed">(event: E, callback: (data: EventData<`fs/${E}`>) => void) => Promise<void>;
+    unsubscribe: <E extends "changed" | "trash-changed">(event: E, callback: (data: EventData<`fs/${E}`>) => void) => void;
+};
+export { fsCommands as fs };
+declare const i18nCommands: {
+    getCommon: (locale: CommandArgs<"i18n/get-common">["locale"]) => Promise<CommandResult<"i18n/get-common">>;
+    getLocale: () => Promise<CommandResult<"i18n/get-locale">>;
+    subscribe: <E extends "locale-changed">(event: E, callback: (data: EventData<`i18n/${E}`>) => void) => Promise<void>;
+    unsubscribe: <E extends "locale-changed">(event: E, callback: (data: EventData<`i18n/${E}`>) => void) => void;
+};
+export { i18nCommands as i18n };
+declare const notificationCommands: {
+    /**
+     * Report a notification action click from the toaster.
+     */
+    actionClicked: (notificationId: CommandArgs<"notification/action-clicked">["notificationId"], actionId: CommandArgs<"notification/action-clicked">["actionId"]) => Promise<CommandResult<"notification/action-clicked">>;
+    /**
+     * Report a notification dismissal from the toaster.
+     */
+    dismissed: (notificationId: CommandArgs<"notification/dismissed">["notificationId"]) => Promise<CommandResult<"notification/dismissed">>;
+    /**
+     * Push a new notification to subscribers.
+     */
+    push: (title: CommandArgs<"notification/push">["title"], message: CommandArgs<"notification/push">["message"], options?: Pick<CommandArgs<"notification/push">, "timeout" | "type" | "actions">) => Promise<CommandResult<"notification/push">>;
+    /**
+     * Register the notification display provider.
+     */
+    registerDisplay: () => Promise<CommandResult<"notification/register-display">>;
+    subscribe: <E extends "action-clicked" | "added" | "removed">(event: E, callback: (data: EventData<`notification/${E}`>) => void) => Promise<void>;
+    unsubscribe: <E extends "action-clicked" | "added" | "removed">(event: E, callback: (data: EventData<`notification/${E}`>) => void) => void;
+};
+export { notificationCommands as notification };
+declare const operationCommands: {
+    cancel: (handle: CommandArgs<"operation/cancel">["handle"]) => Promise<CommandResult<"operation/cancel">>;
+    get: (handle: CommandArgs<"operation/get">["handle"]) => Promise<CommandResult<"operation/get">>;
+    list: () => Promise<CommandResult<"operation/list">>;
+    subscribe: <E extends "changed">(event: E, callback: (data: EventData<`operation/${E}`>) => void) => Promise<void>;
+    unsubscribe: <E extends "changed">(event: E, callback: (data: EventData<`operation/${E}`>) => void) => void;
+};
+export { operationCommands as operation };
+declare const packageCommands: {
+    get: (packageId: CommandArgs<"package/get">["packageId"]) => Promise<CommandResult<"package/get">>;
+    getIcon: (packageId: CommandArgs<"package/get-icon">["packageId"]) => Promise<CommandResult<"package/get-icon">>;
+    getInfo: (location: CommandArgs<"package/get-info">["location"]) => Promise<CommandResult<"package/get-info">>;
+    getSize: (packageId: CommandArgs<"package/get-size">["packageId"]) => Promise<CommandResult<"package/get-size">>;
+    install: (source: CommandArgs<"package/install">["source"], options?: Pick<CommandArgs<"package/install">, "replace"> & {
+        submission?: OperationSubmission;
+    }) => Promise<CommandResult<"package/install">>;
+    isHotReloadEnabled: (packageId: CommandArgs<"package/is-hot-reload-enabled">["packageId"]) => Promise<CommandResult<"package/is-hot-reload-enabled">>;
+    list: (options?: Pick<CommandArgs<"package/list">, "showHidden" | "showRestricted">) => Promise<CommandResult<"package/list">>;
+    self: () => Promise<CommandResult<"package/self">>;
+    toggleHotReload: (packageId: CommandArgs<"package/toggle-hot-reload">["packageId"]) => Promise<CommandResult<"package/toggle-hot-reload">>;
+    uninstall: (packageId: CommandArgs<"package/uninstall">["packageId"], options?: {
+        submission?: OperationSubmission;
+    }) => Promise<CommandResult<"package/uninstall">>;
+    subscribe: <E extends "installed" | "uninstalled">(event: E, callback: (data: EventData<`package/${E}`>) => void) => Promise<void>;
+    unsubscribe: <E extends "installed" | "uninstalled">(event: E, callback: (data: EventData<`package/${E}`>) => void) => void;
+};
+export { packageCommands as package };
+declare const processCommands: {
+    exit: (options?: {
+        submission?: OperationSubmission;
+    }) => Promise<CommandResult<"process/exit">>;
+    launch: (appId: CommandArgs<"process/launch">["appId"], options?: Pick<CommandArgs<"process/launch">, "bounds"> & {
+        submission?: OperationSubmission;
+    }) => Promise<CommandResult<"process/launch">>;
+    list: (options?: Pick<CommandArgs<"process/list">, "showHidden">) => Promise<CommandResult<"process/list">>;
+    metrics: (options?: Pick<CommandArgs<"process/metrics">, "showHidden" | "pollingTimeoutMs" | "waitForAccurateCpu">) => Promise<CommandResult<"process/metrics">>;
+    stop: (appId: CommandArgs<"process/stop">["appId"], options?: {
+        submission?: OperationSubmission;
+    }) => Promise<CommandResult<"process/stop">>;
+    subscribe: <E extends "error" | "exited" | "launched" | "reloading" | "stopped">(event: E, callback: (data: EventData<`process/${E}`>) => void) => Promise<void>;
+    unsubscribe: <E extends "error" | "exited" | "launched" | "reloading" | "stopped">(event: E, callback: (data: EventData<`process/${E}`>) => void) => void;
+};
+export { processCommands as process };
+declare const sessionCommands: {
+    getCurrent: () => Promise<CommandResult<"session/get-current">>;
+    login: (username: CommandArgs<"session/login">["username"], password: CommandArgs<"session/login">["password"], options?: {
+        submission?: OperationSubmission;
+    }) => Promise<CommandResult<"session/login">>;
+    logout: (options?: {
+        submission?: OperationSubmission;
+    }) => Promise<CommandResult<"session/logout">>;
+    subscribe: <E extends "changed">(event: E, callback: (data: EventData<`session/${E}`>) => void) => Promise<void>;
+    unsubscribe: <E extends "changed">(event: E, callback: (data: EventData<`session/${E}`>) => void) => void;
+};
+export { sessionCommands as session };
+declare const settingsCommands: {
+    action: (panelId: CommandArgs<"settings/action">["panelId"], actionId: CommandArgs<"settings/action">["actionId"], options?: Pick<CommandArgs<"settings/action">, "invocation">) => Promise<CommandResult<"settings/action">>;
+    /**
+     * Get a setting value (scoped to caller's app)
+     */
+    get: (key: CommandArgs<"settings/get">["key"], options?: Pick<CommandArgs<"settings/get">, "appId">) => Promise<CommandResult<"settings/get">>;
+    /**
+     * Get all settings with values (scoped to caller's app)
+     */
+    getAll: () => Promise<CommandResult<"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: CommandArgs<"settings/get-all/su">["appId"], options?: Pick<CommandArgs<"settings/get-all/su">, "showRestricted">) => Promise<CommandResult<"settings/get-all/su">>;
+    /**
+     * Get a setting from any app's namespace (superuser only)
+     */
+    getSu: (appId: CommandArgs<"settings/get/su">["appId"], key: CommandArgs<"settings/get/su">["key"]) => Promise<CommandResult<"settings/get/su">>;
+    /**
+     * List all settings keys (scoped to caller's app)
+     */
+    list: () => Promise<CommandResult<"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: CommandArgs<"settings/list/su">["appId"], options?: Pick<CommandArgs<"settings/list/su">, "showRestricted">) => Promise<CommandResult<"settings/list/su">>;
+    panel: (panelId: CommandArgs<"settings/panel">["panelId"]) => Promise<CommandResult<"settings/panel">>;
+    panels: () => Promise<CommandResult<"settings/panels">>;
+    /**
+     * Reset a setting to default (scoped to caller's app)
+     */
+    reset: (key: CommandArgs<"settings/reset">["key"], options?: Pick<CommandArgs<"settings/reset">, "schema">) => Promise<CommandResult<"settings/reset">>;
+    /**
+     * Reset a setting for any app (superuser only)
+     */
+    resetSu: (appId: CommandArgs<"settings/reset/su">["appId"], key: CommandArgs<"settings/reset/su">["key"], options?: Pick<CommandArgs<"settings/reset/su">, "schema">) => Promise<CommandResult<"settings/reset/su">>;
+    /**
+     * Set a setting value (scoped to caller's app)
+     */
+    set: (key: CommandArgs<"settings/set">["key"], value: CommandArgs<"settings/set">["value"]) => Promise<CommandResult<"settings/set">>;
+    /**
+     * Set a setting in any app's namespace (superuser only)
+     */
+    setSu: (appId: CommandArgs<"settings/set/su">["appId"], key: CommandArgs<"settings/set/su">["key"], value: CommandArgs<"settings/set/su">["value"]) => Promise<CommandResult<"settings/set/su">>;
+    subscribe: <E extends "changed" | "panels-changed">(event: E, callback: (data: EventData<`settings/${E}`>) => void) => Promise<void>;
+    unsubscribe: <E extends "changed" | "panels-changed">(event: E, callback: (data: EventData<`settings/${E}`>) => void) => void;
+};
+export { settingsCommands as settings };
+declare const streamCommands: {
+    /**
+     * Return credit for chunks that the caller consumed from its stream.
+     * Stream readers send this automatically.
+     */
+    ack: (handle: CommandArgs<"stream/ack">["handle"], count: CommandArgs<"stream/ack">["count"]) => Promise<CommandResult<"stream/ack">>;
+    /**
+     * Stop a stream that the caller opened.
+     */
+    cancel: (handle: CommandArgs<"stream/cancel">["handle"]) => Promise<CommandResult<"stream/cancel">>;
+};
+export { streamCommands as stream };
+declare const systemCommands: {
+    /**
+     * Get consumer-controlled product branding for SDK-owned interfaces.
+     */
+    branding: () => Promise<CommandResult<"system/branding">>;
+    info: () => Promise<CommandResult<"system/info">>;
+    power: (action: CommandArgs<"system/power">["action"], options?: {
+        submission?: OperationSubmission;
+    }) => Promise<CommandResult<"system/power">>;
+    powerCapabilities: () => Promise<CommandResult<"system/power-capabilities">>;
+};
+export { systemCommands as system };
+declare const userCommands: {
+    changePassword: (currentPassword: CommandArgs<"user/change-password">["currentPassword"], newPassword: CommandArgs<"user/change-password">["newPassword"]) => Promise<CommandResult<"user/change-password">>;
+    create: (name: CommandArgs<"user/create">["name"], password: CommandArgs<"user/create">["password"], options?: Pick<CommandArgs<"user/create">, "username" | "role" | "grants" | "directoryRestriction">) => Promise<CommandResult<"user/create">>;
+    delete: (username: CommandArgs<"user/delete">["username"]) => Promise<CommandResult<"user/delete">>;
+    getDefault: () => Promise<CommandResult<"user/get-default">>;
+    grantOptions: () => Promise<CommandResult<"user/grant-options">>;
+    hasGrant: (grant: CommandArgs<"user/has-grant">["grant"]) => Promise<CommandResult<"user/has-grant">>;
+    list: () => Promise<CommandResult<"user/list">>;
+    setDefault: (username: CommandArgs<"user/set-default">["username"]) => Promise<CommandResult<"user/set-default">>;
+    setPassword: (username: CommandArgs<"user/set-password">["username"], password: CommandArgs<"user/set-password">["password"]) => Promise<CommandResult<"user/set-password">>;
+    update: (username: CommandArgs<"user/update">["username"], options?: Pick<CommandArgs<"user/update">, "name" | "role" | "grants" | "directoryRestriction">) => Promise<CommandResult<"user/update">>;
+    subscribe: <E extends "grant-options-changed">(event: E, callback: (data: EventData<`user/${E}`>) => void) => Promise<void>;
+    unsubscribe: <E extends "grant-options-changed">(event: E, callback: (data: EventData<`user/${E}`>) => void) => void;
+};
+export { userCommands as user };
+declare const viewCommands: {
+    endDrag: () => Promise<CommandResult<"view/end-drag">>;
+    endResize: () => Promise<CommandResult<"view/end-resize">>;
+    expandTile: (direction: CommandArgs<"view/expand-tile">["direction"]) => Promise<CommandResult<"view/expand-tile">>;
+    focus: () => Promise<CommandResult<"view/focus">>;
+    focusView: (appId: CommandArgs<"view/focus-view">["appId"]) => Promise<CommandResult<"view/focus-view">>;
+    getInterfaceScale: () => Promise<CommandResult<"view/get-interface-scale">>;
+    globalMouseup: () => Promise<CommandResult<"view/global-mouseup">>;
+    setInterfaceScale: (scale: CommandArgs<"view/set-interface-scale">["scale"]) => Promise<CommandResult<"view/set-interface-scale">>;
+    setViewVisibility: (appId: CommandArgs<"view/set-view-visibility">["appId"], visible: CommandArgs<"view/set-view-visibility">["visible"]) => Promise<CommandResult<"view/set-view-visibility">>;
+    setVisibility: (visible: CommandArgs<"view/set-visibility">["visible"]) => Promise<CommandResult<"view/set-visibility">>;
+    startDrag: (startX: CommandArgs<"view/start-drag">["startX"], startY: CommandArgs<"view/start-drag">["startY"]) => Promise<CommandResult<"view/start-drag">>;
+    startResize: (startX: CommandArgs<"view/start-resize">["startX"], startY: CommandArgs<"view/start-resize">["startY"], options?: Pick<CommandArgs<"view/start-resize">, "direction">) => Promise<CommandResult<"view/start-resize">>;
+    swapTile: (direction: CommandArgs<"view/swap-tile">["direction"]) => Promise<CommandResult<"view/swap-tile">>;
+    tileLayoutState: () => Promise<CommandResult<"view/tile-layout-state">>;
+    toggleMode: (options?: Pick<CommandArgs<"view/toggle-mode">, "mode">) => Promise<CommandResult<"view/toggle-mode">>;
+    toggleViewMode: (appId: CommandArgs<"view/toggle-view-mode">["appId"], options?: Pick<CommandArgs<"view/toggle-view-mode">, "mode">) => Promise<CommandResult<"view/toggle-view-mode">>;
+    updateBounds: (bounds: CommandArgs<"view/update-bounds">["bounds"]) => Promise<CommandResult<"view/update-bounds">>;
+    updateGlobalBounds: (bounds: CommandArgs<"view/update-global-bounds">["bounds"], windowSize: CommandArgs<"view/update-global-bounds">["windowSize"]) => Promise<CommandResult<"view/update-global-bounds">>;
+    updateViewBounds: (appId: CommandArgs<"view/update-view-bounds">["appId"], bounds: CommandArgs<"view/update-view-bounds">["bounds"]) => Promise<CommandResult<"view/update-view-bounds">>;
+    windowSize: () => Promise<CommandResult<"view/window-size">>;
+    subscribe: <E extends "bounds-updated" | "global-bounds-changed" | "interface-scale-changed" | "mode-changed" | "view-load-failed" | "view-loaded" | "view-removed">(event: E, callback: (data: EventData<`view/${E}`>) => void) => Promise<void>;
+    unsubscribe: <E extends "bounds-updated" | "global-bounds-changed" | "interface-scale-changed" | "mode-changed" | "view-load-failed" | "view-loaded" | "view-removed">(event: E, callback: (data: EventData<`view/${E}`>) => void) => void;
+};
+export { viewCommands as view };
+declare const volumeCommands: {
+    eject: (volume: CommandArgs<"volume/eject">["volume"], options?: {
+        submission?: OperationSubmission;
+    }) => Promise<CommandResult<"volume/eject">>;
+    list: () => Promise<CommandResult<"volume/list">>;
+    subscribe: <E extends "changed">(event: E, callback: (data: EventData<`volume/${E}`>) => void) => Promise<void>;
+    unsubscribe: <E extends "changed">(event: E, callback: (data: EventData<`volume/${E}`>) => void) => void;
+};
+export { volumeCommands as volume };
+//# sourceMappingURL=commands.generated.d.ts.map