@boxrouter/sdk 0.0.0-stage → 0.12.190

package/dist/sdk.gen.js

@@ -0,0 +1,3862 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BoxRouterApi = exports.Providers = exports.Pricing = exports.Files = exports.Commands = exports.Volumes = exports.ProviderAccounts = exports.Sandboxes = exports.Previews = exports.Secrets = exports.Terminals = exports.Usage = exports.SpendLimits = exports.Credits = exports.Processes = exports.Images = exports.Artifacts = exports.Operations = exports.Routing = exports.Actions = exports.Placements = exports.Jobs = exports.PoolIdleTime = exports.Runs = exports.Policies = exports.Repositories = exports.Github = exports.LaunchRuns = exports.Launches = exports.Agents = void 0;
+const eventValidation_1 = require("./core/eventValidation");
+const client_gen_1 = require("./client.gen");
+class HeyApiClient {
+    client;
+    constructor(args) {
+        this.client = args?.client ?? client_gen_1.client;
+    }
+}
+class HeyApiRegistry {
+    defaultKey = 'default';
+    instances = new Map();
+    get(key) {
+        const instance = this.instances.get(key ?? this.defaultKey);
+        if (!instance) {
+            throw new Error(`No SDK client found. Create one with "new BoxRouterApi()" to fix this error.`);
+        }
+        return instance;
+    }
+    set(value, key) {
+        this.instances.set(key ?? this.defaultKey, value);
+    }
+}
+class Agents extends HeyApiClient {
+    /**
+     * List launch agents
+     *
+     * List the launch manifests available to this workspace. The response includes
+     * names, descriptions, declared secret names and preview ports. It never includes
+     * commands, file contents or secret values.
+     *
+     */
+    list(options) {
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/agents',
+            ...options
+        });
+    }
+    /**
+     * Get a launch agent manifest
+     *
+     * Returns a workspace-available manifest. Unknown names return agent_not_found.
+     */
+    get(options) {
+        return (options.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/agents/{name}',
+            ...options
+        });
+    }
+}
+exports.Agents = Agents;
+class Launches extends HeyApiClient {
+    /**
+     * Create an agent launch
+     *
+     * Create one workspace-owned sandbox and prepare it from a catalog agent or inline
+     * manifest. `overrides.lifetime_seconds` requests a lifetime in seconds in place of
+     * the manifest value. The required Idempotency-Key identifies one logical launch; retry an
+     * uncertain request with the same key and body. BoxRouter validates the manifest,
+     * the secrets, the routes and the funding first and answers 400, 402 or 409 with outcome
+     * `not_started` for a launch it cannot start; it returns 202 only after the launch
+     * operation is durably accepted. Poll the operation URL from Location for
+     * queued/running status and phase progress. A matching key returns the same operation,
+     * including the original result. New requests and matching retries both return HTTP 202.
+     * A key used with different input returns 409 and does not start another launch.
+     * Setup, file, background and preview preparation failures destroy the newly created
+     * sandbox before the operation becomes failed.
+     *
+     * Secret values supplied in secret_values are used only for this request and are
+     * never stored or returned. Names declared by the manifest can instead resolve from
+     * the workspace secret store. The successful operation contains the sandbox ID,
+     * phase results, preview URLs and enforced expiry in result.
+     *
+     */
+    create(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/launches',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+    /**
+     * Get launch status and phase progress
+     *
+     * Returns the durable status of one launch operation owned by the caller's workspace.
+     * Poll while status is queued or running, respecting Retry-After when present. A
+     * succeeded operation includes result; a failed operation includes the original
+     * structured API error and its HTTP status. Secret values are never included.
+     *
+     */
+    getOperation(options) {
+        return (options.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/launches/{operation_id}',
+            ...options
+        });
+    }
+    /**
+     * Get what a launch asked for
+     *
+     * Returns the choices one launch was created with: the catalog agent or the caller's own
+     * source, whether BoxRouter picked the provider or the caller chose one, and the names of
+     * the secrets it used. Every client that creates a launch (the dashboard, the CLI, the
+     * SDKs) is recorded the same way, so any of them can show or repeat it. Secret values are
+     * never recorded or returned. A launch created before settings were recorded is 404.
+     *
+     */
+    getSettings(options) {
+        return (options.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/launches/{operation_id}/settings',
+            ...options
+        });
+    }
+    /**
+     * Get unattended command state
+     *
+     * Returns the observed state of the unattended command attached to a launch owned by the
+     * caller's workspace. Observation waits up to five seconds. While the command is running,
+     * call this endpoint again to observe its state. `unknown` means the outcome could not be
+     * confirmed; it is never inferred from a missing sandbox or an observation failure.
+     * A launch with no recorded unattended command returns 404. This response never contains
+     * command text, environment variables, process identity, stdout, stderr or other output.
+     * `timed_out` with exit code 124 means the armed command timer was observed to expire; an
+     * ordinary command exit with code 124 remains `exited`.
+     *
+     */
+    getCommand(options) {
+        return (options.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/launches/{operation_id}/command',
+            ...options
+        });
+    }
+    /**
+     * Check whether this workspace can read a repository
+     *
+     * Answers, without launching anything, whether the caller's workspace can read the
+     * repository: public repositories directly, private ones through the workspace's linked
+     * GitHub App installation. A repository that cannot be read is a 200 with readable false
+     * and the refusal's code, message and fix. When readable, the answer also names the commit
+     * the default branch (or the requested ref) points at, the repository's top-level entries
+     * (directories end in a slash) and the recipe a launch would use. Results are cached per
+     * commit and never stored in a response cache.
+     *
+     */
+    checkRepositoryAccess(options) {
+        return (options.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/repositories/{owner}/{repo}/access',
+            ...options
+        });
+    }
+}
+exports.Launches = Launches;
+class LaunchRuns extends HeyApiClient {
+    /**
+     * List launch runs
+     *
+     * List the authenticated workspace's launch runs, newest first, as lightweight summaries.
+     * Rows contain no copy items, specs, command data or outputs; read getLaunchRun for one
+     * run's copies. `total_copies` and `live_copies` cover every run in the workspace, not
+     * only the returned page. A live copy is one whose sandbox has not been confirmed absent,
+     * including copies that are stopping. The read uses stored metadata only and makes no
+     * provider calls. Responses are private to the workspace and must not be cached.
+     *
+     * If launch-run copies are not available to you, the read still answers 200, with `available`
+     * false, no runs and zero totals.
+     *
+     * `next_cursor` is an opaque, workspace-scoped value for the next page and is null on the
+     * last page. A cursor from another workspace or a malformed cursor is invalid_request.
+     *
+     */
+    list(options) {
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/launch-runs',
+            ...options
+        });
+    }
+    /**
+     * Start an unattended launch run
+     *
+     * Reserve one workspace-owned run and all requested copies atomically. The existing
+     * launch request fields select exactly one catalog agent or inline manifest; `copies`
+     * is required. Acceptance returns 202 with a Location for metadata polling and makes
+     * no provider create before the executor claims each copy. Reuse the same
+     * Idempotency-Key and identical body to recover an uncertain acceptance; a changed
+     * body conflicts and never creates another run.
+     *
+     * Credential selectors are resolved at each copy claim. Secret values and provider
+     * tokens are never stored. Saved secrets are re-read by name, so rotation can affect
+     * later copies. Inline secret_values, interactive launches, and unsupported manifest
+     * features are refused before reservation. The feature remains opt-in until compatible
+     * clients are released.
+     *
+     */
+    create(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/launch-runs',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+    /**
+     * Read launch run metadata
+     *
+     * Read the stored run row and copy rows only. This response excludes command data and
+     * output fields and makes no provider calls. `include=command` opts into bounded state
+     * and exit-code observations for active copies; the server uses at most eight
+     * observations at once and one five-second response deadline. Unknown, hung, saturated,
+     * or failed observations return `unknown`. Neither variant exposes command text,
+     * outputs, process handles, or credentials. Foreign and missing IDs have the same 404
+     * response.
+     *
+     */
+    get(options) {
+        return (options.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/launch-runs/{run_id}',
+            ...options
+        });
+    }
+    /**
+     * Stop a launch run
+     *
+     * Set the workspace-owned run's desired state to stopped and request copy cancellation. The request is idempotent; repeating stop returns the original stop timestamp. This does not imply that the provider sandbox was destroyed. Foreign and missing IDs have the same 404 response.
+     */
+    stop(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/launch-runs/{run_id}/stop',
+            ...options
+        });
+    }
+    /**
+     * Destroy one launch-run copy
+     *
+     * Durably request cleanup of one copy of a workspace-owned run; the run and its other
+     * copies keep running. Acceptance records the request only: no provider call is made
+     * during the request, and `stopping` does not mean the sandbox is gone. The copy's
+     * status in getLaunchRun becomes `stopped` only after its absence is confirmed; a queued
+     * copy that was never dispatched has no sandbox and stops at once.
+     *
+     * The request is idempotent. Retrying it, or destroying a copy that is already stopping
+     * or stopped, returns the same 202 and leaves the copy's state and timestamps unchanged.
+     * Foreign and missing run IDs and copy indexes have the same 404 response. Responses are
+     * private and must not be cached.
+     *
+     */
+    destroyCopy(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/launch-runs/{run_id}/copies/{copy_index}/destroy',
+            ...options
+        });
+    }
+}
+exports.LaunchRuns = LaunchRuns;
+class Github extends HeyApiClient {
+    /**
+     * List GitHub App installations linked to this workspace
+     *
+     * Requires read authority in the authenticated workspace. Results include only
+     * installations linked to that workspace; an installation ID supplied by a caller
+     * is not authority. Empty workspaces return an empty page. This is a read and never
+     * installs, uninstalls or relinks the App.
+     *
+     */
+    listInstallations(options) {
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/github/installations',
+            ...options
+        });
+    }
+    /**
+     * Unlink a GitHub App installation from this workspace
+     *
+     * Requires workspace administrator authority. Browser-session calls require the CSRF
+     * token and configured Origin. An Idempotency-Key identifies this one unlink request;
+     * an identical replay returns its recorded result, a changed request under that key
+     * conflicts, and an unknown GitHub or storage outcome is reconciled without replay.
+     * Unlinking prevents new Actions work and does not uninstall the shared App from
+     * GitHub or cancel already accepted workflow runs.
+     *
+     */
+    unlinkInstallation(options) {
+        return (options.client ?? this.client).delete({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/github/installations/{installation_id}',
+            ...options
+        });
+    }
+    /**
+     * List repositories visible through a linked installation
+     *
+     * Requires read authority in the authenticated workspace. The installation must be
+     * linked to that workspace and its current GitHub permissions are revalidated; names
+     * are descriptive while stable repository IDs bind settings and work. Results contain
+     * no installation access credentials. Empty installations return an empty page.
+     *
+     */
+    listRepositories(options) {
+        return (options.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/github/repositories',
+            ...options
+        });
+    }
+}
+exports.Github = Github;
+class Repositories extends HeyApiClient {
+    /**
+     * Get Actions enablement and defaults for a repository
+     *
+     * Requires read authority in the authenticated workspace. The repository must have
+     * a currently linked, verified GitHub installation. The returned ETag identifies
+     * this settings revision. A missing settings record is represented as `exists: false`,
+     * disabled with no required policy; it is not silently enabled by reading it. For
+     * `exists: false`, omit If-Match on the first write; for `exists: true`, send the
+     * returned ETag to update the existing record safely.
+     *
+     */
+    get(options) {
+        return (options.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/actions/repositories/{repository_id}',
+            ...options
+        });
+    }
+    /**
+     * Enable or update Actions defaults for a repository
+     *
+     * Requires workspace administrator authority. Browser-session calls require the CSRF
+     * token and configured Origin. The minimal enable request is `{"enabled":true}`;
+     * Actions creates its safe default settings and begins automatic image preparation
+     * without requiring a named policy, provider key, runner registration or YAML change.
+     * `policy_id` is optional and, when null, selects the workspace's current safe
+     * defaults. When the preceding read returned `exists: false`, omit If-Match to create
+     * the settings record; when it returned `exists: true`, send its ETag to update. The
+     * server rejects a write if that existence state changed after the read. An
+     * Idempotency-Key records
+     * the logical mutation: identical uncertain retries return the recorded outcome,
+     * changed input under the same key conflicts, and unknown effects are reconciled
+     * without automatic redispatch. Disabling stops new admission; it does not cancel
+     * accepted GitHub workflow runs or change their funding binding.
+     *
+     */
+    update(options) {
+        return (options.client ?? this.client).put({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/actions/repositories/{repository_id}',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+}
+exports.Repositories = Repositories;
+class Policies extends HeyApiClient {
+    /**
+     * List workspace Actions policies
+     *
+     * Requires workspace read authority. Stable ID-ordered pages may be empty; listing never changes policy or starts compute.
+     */
+    list(options) {
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/actions/policies',
+            ...options
+        });
+    }
+    /**
+     * Create a named workspace Actions policy
+     *
+     * Requires workspace administrator authority. Browser-session calls require the CSRF
+     * token and configured Origin. Policy settings can only narrow workspace and
+     * repository guardrails. The workspace funding choice decides the logical authority
+     * (workspace BYOK or platform managed); the actual provider, account and payer binding
+     * is confirmed separately for each attempt and is never taken from a policy. A policy
+     * cannot change supply or add accounts. Idempotency-Key replays the recorded
+     * outcome for identical input; changed input conflicts. An unknown outcome is
+     * reconciled without creating a second policy.
+     *
+     */
+    create(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/actions/policies',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+    /**
+     * Delete an unused workspace Actions policy
+     *
+     * Requires workspace administrator authority. Browser-session calls require CSRF and
+     * the configured Origin. If-Match is required. A policy referenced by repository
+     * defaults or accepted work cannot be deleted and returns 409. Idempotency-Key
+     * returns the recorded delete result for identical retries; changed input conflicts. Unknown outcomes are
+     * reconciled without repeating the deletion.
+     *
+     */
+    delete(options) {
+        return (options.client ?? this.client).delete({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/actions/policies/{policy_id}',
+            ...options
+        });
+    }
+    /**
+     * Get a workspace Actions policy
+     *
+     * Requires workspace read authority. The policy ID is workspace-scoped; foreign and unknown IDs both return 404.
+     */
+    get(options) {
+        return (options.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/actions/policies/{policy_id}',
+            ...options
+        });
+    }
+    /**
+     * Replace a workspace Actions policy
+     *
+     * Requires workspace administrator authority. Browser-session calls require CSRF and
+     * the configured Origin. If-Match is required and must equal the latest ETag. Policy
+     * changes only narrow workspace/repository guardrails and do not mutate accepted jobs
+     * or change their supply, accounts or logical funding authority. Idempotency-Key replays an identical recorded update;
+     * changed input conflicts. A stale ETag returns 409 without writing. Unknown outcomes
+     * are reconciled, never automatically redispatched.
+     *
+     */
+    update(options) {
+        return (options.client ?? this.client).put({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/actions/policies/{policy_id}',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+}
+exports.Policies = Policies;
+class Runs extends HeyApiClient {
+    /**
+     * List workspace Actions workflow-run projections
+     *
+     * Requires workspace read authority. Pages may be empty and default to newest-first
+     * by creation time; `sort` also supports oldest-first by creation time and longest
+     * first by duration. Equal sort values retain a stable run ID order, including
+     * across pages. A run's status and cost are BoxRouter's latest recorded evidence;
+     * this read does not poll GitHub, change a run, start a job or retry an uncertain
+     * effect.
+     *
+     */
+    list(options) {
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/actions/runs',
+            ...options
+        });
+    }
+    /**
+     * Count the values each run filter offers
+     *
+     * For each filter of `listActionsRuns`, its values with the number of runs in the whole
+     * workspace that have the value, ignoring any active filters. A run counts once for each
+     * value it has. Requires workspace read authority; it does not poll GitHub.
+     *
+     */
+    listFacets(options) {
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/actions/runs/facets',
+            ...options
+        });
+    }
+    /**
+     * Get a workflow-run projection and aggregate billing evidence
+     *
+     * Requires workspace read authority. Foreign and unknown run IDs both return 404; state and costs are not inferred from missing observations.
+     */
+    get(options) {
+        return (options.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/actions/runs/{run_id}',
+            ...options
+        });
+    }
+    /**
+     * List GitHub jobs projected for a workflow run
+     *
+     * Requires workspace read authority. Job assignment is tied to the runner GitHub actually assigns, not the job a JIT label initially requested.
+     */
+    listJobs(options) {
+        return (options.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/actions/runs/{run_id}/jobs',
+            ...options
+        });
+    }
+    /**
+     * List placements attempted for a workflow run
+     *
+     * Requires workspace read authority. Placement state, outcome, cleanup and billing evidence remain separate; uncertain effects are never replayed by this read.
+     */
+    listPlacements(options) {
+        return (options.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/actions/runs/{run_id}/placements',
+            ...options
+        });
+    }
+    /**
+     * Ask GitHub to cancel the entire workflow run
+     *
+     * Requires workspace execute authority. This explicitly cancels the whole GitHub
+     * workflow run, including its other jobs; it cannot cancel only one job. GitHub
+     * remains authoritative for cancellation. A 202 means GitHub acknowledged the
+     * request, not that every job or sandbox has ended. Idempotency-Key identifies this
+     * user-authorized mutation. An identical replay returns the recorded result; changed
+     * input conflicts. Unknown outcomes are reconciled against GitHub without repeating
+     * the cancellation automatically. BoxRouter never cancels as a side effect of a
+     * read, timeout or cleanup failure.
+     *
+     */
+    cancel(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/actions/runs/{run_id}/cancel',
+            ...options
+        });
+    }
+    /**
+     * Ask GitHub to rerun the entire workflow
+     *
+     * Requires workspace execute authority. This explicitly asks GitHub to rerun the
+     * entire workflow run, not one job or only failed jobs. GitHub creates and owns the
+     * new attempt. A 202 means GitHub acknowledged the request; it does not mean the new
+     * jobs have started. Idempotency-Key identifies this user-authorized mutation. An
+     * identical replay returns the recorded result; changed input conflicts. An unknown
+     * outcome is reconciled against GitHub and never automatically submitted again.
+     * Actions admission still rechecks repository binding, policy, trust and the
+     * immutable workspace/account/payer before creating any new placement.
+     *
+     */
+    rerun(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/actions/runs/{run_id}/rerun',
+            ...options
+        });
+    }
+    /**
+     * Ask GitHub to rerun failed jobs and their dependents
+     *
+     * Requires workspace execute authority. This explicitly asks GitHub to rerun the failed
+     * jobs of the entire workflow run and the jobs that depend on them in a new attempt.
+     * Passed jobs rerun only when they depend on a failed job. GitHub creates and owns the new attempt. A 202 means
+     * GitHub acknowledged the request; it does not mean the new jobs have started.
+     * Idempotency-Key identifies this user-authorized mutation. An identical replay returns
+     * the recorded result; changed input conflicts. An unknown outcome is reconciled against
+     * GitHub and never automatically submitted again. A run with no failed job is refused
+     * with 409. Actions admission still rechecks repository binding, policy, trust and the
+     * immutable workspace/account/payer before creating any new placement.
+     *
+     */
+    rerunFailedJobs(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/actions/runs/{run_id}/rerun-failed-jobs',
+            ...options
+        });
+    }
+}
+exports.Runs = Runs;
+class PoolIdleTime extends HeyApiClient {
+    /**
+     * Get the billed time of runners that served no job
+     *
+     * Requires workspace read authority. A pooled runner can cost money while no GitHub job
+     * shows it: it sat idle until the pool drained it, or its pickup was foreign or revoked,
+     * or it failed after its sandbox existed. That time is charged to the payer and shown
+     * here, apart from every run and job. The read counts the runners that started in
+     * `[since, until)`, in total and per pool, with the same `billing` object a run carries.
+     * `idle_seconds` is each runner's lifetime from creation to its end (to now for a runner
+     * that is still alive). `until` defaults to now, `since` to 30 days before `until`, and the
+     * range may not exceed 92 days; a longer or empty range returns 400. It does not poll
+     * GitHub or a provider and does not change a runner.
+     *
+     */
+    get(options) {
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/actions/pool-idle-time',
+            ...options
+        });
+    }
+}
+exports.PoolIdleTime = PoolIdleTime;
+class Jobs extends HeyApiClient {
+    /**
+     * Get an Actions job projection
+     *
+     * Requires workspace read authority. The GitHub assignment is authoritative; a requested job ID is not treated as runner reservation.
+     */
+    get(options) {
+        return (options.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/actions/jobs/{job_id}',
+            ...options
+        });
+    }
+    /**
+     * Get GitHub workflow steps for an Actions job
+     *
+     * Requires workspace execute authority. Resolves the selected workspace-owned
+     * job and its exact historical run attempt before reading the assigned GitHub
+     * workflow job. Steps preserve GitHub source order and original step numbers;
+     * position is the zero-based display order. Pending, unavailable, forbidden and
+     * removed are explicit source states. Step output is not included.
+     *
+     */
+    getSteps(options) {
+        return (options.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/actions/jobs/{job_id}/steps',
+            ...options
+        });
+    }
+    /**
+     * Read a bounded prefix of the selected GitHub job log
+     *
+     * Requires workspace execute authority. Resolves the workspace-owned job,
+     * current repository binding, assigned GitHub job and exact historical attempt
+     * before fetching only that native whole-job log. At most 1 MiB is returned;
+     * partial indicates a bounded prefix. Output is transient and is not retained.
+     * Individual step log availability depends on the GitHub App/repository source.
+     *
+     */
+    getLogs(options) {
+        return (options.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/actions/jobs/{job_id}/logs',
+            ...options
+        });
+    }
+    /**
+     * Read a bounded prefix of one GitHub step log
+     *
+     * Requires workspace execute authority. step_position is zero-based and is
+     * verified against the selected fresh GitHub job before this endpoint is read.
+     * GitHub may report individual step logs unavailable for an App/repository;
+     * this is returned explicitly without synthesizing output from the whole-job log.
+     * At most 1 MiB is returned and partial indicates a bounded prefix.
+     *
+     */
+    getStepLogs(options) {
+        return (options.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/actions/jobs/{job_id}/steps/{step_position}/logs',
+            ...options
+        });
+    }
+    /**
+     * List Actions step events for a job
+     *
+     * Requires workspace execute authority. Returns durable step events recorded for
+     * this workspace-owned Actions job, ordered by event time and ID. Use the
+     * continuation cursor to retrieve the next page; the list is empty when no
+     * events are available.
+     *
+     */
+    listEvents(options) {
+        return (options.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/actions/jobs/{job_id}/events',
+            ...options
+        });
+    }
+}
+exports.Jobs = Jobs;
+class Placements extends HeyApiClient {
+    /**
+     * Get an Actions placement and its cost and cleanup evidence
+     *
+     * Requires workspace read authority. A completed workflow job does not prove sandbox cleanup or final charge; pending and unknown remain explicit.
+     */
+    get(options) {
+        return (options.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/actions/placements/{placement_id}',
+            ...options
+        });
+    }
+}
+exports.Placements = Placements;
+class Actions extends HeyApiClient {
+    /**
+     * Read Actions runner and workspace funding readiness
+     *
+     * Requires workspace read authority. This read-only view uses the workspace's
+     * existing provider accounts and credits. Unknown source facts remain unknown;
+     * link targets appear only when an existing page can address the reported issue.
+     * When `repository_id` is supplied, readiness is scoped to that repository's saved
+     * software profile. The profile is resolved from workspace-owned settings; callers
+     * cannot select a profile through this parameter.
+     *
+     */
+    readiness(options) {
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/actions/readiness',
+            ...options
+        });
+    }
+    /**
+     * Read the recommended Actions runner labels and resource floors
+     *
+     * Requires workspace read authority. The catalog is fixed for a server release and does not
+     * depend on the workspace, so clients and caches may reuse it until its ETag changes. It does not assert live route availability or
+     * verified software; use readiness for that. Readiness still carries `runner_catalog` for
+     * older clients, but new clients should read this operation instead.
+     *
+     */
+    runnerCatalog(options) {
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/actions/runner-catalog',
+            ...options
+        });
+    }
+    /**
+     * Preview Actions label and policy eligibility
+     *
+     * Requires read authority for the linked repository in the authenticated workspace.
+     * This is a read-only evaluation of the same resolved policy and route matcher used
+     * for dispatch. It creates no runner, sandbox, reservation or billing hold. Refused
+     * and unknown results remain explicit; the preview never relaxes a requirement or
+     * claims an unverified route is eligible. It does not verify runner images. Runner image readiness is checked separately before dispatch.
+     *
+     */
+    preview(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/actions/preview',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+    _repositories;
+    get repositories() {
+        return this._repositories ??= new Repositories({ client: this.client });
+    }
+    _policies;
+    get policies() {
+        return this._policies ??= new Policies({ client: this.client });
+    }
+    _runs;
+    get runs() {
+        return this._runs ??= new Runs({ client: this.client });
+    }
+    _poolIdleTime;
+    get poolIdleTime() {
+        return this._poolIdleTime ??= new PoolIdleTime({ client: this.client });
+    }
+    _jobs;
+    get jobs() {
+        return this._jobs ??= new Jobs({ client: this.client });
+    }
+    _placements;
+    get placements() {
+        return this._placements ??= new Placements({ client: this.client });
+    }
+}
+exports.Actions = Actions;
+class Routing extends HeyApiClient {
+    /**
+     * Read workspace routing and provider funding
+     *
+     * Workspace read authority required. Returns each independently versioned section
+     * and its opaque ETag in section_etags. Never returns credentials. The GET itself
+     * has no whole-document validator; send a chosen section's token in If-Match to
+     * guard a write to that section.
+     * On a workspace's first read, the server atomically creates sections from its
+     * legacy funding state. Concurrent first reads return the same persisted sections
+     * and ETags. Later reads do not change settings unless a supported provider,
+     * managed offer or connected account changed and needs reconciliation; only a
+     * section that actually changes advances its ETag. The saved Prevent Overrides
+     * switch is retained across reads.
+     *
+     */
+    settings(options) {
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/routing/settings',
+            ...options
+        });
+    }
+    /**
+     * Update one workspace routing section
+     *
+     * Workspace admin (or provider-accounts:manage for provider funding) required;
+     * browser mutations also require Origin and X-CSRF-Token. The body names exactly
+     * one section: routing fields or one provider funding section. Send only the fields
+     * to change; every omitted field keeps its stored value, and the merged section is
+     * validated as a complete section before it is written. If-Match is optional. When
+     * sent, it must be the opaque token returned for THAT section by GET or the call
+     * fails 412 with no write; when omitted, the named fields are written to the
+     * current section. Atomically update only the named section and advance only its
+     * ETag. A stale token for that same section returns 412 with no write; a concurrent
+     * Routing edit cannot conflict with provider funding, and edits to distinct
+     * providers cannot conflict with one another. Reject duplicate account IDs,
+     * foreign/wrong-provider accounts and newly enabled Credits on unavailable managed
+     * providers before writing. Adding a key does not change provider exclusion.
+     * Identical idempotency replay returns the previously recorded response, not a
+     * second write.
+     *
+     */
+    updateSettings(options) {
+        return (options.client ?? this.client).put({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/routing/settings',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+    /**
+     * Preview workspace route availability without dispatch
+     *
+     * Workspace read authority required. Side-effect-free current eligibility and
+     * versioned hold quotes from admission. No next-job prediction, workspace spend
+     * cap or promise that a later create can start. No secret or foreign balance.
+     *
+     */
+    preview(options) {
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/routing/preview',
+            ...options
+        });
+    }
+}
+exports.Routing = Routing;
+class Operations extends HeyApiClient {
+    /**
+     * List recorded workspace operations
+     *
+     * Stable ID-ordered pagination over authoritative mutation records. Observed time is the lookup time, not the original execution timestamp. Listing never reconciles or retries work.
+     */
+    list(options) {
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/operations',
+            ...options
+        });
+    }
+    /**
+     * Get a mutation's known outcome
+     *
+     * Read the workspace-owned mutation record identified in an error response.
+     * This lookup never repeats the mutation. Unknown remains unknown until
+     * reconciliation establishes an outcome.
+     *
+     * If a creation response was lost, explicitly resubmitting POST /sandboxes
+     * in the original workspace with the original Idempotency-Key and identical
+     * effective request body recovers a retained creation record. Completed
+     * creation returns the original sandbox or an error retaining its operation
+     * ID if observing the sandbox's current state fails. An unresolved record
+     * returns 409 with its operation ID without dispatching creation again.
+     * Different input returns 409. This POST can create a sandbox if no record
+     * exists; it is not a read-only lookup. Unknown records remain until resolved;
+     * completed records remain for at least 24 hours. Without the original key and request,
+     * or beyond guaranteed retention, inspect owned resources or use support
+     * before creating more work. Never change the key to bypass uncertainty.
+     *
+     */
+    get(options) {
+        return (options.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/operations/{operation_id}',
+            ...options
+        });
+    }
+}
+exports.Operations = Operations;
+class Artifacts extends HeyApiClient {
+    /**
+     * Upload a staged input
+     *
+     * Stream opaque source bytes to workspace-scoped temporary storage. Enforce
+     * workspace upload quotas without buffering the entire request in memory.
+     * Compute the digest server-side; return a handle only after the full upload
+     * succeeds. A failed upload is not a usable artifact. Do not execute or import
+     * uploaded code. Artifact references stay workspace-scoped and can be used across routes.
+     *
+     */
+    upload(options) {
+        return (options.client ?? this.client).post({
+            bodySerializer: null,
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/artifacts',
+            ...options,
+            headers: {
+                'Content-Type': 'application/octet-stream',
+                ...options.headers
+            }
+        });
+    }
+    /**
+     * Remove a staged artifact
+     *
+     * Delete source storage without deleting resulting provider images. Reject with
+     * 409 while a submitted build, file transfer or credential-factory activation
+     * still needs these bytes. An activated factory uses its retained encrypted
+     * copy; deleting staging bytes does not revoke that credential version. Successful deletion is
+     * idempotent for a known owned record; unowned IDs remain 404.
+     *
+     */
+    delete(options) {
+        return (options.client ?? this.client).delete({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/artifacts/{artifact_id}',
+            ...options
+        });
+    }
+    /**
+     * Inspect a staged artifact
+     *
+     * Return metadata only. Unknown, unowned and expired artifacts return 404.
+     */
+    get(options) {
+        return (options.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/artifacts/{artifact_id}',
+            ...options
+        });
+    }
+}
+exports.Artifacts = Artifacts;
+class Images extends HeyApiClient {
+    /**
+     * Prepare an image on selected providers
+     *
+     * Start background preparation using this workspace's payer-account rules, on the named
+     * `providers` or on the `top` providers a create with the `match` body would pick now.
+     * A named provider that cannot run the image reports its fit reason immediately; a
+     * `match` body that no route can run is refused as that create would be. With `match`,
+     * the response lists the picked providers in rank order, and each reason says how it
+     * was ranked. A ready result means a usable copy existed when preparation completed;
+     * it does not keep the copy awake afterward. Read progress from GET /images/preparations.
+     * OCI and Dockerfile inputs use the same declared preparation capabilities as a create.
+     * A Dockerfile response returns a content selector for status and unprepare. If no selected
+     * offering declares prepared Dockerfile/context support, it is refused before reading the
+     * context or starting provider work. Existing provider artifacts are already prepared.
+     * The request JSON is limited to 64 KiB; uploaded contexts retain the artifacts API limits.
+     *
+     */
+    prepare(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/images/prepare',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+    /**
+     * Read image preparation status
+     *
+     * Reads preparation state recorded for the requested image in this workspace. The providers query can limit the result; omitted returns every recorded provider. A content selector reads the workspace's recorded copy without contacting a registry.
+     */
+    status(options) {
+        return (options.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/images/preparations',
+            ...options
+        });
+    }
+    /**
+     * Remove this workspace's prepared image copies
+     *
+     * Remove only copies Cloud recorded for this workspace. Copies on managed accounts
+     * that other workspaces still use remain available, while this workspace's use is
+     * dropped. The image itself is not deleted. A provider reports gone only after it
+     * confirms removal. A later sandbox create may prepare the image again.
+     *
+     */
+    unprepare(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/images/unprepare',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+}
+exports.Images = Images;
+class Processes extends HeyApiClient {
+    /**
+     * Start a durable background command
+     *
+     * Runs a command in the background in a Bash login shell and returns a process ID. The
+     * process keeps running between your calls: read its output, write to its input, or cancel
+     * it later, from any client. The sandbox's lifetime bounds how long it can run; cancel it to
+     * end it sooner.
+     *
+     * The sandbox image needs Linux `/proc`, Bash, and a few standard tools (`setsid`, `nohup`,
+     * `tail`, `base64`). If one is missing, the call fails with `unsupported_feature` before
+     * anything starts.
+     *
+     * `stdin` defaults to `false`. Setting it to `true`, to write to the process later, needs a
+     * sandbox created with the `processes.input` requirement and a route that supports writing to
+     * the process after it reconnects (`reattached_stdin`). To check ahead of time which routes
+     * qualify, send the same requirements to `POST /sandboxes/match`.
+     *
+     * With `wait_for_port`, the call returns once that port accepts TCP connections inside the
+     * sandbox. If the process exits first, or the port is still closed after 30 seconds, the
+     * process is ended and the call fails with `409 port_not_listening`. `details` carries
+     * `port`, `stdout_tail`, `stderr_tail` and, when the process exited, `exit_code`.
+     *
+     */
+    start(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/sandboxes/{sandbox_id}/processes',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+    /**
+     * Delete a finished process's retained output
+     *
+     * Deletes the retained output and metadata for a finished process in the addressed sandbox. It does not stop a running process; that request returns 409. The SDK generates an Idempotency-Key when omitted; reuse a supplied key with the identical request to reconcile an uncertain result.
+     */
+    remove(options) {
+        return (options.client ?? this.client).delete({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/sandboxes/{sandbox_id}/processes/{process_id}',
+            ...options
+        });
+    }
+    /**
+     * Read process output from byte offsets
+     *
+     * **Process observation**
+     *
+     * You can rely on:
+     * - A completed result carries the exact exit status and the complete output; otherwise the call reports lost observation or incomplete output.
+     * - Output bytes are exact on every route (commands in byte mode stay exact everywhere).
+     *
+     * You can set: observation deadline. Reattach where the route supports it.
+     *
+     * Not promised: chunk sizes; immediate status visibility; output kept beyond the retained history.
+     *
+     * **Process wait**
+     *
+     * You can rely on:
+     * - Returns the exact observed exit status.
+     * - An observation deadline does not claim the process stopped.
+     *
+     * You can set: observation deadline.
+     *
+     * Returns up to 256 KiB per stream from the requested byte offsets. Pass the
+     * returned next offsets to continue without gaps or repeats. `exit_code` is set
+     * only after the process ended and both streams were read to their ends. Reads
+     * are non-blocking. If the provider replaced the guest session, the answer is
+     * 410 `expired`; the command is never run again.
+     *
+     */
+    read(options) {
+        return (options.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/sandboxes/{sandbox_id}/processes/{process_id}',
+            ...options
+        });
+    }
+    /**
+     * Write process input
+     *
+     * You can rely on:
+     * - Input is delivered in order.
+     * - EOF is explicit.
+     * - Uncertain delivery is never resent.
+     * - Input is UTF-8 text on every route.
+     *
+     * You can set: data (text), EOF.
+     *
+     * Not promised: chunking on the wire.
+     *
+     * Append text to a process started with `stdin: true`. Calls from one client
+     * must be awaited sequentially to preserve input order. The selected route must
+     * support both `processes.input` and input after process reconnection
+     * (`reattached_stdin`); otherwise writes and EOF are refused as `unsupported_feature`
+     * before dispatch. Use `POST /sandboxes/match` with `requirements.processes.input`
+     * set to true to inspect eligible routes before create. If stdin is closed, return 409.
+     *
+     */
+    writeStdin(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/sandboxes/{sandbox_id}/processes/{process_id}/stdin',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+    /**
+     * Send stdin EOF
+     *
+     * You can rely on:
+     * - Input is delivered in order.
+     * - EOF is explicit.
+     * - Uncertain delivery is never resent.
+     * - Input is UTF-8 text on every route.
+     *
+     * You can set: data (text), EOF.
+     *
+     * Not promised: chunking on the wire.
+     *
+     * Close only the input stream of a process started with stdin enabled; unsupported providers refuse before dispatch.
+     *
+     */
+    closeStdin(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/sandboxes/{sandbox_id}/processes/{process_id}/stdin/close',
+            ...options
+        });
+    }
+    /**
+     * Cancel a durable process
+     *
+     * Ends the process and everything it started. This works on every sandbox; it needs no
+     * `processes.cancel` requirement. Cancelling a process that has already finished succeeds and
+     * changes nothing.
+     *
+     */
+    cancel(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/sandboxes/{sandbox_id}/processes/{process_id}/cancel',
+            ...options
+        });
+    }
+}
+exports.Processes = Processes;
+class Credits extends HeyApiClient {
+    /**
+     * Get the workspace credit balance
+     *
+     * Requires account-management permission; execution keys receive 403. Returns 503
+     * payments_unavailable while credit purchases are not configured. BYOK work never
+     * depends on this balance.
+     *
+     */
+    balance(options) {
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/credits',
+            ...options
+        });
+    }
+    /**
+     * List recent credit purchases
+     *
+     * Workspace-owned purchases in every state, ordered by creation time and ID descending. Invoice and receipt links appear only after confirmed payment. New purchases do not shift subsequent pages. Invalid or another workspace's cursor is a 400.
+     */
+    purchases(options) {
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/credits/purchases',
+            ...options
+        });
+    }
+    /**
+     * Start a credit purchase through Checkout or a saved card
+     *
+     * Without payment_method_id, records a pending purchase and returns the hosted
+     * Checkout page; success_url and cancel_url are required for this path. The response
+     * reports fee_minor and total_minor before redirect: Checkout charges total_minor
+     * (amount_minor plus BoxRouter's purchase fee, before tax) in two line items, and only
+     * amount_minor is added as credit. A refund returns credit only; the fee is not
+     * refunded. With a
+     * workspace-owned payment_method_id, creates and pays a
+     * Stripe invoice using that card. A verified paid invoice returns confirmed; when
+     * payer authentication is required, returns pending with the hosted invoice
+     * authentication_url. Send the payer there, then poll this purchase after they
+     * return to the dashboard. Credit is added only after BoxRouter fetches and validates
+     * the paid invoice. A definitive card decline returns payment_declined with the
+     * purchase ID and a short safe decline reason in error details, outcome not_started;
+     * the failed purchase remains in history. Repeating a request with the same
+     * Idempotency-Key returns its original result; a different amount or card under that
+     * key is a 409. After a payment_provider_unavailable response with outcome unknown,
+     * retry with the same key.
+     *
+     */
+    purchase(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/credits/purchases',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+    /**
+     * Preview a credit purchase and its tax
+     *
+     * Returns Stripe's current tax preview for the requested top-up amount. Requires account-management permission and is available only when in-page card purchases are enabled.
+     */
+    quotePurchase(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/credits/purchases/quote',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+    /**
+     * List managed-compute credit movements
+     *
+     * Requires account-management permission; execution keys receive 403. Returns
+     * confirmed, nonzero charges from the configured test or live billing book, the later
+     * corrections to them, reservations still held, and reservations released with no
+     * charge, newest first. Results are limited to the calling workspace. BYOK work,
+     * supplier costs, provider account identities, API-key digests and raw usage evidence
+     * are not returned; a row's `key_id` names the workspace API key it belongs to. A
+     * cursor belongs to this workspace and billing mode; invalid or foreign cursors
+     * return 400. New rows do not shift subsequent pages. No provider or payment-provider
+     * calls are made.
+     *
+     */
+    usage(options) {
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/credits/usage',
+            ...options
+        });
+    }
+    /**
+     * Get one credit purchase
+     *
+     * The authoritative state to poll after the payer returns from Checkout. Another workspace's purchase is a 404.
+     */
+    getPurchase(options) {
+        return (options.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/credits/purchases/{purchase_id}',
+            ...options
+        });
+    }
+    /**
+     * Close an unpaid Checkout session
+     *
+     * Expires a known open Checkout session for this workspace-owned purchase. A
+     * completed payment is reconciled and remains confirmed. If Checkout creation
+     * had an unknown outcome and no session ID was recorded, the same stable Stripe
+     * idempotency key recovers that request before BoxRouter expires the session.
+     * Repeating this request is safe. The request needs no body: the return URLs are
+     * optional and unused when closing a purchase.
+     *
+     */
+    cancelPurchase(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/credits/purchases/{purchase_id}/cancel',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+    /**
+     * List redeemed promotion codes
+     *
+     * Promotion codes this workspace redeemed, newest first.
+     */
+    promotions(options) {
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/credits/promotions',
+            ...options
+        });
+    }
+    /**
+     * Redeem a promotion code for free credit
+     *
+     * Adds the code's credit to the workspace balance, once per workspace. Codes are
+     * case-insensitive and surrounding spaces are ignored. An unknown, expired, disabled
+     * or fully used code is 404 promotion_code_invalid; these cases are not told apart.
+     * A new redemption answers 201. A code this workspace already redeemed is refused
+     * with 409 promotion_already_redeemed and details.redemption containing the original redemption;
+     * its message names the redemption date. No credit is granted again. Promotional
+     * credit does not expire. Requires account-management permission; 503 payments_unavailable while
+     * credits are not configured.
+     *
+     */
+    redeem(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/credits/promotions',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+    /**
+     * Get workspace billing details
+     *
+     * Requires account-management permission. Reads the workspace Stripe customer. When multiple customer tax IDs exist, tax_id is the newest by creation time (ID breaks ties). Unset details are null.
+     */
+    billingDetails(options) {
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/credits/billing-details',
+            ...options
+        });
+    }
+    /**
+     * Replace workspace billing details
+     *
+     * Stores legal name, invoice email, address and one tax ID on the workspace Stripe customer, creating it when absent. Details apply to future invoices. PUT replaces all customer tax IDs with the supplied single ID, adding the replacement before deleting old IDs so a rejected replacement preserves them. Stripe tax ID verification can be pending or unsuccessful. Repeat an uncertain update with the same Idempotency-Key; a changed body under that key returns 409. Stripe rejection returns 502; the update can have partially completed, so read current details before correcting it.
+     */
+    updateBillingDetails(options) {
+        return (options.client ?? this.client).put({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/credits/billing-details',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+    /**
+     * Get workspace credit alert settings
+     *
+     * Requires account-management permission. Returns workspace-owned settings only.
+     */
+    alerts(options) {
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/credits/alerts',
+            ...options
+        });
+    }
+    /**
+     * Replace workspace credit alert settings
+     *
+     * Atomically replaces the optional trigger level and evaluates the current available balance. Repeating identical settings is idempotent and requires no Idempotency-Key. Sends the owner one alert per crossing below the trigger level and one when available credit is zero or negative; a repeated evaluation does not resend. Re-arms at or above the trigger level and above zero respectively. BYOK work is unaffected by credit balance.
+     */
+    updateAlerts(options) {
+        return (options.client ?? this.client).put({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/credits/alerts',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+    /**
+     * List saved workspace payment methods
+     *
+     * Returns masked card details only. Saved methods can be charged for a workspace member's purchase or immediately when enabling auto top-up with a trigger level above the current balance.
+     */
+    paymentMethods(options) {
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/credits/payment-methods',
+            ...options
+        });
+    }
+    /**
+     * Start hosted setup for a saved payment method
+     *
+     * Creates a Stripe-hosted setup page and returns its URL. Setup does not charge the
+     * payer. The completed method can be charged for a later user-initiated purchase or immediately when enabling auto top-up with a trigger level above the current balance.
+     * Repeating the request with the same Idempotency-Key returns the same page.
+     *
+     */
+    setupPaymentMethod(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/credits/payment-methods/setup',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+    /**
+     * Start in-page saved card setup
+     *
+     * Creates a Stripe SetupIntent for in-page card collection. Requires account-management permission and the in-page cards feature.
+     */
+    setupPaymentMethodIntent(options) {
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/credits/payment-methods/setup-intent',
+            ...options
+        });
+    }
+    /**
+     * Set saved card charge order
+     *
+     * Replaces the order of every saved card and Link method for automatic top-up. Requires account-management permission and the multi-card top-up feature.
+     */
+    reorderPaymentMethods(options) {
+        return (options.client ?? this.client).put({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/credits/payment-methods/order',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+    /**
+     * Get a saved payment method setup status
+     *
+     * Reads Stripe's current setup state after the payer returns. Another workspace's setup is a 404.
+     */
+    getPaymentMethodSetup(options) {
+        return (options.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/credits/payment-method-setups/{setup_id}',
+            ...options
+        });
+    }
+    /**
+     * Remove a saved workspace payment method
+     *
+     * Detaches a saved card. Another workspace's payment method is a 404. If the card
+     * was the default, the next saved card becomes default; removing the last card
+     * disables auto top-up with disabled_reason payment_method_required.
+     *
+     */
+    deletePaymentMethod(options) {
+        return (options.client ?? this.client).delete({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/credits/payment-methods/{payment_method_id}',
+            ...options
+        });
+    }
+    /**
+     * Set the workspace's default saved card
+     *
+     * Makes this workspace-owned saved card the only default card. The first saved
+     * card becomes default automatically. This local setting is used by one-click
+     * purchases and auto top-up; repeating the request is safe. Another workspace's
+     * card is a 404.
+     *
+     */
+    setDefaultPaymentMethod(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/credits/payment-methods/{payment_method_id}/default',
+            ...options
+        });
+    }
+    /**
+     * Get automatic credit top-up settings
+     *
+     * Requires account-management permission. Auto top-up is off until explicitly enabled.
+     */
+    autoTopUp(options) {
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/credits/auto-top-up',
+            ...options
+        });
+    }
+    /**
+     * Replace automatic credit top-up settings
+     *
+     * Stores the enabled state, trigger level and purchase amount. The amount must be
+     * within current purchase_bounds_minor and the trigger level must be zero or greater.
+     * Enabling requires a default saved card. Enabling with a trigger level above current
+     * available credit evaluates and attempts one top-up immediately. An attempt is
+     * made once per crossing below the trigger level and is never retried automatically. A
+     * decline or required authentication disables auto top-up and records the reason.
+     * Repeating the same settings is idempotent and does not start a second attempt for
+     * the same balance crossing. After a 503 with outcome unknown, retry the identical
+     * settings or GET the settings; inspect last_attempt.purchase_id and poll that
+     * purchase to reconcile the original attempt.
+     *
+     */
+    updateAutoTopUp(options) {
+        return (options.client ?? this.client).put({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/credits/auto-top-up',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+}
+exports.Credits = Credits;
+class SpendLimits extends HeyApiClient {
+    /**
+     * List managed-compute spend limits
+     *
+     * Requires account-management permission; execution keys receive 403. Returns the
+     * workspace cap and every key's cap; a scope with no cap has `spend_limit: null`.
+     * Each capped scope also carries `spent` so far in its current period, holds included:
+     * `workspace_spent_nanodollars` for the workspace and `spent_nanodollars` per key.
+     * Limits and usage are scoped to the configured test or live billing book. BYOK usage
+     * is excluded.
+     *
+     */
+    list(options) {
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/spend-limits',
+            ...options
+        });
+    }
+    /**
+     * Clear a managed-compute spend cap
+     *
+     * Requires account-management permission. Removes the scope's cap. Clearing a scope
+     * with no cap succeeds and returns `spend_limit: null`.
+     *
+     */
+    clear(options) {
+        return (options.client ?? this.client).delete({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/spend-limits/{scope}',
+            ...options
+        });
+    }
+    /**
+     * Set a managed-compute spend cap
+     *
+     * Requires account-management permission. The cap applies to the scope's settled
+     * managed charges and open managed holds. `limit_period` sets when it resets: `daily`
+     * and `monthly` at 00:00 UTC (monthly on the first of the month), `total` never.
+     * Replaces any cap the scope already has. BYOK usage is excluded.
+     *
+     */
+    set(options) {
+        return (options.client ?? this.client).put({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/spend-limits/{scope}',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+}
+exports.SpendLimits = SpendLimits;
+class Usage extends HeyApiClient {
+    /**
+     * List grouped managed and BYOK sandbox usage
+     *
+     * Requires account-management permission; execution-only keys receive 403. Reads
+     * only this workspace and the configured test or live billing book. Settled managed
+     * charges come from verified ledger receipts and are recognized on their settlement
+     * date. BYOK costs come from the provider's own cost or usage records priced at
+     * stored list rates. byok_provider_cost_usd is that exact amount or null, never a
+     * local-clock cost or partial subtotal. No BYOK fee is included because its price-book policy remains
+     * proposed and unapproved. Current managed reservations are reported as held amounts;
+     * with group_by=day they appear under period and group_key `current`, outside the
+     * requested historical date range. Dates are inclusive UTC calendar dates and the
+     * range may not exceed 92 days. Unknown observations remain null and are counted in
+     * the corresponding unknown-sandbox field; a BYOK cost is null when any contributing
+     * sandbox's provider cost is unknown. The optional provider filter is applied
+     * before grouping to managed and BYOK history and to current managed holds. Cursors
+     * are scoped to workspace, billing mode and all report filters; malformed or foreign
+     * cursors return 400. No provider or
+     * payment-provider calls are made.
+     *
+     */
+    list(options) {
+        return (options.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/usage',
+            ...options
+        });
+    }
+    /**
+     * Export grouped managed and BYOK sandbox usage as CSV
+     *
+     * Uses the same workspace, billing mode, date range, filters and page as the JSON usage report. CSV values preserve the JSON report's exact decimal strings; `X-Usage-As-Of` identifies the observation time and `X-Next-Cursor` is present when another page exists.
+     */
+    exportCsv(options) {
+        return (options.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/usage.csv',
+            ...options
+        });
+    }
+}
+exports.Usage = Usage;
+class Terminals extends HeyApiClient {
+    /**
+     * Open a terminal
+     *
+     * Opens a real PTY running a Bash login shell on any active provider. A small
+     * Python 3 helper in the guest owns the PTY, so the sandbox image must provide
+     * `python3`. Opens once and returns a BoxRouter terminal handle; the shell ends at
+     * `timeout_seconds`, on `kill`, when it exits, or with the sandbox. Terminal
+     * connections and output expire on API worker loss; the durable open record still
+     * prevents another dispatch. No automatic recovery or replay.
+     *
+     */
+    open(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/sandboxes/{sandbox_id}/terminals',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+    /**
+     * Get observed terminal state
+     *
+     * Reads an owned terminal record without consuming output.
+     */
+    get(options) {
+        return (options.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/sandboxes/{sandbox_id}/terminals/{terminal_id}',
+            ...options
+        });
+    }
+    /**
+     * Stream terminal output and its end
+     *
+     * You can rely on:
+     * - Input order is kept and output applies backpressure on PTY routes.
+     * - Closing an observer does not by itself end the process.
+     *
+     * You can set: input, dimensions. Observation controls where supported.
+     *
+     * Not promised: unlimited concurrent observers.
+     *
+     * Server-sent events. Each data field contains one JSON TerminalEvent; the SSE id
+     * is its sequence. Output events carry exact bytes as base64. An exit event follows
+     * all output. An error event may arrive after HTTP 200 and ends the stream without
+     * implying the shell stopped. EOF without an exit or error event is an incomplete
+     * stream, not success.
+     *
+     * Output is retained in a 1 MiB sliding window until 60 seconds after the shell
+     * ends. Last-Event-ID resumes after that event while it is retained; a dropped
+     * sequence returns 410, or an error event for a reader that falls behind, and is
+     * never skipped silently. Without Last-Event-ID the stream starts at the oldest
+     * retained event.
+     *
+     */
+    events(options) {
+        return (0, eventValidation_1.withEventValidators)(({ signal: (options.client ?? this.client).getConfig().signal, ...options }).signal, eventValidators => (options.client ?? this.client).sse.get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/sandboxes/{sandbox_id}/terminals/{terminal_id}/events',
+            ...options,
+            ...(0, eventValidation_1.validateEvent)("SandboxTerminalEventSSE", eventValidators.validate0, options.responseValidator ?? (options.client ?? this.client).getConfig().responseValidator, ["exit", "error"], void 0, ["error", "exit", "output"])
+        }));
+    }
+    /**
+     * Write terminal input
+     *
+     * You can rely on:
+     * - Input order is kept and output applies backpressure on PTY routes.
+     * - Closing an observer does not by itself end the process.
+     *
+     * You can set: input, dimensions. Observation controls where supported.
+     *
+     * Not promised: unlimited concurrent observers.
+     *
+     * Writes exact bytes to the PTY once. Await calls sequentially to preserve order.
+     * Each call is one command round trip on the provider. An uncertain write must not
+     * be replayed with a new key. Returns 409 after the shell has ended.
+     *
+     */
+    write(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/sandboxes/{sandbox_id}/terminals/{terminal_id}/input',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+    /**
+     * Resize the terminal window
+     *
+     * You can rely on:
+     * - Changes the terminal's window size, or is refused where the sandbox cannot resize an open terminal.
+     *
+     * You can set: columns, rows.
+     *
+     * Not promised: when the running program notices the new size.
+     *
+     * The foreground program receives SIGWINCH. Where the sandbox cannot resize an open
+     * terminal, the refusal is `409 capability_unavailable`; open the terminal at the size
+     * you need.
+     *
+     */
+    resize(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/sandboxes/{sandbox_id}/terminals/{terminal_id}/resize',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+    /**
+     * Hang up the terminal without destroying its sandbox
+     *
+     * You can rely on:
+     * - Ends the terminal's shell without destroying the sandbox, or is refused where the sandbox cannot end it from outside; ending a terminal that already ended succeeds until the terminal expires.
+     *
+     * Not promised: that the shell has already ended when the call returns (its exit event shows when it does); that the whole process group receives the hang-up.
+     *
+     * It sends a hang-up to the shell's process group where the provider allows that, and
+     * otherwise ends the shell process. The terminal's exit event carries the shell's exit
+     * code, or -1 when, after a kill, the provider ends the terminal without reporting one. Closing an
+     * events connection never calls this. Where the sandbox cannot end a terminal's shell from
+     * outside, the refusal is `409 capability_unavailable`; type `exit` in the terminal or
+     * destroy the sandbox. A terminal expires 60 seconds after its shell ends: until then a
+     * kill answers 204, afterwards `410 expired`.
+     *
+     */
+    kill(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/sandboxes/{sandbox_id}/terminals/{terminal_id}/kill',
+            ...options
+        });
+    }
+}
+exports.Terminals = Terminals;
+class Secrets extends HeyApiClient {
+    /**
+     * List workspace secret names
+     *
+     * Requires `credentials:manage` on API keys; dashboard browser sessions are also
+     * authorized. An execution key alone cannot administer workspace secrets. Lists
+     * metadata only; secret values are never returned.
+     *
+     */
+    list(options) {
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/secrets',
+            ...options
+        });
+    }
+    /**
+     * Delete a workspace secret
+     *
+     * Requires `credentials:manage` on API keys; dashboard browser sessions are also
+     * authorized. An execution key alone cannot administer workspace secrets. Remove the
+     * named workspace secret and return no secret data.
+     *
+     */
+    delete(options) {
+        return (options.client ?? this.client).delete({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/secrets/{name}',
+            ...options
+        });
+    }
+    /**
+     * Store a workspace secret
+     *
+     * Requires `credentials:manage` on API keys; dashboard browser sessions are also
+     * authorized. An execution key alone cannot administer workspace secrets. Create or
+     * replace a workspace-scoped secret. The value is accepted only in this request body;
+     * it is never returned by this or any secret listing operation.
+     *
+     */
+    put(options) {
+        return (options.client ?? this.client).put({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/secrets/{name}',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+}
+exports.Secrets = Secrets;
+class Previews extends HeyApiClient {
+    /**
+     * List a sandbox's open previews
+     *
+     * You can rely on:
+     * - Lists the previews this sandbox has open, as recorded when they were opened; a resume forgets them, so the list is empty until one is opened again.
+     *
+     * You can set: cursor, limit.
+     *
+     * Not promised: that a listed preview still works.
+     *
+     * Records only: this call observes no provider.
+     *
+     */
+    list(options) {
+        return (options.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/sandboxes/{sandbox_id}/previews',
+            ...options
+        });
+    }
+    /**
+     * Get a URL for a sandbox port
+     *
+     * You can rely on:
+     * - A private preview never falls back to a public link, and a requested credential form never falls back to the other; a mode the sandbox cannot enforce is refused. A route whose declaration cannot enforce the mode is refused before anything is opened; a weaker preview a route does open is ended before the refusal, or the refusal says it may still be reachable and names its port and id.
+     * - Opening a port that already has a preview with the same access returns that preview instead of opening a second one.
+     *
+     * You can set: port, access, credential.
+     *
+     * Not promised: that an application is listening on the port; an expiry time unless one is enforced.
+     *
+     * Returns an HTTPS URL for one port in the sandbox and, when the link is private, where its
+     * credential is carried. The sandbox must have been created with the `previews`
+     * requirement naming that port and the access you ask for.
+     *
+     * 404 means the sandbox does not exist in this workspace. A sandbox that exists but
+     * was not created through this API is refused with `409 invalid_state`; one that has
+     * ended answers `410 sandbox_ended`.
+     *
+     * A preview is never returned with other access than the request asked for. When the
+     * provider answers with one (for example a public link for a private request), the call
+     * is refused with `502 preview_access_refused` and the unwanted preview is ended where
+     * the provider allows. `details.port` names the port. `details.revoked` is true when it
+     * was ended and no access remains. When it could not be ended the outcome is `unknown`,
+     * the message says the preview may still be reachable, and `details.preview_id` and
+     * `details.url` name a public one (a private preview's address holds a credential and is
+     * never repeated). The operation stays open for reconciliation: do not send the call
+     * again; end the sandbox to be certain no access remains.
+     *
+     */
+    open(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/sandboxes/{sandbox_id}/previews',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+    /**
+     * Revoke a preview
+     *
+     * You can rely on:
+     * - Access through the named preview ends while the sandbox and its other previews keep running; revoking a preview that already ended succeeds.
+     *
+     * You can set: preview id.
+     *
+     * Ends a preview, named by the ID that opening it returned. The sandbox must have been created
+     * with `previews.revocable` set to `true`; otherwise the call fails with `not_named`, and `fix`
+     * shows the requirement to send. A sandbox that is not running fails with `not_running`, even
+     * if the preview has already ended. Otherwise, ending a preview that has already ended answers
+     * `204`.
+     *
+     */
+    revoke(options) {
+        return (options.client ?? this.client).delete({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/sandboxes/{sandbox_id}/previews/{preview_id}',
+            ...options
+        });
+    }
+}
+exports.Previews = Previews;
+class Sandboxes extends HeyApiClient {
+    /**
+     * Prove a headless Chromium in the sandbox
+     *
+     * You can rely on:
+     * - Returns only the automation channels that loaded a page served inside the sandbox; when none does, the call is refused.
+     *
+     * Not promised: installing a browser in the sandbox.
+     *
+     * Loads a page from a server inside the guest in the image's own headless Chromium
+     * and reads the CDP endpoint: Playwright and CDP on glibc images, CDP on Alpine.
+     * Create the sandbox from an image with Python 3 and Playwright with Chromium (or a
+     * Chromium binary); BoxRouter's standard image has neither. An image without them, or a sandbox
+     * where no channel passes, such as one with too little memory, is refused with
+     * `422 unsupported_feature`. Afterwards run browser scripts through commands or processes.
+     *
+     */
+    browser(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/sandboxes/{sandbox_id}/browser',
+            ...options
+        });
+    }
+    /**
+     * Pause a sandbox and keep it
+     *
+     * You can rely on:
+     * - On return the sandbox is paused, and the result says whether running processes are kept or only files.
+     * - The remaining lifetime budget is preserved.
+     *
+     * You can set: lifetime.
+     *
+     * Stops compute and keeps the sandbox where it is. The sandbox must have been created with
+     * the `pause_resume` requirement. The result says what was kept (running processes, or
+     * only files) and how much lifetime remains. Resume the sandbox before doing more work in it.
+     *
+     * 404 means the sandbox does not exist in this workspace. A sandbox that exists but
+     * was not created through this API is refused with `409 invalid_state`; one that has
+     * ended answers `410 sandbox_ended`.
+     *
+     */
+    pause(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/sandboxes/{sandbox_id}/pause',
+            ...options
+        });
+    }
+    /**
+     * Resume the same paused sandbox
+     *
+     * You can rely on:
+     * - Resumes the same sandbox on its original provider and account, never a replacement.
+     * - On return the sandbox is running, and the result says whether processes from before the pause were lost.
+     * - The sandbox runs on with the lifetime budget it had left; resume takes no new budget.
+     * - Resuming a sandbox that is already running succeeds and changes nothing, so a retry is safe.
+     *
+     * Not promised: that previews opened before the pause still work.
+     *
+     * Starts a paused or stopped sandbox again and returns its remaining lifetime. Resume takes
+     * no fields: send no body or `{}`, and any other field fails with `400 invalid_request`. To
+     * change how long the sandbox may run, extend its lifetime, which works while it is running,
+     * paused or stopped.
+     *
+     * Resuming a sandbox that is already running changes nothing, so you can safely send the call
+     * again. 404 means the sandbox does not exist in this workspace. A sandbox that cannot be
+     * resumed fails with 409: `invalid_state` while it is being created or destroyed, or when it
+     * was not created through this API; `lifetime_used_up` when its lifetime is spent (extend it,
+     * then resume); `volume_lease_lost` or `volume_busy` when its Volume cannot follow. A sandbox
+     * that has ended answers `410 sandbox_ended`.
+     *
+     * Those refusals happen before anything is resumed and report `outcome: not_started`. If the
+     * provider resumed the sandbox and a later step failed, the outcome is never `not_started`:
+     * `502 volume_restore_failed` (the sandbox restarted without its Volume mounted) reports
+     * `outcome: partial` with an `operation_id`, and the sandbox is running without its Volume.
+     * Do not send the resume again; destroy the sandbox and create a new one with the Volume
+     * attached. A lifetime failure after the resume reports `outcome: unknown`; read the operation
+     * before acting.
+     *
+     */
+    resume(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/sandboxes/{sandbox_id}/resume',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+    /**
+     * Extend a sandbox lifetime
+     *
+     * You can rely on:
+     * - The value is the new total running-time budget, not an increment, so sending it again is safe; a budget shorter than the current one or than the running time already used is refused. On success the sandbox may run for at least the requested total; extending a paused or stopped sandbox sets the budget it resumes with.
+     *
+     * You can set: lifetime_seconds.
+     *
+     * Not promised: that the sandbox ends exactly when the budget runs out.
+     *
+     * Refused with not_named unless the creation request asked for resources.extendable_lifetime. It is
+     * not a re-match: the only check is the route's max_lifetime_seconds for this account,
+     * against the current run, and over it the answer is lifetime_limit. Allowed while
+     * running, paused or stopped: a paused or stopped sandbox resumes with the new budget.
+     * A total shorter than the current budget is invalid_request (400); a total below the
+     * running time already used is lifetime_limit (409).
+     *
+     * 404 means the sandbox does not exist in this workspace. A sandbox that exists but
+     * was not created through this API is refused with `409 invalid_state`; one that has
+     * ended answers `410 sandbox_ended`.
+     *
+     */
+    extend(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/sandboxes/{sandbox_id}/lifetime',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+    /**
+     * Change a running sandbox's outbound network policy
+     *
+     * You can rely on:
+     * - Connections opened after the call returns follow the new policy, and the sandbox keeps its processes and files.
+     * - An uncertain outcome is never resent.
+     *
+     * You can set: policy, allow, deny.
+     *
+     * Not promised: that connections already open when the call returns are closed; name lookups and DNS traffic.
+     *
+     * Switches the sandbox's outbound network policy, or changes its entries. Each call starts
+     * from the policy the sandbox has now: the last one this call applied, or else the one named
+     * when the sandbox was created (`open` if it named none).
+     *
+     * The sandbox must have been created with the `network_lockdown` requirement naming the
+     * settings the change needs. Otherwise the call fails with `not_named`, and `fix` shows the
+     * requirement to send:
+     *
+     * - Switching to a different policy needs `switchable`, and the target policy listed in
+     * `switches_to` unless it is the policy the sandbox was created with. Switching back to the
+     * created policy with different entries also needs `changeable`.
+     * - Changing the entries of the current policy needs `changeable`, even when the entries are
+     * the same. After one switch, a further call that names the new policy needs `changeable`.
+     * - Deny entries on an allowlist need `deny_wins`, and an HTTP rule among the entries needs
+     * `http_rules`.
+     *
+     * `422 unsupported_feature` with outcome `not_started` means the route cannot switch policies.
+     *
+     */
+    updateNetworkPolicy(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/sandboxes/{sandbox_id}/network-policy',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+    /**
+     * List workspace sandboxes
+     *
+     * You can rely on:
+     * - Lists only the workspace's own sandboxes, each with its latest recorded state.
+     * - A label filter matches exactly: only sandboxes carrying every requested label are listed.
+     *
+     * You can set: filters, sort, cursor, limit.
+     *
+     * Not promised: a fresh observation of each sandbox from its provider.
+     *
+     * Lists your workspace's sandboxes from BoxRouter's records, without asking providers. `state`
+     * is the latest state BoxRouter recorded, or `unknown` if it recorded none; get one sandbox to
+     * check its provider live. `observed_at` is when the list was read, and `state_recorded_at` is
+     * when that state was recorded, which can be earlier.
+     *
+     * `lifecycle` defaults to `all`; send `lifecycle=live` to list only live sandboxes, or `ended` for
+     * the rest. You can repeat the `state` and `provider` parameters to match any
+     * of several values; repeated `label` parameters must all match. Unknown query parameters fail the request. The page counts apply every
+     * filter except `lifecycle`, and `by_state` also ignores `state`, so you can show counts while
+     * changing those two filters. `source` filters by what created the sandbox, and a sandbox's
+     * origin stays readable after it ends or is removed.
+     *
+     */
+    list(options) {
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/sandboxes',
+            ...options
+        });
+    }
+    /**
+     * Create a sandbox
+     *
+     * **create (standard image)**
+     *
+     * You can rely on:
+     * - Sandboxes are created from the requested image.
+     *
+     * You can set: image, lifetime, requirements.
+     *
+     * **volume mount**
+     *
+     * You can rely on:
+     * - The named checkpoint, or the head when none is named, is restored into the mount folder, replacing what the image has there; an empty volume restores nothing.
+     *
+     * You can set: volume.
+     *
+     * Not promised: mounting a provider's own volumes.
+     *
+     * Creates a sandbox and returns it once it is ready to run commands. Send `{}`, or no
+     * body, for the default: the standard image on the best eligible route, running for up
+     * to 300 seconds. A credit-funded sandbox on a route that can extend a lifetime runs
+     * instead for as long as your credit balance covers it when you leave out
+     * `lifetime_seconds`; `funded_until` on the sandbox says how far it is funded.
+     *
+     * Describe what you need and BoxRouter picks a route that meets all of it:
+     *
+     * - `requirements`: capabilities such as `pause_resume`, `previews` or
+     * `network_lockdown`, each with the settings you need.
+     * - `resources`: minimum CPU and memory, and a region.
+     * - `lifetime_seconds` and `at_end`: how long the sandbox may run, and whether it is
+     * destroyed or paused afterward.
+     * - `preferences`: how to choose among eligible routes (`sort`, `only`, `ignore`,
+     * `order`, `allow_fallbacks`).
+     * - `volume`: a Volume to mount, optionally at a checkpoint.
+     * - `secret_refs`: saved workspace secrets to add to the environment.
+     *
+     * BoxRouter never relaxes a requirement to find a cheaper or faster route. If no route
+     * can meet the request, the call fails with `409 no_eligible_route`, `details` names each
+     * route that was ruled out and the nearest changes, and nothing is created. A field that
+     * BoxRouter does not recognize fails with `400 invalid_request`; it is never ignored.
+     * Choosing a connected account or route whose provider is not enabled for you fails with
+     * `409 provider_not_enabled` before any route is considered. The response records the
+     * contract the sandbox was created under and why its route was chosen.
+     *
+     * A created sandbox does not mean your application is listening on a port yet. If the
+     * outcome of a create is unclear, BoxRouter does not retry it or move to another
+     * provider; read the operation named by `operation_id` to find out what happened.
+     *
+     * A `volume` has one writer at a time. If its previous writer is ending (its destroy
+     * was accepted, or cleanup of its access is pending), this call waits for the
+     * release, at most 120 seconds, and then creates the sandbox, so you need no polling or
+     * retry. If the release does not finish in that time, or the writer is still running,
+     * the call fails with `409 volume_busy`, outcome `not_started`, and
+     * `details.writer_sandbox_id` names the writer. A running writer fails at once.
+     *
+     */
+    create(options) {
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/sandboxes',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers
+            }
+        });
+    }
+    /**
+     * Explain routing without creating
+     *
+     * You can rely on:
+     * - Evaluates the body exactly as create would and returns the routes create would try, in order, without provisioning, reserving or recording anything.
+     *
+     * You can set: creation body.
+     *
+     * Not promised: that a later create finds the same routes eligible.
+     *
+     * Each eligible route carries the contract it would grant, every excluded route the
+     * checks it failed, and the nearest changes are listed; a later creation checks again.
+     * A workspace with nothing to match against, that is no provider keys and no credits,
+     * or a `preferences.only` pin on a provider the workspace has not connected, answers 409 no_eligible_route with the same fix
+     * POST /sandboxes gives, because a dry run answers what the creation it stands for
+     * would.
+     *
+     */
+    match(options) {
+        return (options?.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/sandboxes/match',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers
+            }
+        });
+    }
+    /**
+     * Destroy a sandbox
+     *
+     * You can rely on:
+     * - Never deletes another generation of the sandbox.
+     * - Returns once accepted: 204 when confirmed, else 202 with an operation that completes lifecycle work; GET /operations/{id} reports completion.
+     * - While a destroy is unresolved, a repeated destroy is accepted as the same pending operation and makes no second provider call; once the destroy is confirmed, a repeat returns 204 with no body.
+     *
+     * You can set: nothing.
+     *
+     * Not promised: how long teardown takes; that the sandbox is already absent from listings on return.
+     *
+     * Requests destruction on the original upstream account, including persistent sandbox
+     * storage where the provider's destroy operation removes it. Separately owned volumes
+     * are not deleted. DELETE returns once the provider accepts the destroy, always as 202
+     * with the sandbox: `state` is `destroyed` when the provider confirmed within the request
+     * and `destroying` while lifecycle work remains, and `operation_id` is set while work
+     * remains. BoxRouter finishes an accepted destroy without the caller. GET
+     * /operations/{operation_id} reports the operation's outcome; for an accepted destroy this
+     * includes any remaining stop, final usage, and deletion work.
+     *
+     * A repeat DELETE while destruction is unresolved returns 202 with the existing
+     * operation_id and makes no second provider call. Once destruction is confirmed,
+     * repeat DELETEs return 202 with the destroyed sandbox and no `operation_id`. Unknown or
+     * unowned sandbox IDs return 404.
+     *
+     */
+    destroy(options) {
+        return (options.client ?? this.client).delete({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/sandboxes/{sandbox_id}',
+            ...options
+        });
+    }
+    /**
+     * Get a sandbox
+     *
+     * You can rely on:
+     * - Returns a handle for the id, or not_found.
+     *
+     * You can set: sandbox id.
+     *
+     * Returns the sandbox with its current state, checked with the provider, without resuming it.
+     * `observed_at` is when the provider was checked. `state_recorded_at` is when BoxRouter last
+     * recorded the state it returns; it is null if a concurrent change replaced the state during
+     * the read. `origin` says what created the sandbox and stays readable after the sandbox ends or
+     * is removed, even when the provider can no longer be checked.
+     *
+     */
+    get(options) {
+        return (options.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/sandboxes/{sandbox_id}',
+            ...options
+        });
+    }
+}
+exports.Sandboxes = Sandboxes;
+class ProviderAccounts extends HeyApiClient {
+    /**
+     * List connected accounts
+     *
+     * Requires `provider-accounts:manage` on API keys; dashboard browser sessions are also
+     * authorized. Returns your workspace's account metadata and the list of providers enabled for you;
+     * it never returns stored credentials.
+     *
+     */
+    list(options) {
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/provider-accounts',
+            ...options
+        });
+    }
+    /**
+     * Connect a provider account
+     *
+     * Saves your own provider credentials so BoxRouter can run sandboxes on that account. Needs
+     * the `provider-accounts:manage` permission on the API key; a signed-in dashboard session also
+     * works. This permission is separate from the access that creates sandboxes.
+     *
+     * BoxRouter first makes one read-only request to the provider with the credentials. A clear
+     * rejection fails with `422 credentials_rejected`; an unreachable provider or an inconclusive
+     * answer does not block the save. The credentials are then stored encrypted and never
+     * returned. The account is enabled at once. Connecting starts no sandbox and prepares
+     * nothing in your provider account: the first sandbox that needs the standard image
+     * prepares it, or run the standard image setup to prepare it now.
+     *
+     * If the key matches one you already connected (same provider, settings and last four
+     * characters), the account is still connected and the response carries a
+     * `duplicate_credential` warning naming the other account. Connecting or testing an account
+     * whose provider is not enabled for you fails with `409 provider_not_enabled`.
+     *
+     * Provider connection settings, such as a custom URL or proxy, and credentials that run your
+     * code need extra authority on the key. Submitting a URL or proxy does not by itself give
+     * BoxRouter network access to that host. For credentials that run your code, send the ID of an
+     * artifact you uploaded; an unknown or expired artifact fails with `404`. The response
+     * returns account metadata only, never the code, configuration or tokens. Sending the same
+     * request again reuses the recorded outcome, and a request still waiting on the provider
+     * fails with `409` instead of running your code a second time.
+     *
+     * If the provider later answers with `401` or `403`, the account's status becomes
+     * `credentials_rejected`; the status carries a safe cause and the action that restores access.
+     *
+     */
+    connect(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/provider-accounts',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+    /**
+     * Test provider credentials without saving them
+     *
+     * Checks credentials without saving them. Needs the `provider-accounts:manage` permission on
+     * the API key; a signed-in dashboard session also works. BoxRouter makes the same read-only
+     * request to the provider as when it tests a saved account, using the credentials in the body.
+     * Nothing is stored and no account is created or changed, so no idempotency key is needed.
+     *
+     * Credentials that run your code are not accepted here. Connection settings, such as a custom
+     * URL, are accepted and choose where the request goes; they need extra authority on the key,
+     * and submitting a URL or proxy does not by itself give BoxRouter network access to that host.
+     * The response returns the provider's own status and body, up to 4096 characters, without
+     * adding a validation message.
+     *
+     * Fails with `409 provider_not_enabled` when this provider is not enabled for you.
+     *
+     */
+    testCredentials(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/provider-accounts/test',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+    /**
+     * Remove a connected account
+     *
+     * Requires `provider-accounts:manage` on API keys; dashboard browser sessions are also
+     * authorized. Reject with 409 while owned
+     * resources, pending mutations or unresolved cleanup still depend on this
+     * credential. Never orphan sandboxes silently or transfer them to managed
+     * billing. Removes the stored secret; does not revoke the upstream token.
+     * For callable credentials, close all unreferenced factory workers and remove
+     * their retained code/configuration and acquired secrets. Pending acquisitions
+     * and retained credential-version dependencies also prevent disconnection.
+     *
+     * Removal waits for work already running on the account (standard-image setup,
+     * Actions runner-image checks), which can take minutes. With `wait=false` the
+     * request returns 202 at once with the account and `disconnect.state:
+     * disconnecting`, and finishes in the background: read the account until it
+     * returns 404 (removed) or `disconnect.state: failed`, whose `error` is the
+     * refusal this request would otherwise have returned, with the account still
+     * connected. Repeating the request while a removal runs returns the same 202 and
+     * starts nothing new.
+     *
+     */
+    disconnect(options) {
+        return (options.client ?? this.client).delete({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/provider-accounts/{account_id}',
+            ...options
+        });
+    }
+    /**
+     * Get connected-account metadata
+     *
+     * Requires `provider-accounts:manage` on API keys; dashboard browser sessions are also
+     * authorized. The account must be visible within the caller's workspace. Never reveals
+     * key material.
+     *
+     */
+    get(options) {
+        return (options.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/provider-accounts/{account_id}',
+            ...options
+        });
+    }
+    /**
+     * Rotate a connected account's credentials
+     *
+     * Replaces a connected account's credentials, for example to rotate a key. Needs the
+     * `provider-accounts:manage` permission on the API key (a signed-in dashboard session also
+     * works) and the account's current `expected_version`.
+     *
+     * The new credentials must belong to the same provider. BoxRouter makes one read-only request
+     * to the provider and refuses a clear rejection with `422 credentials_rejected`; it does not
+     * check which account the key belongs to. Requests already running keep the old credentials,
+     * and requests that start afterward use the new ones. A provider that is not enabled for you
+     * fails with `409 provider_not_enabled`.
+     *
+     * Leave out the connection settings to keep the existing ones. Settings you send must match the
+     * existing route; changing the endpoint, proxy or header identity needs a new connected
+     * account, not a key rotation. Credentials that run your code need extra authority on the key
+     * and an artifact you uploaded. If the new credentials fail to activate, the old version stays
+     * in use. A token refresh that already happened with the provider is not undone.
+     *
+     */
+    replaceCredentials(options) {
+        return (options.client ?? this.client).put({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/provider-accounts/{account_id}/credentials',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+    /**
+     * Test a saved provider account
+     *
+     * Requires `provider-accounts:manage` on API keys; dashboard browser sessions are also
+     * authorized. The credential check makes one read-only provider request using the saved
+     * credentials and returns the provider's native status and body, limited to 4096 characters.
+     * A successful test can update account health and register provider event webhooks. It
+     * starts no sandbox and prepares no image; run the standard image setup to prepare the
+     * standard image before the first sandbox needs it. The response reports the credential
+     * check.
+     * Fails with `409 provider_not_enabled` when this provider is not enabled for you.
+     *
+     */
+    test(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/provider-accounts/{account_id}/test',
+            ...options
+        });
+    }
+    /**
+     * Run the standard image setup proof
+     *
+     * Requires `provider-accounts:manage` on API keys; dashboard browser sessions are also
+     * authorized. This explicit action first tests the saved key, then boots the provider's
+     * standard image, runs a bounded command, and destroys the proof sandbox. The provider
+     * may charge for that short sandbox. Readiness is recorded only after boot, command and
+     * cleanup succeed; failure returns the unavailable state and its setup fix. Requests are
+     * idempotent and must include an idempotency key.
+     *
+     */
+    setupStandardImage(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/provider-accounts/{account_id}/standard-image/setup',
+            ...options
+        });
+    }
+}
+exports.ProviderAccounts = ProviderAccounts;
+class Volumes extends HeyApiClient {
+    /**
+     * List volumes
+     *
+     * Lists volumes in the caller's workspace using cursor-based pagination. The response includes the current storage usage and live-volume policy only when those values are available.
+     */
+    list(options) {
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/volumes',
+            ...options
+        });
+    }
+    /**
+     * Create a volume
+     *
+     * The service selects its configured live backend when this workspace's live-volume policy allows creation. Backend identity is neither a request field nor a response label.
+     */
+    create(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/volumes',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+    /**
+     * Delete a volume and its checkpoints
+     *
+     * Deletes a volume and all checkpoint references and stored bytes for it. When the volume's writer is ending (its destroy was accepted), the call waits for the release, at most 120 seconds, before deleting. A running writer fails at once with volume_busy (409). Reuse a supplied Idempotency-Key with the identical request to reconcile an uncertain result; a conflicting active use can return 409.
+     */
+    delete(options) {
+        return (options.client ?? this.client).delete({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/volumes/{volume_id}',
+            ...options
+        });
+    }
+    /**
+     * Get a volume
+     *
+     * Returns metadata for a BoxRouter-managed volume in the caller's workspace.
+     */
+    get(options) {
+        return (options.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/volumes/{volume_id}',
+            ...options
+        });
+    }
+    /**
+     * List volume checkpoints
+     *
+     * Lists committed checkpoints for this volume, newest first. A checkpoint created by an in-progress save is not listed until the save commits.
+     */
+    listCheckpoints(options) {
+        return (options.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/volumes/{volume_id}/checkpoints',
+            ...options
+        });
+    }
+    /**
+     * Save a volume checkpoint
+     *
+     * Saves the current volume filesystem as an immutable checkpoint. The optional sandbox_id identifies the expected writer-lease holder; if omitted, the current holder is used. A mounted branch sandbox can be named to checkpoint its branch files without advancing the source volume's head. Read-only sandboxes cannot save. Reuse a supplied Idempotency-Key with the identical request to reconcile an uncertain response.
+     */
+    save(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/volumes/{volume_id}/checkpoints',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+    /**
+     * Delete a checkpoint
+     *
+     * Removes the checkpoint reference. Backend data is reclaimed when the volume is erased.
+     */
+    deleteCheckpoint(options) {
+        return (options.client ?? this.client).delete({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/volumes/{volume_id}/checkpoints/{checkpoint}',
+            ...options
+        });
+    }
+    /**
+     * Get a volume checkpoint
+     *
+     * Returns an immutable committed checkpoint by its volume ID and checkpoint number.
+     */
+    getCheckpoint(options) {
+        return (options.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/volumes/{volume_id}/checkpoints/{checkpoint}',
+            ...options
+        });
+    }
+    /**
+     * Release a volume's writer lease
+     *
+     * Releases the volume's writer lease and advances its epoch, invalidating the former writer's lease token. Reuse a supplied Idempotency-Key with the identical request to reconcile an uncertain result.
+     */
+    release(options) {
+        return (options.client ?? this.client).delete({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/volumes/{volume_id}/lease',
+            ...options
+        });
+    }
+    /**
+     * Create a volume file upload
+     *
+     * Creates a multipart upload for a file that will appear at
+     * `/workspace/<path>` in sandboxes. Upload every returned part URL with an
+     * HTTP PUT containing exactly that part's bytes; save the response `ETag`
+     * header for the completion request. Part URLs expire after six hours.
+     * An open upload blocks `write` sandboxes, and a live or pending `write`
+     * attachment blocks uploads (`volume_busy`). `read` and `shared` attachments
+     * may coexist, but their sandboxes may need to refresh their volume cache to
+     * see the new file.
+     *
+     */
+    createUpload(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/volumes/{volume_id}/uploads',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+    /**
+     * Complete a volume file upload
+     *
+     * Supply each part number exactly once with the `ETag` header returned by its PUT response.
+     */
+    completeUpload(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/volumes/{volume_id}/uploads/{upload_id}/complete',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+    /**
+     * Abort a volume file upload
+     *
+     * Aborts an open multipart upload for this volume. Repeating an abort is safe; the uploaded file is not made visible in the volume.
+     */
+    abortUpload(options) {
+        return (options.client ?? this.client).delete({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/volumes/{volume_id}/uploads/{upload_id}',
+            ...options
+        });
+    }
+    /**
+     * Create a volume file download
+     *
+     * Creates a temporary download link that expires after one hour.
+     */
+    createDownload(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/volumes/{volume_id}/downloads',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+    /**
+     * List files in a volume
+     *
+     * Recursively lists files in path order without a directory delimiter. Read and shared sandboxes may need to refresh their volume cache to see new files.
+     */
+    listFiles(options) {
+        return (options.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/volumes/{volume_id}/files',
+            ...options
+        });
+    }
+}
+exports.Volumes = Volumes;
+class Commands extends HeyApiClient {
+    /**
+     * Run a buffered command
+     *
+     * **Commands**
+     *
+     * You can rely on:
+     * - Runs in a login Bash, so PATH changes that installers write to ~/.profile apply to later commands.
+     * - Returns the exit status.
+     * - Returns stdout and stderr separately.
+     * - Returns exact bytes in byte mode.
+     * - The timeout ends the command.
+     * - On a timeout the command's process group receives TERM at the deadline and KILL 5 seconds later, in both output modes.
+     * - Returned output is captured after the shell exits, and later writes by background children cannot change it.
+     * - An uncertain outcome is never replayed.
+     * - Output over the limit returns the exit status and the first output_limit_bytes of each stream, marked truncated. Default and maximum: 512 KiB per stream. Processes stream complete large output.
+     *
+     * You can set: command, cwd, env, timeout_seconds, output (text or bytes), output_limit_bytes.
+     *
+     * Not promised: guest disk used by output above the limit; ending children that leave the command's process group (for example setsid daemons).
+     *
+     * **Command stdin**
+     *
+     * You can rely on:
+     * - A command takes no input: it starts with stdin at end-of-file, and login profiles, the command and its children all read empty input.
+     *
+     * You can set: nothing (use process input for interactive input).
+     *
+     * Output over output_limit_bytes is not an error: the result sets stdout_truncated or
+     * stderr_truncated. A nonzero exit is a completed workload result, not an HTTP failure.
+     * A command that reaches timeout_seconds is a result too: the process group is ended and
+     * the answer is 200 with timed_out true, exit_code null and the output written so far.
+     * 504 timeout is left for the case where BoxRouter lost sight of the command and cannot
+     * say whether it ran. A disconnected HTTP client is not promised to end the command; the
+     * timeout ends it. Use process streaming for output without a bound.
+     * Generated clients take an opt-in check argument and raise CommandFailed (the operation's
+     * x-boxrouter-result-check) when exit_code is not 0 or timed_out is true.
+     *
+     */
+    run(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/sandboxes/{sandbox_id}/commands',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+}
+exports.Commands = Commands;
+class Files extends HeyApiClient {
+    /**
+     * Read exact file bytes
+     *
+     * You can rely on:
+     * - Returns complete bytes, or resource_limit with no prefix returned.
+     * - Reading a directory or another path that is not a regular file fails and returns no data.
+     * - An absent path is not_found, outcome failed: a read has no effect, so its outcome is never unknown.
+     *
+     * You can set: path.
+     *
+     * Not promised: consistency while another writer changes the file.
+     *
+     * The limit is the advertised limits.file_transfer_bytes. Bytes are not text-decoded.
+     * Closing the transfer does not destroy the sandbox. A stream that ends before
+     * Content-Length is an incomplete transfer, not a successful file read.
+     *
+     */
+    read(options) {
+        return (options.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/sandboxes/{sandbox_id}/files/content',
+            ...options
+        });
+    }
+    /**
+     * Read exact file bytes
+     *
+     * You can rely on:
+     * - Returns complete bytes, or resource_limit with no prefix returned.
+     * - Reading a directory or another path that is not a regular file fails and returns no data.
+     * - An absent path is not_found, outcome failed: a read has no effect, so its outcome is never unknown.
+     *
+     * You can set: path.
+     *
+     * Not promised: consistency while another writer changes the file.
+     *
+     * The limit is the advertised limits.file_transfer_bytes. Bytes are not text-decoded.
+     * Closing the transfer does not destroy the sandbox. A stream that ends before
+     * Content-Length is an incomplete transfer, not a successful file read.
+     *
+     */
+    readStream(options) {
+        return (options.client ?? this.client).get({
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/sandboxes/{sandbox_id}/files/content',
+            ...options,
+            parseAs: "binaryStream",
+            responseStyle: "fields"
+        });
+    }
+    /**
+     * Write exact file bytes
+     *
+     * You can rely on:
+     * - Writes exact bytes.
+     * - Creates missing parents.
+     * - A new file is readable and writable by the command user.
+     * - The size limit is enforced.
+     *
+     * You can set: path, data.
+     *
+     * Not promised: owner, mode or executable bit; atomic replace; whether a symbolic link at the path is followed or replaced.
+     *
+     * The limit is the advertised limits.file_transfer_bytes. A failed transfer may leave
+     * partial data; the error's outcome describes what is known. SDK text helpers must encode
+     * text as UTF-8 before transfer.
+     *
+     */
+    write(options) {
+        return (options.client ?? this.client).put({
+            bodySerializer: null,
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/sandboxes/{sandbox_id}/files/content',
+            ...options,
+            headers: {
+                'Content-Type': 'application/octet-stream',
+                ...options.headers
+            }
+        });
+    }
+    /**
+     * Create a sandbox file upload
+     *
+     * You can rely on:
+     * - A completed upload leaves exactly the declared bytes at the path; a body of another length is refused.
+     *
+     * You can set: path, size.
+     *
+     * Not promised: removing bytes already written when an upload is aborted.
+     *
+     * Starts an upload of a file of known size to an absolute path in a running sandbox. Send
+     * every returned part as described by its `TransferPart`, then call `completeSandboxUpload`
+     * with each part's response `ETag`, if any. BoxRouter chooses the `route`; it is
+     * informational and clients must not branch on it. Upload links and the session last up to
+     * six hours after creation; `expires_at` says when they end. Launch behaviour is always
+     * exactly one part. Idempotency-Key is required on create, complete and abort; repeat an
+     * uncertain call with the same key.
+     *
+     */
+    createUpload(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/sandboxes/{sandbox_id}/files/uploads',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+    /**
+     * Complete a sandbox file upload
+     *
+     * You can rely on:
+     * - A completed upload leaves exactly the declared bytes at the path; a body of another length is refused.
+     *
+     * You can set: path, size.
+     *
+     * Not promised: removing bytes already written when an upload is aborted.
+     *
+     * Supply each part number exactly once with the `ETag` header returned by its request, if
+     * it returned one. Repeating the call with the same idempotency key returns the same result.
+     *
+     */
+    completeUpload(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/sandboxes/{sandbox_id}/files/uploads/{upload_id}/complete',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+    /**
+     * Abort a sandbox file upload
+     *
+     * You can rely on:
+     * - A completed upload leaves exactly the declared bytes at the path; a body of another length is refused.
+     *
+     * You can set: path, size.
+     *
+     * Not promised: removing bytes already written when an upload is aborted.
+     *
+     * Idempotent.
+     *
+     */
+    abortUpload(options) {
+        return (options.client ?? this.client).delete({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/sandboxes/{sandbox_id}/files/uploads/{upload_id}',
+            ...options
+        });
+    }
+    /**
+     * Create a sandbox file download
+     *
+     * You can rely on:
+     * - A complete download returns exactly the file's bytes; a transfer that ends short fails instead of returning a prefix.
+     *
+     * You can set: path.
+     *
+     * Not promised: the file's size before the download starts.
+     *
+     * Creates a temporary download link for a file in a running sandbox. The link lasts up to
+     * one hour after creation; `expires_at` says when it ends. `route` is informational and
+     * clients must not branch on it.
+     *
+     */
+    createDownload(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/sandboxes/{sandbox_id}/files/downloads',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+    /**
+     * List the immediate entries of a directory
+     *
+     * You can rely on:
+     * - Returns every immediate entry, including hidden ones and broken symbolic links, sorted by name.
+     * - Each entry has its type (file, directory, symlink, other); a link is not followed.
+     * - More entries than the advertised limit fail; the list is never truncated.
+     *
+     * You can set: path.
+     *
+     * Not promised: metadata beyond the type; a consistent snapshot while the directory changes.
+     *
+     * An unreadable or missing directory fails; it does not appear empty. No recursion.
+     *
+     */
+    list(options) {
+        return (options.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/sandboxes/{sandbox_id}/files/directories',
+            ...options
+        });
+    }
+    /**
+     * Create a directory
+     *
+     * You can rely on:
+     * - parents=true (the default) creates missing parents and accepts an existing directory.
+     * - parents=false requires the parent and refuses an existing path.
+     *
+     * You can set: path, parents.
+     *
+     * Not promised: mode and owner beyond command-user usability.
+     *
+     * A failure may leave some parent directories created. An uncertain mutation is never automatically replayed.
+     *
+     */
+    mkdir(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/sandboxes/{sandbox_id}/files/directories',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+    /**
+     * Check for an accessible filesystem target
+     *
+     * You can rely on:
+     * - Follows symbolic links. True when the target exists; false when it is missing, the link is broken, or the target is not accessible.
+     * - A failure to check raises an error; it never reads as false.
+     *
+     * You can set: path.
+     *
+     * Not promised: whether the answer still holds after the call.
+     *
+     * Transport and command-startup failures remain errors. This read does not reserve the path or guarantee it remains present.
+     *
+     */
+    exists(options) {
+        return (options.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/sandboxes/{sandbox_id}/files/exists',
+            ...options
+        });
+    }
+    /**
+     * Remove a file, symbolic link or directory
+     *
+     * You can rely on:
+     * - Removes only the named entry.
+     * - A nonempty directory needs recursive.
+     * - A symbolic link, broken or not, is unlinked and its target kept.
+     * - A missing path fails.
+     * - The sandbox root is refused.
+     *
+     * You can set: path, recursive.
+     *
+     * Not promised: atomicity; partial progress after a failure.
+     *
+     * A final slash does not change which entry is removed. Failures may leave partial changes. An uncertain mutation is never automatically replayed.
+     *
+     */
+    remove(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/sandboxes/{sandbox_id}/files/remove',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+}
+exports.Files = Files;
+class Pricing extends HeyApiClient {
+    /**
+     * List the providers' live price versions
+     *
+     * Public: needs no key or session. Lists every live price version, which is what
+     * BoxRouter used to calculate sandbox costs, so a published cost can be
+     * rechecked without BoxRouter's database. Live versions never change. With `at`, returns
+     * only the version in effect at that time, one per provider; a provider with no version
+     * in effect then is left out. Effective periods include `effective_from` and exclude
+     * `effective_to` (`[effective_from, effective_to)`); the version taking over at a boundary
+     * applies at that instant.
+     *
+     */
+    versions(options) {
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            url: '/price-versions',
+            ...options
+        });
+    }
+}
+exports.Pricing = Pricing;
+class Providers extends HeyApiClient {
+    /**
+     * List available provider routes
+     *
+     * Returns only supply visible to the caller, including account-specific
+     * entitlements and limits. This is a point-in-time eligibility view, not a
+     * capacity reservation. Unknown or unverified capability guarantees are not
+     * advertised as supported. Server-side eligibility is rechecked at creation.
+     *
+     */
+    list(options) {
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/providers',
+            ...options
+        });
+    }
+}
+exports.Providers = Providers;
+class BoxRouterApi extends HeyApiClient {
+    static __registry = new HeyApiRegistry();
+    constructor(args) {
+        super(args);
+        BoxRouterApi.__registry.set(this, args?.key);
+    }
+    _agents;
+    get agents() {
+        return this._agents ??= new Agents({ client: this.client });
+    }
+    _launches;
+    get launches() {
+        return this._launches ??= new Launches({ client: this.client });
+    }
+    _launchRuns;
+    get launchRuns() {
+        return this._launchRuns ??= new LaunchRuns({ client: this.client });
+    }
+    _github;
+    get github() {
+        return this._github ??= new Github({ client: this.client });
+    }
+    _actions;
+    get actions() {
+        return this._actions ??= new Actions({ client: this.client });
+    }
+    _routing;
+    get routing() {
+        return this._routing ??= new Routing({ client: this.client });
+    }
+    _operations;
+    get operations() {
+        return this._operations ??= new Operations({ client: this.client });
+    }
+    _artifacts;
+    get artifacts() {
+        return this._artifacts ??= new Artifacts({ client: this.client });
+    }
+    _images;
+    get images() {
+        return this._images ??= new Images({ client: this.client });
+    }
+    _processes;
+    get processes() {
+        return this._processes ??= new Processes({ client: this.client });
+    }
+    _credits;
+    get credits() {
+        return this._credits ??= new Credits({ client: this.client });
+    }
+    _spendLimits;
+    get spendLimits() {
+        return this._spendLimits ??= new SpendLimits({ client: this.client });
+    }
+    _usage;
+    get usage() {
+        return this._usage ??= new Usage({ client: this.client });
+    }
+    _terminals;
+    get terminals() {
+        return this._terminals ??= new Terminals({ client: this.client });
+    }
+    _secrets;
+    get secrets() {
+        return this._secrets ??= new Secrets({ client: this.client });
+    }
+    _previews;
+    get previews() {
+        return this._previews ??= new Previews({ client: this.client });
+    }
+    _sandboxes;
+    get sandboxes() {
+        return this._sandboxes ??= new Sandboxes({ client: this.client });
+    }
+    _providerAccounts;
+    get providerAccounts() {
+        return this._providerAccounts ??= new ProviderAccounts({ client: this.client });
+    }
+    _volumes;
+    get volumes() {
+        return this._volumes ??= new Volumes({ client: this.client });
+    }
+    _commands;
+    get commands() {
+        return this._commands ??= new Commands({ client: this.client });
+    }
+    _files;
+    get files() {
+        return this._files ??= new Files({ client: this.client });
+    }
+    _pricing;
+    get pricing() {
+        return this._pricing ??= new Pricing({ client: this.client });
+    }
+    _providers;
+    get providers() {
+        return this._providers ??= new Providers({ client: this.client });
+    }
+}
+exports.BoxRouterApi = BoxRouterApi;