@boxrouter/sdk 0.0.0-stage → 0.12.190

package/dist/namespace-sandboxes.mjs

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

package/dist/namespace-secrets.d.mts

@@ -0,0 +1,46 @@
+import type { Client, ClientMeta, Options as Options2, RequestResult, TDataShape } from './client/index.js';
+import { HeyApiClient } from './namespace-base.mjs';
+import type { SecretsDeleteData, SecretsDeleteErrors, SecretsDeleteResponses, SecretsListData, SecretsListErrors, SecretsListResponses, SecretsPutData, SecretsPutErrors, SecretsPutResponses } 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 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<ThrowOnError extends boolean = true>(options?: Options<SecretsListData, ThrowOnError>): RequestResult<SecretsListResponses, SecretsListErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = true>(options: Options<SecretsDeleteData, ThrowOnError>): RequestResult<SecretsDeleteResponses, SecretsDeleteErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = true>(options: Options<SecretsPutData, ThrowOnError>): RequestResult<SecretsPutResponses, SecretsPutErrors, ThrowOnError, 'data'>;
+}

package/dist/namespace-secrets.mjs

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

package/dist/namespace-spend_limits.d.mts

@@ -0,0 +1,48 @@
+import type { Client, ClientMeta, Options as Options2, RequestResult, TDataShape } from './client/index.js';
+import { HeyApiClient } from './namespace-base.mjs';
+import type { SpendLimitsClearData, SpendLimitsClearErrors, SpendLimitsClearResponses, SpendLimitsListData, SpendLimitsListErrors, SpendLimitsListResponses, SpendLimitsSetData, SpendLimitsSetErrors, SpendLimitsSetResponses } 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 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<ThrowOnError extends boolean = true>(options?: Options<SpendLimitsListData, ThrowOnError>): RequestResult<SpendLimitsListResponses, SpendLimitsListErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = true>(options: Options<SpendLimitsClearData, ThrowOnError>): RequestResult<SpendLimitsClearResponses, SpendLimitsClearErrors, ThrowOnError, 'data'>;
+    /**
+     * 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<ThrowOnError extends boolean = true>(options: Options<SpendLimitsSetData, ThrowOnError>): RequestResult<SpendLimitsSetResponses, SpendLimitsSetErrors, ThrowOnError, 'data'>;
+}

package/dist/namespace-spend_limits.mjs

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