@usestatemachines/sdk 0.7.0 → 0.8.0

package/esm/extensions/credentials.d.ts

@@ -1,13 +1,30 @@
-import type { Api } from '../models/api.js';
-import type { Credentials as CredentialsData } from '../models/credentials.js';
-/** The API's `Credentials`, plus `fetch` to call the app with them. */
+import type { Credentials as CredentialsData, CredentialsService as CredentialsServiceData } from '../models/credentials.js';
+/** What a client needs to reach one MCP server of a service: send `headers` with every request to `url`. */
+export interface McpServerCredentials {
+    url: string;
+    headers: Record<string, string>;
+}
+/** One service from the credentials, plus `server` to hand one of its MCP servers to a client. */
+export type ServiceCredentials = CredentialsServiceData & {
+    /**
+     * The URL of one MCP server the service serves, with the service's headers.
+     * Throws a `TypeError` naming the served MCP servers when it serves no MCP server
+     * named `name`.
+     */
+    server(name: string): McpServerCredentials;
+};
+/** The API's `Credentials`, plus `fetch` to call the app and `service` to find one service. */
 export type Credentials = CredentialsData & {
     /**
-     * Sends one request to the app: `path` is joined to `url`, `headers` are added, and
-     * `token` goes in the header of the API whose path matches (`Authorization: Bearer`
-     * for Salesforce REST and Bulk 2.0). Never retries, never follows redirects, never
-     * sends the State Machines API key. The SOAP session header is the caller's job.
+     * Sends one request to the `api` service: `path` is joined to its `url`.
+     * Its `headers` are defaults, so a header the caller sets, such as another
+     * session's `Authorization`, is sent instead. The environment token header
+     * is always the service's. Never retries, never follows redirects, never
+     * sends the State Machines API key. Throws a `TypeError` when the
+     * credentials list no `api` service.
      */
     fetch(path: string, init?: RequestInit): Promise<Response>;
+    /** The service with this ID. Throws a `TypeError` naming the listed services when there is none. */
+    service(id: string): ServiceCredentials;
 };
-export declare function bindCredentials(data: CredentialsData, apis: readonly Api[], fetcher: typeof fetch | undefined): Credentials;
+export declare function bindCredentials(data: CredentialsData, fetcher: typeof fetch | undefined): Credentials;

package/esm/extensions/credentials.js

@@ -1,56 +1,91 @@
-const HTTP_TOKEN = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+/** The gateway admits a request by this header, so a caller cannot replace it. */
+const ENVIRONMENT_TOKEN_HEADER = 'StateMachines-Environment-Token';
 // Checked on the path part only. 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 = 'Credentials.fetch only reaches paths under the app url.';
-export function bindCredentials(data, apis, fetcher) {
-    const base = URL.canParse(data.url) ? new URL(data.url) : null;
-    if (!base || !/^https?:$/.test(base.protocol) || base.search || base.hash) {
-        throw new TypeError('The credentials url is not a plain http(s) URL.');
-    }
-    if (!base.pathname.endsWith('/')) {
-        base.pathname += '/';
+const OUTSIDE = 'Credentials.fetch only reaches paths under the api service url.';
+export function bindCredentials(data, fetcher) {
+    return new BoundCredentials(data, fetcher);
+}
+// Methods live on the prototype, so neither JSON nor a spread copies them.
+class BoundCredentials {
+    actorId;
+    appName;
+    environmentId;
+    expiresAt;
+    login;
+    services;
+    token;
+    #api;
+    #fetcher;
+    constructor(data, fetcher) {
+        this.actorId = data.actorId;
+        this.appName = data.appName;
+        this.environmentId = data.environmentId;
+        this.expiresAt = data.expiresAt;
+        this.login = data.login;
+        this.services = data.services;
+        this.token = data.token;
+        this.#fetcher = fetcher;
+        const api = data.services.find((candidate) => candidate.id === 'api');
+        this.#api = api
+            ? { base: baseUrl(api.url), headers: { ...api.headers } }
+            : null;
     }
-    const send = async (path, init = {}) => {
+    async fetch(path, init = {}) {
+        const { base, headers: apiHeaders } = this.#api ?? this.#unlisted('api');
         const url = resolve(base, path);
         const headers = new Headers(init.headers);
-        const actor = actorHeader(apis, `/${url.pathname.slice(base.pathname.length)}`, data.token);
-        // Ours go last so a caller header of the same name cannot replace them.
-        for (const [name, value] of Object.entries(data.headers)) {
-            headers.set(name, value);
-        }
-        if (actor) {
-            headers.set(actor.name, actor.value);
+        for (const [name, value] of Object.entries(apiHeaders)) {
+            if (!headers.has(name) ||
+                name.toLowerCase() === ENVIRONMENT_TOKEN_HEADER.toLowerCase()) {
+                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 fetcher ? fetcher(request) : globalThis.fetch(request);
-    };
-    return Object.defineProperty({ ...data }, 'fetch', {
-        value: send,
-        enumerable: false,
-    });
+        return this.#fetcher ? this.#fetcher(request) : globalThis.fetch(request);
+    }
+    service(id) {
+        const entry = this.services.find((candidate) => candidate.id === id);
+        return entry ? new BoundService(entry) : this.#unlisted(id);
+    }
+    #unlisted(id) {
+        const listed = this.services.map((each) => each.id).join(', ') || 'none';
+        throw new TypeError(`These credentials list no service named ${JSON.stringify(id)}. They list ${listed}.`);
+    }
 }
-/** The longest `pathTemplate` that prefixes the path names the API; `{...}` matches one segment. */
-function actorHeader(apis, path, token) {
-    let match = null;
-    for (const api of apis) {
-        const pattern = api.pathTemplate
-            .replace(/\/+$/, '')
-            .split(/\{[^}]*\}/)
-            .map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
-            .join('[^/]+');
-        if (new RegExp(`^${pattern}(?:/|$)`).test(path) &&
-            api.pathTemplate.length > (match?.pathTemplate.length ?? -1)) {
-            match = api;
+class BoundService {
+    headers;
+    id;
+    url;
+    constructor(entry) {
+        this.headers = entry.headers;
+        this.id = entry.id;
+        this.url = entry.url;
+        // Set only when present, so a spread or JSON of a service without servers has no `servers` key.
+        if (entry.servers) {
+            this.servers = entry.servers;
+        }
+    }
+    server(name) {
+        const found = this.servers?.find((candidate) => candidate.name === name);
+        if (!found) {
+            const served = this.servers?.map((each) => each.name).join(', ') || 'none';
+            throw new TypeError(`The ${this.id} service serves no MCP server named ${JSON.stringify(name)}. It serves ${served}.`);
         }
+        return { url: found.url, headers: { ...this.headers } };
+    }
+}
+function baseUrl(url) {
+    const base = URL.canParse(url) ? new URL(url) : null;
+    if (!base || !/^https?:$/.test(base.protocol) || base.search || base.hash) {
+        throw new TypeError('The api service url is not a plain http(s) URL.');
     }
-    if (!match || !HTTP_TOKEN.test(match.actorHeader)) {
-        return null;
+    if (!base.pathname.endsWith('/')) {
+        base.pathname += '/';
     }
-    return match.actorHeader.toLowerCase() === 'authorization'
-        ? { name: 'Authorization', value: `Bearer ${token}` }
-        : { name: match.actorHeader, value: token };
+    return base;
 }
 function resolve(base, path) {
     const pathPart = path.split(/[?#]/, 1)[0] ?? '';

package/esm/extensions/environment.d.ts

@@ -9,7 +9,7 @@ import type { Credentials } from './credentials.js';
 export type Environment = EnvironmentData & EnvironmentHelpers;
 export interface EnvironmentHelpers {
     /** Credentials for one app; `actorId` defaults to the app's default actor. */
-    connect(app: string, options?: ConnectOptions): Promise<Credentials>;
+    connect(appName: string, options?: ConnectOptions): Promise<Credentials>;
     delete(options?: SignalOptions): Promise<Environment>;
     /** Reads the environment again. */
     refresh(): Promise<Environment>;

package/esm/extensions/errors.js

@@ -48,7 +48,7 @@ export class EnvironmentFailedError extends StateMachinesError {
         super({
             ...noResponse,
             message: failure
-                ? `Environment ${environment.id} failed: ${failure.message} (${failure.code}, app ${failure.app}).`
+                ? `Environment ${environment.id} failed: ${failure.message} (${failure.code}, app ${failure.appName}).`
                 : `Environment ${environment.id} failed.`,
         });
         this.environment = environment;

package/esm/extensions/index.d.ts

@@ -1,7 +1,7 @@
-export type { Actor, Api, App, AuditEvent, BodyPreview, CreateEnvironment, CreateEnvironmentApp, EnvironmentApp, EnvironmentFailure, EnvironmentFailureCode, EnvironmentStatus, ErrorCode, Me, Permission, Principal, RequestDetail, RequestStats, RequestT as Request, Snapshot, SnapshotStatus, Version, Workspace, } from '../models/index.js';
+export type { Actor, App, AppEntry, AuditEvent, BodyPreview, CreateEnvironment, CreateEnvironmentApp, EnvironmentApp, EnvironmentFailure, EnvironmentFailureCode, EnvironmentStatus, ErrorCode, Me, Permission, Principal, RequestDetail, RequestStats, RequestT as Request, Snapshot, SnapshotStatus, Version, Workspace, } from '../models/index.js';
 export type { ConnectOptions, CreateEnvironmentOptions, CreateSnapshotOptions, ListAuditEventsQuery, ListEnvironmentsQuery, ListRequestsQuery, ListSnapshotsQuery, ListWorkspacesQuery, Page, PageQuery, RequestStatsQuery, SignalOptions, StateMachinesOptions, } from './client.js';
 export { StateMachines } from './client.js';
-export type { Credentials } from './credentials.js';
+export type { Credentials, McpServerCredentials, ServiceCredentials, } from './credentials.js';
 export type { Environment, EnvironmentHelpers } from './environment.js';
 export { EnvironmentFailedError, SnapshotFailedError, StateMachinesError, UnexpectedStatusError, WaitTimeoutError, } from './errors.js';
 export type { WaitOptions } from './wait.js';

package/esm/extensions/yaml.js

@@ -1,6 +1,6 @@
 import { isAlias, isScalar, parseDocument, visit } from 'yaml';
 import { invalidInput } from './errors.js';
-const APP_FIELDS = new Set(['app', 'name', 'settings']);
+const APP_FIELDS = new Set(['appId', 'name', 'setup', 'services']);
 /**
  * Parses a YAML document with the fields of `CreateEnvironment`. The SDK checks the shape;
  * the API checks the values. Anchors, aliases, tags and duplicate keys are refused.
@@ -97,8 +97,8 @@ export function parseEnvironmentYaml(text) {
                 add(key, 'Unknown field.');
         }
     }
-    if ('apps' in value === 'snapshotId' in value) {
-        add('$', 'Pass exactly one of apps and snapshotId.');
+    if (!('apps' in value) && !('snapshotId' in value)) {
+        add('$', 'Send apps, snapshotId or both.');
     }
     if (Object.keys(fields).length > 0) {
         throw bad(fields);
@@ -110,22 +110,24 @@ function checkApp(app, path, add) {
         return;
     }
     if (!isRecord(app)) {
-        add(path, 'Expected an app ID or a mapping with app.');
+        add(path, 'Expected an app ID or a mapping with appId.');
         return;
     }
-    const { app: id, name, settings } = app;
-    if (typeof id !== 'string') {
-        add(`${path}.app`, 'Expected a string.');
+    const { appId, name } = app;
+    if (typeof appId !== 'string') {
+        add(`${path}.appId`, 'Expected a string.');
     }
     if ('name' in app && typeof name !== 'string') {
         add(`${path}.name`, 'Expected a string.');
     }
-    if ('settings' in app && !isRecord(settings)) {
-        add(`${path}.settings`, 'Expected a mapping.');
+    for (const field of ['setup', 'services']) {
+        if (field in app && !isRecord(app[field])) {
+            add(`${path}.${field}`, 'Expected a mapping.');
+        }
     }
-    for (const key of Object.keys(app)) {
-        if (!APP_FIELDS.has(key)) {
-            add(`${path}.${key}`, 'Unknown field.');
+    for (const field of Object.keys(app)) {
+        if (!APP_FIELDS.has(field)) {
+            add(`${path}.${field}`, 'Unknown field.');
         }
     }
 }

package/esm/funcs/environments-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 environmentsCreators(client: StateMachinesCore, request?: operations.ListEnvironmentCreatorsRequest | undefined, options?: RequestOptions): APIPromise<Result<operations.ListEnvironmentCreatorsResponse, errors.ErrorT | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;

package/esm/funcs/environments-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 environmentsCreators(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.ListEnvironmentCreatorsRequest$outboundSchema), value), "Input validation failed");
+    if (!parsed.ok) {
+        return [parsed, { status: "invalid" }];
+    }
+    const payload = parsed.value;
+    const body = null;
+    const path = pathToFunc("/v1/environments/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: "listEnvironmentCreators",
+        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.ListEnvironmentCreatorsResponse$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/environments-list.js

@@ -24,6 +24,8 @@ async function $do(client, request, options) {
     const body = null;
     const path = pathToFunc("/v1/environments")();
     const query = encodeFormQuery({
+        "appId": payload?.appId,
+        "createdBy": payload?.createdBy,
         "cursor": payload?.cursor,
         "label": payload?.label,
         "limit": payload?.limit,

package/esm/funcs/requests-list.js

@@ -24,16 +24,20 @@ async function $do(client, request, options) {
     const body = null;
     const path = pathToFunc("/v1/requests")();
     const query = encodeFormQuery({
-        "app": payload.app,
+        "appName": payload.appName,
         "cursor": payload.cursor,
         "environmentId": payload.environmentId,
         "from": payload.from,
         "limit": payload.limit,
+        "mcpServer": payload.mcpServer,
         "method": payload.method,
+        "operation": payload.operation,
         "responseStatus": payload.responseStatus,
         "search": payload.search,
+        "service": payload.service,
         "statusClass": payload.statusClass,
         "to": payload.to,
+        "tool": payload.tool,
         "writesOnly": payload.writesOnly,
     });
     const headers = new Headers(compactMap({

package/esm/funcs/requests-stats.js

@@ -25,14 +25,18 @@ async function $do(client, request, options) {
     const body = null;
     const path = pathToFunc("/v1/requests/stats")();
     const query = encodeFormQuery({
-        "app": payload.app,
+        "appName": payload.appName,
         "environmentId": payload.environmentId,
         "from": payload.from,
+        "mcpServer": payload.mcpServer,
         "method": payload.method,
+        "operation": payload.operation,
         "responseStatus": payload.responseStatus,
         "search": payload.search,
+        "service": payload.service,
         "statusClass": payload.statusClass,
         "to": payload.to,
+        "tool": payload.tool,
         "writesOnly": payload.writesOnly,
     });
     const headers = new Headers(compactMap({

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.7.0";
+    readonly sdkVersion: "0.8.0";
     readonly genVersion: "2.941.0";
-    readonly userAgent: "speakeasy-sdk/typescript 0.7.0 2.941.0 1.0.0 @usestatemachines/sdk";
+    readonly userAgent: "speakeasy-sdk/typescript 0.8.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.7.0",
+    sdkVersion: "0.8.0",
     genVersion: "2.941.0",
-    userAgent: "speakeasy-sdk/typescript 0.7.0 2.941.0 1.0.0 @usestatemachines/sdk",
+    userAgent: "speakeasy-sdk/typescript 0.8.0 2.941.0 1.0.0 @usestatemachines/sdk",
 };

package/esm/models/app-entry.d.ts

@@ -0,0 +1,8 @@
+import * as z from "zod/v4-mini";
+import { CreateEnvironmentApp, CreateEnvironmentApp$Outbound } from "./create-environment-app.js";
+export type AppEntry = CreateEnvironmentApp | string;
+/** @internal */
+export type AppEntry$Outbound = CreateEnvironmentApp$Outbound | string;
+/** @internal */
+export declare const AppEntry$outboundSchema: z.ZodMiniType<AppEntry$Outbound, AppEntry>;
+export declare function appEntryToJSON(appEntry: AppEntry): string;

package/esm/models/app-entry.js

@@ -0,0 +1,11 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4-mini";
+import { smartUnion } from "../types/smart-union.js";
+import { CreateEnvironmentApp$outboundSchema, } from "./create-environment-app.js";
+/** @internal */
+export const AppEntry$outboundSchema = smartUnion([CreateEnvironmentApp$outboundSchema, z.string()]);
+export function appEntryToJSON(appEntry) {
+    return JSON.stringify(AppEntry$outboundSchema.parse(appEntry));
+}

package/esm/models/create-environment-app.d.ts

@@ -0,0 +1,25 @@
+import * as z from "zod/v4-mini";
+export type CreateEnvironmentApp = {
+    appId: string;
+    name?: string | undefined;
+    services?: {
+        [k: string]: any;
+    } | undefined;
+    setup?: {
+        [k: string]: any;
+    } | undefined;
+};
+/** @internal */
+export type CreateEnvironmentApp$Outbound = {
+    appId: string;
+    name?: string | undefined;
+    services?: {
+        [k: string]: any;
+    } | undefined;
+    setup?: {
+        [k: string]: any;
+    } | undefined;
+};
+/** @internal */
+export declare const CreateEnvironmentApp$outboundSchema: z.ZodMiniType<CreateEnvironmentApp$Outbound, CreateEnvironmentApp>;
+export declare function createEnvironmentAppToJSON(createEnvironmentApp: CreateEnvironmentApp): string;

package/esm/models/create-environment-app.js

@@ -0,0 +1,14 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4-mini";
+/** @internal */
+export const CreateEnvironmentApp$outboundSchema = z.object({
+    appId: z.string(),
+    name: z.optional(z.string()),
+    services: z.optional(z.record(z.string(), z.any())),
+    setup: z.optional(z.record(z.string(), z.any())),
+});
+export function createEnvironmentAppToJSON(createEnvironmentApp) {
+    return JSON.stringify(CreateEnvironmentApp$outboundSchema.parse(createEnvironmentApp));
+}

package/esm/models/create-environment.d.ts

@@ -1,14 +1,7 @@
 import * as z from "zod/v4-mini";
-export type CreateEnvironmentApp = {
-    app: string;
-    name?: string | undefined;
-    settings?: {
-        [k: string]: any;
-    } | undefined;
-};
-export type AppUnion = CreateEnvironmentApp | string;
+import { AppEntry, AppEntry$Outbound } from "./app-entry.js";
 export type CreateEnvironment = {
-    apps?: Array<CreateEnvironmentApp | string> | undefined;
+    apps?: Array<AppEntry> | undefined;
     labels?: {
         [k: string]: string;
     } | undefined;
@@ -19,24 +12,8 @@ export type CreateEnvironment = {
     workspaceId?: string | undefined;
 };
 /** @internal */
-export type CreateEnvironmentApp$Outbound = {
-    app: string;
-    name?: string | undefined;
-    settings?: {
-        [k: string]: any;
-    } | undefined;
-};
-/** @internal */
-export declare const CreateEnvironmentApp$outboundSchema: z.ZodMiniType<CreateEnvironmentApp$Outbound, CreateEnvironmentApp>;
-export declare function createEnvironmentAppToJSON(createEnvironmentApp: CreateEnvironmentApp): string;
-/** @internal */
-export type AppUnion$Outbound = CreateEnvironmentApp$Outbound | string;
-/** @internal */
-export declare const AppUnion$outboundSchema: z.ZodMiniType<AppUnion$Outbound, AppUnion>;
-export declare function appUnionToJSON(appUnion: AppUnion): string;
-/** @internal */
 export type CreateEnvironment$Outbound = {
-    apps?: Array<CreateEnvironmentApp$Outbound | string> | undefined;
+    apps?: Array<AppEntry$Outbound> | undefined;
     labels?: {
         [k: string]: string;
     } | undefined;

package/esm/models/create-environment.js

@@ -2,27 +2,10 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 import * as z from "zod/v4-mini";
-import { smartUnion } from "../types/smart-union.js";
-/** @internal */
-export const CreateEnvironmentApp$outboundSchema = z.object({
-    app: z.string(),
-    name: z.optional(z.string()),
-    settings: z.optional(z.record(z.string(), z.any())),
-});
-export function createEnvironmentAppToJSON(createEnvironmentApp) {
-    return JSON.stringify(CreateEnvironmentApp$outboundSchema.parse(createEnvironmentApp));
-}
-/** @internal */
-export const AppUnion$outboundSchema = smartUnion([z.lazy(() => CreateEnvironmentApp$outboundSchema), z.string()]);
-export function appUnionToJSON(appUnion) {
-    return JSON.stringify(AppUnion$outboundSchema.parse(appUnion));
-}
+import { AppEntry$outboundSchema, } from "./app-entry.js";
 /** @internal */
 export const CreateEnvironment$outboundSchema = z.object({
-    apps: z.optional(z.array(smartUnion([
-        z.lazy(() => CreateEnvironmentApp$outboundSchema),
-        z.string(),
-    ]))),
+    apps: z.optional(z.array(AppEntry$outboundSchema)),
     labels: z.optional(z.record(z.string(), z.string())),
     name: z.optional(z.nullable(z.string())),
     snapshotId: z.optional(z.string()),

package/esm/models/credential.d.ts

@@ -0,0 +1,50 @@
+import * as z from "zod/v4-mini";
+import * as discriminatedUnionTypes from "../types/discriminated-union.js";
+import { OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+export declare const ApiKeyKind: {
+    readonly Dashboard: "dashboard";
+    readonly CliRun: "cli_run";
+    readonly EnvPull: "env_pull";
+};
+export type ApiKeyKind = OpenEnum<typeof ApiKeyKind>;
+export type CredentialAPIKey = {
+    apiKeyKind: ApiKeyKind;
+    expiresAt: Date | null;
+    id: string;
+    idleExpiresAt: any | null;
+    kind: "api_key";
+    name: string;
+};
+export type CredentialCliToken = {
+    apiKeyKind: any | null;
+    expiresAt: Date;
+    id: string;
+    idleExpiresAt: Date;
+    kind: "cli_token";
+    name: string;
+};
+export type CredentialSession = {
+    apiKeyKind: any | null;
+    expiresAt: Date;
+    id: string;
+    idleExpiresAt: any | null;
+    kind: "session";
+    name: any | null;
+};
+export type Credential = CredentialSession | CredentialCliToken | CredentialAPIKey | discriminatedUnionTypes.Unknown<"kind">;
+/** @internal */
+export declare const ApiKeyKind$inboundSchema: z.ZodMiniType<ApiKeyKind, unknown>;
+/** @internal */
+export declare const CredentialAPIKey$inboundSchema: z.ZodMiniType<CredentialAPIKey, unknown>;
+export declare function credentialAPIKeyFromJSON(jsonString: string): SafeParseResult<CredentialAPIKey, SDKValidationError>;
+/** @internal */
+export declare const CredentialCliToken$inboundSchema: z.ZodMiniType<CredentialCliToken, unknown>;
+export declare function credentialCliTokenFromJSON(jsonString: string): SafeParseResult<CredentialCliToken, SDKValidationError>;
+/** @internal */
+export declare const CredentialSession$inboundSchema: z.ZodMiniType<CredentialSession, unknown>;
+export declare function credentialSessionFromJSON(jsonString: string): SafeParseResult<CredentialSession, SDKValidationError>;
+/** @internal */
+export declare const Credential$inboundSchema: z.ZodMiniType<Credential, unknown>;
+export declare function credentialFromJSON(jsonString: string): SafeParseResult<Credential, SDKValidationError>;