@usestatemachines/sdk 0.1.1

package/esm/extensions/errors.js

@@ -0,0 +1,129 @@
+import { ErrorResponse } from '../models/errors/error-response.js';
+import { ConnectionError, RequestTimeoutError, } from '../models/errors/http-client-errors.js';
+import { ResponseValidationError } from '../models/errors/response-validation-error.js';
+import { StateMachinesHTTPError } from '../models/errors/state-machines-http-error.js';
+/**
+ * Any failed API call: an error response, an invalid response, or no response at
+ * all (`status` null). The message never includes a response body.
+ */
+export class StateMachinesError extends Error {
+    name = 'StateMachinesError';
+    status;
+    code;
+    requestId;
+    fields;
+    /** Milliseconds the server asked the client to wait. */
+    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. */
+    idempotencyKey;
+    /** Wraps any thrown value. Wrapping a `StateMachinesError` copies it, keeping its cause. */
+    constructor(error, extra = {}) {
+        const details = error instanceof StateMachinesError ? error : describe(error);
+        super(details.message, details.cause === undefined ? undefined : { cause: details.cause });
+        this.status = details.status;
+        this.code = details.code;
+        this.requestId = details.requestId;
+        this.fields = details.fields;
+        this.retryAfter = details.retryAfter;
+        this.retryable = details.retryable;
+        const idempotencyKey = extra.idempotencyKey ?? details.idempotencyKey;
+        if (idempotencyKey !== undefined) {
+            this.idempotencyKey = idempotencyKey;
+        }
+    }
+}
+export function toStateMachinesError(error) {
+    return error instanceof StateMachinesError
+        ? error
+        : new StateMachinesError(error);
+}
+// Matches the generated retry codes (.speakeasy/overlay.yaml): Cloudflare answers 502 and 504
+// when the API origin is unreachable, and the API answers 503 when it is saturated.
+const retryableStatuses = new Set([502, 503, 504]);
+function describe(error) {
+    const empty = {
+        status: null,
+        code: null,
+        requestId: null,
+        fields: null,
+        retryAfter: null,
+        retryable: false,
+    };
+    if (error instanceof StateMachinesHTTPError) {
+        return describeResponse(error);
+    }
+    if (error instanceof SyntaxError) {
+        // A malformed JSON body; V8 quotes the body in the parser's message.
+        return { ...empty, message: 'Invalid response from the State API.' };
+    }
+    if (error instanceof Error) {
+        // A `TimeoutError` DOMException is an attempt timeout that fired while the body was read.
+        const retryable = error instanceof ConnectionError ||
+            error instanceof RequestTimeoutError ||
+            error.name === 'TimeoutError';
+        return { ...empty, message: error.message, cause: error, retryable };
+    }
+    return { ...empty, message: String(error), cause: error };
+}
+function describeResponse(error) {
+    const status = error.statusCode;
+    const body = error instanceof ErrorResponse ? error.error : undefined;
+    const success = status >= 200 && status < 300;
+    let message = `HTTP ${status} from the State API`;
+    if (success || error instanceof ResponseValidationError) {
+        message = `Invalid response from the State API (HTTP ${status})`;
+    }
+    else if (body?.message) {
+        message = body.message;
+    }
+    return {
+        message,
+        // No cause: generated HTTP errors hold the request (with the API key) and the raw body.
+        status,
+        code: body?.code ?? null,
+        requestId: body?.requestId ?? error.headers.get('x-request-id'),
+        fields: body?.fields ?? null,
+        retryAfter: retryAfter(error.headers),
+        retryable: retryableStatuses.has(status),
+    };
+}
+function retryAfter(headers) {
+    const value = headers.get('retry-after')?.trim();
+    if (!value) {
+        return null;
+    }
+    const seconds = Number(value);
+    if (Number.isFinite(seconds)) {
+        return Math.max(0, seconds * 1000);
+    }
+    const date = Date.parse(value);
+    return Number.isNaN(date) ? null : Math.max(0, date - Date.now());
+}
+export class EnvironmentFailedError extends Error {
+    environment;
+    name = 'EnvironmentFailedError';
+    constructor(environment) {
+        super(`Environment ${environment.id} is ${environment.status} (${environment.stopReason ?? 'no stop reason'}).`);
+        this.environment = environment;
+    }
+}
+export class DisposalIncompleteError extends Error {
+    environment;
+    name = 'DisposalIncompleteError';
+    constructor(environment) {
+        super(`Environment ${environment.id} ended, but not every sandbox was confirmed disposed.`);
+        this.environment = environment;
+    }
+}
+export class TimeoutError extends Error {
+    timeoutMs;
+    environment;
+    name = 'TimeoutError';
+    constructor(timeoutMs, environment) {
+        super(`Timed out after ${timeoutMs} ms.`);
+        this.timeoutMs = timeoutMs;
+        this.environment = environment;
+    }
+}

package/esm/extensions/index.d.ts

@@ -0,0 +1,11 @@
+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 { Code as ErrorCode, Disposal, EnvironmentStatus, StopReason, } from '../models/index.js';
+export { Status as EnvironmentListStatus } from '../models/operations/list-environments.js';
+export type { CallOptions, ConnectOptions, CreateOptions, ListEnvironmentsQuery, Page, StateMachinesOptions, } from './client.js';
+export { StateMachines } from './client.js';
+export { Connection, formatActorHeader } from './connection.js';
+export { DisposalIncompleteError, EnvironmentFailedError, StateMachinesError, TimeoutError, } from './errors.js';
+export type { WaitOptions } from './wait.js';

package/esm/extensions/index.js

@@ -0,0 +1,7 @@
+export { HTTPClient } from '../lib/http.js';
+export { ConnectionError, ErrorResponse, HTTPClientError, InvalidRequestError, RequestAbortedError, RequestTimeoutError, ResponseValidationError, SDKValidationError, StateMachinesHTTPError, UnexpectedClientError, UnexpectedResponseError, } from '../models/errors/index.js';
+export { Code as ErrorCode, Disposal, EnvironmentStatus, StopReason, } from '../models/index.js';
+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';

package/esm/extensions/signal.d.ts

@@ -0,0 +1,14 @@
+/** 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. */
+    dispose(): void;
+    /** Aborts the signal, so anything linked to it releases its resources too. */
+    close(): void;
+}
+/**
+ * Links with an explicit controller instead of `AbortSignal.any`, which never fired
+ * 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;

package/esm/extensions/signal.js

@@ -0,0 +1,29 @@
+/**
+ * Links with an explicit controller instead of `AbortSignal.any`, which never fired
+ * on Node 20.20 in our probes. The timer and the listener hold the controller, so
+ * the abort reaches in-flight requests.
+ */
+export function linkSignal(parent, timeoutMs) {
+    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 dispose = () => {
+        clearTimeout(timer);
+        parent?.removeEventListener('abort', onAbort);
+    };
+    timer?.unref?.();
+    controller.signal.addEventListener('abort', dispose, { once: true });
+    if (parent?.aborted) {
+        onAbort();
+    }
+    else {
+        parent?.addEventListener('abort', onAbort, { once: true });
+    }
+    return {
+        signal: controller.signal,
+        dispose,
+        close: () => controller.abort(new DOMException('The call settled.', 'AbortError')),
+    };
+}

package/esm/extensions/wait.d.ts

@@ -0,0 +1,19 @@
+import type { Environment } from '../models/environment.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;
+/**
+ * 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>;
+/** 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;
+export {};

package/esm/extensions/wait.js

@@ -0,0 +1,102 @@
+import { DisposalIncompleteError, EnvironmentFailedError, TimeoutError, toStateMachinesError, } from './errors.js';
+import { linkSignal } from './signal.js';
+const defaultTimeoutMs = 600000;
+const readTimeoutMs = 30000;
+/**
+ * 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 = {}) {
+    const { signal } = options;
+    const timeoutMs = options.timeoutMs ?? defaultTimeoutMs;
+    if (!(timeoutMs >= 0)) {
+        throw new RangeError(`timeoutMs must be a non-negative number, got ${timeoutMs}.`);
+    }
+    const deadline = Date.now() + timeoutMs;
+    let last = null;
+    for (let attempt = 0;; attempt += 1) {
+        signal?.throwIfAborted();
+        const remaining = deadline - Date.now();
+        if (remaining <= 0) {
+            throw new TimeoutError(timeoutMs, last);
+        }
+        let waitMs = backoff(attempt);
+        let environment = null;
+        const link = linkSignal(signal, Math.min(readTimeoutMs, remaining));
+        try {
+            environment = await read(link.signal);
+            last = environment;
+        }
+        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);
+            }
+            if (!link.signal.aborted) {
+                const failure = toStateMachinesError(error);
+                if (!failure.retryable) {
+                    throw failure;
+                }
+                waitMs = Math.max(waitMs, failure.retryAfter ?? 0);
+            }
+        }
+        finally {
+            link.dispose();
+        }
+        // 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);
+        }
+        if (environment && done(environment)) {
+            return environment;
+        }
+        await sleep(Math.min(waitMs, deadline - Date.now()), signal);
+    }
+}
+/** Resolves on `running`. Never stops the environment. */
+export function ready(environment) {
+    switch (environment.status) {
+        case 'running':
+            return true;
+        case 'failed':
+        case 'stopping':
+        case 'stopped':
+            throw new EnvironmentFailedError(environment);
+        default:
+            return false;
+    }
+}
+/** Resolves once the environment ended and every app's sandbox is confirmed disposed. */
+export function disposed(environment) {
+    if (environment.status !== 'stopped' && environment.status !== 'failed') {
+        return false;
+    }
+    const unconfirmed = environment.apps.some(({ disposal }) => disposal === 'failed' || disposal === 'unknown');
+    if (unconfirmed) {
+        throw new DisposalIncompleteError(environment);
+    }
+    return environment.apps.every((app) => app.disposal === 'complete');
+}
+/** 1 s × 1.5ⁿ, capped at 5 s, with ±20% jitter. */
+function backoff(attempt) {
+    return Math.min(5000, 1000 * 1.5 ** attempt) * (0.8 + Math.random() * 0.4);
+}
+function sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(signal.reason);
+            return;
+        }
+        const onAbort = () => {
+            clearTimeout(timer);
+            reject(signal?.reason);
+        };
+        const timer = setTimeout(() => {
+            signal?.removeEventListener('abort', onAbort);
+            resolve();
+        }, ms);
+        signal?.addEventListener('abort', onAbort, { once: true });
+    });
+}

package/esm/funcs/catalog-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 catalogGet(client: StateMachinesCore, options?: RequestOptions): APIPromise<Result<operations.GetCatalogResponse, errors.ErrorResponse | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;

package/esm/funcs/catalog-get.js

@@ -0,0 +1,76 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import { matchStatusCode } from "../lib/http.js";
+import * as M from "../lib/matchers.js";
+import { compactMap } from "../lib/primitives.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 catalogGet(client, options) {
+    return new APIPromise($do(client, options));
+}
+async function $do(client, options) {
+    const path = pathToFunc("/v1/catalog")();
+    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: "getCatalog",
+        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: "GET",
+        baseURL: options?.serverURL,
+        path: path,
+        headers: headers,
+        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.GetCatalogResponse$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/catalog-release.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 catalogRelease(client: StateMachinesCore, request: operations.GetReleaseRequest, options?: RequestOptions): APIPromise<Result<operations.GetReleaseResponse, errors.ErrorResponse | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;

package/esm/funcs/catalog-release.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 catalogRelease(client, request, options) {
+    return new APIPromise($do(client, request, options));
+}
+async function $do(client, request, options) {
+    const parsed = safeParse(request, (value) => z.parse(operations.GetReleaseRequest$outboundSchema, value), "Input validation failed");
+    if (!parsed.ok) {
+        return [parsed, { status: "invalid" }];
+    }
+    const payload = parsed.value;
+    const body = null;
+    const pathParams = {
+        releaseId: encodeSimple("releaseId", payload.releaseId, {
+            explode: false,
+            charEncoding: "percent",
+        }),
+    };
+    const path = pathToFunc("/v1/catalog/releases/{releaseId}")(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: "getRelease",
+        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: "GET",
+        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.GetReleaseResponse$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/credential-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 credentialGet(client: StateMachinesCore, options?: RequestOptions): APIPromise<Result<operations.GetCredentialResponse, errors.ErrorResponse | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;

package/esm/funcs/credential-get.js

@@ -0,0 +1,76 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import { matchStatusCode } from "../lib/http.js";
+import * as M from "../lib/matchers.js";
+import { compactMap } from "../lib/primitives.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 credentialGet(client, options) {
+    return new APIPromise($do(client, options));
+}
+async function $do(client, options) {
+    const path = pathToFunc("/v1/credential")();
+    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: "getCredential",
+        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: "GET",
+        baseURL: options?.serverURL,
+        path: path,
+        headers: headers,
+        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.GetCredentialResponse$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-create.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 environmentsCreate(client: StateMachinesCore, request: operations.CreateEnvironmentsRequest, options?: RequestOptions): APIPromise<Result<operations.CreateEnvironmentsResponse, errors.ErrorResponse | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;