@usestatemachines/sdk 0.1.1

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

@@ -0,0 +1,42 @@
+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";
+export declare const Disposal: {
+    readonly Pending: "pending";
+    readonly Complete: "complete";
+    readonly Failed: "failed";
+    readonly Unknown: "unknown";
+};
+export type Disposal = OpenEnum<typeof Disposal>;
+export declare const EnvironmentAppStatus: {
+    readonly Pending: "pending";
+    readonly Starting: "starting";
+    readonly Ready: "ready";
+    readonly Stopping: "stopping";
+    readonly Stopped: "stopped";
+    readonly Failed: "failed";
+};
+export type EnvironmentAppStatus = OpenEnum<typeof EnvironmentAppStatus>;
+export type EnvironmentApp = {
+    allocatedAt: Date | null;
+    appId: string;
+    appReleaseId: string;
+    disposal: Disposal;
+    errorCode: string | null;
+    expiresAt: Date | null;
+    id: string;
+    key: string;
+    provider: string;
+    readyAt: Date | null;
+    region: string | null;
+    status: EnvironmentAppStatus;
+    stoppedAt: Date | null;
+};
+/** @internal */
+export declare const Disposal$inboundSchema: z.ZodMiniType<Disposal, unknown>;
+/** @internal */
+export declare const EnvironmentAppStatus$inboundSchema: z.ZodMiniType<EnvironmentAppStatus, unknown>;
+/** @internal */
+export declare const EnvironmentApp$inboundSchema: z.ZodMiniType<EnvironmentApp, unknown>;
+export declare function environmentAppFromJSON(jsonString: string): SafeParseResult<EnvironmentApp, SDKValidationError>;

package/esm/models/environment-app.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 * as openEnums from "../types/enums.js";
+import * as types from "../types/primitives.js";
+export const Disposal = {
+    Pending: "pending",
+    Complete: "complete",
+    Failed: "failed",
+    Unknown: "unknown",
+};
+export const EnvironmentAppStatus = {
+    Pending: "pending",
+    Starting: "starting",
+    Ready: "ready",
+    Stopping: "stopping",
+    Stopped: "stopped",
+    Failed: "failed",
+};
+/** @internal */
+export const Disposal$inboundSchema = openEnums.inboundSchema(Disposal);
+/** @internal */
+export const EnvironmentAppStatus$inboundSchema = openEnums.inboundSchema(EnvironmentAppStatus);
+/** @internal */
+export const EnvironmentApp$inboundSchema = z.object({
+    allocatedAt: types.nullable(types.date()),
+    appId: types.string(),
+    appReleaseId: types.string(),
+    disposal: Disposal$inboundSchema,
+    errorCode: types.nullable(types.string()),
+    expiresAt: types.nullable(types.date()),
+    id: types.string(),
+    key: types.string(),
+    provider: types.string(),
+    readyAt: types.nullable(types.date()),
+    region: types.nullable(types.string()),
+    status: EnvironmentAppStatus$inboundSchema,
+    stoppedAt: types.nullable(types.date()),
+});
+export function environmentAppFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => EnvironmentApp$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'EnvironmentApp' from JSON`);
+}

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

@@ -0,0 +1,10 @@
+import * as z from "zod/v4-mini";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+export type EnvironmentLifetime = {
+    defaultMinutes: number;
+    maximumMinutes: number;
+};
+/** @internal */
+export declare const EnvironmentLifetime$inboundSchema: z.ZodMiniType<EnvironmentLifetime, unknown>;
+export declare function environmentLifetimeFromJSON(jsonString: string): SafeParseResult<EnvironmentLifetime, SDKValidationError>;

package/esm/models/environment-lifetime.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 EnvironmentLifetime$inboundSchema = z.object({
+    defaultMinutes: types.number(),
+    maximumMinutes: types.number(),
+});
+export function environmentLifetimeFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => EnvironmentLifetime$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'EnvironmentLifetime' from JSON`);
+}

package/esm/models/environment.d.ts

@@ -0,0 +1,47 @@
+import * as z from "zod/v4-mini";
+import { OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { Actor } from "./actor.js";
+import { EnvironmentApp } from "./environment-app.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+export declare const EnvironmentStatus: {
+    readonly Queued: "queued";
+    readonly Starting: "starting";
+    readonly Running: "running";
+    readonly Stopping: "stopping";
+    readonly Stopped: "stopped";
+    readonly Failed: "failed";
+};
+export type EnvironmentStatus = OpenEnum<typeof EnvironmentStatus>;
+export declare const StopReason: {
+    readonly Requested: "requested";
+    readonly Expired: "expired";
+    readonly AppFailed: "app_failed";
+    readonly OwnerLost: "owner_lost";
+};
+export type StopReason = OpenEnum<typeof StopReason>;
+export type Environment = {
+    apps: Array<EnvironmentApp>;
+    createdAt: Date;
+    createdBy: Actor | null;
+    expiresAt: Date | null;
+    id: string;
+    labels: {
+        [k: string]: string;
+    };
+    lifetimeMinutes: number;
+    name: string | null;
+    startedAt: Date | null;
+    status: EnvironmentStatus;
+    stopReason: StopReason | null;
+    stoppedAt: Date | null;
+    version: number;
+    workspaceId: string;
+};
+/** @internal */
+export declare const EnvironmentStatus$inboundSchema: z.ZodMiniType<EnvironmentStatus, unknown>;
+/** @internal */
+export declare const StopReason$inboundSchema: z.ZodMiniType<StopReason, unknown>;
+/** @internal */
+export declare const Environment$inboundSchema: z.ZodMiniType<Environment, unknown>;
+export declare function environmentFromJSON(jsonString: string): SafeParseResult<Environment, SDKValidationError>;

package/esm/models/environment.js

@@ -0,0 +1,48 @@
+/*
+ * 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";
+import { Actor$inboundSchema } from "./actor.js";
+import { EnvironmentApp$inboundSchema, } from "./environment-app.js";
+export const EnvironmentStatus = {
+    Queued: "queued",
+    Starting: "starting",
+    Running: "running",
+    Stopping: "stopping",
+    Stopped: "stopped",
+    Failed: "failed",
+};
+export const StopReason = {
+    Requested: "requested",
+    Expired: "expired",
+    AppFailed: "app_failed",
+    OwnerLost: "owner_lost",
+};
+/** @internal */
+export const EnvironmentStatus$inboundSchema = openEnums.inboundSchema(EnvironmentStatus);
+/** @internal */
+export const StopReason$inboundSchema = openEnums.inboundSchema(StopReason);
+/** @internal */
+export const Environment$inboundSchema = z
+    .object({
+    apps: z.array(EnvironmentApp$inboundSchema),
+    createdAt: types.date(),
+    createdBy: types.nullable(Actor$inboundSchema),
+    expiresAt: types.nullable(types.date()),
+    id: types.string(),
+    labels: z.record(z.string(), types.string()),
+    lifetimeMinutes: types.number(),
+    name: types.nullable(types.string()),
+    startedAt: types.nullable(types.date()),
+    status: EnvironmentStatus$inboundSchema,
+    stopReason: types.nullable(StopReason$inboundSchema),
+    stoppedAt: types.nullable(types.date()),
+    version: types.number(),
+    workspaceId: types.string(),
+});
+export function environmentFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Environment$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Environment' from JSON`);
+}

package/esm/models/error-response.d.ts

@@ -0,0 +1,45 @@
+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";
+export declare const Code: {
+    readonly BodyTooLarge: "body-too-large";
+    readonly ConnectionUnavailable: "connection-unavailable";
+    readonly EnvironmentLimit: "environment-limit";
+    readonly Forbidden: "forbidden";
+    readonly IdempotencyConflict: "idempotency-conflict";
+    readonly IdentityRequestRejected: "identity-request-rejected";
+    readonly InternalError: "internal-error";
+    readonly InvalidCursor: "invalid-cursor";
+    readonly InvalidRequest: "invalid-request";
+    readonly InvalidResponse: "invalid-response";
+    readonly InvalidWebhook: "invalid-webhook";
+    readonly LastOwner: "last-owner";
+    readonly LastWorkspace: "last-workspace";
+    readonly LifetimeTooLong: "lifetime-too-long";
+    readonly NotFound: "not-found";
+    readonly NotReady: "not-ready";
+    readonly OrganizationRequired: "organization-required";
+    readonly ReleaseUnavailable: "release-unavailable";
+    readonly RequestCapacityReached: "request-capacity-reached";
+    readonly RequestTimeout: "request-timeout";
+    readonly ServiceUnavailable: "service-unavailable";
+    readonly Unauthorized: "unauthorized";
+    readonly VersionConflict: "version-conflict";
+    readonly WorkspaceArchived: "workspace-archived";
+    readonly WorkspaceNameTaken: "workspace-name-taken";
+};
+export type Code = OpenEnum<typeof Code>;
+export type ErrorT = {
+    code: Code;
+    fields?: {
+        [k: string]: Array<string>;
+    } | undefined;
+    message: string;
+    requestId: string;
+};
+/** @internal */
+export declare const Code$inboundSchema: z.ZodMiniType<Code, unknown>;
+/** @internal */
+export declare const ErrorT$inboundSchema: z.ZodMiniType<ErrorT, unknown>;
+export declare function errorFromJSON(jsonString: string): SafeParseResult<ErrorT, SDKValidationError>;

package/esm/models/error-response.js

@@ -0,0 +1,47 @@
+/*
+ * 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";
+export const Code = {
+    BodyTooLarge: "body-too-large",
+    ConnectionUnavailable: "connection-unavailable",
+    EnvironmentLimit: "environment-limit",
+    Forbidden: "forbidden",
+    IdempotencyConflict: "idempotency-conflict",
+    IdentityRequestRejected: "identity-request-rejected",
+    InternalError: "internal-error",
+    InvalidCursor: "invalid-cursor",
+    InvalidRequest: "invalid-request",
+    InvalidResponse: "invalid-response",
+    InvalidWebhook: "invalid-webhook",
+    LastOwner: "last-owner",
+    LastWorkspace: "last-workspace",
+    LifetimeTooLong: "lifetime-too-long",
+    NotFound: "not-found",
+    NotReady: "not-ready",
+    OrganizationRequired: "organization-required",
+    ReleaseUnavailable: "release-unavailable",
+    RequestCapacityReached: "request-capacity-reached",
+    RequestTimeout: "request-timeout",
+    ServiceUnavailable: "service-unavailable",
+    Unauthorized: "unauthorized",
+    VersionConflict: "version-conflict",
+    WorkspaceArchived: "workspace-archived",
+    WorkspaceNameTaken: "workspace-name-taken",
+};
+/** @internal */
+export const Code$inboundSchema = openEnums
+    .inboundSchema(Code);
+/** @internal */
+export const ErrorT$inboundSchema = z.object({
+    code: Code$inboundSchema,
+    fields: types.optional(z.record(z.string(), z.array(types.string()))),
+    message: types.string(),
+    requestId: types.string(),
+});
+export function errorFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ErrorT$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ErrorT' from JSON`);
+}

package/esm/models/errors/error-response.d.ts

@@ -0,0 +1,18 @@
+import * as z from "zod/v4-mini";
+import * as models from "../index.js";
+import { StateMachinesHTTPError } from "./state-machines-http-error.js";
+export type ErrorResponseData = {
+    error: models.ErrorT;
+};
+export declare class ErrorResponse extends StateMachinesHTTPError {
+    error: models.ErrorT;
+    /** The original data that was passed to this error instance. */
+    data$: ErrorResponseData;
+    constructor(err: ErrorResponseData, httpMeta: {
+        response: Response;
+        request: Request;
+        body: string;
+    });
+}
+/** @internal */
+export declare const ErrorResponse$inboundSchema: z.ZodMiniType<ErrorResponse, unknown>;

package/esm/models/errors/error-response.js

@@ -0,0 +1,32 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4-mini";
+import * as models from "../index.js";
+import { StateMachinesHTTPError } from "./state-machines-http-error.js";
+export class ErrorResponse extends StateMachinesHTTPError {
+    error;
+    /** The original data that was passed to this error instance. */
+    data$;
+    constructor(err, httpMeta) {
+        const message = err.error?.message
+            || `API error occurred: ${JSON.stringify(err)}`;
+        super(message, httpMeta);
+        this.data$ = err;
+        this.error = err.error;
+        this.name = "ErrorResponse";
+    }
+}
+/** @internal */
+export const ErrorResponse$inboundSchema = z.pipe(z.object({
+    error: z.lazy(() => models.ErrorT$inboundSchema),
+    request$: z.custom(x => x instanceof Request),
+    response$: z.custom(x => x instanceof Response),
+    body$: z.string(),
+}), z.transform((v) => {
+    return new ErrorResponse(v, {
+        request: v.request$,
+        response: v.response$,
+        body: v.body$,
+    });
+}));

package/esm/models/errors/http-client-errors.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Base class for all HTTP errors.
+ */
+export declare class HTTPClientError extends Error {
+    /** The underlying cause of the error. */
+    readonly cause: unknown;
+    name: string;
+    constructor(message: string, opts?: {
+        cause?: unknown;
+    });
+}
+/**
+ * An error to capture unrecognised or unexpected errors when making HTTP calls.
+ */
+export declare class UnexpectedClientError extends HTTPClientError {
+    name: string;
+}
+/**
+ * An error that is raised when any inputs used to create a request are invalid.
+ */
+export declare class InvalidRequestError extends HTTPClientError {
+    name: string;
+}
+/**
+ * An error that is raised when a HTTP request was aborted by the client error.
+ */
+export declare class RequestAbortedError extends HTTPClientError {
+    readonly name = "RequestAbortedError";
+}
+/**
+ * An error that is raised when a HTTP request timed out due to an AbortSignal
+ * signal timeout.
+ */
+export declare class RequestTimeoutError extends HTTPClientError {
+    readonly name = "RequestTimeoutError";
+}
+/**
+ * An error that is raised when a HTTP client is unable to make a request to
+ * a server.
+ */
+export declare class ConnectionError extends HTTPClientError {
+    readonly name = "ConnectionError";
+}

package/esm/models/errors/http-client-errors.js

@@ -0,0 +1,55 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+/**
+ * Base class for all HTTP errors.
+ */
+export class HTTPClientError extends Error {
+    /** The underlying cause of the error. */
+    cause;
+    name = "HTTPClientError";
+    constructor(message, opts) {
+        let msg = message;
+        if (opts?.cause) {
+            msg += `: ${opts.cause}`;
+        }
+        super(msg, opts);
+        // In older runtimes, the cause field would not have been assigned through
+        // the super() call.
+        if (typeof this.cause === "undefined") {
+            this.cause = opts?.cause;
+        }
+    }
+}
+/**
+ * An error to capture unrecognised or unexpected errors when making HTTP calls.
+ */
+export class UnexpectedClientError extends HTTPClientError {
+    name = "UnexpectedClientError";
+}
+/**
+ * An error that is raised when any inputs used to create a request are invalid.
+ */
+export class InvalidRequestError extends HTTPClientError {
+    name = "InvalidRequestError";
+}
+/**
+ * An error that is raised when a HTTP request was aborted by the client error.
+ */
+export class RequestAbortedError extends HTTPClientError {
+    name = "RequestAbortedError";
+}
+/**
+ * An error that is raised when a HTTP request timed out due to an AbortSignal
+ * signal timeout.
+ */
+export class RequestTimeoutError extends HTTPClientError {
+    name = "RequestTimeoutError";
+}
+/**
+ * An error that is raised when a HTTP client is unable to make a request to
+ * a server.
+ */
+export class ConnectionError extends HTTPClientError {
+    name = "ConnectionError";
+}

package/esm/models/errors/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./error-response.js";
+export * from "./http-client-errors.js";
+export * from "./response-validation-error.js";
+export * from "./sdk-validation-error.js";
+export * from "./state-machines-http-error.js";
+export * from "./unexpected-response-error.js";

package/esm/models/errors/index.js

@@ -0,0 +1,9 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+export * from "./error-response.js";
+export * from "./http-client-errors.js";
+export * from "./response-validation-error.js";
+export * from "./sdk-validation-error.js";
+export * from "./state-machines-http-error.js";
+export * from "./unexpected-response-error.js";

package/esm/models/errors/response-validation-error.d.ts

@@ -0,0 +1,25 @@
+import { StateMachinesHTTPError } from "./state-machines-http-error.js";
+export declare class ResponseValidationError extends StateMachinesHTTPError {
+    /**
+     * The raw value that failed validation.
+     */
+    readonly rawValue: unknown;
+    /**
+     * The raw message that failed validation.
+     */
+    readonly rawMessage: unknown;
+    constructor(message: string, extra: {
+        response: Response;
+        request: Request;
+        body: string;
+        cause: unknown;
+        rawValue: unknown;
+        rawMessage: unknown;
+    });
+    /**
+     * Return a pretty-formatted error message if the underlying validation error
+     * is a ZodError or some other recognized error type, otherwise return the
+     * default error message.
+     */
+    pretty(): string;
+}

package/esm/models/errors/response-validation-error.js

@@ -0,0 +1,36 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4/core";
+import { formatZodError } from "./sdk-validation-error.js";
+import { StateMachinesHTTPError } from "./state-machines-http-error.js";
+export class ResponseValidationError extends StateMachinesHTTPError {
+    /**
+     * The raw value that failed validation.
+     */
+    rawValue;
+    /**
+     * The raw message that failed validation.
+     */
+    rawMessage;
+    constructor(message, extra) {
+        super(message, extra);
+        this.name = "ResponseValidationError";
+        this.cause = extra.cause;
+        this.rawValue = extra.rawValue;
+        this.rawMessage = extra.rawMessage;
+    }
+    /**
+     * Return a pretty-formatted error message if the underlying validation error
+     * is a ZodError or some other recognized error type, otherwise return the
+     * default error message.
+     */
+    pretty() {
+        if (this.cause instanceof z.$ZodError) {
+            return `${this.rawMessage}\n${formatZodError(this.cause)}`;
+        }
+        else {
+            return this.toString();
+        }
+    }
+}

package/esm/models/errors/sdk-validation-error.d.ts

@@ -0,0 +1,20 @@
+import * as z from "zod/v4/core";
+export declare class SDKValidationError extends Error {
+    /**
+     * The raw value that failed validation.
+     */
+    readonly rawValue: unknown;
+    /**
+     * The raw message that failed validation.
+     */
+    readonly rawMessage: unknown;
+    static [Symbol.hasInstance](instance: unknown): instance is SDKValidationError;
+    constructor(message: string, cause: unknown, rawValue: unknown);
+    /**
+     * Return a pretty-formatted error message if the underlying validation error
+     * is a ZodError or some other recognized error type, otherwise return the
+     * default error message.
+     */
+    pretty(): string;
+}
+export declare function formatZodError(err: z.$ZodError): string;

package/esm/models/errors/sdk-validation-error.js

@@ -0,0 +1,51 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4/core";
+export class SDKValidationError extends Error {
+    /**
+     * The raw value that failed validation.
+     */
+    rawValue;
+    /**
+     * The raw message that failed validation.
+     */
+    rawMessage;
+    // Allows for backwards compatibility for `instanceof` checks of `ResponseValidationError`
+    static [Symbol.hasInstance](instance) {
+        if (!(instance instanceof Error))
+            return false;
+        if (!("rawValue" in instance))
+            return false;
+        if (!("rawMessage" in instance))
+            return false;
+        if (!("pretty" in instance))
+            return false;
+        if (typeof instance.pretty !== "function")
+            return false;
+        return true;
+    }
+    constructor(message, cause, rawValue) {
+        super(`${message}: ${cause}`);
+        this.name = "SDKValidationError";
+        this.cause = cause;
+        this.rawValue = rawValue;
+        this.rawMessage = message;
+    }
+    /**
+     * Return a pretty-formatted error message if the underlying validation error
+     * is a ZodError or some other recognized error type, otherwise return the
+     * default error message.
+     */
+    pretty() {
+        if (this.cause instanceof z.$ZodError) {
+            return `${this.rawMessage}\n${formatZodError(this.cause)}`;
+        }
+        else {
+            return this.toString();
+        }
+    }
+}
+export function formatZodError(err) {
+    return z.prettifyError(err);
+}

package/esm/models/errors/state-machines-http-error.d.ts

@@ -0,0 +1,18 @@
+/** The base class for all HTTP error responses */
+export declare class StateMachinesHTTPError extends Error {
+    /** HTTP status code */
+    readonly statusCode: number;
+    /** HTTP body */
+    readonly body: string;
+    /** HTTP headers */
+    readonly headers: Headers;
+    /** HTTP content type */
+    readonly contentType: string;
+    /** Raw response */
+    readonly rawResponse: Response;
+    constructor(message: string, httpMeta: {
+        response: Response;
+        request: Request;
+        body: string;
+    });
+}

package/esm/models/errors/state-machines-http-error.js

@@ -0,0 +1,25 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+/** The base class for all HTTP error responses */
+export class StateMachinesHTTPError extends Error {
+    /** HTTP status code */
+    statusCode;
+    /** HTTP body */
+    body;
+    /** HTTP headers */
+    headers;
+    /** HTTP content type */
+    contentType;
+    /** Raw response */
+    rawResponse;
+    constructor(message, httpMeta) {
+        super(message);
+        this.statusCode = httpMeta.response.status;
+        this.body = httpMeta.body;
+        this.headers = httpMeta.response.headers;
+        this.contentType = httpMeta.response.headers.get("content-type") || "";
+        this.rawResponse = httpMeta.response;
+        this.name = "StateMachinesHTTPError";
+    }
+}

package/esm/models/errors/unexpected-response-error.d.ts

@@ -0,0 +1,9 @@
+import { StateMachinesHTTPError } from "./state-machines-http-error.js";
+/** The fallback error class if no more specific error class is matched */
+export declare class UnexpectedResponseError extends StateMachinesHTTPError {
+    constructor(message: string, httpMeta: {
+        response: Response;
+        request: Request;
+        body: string;
+    });
+}