@usestatemachines/sdk 0.4.0 → 0.6.0

package/esm/models/{event.js → audit-event.js}

@@ -4,19 +4,20 @@
 import * as z from "zod/v4-mini";
 import { safeParse } from "../lib/schemas.js";
 import * as types from "../types/primitives.js";
-import { Actor$inboundSchema } from "./actor.js";
+import { Principal$inboundSchema } from "./principal.js";
 /** @internal */
-export const Event$inboundSchema = z.object({
-    action: types.string(),
-    actor: types.nullable(Actor$inboundSchema),
+export const AuditEvent$inboundSchema = z
+    .object({
     data: z.record(z.string(), z.any()),
     environmentId: types.nullable(types.string()),
     id: types.string(),
+    name: types.string(),
     occurredAt: types.date(),
+    principal: Principal$inboundSchema,
     requestId: types.nullable(types.string()),
     subjectId: types.string(),
     workspaceId: types.nullable(types.string()),
 });
-export function eventFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => Event$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Event' from JSON`);
+export function auditEventFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AuditEvent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AuditEvent' from JSON`);
 }

package/esm/models/body-preview.d.ts

@@ -0,0 +1,31 @@
+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 Coverage: {
+    readonly Recorded: "recorded";
+    readonly Redacted: "redacted";
+    readonly Omitted: "omitted";
+};
+export type Coverage = OpenEnum<typeof Coverage>;
+export declare const Encoding: {
+    readonly Utf8: "utf8";
+    readonly Binary: "binary";
+};
+export type Encoding = OpenEnum<typeof Encoding>;
+export type BodyPreview = {
+    bytes: number | null;
+    contentType: string | null;
+    coverage: Coverage;
+    encoding: Encoding;
+    preview: string | null;
+    previewTruncated: boolean;
+    reason: string | null;
+};
+/** @internal */
+export declare const Coverage$inboundSchema: z.ZodMiniType<Coverage, unknown>;
+/** @internal */
+export declare const Encoding$inboundSchema: z.ZodMiniType<Encoding, unknown>;
+/** @internal */
+export declare const BodyPreview$inboundSchema: z.ZodMiniType<BodyPreview, unknown>;
+export declare function bodyPreviewFromJSON(jsonString: string): SafeParseResult<BodyPreview, SDKValidationError>;

package/esm/models/body-preview.js

@@ -0,0 +1,34 @@
+/*
+ * 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 Coverage = {
+    Recorded: "recorded",
+    Redacted: "redacted",
+    Omitted: "omitted",
+};
+export const Encoding = {
+    Utf8: "utf8",
+    Binary: "binary",
+};
+/** @internal */
+export const Coverage$inboundSchema = openEnums.inboundSchema(Coverage);
+/** @internal */
+export const Encoding$inboundSchema = openEnums.inboundSchema(Encoding);
+/** @internal */
+export const BodyPreview$inboundSchema = z
+    .object({
+    bytes: types.nullable(types.number()),
+    contentType: types.nullable(types.string()),
+    coverage: Coverage$inboundSchema,
+    encoding: Encoding$inboundSchema,
+    preview: types.nullable(types.string()),
+    previewTruncated: types.boolean(),
+    reason: types.nullable(types.string()),
+});
+export function bodyPreviewFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => BodyPreview$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'BodyPreview' from JSON`);
+}

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

@@ -0,0 +1,51 @@
+import * as z from "zod/v4-mini";
+export type CreateEnvironmentApp = {
+    app: string;
+    name?: string | undefined;
+    settings?: {
+        [k: string]: any;
+    } | undefined;
+};
+export type AppUnion = CreateEnvironmentApp | string;
+export type CreateEnvironment = {
+    apps?: Array<CreateEnvironmentApp | string> | undefined;
+    labels?: {
+        [k: string]: string;
+    } | undefined;
+    name?: string | null | undefined;
+    snapshotId?: string | undefined;
+    timeLimitMinutes?: number | undefined;
+    tokenInUrl?: boolean | undefined;
+    workspaceId?: string | undefined;
+};
+/** @internal */
+export type CreateEnvironmentApp$Outbound = {
+    app: string;
+    name?: string | undefined;
+    settings?: {
+        [k: string]: any;
+    } | undefined;
+};
+/** @internal */
+export declare const CreateEnvironmentApp$outboundSchema: z.ZodMiniType<CreateEnvironmentApp$Outbound, CreateEnvironmentApp>;
+export declare function createEnvironmentAppToJSON(createEnvironmentApp: CreateEnvironmentApp): string;
+/** @internal */
+export type AppUnion$Outbound = CreateEnvironmentApp$Outbound | string;
+/** @internal */
+export declare const AppUnion$outboundSchema: z.ZodMiniType<AppUnion$Outbound, AppUnion>;
+export declare function appUnionToJSON(appUnion: AppUnion): string;
+/** @internal */
+export type CreateEnvironment$Outbound = {
+    apps?: Array<CreateEnvironmentApp$Outbound | string> | undefined;
+    labels?: {
+        [k: string]: string;
+    } | undefined;
+    name?: string | null | undefined;
+    snapshotId?: string | undefined;
+    timeLimitMinutes?: number | undefined;
+    tokenInUrl: boolean;
+    workspaceId?: string | undefined;
+};
+/** @internal */
+export declare const CreateEnvironment$outboundSchema: z.ZodMiniType<CreateEnvironment$Outbound, CreateEnvironment>;
+export declare function createEnvironmentToJSON(createEnvironment: CreateEnvironment): string;

package/esm/models/create-environment.js

@@ -0,0 +1,35 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4-mini";
+import { smartUnion } from "../types/smart-union.js";
+/** @internal */
+export const CreateEnvironmentApp$outboundSchema = z.object({
+    app: z.string(),
+    name: z.optional(z.string()),
+    settings: z.optional(z.record(z.string(), z.any())),
+});
+export function createEnvironmentAppToJSON(createEnvironmentApp) {
+    return JSON.stringify(CreateEnvironmentApp$outboundSchema.parse(createEnvironmentApp));
+}
+/** @internal */
+export const AppUnion$outboundSchema = smartUnion([z.lazy(() => CreateEnvironmentApp$outboundSchema), z.string()]);
+export function appUnionToJSON(appUnion) {
+    return JSON.stringify(AppUnion$outboundSchema.parse(appUnion));
+}
+/** @internal */
+export const CreateEnvironment$outboundSchema = z.object({
+    apps: z.optional(z.array(smartUnion([
+        z.lazy(() => CreateEnvironmentApp$outboundSchema),
+        z.string(),
+    ]))),
+    labels: z.optional(z.record(z.string(), z.string())),
+    name: z.optional(z.nullable(z.string())),
+    snapshotId: z.optional(z.string()),
+    timeLimitMinutes: z.optional(z.int()),
+    tokenInUrl: z._default(z.boolean(), false),
+    workspaceId: z.optional(z.string()),
+});
+export function createEnvironmentToJSON(createEnvironment) {
+    return JSON.stringify(CreateEnvironment$outboundSchema.parse(createEnvironment));
+}

package/esm/models/credentials.d.ts

@@ -0,0 +1,31 @@
+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 Login = {
+    authentication: string;
+    parameters: {
+        [k: string]: string;
+    };
+    secrets: {
+        [k: string]: string;
+    };
+    url: string;
+};
+export type Credentials = {
+    actorId: string;
+    app: string;
+    environmentId: string;
+    expiresAt: Date;
+    headers: {
+        [k: string]: string;
+    };
+    login: Login | null;
+    token: string;
+    url: string;
+};
+/** @internal */
+export declare const Login$inboundSchema: z.ZodMiniType<Login, unknown>;
+export declare function loginFromJSON(jsonString: string): SafeParseResult<Login, SDKValidationError>;
+/** @internal */
+export declare const Credentials$inboundSchema: z.ZodMiniType<Credentials, unknown>;
+export declare function credentialsFromJSON(jsonString: string): SafeParseResult<Credentials, SDKValidationError>;

package/esm/models/credentials.js

@@ -0,0 +1,31 @@
+/*
+ * 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 Login$inboundSchema = z.object({
+    authentication: types.string(),
+    parameters: z.record(z.string(), types.string()),
+    secrets: z.record(z.string(), types.string()),
+    url: types.string(),
+});
+export function loginFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Login$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Login' from JSON`);
+}
+/** @internal */
+export const Credentials$inboundSchema = z
+    .object({
+    actorId: types.string(),
+    app: types.string(),
+    environmentId: types.string(),
+    expiresAt: types.date(),
+    headers: z.record(z.string(), types.string()),
+    login: types.nullable(z.lazy(() => Login$inboundSchema)),
+    token: types.string(),
+    url: types.string(),
+});
+export function credentialsFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Credentials$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Credentials' from JSON`);
+}

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

@@ -0,0 +1,22 @@
+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 EnvironmentFailureCode: {
+    readonly StartFailed: "start_failed";
+    readonly RestartFailed: "restart_failed";
+    readonly ResumeFailed: "resume_failed";
+    readonly VersionUnavailable: "version_unavailable";
+    readonly InvalidSettings: "invalid_settings";
+};
+export type EnvironmentFailureCode = OpenEnum<typeof EnvironmentFailureCode>;
+export type EnvironmentFailure = {
+    app: string;
+    code: EnvironmentFailureCode;
+    message: string;
+};
+/** @internal */
+export declare const EnvironmentFailureCode$inboundSchema: z.ZodMiniType<EnvironmentFailureCode, unknown>;
+/** @internal */
+export declare const EnvironmentFailure$inboundSchema: z.ZodMiniType<EnvironmentFailure, unknown>;
+export declare function environmentFailureFromJSON(jsonString: string): SafeParseResult<EnvironmentFailure, SDKValidationError>;

package/esm/models/environment-failure.js

@@ -0,0 +1,25 @@
+/*
+ * 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 EnvironmentFailureCode = {
+    StartFailed: "start_failed",
+    RestartFailed: "restart_failed",
+    ResumeFailed: "resume_failed",
+    VersionUnavailable: "version_unavailable",
+    InvalidSettings: "invalid_settings",
+};
+/** @internal */
+export const EnvironmentFailureCode$inboundSchema = openEnums.inboundSchema(EnvironmentFailureCode);
+/** @internal */
+export const EnvironmentFailure$inboundSchema = z.object({
+    app: types.string(),
+    code: EnvironmentFailureCode$inboundSchema,
+    message: types.string(),
+});
+export function environmentFailureFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => EnvironmentFailure$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'EnvironmentFailure' from JSON`);
+}

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

@@ -0,0 +1,14 @@
+import * as z from "zod/v4-mini";
+import { OpenEnum } from "../types/enums.js";
+export declare const EnvironmentStatus: {
+    readonly Starting: "starting";
+    readonly Running: "running";
+    readonly Paused: "paused";
+    readonly Failed: "failed";
+    readonly Deleted: "deleted";
+};
+export type EnvironmentStatus = OpenEnum<typeof EnvironmentStatus>;
+/** @internal */
+export declare const EnvironmentStatus$inboundSchema: z.ZodMiniType<EnvironmentStatus, unknown>;
+/** @internal */
+export declare const EnvironmentStatus$outboundSchema: z.ZodMiniType<string, EnvironmentStatus>;

package/esm/models/environment-status.js

@@ -0,0 +1,15 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as openEnums from "../types/enums.js";
+export const EnvironmentStatus = {
+    Starting: "starting",
+    Running: "running",
+    Paused: "paused",
+    Failed: "failed",
+    Deleted: "deleted",
+};
+/** @internal */
+export const EnvironmentStatus$inboundSchema = openEnums.inboundSchema(EnvironmentStatus);
+/** @internal */
+export const EnvironmentStatus$outboundSchema = openEnums.outboundSchema(EnvironmentStatus);

package/esm/models/environment.d.ts

@@ -1,52 +1,52 @@
 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 { EnvironmentFailure } from "./environment-failure.js";
+import { EnvironmentStatus } from "./environment-status.js";
 import { SDKValidationError } from "./errors/sdk-validation-error.js";
-export declare const EnvironmentStatus: {
-    readonly Queued: "queued";
-    readonly Starting: "starting";
-    readonly Running: "running";
-    readonly Suspending: "suspending";
-    readonly Suspended: "suspended";
-    readonly Stopping: "stopping";
-    readonly Stopped: "stopped";
-    readonly Failed: "failed";
+import { Principal } from "./principal.js";
+export type EnvironmentApp = {
+    appId: string;
+    name: string;
+    settings: {
+        [k: string]: any;
+    };
+    url: string;
+    version: string;
+    versionId: string;
 };
-export type EnvironmentStatus = OpenEnum<typeof EnvironmentStatus>;
-export declare const StopReason: {
-    readonly Requested: "requested";
+export declare const Reason: {
+    readonly Cancelled: "cancelled";
     readonly Expired: "expired";
-    readonly AppFailed: "app_failed";
-    readonly OwnerLost: "owner_lost";
+    readonly Failed: "failed";
 };
-export type StopReason = OpenEnum<typeof StopReason>;
+export type Reason = OpenEnum<typeof Reason>;
 export type Environment = {
     apps: Array<EnvironmentApp>;
     createdAt: Date;
-    createdBy: Actor | null;
+    createdBy: Principal;
+    deletedAt: Date | null;
     expiresAt: Date | null;
+    failure: EnvironmentFailure | null;
     id: string;
     labels: {
         [k: string]: string;
     };
-    lifetimeMinutes: number;
     name: string | null;
-    sourceEnvironmentId: string | null;
-    sourceEnvironmentSnapshotId: string | null;
+    pausedAt: Date | null;
+    reason: Reason | null;
+    snapshotId: string | null;
     startedAt: Date | null;
     status: EnvironmentStatus;
-    stopReason: StopReason | null;
-    stoppedAt: Date | null;
-    suspendedAt: Date | null;
-    version: number;
+    timeLimitMinutes: number;
+    tokenInUrl: boolean;
     workspaceId: string;
 };
 /** @internal */
-export declare const EnvironmentStatus$inboundSchema: z.ZodMiniType<EnvironmentStatus, unknown>;
+export declare const EnvironmentApp$inboundSchema: z.ZodMiniType<EnvironmentApp, unknown>;
+export declare function environmentAppFromJSON(jsonString: string): SafeParseResult<EnvironmentApp, SDKValidationError>;
 /** @internal */
-export declare const StopReason$inboundSchema: z.ZodMiniType<StopReason, unknown>;
+export declare const Reason$inboundSchema: z.ZodMiniType<Reason, 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

@@ -5,47 +5,48 @@ 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",
-    Suspending: "suspending",
-    Suspended: "suspended",
-    Stopping: "stopping",
-    Stopped: "stopped",
-    Failed: "failed",
-};
-export const StopReason = {
-    Requested: "requested",
+import { EnvironmentFailure$inboundSchema, } from "./environment-failure.js";
+import { EnvironmentStatus$inboundSchema, } from "./environment-status.js";
+import { Principal$inboundSchema } from "./principal.js";
+export const Reason = {
+    Cancelled: "cancelled",
     Expired: "expired",
-    AppFailed: "app_failed",
-    OwnerLost: "owner_lost",
+    Failed: "failed",
 };
 /** @internal */
-export const EnvironmentStatus$inboundSchema = openEnums.inboundSchema(EnvironmentStatus);
+export const EnvironmentApp$inboundSchema = z.object({
+    appId: types.string(),
+    name: types.string(),
+    settings: z.record(z.string(), z.any()),
+    url: types.string(),
+    version: types.string(),
+    versionId: types.string(),
+});
+export function environmentAppFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => EnvironmentApp$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'EnvironmentApp' from JSON`);
+}
 /** @internal */
-export const StopReason$inboundSchema = openEnums.inboundSchema(StopReason);
+export const Reason$inboundSchema = openEnums
+    .inboundSchema(Reason);
 /** @internal */
 export const Environment$inboundSchema = z
     .object({
-    apps: z.array(EnvironmentApp$inboundSchema),
+    apps: z.array(z.lazy(() => EnvironmentApp$inboundSchema)),
     createdAt: types.date(),
-    createdBy: types.nullable(Actor$inboundSchema),
+    createdBy: Principal$inboundSchema,
+    deletedAt: types.nullable(types.date()),
     expiresAt: types.nullable(types.date()),
+    failure: types.nullable(EnvironmentFailure$inboundSchema),
     id: types.string(),
     labels: z.record(z.string(), types.string()),
-    lifetimeMinutes: types.number(),
     name: types.nullable(types.string()),
-    sourceEnvironmentId: z._default(z.nullable(types.string()), null),
-    sourceEnvironmentSnapshotId: z._default(z.nullable(types.string()), null),
+    pausedAt: types.nullable(types.date()),
+    reason: types.nullable(Reason$inboundSchema),
+    snapshotId: types.nullable(types.string()),
     startedAt: types.nullable(types.date()),
     status: EnvironmentStatus$inboundSchema,
-    stopReason: types.nullable(StopReason$inboundSchema),
-    stoppedAt: types.nullable(types.date()),
-    suspendedAt: types.nullable(types.date()),
-    version: types.number(),
+    timeLimitMinutes: types.number(),
+    tokenInUrl: types.boolean(),
     workspaceId: types.string(),
 });
 export function environmentFromJSON(jsonString) {

package/esm/models/error.d.ts

@@ -0,0 +1,38 @@
+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 ErrorCode: {
+    readonly InvalidRequest: "invalid_request";
+    readonly Unauthenticated: "unauthenticated";
+    readonly Forbidden: "forbidden";
+    readonly NotFound: "not_found";
+    readonly InvalidStatus: "invalid_status";
+    readonly SnapshotInProgress: "snapshot_in_progress";
+    readonly IdempotencyKeyReused: "idempotency_key_reused";
+    readonly NameTaken: "name_taken";
+    readonly LastOwner: "last_owner";
+    readonly LastWorkspace: "last_workspace";
+    readonly WorkspaceArchived: "workspace_archived";
+    readonly VersionInUse: "version_in_use";
+    readonly BodyTooLarge: "body_too_large";
+    readonly VersionUnavailable: "version_unavailable";
+    readonly EnvironmentLimitReached: "environment_limit_reached";
+    readonly InternalError: "internal_error";
+    readonly Unavailable: "unavailable";
+};
+export type ErrorCode = OpenEnum<typeof ErrorCode>;
+export type ErrorT = {
+    code: ErrorCode;
+    fields?: {
+        [k: string]: Array<string>;
+    } | undefined;
+    message: string;
+    requestId: string;
+    status?: string | undefined;
+};
+/** @internal */
+export declare const ErrorCode$inboundSchema: z.ZodMiniType<ErrorCode, unknown>;
+/** @internal */
+export declare const ErrorT$inboundSchema: z.ZodMiniType<ErrorT, unknown>;
+export declare function errorFromJSON(jsonString: string): SafeParseResult<ErrorT, SDKValidationError>;

package/esm/models/error.js

@@ -0,0 +1,39 @@
+/*
+ * 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 ErrorCode = {
+    InvalidRequest: "invalid_request",
+    Unauthenticated: "unauthenticated",
+    Forbidden: "forbidden",
+    NotFound: "not_found",
+    InvalidStatus: "invalid_status",
+    SnapshotInProgress: "snapshot_in_progress",
+    IdempotencyKeyReused: "idempotency_key_reused",
+    NameTaken: "name_taken",
+    LastOwner: "last_owner",
+    LastWorkspace: "last_workspace",
+    WorkspaceArchived: "workspace_archived",
+    VersionInUse: "version_in_use",
+    BodyTooLarge: "body_too_large",
+    VersionUnavailable: "version_unavailable",
+    EnvironmentLimitReached: "environment_limit_reached",
+    InternalError: "internal_error",
+    Unavailable: "unavailable",
+};
+/** @internal */
+export const ErrorCode$inboundSchema = openEnums.inboundSchema(ErrorCode);
+/** @internal */
+export const ErrorT$inboundSchema = z.object({
+    code: ErrorCode$inboundSchema,
+    fields: types.optional(z.record(z.string(), z.array(types.string()))),
+    message: types.string(),
+    requestId: types.string(),
+    status: types.optional(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 → error.d.ts}

@@ -1,18 +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 = {
+export type ErrorTData = {
     error: models.ErrorT;
 };
-export declare class ErrorResponse extends StateMachinesHTTPError {
+export declare class ErrorT extends StateMachinesHTTPError {
     error: models.ErrorT;
     /** The original data that was passed to this error instance. */
-    data$: ErrorResponseData;
-    constructor(err: ErrorResponseData, httpMeta: {
+    data$: ErrorTData;
+    constructor(err: ErrorTData, httpMeta: {
         response: Response;
         request: Request;
         body: string;
     });
 }
 /** @internal */
-export declare const ErrorResponse$inboundSchema: z.ZodMiniType<ErrorResponse, unknown>;
+export declare const ErrorT$inboundSchema: z.ZodMiniType<ErrorT, unknown>;

package/esm/models/errors/{error-response.js → error.js}

@@ -4,7 +4,7 @@
 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 {
+export class ErrorT extends StateMachinesHTTPError {
     error;
     /** The original data that was passed to this error instance. */
     data$;
@@ -14,17 +14,17 @@ export class ErrorResponse extends StateMachinesHTTPError {
         super(message, httpMeta);
         this.data$ = err;
         this.error = err.error;
-        this.name = "ErrorResponse";
+        this.name = "ErrorT";
     }
 }
 /** @internal */
-export const ErrorResponse$inboundSchema = z.pipe(z.object({
+export const ErrorT$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, {
+    return new ErrorT(v, {
         request: v.request$,
         response: v.response$,
         body: v.body$,

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

@@ -1,4 +1,4 @@
-export * from "./error-response.js";
+export * from "./error.js";
 export * from "./http-client-errors.js";
 export * from "./response-validation-error.js";
 export * from "./sdk-validation-error.js";

package/esm/models/errors/index.js

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