@boxrouter/sdk 0.0.0-stage → 0.12.190

package/dist/namespace-launch_runs.mjs

@@ -0,0 +1,133 @@
+import { HeyApiClient } from './namespace-base.mjs';
+export 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
+        });
+    }
+}

package/dist/namespace-launches.d.mts

@@ -0,0 +1,89 @@
+import type { Client, ClientMeta, Options as Options2, RequestResult, TDataShape } from './client/index.js';
+import { HeyApiClient } from './namespace-base.mjs';
+import type { LaunchesCheckRepositoryAccessData, LaunchesCheckRepositoryAccessErrors, LaunchesCheckRepositoryAccessResponses, LaunchesCreateData, LaunchesCreateErrors, LaunchesCreateResponses, LaunchesGetCommandData, LaunchesGetCommandErrors, LaunchesGetCommandResponses, LaunchesGetOperationData, LaunchesGetOperationErrors, LaunchesGetOperationResponses, LaunchesGetSettingsData, LaunchesGetSettingsErrors, LaunchesGetSettingsResponses } from './types.gen.js';
+export type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown> = Options2<TData, ThrowOnError, TResponse> & {
+    /**
+     * You can provide a client instance returned by `createClient()` instead of
+     * individual options. This might be also useful if you want to implement a
+     * custom client.
+     */
+    client?: Client;
+    /**
+     * You can pass arbitrary values through the `meta` object. This can be
+     * used to access values that aren't defined as part of the SDK function.
+     */
+    meta?: keyof ClientMeta extends never ? Record<string, unknown> : ClientMeta;
+};
+export declare 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<ThrowOnError extends boolean = true>(options: Options<LaunchesCreateData, ThrowOnError>): RequestResult<LaunchesCreateResponses, LaunchesCreateErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = true>(options: Options<LaunchesGetOperationData, ThrowOnError>): RequestResult<LaunchesGetOperationResponses, LaunchesGetOperationErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = true>(options: Options<LaunchesGetSettingsData, ThrowOnError>): RequestResult<LaunchesGetSettingsResponses, LaunchesGetSettingsErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = true>(options: Options<LaunchesGetCommandData, ThrowOnError>): RequestResult<LaunchesGetCommandResponses, LaunchesGetCommandErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = true>(options: Options<LaunchesCheckRepositoryAccessData, ThrowOnError>): RequestResult<LaunchesCheckRepositoryAccessResponses, LaunchesCheckRepositoryAccessErrors, ThrowOnError, 'data'>;
+}

package/dist/namespace-launches.mjs

@@ -0,0 +1,133 @@
+import { HeyApiClient } from './namespace-base.mjs';
+export 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
+        });
+    }
+}

package/dist/namespace-operations.d.mts

@@ -0,0 +1,45 @@
+import type { Client, ClientMeta, Options as Options2, RequestResult, TDataShape } from './client/index.js';
+import { HeyApiClient } from './namespace-base.mjs';
+import type { OperationsGetData, OperationsGetErrors, OperationsGetResponses, OperationsListData, OperationsListErrors, OperationsListResponses } from './types.gen.js';
+export type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown> = Options2<TData, ThrowOnError, TResponse> & {
+    /**
+     * You can provide a client instance returned by `createClient()` instead of
+     * individual options. This might be also useful if you want to implement a
+     * custom client.
+     */
+    client?: Client;
+    /**
+     * You can pass arbitrary values through the `meta` object. This can be
+     * used to access values that aren't defined as part of the SDK function.
+     */
+    meta?: keyof ClientMeta extends never ? Record<string, unknown> : ClientMeta;
+};
+export declare 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<ThrowOnError extends boolean = true>(options?: Options<OperationsListData, ThrowOnError>): RequestResult<OperationsListResponses, OperationsListErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = true>(options: Options<OperationsGetData, ThrowOnError>): RequestResult<OperationsGetResponses, OperationsGetErrors, ThrowOnError, 'data'>;
+}

package/dist/namespace-operations.mjs

@@ -0,0 +1,52 @@
+import { HeyApiClient } from './namespace-base.mjs';
+export 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
+        });
+    }
+}

package/dist/namespace-previews.d.mts

@@ -0,0 +1,79 @@
+import type { Client, ClientMeta, Options as Options2, RequestResult, TDataShape } from './client/index.js';
+import { HeyApiClient } from './namespace-base.mjs';
+import type { PreviewsListData, PreviewsListErrors, PreviewsListResponses, PreviewsOpenData, PreviewsOpenErrors, PreviewsOpenResponses, PreviewsRevokeData, PreviewsRevokeErrors, PreviewsRevokeResponses } from './types.gen.js';
+export type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown> = Options2<TData, ThrowOnError, TResponse> & {
+    /**
+     * You can provide a client instance returned by `createClient()` instead of
+     * individual options. This might be also useful if you want to implement a
+     * custom client.
+     */
+    client?: Client;
+    /**
+     * You can pass arbitrary values through the `meta` object. This can be
+     * used to access values that aren't defined as part of the SDK function.
+     */
+    meta?: keyof ClientMeta extends never ? Record<string, unknown> : ClientMeta;
+};
+export declare 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<ThrowOnError extends boolean = true>(options: Options<PreviewsListData, ThrowOnError>): RequestResult<PreviewsListResponses, PreviewsListErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = true>(options: Options<PreviewsOpenData, ThrowOnError>): RequestResult<PreviewsOpenResponses, PreviewsOpenErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = true>(options: Options<PreviewsRevokeData, ThrowOnError>): RequestResult<PreviewsRevokeResponses, PreviewsRevokeErrors, ThrowOnError, 'data'>;
+}

package/dist/namespace-previews.mjs

@@ -0,0 +1,101 @@
+import { HeyApiClient } from './namespace-base.mjs';
+export 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
+        });
+    }
+}