@usestatemachines/sdk 0.4.0 → 0.6.0

package/esm/extensions/wait.js

@@ -1,15 +1,64 @@
-import { DisposalIncompleteError, EnvironmentFailedError, SnapshotFailedError, TimeoutError, toStateMachinesError, } from './errors.js';
+import { EnvironmentFailedError, isTransient, SnapshotFailedError, toStateMachinesError, UnexpectedStatusError, WaitTimeoutError, } from './errors.js';
 import { linkSignal } from './signal.js';
 export const defaultTimeoutMs = 600000;
 const readTimeoutMs = 30000;
-export function poll(read, done, options) {
-    return pollUntil(read, done, options, (timeoutMs, last) => new TimeoutError(timeoutMs, last));
+/**
+ * The statuses each status reaches with no call from the customer: a boot ends, a restart
+ * fails, the time limit passes, a paused or failed environment expires after a day.
+ */
+const environmentReaches = {
+    starting: ['running', 'failed', 'deleted'],
+    running: ['failed', 'deleted'],
+    paused: ['deleted'],
+    failed: ['deleted'],
+    deleted: [],
+};
+const snapshotReaches = {
+    saving: ['ready', 'failed'],
+    ready: [],
+    failed: [],
+    deleted: [],
+};
+/** True at the target; false while the target is still reachable; throws otherwise. */
+export function environmentAt(target) {
+    return (environment) => {
+        const { status } = environment;
+        if (status === target) {
+            return true;
+        }
+        // An unknown status may be a step this SDK predates, so the wait goes on.
+        const reaches = environmentReaches[status] ?? null;
+        if (!reaches || reaches.includes(target)) {
+            return false;
+        }
+        if (status === 'failed' ||
+            (status === 'deleted' && environment.reason === 'failed')) {
+            throw new EnvironmentFailedError(environment);
+        }
+        throw new UnexpectedStatusError(environment, target);
+    };
+}
+export function snapshotAt(target) {
+    return (snapshot) => {
+        const { status } = snapshot;
+        if (status === target) {
+            return true;
+        }
+        const reaches = snapshotReaches[status] ?? null;
+        if (!reaches || reaches.includes(target)) {
+            return false;
+        }
+        if (status === 'failed') {
+            throw new SnapshotFailedError(snapshot);
+        }
+        throw new UnexpectedStatusError(snapshot, target);
+    };
 }
 /**
- * Reads until `done` returns true. `done` throws to end the wait with a failure.
+ * Reads until `done` returns true; `done` throws to end the wait with a failure.
  * Transient read failures are retried with backoff until the deadline.
  */
-export async function pollUntil(read, done, options = {}, timeout) {
+export async function poll(id, read, done, options = {}) {
     const { signal } = options;
     const timeoutMs = options.timeoutMs ?? defaultTimeoutMs;
     if (!(timeoutMs >= 0)) {
@@ -17,11 +66,12 @@ export async function pollUntil(read, done, options = {}, timeout) {
     }
     const deadline = Date.now() + timeoutMs;
     let last = null;
+    const timeout = () => new WaitTimeoutError(last, timeoutMs, id);
     for (let attempt = 0;; attempt += 1) {
         signal?.throwIfAborted();
         const remaining = deadline - Date.now();
         if (remaining <= 0) {
-            throw timeout(timeoutMs, last);
+            throw timeout();
         }
         let waitMs = backoff(attempt);
         let value = null;
@@ -34,14 +84,14 @@ export async function pollUntil(read, done, options = {}, timeout) {
             // Classify by signal state: a stalled body read surfaces as an arbitrary error.
             signal?.throwIfAborted();
             if (Date.now() >= deadline) {
-                throw timeout(timeoutMs, last);
+                throw timeout();
             }
             if (!link.signal.aborted) {
                 const failure = toStateMachinesError(error);
-                if (!failure.retryable) {
+                if (!isTransient(failure)) {
                     throw failure;
                 }
-                waitMs = Math.max(waitMs, failure.retryAfter ?? 0);
+                waitMs = Math.max(waitMs, failure.retryAfterMs ?? 0);
             }
         }
         finally {
@@ -50,7 +100,7 @@ export async function pollUntil(read, done, options = {}, timeout) {
         // A read can settle after an abort or past the deadline; neither may resolve the wait.
         signal?.throwIfAborted();
         if (Date.now() >= deadline) {
-            throw timeout(timeoutMs, last);
+            throw timeout();
         }
         if (value !== null && done(value)) {
             return value;
@@ -58,52 +108,6 @@ export async function pollUntil(read, done, options = {}, timeout) {
         await sleep(Math.min(waitMs, deadline - Date.now()), signal);
     }
 }
-/** Resolves on `running`. Never suspends or stops the environment. */
-export function ready(environment) {
-    switch (environment.status) {
-        case 'running':
-            return true;
-        case 'failed':
-        case 'suspending':
-        case 'suspended':
-        case 'stopping':
-        case 'stopped':
-            throw new EnvironmentFailedError(environment);
-        default:
-            return false;
-    }
-}
-/** Resolves on `suspended`, when the environment can resume. */
-export function suspended(environment) {
-    switch (environment.status) {
-        case 'suspended':
-            return true;
-        case 'failed':
-        case 'stopping':
-        case 'stopped':
-            throw new EnvironmentFailedError(environment);
-        default:
-            return false;
-    }
-}
-/** Resolves once the environment ended and every app's sandbox is confirmed disposed. */
-export function disposed(environment) {
-    if (environment.status !== 'stopped' && environment.status !== 'failed') {
-        return false;
-    }
-    const unconfirmed = environment.apps.some(({ disposal }) => disposal === 'failed' || disposal === 'unknown');
-    if (unconfirmed) {
-        throw new DisposalIncompleteError(environment);
-    }
-    return environment.apps.every((app) => app.disposal === 'complete');
-}
-/** Resolves on `ready`. A failed or deleted snapshot ends the wait. */
-export function snapshotReady(snapshot) {
-    if (snapshot.status === 'failed' || snapshot.deletedAt) {
-        throw new SnapshotFailedError(snapshot);
-    }
-    return snapshot.status === 'ready';
-}
 /** 1 s × 1.5ⁿ, capped at 5 s, with ±20% jitter. */
 export function backoff(attempt) {
     return Math.min(5000, 1000 * 1.5 ** attempt) * (0.8 + Math.random() * 0.4);

package/esm/extensions/yaml.d.ts

@@ -0,0 +1,6 @@
+import type { CreateEnvironment } from '../models/create-environment.js';
+/**
+ * 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.
+ */
+export declare function parseEnvironmentYaml(text: string): CreateEnvironment;

package/esm/extensions/yaml.js

@@ -0,0 +1,137 @@
+import { isAlias, isScalar, parseDocument, visit } from 'yaml';
+import { invalidInput } from './errors.js';
+const APP_FIELDS = new Set(['app', 'name', 'settings']);
+/**
+ * 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.
+ */
+export function parseEnvironmentYaml(text) {
+    const document = parseDocument(text, {
+        version: '1.2',
+        strict: true,
+        uniqueKeys: true,
+        merge: false,
+        resolveKnownTags: false,
+    });
+    const issue = document.errors[0] ?? document.warnings[0];
+    if (issue) {
+        const position = issue.linePos?.[0];
+        throw bad({
+            $: [
+                `Invalid YAML${position ? ` at ${position.line}:${position.col}` : ''}: ${issue.code}.`,
+            ],
+        });
+    }
+    let refused = null;
+    visit(document, {
+        Node(_key, node) {
+            if (isAlias(node) || ('anchor' in node && node.anchor) || node.tag) {
+                refused = 'Anchors, aliases and tags are not supported.';
+                return visit.BREAK;
+            }
+            return undefined;
+        },
+        Pair(_key, pair) {
+            if (!isScalar(pair.key) || typeof pair.key.value !== 'string') {
+                refused = 'Every key must be a string.';
+                return visit.BREAK;
+            }
+            return undefined;
+        },
+    });
+    if (refused) {
+        throw bad({ $: [refused] });
+    }
+    const value = document.toJS({ maxAliasCount: 0 });
+    const fields = {};
+    const add = (path, message) => {
+        fields[path] = [...(fields[path] ?? []), message];
+    };
+    if (!isRecord(value)) {
+        throw bad({ $: ['The document must be a mapping.'] });
+    }
+    for (const [key, field] of Object.entries(value)) {
+        switch (key) {
+            case 'workspaceId':
+            case 'snapshotId':
+                if (typeof field !== 'string') {
+                    add(key, 'Expected a string.');
+                }
+                break;
+            case 'name':
+                if (field !== null && typeof field !== 'string') {
+                    add(key, 'Expected a string or null.');
+                }
+                break;
+            case 'tokenInUrl':
+                if (typeof field !== 'boolean') {
+                    add(key, 'Expected a boolean.');
+                }
+                break;
+            case 'timeLimitMinutes':
+                if (!Number.isInteger(field)) {
+                    add(key, 'Expected an integer.');
+                }
+                break;
+            case 'labels':
+                if (!isRecord(field)) {
+                    add(key, 'Expected a mapping.');
+                    break;
+                }
+                for (const [label, text] of Object.entries(field)) {
+                    if (typeof text !== 'string') {
+                        add(`labels.${label}`, 'Expected a string.');
+                    }
+                }
+                break;
+            case 'apps':
+                if (!Array.isArray(field)) {
+                    add(key, 'Expected a list.');
+                    break;
+                }
+                for (const [index, app] of field.entries()) {
+                    checkApp(app, `apps.${index}`, add);
+                }
+                break;
+            default:
+                add(key, 'Unknown field.');
+        }
+    }
+    if ('apps' in value === 'snapshotId' in value) {
+        add('$', 'Pass exactly one of apps and snapshotId.');
+    }
+    if (Object.keys(fields).length > 0) {
+        throw bad(fields);
+    }
+    return value;
+}
+function checkApp(app, path, add) {
+    if (typeof app === 'string') {
+        return;
+    }
+    if (!isRecord(app)) {
+        add(path, 'Expected an app ID or a mapping with app.');
+        return;
+    }
+    const { app: id, name, settings } = app;
+    if (typeof id !== 'string') {
+        add(`${path}.app`, '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 key of Object.keys(app)) {
+        if (!APP_FIELDS.has(key)) {
+            add(`${path}.${key}`, 'Unknown field.');
+        }
+    }
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function bad(fields) {
+    return invalidInput('The environment YAML is invalid.', fields);
+}

package/esm/funcs/{catalog-release.d.ts → apps-list.d.ts}

@@ -8,4 +8,4 @@ import { StateMachinesHTTPError } from "../models/errors/state-machines-http-err
 import * as operations from "../models/operations/index.js";
 import { APIPromise } from "../types/async.js";
 import { Result } from "../types/fp.js";
-export declare function catalogRelease(client: StateMachinesCore, request: operations.GetReleaseRequest, options?: RequestOptions): APIPromise<Result<operations.GetReleaseResponse, errors.ErrorResponse | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+export declare function appsList(client: StateMachinesCore, request?: operations.ListAppsRequest | undefined, options?: RequestOptions): APIPromise<Result<operations.ListAppsResponse, errors.ErrorT | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;

package/esm/funcs/apps-list.js

@@ -0,0 +1,91 @@
+/*
+ * 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 appsList(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.ListAppsRequest$outboundSchema), value), "Input validation failed");
+    if (!parsed.ok) {
+        return [parsed, { status: "invalid" }];
+    }
+    const payload = parsed.value;
+    const body = null;
+    const path = pathToFunc("/v1/apps")();
+    const query = encodeFormQuery({
+        "cursor": payload?.cursor,
+        "limit": payload?.limit,
+    });
+    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: "listApps",
+        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.ListAppsResponse$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/{credential-get.d.ts → apps-versions.d.ts}

@@ -8,4 +8,4 @@ import { StateMachinesHTTPError } from "../models/errors/state-machines-http-err
 import * as operations from "../models/operations/index.js";
 import { APIPromise } from "../types/async.js";
 import { Result } from "../types/fp.js";
-export declare function credentialGet(client: StateMachinesCore, options?: RequestOptions): APIPromise<Result<operations.GetCredentialResponse, errors.ErrorResponse | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+export declare function appsVersions(client: StateMachinesCore, request: operations.ListVersionsRequest, options?: RequestOptions): APIPromise<Result<operations.ListVersionsResponse, errors.ErrorT | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;

package/esm/funcs/{workspaces-events.js → apps-versions.js}

@@ -10,26 +10,25 @@ 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";
-export function workspacesEvents(client, request, options) {
+export function appsVersions(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => z.parse(operations.ListWorkspaceEventsRequest$outboundSchema, value), "Input validation failed");
+    const parsed = safeParse(request, (value) => z.parse(operations.ListVersionsRequest$outboundSchema, value), "Input validation failed");
     if (!parsed.ok) {
         return [parsed, { status: "invalid" }];
     }
     const payload = parsed.value;
     const body = null;
     const pathParams = {
-        workspaceId: encodeSimple("workspaceId", payload.workspaceId, {
+        appId: encodeSimple("appId", payload.appId, {
             explode: false,
             charEncoding: "percent",
         }),
     };
-    const path = pathToFunc("/v1/workspaces/{workspaceId}/events")(pathParams);
+    const path = pathToFunc("/v1/apps/{appId}/versions")(pathParams);
     const query = encodeFormQuery({
         "cursor": payload.cursor,
         "limit": payload.limit,
@@ -43,7 +42,7 @@ async function $do(client, request, options) {
     const context = {
         options: client._options,
         baseURL: options?.serverURL ?? client._baseURL ?? "",
-        operationID: "listWorkspaceEvents",
+        operationID: "listVersions",
         oAuth2Scopes: null,
         resolvedSecurity: requestSecurity,
         securitySource: client._options.apiKey,
@@ -90,7 +89,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, models.EventPage$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 });
+    const [result] = await M.match(M.json(200, operations.ListVersionsResponse$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 }];
     }

package/esm/funcs/{environments-get-connection.d.ts → audit-events-list.d.ts}

@@ -8,4 +8,4 @@ import { StateMachinesHTTPError } from "../models/errors/state-machines-http-err
 import * as operations from "../models/operations/index.js";
 import { APIPromise } from "../types/async.js";
 import { Result } from "../types/fp.js";
-export declare function environmentsGetConnection(client: StateMachinesCore, request: operations.GetConnectionRequest, options?: RequestOptions): APIPromise<Result<operations.GetConnectionResponse, errors.ErrorResponse | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+export declare function auditEventsList(client: StateMachinesCore, request?: operations.ListAuditEventsRequest | undefined, options?: RequestOptions): APIPromise<Result<operations.ListAuditEventsResponse, errors.ErrorT | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;

package/esm/funcs/audit-events-list.js

@@ -0,0 +1,93 @@
+/*
+ * 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 auditEventsList(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.ListAuditEventsRequest$outboundSchema), value), "Input validation failed");
+    if (!parsed.ok) {
+        return [parsed, { status: "invalid" }];
+    }
+    const payload = parsed.value;
+    const body = null;
+    const path = pathToFunc("/v1/audit-events")();
+    const query = encodeFormQuery({
+        "cursor": payload?.cursor,
+        "environmentId": payload?.environmentId,
+        "limit": payload?.limit,
+        "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: "listAuditEvents",
+        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.ListAuditEventsResponse$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/{workspaces-events.d.ts → environments-connect.d.ts}

@@ -9,4 +9,4 @@ 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";
-export declare function workspacesEvents(client: StateMachinesCore, request: operations.ListWorkspaceEventsRequest, options?: RequestOptions): APIPromise<Result<models.EventPage, errors.ErrorResponse | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+export declare function environmentsConnect(client: StateMachinesCore, request: operations.CreateCredentialsRequest, options?: RequestOptions): APIPromise<Result<models.Credentials, errors.ErrorT | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;

package/esm/funcs/{environments-reveal.js → environments-connect.js}

@@ -10,20 +10,21 @@ 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";
-export function environmentsReveal(client, request, options) {
+export function environmentsConnect(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => z.parse(operations.RevealConnectionRequest$outboundSchema, value), "Input validation failed");
+    const parsed = safeParse(request, (value) => z.parse(operations.CreateCredentialsRequest$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 = {
-        appKey: encodeSimple("appKey", payload.appKey, {
+        appName: encodeSimple("appName", payload.appName, {
             explode: false,
             charEncoding: "percent",
         }),
@@ -32,7 +33,7 @@ async function $do(client, request, options) {
             charEncoding: "percent",
         }),
     };
-    const path = pathToFunc("/v1/environments/{environmentId}/apps/{appKey}/connection/reveal")(pathParams);
+    const path = pathToFunc("/v1/environments/{environmentId}/apps/{appName}/credentials")(pathParams);
     const headers = new Headers(compactMap({
         "Content-Type": "application/json",
         Accept: "application/json",
@@ -43,7 +44,7 @@ async function $do(client, request, options) {
     const context = {
         options: client._options,
         baseURL: options?.serverURL ?? client._baseURL ?? "",
-        operationID: "revealConnection",
+        operationID: "createCredentials",
         oAuth2Scopes: null,
         resolvedSecurity: requestSecurity,
         securitySource: client._options.apiKey,
@@ -89,7 +90,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, operations.RevealConnectionResponse$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 });
+    const [result] = await M.match(M.json(200, models.Credentials$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 }];
     }

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

@@ -5,7 +5,8 @@ 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";
-export declare function environmentsCreate(client: StateMachinesCore, request: operations.CreateEnvironmentsRequest, options?: RequestOptions): APIPromise<Result<operations.CreateEnvironmentsResponse, errors.ErrorResponse | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+export declare function environmentsCreate(client: StateMachinesCore, request: operations.CreateEnvironmentRequest, options?: RequestOptions): APIPromise<Result<models.Environment, errors.ErrorT | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;