@usestatemachines/sdk 0.9.0 → 0.10.0

package/esm/extensions/client.d.ts

@@ -1,11 +1,13 @@
 import type { App } from '../models/app.js';
 import type { AuditEvent } from '../models/audit-event.js';
 import type { CreateEnvironment } from '../models/create-environment.js';
+import type { Import } from '../models/import.js';
 import type { Me } from '../models/me.js';
 import type { CreateCredentialsRequestBody } from '../models/operations/create-credentials.js';
 import type { GetRequestStatsRequest } from '../models/operations/get-request-stats.js';
 import type { ListAuditEventsRequest } from '../models/operations/list-audit-events.js';
 import type { ListEnvironmentsRequest } from '../models/operations/list-environments.js';
+import type { ListImportsRequest } from '../models/operations/list-imports.js';
 import type { ListRequestsRequest } from '../models/operations/list-requests.js';
 import type { ListSnapshotsRequest } from '../models/operations/list-snapshots.js';
 import type { ListWorkspacesRequest } from '../models/operations/list-workspaces.js';
@@ -42,6 +44,12 @@ export interface CreateEnvironmentOptions extends SignalOptions {
     idempotencyKey?: string;
 }
 export type CreateSnapshotOptions = CreateEnvironmentOptions;
+export interface UploadImportOptions extends SignalOptions {
+    /** The import's workspace. Defaults to the client's `workspaceId`; an API key has its own. */
+    workspaceId?: string;
+    /** A repeat with the same key and the same bytes finds the same import. Defaults to a new UUID. */
+    idempotencyKey?: string;
+}
 /**
  * The body of the credentials call. `actorId` defaults to the app's default
  * actor (for Salesforce, the administrator). `services` names more services
@@ -59,6 +67,7 @@ export type PageQuery = {
 };
 export type ListEnvironmentsQuery = ListEnvironmentsRequest;
 export type ListSnapshotsQuery = ListSnapshotsRequest;
+export type ListImportsQuery = ListImportsRequest;
 export type ListAuditEventsQuery = ListAuditEventsRequest;
 export type ListWorkspacesQuery = ListWorkspacesRequest;
 export type ListRequestsQuery = ListRequestsRequest;
@@ -96,10 +105,18 @@ export declare class StateMachines {
         connect: (environmentId: string, appName: string, options?: ConnectOptions) => Promise<Credentials>;
     };
     readonly snapshots: {
-        /** Creates a snapshot of a running environment and, unless `wait` is false, waits until it is `ready`. */
+        /**
+         * Creates a snapshot of a running environment, or builds one from a `ready` import,
+         * and, unless `wait` is false, waits until it is `ready`. A snapshot from an import
+         * takes every app of the import, each on its default version, with empty setup and
+         * services. An import that an app refuses throws `SnapshotFailedError` with its problems.
+         */
         create: (input: {
             environmentId: string;
             name?: string | null;
+        } | {
+            importId: string;
+            name?: string | null;
         }, options?: CreateEnvironmentOptions) => Promise<Snapshot>;
         /** Newest first. Leaves deleted snapshots out unless `status` asks for them. */
         list: (query?: ListSnapshotsRequest) => Promise<Page<Snapshot>>;
@@ -116,6 +133,19 @@ export declare class StateMachines {
          */
         wait: (snapshotId: string, options: WaitOptions<KnownSnapshotStatus>) => Promise<Snapshot>;
     };
+    readonly imports: {
+        /**
+         * Uploads an import's zip file and resolves with the import as its check left it:
+         * `ready`, or `invalid` with its problems. An import that is no longer `uploading` resolves
+         * as it is. The zip file goes to the upload URL under `signal` alone, without `attemptTimeoutMs`.
+         */
+        upload: (zip: Uint8Array<ArrayBufferLike>, options?: UploadImportOptions) => Promise<Import>;
+        /** Newest first. Leaves deleted imports out unless `status` asks for them. */
+        list: (query?: ListImportsRequest) => Promise<Page<Import>>;
+        get: (importId: string) => Promise<Import>;
+        /** Removes the import's zip file once no build reads it. Snapshots built from it keep their data. Safe to repeat. */
+        delete: (importId: string, options?: SignalOptions) => Promise<Import>;
+    };
     readonly requests: {
         /** Calls the gateway recorded for one environment, newest first. Recording is best effort. */
         list: (query: ListRequestsRequest) => Promise<Page<Request>>;

package/esm/extensions/client.js

@@ -2,7 +2,7 @@ import { SDK_METADATA } from '../lib/config.js';
 import { HTTPClient } from '../lib/http.js';
 import { StateMachines as Generated } from '../sdk/sdk.js';
 import { bindCredentials } from './credentials.js';
-import { CallerAbortedError, toStateMachinesError } from './errors.js';
+import { CallerAbortedError, StateMachinesError, toStateMachinesError, uploadRefused, uploadUnanswered, } from './errors.js';
 import { linkSignal } from './signal.js';
 import { environmentAt, poll, snapshotAt, } from './wait.js';
 export class StateMachines {
@@ -83,7 +83,12 @@ export class StateMachines {
         connect: (environmentId, appName, options = {}) => this.#connect(environmentId, appName, options),
     };
     snapshots = {
-        /** Creates a snapshot of a running environment and, unless `wait` is false, waits until it is `ready`. */
+        /**
+         * Creates a snapshot of a running environment, or builds one from a `ready` import,
+         * and, unless `wait` is false, waits until it is `ready`. A snapshot from an import
+         * takes every app of the import, each on its default version, with empty setup and
+         * services. An import that an app refuses throws `SnapshotFailedError` with its problems.
+         */
         create: async (input, options = {}) => {
             const idempotencyKey = options.idempotencyKey ?? crypto.randomUUID();
             const created = await this.#call(options.signal, (call) => this.#sdk.snapshots.create({ idempotencyKey, body: input }, call));
@@ -107,6 +112,36 @@ export class StateMachines {
          */
         wait: (snapshotId, options) => poll(snapshotId, (signal) => this.#read(signal, (call) => this.#sdk.snapshots.get({ snapshotId }, call)), snapshotAt(options.status), options),
     };
+    imports = {
+        /**
+         * Uploads an import's zip file and resolves with the import as its check left it:
+         * `ready`, or `invalid` with its problems. An import that is no longer `uploading` resolves
+         * as it is. The zip file goes to the upload URL under `signal` alone, without `attemptTimeoutMs`.
+         */
+        upload: async (zip, options = {}) => {
+            const { signal } = options;
+            const bytes = unshared(zip);
+            const idempotencyKey = options.idempotencyKey ?? crypto.randomUUID();
+            const body = this.#inWorkspace({
+                ...(options.workspaceId === undefined
+                    ? {}
+                    : { workspaceId: options.workspaceId }),
+                sizeBytes: bytes.byteLength,
+                digest: await sha256(bytes),
+            });
+            const created = await this.#call(signal, (call) => this.#sdk.imports.create({ idempotencyKey, body }, call));
+            if (created.upload === null) {
+                return created.import;
+            }
+            await this.#send(created.upload, bytes, signal);
+            return this.#call(signal, (call) => this.#sdk.imports.complete({ importId: created.import.id }, call));
+        },
+        /** Newest first. Leaves deleted imports out unless `status` asks for them. */
+        list: (query = {}) => this.#call(undefined, (call) => this.#sdk.imports.list(this.#inWorkspace(query), call)),
+        get: (importId) => this.#call(undefined, (call) => this.#sdk.imports.get({ importId }, call)),
+        /** Removes the import's zip file once no build reads it. Snapshots built from it keep their data. Safe to repeat. */
+        delete: (importId, options = {}) => this.#call(options.signal, (call) => this.#sdk.imports.delete({ importId }, call)),
+    };
     requests = {
         /** Calls the gateway recorded for one environment, newest first. Recording is best effort. */
         list: (query) => this.#call(undefined, (call) => this.#sdk.requests.list(query, call)),
@@ -137,6 +172,34 @@ export class StateMachines {
         const credentials = await this.#call(undefined, (call) => this.#sdk.environments.connect({ environmentId, appName, body }, call));
         return bindCredentials(credentials, this.#fetch);
     }
+    async #send(upload, zip, signal) {
+        const fetcher = this.#fetch ?? fetch;
+        const scope = linkSignal(signal);
+        // fetch sets Content-Length from the body, and a browser refuses to set it.
+        const headers = Object.entries(upload.headers).filter(([name]) => name.toLowerCase() !== 'content-length');
+        try {
+            const response = await fetcher(new Request(upload.url, {
+                method: upload.method,
+                headers,
+                body: zip,
+                signal: scope.signal,
+            }));
+            // A bucket answers 412 to `If-None-Match: *` once the bytes arrived.
+            if (!(response.ok || response.status === 409 || response.status === 412)) {
+                throw uploadRefused(response);
+            }
+        }
+        catch (error) {
+            throw signal?.aborted
+                ? toStateMachinesError(new CallerAbortedError(signal.reason))
+                : error instanceof StateMachinesError
+                    ? error
+                    : uploadUnanswered(error);
+        }
+        finally {
+            scope.close();
+        }
+    }
     #bind(data) {
         const { id } = data;
         const helpers = {
@@ -216,6 +279,15 @@ function addAttemptTimeout(httpClient, timeoutMs, calls) {
         }
     });
 }
+function unshared(bytes) {
+    return bytes.buffer instanceof ArrayBuffer
+        ? new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength)
+        : new Uint8Array(bytes);
+}
+async function sha256(bytes) {
+    const hash = new Uint8Array(await crypto.subtle.digest('SHA-256', bytes));
+    return `sha256:${Array.from(hash, (byte) => byte.toString(16).padStart(2, '0')).join('')}`;
+}
 function waitOptions(options) {
     return {
         ...(options.timeoutMs === undefined

package/esm/extensions/errors.d.ts

@@ -1,5 +1,6 @@
 import type { Environment as EnvironmentData } from '../models/environment.js';
 import type { ErrorCode } from '../models/error.js';
+import type { ImportProblem } from '../models/import-problem.js';
 import type { Snapshot } from '../models/snapshot.js';
 export interface ErrorDetails {
     readonly message: string;
@@ -37,6 +38,8 @@ export declare class EnvironmentFailedError extends StateMachinesError {
 export declare class SnapshotFailedError extends StateMachinesError {
     readonly snapshot: Snapshot;
     readonly name = "SnapshotFailedError";
+    /** The problems of an import that an app refused, errors before warnings. Empty for every other failure. */
+    readonly problems: readonly ImportProblem[];
     constructor(snapshot: Snapshot);
 }
 /** The resource reached a status from which the awaited one needs a call of yours. */
@@ -58,6 +61,10 @@ export declare class CallerAbortedError extends Error {
     readonly name = "CallerAbortedError";
     constructor(reason: unknown);
 }
+/** An upload URL that answered with a status that ends the upload. The message never includes the body. */
+export declare function uploadRefused(response: Response): StateMachinesError;
+/** An upload URL that gave no answer. The message never names the URL, which carries a signature. */
+export declare function uploadUnanswered(cause: unknown): StateMachinesError;
 /** The SDK refused input before sending it, as the API would with `invalid_request`. */
 export declare function invalidInput(message: string, fields: Record<string, string[]>): StateMachinesError;
 export declare function toStateMachinesError(error: unknown): StateMachinesError;

package/esm/extensions/errors.js

@@ -2,6 +2,7 @@ import { ErrorT } from '../models/errors/error.js';
 import { ConnectionError, RequestTimeoutError, } from '../models/errors/http-client-errors.js';
 import { ResponseValidationError } from '../models/errors/response-validation-error.js';
 import { StateMachinesHTTPError } from '../models/errors/state-machines-http-error.js';
+import { isUnknown } from '../types/discriminated-union.js';
 /**
  * Any failed call: an error response, an invalid response, no response at all, or input
  * the SDK refused before sending. The message never includes a response body.
@@ -54,19 +55,41 @@ export class EnvironmentFailedError extends StateMachinesError {
         this.environment = environment;
     }
 }
+function firstProblem(problems) {
+    const [first] = problems;
+    if (first === undefined) {
+        return '';
+    }
+    return problems.length === 1
+        ? ` ${problemLine(first)}`
+        : ` First of ${problems.length} listed problems: ${problemLine(first)}`;
+}
+function problemLine(problem) {
+    const place = problem.line === null ? problem.file : `${problem.file}:${problem.line}`;
+    const at = problem.pointer === null ? '' : ` ${problem.pointer || '/'}`;
+    return `${place}${at} ${problem.severity} ${problem.code} ${problem.message}`;
+}
 /** A snapshot that ended `failed` while the SDK waited for it. */
 export class SnapshotFailedError extends StateMachinesError {
     snapshot;
     name = 'SnapshotFailedError';
+    /** The problems of an import that an app refused, errors before warnings. Empty for every other failure. */
+    problems;
     constructor(snapshot) {
-        const failure = snapshot.failure;
+        const failure = snapshot.failure === null || isUnknown(snapshot.failure)
+            ? null
+            : snapshot.failure;
+        const refused = failure?.code === 'invalid_import' ? failure : null;
+        const problems = refused?.problems ?? [];
+        const app = refused?.appName === undefined ? '' : `, app ${refused.appName}`;
         super({
             ...noResponse,
             message: failure
-                ? `Snapshot ${snapshot.id} failed: ${failure.message} (${failure.code}).`
+                ? `Snapshot ${snapshot.id} failed: ${failure.message} (${failure.code}${app}).${firstProblem(problems)}`
                 : `Snapshot ${snapshot.id} failed.`,
         });
         this.snapshot = snapshot;
+        this.problems = problems;
     }
 }
 /** The resource reached a status from which the awaited one needs a call of yours. */
@@ -98,6 +121,27 @@ export class CallerAbortedError extends Error {
         super('The caller aborted the request.', { cause: reason });
     }
 }
+/** An upload URL that answered with a status that ends the upload. The message never includes the body. */
+export function uploadRefused(response) {
+    const details = {
+        ...noResponse,
+        message: `HTTP ${response.status} from the upload URL`,
+        status: response.status,
+        requestId: response.headers.get('request-id'),
+        retryAfterMs: retryAfterMs(response.headers),
+    };
+    return retryableStatuses.has(response.status)
+        ? transientError(details)
+        : new StateMachinesError(details);
+}
+/** An upload URL that gave no answer. The message never names the URL, which carries a signature. */
+export function uploadUnanswered(cause) {
+    return transientError({
+        ...noResponse,
+        message: 'The upload URL did not answer.',
+        cause,
+    });
+}
 /** The SDK refused input before sending it, as the API would with `invalid_request`. */
 export function invalidInput(message, fields) {
     return new StateMachinesError({

package/esm/extensions/index.d.ts

@@ -1,5 +1,5 @@
-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 type { Actor, App, AppEntry, AuditEvent, BodyPreview, CreateEnvironment, CreateEnvironmentApp, EnvironmentApp, EnvironmentFailure, EnvironmentFailureCode, EnvironmentStatus, ErrorCode, Import, ImportApp, ImportProblem, ImportStatus, Me, Permission, Principal, RequestDetail, RequestStats, RequestT as Request, Snapshot, SnapshotStatus, Version, Workspace, } from '../models/index.js';
+export type { ConnectOptions, CreateEnvironmentOptions, CreateSnapshotOptions, ListAuditEventsQuery, ListEnvironmentsQuery, ListImportsQuery, ListRequestsQuery, ListSnapshotsQuery, ListWorkspacesQuery, Page, PageQuery, RequestStatsQuery, SignalOptions, StateMachinesOptions, UploadImportOptions, } from './client.js';
 export { StateMachines } from './client.js';
 export type { Credentials, McpServerCredentials, ServiceCredentials, } from './credentials.js';
 export type { Environment, EnvironmentHelpers } from './environment.js';

package/esm/funcs/imports-complete.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 importsComplete(client: StateMachinesCore, request: operations.CompleteImportRequest, options?: RequestOptions): APIPromise<Result<models.Import, errors.ErrorT | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;

package/esm/funcs/imports-complete.js

@@ -0,0 +1,93 @@
+/*
+ * 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 importsComplete(client, request, options) {
+    return new APIPromise($do(client, request, options));
+}
+async function $do(client, request, options) {
+    const parsed = safeParse(request, (value) => z.parse(operations.CompleteImportRequest$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}/complete")(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: "completeImport",
+        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(200, models.Import$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/imports-create.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 importsCreate(client: StateMachinesCore, request: operations.CreateImportRequest, options?: RequestOptions): APIPromise<Result<models.CreatedImport, errors.ErrorT | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;

package/esm/funcs/imports-create.js

@@ -0,0 +1,89 @@
+/*
+ * 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";
+export function importsCreate(client, request, options) {
+    return new APIPromise($do(client, request, options));
+}
+async function $do(client, request, options) {
+    const parsed = safeParse(request, (value) => z.parse(operations.CreateImportRequest$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 path = pathToFunc("/v1/imports")();
+    const headers = new Headers(compactMap({
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        "idempotency-key": encodeSimple("idempotency-key", payload["idempotency-key"], { explode: false, charEncoding: "none" }),
+    }));
+    const secConfig = await extractSecurity(client._options.apiKey);
+    const securityInput = secConfig == null ? {} : { apiKey: secConfig };
+    const requestSecurity = resolveGlobalSecurity(securityInput);
+    const context = {
+        options: client._options,
+        baseURL: options?.serverURL ?? client._baseURL ?? "",
+        operationID: "createImport",
+        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([200, 201], models.CreatedImport$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/imports-delete.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 importsDelete(client: StateMachinesCore, request: operations.DeleteImportRequest, options?: RequestOptions): APIPromise<Result<models.Import, errors.ErrorT | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;

package/esm/funcs/imports-delete.js

@@ -0,0 +1,93 @@
+/*
+ * 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 importsDelete(client, request, options) {
+    return new APIPromise($do(client, request, options));
+}
+async function $do(client, request, options) {
+    const parsed = safeParse(request, (value) => z.parse(operations.DeleteImportRequest$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}")(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: "deleteImport",
+        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.Import$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/imports-get.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 importsGet(client: StateMachinesCore, request: operations.GetImportRequest, options?: RequestOptions): APIPromise<Result<models.Import, errors.ErrorT | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;