@usestatemachines/sdk 0.1.1 → 0.2.0

package/esm/extensions/client.js

@@ -1,10 +1,13 @@
 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 { Connection } from './connection.js';
-import { StateMachinesError, toStateMachinesError } from './errors.js';
+import { EnvironmentFailedError, StateMachinesError, TimeoutError, toStateMachinesError, } from './errors.js';
+import { RunningEnvironment } from './running-environment.js';
 import { linkSignal } from './signal.js';
-import { disposed, poll, ready } from './wait.js';
+import { defaultTimeoutMs, disposed, poll, ready, } 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';
@@ -16,6 +19,8 @@ export class StateMachines {
     #sdk;
     #fetch;
     #workspaceId;
+    #callSignals = new Map();
+    #lastCall = 0;
     #credentialWorkspace;
     constructor(options = {}) {
         const apiKey = options.apiKey ?? environmentApiKey();
@@ -37,7 +42,7 @@ export class StateMachines {
         }
         const httpClient = options.httpClient?.clone() ??
             new HTTPClient(fetcher ? { fetcher: (input) => fetcher(input) } : {});
-        addAttemptTimeout(httpClient, timeoutMs);
+        addAttemptTimeout(httpClient, timeoutMs, this.#callSignals);
         this.#fetch = fetcher;
         this.#workspaceId = options.workspaceId;
         this.#sdk = new Generated({
@@ -66,13 +71,56 @@ export class StateMachines {
             return this.#sdk.environments.list({ ...filters, workspaceId: resolved }, call);
         }),
         get: (environmentId, options) => this.#unwrap(options, (call) => this.#sdk.environments.get({ environmentId }, call)),
-        /** Every failure carries the `idempotencyKey`; replaying the create with it is safe. */
+        /**
+         * Creates an environment and waits until it's running. If the wait fails, stops the
+         * environment (unless the caller passed its own `idempotencyKey`), then rethrows the
+         * error with `environmentId`, `stopped` and `stopError`.
+         */
+        start: async (input, options = {}) => {
+            const { readyTimeoutMs, ...createOptions } = options;
+            const { idempotencyKey, signal } = options;
+            const timeoutMs = readyTimeoutMs ?? defaultTimeoutMs;
+            if (!(timeoutMs > 0)) {
+                throw new RangeError('readyTimeoutMs must be more than 0.');
+            }
+            const created = await this.environments.create(input, createOptions);
+            try {
+                const environment = await this.environments.waitUntilReady(created.id, {
+                    timeoutMs,
+                    ...(signal ? { signal } : {}),
+                });
+                return new RunningEnvironment(this, environment);
+            }
+            catch (error) {
+                // The API replays a create by key, returning the same environment to another
+                // start() that may still be using it, so only the SDK's own key allows a stop.
+                const outcome = idempotencyKey === undefined
+                    ? await this.#stopAfterFailure(created.id)
+                    : { environmentId: created.id, stopped: false };
+                const isCallerReason = signal?.aborted && Object.is(error, signal.reason);
+                if (isCallerReason) {
+                    if (outcome.stopped) {
+                        throw error;
+                    }
+                    throw Object.assign(new StateMachinesError(new CallerAbortedError(error)), outcome);
+                }
+                if (isStartError(error) && Object.isExtensible(error)) {
+                    Object.assign(error, outcome);
+                }
+                throw error;
+            }
+        },
+        /**
+         * A string app is shorthand for `{ key: <the string>, appId: <the string> }`. Every
+         * failure carries the `idempotencyKey`; replaying the create with it is safe.
+         */
         create: async (input, options = {}) => {
             const idempotencyKey = options.idempotencyKey ?? crypto.randomUUID();
             try {
+                const body = expandApps(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: input }, call);
+                    const { data } = await this.#sdk.environments.create({ workspaceId, idempotencyKey, body }, call);
                     const [environment] = data;
                     if (!environment) {
                         throw new Error('Invalid response from the State API: the create returned no environment.');
@@ -87,23 +135,51 @@ export class StateMachines {
         },
         stop: (environmentId, options) => this.#unwrap(options, (call) => this.#sdk.environments.stop({ environmentId }, call)),
         events: (environmentId, query = {}, options) => this.#call(options, (call) => this.#sdk.environments.events({ ...query, environmentId }, call)),
+        /** The app's users, in the release's order. */
+        actors: async (environmentId, appKey, options) => (await this.environments.getConnection(environmentId, appKey, options))
+            .actors,
         getConnection: (environmentId, appKey, options) => this.#unwrap(options, (call) => this.#sdk.environments.getConnection({ environmentId, appKey }, call)),
-        reveal: (environmentId, appKey, actorId, options) => this.#unwrap(options, (call) => this.#sdk.environments.reveal({ environmentId, appKey, body: { actorId } }, call)),
+        reveal: (environmentId, appKey, actorId, options) => this.#reveal(environmentId, appKey, { actorId }, options),
         /** Resolves when the environment is running. Never stops it. */
         waitUntilReady: (environmentId, options) => poll((signal) => this.#poll(environmentId, signal), ready, options),
         /** Resolves when the environment ended and every sandbox is confirmed disposed. */
         waitUntilStopped: (environmentId, options) => poll((signal) => this.#poll(environmentId, signal), disposed, options),
+        /**
+         * 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: async (environmentId, appKey, options = {}) => {
             const details = await this.environments.getConnection(environmentId, appKey, options);
             if (details.status !== 'ready' || !details.baseUrl) {
                 throw new TypeError(`App ${appKey} is not ready to connect (${details.status}).`);
             }
-            const actor = pick('actor', details.actors, options.actorId);
-            const api = pick('API', details.apis, options.apiId);
-            const secret = await this.environments.reveal(environmentId, appKey, actor.id, options);
+            // The API resolves { actorId } to that actor's first connection, not the declared one.
+            const body = options.actorId === undefined && details.defaultConnection
+                ? { connectionKey: details.defaultConnection }
+                : { actorId: pickActor(appKey, details.actors, options.actorId).id };
+            const api = pickApi(appKey, details.apis, options.apiId);
+            const secret = await this.#reveal(environmentId, appKey, body, options);
             return new Connection(details.baseUrl, api, secret, this.#fetch);
         },
     };
+    #reveal(environmentId, appKey, body, options) {
+        return this.#unwrap(options, (call) => this.#sdk.environments.reveal({ environmentId, appKey, body }, call));
+    }
+    async #stopAfterFailure(environmentId) {
+        const budget = linkSignal(undefined, stopAfterFailureMs);
+        try {
+            // abortable() ends the wait at the budget even during a retry delay.
+            await abortable(this.environments.stop(environmentId, { signal: budget.signal }), budget.signal);
+            return { environmentId, stopped: true };
+        }
+        catch (stopError) {
+            return { environmentId, stopped: false, stopError };
+        }
+        finally {
+            budget.dispose();
+        }
+    }
     /** One read for the poller, which owns retries, timing and the caller's signal. */
     #poll(environmentId, signal) {
         return this.#unwrap({ signal }, (call) => this.#sdk.environments.get({ environmentId }, { ...call, retries: { strategy: 'none' } }));
@@ -141,8 +217,13 @@ export class StateMachines {
      */
     async #call(options, run) {
         const scope = linkSignal(options?.signal);
+        const id = String(++this.#lastCall);
+        this.#callSignals.set(id, scope.signal);
         try {
-            return await run({ signal: scope.signal });
+            return await run({
+                signal: scope.signal,
+                headers: { [CALL_HEADER]: id },
+            });
         }
         catch (error) {
             // A caller abort can surface as a raw TimeoutError while a body is read; it is never retryable.
@@ -151,35 +232,53 @@ export class StateMachines {
                 : error);
         }
         finally {
+            this.#callSignals.delete(id);
             scope.close();
         }
     }
 }
 /**
- * Gives each attempt its own timeout, linked to the caller's signal. The generated
+ * Names the call a request belongs to. Never sent: the attempt hook removes it.
+ * Needed because the generated loop clones each attempt, and after a garbage
+ * collection a clone's signal no longer follows the call's (Node 20 and 24).
+ */
+export const CALL_HEADER = 'x-statemachines-call';
+/**
+ * Gives each attempt its own timeout, linked to its call's signal. The generated
  * `timeoutMs` is never used: it is dropped when a caller passes a signal.
  */
-function addAttemptTimeout(httpClient, timeoutMs) {
+function addAttemptTimeout(httpClient, timeoutMs, calls) {
     const callers = new WeakMap();
     httpClient.addHook('beforeRequest', (request) => {
-        const caller = request.signal;
-        if (caller.aborted) {
-            throw new CallerAbortedError(caller.reason);
+        const headers = new Headers(request.headers);
+        const call = calls.get(headers.get(CALL_HEADER) ?? '');
+        // The request's own signal still counts: a caller's hook may have set it.
+        const sources = call ? [call, request.signal] : [request.signal];
+        const aborted = sources.find(({ aborted }) => aborted);
+        headers.delete(CALL_HEADER);
+        if (aborted) {
+            throw new CallerAbortedError(aborted.reason);
         }
         const attempt = new Request(request, {
-            signal: linkSignal(caller, timeoutMs).signal,
+            headers,
+            signal: linkSignal(sources, timeoutMs).signal,
         });
-        callers.set(attempt, caller);
+        callers.set(attempt, sources);
         return attempt;
     });
     // Without this, a timeout-shaped abort reason looks like a retryable timeout to the generated loop.
     httpClient.addHook('requestError', (_error, request) => {
-        const caller = callers.get(request);
-        if (caller?.aborted) {
-            throw new CallerAbortedError(caller.reason);
+        const aborted = callers.get(request)?.find(({ aborted }) => aborted);
+        if (aborted) {
+            throw new CallerAbortedError(aborted.reason);
         }
     });
 }
+function isStartError(error) {
+    return (error instanceof StateMachinesError ||
+        error instanceof EnvironmentFailedError ||
+        error instanceof TimeoutError);
+}
 function abortable(promise, signal) {
     if (!signal) {
         return promise;
@@ -196,16 +295,33 @@ function abortable(promise, signal) {
             .finally(() => signal.removeEventListener('abort', onAbort));
     });
 }
-function pick(kind, choices, id) {
-    const found = id
-        ? choices.find((choice) => choice.id === id)
-        : choices.length === 1
-            ? choices[0]
+function pickActor(appKey, actors, actorId) {
+    const [first] = actors;
+    if (!first) {
+        throw new TypeError(`App ${appKey} has no actors.`);
+    }
+    if (actorId === undefined) {
+        return first;
+    }
+    const actor = actors.find(({ id }) => id === actorId);
+    if (!actor) {
+        throw new TypeError(`Unknown actor ${actorId} for ${appKey}. Choose one of: ${ids(actors)}.`);
+    }
+    return actor;
+}
+function pickApi(appKey, apis, apiId) {
+    const api = apiId
+        ? apis.find(({ id }) => id === apiId)
+        : apis.length === 1
+            ? apis[0]
             : undefined;
-    if (!found) {
-        throw new TypeError(`Choose one ${kind}: ${choices.map((choice) => choice.id).join(', ') || 'none available'}.`);
+    if (!api) {
+        throw new TypeError(`Choose one API for ${appKey}: ${ids(apis) || 'none available'}.`);
     }
-    return found;
+    return api;
+}
+function ids(choices) {
+    return choices.map(({ id }) => id).join(', ');
 }
 function environmentApiKey() {
     const runtime = globalThis;

package/esm/extensions/errors.d.ts

@@ -1,5 +1,14 @@
 import type { Environment } from '../models/environment.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 {
+    /** The environment the start created. */
+    readonly environmentId?: string;
+    /** Whether the stop request succeeded. Disposal may still be in progress. */
+    readonly stopped?: boolean;
+    /** Why the stop request failed, when it did. */
+    readonly stopError?: unknown;
+}
 interface Details {
     readonly message: string;
     readonly cause?: unknown;
@@ -12,11 +21,15 @@ interface Details {
     readonly idempotencyKey?: string;
 }
 /**
- * Any failed API call: an error response, an invalid response, or no response at
- * all (`status` null). The message never includes a response body.
+ * Any failed API call: an error response, an invalid response, no response at all,
+ * or input the SDK rejected before sending (`status` null for the last three). The
+ * message never includes a response body.
  */
-export declare class StateMachinesError extends Error implements Details {
+export declare class StateMachinesError extends Error implements Details, StartFailure {
     readonly name = "StateMachinesError";
+    readonly environmentId?: string;
+    readonly stopped?: boolean;
+    readonly stopError?: unknown;
     readonly status: number | null;
     readonly code: Code | null;
     readonly requestId: string | null;
@@ -33,9 +46,12 @@ export declare class StateMachinesError extends Error implements Details {
     });
 }
 export declare function toStateMachinesError(error: unknown): StateMachinesError;
-export declare class EnvironmentFailedError extends Error {
+export declare class EnvironmentFailedError extends Error implements StartFailure {
     readonly environment: Environment;
     readonly name = "EnvironmentFailedError";
+    readonly environmentId?: string;
+    readonly stopped?: boolean;
+    readonly stopError?: unknown;
     constructor(environment: Environment);
 }
 export declare class DisposalIncompleteError extends Error {
@@ -43,10 +59,13 @@ export declare class DisposalIncompleteError extends Error {
     readonly name = "DisposalIncompleteError";
     constructor(environment: Environment);
 }
-export declare class TimeoutError extends Error {
+export declare class TimeoutError extends Error implements StartFailure {
     readonly timeoutMs: number;
     readonly environment: Environment | null;
     readonly name = "TimeoutError";
+    readonly environmentId?: string;
+    readonly stopped?: boolean;
+    readonly stopError?: unknown;
     constructor(timeoutMs: number, environment: Environment | null);
 }
 export {};

package/esm/extensions/errors.js

@@ -3,8 +3,9 @@ import { ConnectionError, RequestTimeoutError, } from '../models/errors/http-cli
 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.
+ * Any failed API call: an error response, an invalid response, no response at all,
+ * or input the SDK rejected before sending (`status` null for the last three). The
+ * message never includes a response body.
  */
 export class StateMachinesError extends Error {
     name = 'StateMachinesError';

package/esm/extensions/index.d.ts

@@ -4,8 +4,10 @@ export { ConnectionError, ErrorResponse, HTTPClientError, InvalidRequestError, R
 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 type { AppInput, EnvironmentInput } from './apps.js';
+export type { CallOptions, ConnectOptions, CreateOptions, ListEnvironmentsQuery, 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 { RunningEnvironment } from './running-environment.js';
 export type { WaitOptions } from './wait.js';

package/esm/extensions/index.js

@@ -5,3 +5,4 @@ export { Status as EnvironmentListStatus } from '../models/operations/list-envir
 export { StateMachines } from './client.js';
 export { Connection, formatActorHeader } from './connection.js';
 export { DisposalIncompleteError, EnvironmentFailedError, StateMachinesError, TimeoutError, } from './errors.js';
+export { RunningEnvironment } from './running-environment.js';

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

@@ -0,0 +1,29 @@
+import type { Environment } from '../models/environment.js';
+import type { ReleaseActor } from '../models/release-actor.js';
+import type { CallOptions, 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[]>;
+    /** 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,35 @@
+/** 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;
+    constructor(sm, environment) {
+        this.id = environment.id;
+        this.environment = environment;
+        this.#environments = sm.environments;
+    }
+    /**
+     * 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);
+    }
+    /** 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

@@ -7,6 +7,7 @@ export interface WaitOptions {
 }
 type Read = (signal: AbortSignal) => Promise<Environment>;
 type Decide = (environment: Environment) => boolean;
+export declare const defaultTimeoutMs = 600000;
 /**
  * Reads until `done` returns true. `done` throws to end the wait with a failure.
  * Transient read failures are retried with backoff until the deadline.

package/esm/extensions/wait.js

@@ -1,6 +1,6 @@
 import { DisposalIncompleteError, EnvironmentFailedError, TimeoutError, toStateMachinesError, } from './errors.js';
 import { linkSignal } from './signal.js';
-const defaultTimeoutMs = 600000;
+export const defaultTimeoutMs = 600000;
 const readTimeoutMs = 30000;
 /**
  * Reads until `done` returns true. `done` throws to end the wait with a failure.

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/lib/config.d.ts

@@ -31,7 +31,7 @@ export declare function serverURLFromOptions(options: SDKOptions): URL | null;
 export declare const SDK_METADATA: {
     readonly language: "typescript";
     readonly openapiDocVersion: "1.0.0";
-    readonly sdkVersion: "0.1.1";
+    readonly sdkVersion: "0.2.0";
     readonly genVersion: "2.941.0";
-    readonly userAgent: "speakeasy-sdk/typescript 0.1.1 2.941.0 1.0.0 @usestatemachines/sdk";
+    readonly userAgent: "speakeasy-sdk/typescript 0.2.0 2.941.0 1.0.0 @usestatemachines/sdk";
 };

package/esm/lib/config.js

@@ -24,7 +24,7 @@ export function serverURLFromOptions(options) {
 export const SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "1.0.0",
-    sdkVersion: "0.1.1",
+    sdkVersion: "0.2.0",
     genVersion: "2.941.0",
-    userAgent: "speakeasy-sdk/typescript 0.1.1 2.941.0 1.0.0 @usestatemachines/sdk",
+    userAgent: "speakeasy-sdk/typescript 0.2.0 2.941.0 1.0.0 @usestatemachines/sdk",
 };

package/esm/models/connection-secret.d.ts

@@ -1,14 +1,30 @@
 import * as z from "zod/v4-mini";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdk-validation-error.js";
+export type Native = {
+    authentication: string;
+    baseUrl: string;
+    credentials: {
+        [k: string]: string;
+    };
+    key: string;
+    parameters: {
+        [k: string]: string;
+    };
+};
 export type ConnectionSecret = {
     actorId: string;
     actorToken: string;
     appKey: string;
+    connectionKey: string | null;
     environmentId: string;
     environmentToken: string;
     expiresAt: Date;
+    native?: Native | undefined;
 };
 /** @internal */
+export declare const Native$inboundSchema: z.ZodMiniType<Native, unknown>;
+export declare function nativeFromJSON(jsonString: string): SafeParseResult<Native, SDKValidationError>;
+/** @internal */
 export declare const ConnectionSecret$inboundSchema: z.ZodMiniType<ConnectionSecret, unknown>;
 export declare function connectionSecretFromJSON(jsonString: string): SafeParseResult<ConnectionSecret, SDKValidationError>;