@usestatemachines/sdk 0.4.0 → 0.6.0

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@usestatemachines/sdk",
-  "version": "0.4.0",
-  "description": "TypeScript SDK for State environments",
+  "version": "0.6.0",
+  "description": "TypeScript SDK for State Machines environments",
   "license": "MIT",
   "homepage": "https://usestatemachines.com",
-  "author": "State",
+  "author": "State Machines",
   "type": "module",
   "sideEffects": false,
   "engines": {
@@ -29,7 +29,18 @@
     "openapi.json",
     "README.md"
   ],
+  "scripts": {
+    "build": "node scripts/clean.mjs && tsgo",
+    "prepare": "pnpm build",
+    "typecheck": "tsgo -p tsconfig.check.json",
+    "lint": "biome ci . && pnpm agents:check && node scripts/source-stamp.mjs --check && node scripts/published-contract.mjs",
+    "generate": "speakeasy run -y --skip-versioning --skip-upload-spec --skip-compile && node scripts/source-stamp.mjs --write",
+    "test": "vitest run",
+    "agents:build": "node scripts/build-agents.mjs",
+    "agents:check": "node scripts/build-agents.mjs --check"
+  },
   "dependencies": {
+    "yaml": "^2.9.1",
     "zod": "^3.25.65 || ^4.0.0"
   },
   "devDependencies": {
@@ -37,14 +48,5 @@
     "@types/node": "24.13.4",
     "@typescript/native-preview": "7.0.0-dev.20260302.1",
     "vitest": "5.0.1"
-  },
-  "scripts": {
-    "build": "tsgo",
-    "typecheck": "tsgo -p tsconfig.check.json",
-    "lint": "biome ci . && pnpm agents:check && node scripts/source-stamp.mjs --check",
-    "generate": "speakeasy run -y --skip-versioning --skip-upload-spec --skip-compile && node scripts/source-stamp.mjs --write",
-    "test": "vitest run",
-    "agents:build": "node scripts/build-agents.mjs",
-    "agents:check": "node scripts/build-agents.mjs --check"
   }
-}
+}

package/esm/extensions/apps.d.ts

@@ -1,18 +0,0 @@
-import type { CreateEnvironmentInput, CreateEnvironmentInputApp } from '../models/create-environment-input.js';
-/** A string is shorthand for `{ key: <the string>, appId: <the string> }`. */
-export type AppInput = string | CreateEnvironmentInputApp;
-type Common = Omit<CreateEnvironmentInput, 'apps' | 'snapshotId' | 'snapshotAppInstanceKeys'>;
-export interface EnvironmentInput extends Common {
-    /** 1 to 10 apps with unique keys. */
-    apps: AppInput[];
-}
-/** Starts from a snapshot: each app keeps the key it had when captured. */
-export interface SnapshotEnvironmentInput extends Common {
-    snapshotId: string;
-    /** Keys of the snapshot's app instances to restore. Defaults to all. */
-    snapshotAppInstanceKeys?: string[];
-}
-export declare function expandApps(input: EnvironmentInput): CreateEnvironmentInput;
-export type EnvironmentSource = EnvironmentInput | SnapshotEnvironmentInput | CreateEnvironmentInput;
-export declare function expandSource(input: EnvironmentSource): CreateEnvironmentInput;
-export {};

package/esm/extensions/apps.js

@@ -1,39 +0,0 @@
-const APP_KEY = /^[a-z][a-z0-9-]{0,39}$/;
-export function expandApps(input) {
-    if (input.apps.length === 0) {
-        throw new TypeError('Pass at least one app.');
-    }
-    const apps = input.apps.map((app) => {
-        if (typeof app !== 'string') {
-            return app;
-        }
-        if (!APP_KEY.test(app)) {
-            throw new TypeError(`"${app}" can't be used as an app key; pass { key, appId } instead.`);
-        }
-        return { key: app, appId: app };
-    });
-    const keys = new Set();
-    for (const { key } of apps) {
-        if (keys.has(key)) {
-            throw new TypeError(`App key "${key}" is used twice.`);
-        }
-        keys.add(key);
-    }
-    return { ...input, apps };
-}
-export function expandSource(input) {
-    const { apps, ...rest } = input;
-    if (rest.snapshotId === undefined) {
-        if (rest.snapshotAppInstanceKeys !== undefined) {
-            throw new TypeError('Pass snapshotAppInstanceKeys with snapshotId.');
-        }
-        if (apps === undefined) {
-            throw new TypeError('Pass apps or snapshotId.');
-        }
-        return expandApps({ ...rest, apps });
-    }
-    if (apps !== undefined) {
-        throw new TypeError('Pass apps or snapshotId, not both.');
-    }
-    return rest;
-}

package/esm/extensions/connection.d.ts

@@ -1,42 +0,0 @@
-import type { Fetcher } from '../lib/http.js';
-import type { ApiProfile } from '../models/api-profile.js';
-import type { ConnectionSecret } from '../models/connection-secret.js';
-/**
- * The HTTP header an app's API expects for its actor token, or `null` when the token goes in
- * the request body instead: for `SOAP SessionHeader`, as the envelope's `SessionHeader/sessionId`.
- */
-export declare function formatActorHeader(actorHeader: string, token: string): {
-    name: string;
-    value: string;
-} | null;
-/** A live app connection. `fetch` only reaches paths under `baseUrl`. */
-export declare class Connection {
-    #private;
-    readonly baseUrl: string;
-    readonly environmentId: string;
-    readonly appKey: string;
-    readonly actorId: string;
-    readonly api: ApiProfile;
-    readonly expiresAt: Date;
-    constructor(baseUrl: string, api: ApiProfile, secret: ConnectionSecret, fetch?: Fetcher);
-    /**
-     * The headers the gateway and the app need, for clients that can't use `fetch`. For an API
-     * whose actor token goes in the request body, such as SOAP, only the environment token.
-     */
-    headers(): Record<string, string>;
-    /**
-     * The live actor token, for APIs that take it in the request body: for a SOAP API, put it in
-     * the envelope's `SessionHeader/sessionId`. Treat it as a secret.
-     */
-    actorToken(): string;
-    /** Sends one request to the app. Never retries, never follows redirects, never adds the API key. */
-    fetch(path: string, init?: RequestInit): Promise<Response>;
-    toJSON(): {
-        baseUrl: string;
-        environmentId: string;
-        appKey: string;
-        actorId: string;
-        api: ApiProfile;
-        expiresAt: Date;
-    };
-}

package/esm/extensions/connection.js

@@ -1,133 +0,0 @@
-const HTTP_TOKEN = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
-// Salesforce's SOAP API takes the actor token in the envelope, not an HTTP header.
-const SOAP_SESSION_HEADER = 'SOAP SessionHeader';
-// Visible ASCII only: `Headers` would otherwise echo a bad value, token included, in its error.
-const TOKEN_VALUE = /^[\x21-\x7e]+$/;
-// Checked on the path part only (C7). Covers protocol-relative starts, backslashes, control
-// characters and encoded dots, slashes and backslashes, including double encoding.
-const UNSAFE_PATH = /^\/\/|\\|%(?:25)*(?:2e|2f|5c)|\p{Cc}/iu;
-const OUTSIDE = 'Connection.fetch only reaches paths under the connection baseUrl.';
-/**
- * The HTTP header an app's API expects for its actor token, or `null` when the token goes in
- * the request body instead: for `SOAP SessionHeader`, as the envelope's `SessionHeader/sessionId`.
- */
-export function formatActorHeader(actorHeader, token) {
-    if (actorHeader === SOAP_SESSION_HEADER) {
-        return null;
-    }
-    if (!HTTP_TOKEN.test(actorHeader) ||
-        actorHeader.toLowerCase().startsWith('x-state-')) {
-        throw new TypeError('The API profile names an invalid actor header.');
-    }
-    return actorHeader.toLowerCase() === 'authorization'
-        ? { name: 'Authorization', value: `Bearer ${token}` }
-        : { name: actorHeader, value: token };
-}
-/** A live app connection. `fetch` only reaches paths under `baseUrl`. */
-export class Connection {
-    baseUrl;
-    environmentId;
-    appKey;
-    actorId;
-    api;
-    expiresAt;
-    #base;
-    #environmentToken;
-    #actorToken;
-    #actor;
-    #fetch;
-    constructor(baseUrl, api, secret, fetch) {
-        const base = URL.canParse(baseUrl) ? new URL(baseUrl) : null;
-        if (!base ||
-            !/^https?:$/.test(base.protocol) ||
-            base.username ||
-            base.password ||
-            base.search ||
-            base.hash) {
-            throw new TypeError('The connection baseUrl is not a plain http(s) URL.');
-        }
-        if (!TOKEN_VALUE.test(secret.environmentToken) ||
-            !TOKEN_VALUE.test(secret.actorToken)) {
-            throw new TypeError('The connection tokens are malformed.');
-        }
-        if (!base.pathname.endsWith('/')) {
-            base.pathname += '/';
-        }
-        this.#base = base;
-        this.#environmentToken = secret.environmentToken;
-        this.#actorToken = secret.actorToken;
-        this.#actor = formatActorHeader(api.actorHeader, secret.actorToken);
-        this.#fetch = fetch;
-        this.baseUrl = base.href;
-        this.environmentId = secret.environmentId;
-        this.appKey = secret.appKey;
-        this.actorId = secret.actorId;
-        this.api = api;
-        this.expiresAt = secret.expiresAt;
-    }
-    /**
-     * The headers the gateway and the app need, for clients that can't use `fetch`. For an API
-     * whose actor token goes in the request body, such as SOAP, only the environment token.
-     */
-    headers() {
-        return {
-            'X-State-Environment-Token': this.#environmentToken,
-            ...(this.#actor ? { [this.#actor.name]: this.#actor.value } : {}),
-        };
-    }
-    /**
-     * The live actor token, for APIs that take it in the request body: for a SOAP API, put it in
-     * the envelope's `SessionHeader/sessionId`. Treat it as a secret.
-     */
-    actorToken() {
-        return this.#actorToken;
-    }
-    /** Sends one request to the app. Never retries, never follows redirects, never adds the API key. */
-    async fetch(path, init = {}) {
-        const url = this.#resolve(path);
-        const headers = new Headers(init.headers);
-        for (const name of headers.keys()) {
-            if (name.startsWith('x-state-')) {
-                throw new TypeError(`Header ${name} is reserved for State.`);
-            }
-        }
-        // Ours go last so a caller header of the same name can't replace them.
-        for (const [name, value] of Object.entries(this.headers())) {
-            headers.set(name, value);
-        }
-        const request = new Request(url, { ...init, headers, redirect: 'manual' });
-        // Called on `globalThis` at use time: a stored unbound `fetch` throws "Illegal invocation" in Workers.
-        return this.#fetch ? this.#fetch(request) : globalThis.fetch(request);
-    }
-    toJSON() {
-        return {
-            baseUrl: this.baseUrl,
-            environmentId: this.environmentId,
-            appKey: this.appKey,
-            actorId: this.actorId,
-            api: this.api,
-            expiresAt: this.expiresAt,
-        };
-    }
-    #resolve(path) {
-        const pathPart = path.split(/[?#]/, 1)[0] ?? '';
-        if (UNSAFE_PATH.test(pathPart)) {
-            throw new TypeError(OUTSIDE);
-        }
-        // A leading `/` means the root of the connection, not of the gateway.
-        const relative = path.startsWith('/') ? `.${path}` : path;
-        // `URL` errors carry the input, query included, so they are replaced rather than rethrown.
-        const url = URL.canParse(relative, this.#base)
-            ? new URL(relative, this.#base)
-            : null;
-        if (!url ||
-            url.origin !== this.#base.origin ||
-            url.username ||
-            url.password ||
-            !url.pathname.startsWith(this.#base.pathname) ||
-            UNSAFE_PATH.test(url.pathname)) {
-            throw new TypeError(OUTSIDE);
-        }
-        return url;
-    }
-}

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

@@ -1,46 +0,0 @@
-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 `suspend()` and `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>;
-    /**
-     * Ends the sandboxes and keeps the data for `resume()`. Doesn't wait: use
-     * `waitUntilSuspended()` before resuming.
-     */
-    suspend(options?: CallOptions): Promise<Environment>;
-    /** Resolves when the environment is suspended and can resume. */
-    waitUntilSuspended(options?: WaitOptions): Promise<Environment>;
-    /** Runs a suspended environment again on its data. Use `waitUntilReady()` before connecting. */
-    resume(options?: CallOptions): Promise<Environment>;
-    /** Resolves when the environment is running again. */
-    waitUntilReady(options?: WaitOptions): Promise<Environment>;
-    /**
-     * Ends the environment and discards its data. 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

@@ -1,66 +0,0 @@
-/** A started environment. It remains the handle after `suspend()` and `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,
-        });
-    }
-    /**
-     * Ends the sandboxes and keeps the data for `resume()`. Doesn't wait: use
-     * `waitUntilSuspended()` before resuming.
-     */
-    suspend(options) {
-        return this.#environments.suspend(this.id, options);
-    }
-    /** Resolves when the environment is suspended and can resume. */
-    waitUntilSuspended(options) {
-        return this.#environments.waitUntilSuspended(this.id, options);
-    }
-    /** Runs a suspended environment again on its data. Use `waitUntilReady()` before connecting. */
-    resume(options) {
-        return this.#environments.resume(this.id, options);
-    }
-    /** Resolves when the environment is running again. */
-    waitUntilReady(options) {
-        return this.#environments.waitUntilReady(this.id, options);
-    }
-    /**
-     * Ends the environment and discards its data. 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/funcs/create-environment-definition.d.ts

@@ -1,11 +0,0 @@
-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

@@ -1,94 +0,0 @@
-/*
- * 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/credential-get.js

@@ -1,76 +0,0 @@
-/*
- * 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-reveal.d.ts

@@ -1,11 +0,0 @@
-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 environmentsReveal(client: StateMachinesCore, request: operations.RevealConnectionRequest, options?: RequestOptions): APIPromise<Result<operations.RevealConnectionResponse, errors.ErrorResponse | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;

package/esm/funcs/environments-suspend.d.ts

@@ -1,11 +0,0 @@
-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 environmentsSuspend(client: StateMachinesCore, request: operations.SuspendEnvironmentRequest, options?: RequestOptions): APIPromise<Result<operations.SuspendEnvironmentResponse, errors.ErrorResponse | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;

package/esm/funcs/get-environment-exchange.d.ts

@@ -1,11 +0,0 @@
-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 getEnvironmentExchange(client: StateMachinesCore, request: operations.GetEnvironmentExchangeRequest, options?: RequestOptions): APIPromise<Result<operations.GetEnvironmentExchangeResponse, errors.ErrorResponse | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;