@usestatemachines/sdk 0.2.0 → 0.3.0

package/esm/extensions/client.js

@@ -1,20 +1,14 @@
 import { SDK_METADATA } from '../lib/config.js';
 import { HTTPClient } from '../lib/http.js';
 import { StateMachines as Generated } from '../sdk/sdk.js';
-import { expandApps } from './apps.js';
+import { expandSource } from './apps.js';
 import { Connection } from './connection.js';
-import { EnvironmentFailedError, StateMachinesError, TimeoutError, toStateMachinesError, } from './errors.js';
+import { CallerAbortedError, EnvironmentFailedError, SnapshotFailedError, SnapshotTimeoutError, StateMachinesError, TimeoutError, toStateMachinesError, } from './errors.js';
 import { RunningEnvironment } from './running-environment.js';
 import { linkSignal } from './signal.js';
-import { defaultTimeoutMs, disposed, poll, ready, } from './wait.js';
+import { backoff, defaultTimeoutMs, disposed, poll, pollUntil, ready, sleep, snapshotReady, } from './wait.js';
 const stopAfterFailureMs = 30000;
-/** Thrown from a hook so the generated retry loop stops, whatever the abort reason. */
-class CallerAbortedError extends Error {
-    name = 'CallerAbortedError';
-    constructor(reason) {
-        super('The caller aborted the request.', { cause: reason });
-    }
-}
+const busyBudgetMs = 60000;
 export class StateMachines {
     #sdk;
     #fetch;
@@ -117,7 +111,7 @@ export class StateMachines {
         create: async (input, options = {}) => {
             const idempotencyKey = options.idempotencyKey ?? crypto.randomUUID();
             try {
-                const body = expandApps(input);
+                const body = expandSource(input);
                 return await this.#call(options, async (call) => {
                     const workspaceId = await this.#workspace(options.workspaceId, call.signal);
                     const { data } = await this.#sdk.environments.create({ workspaceId, idempotencyKey, body }, call);
@@ -163,6 +157,97 @@ export class StateMachines {
             return new Connection(details.baseUrl, api, secret, this.#fetch);
         },
     };
+    snapshots = {
+        /** Returns the API's answer at once: it may still be `capturing`. */
+        create: (environmentId, input = {}, options = {}) => this.#createSnapshot(environmentId, input, options, 0),
+        /**
+         * Creates a snapshot and waits until it's `ready`. Needs `snapshots:create` and
+         * `snapshots:read`. A failed or timed-out snapshot is never deleted: the error
+         * carries `snapshotId` and `idempotencyKey`.
+         */
+        capture: async (environmentId, input = {}, options = {}) => {
+            const { readyTimeoutMs, ...createOptions } = options;
+            const { signal } = options;
+            const idempotencyKey = options.idempotencyKey ?? crypto.randomUUID();
+            const timeoutMs = readyTimeoutMs ?? defaultTimeoutMs;
+            if (!(timeoutMs > 0)) {
+                throw new RangeError('readyTimeoutMs must be more than 0.');
+            }
+            const created = await this.#createSnapshot(environmentId, input, { ...createOptions, idempotencyKey }, busyBudgetMs);
+            try {
+                signal?.throwIfAborted();
+                if (snapshotReady(created)) {
+                    return created;
+                }
+                return await this.snapshots.waitUntilReady(created.id, {
+                    timeoutMs,
+                    ...(signal ? { signal } : {}),
+                });
+            }
+            catch (error) {
+                const snapshotId = created.id;
+                if (signal?.aborted && Object.is(error, signal.reason)) {
+                    throw Object.assign(new StateMachinesError(new CallerAbortedError(error), {
+                        idempotencyKey,
+                    }), { snapshotId });
+                }
+                if (error instanceof StateMachinesError ||
+                    error instanceof SnapshotFailedError ||
+                    error instanceof SnapshotTimeoutError) {
+                    Object.assign(error, { snapshotId, idempotencyKey });
+                }
+                throw error;
+            }
+        },
+        /** Resolves when the snapshot is `ready`. Never deletes it. */
+        waitUntilReady: (snapshotId, options) => pollUntil((signal) => this.#unwrap({ signal }, (call) => this.#sdk.snapshots.get({ snapshotId }, { ...call, retries: { strategy: 'none' } })), snapshotReady, options, (timeoutMs, last) => new SnapshotTimeoutError(timeoutMs, last, snapshotId)),
+        /** Deleted snapshots too, with `deletedAt` set. */
+        get: (snapshotId, options) => this.#unwrap(options, (call) => this.#sdk.snapshots.get({ snapshotId }, call)),
+        /** Newest first. Deleted snapshots are left out. */
+        list: (query = {}, options) => this.#call(options, async (call) => {
+            const { workspaceId, ...filters } = query;
+            const resolved = await this.#workspace(workspaceId, call.signal);
+            return this.#sdk.snapshots.list({ ...filters, workspaceId: resolved }, call);
+        }),
+        /**
+         * `null` clears the name. A stale `expectedVersion`, or a deleted snapshot, is a 409
+         * `version-conflict`; so is a retry of a rename whose first answer was lost.
+         */
+        rename: (snapshotId, body, options) => this.#unwrap(options, (call) => this.#sdk.snapshots.update({ snapshotId, body }, call)),
+        /** Marks the snapshot deleted and returns it; safe to repeat. A capturing snapshot is a 409 `not-ready`. */
+        delete: (snapshotId, options) => this.#unwrap(options, (call) => this.#sdk.snapshots.delete({ snapshotId }, call)),
+    };
+    async #createSnapshot(environmentId, input, options, busyMs) {
+        const idempotencyKey = options.idempotencyKey ?? crypto.randomUUID();
+        try {
+            return await this.#call(options, async (call) => {
+                const workspaceId = await this.#workspace(options.workspaceId, call.signal);
+                const request = {
+                    workspaceId,
+                    idempotencyKey,
+                    body: { ...input, environmentId },
+                };
+                const deadline = Date.now() + busyMs;
+                for (let attempt = 0;; attempt += 1) {
+                    try {
+                        return (await this.#sdk.snapshots.capture(request, call)).data;
+                    }
+                    catch (error) {
+                        const busy = toStateMachinesError(error);
+                        const waitMs = Math.max(busy.retryAfter ?? 0, backoff(attempt));
+                        if (busy.code !== 'snapshot-limit' ||
+                            Date.now() + waitMs >= deadline) {
+                            throw error;
+                        }
+                        await sleep(waitMs, call.signal);
+                    }
+                }
+            });
+        }
+        catch (error) {
+            throw new StateMachinesError(error, { idempotencyKey });
+        }
+    }
     #reveal(environmentId, appKey, body, options) {
         return this.#unwrap(options, (call) => this.#sdk.environments.reveal({ environmentId, appKey, body }, call));
     }

package/esm/extensions/errors.d.ts

@@ -1,4 +1,5 @@
 import type { Environment } from '../models/environment.js';
+import type { EnvironmentSnapshot } from '../models/environment-snapshot.js';
 import type { Code } from '../models/error-response.js';
 /** What `environments.start()` adds to the error it rethrows after a failed wait. */
 export interface StartFailure {
@@ -30,6 +31,8 @@ export declare class StateMachinesError extends Error implements Details, StartF
     readonly environmentId?: string;
     readonly stopped?: boolean;
     readonly stopError?: unknown;
+    /** Set when `snapshots.capture()` fails after the snapshot was created. */
+    readonly snapshotId?: string;
     readonly status: number | null;
     readonly code: Code | null;
     readonly requestId: string | null;
@@ -38,7 +41,7 @@ export declare class StateMachinesError extends Error implements Details, StartF
     readonly retryAfter: number | null;
     /** Transient: a 502, 503 or 504, or the request never got a response. */
     readonly retryable: boolean;
-    /** Set on `environments.create` failures; replay the create with it to recover. */
+    /** Set on create and capture failures. A replay with it returns the same result, so use it when the outcome is unknown. */
     readonly idempotencyKey?: string;
     /** Wraps any thrown value. Wrapping a `StateMachinesError` copies it, keeping its cause. */
     constructor(error: unknown, extra?: {
@@ -68,4 +71,26 @@ export declare class TimeoutError extends Error implements StartFailure {
     readonly stopError?: unknown;
     constructor(timeoutMs: number, environment: Environment | null);
 }
+/** Thrown from a hook so the generated retry loop stops, whatever the abort reason. */
+export declare class CallerAbortedError extends Error {
+    readonly name = "CallerAbortedError";
+    constructor(reason: unknown);
+}
+/** A snapshot that ended `failed`, or was deleted, while the SDK waited for `ready`. */
+export declare class SnapshotFailedError extends Error {
+    readonly snapshot: EnvironmentSnapshot;
+    readonly name = "SnapshotFailedError";
+    readonly snapshotId: string;
+    readonly idempotencyKey?: string;
+    constructor(snapshot: EnvironmentSnapshot);
+}
+/** The wait for `ready` passed its deadline. The capture may still finish on the server. */
+export declare class SnapshotTimeoutError extends Error {
+    readonly timeoutMs: number;
+    readonly snapshot: EnvironmentSnapshot | null;
+    readonly snapshotId: string;
+    readonly name = "SnapshotTimeoutError";
+    readonly idempotencyKey?: string;
+    constructor(timeoutMs: number, snapshot: EnvironmentSnapshot | null, snapshotId: string);
+}
 export {};

package/esm/extensions/errors.js

@@ -17,7 +17,7 @@ export class StateMachinesError extends Error {
     retryAfter;
     /** Transient: a 502, 503 or 504, or the request never got a response. */
     retryable;
-    /** Set on `environments.create` failures; replay the create with it to recover. */
+    /** Set on create and capture failures. A replay with it returns the same result, so use it when the outcome is unknown. */
     idempotencyKey;
     /** Wraps any thrown value. Wrapping a `StateMachinesError` copies it, keeping its cause. */
     constructor(error, extra = {}) {
@@ -128,3 +128,36 @@ export class TimeoutError extends Error {
         this.environment = environment;
     }
 }
+/** Thrown from a hook so the generated retry loop stops, whatever the abort reason. */
+export class CallerAbortedError extends Error {
+    name = 'CallerAbortedError';
+    constructor(reason) {
+        super('The caller aborted the request.', { cause: reason });
+    }
+}
+/** A snapshot that ended `failed`, or was deleted, while the SDK waited for `ready`. */
+export class SnapshotFailedError extends Error {
+    snapshot;
+    name = 'SnapshotFailedError';
+    snapshotId;
+    constructor(snapshot) {
+        super(snapshot.status === 'failed'
+            ? `Snapshot ${snapshot.id} is failed (${snapshot.errorCode ?? 'no error code'}).`
+            : `Snapshot ${snapshot.id} was deleted.`);
+        this.snapshot = snapshot;
+        this.snapshotId = snapshot.id;
+    }
+}
+/** The wait for `ready` passed its deadline. The capture may still finish on the server. */
+export class SnapshotTimeoutError extends Error {
+    timeoutMs;
+    snapshot;
+    snapshotId;
+    name = 'SnapshotTimeoutError';
+    constructor(timeoutMs, snapshot, snapshotId) {
+        super(`Timed out after ${timeoutMs} ms waiting for snapshot ${snapshotId}.`);
+        this.timeoutMs = timeoutMs;
+        this.snapshot = snapshot;
+        this.snapshotId = snapshotId;
+    }
+}

package/esm/extensions/index.d.ts

@@ -1,13 +1,13 @@
 export type { Fetcher, HTTPClientOptions } from '../lib/http.js';
 export { HTTPClient } from '../lib/http.js';
 export { ConnectionError, ErrorResponse, HTTPClientError, InvalidRequestError, RequestAbortedError, RequestTimeoutError, ResponseValidationError, SDKValidationError, StateMachinesHTTPError, UnexpectedClientError, UnexpectedResponseError, } from '../models/errors/index.js';
-export type { ApiProfile, App, Catalog, Connection as ConnectionDetails, ConnectionSecret, CreateEnvironmentInput, Credential, Environment, EnvironmentApp, Event, EventPage, Release, ReleaseActor, Workspace, } from '../models/index.js';
+export type { ApiProfile, App, AppInstanceSnapshot, Catalog, Connection as ConnectionDetails, ConnectionSecret, CreateEnvironmentInput, Credential, Environment, EnvironmentApp, EnvironmentSnapshot, Event, EventPage, Release, ReleaseActor, Workspace, } from '../models/index.js';
 export { Code as ErrorCode, Disposal, EnvironmentStatus, StopReason, } from '../models/index.js';
 export { Status as EnvironmentListStatus } from '../models/operations/list-environments.js';
-export type { AppInput, EnvironmentInput } from './apps.js';
-export type { CallOptions, ConnectOptions, CreateOptions, ListEnvironmentsQuery, Page, StartOptions, StateMachinesOptions, } from './client.js';
+export type { AppInput, EnvironmentInput, SnapshotEnvironmentInput, } from './apps.js';
+export type { CallOptions, CaptureInput, CaptureOptions, ConnectOptions, CreateOptions, ListEnvironmentsQuery, ListSnapshotsQuery, Page, StartOptions, StateMachinesOptions, } from './client.js';
 export { StateMachines } from './client.js';
 export { Connection, formatActorHeader } from './connection.js';
-export { DisposalIncompleteError, EnvironmentFailedError, StateMachinesError, TimeoutError, } from './errors.js';
+export { DisposalIncompleteError, EnvironmentFailedError, SnapshotFailedError, SnapshotTimeoutError, StateMachinesError, TimeoutError, } from './errors.js';
 export { RunningEnvironment } from './running-environment.js';
 export type { WaitOptions } from './wait.js';

package/esm/extensions/index.js

@@ -4,5 +4,5 @@ export { Code as ErrorCode, Disposal, EnvironmentStatus, StopReason, } from '../
 export { Status as EnvironmentListStatus } from '../models/operations/list-environments.js';
 export { StateMachines } from './client.js';
 export { Connection, formatActorHeader } from './connection.js';
-export { DisposalIncompleteError, EnvironmentFailedError, StateMachinesError, TimeoutError, } from './errors.js';
+export { DisposalIncompleteError, EnvironmentFailedError, SnapshotFailedError, SnapshotTimeoutError, StateMachinesError, TimeoutError, } from './errors.js';
 export { RunningEnvironment } from './running-environment.js';

package/esm/extensions/running-environment.d.ts

@@ -1,6 +1,7 @@
 import type { Environment } from '../models/environment.js';
+import type { EnvironmentSnapshot } from '../models/environment-snapshot.js';
 import type { ReleaseActor } from '../models/release-actor.js';
-import type { CallOptions, ConnectOptions, StateMachines } from './client.js';
+import type { CallOptions, CaptureInput, CaptureOptions, ConnectOptions, StateMachines } from './client.js';
 import type { Connection } from './connection.js';
 import type { WaitOptions } from './wait.js';
 /** A started environment. It remains the handle after `stop()`. */
@@ -18,6 +19,8 @@ export declare class RunningEnvironment {
     connect(appKey: string, options?: ConnectOptions): Promise<Connection>;
     /** The app's users, in the release's order. */
     actors(appKey: string, options?: CallOptions): Promise<ReleaseActor[]>;
+    /** Captures a snapshot in the environment's own workspace and waits until it's `ready`. */
+    snapshot(input?: CaptureInput, options?: CaptureOptions): Promise<EnvironmentSnapshot>;
     /** Safe to call twice. Doesn't wait for disposal: use `waitUntilStopped()`. */
     stop(options?: CallOptions): Promise<Environment>;
     /** Resolves when the environment ended and every sandbox is confirmed disposed. */

package/esm/extensions/running-environment.js

@@ -4,10 +4,12 @@ export class RunningEnvironment {
     /** The record when `start()` resolved. Use `sm.environments.get(id)` for fresh state. */
     environment;
     #environments;
+    #snapshots;
     constructor(sm, environment) {
         this.id = environment.id;
         this.environment = environment;
         this.#environments = sm.environments;
+        this.#snapshots = sm.snapshots;
     }
     /**
      * actorId defaults to the actor of the environment's declared default connection, or
@@ -21,6 +23,13 @@ export class RunningEnvironment {
     actors(appKey, options) {
         return this.#environments.actors(this.id, appKey, options);
     }
+    /** Captures a snapshot in the environment's own workspace and waits until it's `ready`. */
+    snapshot(input, options = {}) {
+        return this.#snapshots.capture(this.id, input, {
+            ...options,
+            workspaceId: options.workspaceId ?? this.environment.workspaceId,
+        });
+    }
     /** Safe to call twice. Doesn't wait for disposal: use `waitUntilStopped()`. */
     stop(options) {
         return this.#environments.stop(this.id, options);

package/esm/extensions/wait.d.ts

@@ -1,20 +1,27 @@
 import type { Environment } from '../models/environment.js';
+import type { EnvironmentSnapshot } from '../models/environment-snapshot.js';
 export interface WaitOptions {
     /** Overall deadline for the wait. Defaults to 10 minutes. */
     timeoutMs?: number;
     /** Aborting rejects the wait with `signal.reason`. */
     signal?: AbortSignal;
 }
-type Read = (signal: AbortSignal) => Promise<Environment>;
-type Decide = (environment: Environment) => boolean;
+type Read<T> = (signal: AbortSignal) => Promise<T>;
+type Decide<T> = (value: T) => boolean;
 export declare const defaultTimeoutMs = 600000;
+export declare function poll(read: Read<Environment>, done: Decide<Environment>, options?: WaitOptions): Promise<Environment>;
 /**
  * Reads until `done` returns true. `done` throws to end the wait with a failure.
  * Transient read failures are retried with backoff until the deadline.
  */
-export declare function poll(read: Read, done: Decide, options?: WaitOptions): Promise<Environment>;
+export declare function pollUntil<T>(read: Read<T>, done: Decide<T>, options: WaitOptions | undefined, timeout: (timeoutMs: number, last: T | null) => Error): Promise<T>;
 /** Resolves on `running`. Never stops the environment. */
 export declare function ready(environment: Environment): boolean;
 /** Resolves once the environment ended and every app's sandbox is confirmed disposed. */
 export declare function disposed(environment: Environment): boolean;
+/** Resolves on `ready`. A failed or deleted snapshot ends the wait. */
+export declare function snapshotReady(snapshot: EnvironmentSnapshot): boolean;
+/** 1 s × 1.5ⁿ, capped at 5 s, with ±20% jitter. */
+export declare function backoff(attempt: number): number;
+export declare function sleep(ms: number, signal: AbortSignal | null | undefined): Promise<void>;
 export {};

package/esm/extensions/wait.js

@@ -1,12 +1,15 @@
-import { DisposalIncompleteError, EnvironmentFailedError, TimeoutError, toStateMachinesError, } from './errors.js';
+import { DisposalIncompleteError, EnvironmentFailedError, SnapshotFailedError, TimeoutError, toStateMachinesError, } from './errors.js';
 import { linkSignal } from './signal.js';
 export const defaultTimeoutMs = 600000;
 const readTimeoutMs = 30000;
+export function poll(read, done, options) {
+    return pollUntil(read, done, options, (timeoutMs, last) => new TimeoutError(timeoutMs, last));
+}
 /**
  * Reads until `done` returns true. `done` throws to end the wait with a failure.
  * Transient read failures are retried with backoff until the deadline.
  */
-export async function poll(read, done, options = {}) {
+export async function pollUntil(read, done, options = {}, timeout) {
     const { signal } = options;
     const timeoutMs = options.timeoutMs ?? defaultTimeoutMs;
     if (!(timeoutMs >= 0)) {
@@ -18,20 +21,20 @@ export async function poll(read, done, options = {}) {
         signal?.throwIfAborted();
         const remaining = deadline - Date.now();
         if (remaining <= 0) {
-            throw new TimeoutError(timeoutMs, last);
+            throw timeout(timeoutMs, last);
         }
         let waitMs = backoff(attempt);
-        let environment = null;
+        let value = null;
         const link = linkSignal(signal, Math.min(readTimeoutMs, remaining));
         try {
-            environment = await read(link.signal);
-            last = environment;
+            value = await read(link.signal);
+            last = value;
         }
         catch (error) {
             // Classify by signal state: a stalled body read surfaces as an arbitrary error.
             signal?.throwIfAborted();
             if (Date.now() >= deadline) {
-                throw new TimeoutError(timeoutMs, last);
+                throw timeout(timeoutMs, last);
             }
             if (!link.signal.aborted) {
                 const failure = toStateMachinesError(error);
@@ -47,10 +50,10 @@ export async function poll(read, done, options = {}) {
         // A read can settle after an abort or past the deadline; neither may resolve the wait.
         signal?.throwIfAborted();
         if (Date.now() >= deadline) {
-            throw new TimeoutError(timeoutMs, last);
+            throw timeout(timeoutMs, last);
         }
-        if (environment && done(environment)) {
-            return environment;
+        if (value !== null && done(value)) {
+            return value;
         }
         await sleep(Math.min(waitMs, deadline - Date.now()), signal);
     }
@@ -79,11 +82,18 @@ export function disposed(environment) {
     }
     return environment.apps.every((app) => app.disposal === 'complete');
 }
+/** Resolves on `ready`. A failed or deleted snapshot ends the wait. */
+export function snapshotReady(snapshot) {
+    if (snapshot.status === 'failed' || snapshot.deletedAt) {
+        throw new SnapshotFailedError(snapshot);
+    }
+    return snapshot.status === 'ready';
+}
 /** 1 s × 1.5ⁿ, capped at 5 s, with ±20% jitter. */
-function backoff(attempt) {
+export function backoff(attempt) {
     return Math.min(5000, 1000 * 1.5 ** attempt) * (0.8 + Math.random() * 0.4);
 }
-function sleep(ms, signal) {
+export function sleep(ms, signal) {
     return new Promise((resolve, reject) => {
         if (signal?.aborted) {
             reject(signal.reason);

package/esm/funcs/environments-list.js

@@ -34,6 +34,7 @@ async function $do(client, request, options) {
         "label": payload.label,
         "limit": payload.limit,
         "search": payload.search,
+        "snapshotId": payload.snapshotId,
         "status": payload.status,
     });
     const headers = new Headers(compactMap({

package/esm/funcs/snapshots-capture.d.ts

@@ -0,0 +1,11 @@
+import { StateMachinesCore } from "../core.js";
+import { RequestOptions } from "../lib/sdks.js";
+import { ConnectionError, InvalidRequestError, RequestAbortedError, RequestTimeoutError, UnexpectedClientError } from "../models/errors/http-client-errors.js";
+import * as errors from "../models/errors/index.js";
+import { ResponseValidationError } from "../models/errors/response-validation-error.js";
+import { SDKValidationError } from "../models/errors/sdk-validation-error.js";
+import { StateMachinesHTTPError } from "../models/errors/state-machines-http-error.js";
+import * as operations from "../models/operations/index.js";
+import { APIPromise } from "../types/async.js";
+import { Result } from "../types/fp.js";
+export declare function snapshotsCapture(client: StateMachinesCore, request: operations.CaptureSnapshotRequest, options?: RequestOptions): APIPromise<Result<operations.CaptureSnapshotResponse, errors.ErrorResponse | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;

package/esm/funcs/snapshots-capture.js

@@ -0,0 +1,94 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4-mini";
+import { encodeJSON, encodeSimple } from "../lib/encodings.js";
+import { matchStatusCode } from "../lib/http.js";
+import * as M from "../lib/matchers.js";
+import { compactMap } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
+import { pathToFunc } from "../lib/url.js";
+import * as errors from "../models/errors/index.js";
+import * as operations from "../models/operations/index.js";
+import { APIPromise } from "../types/async.js";
+export function snapshotsCapture(client, request, options) {
+    return new APIPromise($do(client, request, options));
+}
+async function $do(client, request, options) {
+    const parsed = safeParse(request, (value) => z.parse(operations.CaptureSnapshotRequest$outboundSchema, value), "Input validation failed");
+    if (!parsed.ok) {
+        return [parsed, { status: "invalid" }];
+    }
+    const payload = parsed.value;
+    const body = encodeJSON("body", payload.body, { explode: true });
+    const pathParams = {
+        workspaceId: encodeSimple("workspaceId", payload.workspaceId, {
+            explode: false,
+            charEncoding: "percent",
+        }),
+    };
+    const path = pathToFunc("/v1/workspaces/{workspaceId}/snapshots")(pathParams);
+    const headers = new Headers(compactMap({
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        "idempotency-key": encodeSimple("idempotency-key", payload["idempotency-key"], { explode: false, charEncoding: "none" }),
+    }));
+    const secConfig = await extractSecurity(client._options.apiKey);
+    const securityInput = secConfig == null ? {} : { apiKey: secConfig };
+    const requestSecurity = resolveGlobalSecurity(securityInput);
+    const context = {
+        options: client._options,
+        baseURL: options?.serverURL ?? client._baseURL ?? "",
+        operationID: "captureSnapshot",
+        oAuth2Scopes: null,
+        resolvedSecurity: requestSecurity,
+        securitySource: client._options.apiKey,
+        retryConfig: options?.retries
+            || client._options.retryConfig
+            || {
+                strategy: "backoff",
+                backoff: {
+                    initialInterval: 1000,
+                    maxInterval: 5000,
+                    exponent: 1.5,
+                    maxElapsedTime: 600000,
+                },
+                retryConnectionErrors: true,
+            }
+            || { strategy: "none" },
+        retryCodes: options?.retryCodes || ["502", "503", "504"],
+    };
+    const requestRes = client._createRequest(context, {
+        security: requestSecurity,
+        method: "POST",
+        baseURL: options?.serverURL,
+        path: path,
+        headers: headers,
+        body: body,
+        userAgent: client._options.userAgent,
+        timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1,
+    }, options);
+    if (!requestRes.ok) {
+        return [requestRes, { status: "invalid" }];
+    }
+    const req = requestRes.value;
+    const doResult = await client._do(req, {
+        context,
+        isErrorStatusCode: (statusCode) => matchStatusCode({ status: statusCode }, ["4XX", "5XX"]),
+        retryConfig: context.retryConfig,
+        retryCodes: context.retryCodes,
+    });
+    if (!doResult.ok) {
+        return [doResult, { status: "request-error", request: req }];
+    }
+    const response = doResult.value;
+    const responseFields = {
+        HttpMeta: { Response: response, Request: req },
+    };
+    const [result] = await M.match(M.json(202, operations.CaptureSnapshotResponse$inboundSchema), M.jsonErr([400, 401, 403, 404, 409, 413, 422, 429], errors.ErrorResponse$inboundSchema), M.jsonErr([500, 503], errors.ErrorResponse$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    if (!result.ok) {
+        return [result, { status: "complete", request: req, response }];
+    }
+    return [result, { status: "complete", request: req, response }];
+}

package/esm/funcs/snapshots-delete.d.ts

@@ -0,0 +1,11 @@
+import { StateMachinesCore } from "../core.js";
+import { RequestOptions } from "../lib/sdks.js";
+import { ConnectionError, InvalidRequestError, RequestAbortedError, RequestTimeoutError, UnexpectedClientError } from "../models/errors/http-client-errors.js";
+import * as errors from "../models/errors/index.js";
+import { ResponseValidationError } from "../models/errors/response-validation-error.js";
+import { SDKValidationError } from "../models/errors/sdk-validation-error.js";
+import { StateMachinesHTTPError } from "../models/errors/state-machines-http-error.js";
+import * as operations from "../models/operations/index.js";
+import { APIPromise } from "../types/async.js";
+import { Result } from "../types/fp.js";
+export declare function snapshotsDelete(client: StateMachinesCore, request: operations.DeleteSnapshotRequest, options?: RequestOptions): APIPromise<Result<operations.DeleteSnapshotResponse, errors.ErrorResponse | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;

package/esm/funcs/snapshots-delete.js

@@ -0,0 +1,92 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4-mini";
+import { encodeSimple } from "../lib/encodings.js";
+import { matchStatusCode } from "../lib/http.js";
+import * as M from "../lib/matchers.js";
+import { compactMap } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
+import { pathToFunc } from "../lib/url.js";
+import * as errors from "../models/errors/index.js";
+import * as operations from "../models/operations/index.js";
+import { APIPromise } from "../types/async.js";
+export function snapshotsDelete(client, request, options) {
+    return new APIPromise($do(client, request, options));
+}
+async function $do(client, request, options) {
+    const parsed = safeParse(request, (value) => z.parse(operations.DeleteSnapshotRequest$outboundSchema, value), "Input validation failed");
+    if (!parsed.ok) {
+        return [parsed, { status: "invalid" }];
+    }
+    const payload = parsed.value;
+    const body = null;
+    const pathParams = {
+        snapshotId: encodeSimple("snapshotId", payload.snapshotId, {
+            explode: false,
+            charEncoding: "percent",
+        }),
+    };
+    const path = pathToFunc("/v1/snapshots/{snapshotId}")(pathParams);
+    const headers = new Headers(compactMap({
+        Accept: "application/json",
+    }));
+    const secConfig = await extractSecurity(client._options.apiKey);
+    const securityInput = secConfig == null ? {} : { apiKey: secConfig };
+    const requestSecurity = resolveGlobalSecurity(securityInput);
+    const context = {
+        options: client._options,
+        baseURL: options?.serverURL ?? client._baseURL ?? "",
+        operationID: "deleteSnapshot",
+        oAuth2Scopes: null,
+        resolvedSecurity: requestSecurity,
+        securitySource: client._options.apiKey,
+        retryConfig: options?.retries
+            || client._options.retryConfig
+            || {
+                strategy: "backoff",
+                backoff: {
+                    initialInterval: 1000,
+                    maxInterval: 5000,
+                    exponent: 1.5,
+                    maxElapsedTime: 600000,
+                },
+                retryConnectionErrors: true,
+            }
+            || { strategy: "none" },
+        retryCodes: options?.retryCodes || ["502", "503", "504"],
+    };
+    const requestRes = client._createRequest(context, {
+        security: requestSecurity,
+        method: "DELETE",
+        baseURL: options?.serverURL,
+        path: path,
+        headers: headers,
+        body: body,
+        userAgent: client._options.userAgent,
+        timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1,
+    }, options);
+    if (!requestRes.ok) {
+        return [requestRes, { status: "invalid" }];
+    }
+    const req = requestRes.value;
+    const doResult = await client._do(req, {
+        context,
+        isErrorStatusCode: (statusCode) => matchStatusCode({ status: statusCode }, ["4XX", "5XX"]),
+        retryConfig: context.retryConfig,
+        retryCodes: context.retryCodes,
+    });
+    if (!doResult.ok) {
+        return [doResult, { status: "request-error", request: req }];
+    }
+    const response = doResult.value;
+    const responseFields = {
+        HttpMeta: { Response: response, Request: req },
+    };
+    const [result] = await M.match(M.json(200, operations.DeleteSnapshotResponse$inboundSchema), M.jsonErr([400, 401, 403, 404, 409, 413, 422, 429], errors.ErrorResponse$inboundSchema), M.jsonErr([500, 503], errors.ErrorResponse$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    if (!result.ok) {
+        return [result, { status: "complete", request: req, response }];
+    }
+    return [result, { status: "complete", request: req, response }];
+}

package/esm/funcs/snapshots-get.d.ts

@@ -0,0 +1,11 @@
+import { StateMachinesCore } from "../core.js";
+import { RequestOptions } from "../lib/sdks.js";
+import { ConnectionError, InvalidRequestError, RequestAbortedError, RequestTimeoutError, UnexpectedClientError } from "../models/errors/http-client-errors.js";
+import * as errors from "../models/errors/index.js";
+import { ResponseValidationError } from "../models/errors/response-validation-error.js";
+import { SDKValidationError } from "../models/errors/sdk-validation-error.js";
+import { StateMachinesHTTPError } from "../models/errors/state-machines-http-error.js";
+import * as operations from "../models/operations/index.js";
+import { APIPromise } from "../types/async.js";
+import { Result } from "../types/fp.js";
+export declare function snapshotsGet(client: StateMachinesCore, request: operations.GetSnapshotRequest, options?: RequestOptions): APIPromise<Result<operations.GetSnapshotResponse, errors.ErrorResponse | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;