@usestatemachines/sdk 0.8.1 → 0.9.1

package/esm/extensions/ui.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Browser helpers for a UI session that a trusted server launched. This
+ * module imports nothing: it holds no management client, API key or token,
+ * so a browser bundle that imports it holds none either.
+ */
+/** The fields of a launch that a browser needs. A launch from the API has them all. */
+export interface UiLaunch {
+    readonly sessionId: string;
+    /** `embedded` posts into an iframe; `page` posts into a window of its own. */
+    readonly mode: 'embedded' | 'page';
+    /** The session's own origin. */
+    readonly origin: string;
+    /** Where the browser posts the grant. It is on `origin`. */
+    readonly exchangeUrl: string;
+    /** One use. Post it once, from the origin the launch named. */
+    readonly grant: string;
+}
+/** A message that an embedded session posts to the page that frames it. */
+export type UiSessionMessage = {
+    readonly event: 'ready';
+    readonly sessionId: string;
+} | {
+    readonly event: 'logout';
+    readonly sessionId: string;
+} | {
+    readonly event: 'failure';
+    /** Null when the session failed before it knew its ID, such as when the browser blocked its cookie. */
+    readonly sessionId: string | null;
+    /** A short code, such as `ui_access_required`, or null. */
+    readonly reason: string | null;
+};
+export interface ListenOptions {
+    /** Removes the listener when it aborts. */
+    readonly signal?: AbortSignal;
+}
+/**
+ * Posts the launch's grant to its exchange URL, targeted at `target`: an
+ * iframe for an `embedded` launch, or a window for a `page` launch. Open the
+ * window in the click handler, such as with `window.open('about:blank',
+ * name)`, so the browser does not block it. The session then loads in
+ * `target`, and a window loses its `opener`. A launch posts once; a second
+ * post of the same grant is refused.
+ *
+ * The posting page must send its `Origin`, so its `Referrer-Policy` must not
+ * be `no-referrer`.
+ */
+export declare function submitLaunch(launch: UiLaunch, target: HTMLIFrameElement | Window): void;
+/**
+ * The session message in `data`, or null when `data` is not exactly one of
+ * the messages for `sessionId`. A failure may carry a null session ID.
+ */
+export declare function parseSessionMessage(data: unknown, sessionId: string): UiSessionMessage | null;
+/**
+ * Calls `onMessage` with each message that the session in `source` posts:
+ * only from the launch's exact origin, only from `source`'s window, and only
+ * for the launch's session. Every other message is ignored. Answers the
+ * function that removes the listener.
+ */
+export declare function listenToSession(launch: Pick<UiLaunch, 'sessionId' | 'origin'>, source: HTMLIFrameElement | Window, onMessage: (message: UiSessionMessage) => void, options?: ListenOptions): () => void;

package/esm/extensions/ui.js

@@ -0,0 +1,153 @@
+/**
+ * Browser helpers for a UI session that a trusted server launched. This
+ * module imports nothing: it holds no management client, API key or token,
+ * so a browser bundle that imports it holds none either.
+ */
+const MESSAGE_TYPE = 'state-ui';
+const EVENTS = new Set(['ready', 'logout', 'failure']);
+const REASON = /^[a-z][a-z0-9_]{0,63}$/;
+function isFrame(target) {
+    return typeof target.tagName === 'string';
+}
+function sessionOrigin(launch) {
+    const origin = URL.canParse(launch.origin) ? new URL(launch.origin) : null;
+    const exchange = URL.canParse(launch.exchangeUrl)
+        ? new URL(launch.exchangeUrl)
+        : null;
+    if (!origin ||
+        !exchange ||
+        origin.protocol !== 'https:' ||
+        origin.origin !== launch.origin ||
+        exchange.origin !== launch.origin) {
+        throw new TypeError('The launch must name an HTTPS session origin and an exchange URL on it.');
+    }
+    return launch.origin;
+}
+/**
+ * Posts the launch's grant to its exchange URL, targeted at `target`: an
+ * iframe for an `embedded` launch, or a window for a `page` launch. Open the
+ * window in the click handler, such as with `window.open('about:blank',
+ * name)`, so the browser does not block it. The session then loads in
+ * `target`, and a window loses its `opener`. A launch posts once; a second
+ * post of the same grant is refused.
+ *
+ * The posting page must send its `Origin`, so its `Referrer-Policy` must not
+ * be `no-referrer`.
+ */
+export function submitLaunch(launch, target) {
+    sessionOrigin(launch);
+    const frame = isFrame(target);
+    if (frame !== (launch.mode === 'embedded')) {
+        throw new TypeError(launch.mode === 'embedded'
+            ? 'Post an embedded launch into an iframe.'
+            : 'Post a page launch into a window.');
+    }
+    if (!target.name) {
+        const name = `state-ui-${launch.sessionId}`;
+        target.name = name;
+        if (frame) {
+            // Chromium and WebKit keep the name an iframe's frame had when it was
+            // attached, so a later name attribute alone sends the form to a new
+            // window. Name the frame's window too.
+            try {
+                target.contentWindow.name = name;
+            }
+            catch {
+                throw new TypeError('Name the iframe before you attach it, or let the page reach its frame.');
+            }
+        }
+    }
+    const document = frame ? target.ownerDocument : globalThis.document;
+    const form = document.createElement('form');
+    form.method = 'post';
+    form.action = launch.exchangeUrl;
+    form.target = target.name;
+    form.hidden = true;
+    const grant = document.createElement('input');
+    grant.type = 'hidden';
+    grant.name = 'grant';
+    grant.value = launch.grant;
+    form.append(grant);
+    document.body.append(form);
+    try {
+        form.submit();
+    }
+    finally {
+        form.remove();
+    }
+    if (!frame) {
+        // The session page gets no handle on this page. Clearing it before the
+        // submit makes WebKit open another window instead.
+        target.opener = null;
+    }
+}
+function hasExactKeys(value, keys) {
+    const own = Object.keys(value);
+    return (own.length === keys.length && keys.every((key) => Object.hasOwn(value, key)));
+}
+/**
+ * The session message in `data`, or null when `data` is not exactly one of
+ * the messages for `sessionId`. A failure may carry a null session ID.
+ */
+export function parseSessionMessage(data, sessionId) {
+    if (typeof data !== 'object' || data === null || Array.isArray(data)) {
+        return null;
+    }
+    const fields = data;
+    const { type, event, reason, sessionId: id } = fields;
+    if (type !== MESSAGE_TYPE || !EVENTS.has(event)) {
+        return null;
+    }
+    if (event === 'failure') {
+        if (!(hasExactKeys(fields, ['type', 'event', 'sessionId']) ||
+            hasExactKeys(fields, ['type', 'event', 'sessionId', 'reason'])) ||
+            (id !== sessionId && id !== null) ||
+            (reason !== undefined &&
+                !(typeof reason === 'string' && REASON.test(reason)))) {
+            return null;
+        }
+        return {
+            event,
+            sessionId: id,
+            reason: typeof reason === 'string' ? reason : null,
+        };
+    }
+    return hasExactKeys(fields, ['type', 'event', 'sessionId']) &&
+        id === sessionId
+        ? { event: event, sessionId }
+        : null;
+}
+/**
+ * Calls `onMessage` with each message that the session in `source` posts:
+ * only from the launch's exact origin, only from `source`'s window, and only
+ * for the launch's session. Every other message is ignored. Answers the
+ * function that removes the listener.
+ */
+export function listenToSession(launch, source, onMessage, options = {}) {
+    const launcher = isFrame(source)
+        ? source.ownerDocument.defaultView
+        : globalThis.window;
+    if (!launcher) {
+        throw new TypeError('The iframe is not in a window.');
+    }
+    const listener = (event) => {
+        const from = isFrame(source) ? source.contentWindow : source;
+        if (event.origin !== launch.origin || !from || event.source !== from) {
+            return;
+        }
+        const message = parseSessionMessage(event.data, launch.sessionId);
+        if (message) {
+            onMessage(message);
+        }
+    };
+    const remove = () => {
+        launcher.removeEventListener('message', listener);
+        options.signal?.removeEventListener('abort', remove);
+    };
+    if (options.signal?.aborted) {
+        return remove;
+    }
+    launcher.addEventListener('message', listener);
+    options.signal?.addEventListener('abort', remove, { once: true });
+    return remove;
+}

package/esm/funcs/launch-ui-session.d.ts

@@ -0,0 +1,15 @@
+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 models from "../models/index.js";
+import * as operations from "../models/operations/index.js";
+import { APIPromise } from "../types/async.js";
+import { Result } from "../types/fp.js";
+/**
+ * Launches a browser session of one actor in an app's UI. The answer holds a one-use grant and no reusable credential. Return it only to the browser of the user it is for, which posts the grant to `exchangeUrl` from `launcherOrigin`.
+ */
+export declare function launchUiSession(client: StateMachinesCore, request: operations.LaunchUiSessionRequest, options?: RequestOptions): APIPromise<Result<models.UiSessionLaunch, errors.ErrorT | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;

package/esm/funcs/launch-ui-session.js

@@ -0,0 +1,101 @@
+/*
+ * 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 models from "../models/index.js";
+import * as operations from "../models/operations/index.js";
+import { APIPromise } from "../types/async.js";
+/**
+ * Launches a browser session of one actor in an app's UI. The answer holds a one-use grant and no reusable credential. Return it only to the browser of the user it is for, which posts the grant to `exchangeUrl` from `launcherOrigin`.
+ */
+export function launchUiSession(client, request, options) {
+    return new APIPromise($do(client, request, options));
+}
+async function $do(client, request, options) {
+    const parsed = safeParse(request, (value) => z.parse(operations.LaunchUiSessionRequest$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 = {
+        appName: encodeSimple("appName", payload.appName, {
+            explode: false,
+            charEncoding: "percent",
+        }),
+        environmentId: encodeSimple("environmentId", payload.environmentId, {
+            explode: false,
+            charEncoding: "percent",
+        }),
+    };
+    const path = pathToFunc("/v1/environments/{environmentId}/apps/{appName}/ui-sessions")(pathParams);
+    const headers = new Headers(compactMap({
+        "Content-Type": "application/json",
+        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: "launchUiSession",
+        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(201, models.UiSessionLaunch$inboundSchema), M.jsonErr([400, 401, 403, 404, 409, 413, 422, 429], errors.ErrorT$inboundSchema), M.jsonErr([500, 503], errors.ErrorT$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/list-snapshot-creators.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 listSnapshotCreators(client: StateMachinesCore, request?: operations.ListSnapshotCreatorsRequest | undefined, options?: RequestOptions): APIPromise<Result<operations.ListSnapshotCreatorsResponse, errors.ErrorT | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;

package/esm/funcs/list-snapshot-creators.js

@@ -0,0 +1,90 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4-mini";
+import { encodeFormQuery } 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 listSnapshotCreators(client, request, options) {
+    return new APIPromise($do(client, request, options));
+}
+async function $do(client, request, options) {
+    const parsed = safeParse(request, (value) => z.parse(z.optional(operations.ListSnapshotCreatorsRequest$outboundSchema), value), "Input validation failed");
+    if (!parsed.ok) {
+        return [parsed, { status: "invalid" }];
+    }
+    const payload = parsed.value;
+    const body = null;
+    const path = pathToFunc("/v1/snapshots/creators")();
+    const query = encodeFormQuery({
+        "workspaceId": payload?.workspaceId,
+    });
+    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: "listSnapshotCreators",
+        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,
+        query: query,
+        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.ListSnapshotCreatorsResponse$inboundSchema), M.jsonErr([400, 401, 403, 404, 409, 413, 422, 429], errors.ErrorT$inboundSchema), M.jsonErr([500, 503], errors.ErrorT$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/revoke-ui-session.d.ts

@@ -0,0 +1,15 @@
+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 models from "../models/index.js";
+import * as operations from "../models/operations/index.js";
+import { APIPromise } from "../types/async.js";
+import { Result } from "../types/fp.js";
+/**
+ * Revokes a browser session that the caller's own credential launched. Revoking again answers the same result. Another credential's session is not found.
+ */
+export declare function revokeUiSession(client: StateMachinesCore, request: operations.RevokeUiSessionRequest, options?: RequestOptions): APIPromise<Result<models.UiSessionRevocation, errors.ErrorT | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;

package/esm/funcs/revoke-ui-session.js

@@ -0,0 +1,104 @@
+/*
+ * 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 models from "../models/index.js";
+import * as operations from "../models/operations/index.js";
+import { APIPromise } from "../types/async.js";
+/**
+ * Revokes a browser session that the caller's own credential launched. Revoking again answers the same result. Another credential's session is not found.
+ */
+export function revokeUiSession(client, request, options) {
+    return new APIPromise($do(client, request, options));
+}
+async function $do(client, request, options) {
+    const parsed = safeParse(request, (value) => z.parse(operations.RevokeUiSessionRequest$outboundSchema, value), "Input validation failed");
+    if (!parsed.ok) {
+        return [parsed, { status: "invalid" }];
+    }
+    const payload = parsed.value;
+    const body = null;
+    const pathParams = {
+        appName: encodeSimple("appName", payload.appName, {
+            explode: false,
+            charEncoding: "percent",
+        }),
+        environmentId: encodeSimple("environmentId", payload.environmentId, {
+            explode: false,
+            charEncoding: "percent",
+        }),
+        sessionId: encodeSimple("sessionId", payload.sessionId, {
+            explode: false,
+            charEncoding: "percent",
+        }),
+    };
+    const path = pathToFunc("/v1/environments/{environmentId}/apps/{appName}/ui-sessions/{sessionId}")(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: "revokeUiSession",
+        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, models.UiSessionRevocation$inboundSchema), M.jsonErr([400, 401, 403, 404, 409, 413, 422, 429], errors.ErrorT$inboundSchema), M.jsonErr([500, 503], errors.ErrorT$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-list.js

@@ -24,9 +24,12 @@ async function $do(client, request, options) {
     const body = null;
     const path = pathToFunc("/v1/snapshots")();
     const query = encodeFormQuery({
+        "appId": payload?.appId,
+        "createdBy": payload?.createdBy,
         "cursor": payload?.cursor,
         "environmentId": payload?.environmentId,
         "limit": payload?.limit,
+        "search": payload?.search,
         "status": payload?.status,
         "workspaceId": payload?.workspaceId,
     });

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.8.1";
+    readonly sdkVersion: "0.9.1";
     readonly genVersion: "2.941.0";
-    readonly userAgent: "speakeasy-sdk/typescript 0.8.1 2.941.0 1.0.0 @usestatemachines/sdk";
+    readonly userAgent: "speakeasy-sdk/typescript 0.9.1 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.8.1",
+    sdkVersion: "0.9.1",
     genVersion: "2.941.0",
-    userAgent: "speakeasy-sdk/typescript 0.8.1 2.941.0 1.0.0 @usestatemachines/sdk",
+    userAgent: "speakeasy-sdk/typescript 0.9.1 2.941.0 1.0.0 @usestatemachines/sdk",
 };

package/esm/models/browser-capability.d.ts

@@ -0,0 +1,12 @@
+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 BrowserCapability = {
+    acceptsClients: Array<string>;
+    contract: string;
+    documents: Array<string>;
+    entry: string;
+};
+/** @internal */
+export declare const BrowserCapability$inboundSchema: z.ZodMiniType<BrowserCapability, unknown>;
+export declare function browserCapabilityFromJSON(jsonString: string): SafeParseResult<BrowserCapability, SDKValidationError>;

package/esm/models/browser-capability.js

@@ -0,0 +1,16 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4-mini";
+import { safeParse } from "../lib/schemas.js";
+import * as types from "../types/primitives.js";
+/** @internal */
+export const BrowserCapability$inboundSchema = z.object({
+    acceptsClients: z.array(types.string()),
+    contract: types.string(),
+    documents: z.array(types.string()),
+    entry: types.string(),
+});
+export function browserCapabilityFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => BrowserCapability$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'BrowserCapability' from JSON`);
+}

package/esm/models/environment.d.ts

@@ -5,8 +5,13 @@ import { EnvironmentFailure } from "./environment-failure.js";
 import { EnvironmentStatus } from "./environment-status.js";
 import { SDKValidationError } from "./errors/sdk-validation-error.js";
 import { Principal } from "./principal.js";
+export type BrowserService = {
+    documents: Array<string>;
+    id: string;
+};
 export type EnvironmentApp = {
     appId: string;
+    browserServices?: Array<BrowserService> | undefined;
     name: string;
     services: {
         [k: string]: any;
@@ -45,6 +50,9 @@ export type Environment = {
     workspaceId: string;
 };
 /** @internal */
+export declare const BrowserService$inboundSchema: z.ZodMiniType<BrowserService, unknown>;
+export declare function browserServiceFromJSON(jsonString: string): SafeParseResult<BrowserService, SDKValidationError>;
+/** @internal */
 export declare const EnvironmentApp$inboundSchema: z.ZodMiniType<EnvironmentApp, unknown>;
 export declare function environmentAppFromJSON(jsonString: string): SafeParseResult<EnvironmentApp, SDKValidationError>;
 /** @internal */

package/esm/models/environment.js

@@ -14,8 +14,17 @@ export const Reason = {
     Failed: "failed",
 };
 /** @internal */
+export const BrowserService$inboundSchema = z.object({
+    documents: z.array(types.string()),
+    id: types.string(),
+});
+export function browserServiceFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => BrowserService$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'BrowserService' from JSON`);
+}
+/** @internal */
 export const EnvironmentApp$inboundSchema = z.object({
     appId: types.string(),
+    browserServices: types.optional(z.array(z.lazy(() => BrowserService$inboundSchema))),
     name: types.string(),
     services: z.record(z.string(), z.any()),
     setup: z.record(z.string(), z.any()),