@nodaro/sdk 2.29.0 → 2.32.0

package/dist/developer-apps-zSQXWmEG.d.ts

@@ -0,0 +1,294 @@
+import { OAuthScope } from '@nodaro/shared/apps';
+import { MeOrganizations } from '@nodaro/shared/organizations';
+
+/**
+ * Auth provides the token used for `Authorization: Bearer <token>` on each request.
+ * Implementations:
+ *   - StaticTokenAuth — fixed string (server-side, OAuth access token, API token)
+ *   - CallbackAuth    — caller-supplied async function (BYO logic)
+ *   - supabaseAuth    — pulls JWT from a Supabase client live (browser frontends)
+ */
+interface Auth {
+    /** Returns the current Bearer token, or null if not authenticated. */
+    getToken(): Promise<string | null>;
+}
+declare class StaticTokenAuth implements Auth {
+    private token;
+    constructor(token: string);
+    getToken(): Promise<string>;
+}
+declare class CallbackAuth implements Auth {
+    private fn;
+    constructor(fn: () => string | null | Promise<string | null>);
+    getToken(): Promise<string | null>;
+}
+interface SupabaseLikeClient {
+    auth: {
+        getSession(): Promise<{
+            data: {
+                session: {
+                    access_token: string;
+                } | null;
+            };
+        }>;
+    };
+}
+/** Pulls a JWT from a Supabase v2 client. Caller supplies their own supabase. */
+declare function supabaseAuth(supabase: SupabaseLikeClient): Auth;
+
+/**
+ * OAuth scopes that a developer app may request — the server's own list
+ * (`OAUTH_SCOPES` in `@nodaro/shared`), so it cannot fall behind.
+ */
+type DeveloperAppScope = OAuthScope;
+type DeveloperAppStatus = "active" | "suspended" | "pending_review";
+/**
+ * How the app came to exist. `user` is an app someone registered by hand in
+ * the dashboard; the others register themselves (MCP clients via Dynamic
+ * Client Registration, first-party MCP, a connected community instance).
+ * Only `user` apps count toward the per-user registration cap.
+ */
+type DeveloperAppKind = "user" | "dynamic_mcp" | "first_party_mcp" | "community_instance";
+interface DeveloperApp {
+    id: string;
+    name: string;
+    description: string | null;
+    logoUrl: string | null;
+    homepageUrl: string | null;
+    redirectUris: string[];
+    allowedOrigins: string[];
+    scopesRequested: DeveloperAppScope[];
+    clientId: string;
+    status: DeveloperAppStatus;
+    /** Absent from servers older than this field; treat missing as `"user"`. */
+    kind?: DeveloperAppKind | (string & {});
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * One-shot create response — `clientSecret` is returned exactly ONCE here.
+ * Store it securely; subsequent `get`/`list` calls will not include it.
+ */
+interface CreateDeveloperAppResult extends DeveloperApp {
+    clientSecret: string;
+}
+interface CreateDeveloperAppInput {
+    name: string;
+    description?: string;
+    homepageUrl?: string;
+    logoUrl?: string;
+    /** At least 1, at most 10 redirect URIs. Each must be https or http://localhost. */
+    redirectUris: string[];
+    /** Up to 5 bare origins (no path/query/hash), e.g. "https://example.com". */
+    allowedOrigins?: string[];
+    /** At least 1 scope required. */
+    scopesRequested: DeveloperAppScope[];
+}
+interface UpdateDeveloperAppInput {
+    name?: string;
+    description?: string;
+    homepageUrl?: string;
+    logoUrl?: string;
+    redirectUris?: string[];
+    allowedOrigins?: string[];
+    scopesRequested?: DeveloperAppScope[];
+}
+interface RotateSecretResult {
+    /** New client secret. Returned exactly once — old secret is invalidated. */
+    clientSecret: string;
+}
+declare class DeveloperAppsResource {
+    private client;
+    constructor(client: NodaroClientCore);
+    /** List the authenticated user's developer apps. */
+    list(): Promise<{
+        data: DeveloperApp[];
+    }>;
+    /** Get a developer app by ID. */
+    get(id: string): Promise<{
+        data: DeveloperApp;
+    }>;
+    /**
+     * Create a new developer app. Returns the app PLUS a one-time `clientSecret`
+     * — store it now, the secret hash is the only copy kept server-side.
+     */
+    create(input: CreateDeveloperAppInput): Promise<{
+        data: CreateDeveloperAppResult;
+    }>;
+    /** Update a developer app's metadata, redirect URIs, origins, or requested scopes. */
+    update(id: string, input: UpdateDeveloperAppInput): Promise<{
+        data: DeveloperApp;
+    }>;
+    /** Delete a developer app. Returns `{ success: true }`. Throws
+     *  `NotFoundError` when the id doesn't exist or isn't yours. */
+    delete(id: string): Promise<{
+        success: true;
+    }>;
+    /**
+     * Generate a new `clientSecret`. The previous secret is invalidated.
+     * Server returns ONLY the new secret, not the full app record.
+     */
+    rotateSecret(id: string): Promise<RotateSecretResult>;
+}
+
+interface ClientOptions {
+    /** Backend base URL, e.g. "https://nodaro.example.com" or empty string for same-origin. */
+    baseUrl: string;
+    /** Auth provider. Use StaticTokenAuth, supabaseAuth, or CallbackAuth. */
+    auth: Auth;
+    /** Optional fetch override (for tests or custom transports). */
+    fetch?: typeof fetch;
+    /** Default request timeout in ms. Default 60s. */
+    timeoutMs?: number;
+    /**
+     * Overrides the `X-Nodaro-Client` label. Defaults to `sdk/<version>`.
+     *
+     * Exists for `@nodaro/cli`, which is a wrapper AROUND this SDK: without an
+     * override every CLI invocation would be recorded as an SDK call and the two
+     * surfaces could never be told apart.
+     */
+    clientLabel?: string;
+    /**
+     * The workspace every request acts in — sent as `X-Nodaro-Workspace`.
+     *
+     * It selects which workspace a LIST reads from and where a CREATE lands.
+     * It never authorizes: reading, updating, deleting or running an
+     * identified object is decided by that object's own workspace, so a
+     * forgotten header cannot hide work and a forged one cannot reach anyone
+     * else's. Omit it to work in the caller's personal space.
+     *
+     * Prefer {@link NodaroClient.withWorkspace} for anything short-lived — one
+     * client per workspace, no shared mutable selection to get wrong.
+     */
+    workspaceId?: string;
+}
+interface RequestOptions {
+    body?: unknown;
+    query?: Record<string, string | number | boolean | undefined>;
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+}
+/**
+ * The authenticated user's canonical identity (`GET /v1/me`). A token-
+ * introspection primitive: any valid bearer token (first-party Supabase JWT or
+ * a developer-app OAuth token) resolves to its owner's identity. Mirrors the
+ * `profiles` identity columns server-side — the route is the source of truth.
+ */
+interface UserIdentity {
+    /** Nodaro user id (= the Supabase auth user id). */
+    readonly id: string;
+    readonly email: string;
+    /** Human-readable display name (from `profiles.full_name`); `null` if unset. */
+    readonly displayName: string | null;
+    /** Avatar URL; `null` if unset. */
+    readonly avatarUrl: string | null;
+    /** Subscription tier (e.g. "free", "pro"). */
+    readonly tier: string;
+    /**
+     * Whether the user holds an admin role. DESCRIPTIVE only — use it to decide
+     * whether to render admin surfaces without capability-probing an admin
+     * endpoint; every admin API stays enforced server-side regardless.
+     */
+    readonly isAdmin: boolean;
+}
+/**
+ * An app the user let into their account through OAuth (`GET
+ * /v1/me/connected-apps`): a developer app, an AI assistant's MCP connector, or
+ * a self-hosted install. One entry per grant still in force.
+ */
+interface ConnectedApp {
+    /** The grant's id — what {@link NodaroClient.revokeConnectedApp} takes. */
+    readonly authorizationId: string;
+    /** The app's name; `null` if it has none. A `dynamic_mcp` client chose its own. */
+    readonly name: string | null;
+    /**
+     * How the app came to exist: `user` (a developer app someone registered),
+     * `first_party_mcp`, `dynamic_mcp` (an MCP client that registered itself) or
+     * `community_instance` (a self-hosted install).
+     */
+    readonly kind: DeveloperAppKind | (string & {});
+    readonly homepageUrl: string | null;
+    /** The scopes this grant holds. */
+    readonly scopes: readonly DeveloperAppScope[];
+    /** When the user granted access (ISO 8601). */
+    readonly connectedAt: string;
+    /** The latest use of any token issued under the grant; `null` if never used. */
+    readonly lastUsedAt: string | null;
+}
+declare class NodaroClientCore {
+    readonly baseUrl: string;
+    readonly auth: Auth;
+    readonly timeoutMs: number;
+    /** Value sent as `X-Nodaro-Client`; recorded by the backend as job provenance. */
+    readonly clientLabel: string;
+    /** Whether to actually send it — see the note on {@link CLIENT_HEADER}. */
+    private readonly sendClientHeader;
+    private readonly fetchOverride;
+    /**
+     * Resolved lazily so consumers can swap `globalThis.fetch` after the
+     * client has been constructed (e.g. test mocks). Always rebound to the
+     * global object — native fetch throws "Illegal invocation" when its
+     * `this` is anything else.
+     */
+    get fetch(): typeof fetch;
+    /** The workspace this client acts in; undefined = the personal space. */
+    readonly workspaceId: string | undefined;
+    constructor(opts: ClientOptions);
+    /**
+     * The transport: build the request, send it, throw the typed error on a
+     * non-2xx via {@link throwFromResponse}, then read the body via `read` — all
+     * inside the abort timer, so `timeoutMs` bounds the body download too (a
+     * stalled CSV stream aborts, it does not hang forever). Both the JSON path
+     * ({@link request}) and the text path ({@link requestText}) go through here.
+     */
+    private send;
+    /** Authenticated, bounded binary reads through the normal timeout/error transport. */
+    requestBytes(method: string, path: string, options: RequestOptions & {
+        maxBytes: number;
+    }): Promise<ArrayBuffer>;
+    request<T>(method: string, path: string, options?: RequestOptions): Promise<T>;
+    /**
+     * Like {@link request}, for endpoints that answer text (CSV exports). Errors
+     * are still the JSON envelope and throw the same typed errors, and the read is
+     * bounded by the same timeout as the request.
+     */
+    requestText(method: string, path: string, options?: RequestOptions): Promise<string>;
+    /**
+     * `GET /v1/me` → the authenticated user's identity (see {@link UserIdentity}).
+     * Unwraps the `{ data }` envelope. Throws `UnauthorizedError` (401) when the
+     * token is missing/invalid, and the SDK's other typed errors as usual.
+     *
+     * On an instance with organizations it also carries what the caller belongs
+     * to. THREE states, and collapsing them is wrong in a way users feel: the
+     * organization fields ABSENT means this instance has no organizations at
+     * all; present and empty means the account belongs to none; and
+     * `organizationsUnavailable` means the lookup failed — keep whatever
+     * selection you already had rather than concluding the person was removed
+     * from everything.
+     */
+    me(): Promise<UserIdentity & MeOrganizations>;
+    /**
+     * `GET /v1/me/connected-apps` → every app with access to the signed-in
+     * user's account (see {@link ConnectedApp}), newest grant first.
+     *
+     * **A signed-in browser session only.** The route answers a Supabase
+     * session token (`supabaseAuth(…)`, `createSharedSupabaseClient`, or a
+     * `StaticTokenAuth` holding one) and refuses every other credential with
+     * `UnauthorizedError` ("Sign in required"): an app token or an API key must
+     * not list the grants it lives under. Build your "Connected apps" settings
+     * screen on this; a server-side integration cannot call it.
+     */
+    connectedApps(): Promise<ConnectedApp[]>;
+    /**
+     * `POST /v1/me/connected-apps/:authorizationId/revoke` — ends an app's
+     * access: the grant and every token issued under it, at once (the app's next
+     * call is a 401). Resolves when done.
+     *
+     * A signed-in browser session only, like {@link connectedApps}. Throws
+     * `NotFoundError` when the grant is not the user's or is already revoked.
+     */
+    revokeConnectedApp(authorizationId: string): Promise<void>;
+    private buildUrl;
+}
+
+export { type Auth as A, CallbackAuth as C, type DeveloperApp as D, NodaroClientCore as N, type RotateSecretResult as R, StaticTokenAuth as S, type UpdateDeveloperAppInput as U, type ClientOptions as a, type ConnectedApp as b, type CreateDeveloperAppInput as c, type CreateDeveloperAppResult as d, type DeveloperAppKind as e, type DeveloperAppScope as f, type DeveloperAppStatus as g, DeveloperAppsResource as h, type UserIdentity as i, supabaseAuth as s };

package/dist/entries/apps.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+require('../chunk-NJVSKUL2.cjs');
+var chunkDKEYSJCE_cjs = require('../chunk-DKEYSJCE.cjs');
+
+
+
+Object.defineProperty(exports, "AppsResource", {
+  enumerable: true,
+  get: function () { return chunkDKEYSJCE_cjs.AppsResource; }
+});
+//# sourceMappingURL=apps.cjs.map
+//# sourceMappingURL=apps.cjs.map

package/dist/entries/apps.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"apps.cjs"}

package/dist/entries/apps.d.cts

@@ -0,0 +1,300 @@
+import { N as NodaroClientCore } from '../developer-apps-zSQXWmEG.cjs';
+import '@nodaro/shared/apps';
+import '@nodaro/shared/organizations';
+
+/**
+ * A published app — a workflow wrapped in a curated input/output presentation.
+ * Returned by the public `/v1/apps/browse` endpoint.
+ */
+interface PublishedApp {
+    id: string;
+    slug: string;
+    name: string;
+    description?: string | null;
+    creatorId: string;
+    creatorName?: string | null;
+    thumbnailUrl?: string | null;
+    category?: string | null;
+    isFeatured?: boolean;
+    runCount?: number;
+    /** The listed price per run; when `perMinuteCredits` is above 0, its fixed part. */
+    estimatedCredits?: number | null;
+    /**
+     * Credits per minute of the recording the app is given, when its price
+     * follows that recording's length: the price is `estimatedCredits` plus
+     * this per minute. 0 or absent when the price does not depend on a
+     * recording's length.
+     */
+    perMinuteCredits?: number;
+    /**
+     * Credits for each item beyond the creator's saved items of a list input
+     * the app's user fills: the price is the listed one plus this per further
+     * item. 0 or absent when the app has no such input.
+     */
+    perItemCredits?: number;
+    /**
+     * The listed price is a range: `estimatedCredits` (with `perMinuteCredits` /
+     * `perItemCredits`) is "from" — the app's saved settings — and these are
+     * "up to": the most a run can cost over the choices the app's user has (every
+     * exposed field, at the creator's restricted values where set). Present only
+     * when they differ from "from"; absent on an app published before the range
+     * existed until its next publish.
+     */
+    maxEstimatedCredits?: number;
+    maxPerMinuteCredits?: number;
+    maxPerItemCredits?: number;
+    createdAt: string;
+    updatedAt: string;
+}
+interface ListAppsParams {
+    /** Substring search across app name + description. */
+    search?: string;
+    /** Page size; backend caps at 50. */
+    limit?: number;
+    /** Cursor token returned by the previous page. */
+    cursor?: string;
+    /** Filter to a single category slug. */
+    category?: string;
+}
+interface ListAppsResult {
+    data: PublishedApp[];
+    nextCursor?: string | null;
+}
+/**
+ * App detail — includes the input schema (required + optional fields end users
+ * fill in) and the output mapping (which workflow nodes produce which display
+ * cards).
+ */
+interface PublishedAppDetail extends PublishedApp {
+    inputSchema: Record<string, unknown>;
+    outputs: Array<{
+        nodeId: string;
+        label: string;
+        type: string;
+    }>;
+    /**
+     * The app run alone: the listed price less its Render final part (run and
+     * charged separately) — fixed, per minute of the recording and per further
+     * list item. Absent from a server that predates them; read the listed
+     * `estimatedCredits` / `perMinuteCredits` / `perItemCredits` instead.
+     */
+    runEstimatedCredits?: number;
+    runPerMinuteCredits?: number;
+    runPerItemCredits?: number;
+    /**
+     * Whether this server charges Edit Plan per started minute of the recording
+     * (otherwise in 15/30/60/90/120/180-minute steps). Absent from a server that
+     * predates it: read it as the steps.
+     */
+    editPlanPerMinute?: boolean;
+}
+interface AppRunResult {
+    /** The execution-id that was started — poll via client.executions.get(). */
+    executionId: string;
+    status: "pending" | "running";
+    /** App-run id (distinct from executionId — used by listRuns/getRun). */
+    runId?: string;
+}
+interface AppRun {
+    id: string;
+    appSlug: string;
+    executionId: string;
+    status: "pending" | "running" | "completed" | "failed" | "cancelled";
+    inputs: Record<string, unknown>;
+    outputs?: Array<{
+        nodeId: string;
+        type: string;
+        url?: string;
+        text?: string;
+    }>;
+    startedAt: string;
+    finishedAt?: string | null;
+}
+interface ListAppRunsParams {
+    limit?: number;
+    cursor?: string;
+}
+/**
+ * Result of a soft-delete (archive) operation. The run is moved to the user's
+ * archive in the Nodaro UI; restoration and permanent deletion are UI-only by
+ * design — SDK / MCP / API delete callers can't accidentally destroy data.
+ */
+interface DeleteAppRunResult {
+    success: true;
+    archived: true;
+}
+/** Advanced per-run options for `apps.run`. */
+interface RunAppOptions {
+    /**
+     * Raw node-data overrides keyed by node id → field → value, merged onto the
+     * app's workflow for THIS run only. Reaches fields that are NOT exposed as app
+     * inputs — e.g. `{ [nodeId]: { promptPrefix: "…", promptSuffix: "…" } }` to
+     * wrap the end user's prompt with text they never see.
+     */
+    inputOverrides?: Record<string, Record<string, unknown>>;
+}
+/** Options for `apps.resume` — the Retry of a failed app run. */
+interface ResumeAppRunOptions {
+    /** Answer what the Retry would run and charge, and start nothing. */
+    dryRun?: boolean;
+    /**
+     * The app version you expect the Retry to run — the one starting over would
+     * run. Absent: the app's latest. A run of another version is refused with
+     * `app_run_version_changed`; send the run's own version (the refusal's
+     * `runVersion`) to continue on it anyway.
+     */
+    version?: number;
+}
+/** One step a Retry runs again. */
+interface AppRunResumeStep {
+    nodeId: string;
+    type: string;
+    /** The node's label, or `null` when it has none. */
+    label: string | null;
+}
+/** What a Retry would do (`apps.resume(…, { dryRun: true })`); nothing is started. */
+interface AppRunResumePlan {
+    runId: string;
+    /** The failed execution the Retry continues. */
+    continuesExecutionId: string;
+    /** The app version the Retry runs (the run's own). */
+    appVersion: number | null;
+    /** Every node the Retry runs, in graph order. */
+    nodeIds: string[];
+    /** The steps that run again. */
+    steps: AppRunResumeStep[];
+    /** What the Retry is expected to charge, the creator's fee included; `null` without credits. */
+    estimatedCredits: number | null;
+    /** Clips handed back at no cost. */
+    reusedClips: number;
+    /** Whether your balance and your app credits cover what the Retry holds while it runs; `null` without credits. */
+    sufficient: boolean | null;
+    /** Your spendable balance; `null` without credits. */
+    available: number | null;
+    /** Your app credits, present only when they are what stops the Retry (it would be refused `insufficient_app_credits`). */
+    appCreditsAllowance?: number;
+}
+/**
+ * A Retry that started. `deduped: true` when a concurrent double press reached
+ * the same Retry; a second call made while the first is pending is refused
+ * with `already_running` (`AlreadyRunningError`) instead.
+ */
+interface AppRunResumeResult {
+    /** The Retry's execution — the run now points at it. Poll via client.executions.get(). */
+    executionId: string;
+    runId: string;
+    status: "pending";
+    /** Every node the Retry runs. */
+    nodeIds: string[];
+    /** `true` when a concurrent press had already started this Retry. */
+    deduped?: true;
+}
+/**
+ * The `code` the server gives an `apps.resume` refusal. Nothing is written or
+ * billed when a Retry is refused. How each arrives:
+ * - `app_run_version_changed` as `AppRunVersionChangedError`;
+ * - `already_running` as `AlreadyRunningError` (with the live `executionId`);
+ * - `not_found` and `continuation_not_found` as `NotFoundError`, whose `code`
+ *   is always `not_found` (the server's message is kept);
+ * - `insufficient_credits` and `insufficient_app_credits` as
+ *   `InsufficientCreditsError`, whose `code` is always `insufficient_credits`
+ *   (the server's message says which);
+ * - the rest as `NodaroError` carrying this code.
+ */
+type AppRunResumeRefusalCode = 
+/** No such run of yours under this app. */
+"not_found"
+/** The run's execution is not yours. */
+ | "continuation_not_found"
+/** A malformed run id or body, or a component's run (continued by the run that called it). */
+ | "validation_error"
+/** The app version the run ran is gone: start the run over. */
+ | "app_run_version_unavailable"
+/** The app is on another version than the run ran: start over, or send `version` = the run's. */
+ | "app_run_version_changed"
+/** The run's execution ran another workflow, or another version of it (rare). */
+ | "continuation_workflow_mismatch" | "continuation_version_mismatch"
+/** The run did not fail (it completed or was stopped): start it over. */
+ | "continuation_not_failed"
+/** The run is still running, a Retry of it is pending, or it was started again elsewhere. */
+ | "already_running"
+/** Nothing is left to retry: every step completed (409), or the app runs no step (400). */
+ | "continuation_subset_required"
+/** An input the run applied sets a field the app does not let a runner set. */
+ | "locked_field"
+/**
+ * The Retry would stop at a Preview with nobody to review it: retry it from the app page.
+ * (The same refusal arrives under the other preview refusal codes when a review-on use-case
+ * node holds the run; `isPreviewRefusalCode` in `@nodaro/shared/nodes` asks for all of them.)
+ */
+ | "preview_review_required"
+/** Your app credits cannot cover it. */
+ | "insufficient_app_credits"
+/** Your balance cannot cover it. */
+ | "insufficient_credits"
+/** Billing is briefly unavailable for a workspace run (503): try again shortly. */
+ | "billing_unavailable";
+declare class AppsResource {
+    private client;
+    constructor(client: NodaroClientCore);
+    /** List published apps. Public — no auth required for community apps. */
+    list(params?: ListAppsParams): Promise<ListAppsResult>;
+    /** Get one app's metadata + input schema by slug. */
+    get(slug: string): Promise<{
+        data: PublishedAppDetail;
+    }>;
+    /**
+     * Trigger an app run with the given input values. The keys in `inputs` must
+     * match the app's input-schema field names (see `get(slug).inputSchema`).
+     * `opts.inputOverrides` adds raw per-node overrides (see {@link RunAppOptions}).
+     * Returns the execution-id for status polling via client.executions.get().
+     */
+    run(slug: string, inputs?: Record<string, unknown>, opts?: RunAppOptions): Promise<AppRunResult>;
+    /** List past runs for an app (the caller must own the app or the runs). */
+    listRuns(slug: string, params?: ListAppRunsParams): Promise<{
+        data: AppRun[];
+        nextCursor?: string | null;
+    }>;
+    /** Get one app-run by id. */
+    getRun(slug: string, runId: string): Promise<{
+        data: AppRun;
+    }>;
+    /**
+     * Retry a FAILED app run from where it stopped: only the steps it did not
+     * complete run, and only those are charged; every step it completed hands
+     * on its result. It runs the version the run ran, with the inputs the run
+     * applied (it takes none of its own). The run's execution moves to the
+     * Retry's.
+     *
+     * `{ dryRun: true }` answers what the Retry would run and charge
+     * ({@link AppRunResumePlan}) and starts nothing — show it before a Retry.
+     * Refusals are listed in {@link AppRunResumeRefusalCode}; to run with other
+     * inputs or on the app's current version, start over with
+     * `run(slug, inputs)` instead.
+     *
+     * @param slug   The published app's slug.
+     * @param runId  The run's UUID (`AppRunResult.runId`, `AppRun.id`).
+     */
+    resume(slug: string, runId: string, opts: ResumeAppRunOptions & {
+        dryRun: true;
+    }): Promise<{
+        data: AppRunResumePlan;
+    }>;
+    resume(slug: string, runId: string, opts?: ResumeAppRunOptions & {
+        dryRun?: false;
+    }): Promise<AppRunResumeResult>;
+    resume(slug: string, runId: string, opts?: ResumeAppRunOptions): Promise<{
+        data: AppRunResumePlan;
+    } | AppRunResumeResult>;
+    /**
+     * Archive (soft-delete) a published-app run. The run is hidden from the
+     * default run list and can be restored or permanently deleted from the
+     * archive view at https://app.nodaro.ai/archived-runs.
+     *
+     * @param slug   The published app's slug (the last path segment of its URL).
+     * @param runId  The run's UUID.
+     */
+    deleteRun(slug: string, runId: string): Promise<DeleteAppRunResult>;
+}
+
+export { type AppRun, type AppRunResult, type AppRunResumePlan, type AppRunResumeRefusalCode, type AppRunResumeResult, type AppRunResumeStep, AppsResource, type DeleteAppRunResult, type ListAppRunsParams, type ListAppsParams, type ListAppsResult, type PublishedApp, type PublishedAppDetail, type ResumeAppRunOptions, type RunAppOptions };