@usestatemachines/sdk 0.1.1 → 0.3.0

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

@@ -0,0 +1,32 @@
+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, 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()`. */
+export declare class RunningEnvironment {
+    #private;
+    readonly id: string;
+    /** The record when `start()` resolved. Use `sm.environments.get(id)` for fresh state. */
+    readonly environment: Environment;
+    constructor(sm: StateMachines, environment: Environment);
+    /**
+     * actorId defaults to the actor of the environment's declared default connection, or
+     * else the app's first actor (for Salesforce, the administrator). Pick another from
+     * actors() to act with that user's permissions.
+     */
+    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. */
+    waitUntilStopped(options?: WaitOptions): Promise<Environment>;
+    toJSON(): {
+        id: string;
+        environment: Environment;
+    };
+}

package/esm/extensions/running-environment.js

@@ -0,0 +1,44 @@
+/** A started environment. It remains the handle after `stop()`. */
+export class RunningEnvironment {
+    id;
+    /** 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
+     * else the app's first actor (for Salesforce, the administrator). Pick another from
+     * actors() to act with that user's permissions.
+     */
+    connect(appKey, options) {
+        return this.#environments.connect(this.id, appKey, options);
+    }
+    /** The app's users, in the release's order. */
+    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);
+    }
+    /** Resolves when the environment ended and every sandbox is confirmed disposed. */
+    waitUntilStopped(options) {
+        return this.#environments.waitUntilStopped(this.id, options);
+    }
+    toJSON() {
+        return { id: this.id, environment: this.environment };
+    }
+}

package/esm/extensions/signal.d.ts

@@ -1,4 +1,3 @@
-/** A signal that aborts on the parent's abort, after `timeoutMs`, or on `close()`. */
 export interface LinkedSignal {
     readonly signal: AbortSignal;
     /** Releases the timer and the parent listener without aborting. */
@@ -11,4 +10,4 @@ export interface LinkedSignal {
  * on Node 20.20 in our probes. The timer and the listener hold the controller, so
  * the abort reaches in-flight requests.
  */
-export declare function linkSignal(parent: AbortSignal | undefined, timeoutMs?: number): LinkedSignal;
+export declare function linkSignal(parent: AbortSignal | undefined | readonly AbortSignal[], timeoutMs?: number): LinkedSignal;

package/esm/extensions/signal.js

@@ -4,22 +4,27 @@
  * the abort reaches in-flight requests.
  */
 export function linkSignal(parent, timeoutMs) {
+    const parents = parent === undefined ? [] : [parent].flat();
     const controller = new AbortController();
     const timer = timeoutMs === undefined
         ? undefined
         : setTimeout(() => controller.abort(new DOMException(`Timed out after ${timeoutMs} ms.`, 'TimeoutError')), timeoutMs);
-    const onAbort = () => controller.abort(parent?.reason);
+    const onAbort = () => controller.abort(parents.find(({ aborted }) => aborted)?.reason);
     const dispose = () => {
         clearTimeout(timer);
-        parent?.removeEventListener('abort', onAbort);
+        for (const each of parents) {
+            each.removeEventListener('abort', onAbort);
+        }
     };
     timer?.unref?.();
     controller.signal.addEventListener('abort', dispose, { once: true });
-    if (parent?.aborted) {
+    if (parents.some(({ aborted }) => aborted)) {
         onAbort();
     }
     else {
-        parent?.addEventListener('abort', onAbort, { once: true });
+        for (const each of parents) {
+            each.addEventListener('abort', onAbort, { once: true });
+        }
     }
     return {
         signal: controller.signal,

package/esm/extensions/wait.d.ts

@@ -1,19 +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';
-const defaultTimeoutMs = 600000;
+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/create-environment-definition.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 createEnvironmentDefinition(client: StateMachinesCore, request: operations.CreateEnvironmentDefinitionRequest, options?: RequestOptions): APIPromise<Result<operations.CreateEnvironmentDefinitionResponse, errors.ErrorResponse | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;

package/esm/funcs/create-environment-definition.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 createEnvironmentDefinition(client, request, options) {
+    return new APIPromise($do(client, request, options));
+}
+async function $do(client, request, options) {
+    const parsed = safeParse(request, (value) => z.parse(operations.CreateEnvironmentDefinitionRequest$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}/environment-definitions")(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: "createEnvironmentDefinition",
+        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.CreateEnvironmentDefinitionResponse$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/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>>;