@usestatemachines/sdk 0.2.0 → 0.4.0

package/esm/models/app-instance-snapshot.d.ts

@@ -0,0 +1,15 @@
+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 AppInstanceSnapshot = {
+    appId: string;
+    appInstanceKey: string;
+    appReleaseId: string;
+    capturedAt: Date | null;
+    id: string;
+    sizeBytes: number | null;
+    sourceAppInstanceId: string;
+};
+/** @internal */
+export declare const AppInstanceSnapshot$inboundSchema: z.ZodMiniType<AppInstanceSnapshot, unknown>;
+export declare function appInstanceSnapshotFromJSON(jsonString: string): SafeParseResult<AppInstanceSnapshot, SDKValidationError>;

package/esm/models/app-instance-snapshot.js

@@ -0,0 +1,19 @@
+/*
+ * 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 AppInstanceSnapshot$inboundSchema = z.object({
+    appId: types.string(),
+    appInstanceKey: types.string(),
+    appReleaseId: types.string(),
+    capturedAt: types.nullable(types.date()),
+    id: types.string(),
+    sizeBytes: types.nullable(types.number()),
+    sourceAppInstanceId: types.string(),
+});
+export function appInstanceSnapshotFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AppInstanceSnapshot$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AppInstanceSnapshot' from JSON`);
+}

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

@@ -5,12 +5,14 @@ export type CreateEnvironmentInputApp = {
     key: string;
 };
 export type CreateEnvironmentInput = {
-    apps: Array<CreateEnvironmentInputApp>;
+    apps?: Array<CreateEnvironmentInputApp> | undefined;
     labels?: {
         [k: string]: string;
     } | undefined;
     lifetimeMinutes?: number | undefined;
     name?: string | undefined;
+    snapshotAppInstanceKeys?: Array<string> | undefined;
+    snapshotId?: string | undefined;
 };
 /** @internal */
 export type CreateEnvironmentInputApp$Outbound = {
@@ -23,12 +25,14 @@ export declare const CreateEnvironmentInputApp$outboundSchema: z.ZodMiniType<Cre
 export declare function createEnvironmentInputAppToJSON(createEnvironmentInputApp: CreateEnvironmentInputApp): string;
 /** @internal */
 export type CreateEnvironmentInput$Outbound = {
-    apps: Array<CreateEnvironmentInputApp$Outbound>;
+    apps?: Array<CreateEnvironmentInputApp$Outbound> | undefined;
     labels?: {
         [k: string]: string;
     } | undefined;
     lifetimeMinutes?: number | undefined;
     name?: string | undefined;
+    snapshotAppInstanceKeys?: Array<string> | undefined;
+    snapshotId?: string | undefined;
 };
 /** @internal */
 export declare const CreateEnvironmentInput$outboundSchema: z.ZodMiniType<CreateEnvironmentInput$Outbound, CreateEnvironmentInput>;

package/esm/models/create-environment-input.js

@@ -13,10 +13,12 @@ export function createEnvironmentInputAppToJSON(createEnvironmentInputApp) {
 }
 /** @internal */
 export const CreateEnvironmentInput$outboundSchema = z.object({
-    apps: z.array(z.lazy(() => CreateEnvironmentInputApp$outboundSchema)),
+    apps: z.optional(z.array(z.lazy(() => CreateEnvironmentInputApp$outboundSchema))),
     labels: z.optional(z.record(z.string(), z.string())),
     lifetimeMinutes: z.optional(z.int()),
     name: z.optional(z.string()),
+    snapshotAppInstanceKeys: z.optional(z.array(z.string())),
+    snapshotId: z.optional(z.string()),
 });
 export function createEnvironmentInputToJSON(createEnvironmentInput) {
     return JSON.stringify(CreateEnvironmentInput$outboundSchema.parse(createEnvironmentInput));

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

@@ -9,10 +9,16 @@ export declare const Disposal: {
     readonly Unknown: "unknown";
 };
 export type Disposal = OpenEnum<typeof Disposal>;
+export type ForkedAt = {
+    generation: number;
+    lsn: string;
+};
 export declare const EnvironmentAppStatus: {
     readonly Pending: "pending";
     readonly Starting: "starting";
     readonly Ready: "ready";
+    readonly Recovering: "recovering";
+    readonly Suspended: "suspended";
     readonly Stopping: "stopping";
     readonly Stopped: "stopped";
     readonly Failed: "failed";
@@ -25,17 +31,22 @@ export type EnvironmentApp = {
     disposal: Disposal;
     errorCode: string | null;
     expiresAt: Date | null;
+    forkedAt?: ForkedAt | null | undefined;
     id: string;
     key: string;
     provider: string;
     readyAt: Date | null;
     region: string | null;
+    sourceAppInstanceSnapshotId: string | null;
     status: EnvironmentAppStatus;
     stoppedAt: Date | null;
 };
 /** @internal */
 export declare const Disposal$inboundSchema: z.ZodMiniType<Disposal, unknown>;
 /** @internal */
+export declare const ForkedAt$inboundSchema: z.ZodMiniType<ForkedAt, unknown>;
+export declare function forkedAtFromJSON(jsonString: string): SafeParseResult<ForkedAt, SDKValidationError>;
+/** @internal */
 export declare const EnvironmentAppStatus$inboundSchema: z.ZodMiniType<EnvironmentAppStatus, unknown>;
 /** @internal */
 export declare const EnvironmentApp$inboundSchema: z.ZodMiniType<EnvironmentApp, unknown>;

package/esm/models/environment-app.js

@@ -15,6 +15,8 @@ export const EnvironmentAppStatus = {
     Pending: "pending",
     Starting: "starting",
     Ready: "ready",
+    Recovering: "recovering",
+    Suspended: "suspended",
     Stopping: "stopping",
     Stopped: "stopped",
     Failed: "failed",
@@ -22,6 +24,15 @@ export const EnvironmentAppStatus = {
 /** @internal */
 export const Disposal$inboundSchema = openEnums.inboundSchema(Disposal);
 /** @internal */
+export const ForkedAt$inboundSchema = z
+    .object({
+    generation: types.number(),
+    lsn: types.string(),
+});
+export function forkedAtFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ForkedAt$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ForkedAt' from JSON`);
+}
+/** @internal */
 export const EnvironmentAppStatus$inboundSchema = openEnums.inboundSchema(EnvironmentAppStatus);
 /** @internal */
 export const EnvironmentApp$inboundSchema = z.object({
@@ -31,11 +42,13 @@ export const EnvironmentApp$inboundSchema = z.object({
     disposal: Disposal$inboundSchema,
     errorCode: types.nullable(types.string()),
     expiresAt: types.nullable(types.date()),
+    forkedAt: z.optional(z.nullable(z.lazy(() => ForkedAt$inboundSchema))),
     id: types.string(),
     key: types.string(),
     provider: types.string(),
     readyAt: types.nullable(types.date()),
     region: types.nullable(types.string()),
+    sourceAppInstanceSnapshotId: z._default(z.nullable(types.string()), null),
     status: EnvironmentAppStatus$inboundSchema,
     stoppedAt: types.nullable(types.date()),
 });

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

@@ -0,0 +1,116 @@
+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";
+import { HistoryBody } from "./history-body.js";
+import { HistoryPosition } from "./history-position.js";
+import { HistoryTransaction } from "./history-transaction.js";
+export type EnvironmentExchangeActor = {
+    credentialId: string | null;
+    vendorUserId: string | null;
+};
+export type Bodies = {
+    request: HistoryBody;
+    response: HistoryBody;
+};
+export declare const Channel: {
+    readonly Api: "api";
+    readonly Ui: "ui";
+    readonly Reactor: "reactor";
+    readonly Timer: "timer";
+    readonly InboundWebhook: "inbound-webhook";
+    readonly Bootstrap: "bootstrap";
+    readonly Restore: "restore";
+};
+export type Channel = OpenEnum<typeof Channel>;
+export type Operation = {
+    id: string | null;
+    method: string;
+    profile: string;
+    route: string;
+    target: string;
+};
+export declare const Refusal: {
+    readonly Auth: "auth";
+    readonly NotServed: "not-served";
+    readonly Unsupported: "unsupported";
+    readonly Limit: "limit";
+    readonly Validation: "validation";
+    readonly Conflict: "conflict";
+};
+export type Refusal = OpenEnum<typeof Refusal>;
+export type Outcome = {
+    refusal: Refusal | null;
+    status: number;
+    vendorErrorCode: string | null;
+};
+export declare const State: {
+    readonly Recorded: "recorded";
+    readonly Unknown: "unknown";
+};
+export type State = OpenEnum<typeof State>;
+export declare const ClockSource: {
+    readonly Gateway: "gateway";
+    readonly Runner: "runner";
+};
+export type ClockSource = OpenEnum<typeof ClockSource>;
+export type Timing = {
+    clockSource: ClockSource;
+    databaseMs: number;
+    environmentTime: string;
+    handlerMs: number;
+    leaseWaitMs: number;
+    responseReadyAt: string;
+};
+export type Trace = {
+    parentSpanId: string | null;
+    spanId: string;
+    traceId: string;
+};
+export type EnvironmentExchange = {
+    actor: EnvironmentExchangeActor | null;
+    appKey: string;
+    bodies: Bodies | null;
+    channel: Channel | null;
+    eventIds: Array<string>;
+    exchangeId: string;
+    objectCount: number;
+    objects: Array<string>;
+    observedAt: Date;
+    operation: Operation | null;
+    outcome: Outcome | null;
+    position: HistoryPosition;
+    state: State;
+    timing: Timing | null;
+    trace: Trace | null;
+    transactions: Array<HistoryTransaction>;
+};
+/** @internal */
+export declare const EnvironmentExchangeActor$inboundSchema: z.ZodMiniType<EnvironmentExchangeActor, unknown>;
+export declare function environmentExchangeActorFromJSON(jsonString: string): SafeParseResult<EnvironmentExchangeActor, SDKValidationError>;
+/** @internal */
+export declare const Bodies$inboundSchema: z.ZodMiniType<Bodies, unknown>;
+export declare function bodiesFromJSON(jsonString: string): SafeParseResult<Bodies, SDKValidationError>;
+/** @internal */
+export declare const Channel$inboundSchema: z.ZodMiniType<Channel, unknown>;
+/** @internal */
+export declare const Operation$inboundSchema: z.ZodMiniType<Operation, unknown>;
+export declare function operationFromJSON(jsonString: string): SafeParseResult<Operation, SDKValidationError>;
+/** @internal */
+export declare const Refusal$inboundSchema: z.ZodMiniType<Refusal, unknown>;
+/** @internal */
+export declare const Outcome$inboundSchema: z.ZodMiniType<Outcome, unknown>;
+export declare function outcomeFromJSON(jsonString: string): SafeParseResult<Outcome, SDKValidationError>;
+/** @internal */
+export declare const State$inboundSchema: z.ZodMiniType<State, unknown>;
+/** @internal */
+export declare const ClockSource$inboundSchema: z.ZodMiniType<ClockSource, unknown>;
+/** @internal */
+export declare const Timing$inboundSchema: z.ZodMiniType<Timing, unknown>;
+export declare function timingFromJSON(jsonString: string): SafeParseResult<Timing, SDKValidationError>;
+/** @internal */
+export declare const Trace$inboundSchema: z.ZodMiniType<Trace, unknown>;
+export declare function traceFromJSON(jsonString: string): SafeParseResult<Trace, SDKValidationError>;
+/** @internal */
+export declare const EnvironmentExchange$inboundSchema: z.ZodMiniType<EnvironmentExchange, unknown>;
+export declare function environmentExchangeFromJSON(jsonString: string): SafeParseResult<EnvironmentExchange, SDKValidationError>;

package/esm/models/environment-exchange.js

@@ -0,0 +1,126 @@
+/*
+ * 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 { HistoryBody$inboundSchema } from "./history-body.js";
+import { HistoryPosition$inboundSchema, } from "./history-position.js";
+import { HistoryTransaction$inboundSchema, } from "./history-transaction.js";
+export const Channel = {
+    Api: "api",
+    Ui: "ui",
+    Reactor: "reactor",
+    Timer: "timer",
+    InboundWebhook: "inbound-webhook",
+    Bootstrap: "bootstrap",
+    Restore: "restore",
+};
+export const Refusal = {
+    Auth: "auth",
+    NotServed: "not-served",
+    Unsupported: "unsupported",
+    Limit: "limit",
+    Validation: "validation",
+    Conflict: "conflict",
+};
+export const State = {
+    Recorded: "recorded",
+    Unknown: "unknown",
+};
+export const ClockSource = {
+    Gateway: "gateway",
+    Runner: "runner",
+};
+/** @internal */
+export const EnvironmentExchangeActor$inboundSchema = z.object({
+    credentialId: types.nullable(types.string()),
+    vendorUserId: types.nullable(types.string()),
+});
+export function environmentExchangeActorFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => EnvironmentExchangeActor$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'EnvironmentExchangeActor' from JSON`);
+}
+/** @internal */
+export const Bodies$inboundSchema = z.object({
+    request: HistoryBody$inboundSchema,
+    response: HistoryBody$inboundSchema,
+});
+export function bodiesFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Bodies$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Bodies' from JSON`);
+}
+/** @internal */
+export const Channel$inboundSchema = openEnums
+    .inboundSchema(Channel);
+/** @internal */
+export const Operation$inboundSchema = z
+    .object({
+    id: types.nullable(types.string()),
+    method: types.string(),
+    profile: types.string(),
+    route: types.string(),
+    target: types.string(),
+});
+export function operationFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Operation$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Operation' from JSON`);
+}
+/** @internal */
+export const Refusal$inboundSchema = openEnums
+    .inboundSchema(Refusal);
+/** @internal */
+export const Outcome$inboundSchema = z.object({
+    refusal: types.nullable(Refusal$inboundSchema),
+    status: types.number(),
+    vendorErrorCode: types.nullable(types.string()),
+});
+export function outcomeFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Outcome$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Outcome' from JSON`);
+}
+/** @internal */
+export const State$inboundSchema = openEnums
+    .inboundSchema(State);
+/** @internal */
+export const ClockSource$inboundSchema = openEnums.inboundSchema(ClockSource);
+/** @internal */
+export const Timing$inboundSchema = z.object({
+    clockSource: ClockSource$inboundSchema,
+    databaseMs: types.number(),
+    environmentTime: types.string(),
+    handlerMs: types.number(),
+    leaseWaitMs: types.number(),
+    responseReadyAt: types.string(),
+});
+export function timingFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Timing$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Timing' from JSON`);
+}
+/** @internal */
+export const Trace$inboundSchema = z.object({
+    parentSpanId: types.nullable(types.string()),
+    spanId: types.string(),
+    traceId: types.string(),
+});
+export function traceFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Trace$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Trace' from JSON`);
+}
+/** @internal */
+export const EnvironmentExchange$inboundSchema = z.object({
+    actor: types.nullable(z.lazy(() => EnvironmentExchangeActor$inboundSchema)),
+    appKey: types.string(),
+    bodies: types.nullable(z.lazy(() => Bodies$inboundSchema)),
+    channel: types.nullable(Channel$inboundSchema),
+    eventIds: z.array(types.string()),
+    exchangeId: types.string(),
+    objectCount: types.number(),
+    objects: z.array(types.string()),
+    observedAt: types.date(),
+    operation: types.nullable(z.lazy(() => Operation$inboundSchema)),
+    outcome: types.nullable(z.lazy(() => Outcome$inboundSchema)),
+    position: HistoryPosition$inboundSchema,
+    state: State$inboundSchema,
+    timing: types.nullable(z.lazy(() => Timing$inboundSchema)),
+    trace: types.nullable(z.lazy(() => Trace$inboundSchema)),
+    transactions: z.array(HistoryTransaction$inboundSchema),
+});
+export function environmentExchangeFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => EnvironmentExchange$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'EnvironmentExchange' from JSON`);
+}

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

@@ -0,0 +1,25 @@
+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 Position = {
+    generation: number;
+    lsn: string;
+};
+export type EnvironmentPositionApp = {
+    appInstanceId: string;
+    key: string;
+    position: Position | null;
+};
+export type EnvironmentPosition = {
+    apps: Array<EnvironmentPositionApp>;
+    environmentId: string;
+};
+/** @internal */
+export declare const Position$inboundSchema: z.ZodMiniType<Position, unknown>;
+export declare function positionFromJSON(jsonString: string): SafeParseResult<Position, SDKValidationError>;
+/** @internal */
+export declare const EnvironmentPositionApp$inboundSchema: z.ZodMiniType<EnvironmentPositionApp, unknown>;
+export declare function environmentPositionAppFromJSON(jsonString: string): SafeParseResult<EnvironmentPositionApp, SDKValidationError>;
+/** @internal */
+export declare const EnvironmentPosition$inboundSchema: z.ZodMiniType<EnvironmentPosition, unknown>;
+export declare function environmentPositionFromJSON(jsonString: string): SafeParseResult<EnvironmentPosition, SDKValidationError>;

package/esm/models/environment-position.js

@@ -0,0 +1,32 @@
+/*
+ * 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 Position$inboundSchema = z
+    .object({
+    generation: types.number(),
+    lsn: types.string(),
+});
+export function positionFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Position$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Position' from JSON`);
+}
+/** @internal */
+export const EnvironmentPositionApp$inboundSchema = z.object({
+    appInstanceId: types.string(),
+    key: types.string(),
+    position: types.nullable(z.lazy(() => Position$inboundSchema)),
+});
+export function environmentPositionAppFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => EnvironmentPositionApp$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'EnvironmentPositionApp' from JSON`);
+}
+/** @internal */
+export const EnvironmentPosition$inboundSchema = z.object({
+    apps: z.array(z.lazy(() => EnvironmentPositionApp$inboundSchema)),
+    environmentId: types.string(),
+});
+export function environmentPositionFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => EnvironmentPosition$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'EnvironmentPosition' from JSON`);
+}

package/esm/models/environment-snapshot.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 { Actor } from "./actor.js";
+import { AppInstanceSnapshot } from "./app-instance-snapshot.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+export declare const Consistency: {
+    readonly Environment: "environment";
+    readonly AppInstance: "app_instance";
+};
+export type Consistency = OpenEnum<typeof Consistency>;
+export declare const EnvironmentSnapshotStatus: {
+    readonly Capturing: "capturing";
+    readonly Ready: "ready";
+    readonly Failed: "failed";
+};
+export type EnvironmentSnapshotStatus = OpenEnum<typeof EnvironmentSnapshotStatus>;
+export type EnvironmentSnapshot = {
+    appInstanceSnapshots: Array<AppInstanceSnapshot>;
+    consistency: Consistency | null;
+    createdAt: Date;
+    createdBy: Actor | null;
+    deletedAt: Date | null;
+    errorCode: string | null;
+    id: string;
+    name: string | null;
+    readyAt: Date | null;
+    sizeBytes: number | null;
+    sourceEnvironmentId: string;
+    status: EnvironmentSnapshotStatus;
+    version: number;
+    workspaceId: string;
+};
+/** @internal */
+export declare const Consistency$inboundSchema: z.ZodMiniType<Consistency, unknown>;
+/** @internal */
+export declare const EnvironmentSnapshotStatus$inboundSchema: z.ZodMiniType<EnvironmentSnapshotStatus, unknown>;
+/** @internal */
+export declare const EnvironmentSnapshot$inboundSchema: z.ZodMiniType<EnvironmentSnapshot, unknown>;
+export declare function environmentSnapshotFromJSON(jsonString: string): SafeParseResult<EnvironmentSnapshot, SDKValidationError>;

package/esm/models/environment-snapshot.js

@@ -0,0 +1,42 @@
+/*
+ * 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 { AppInstanceSnapshot$inboundSchema, } from "./app-instance-snapshot.js";
+export const Consistency = {
+    Environment: "environment",
+    AppInstance: "app_instance",
+};
+export const EnvironmentSnapshotStatus = {
+    Capturing: "capturing",
+    Ready: "ready",
+    Failed: "failed",
+};
+/** @internal */
+export const Consistency$inboundSchema = openEnums.inboundSchema(Consistency);
+/** @internal */
+export const EnvironmentSnapshotStatus$inboundSchema = openEnums.inboundSchema(EnvironmentSnapshotStatus);
+/** @internal */
+export const EnvironmentSnapshot$inboundSchema = z.object({
+    appInstanceSnapshots: z.array(AppInstanceSnapshot$inboundSchema),
+    consistency: types.nullable(Consistency$inboundSchema),
+    createdAt: types.date(),
+    createdBy: types.nullable(Actor$inboundSchema),
+    deletedAt: types.nullable(types.date()),
+    errorCode: types.nullable(types.string()),
+    id: types.string(),
+    name: types.nullable(types.string()),
+    readyAt: types.nullable(types.date()),
+    sizeBytes: types.nullable(types.number()),
+    sourceEnvironmentId: types.string(),
+    status: EnvironmentSnapshotStatus$inboundSchema,
+    version: types.number(),
+    workspaceId: types.string(),
+});
+export function environmentSnapshotFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => EnvironmentSnapshot$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'EnvironmentSnapshot' from JSON`);
+}

package/esm/models/environment.d.ts

@@ -8,6 +8,8 @@ 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";
@@ -31,10 +33,13 @@ export type Environment = {
     };
     lifetimeMinutes: number;
     name: string | null;
+    sourceEnvironmentId: string | null;
+    sourceEnvironmentSnapshotId: string | null;
     startedAt: Date | null;
     status: EnvironmentStatus;
     stopReason: StopReason | null;
     stoppedAt: Date | null;
+    suspendedAt: Date | null;
     version: number;
     workspaceId: string;
 };

package/esm/models/environment.js

@@ -11,6 +11,8 @@ export const EnvironmentStatus = {
     Queued: "queued",
     Starting: "starting",
     Running: "running",
+    Suspending: "suspending",
+    Suspended: "suspended",
     Stopping: "stopping",
     Stopped: "stopped",
     Failed: "failed",
@@ -36,10 +38,13 @@ export const Environment$inboundSchema = z
     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),
     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(),
     workspaceId: types.string(),
 });

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

@@ -4,6 +4,7 @@ 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 CaptureInProgress: "capture-in-progress";
     readonly ConnectionNotAuthorized: "connection-not-authorized";
     readonly ConnectionUnavailable: "connection-unavailable";
     readonly EnvironmentLimit: "environment-limit";
@@ -23,11 +24,19 @@ export declare const Code: {
     readonly LifetimeTooLong: "lifetime-too-long";
     readonly NotFound: "not-found";
     readonly NotReady: "not-ready";
+    readonly NotSnapshottable: "not-snapshottable";
+    readonly NotSuspended: "not-suspended";
     readonly OrganizationRequired: "organization-required";
+    readonly PositionUnavailable: "position-unavailable";
+    readonly ReleaseGone: "release-gone";
+    readonly ReleaseLifecycle: "release-lifecycle";
     readonly ReleaseUnavailable: "release-unavailable";
     readonly RequestCapacityReached: "request-capacity-reached";
     readonly RequestTimeout: "request-timeout";
     readonly ServiceUnavailable: "service-unavailable";
+    readonly SnapshotLimit: "snapshot-limit";
+    readonly SnapshotsUnavailable: "snapshots-unavailable";
+    readonly SuspendInProgress: "suspend-in-progress";
     readonly Unauthorized: "unauthorized";
     readonly VersionConflict: "version-conflict";
     readonly WorkspaceArchived: "workspace-archived";

package/esm/models/error-response.js

@@ -7,6 +7,7 @@ import * as openEnums from "../types/enums.js";
 import * as types from "../types/primitives.js";
 export const Code = {
     BodyTooLarge: "body-too-large",
+    CaptureInProgress: "capture-in-progress",
     ConnectionNotAuthorized: "connection-not-authorized",
     ConnectionUnavailable: "connection-unavailable",
     EnvironmentLimit: "environment-limit",
@@ -26,11 +27,19 @@ export const Code = {
     LifetimeTooLong: "lifetime-too-long",
     NotFound: "not-found",
     NotReady: "not-ready",
+    NotSnapshottable: "not-snapshottable",
+    NotSuspended: "not-suspended",
     OrganizationRequired: "organization-required",
+    PositionUnavailable: "position-unavailable",
+    ReleaseGone: "release-gone",
+    ReleaseLifecycle: "release-lifecycle",
     ReleaseUnavailable: "release-unavailable",
     RequestCapacityReached: "request-capacity-reached",
     RequestTimeout: "request-timeout",
     ServiceUnavailable: "service-unavailable",
+    SnapshotLimit: "snapshot-limit",
+    SnapshotsUnavailable: "snapshots-unavailable",
+    SuspendInProgress: "suspend-in-progress",
     Unauthorized: "unauthorized",
     VersionConflict: "version-conflict",
     WorkspaceArchived: "workspace-archived",