@usestatemachines/sdk 0.9.0 → 0.10.0

package/esm/funcs/imports-get.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 importsGet(client, request, options) {
+    return new APIPromise($do(client, request, options));
+}
+async function $do(client, request, options) {
+    const parsed = safeParse(request, (value) => z.parse(operations.GetImportRequest$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: "getImport",
+        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,
+        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-list.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 importsList(client: StateMachinesCore, request?: operations.ListImportsRequest | undefined, options?: RequestOptions): APIPromise<Result<operations.ListImportsResponse, errors.ErrorT | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;

package/esm/funcs/imports-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 importsList(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.ListImportsRequest$outboundSchema), value), "Input validation failed");
+    if (!parsed.ok) {
+        return [parsed, { status: "invalid" }];
+    }
+    const payload = parsed.value;
+    const body = null;
+    const path = pathToFunc("/v1/imports")();
+    const query = encodeFormQuery({
+        "cursor": payload?.cursor,
+        "limit": payload?.limit,
+        "status": payload?.status,
+        "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: "listImports",
+        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.ListImportsResponse$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.9.0";
+    readonly sdkVersion: "0.10.0";
     readonly genVersion: "2.941.0";
-    readonly userAgent: "speakeasy-sdk/typescript 0.9.0 2.941.0 1.0.0 @usestatemachines/sdk";
+    readonly userAgent: "speakeasy-sdk/typescript 0.10.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.9.0",
+    sdkVersion: "0.10.0",
     genVersion: "2.941.0",
-    userAgent: "speakeasy-sdk/typescript 0.9.0 2.941.0 1.0.0 @usestatemachines/sdk",
+    userAgent: "speakeasy-sdk/typescript 0.10.0 2.941.0 1.0.0 @usestatemachines/sdk",
 };

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

@@ -0,0 +1,36 @@
+import * as z from "zod/v4-mini";
+import * as discriminatedUnionTypes from "../types/discriminated-union.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+export type AbsentReasonReference = {
+    nativeId: string;
+    object: string;
+    pointer: string;
+    type: "reference";
+};
+export type AbsentReasonProblem = {
+    code: string;
+    message: string;
+    pointer: string | null;
+    type: "problem";
+};
+export type AbsentReasonIdentity = {
+    message: string;
+    type: "identity";
+};
+/**
+ * Why the record did not load.
+ */
+export type AbsentReason = AbsentReasonIdentity | AbsentReasonProblem | AbsentReasonReference | discriminatedUnionTypes.Unknown<"type">;
+/** @internal */
+export declare const AbsentReasonReference$inboundSchema: z.ZodMiniType<AbsentReasonReference, unknown>;
+export declare function absentReasonReferenceFromJSON(jsonString: string): SafeParseResult<AbsentReasonReference, SDKValidationError>;
+/** @internal */
+export declare const AbsentReasonProblem$inboundSchema: z.ZodMiniType<AbsentReasonProblem, unknown>;
+export declare function absentReasonProblemFromJSON(jsonString: string): SafeParseResult<AbsentReasonProblem, SDKValidationError>;
+/** @internal */
+export declare const AbsentReasonIdentity$inboundSchema: z.ZodMiniType<AbsentReasonIdentity, unknown>;
+export declare function absentReasonIdentityFromJSON(jsonString: string): SafeParseResult<AbsentReasonIdentity, SDKValidationError>;
+/** @internal */
+export declare const AbsentReason$inboundSchema: z.ZodMiniType<AbsentReason, unknown>;
+export declare function absentReasonFromJSON(jsonString: string): SafeParseResult<AbsentReason, SDKValidationError>;

package/esm/models/absent-reason.js

@@ -0,0 +1,44 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4-mini";
+import { safeParse } from "../lib/schemas.js";
+import { discriminatedUnion } from "../types/discriminated-union.js";
+import * as types from "../types/primitives.js";
+/** @internal */
+export const AbsentReasonReference$inboundSchema = z.object({
+    nativeId: types.string(),
+    object: types.string(),
+    pointer: types.string(),
+    type: types.literal("reference"),
+});
+export function absentReasonReferenceFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AbsentReasonReference$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AbsentReasonReference' from JSON`);
+}
+/** @internal */
+export const AbsentReasonProblem$inboundSchema = z.object({
+    code: types.string(),
+    message: types.string(),
+    pointer: types.nullable(types.string()),
+    type: types.literal("problem"),
+});
+export function absentReasonProblemFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AbsentReasonProblem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AbsentReasonProblem' from JSON`);
+}
+/** @internal */
+export const AbsentReasonIdentity$inboundSchema = z.object({
+    message: types.string(),
+    type: types.literal("identity"),
+});
+export function absentReasonIdentityFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AbsentReasonIdentity$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AbsentReasonIdentity' from JSON`);
+}
+/** @internal */
+export const AbsentReason$inboundSchema = discriminatedUnion("type", {
+    identity: z.lazy(() => AbsentReasonIdentity$inboundSchema),
+    problem: z.lazy(() => AbsentReasonProblem$inboundSchema),
+    reference: z.lazy(() => AbsentReasonReference$inboundSchema),
+});
+export function absentReasonFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AbsentReason$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AbsentReason' from JSON`);
+}

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

@@ -0,0 +1,13 @@
+import * as z from "zod/v4-mini";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+/**
+ * The file of the record in the import, such as `salesforce/records/Opportunity.jsonl`, and its line, counted from 1.
+ */
+export type AbsentRecordSource = {
+    file: string;
+    line: number | null;
+};
+/** @internal */
+export declare const AbsentRecordSource$inboundSchema: z.ZodMiniType<AbsentRecordSource, unknown>;
+export declare function absentRecordSourceFromJSON(jsonString: string): SafeParseResult<AbsentRecordSource, SDKValidationError>;

package/esm/models/absent-record-source.js

@@ -0,0 +1,14 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4-mini";
+import { safeParse } from "../lib/schemas.js";
+import * as types from "../types/primitives.js";
+/** @internal */
+export const AbsentRecordSource$inboundSchema = z.object({
+    file: types.string(),
+    line: types.nullable(types.number()),
+});
+export function absentRecordSourceFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AbsentRecordSource$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AbsentRecordSource' from JSON`);
+}

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

@@ -0,0 +1,23 @@
+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";
+export type AbsentRecord = {
+    /**
+     * The vendor's ID of the record, or null for a record that holds none.
+     */
+    nativeId: string | null;
+    object: string;
+    /**
+     * Why the record did not load.
+     */
+    reason: AbsentReason;
+    /**
+     * The file of the record in the import, such as `salesforce/records/Opportunity.jsonl`, and its line, counted from 1.
+     */
+    source: AbsentRecordSource;
+};
+/** @internal */
+export declare const AbsentRecord$inboundSchema: z.ZodMiniType<AbsentRecord, unknown>;
+export declare function absentRecordFromJSON(jsonString: string): SafeParseResult<AbsentRecord, SDKValidationError>;

package/esm/models/absent-record.js

@@ -0,0 +1,18 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4-mini";
+import { safeParse } from "../lib/schemas.js";
+import * as types from "../types/primitives.js";
+import { AbsentReason$inboundSchema } from "./absent-reason.js";
+import { AbsentRecordSource$inboundSchema, } from "./absent-record-source.js";
+/** @internal */
+export const AbsentRecord$inboundSchema = z.object({
+    nativeId: types.nullable(types.string()),
+    object: types.string(),
+    reason: AbsentReason$inboundSchema,
+    source: AbsentRecordSource$inboundSchema,
+});
+export function absentRecordFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AbsentRecord$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AbsentRecord' from JSON`);
+}

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

@@ -0,0 +1,13 @@
+import * as z from "zod/v4-mini";
+export type CreateSnapshotFromEnvironment = {
+    environmentId: string;
+    name?: string | null | undefined;
+};
+/** @internal */
+export type CreateSnapshotFromEnvironment$Outbound = {
+    environmentId: string;
+    name?: string | null | undefined;
+};
+/** @internal */
+export declare const CreateSnapshotFromEnvironment$outboundSchema: z.ZodMiniType<CreateSnapshotFromEnvironment$Outbound, CreateSnapshotFromEnvironment>;
+export declare function createSnapshotFromEnvironmentToJSON(createSnapshotFromEnvironment: CreateSnapshotFromEnvironment): string;

package/esm/models/create-snapshot-from-environment.js

@@ -0,0 +1,12 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4-mini";
+/** @internal */
+export const CreateSnapshotFromEnvironment$outboundSchema = z.object({
+    environmentId: z.string(),
+    name: z.optional(z.nullable(z.string())),
+});
+export function createSnapshotFromEnvironmentToJSON(createSnapshotFromEnvironment) {
+    return JSON.stringify(CreateSnapshotFromEnvironment$outboundSchema.parse(createSnapshotFromEnvironment));
+}

package/esm/models/create-snapshot-from-import.d.ts

@@ -0,0 +1,16 @@
+import * as z from "zod/v4-mini";
+export type CreateSnapshotFromImport = {
+    /**
+     * A `ready` import that the caller reaches. The snapshot gets every app of the import, each on the app's default version, with empty setup and services.
+     */
+    importId: string;
+    name?: string | null | undefined;
+};
+/** @internal */
+export type CreateSnapshotFromImport$Outbound = {
+    importId: string;
+    name?: string | null | undefined;
+};
+/** @internal */
+export declare const CreateSnapshotFromImport$outboundSchema: z.ZodMiniType<CreateSnapshotFromImport$Outbound, CreateSnapshotFromImport>;
+export declare function createSnapshotFromImportToJSON(createSnapshotFromImport: CreateSnapshotFromImport): string;

package/esm/models/create-snapshot-from-import.js

@@ -0,0 +1,12 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4-mini";
+/** @internal */
+export const CreateSnapshotFromImport$outboundSchema = z.object({
+    importId: z.string(),
+    name: z.optional(z.nullable(z.string())),
+});
+export function createSnapshotFromImportToJSON(createSnapshotFromImport) {
+    return JSON.stringify(CreateSnapshotFromImport$outboundSchema.parse(createSnapshotFromImport));
+}

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

@@ -0,0 +1,9 @@
+import * as z from "zod/v4-mini";
+import { CreateSnapshotFromEnvironment, CreateSnapshotFromEnvironment$Outbound } from "./create-snapshot-from-environment.js";
+import { CreateSnapshotFromImport, CreateSnapshotFromImport$Outbound } from "./create-snapshot-from-import.js";
+export type CreateSnapshot = CreateSnapshotFromEnvironment | CreateSnapshotFromImport;
+/** @internal */
+export type CreateSnapshot$Outbound = CreateSnapshotFromEnvironment$Outbound | CreateSnapshotFromImport$Outbound;
+/** @internal */
+export declare const CreateSnapshot$outboundSchema: z.ZodMiniType<CreateSnapshot$Outbound, CreateSnapshot>;
+export declare function createSnapshotToJSON(createSnapshot: CreateSnapshot): string;

package/esm/models/create-snapshot.js

@@ -0,0 +1,14 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import { smartUnion } from "../types/smart-union.js";
+import { CreateSnapshotFromEnvironment$outboundSchema, } from "./create-snapshot-from-environment.js";
+import { CreateSnapshotFromImport$outboundSchema, } from "./create-snapshot-from-import.js";
+/** @internal */
+export const CreateSnapshot$outboundSchema = smartUnion([
+    CreateSnapshotFromEnvironment$outboundSchema,
+    CreateSnapshotFromImport$outboundSchema,
+]);
+export function createSnapshotToJSON(createSnapshot) {
+    return JSON.stringify(CreateSnapshot$outboundSchema.parse(createSnapshot));
+}

package/esm/models/created-import.d.ts

@@ -0,0 +1,38 @@
+import * as z from "zod/v4-mini";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+import { Import } from "./import.js";
+export declare const Method: {
+    readonly Put: "PUT";
+};
+export type Method = ClosedEnum<typeof Method>;
+/**
+ * Where to send the zip file while the import is `uploading`, and null after. Complete the import once the upload succeeds.
+ */
+export type ImportUpload = {
+    expiresAt: Date;
+    /**
+     * Send the zip file as the body of a PUT to `url`, with each of these headers as given. The URL refuses another value of each.
+     */
+    headers: {
+        [k: string]: string;
+    };
+    method: Method;
+    url: string;
+};
+export type CreatedImport = {
+    import: Import;
+    /**
+     * Where to send the zip file while the import is `uploading`, and null after. Complete the import once the upload succeeds.
+     */
+    upload: ImportUpload | null;
+};
+/** @internal */
+export declare const Method$inboundSchema: z.ZodMiniEnum<typeof Method>;
+/** @internal */
+export declare const ImportUpload$inboundSchema: z.ZodMiniType<ImportUpload, unknown>;
+export declare function importUploadFromJSON(jsonString: string): SafeParseResult<ImportUpload, SDKValidationError>;
+/** @internal */
+export declare const CreatedImport$inboundSchema: z.ZodMiniType<CreatedImport, unknown>;
+export declare function createdImportFromJSON(jsonString: string): SafeParseResult<CreatedImport, SDKValidationError>;

package/esm/models/created-import.js

@@ -0,0 +1,30 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4-mini";
+import { safeParse } from "../lib/schemas.js";
+import * as types from "../types/primitives.js";
+import { Import$inboundSchema } from "./import.js";
+export const Method = {
+    Put: "PUT",
+};
+/** @internal */
+export const Method$inboundSchema = z.enum(Method);
+/** @internal */
+export const ImportUpload$inboundSchema = z.object({
+    expiresAt: types.date(),
+    headers: z.record(z.string(), types.string()),
+    method: Method$inboundSchema,
+    url: types.string(),
+});
+export function importUploadFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ImportUpload$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ImportUpload' from JSON`);
+}
+/** @internal */
+export const CreatedImport$inboundSchema = z.object({
+    import: Import$inboundSchema,
+    upload: types.nullable(z.lazy(() => ImportUpload$inboundSchema)),
+});
+export function createdImportFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CreatedImport$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CreatedImport' from JSON`);
+}

package/esm/models/import-problem.d.ts

@@ -0,0 +1,40 @@
+import * as z from "zod/v4-mini";
+import { OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+/**
+ * An error refuses the import: the check of the zip file makes the import `invalid`, and the load of a snapshot from the import fails the snapshot. A warning refuses nothing.
+ */
+export declare const Severity: {
+    readonly Error: "error";
+    readonly Warning: "warning";
+};
+/**
+ * An error refuses the import: the check of the zip file makes the import `invalid`, and the load of a snapshot from the import fails the snapshot. A warning refuses nothing.
+ */
+export type Severity = OpenEnum<typeof Severity>;
+export type ImportProblem = {
+    code: string;
+    /**
+     * The path in the import, such as `salesforce/records/Account.jsonl`. An empty path names the zip file as a whole.
+     */
+    file: string;
+    /**
+     * The line in the file, counted from 1, or null when the problem is about the whole file.
+     */
+    line: number | null;
+    message: string;
+    /**
+     * The JSON pointer of the value, such as `/apps/0/name`. In a records file, it points into the record on `line`. Null when the problem names no value.
+     */
+    pointer: string | null;
+    /**
+     * An error refuses the import: the check of the zip file makes the import `invalid`, and the load of a snapshot from the import fails the snapshot. A warning refuses nothing.
+     */
+    severity: Severity;
+};
+/** @internal */
+export declare const Severity$inboundSchema: z.ZodMiniType<Severity, unknown>;
+/** @internal */
+export declare const ImportProblem$inboundSchema: z.ZodMiniType<ImportProblem, unknown>;
+export declare function importProblemFromJSON(jsonString: string): SafeParseResult<ImportProblem, SDKValidationError>;

package/esm/models/import-problem.js

@@ -0,0 +1,28 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4-mini";
+import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+import * as types from "../types/primitives.js";
+/**
+ * An error refuses the import: the check of the zip file makes the import `invalid`, and the load of a snapshot from the import fails the snapshot. A warning refuses nothing.
+ */
+export const Severity = {
+    Error: "error",
+    Warning: "warning",
+};
+/** @internal */
+export const Severity$inboundSchema = openEnums.inboundSchema(Severity);
+/** @internal */
+export const ImportProblem$inboundSchema = z.object({
+    code: types.string(),
+    file: types.string(),
+    line: types.nullable(types.number()),
+    message: types.string(),
+    pointer: types.nullable(types.string()),
+    severity: Severity$inboundSchema,
+});
+export function importProblemFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ImportProblem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ImportProblem' from JSON`);
+}

package/esm/models/import-status.d.ts

@@ -0,0 +1,13 @@
+import * as z from "zod/v4-mini";
+import { OpenEnum } from "../types/enums.js";
+export declare const ImportStatus: {
+    readonly Uploading: "uploading";
+    readonly Ready: "ready";
+    readonly Invalid: "invalid";
+    readonly Deleted: "deleted";
+};
+export type ImportStatus = OpenEnum<typeof ImportStatus>;
+/** @internal */
+export declare const ImportStatus$inboundSchema: z.ZodMiniType<ImportStatus, unknown>;
+/** @internal */
+export declare const ImportStatus$outboundSchema: z.ZodMiniType<string, ImportStatus>;

package/esm/models/import-status.js

@@ -0,0 +1,14 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as openEnums from "../types/enums.js";
+export const ImportStatus = {
+    Uploading: "uploading",
+    Ready: "ready",
+    Invalid: "invalid",
+    Deleted: "deleted",
+};
+/** @internal */
+export const ImportStatus$inboundSchema = openEnums.inboundSchema(ImportStatus);
+/** @internal */
+export const ImportStatus$outboundSchema = openEnums.outboundSchema(ImportStatus);