@usestatemachines/sdk 0.11.0 → 0.12.0

package/esm/extensions/zip.js

@@ -0,0 +1,121 @@
+// APPNOTE.TXT 4.3 and 4.4: the signature of each record, version 2.0 to
+// read, a Unix host in the high byte of `version made by`, bit 11 of the
+// flags for a UTF-8 name, method 0 to store, 1980-01-01 as the earliest
+// MS-DOS date, and 0xffff and 0xffffffff for values in ZIP64. Info-ZIP keeps
+// the mode of a file from a Unix host in the high 16 bits of the external
+// attributes.
+const LOCAL_HEADER = 0x04034b50;
+const DIRECTORY_HEADER = 0x02014b50;
+const END_OF_DIRECTORY = 0x06054b50;
+const VERSION = 20;
+const MADE_BY_UNIX = (3 << 8) | VERSION;
+const UTF8_NAME = 0x800;
+const STORED = 0;
+const EARLIEST_DATE = (1 << 5) | 1;
+const REGULAR_FILE = 0o100644 * 0x10000;
+const MOST_ENTRIES = 0xfffe;
+const MOST_BYTES = 0xfffffffe;
+const utf8 = new TextEncoder();
+const textOrder = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
+/**
+ * A zip file of `files`, keyed by their paths, in the order of their paths.
+ * Each file is stored, with a UTF-8 name, the earliest MS-DOS time, and no
+ * extra field, so the same files always give the same bytes. It refuses what
+ * needs ZIP64. It needs no `node:zlib`, because the SDK imports no Node
+ * module and runs in Cloudflare Workers.
+ */
+export function zipFiles(files) {
+    if (files.size > MOST_ENTRIES) {
+        throw new RangeError(`A zip file holds at most ${MOST_ENTRIES} files.`);
+    }
+    const parts = [];
+    const directory = [];
+    let offset = 0;
+    for (const [path, bytes] of [...files].sort(([a], [b]) => textOrder(a, b))) {
+        if (bytes.length > MOST_BYTES) {
+            throw new RangeError(`A file in a zip file holds at most ${MOST_BYTES} bytes.`);
+        }
+        const name = utf8.encode(path);
+        const shared = [
+            [2, VERSION],
+            [2, UTF8_NAME],
+            [2, STORED],
+            [2, 0],
+            [2, EARLIEST_DATE],
+            [4, crc32(bytes)],
+            [4, bytes.length],
+            [4, bytes.length],
+            [2, name.length],
+            [2, 0],
+        ];
+        const local = record([[4, LOCAL_HEADER], ...shared], name);
+        directory.push(record([
+            [4, DIRECTORY_HEADER],
+            [2, MADE_BY_UNIX],
+            ...shared,
+            [2, 0],
+            [2, 0],
+            [2, 0],
+            [4, REGULAR_FILE],
+            [4, offset],
+        ], name));
+        parts.push(local, bytes);
+        offset += local.length + bytes.length;
+    }
+    const size = directory.reduce((sum, header) => sum + header.length, 0);
+    if (offset + size > MOST_BYTES) {
+        throw new RangeError(`A zip file holds at most ${MOST_BYTES} bytes.`);
+    }
+    const end = record([
+        [4, END_OF_DIRECTORY],
+        [2, 0],
+        [2, 0],
+        [2, files.size],
+        [2, files.size],
+        [4, size],
+        [4, offset],
+        [2, 0],
+    ]);
+    return concatenated([...parts, ...directory, end]);
+}
+function record(fields, name = new Uint8Array()) {
+    const size = fields.reduce((sum, [bytes]) => sum + bytes, 0);
+    const bytes = new Uint8Array(size + name.length);
+    const view = new DataView(bytes.buffer);
+    let at = 0;
+    for (const [field, value] of fields) {
+        if (field === 2) {
+            view.setUint16(at, value, true);
+        }
+        else {
+            view.setUint32(at, value, true);
+        }
+        at += field;
+    }
+    bytes.set(name, size);
+    return bytes;
+}
+function concatenated(parts) {
+    const bytes = new Uint8Array(parts.reduce((sum, part) => sum + part.length, 0));
+    let at = 0;
+    for (const part of parts) {
+        bytes.set(part, at);
+        at += part.length;
+    }
+    return bytes;
+}
+// The CRC-32 of zip files, from ISO 3309, with the reflected polynomial 0xedb88320.
+const CRC_TABLE = Uint32Array.from({ length: 256 }, (_, byte) => {
+    let crc = byte;
+    for (let bit = 0; bit < 8; bit += 1) {
+        crc = crc & 1 ? 0xedb88320 ^ (crc >>> 1) : crc >>> 1;
+    }
+    return crc;
+});
+function crc32(bytes) {
+    let crc = 0xffffffff;
+    for (const byte of bytes) {
+        crc = CRC_TABLE[(crc ^ byte) & 0xff] ^ (crc >>> 8);
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+}

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

package/esm/funcs/environments-actors.js

@@ -0,0 +1,102 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4-mini";
+import { encodeFormQuery, 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 environmentsActors(client, request, options) {
+    return new APIPromise($do(client, request, options));
+}
+async function $do(client, request, options) {
+    const parsed = safeParse(request, (value) => z.parse(operations.ListActorsRequest$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",
+        }),
+    };
+    const path = pathToFunc("/v1/environments/{environmentId}/apps/{appName}/actors")(pathParams);
+    const query = encodeFormQuery({
+        "cursor": payload.cursor,
+        "limit": payload.limit,
+        "search": payload.search,
+    });
+    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: "listActors",
+        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.ListActorsResponse$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/get-import-file.d.ts

@@ -0,0 +1,12 @@
+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";
+export declare function getImportFile(client: StateMachinesCore, request: operations.GetImportFileRequest, options?: RequestOptions): APIPromise<Result<models.ImportFile, errors.ErrorT | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;

package/esm/funcs/get-import-file.js

@@ -0,0 +1,97 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4-mini";
+import { encodeFormQuery, 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";
+export function getImportFile(client, request, options) {
+    return new APIPromise($do(client, request, options));
+}
+async function $do(client, request, options) {
+    const parsed = safeParse(request, (value) => z.parse(operations.GetImportFileRequest$outboundSchema, value), "Input validation failed");
+    if (!parsed.ok) {
+        return [parsed, { status: "invalid" }];
+    }
+    const payload = parsed.value;
+    const body = null;
+    const pathParams = {
+        importId: encodeSimple("importId", payload.importId, {
+            explode: false,
+            charEncoding: "percent",
+        }),
+    };
+    const path = pathToFunc("/v1/imports/{importId}/file")(pathParams);
+    const query = encodeFormQuery({
+        "path": payload.path,
+    });
+    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: "getImportFile",
+        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, models.ImportFile$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-import-files.d.ts

@@ -0,0 +1,12 @@
+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";
+export declare function listImportFiles(client: StateMachinesCore, request: operations.ListImportFilesRequest, options?: RequestOptions): APIPromise<Result<models.ImportFolder, errors.ErrorT | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;

package/esm/funcs/list-import-files.js

@@ -0,0 +1,98 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4-mini";
+import { encodeFormQuery, 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";
+export function listImportFiles(client, request, options) {
+    return new APIPromise($do(client, request, options));
+}
+async function $do(client, request, options) {
+    const parsed = safeParse(request, (value) => z.parse(operations.ListImportFilesRequest$outboundSchema, value), "Input validation failed");
+    if (!parsed.ok) {
+        return [parsed, { status: "invalid" }];
+    }
+    const payload = parsed.value;
+    const body = null;
+    const pathParams = {
+        importId: encodeSimple("importId", payload.importId, {
+            explode: false,
+            charEncoding: "percent",
+        }),
+    };
+    const path = pathToFunc("/v1/imports/{importId}/files")(pathParams);
+    const query = encodeFormQuery({
+        "cursor": payload.cursor,
+        "path": payload.path,
+    });
+    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: "listImportFiles",
+        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, models.ImportFolder$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/upload-import.d.ts

@@ -0,0 +1,12 @@
+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";
+export declare function uploadImport(client: StateMachinesCore, request: operations.UploadImportRequest, options?: RequestOptions): APIPromise<Result<models.ReceivedImport, errors.ErrorT | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;

package/esm/funcs/upload-import.js

@@ -0,0 +1,96 @@
+/*
+ * 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";
+export function uploadImport(client, request, options) {
+    return new APIPromise($do(client, request, options));
+}
+async function $do(client, request, options) {
+    const parsed = safeParse(request, (value) => z.parse(operations.UploadImportRequest$outboundSchema, value), "Input validation failed");
+    if (!parsed.ok) {
+        return [parsed, { status: "invalid" }];
+    }
+    const payload = parsed.value;
+    const body = payload.body instanceof Uint8Array
+        ? new Uint8Array(payload.body).buffer
+        : payload.body;
+    const pathParams = {
+        importId: encodeSimple("importId", payload.importId, {
+            explode: false,
+            charEncoding: "percent",
+        }),
+    };
+    const path = pathToFunc("/v1/imports/{importId}/upload")(pathParams);
+    const headers = new Headers(compactMap({
+        "Content-Type": "application/zip",
+        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: "uploadImport",
+        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: "PUT",
+        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.ReceivedImport$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/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.11.0";
+    readonly sdkVersion: "0.12.0";
     readonly genVersion: "2.941.0";
-    readonly userAgent: "speakeasy-sdk/typescript 0.11.0 2.941.0 1.0.0 @usestatemachines/sdk";
+    readonly userAgent: "speakeasy-sdk/typescript 0.12.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.11.0",
+    sdkVersion: "0.12.0",
     genVersion: "2.941.0",
-    userAgent: "speakeasy-sdk/typescript 0.11.0 2.941.0 1.0.0 @usestatemachines/sdk",
+    userAgent: "speakeasy-sdk/typescript 0.12.0 2.941.0 1.0.0 @usestatemachines/sdk",
 };

package/esm/models/absent-record.d.ts

@@ -1,8 +1,8 @@
 import * as z from "zod/v4-mini";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { AbsentReason } from "./absent-reason.js";
-import { AbsentRecordSource } from "./absent-record-source.js";
 import { SDKValidationError } from "./errors/sdk-validation-error.js";
+import { RecordSource } from "./record-source.js";
 export type AbsentRecord = {
     /**
      * The vendor's ID of the record, or null for a record that holds none.
@@ -14,9 +14,13 @@ export type AbsentRecord = {
      */
     reason: AbsentReason;
     /**
-     * The file of the record in the import, such as `salesforce/records/Opportunity.jsonl`, and its line, counted from 1.
+     * The file that holds the record in the import, such as `salesforce/records/Opportunity.jsonl` or the manifest `acme.yaml`, and the line where the record starts, counted from 1.
      */
-    source: AbsentRecordSource;
+    source: RecordSource;
+    /**
+     * The text that the record wrote as its ID, such as `acme`, when the text is no vendor ID.
+     */
+    text?: string | undefined;
 };
 /** @internal */
 export declare const AbsentRecord$inboundSchema: z.ZodMiniType<AbsentRecord, unknown>;

package/esm/models/absent-record.js

@@ -5,13 +5,14 @@ import * as z from "zod/v4-mini";
 import { safeParse } from "../lib/schemas.js";
 import * as types from "../types/primitives.js";
 import { AbsentReason$inboundSchema } from "./absent-reason.js";
-import { AbsentRecordSource$inboundSchema, } from "./absent-record-source.js";
+import { RecordSource$inboundSchema } from "./record-source.js";
 /** @internal */
 export const AbsentRecord$inboundSchema = z.object({
     nativeId: types.nullable(types.string()),
     object: types.string(),
     reason: AbsentReason$inboundSchema,
-    source: AbsentRecordSource$inboundSchema,
+    source: RecordSource$inboundSchema,
+    text: types.optional(types.string()),
 });
 export function absentRecordFromJSON(jsonString) {
     return safeParse(jsonString, (x) => AbsentRecord$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AbsentRecord' from JSON`);

package/esm/models/actor.d.ts

@@ -1,6 +1,9 @@
 import * as z from "zod/v4-mini";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdk-validation-error.js";
+/**
+ * A user of the app's seed, for display.
+ */
 export type Actor = {
     id: string;
     name: string;

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

@@ -0,0 +1,17 @@
+import * as z from "zod/v4-mini";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+/**
+ * A user of an app who can sign in, as the app answers it.
+ */
+export type AppUser = {
+    default: boolean;
+    email: string | null;
+    id: string;
+    name: string;
+    role: string | null;
+    username: string | null;
+};
+/** @internal */
+export declare const AppUser$inboundSchema: z.ZodMiniType<AppUser, unknown>;
+export declare function appUserFromJSON(jsonString: string): SafeParseResult<AppUser, SDKValidationError>;