@usestatemachines/sdk 0.3.0 → 0.4.0

package/esm/funcs/list-environment-history.js

@@ -0,0 +1,97 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4-mini";
+import { encodeFormQuery, 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 operations from "../models/operations/index.js";
+import { APIPromise } from "../types/async.js";
+export function listEnvironmentHistory(client, request, options) {
+    return new APIPromise($do(client, request, options));
+}
+async function $do(client, request, options) {
+    const parsed = safeParse(request, (value) => z.parse(operations.ListEnvironmentHistoryRequest$outboundSchema, value), "Input validation failed");
+    if (!parsed.ok) {
+        return [parsed, { status: "invalid" }];
+    }
+    const payload = parsed.value;
+    const body = null;
+    const pathParams = {
+        environmentId: encodeSimple("environmentId", payload.environmentId, {
+            explode: false,
+            charEncoding: "percent",
+        }),
+    };
+    const path = pathToFunc("/v1/environments/{environmentId}/history")(pathParams);
+    const query = encodeFormQuery({
+        "cursor": payload.cursor,
+        "limit": payload.limit,
+    });
+    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: "listEnvironmentHistory",
+        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.ListEnvironmentHistoryResponse$inboundSchema), M.jsonErr([400, 401, 403, 404, 409, 413, 422, 429], errors.ErrorResponse$inboundSchema), M.jsonErr([500, 503], errors.ErrorResponse$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.3.0";
+    readonly sdkVersion: "0.4.0";
     readonly genVersion: "2.941.0";
-    readonly userAgent: "speakeasy-sdk/typescript 0.3.0 2.941.0 1.0.0 @usestatemachines/sdk";
+    readonly userAgent: "speakeasy-sdk/typescript 0.4.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.3.0",
+    sdkVersion: "0.4.0",
     genVersion: "2.941.0",
-    userAgent: "speakeasy-sdk/typescript 0.3.0 2.941.0 1.0.0 @usestatemachines/sdk",
+    userAgent: "speakeasy-sdk/typescript 0.4.0 2.941.0 1.0.0 @usestatemachines/sdk",
 };

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,6 +31,7 @@ export type EnvironmentApp = {
     disposal: Disposal;
     errorCode: string | null;
     expiresAt: Date | null;
+    forkedAt?: ForkedAt | null | undefined;
     id: string;
     key: string;
     provider: string;
@@ -37,6 +44,9 @@ export type EnvironmentApp = {
 /** @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,6 +42,7 @@ 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(),

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

@@ -5,7 +5,8 @@ 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 PerAppInstance: "per-app-instance";
+    readonly Environment: "environment";
+    readonly AppInstance: "app_instance";
 };
 export type Consistency = OpenEnum<typeof Consistency>;
 export declare const EnvironmentSnapshotStatus: {
@@ -16,7 +17,7 @@ export declare const EnvironmentSnapshotStatus: {
 export type EnvironmentSnapshotStatus = OpenEnum<typeof EnvironmentSnapshotStatus>;
 export type EnvironmentSnapshot = {
     appInstanceSnapshots: Array<AppInstanceSnapshot>;
-    consistency: Consistency;
+    consistency: Consistency | null;
     createdAt: Date;
     createdBy: Actor | null;
     deletedAt: Date | null;

package/esm/models/environment-snapshot.js

@@ -8,7 +8,8 @@ import * as types from "../types/primitives.js";
 import { Actor$inboundSchema } from "./actor.js";
 import { AppInstanceSnapshot$inboundSchema, } from "./app-instance-snapshot.js";
 export const Consistency = {
-    PerAppInstance: "per-app-instance",
+    Environment: "environment",
+    AppInstance: "app_instance",
 };
 export const EnvironmentSnapshotStatus = {
     Capturing: "capturing",
@@ -22,7 +23,7 @@ export const EnvironmentSnapshotStatus$inboundSchema = openEnums.inboundSchema(E
 /** @internal */
 export const EnvironmentSnapshot$inboundSchema = z.object({
     appInstanceSnapshots: z.array(AppInstanceSnapshot$inboundSchema),
-    consistency: Consistency$inboundSchema,
+    consistency: types.nullable(Consistency$inboundSchema),
     createdAt: types.date(),
     createdBy: types.nullable(Actor$inboundSchema),
     deletedAt: types.nullable(types.date()),

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,11 +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,11 +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,12 +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,12 +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",

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

@@ -0,0 +1,28 @@
+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 type BlobT = {
+    bytes: number;
+    sha256: string;
+};
+export declare const Coverage: {
+    readonly Complete: "complete";
+    readonly Redacted: "redacted";
+    readonly Truncated: "truncated";
+    readonly Omitted: "omitted";
+};
+export type Coverage = OpenEnum<typeof Coverage>;
+export type HistoryBody = {
+    blob: BlobT | null;
+    coverage: Coverage;
+    inline: string | null;
+};
+/** @internal */
+export declare const BlobT$inboundSchema: z.ZodMiniType<BlobT, unknown>;
+export declare function blobFromJSON(jsonString: string): SafeParseResult<BlobT, SDKValidationError>;
+/** @internal */
+export declare const Coverage$inboundSchema: z.ZodMiniType<Coverage, unknown>;
+/** @internal */
+export declare const HistoryBody$inboundSchema: z.ZodMiniType<HistoryBody, unknown>;
+export declare function historyBodyFromJSON(jsonString: string): SafeParseResult<HistoryBody, SDKValidationError>;