@usestatemachines/sdk 0.1.1 → 0.3.0

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

@@ -4,15 +4,19 @@ 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 ConnectionNotAuthorized: "connection-not-authorized";
     readonly ConnectionUnavailable: "connection-unavailable";
     readonly EnvironmentLimit: "environment-limit";
     readonly Forbidden: "forbidden";
     readonly IdempotencyConflict: "idempotency-conflict";
     readonly IdentityRequestRejected: "identity-request-rejected";
+    readonly InitializationBusy: "initialization-busy";
+    readonly InitializationUnavailable: "initialization-unavailable";
     readonly InternalError: "internal-error";
     readonly InvalidCursor: "invalid-cursor";
     readonly InvalidRequest: "invalid-request";
     readonly InvalidResponse: "invalid-response";
+    readonly InvalidSetup: "invalid-setup";
     readonly InvalidWebhook: "invalid-webhook";
     readonly LastOwner: "last-owner";
     readonly LastWorkspace: "last-workspace";
@@ -24,6 +28,7 @@ export declare const Code: {
     readonly RequestCapacityReached: "request-capacity-reached";
     readonly RequestTimeout: "request-timeout";
     readonly ServiceUnavailable: "service-unavailable";
+    readonly SnapshotLimit: "snapshot-limit";
     readonly Unauthorized: "unauthorized";
     readonly VersionConflict: "version-conflict";
     readonly WorkspaceArchived: "workspace-archived";

package/esm/models/error-response.js

@@ -7,15 +7,19 @@ import * as openEnums from "../types/enums.js";
 import * as types from "../types/primitives.js";
 export const Code = {
     BodyTooLarge: "body-too-large",
+    ConnectionNotAuthorized: "connection-not-authorized",
     ConnectionUnavailable: "connection-unavailable",
     EnvironmentLimit: "environment-limit",
     Forbidden: "forbidden",
     IdempotencyConflict: "idempotency-conflict",
     IdentityRequestRejected: "identity-request-rejected",
+    InitializationBusy: "initialization-busy",
+    InitializationUnavailable: "initialization-unavailable",
     InternalError: "internal-error",
     InvalidCursor: "invalid-cursor",
     InvalidRequest: "invalid-request",
     InvalidResponse: "invalid-response",
+    InvalidSetup: "invalid-setup",
     InvalidWebhook: "invalid-webhook",
     LastOwner: "last-owner",
     LastWorkspace: "last-workspace",
@@ -27,6 +31,7 @@ export const Code = {
     RequestCapacityReached: "request-capacity-reached",
     RequestTimeout: "request-timeout",
     ServiceUnavailable: "service-unavailable",
+    SnapshotLimit: "snapshot-limit",
     Unauthorized: "unauthorized",
     VersionConflict: "version-conflict",
     WorkspaceArchived: "workspace-archived",

package/esm/models/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./actor.js";
 export * from "./api-profile.js";
+export * from "./app-instance-snapshot.js";
 export * from "./app.js";
 export * from "./catalog.js";
 export * from "./connection-secret.js";
@@ -9,6 +10,7 @@ export * from "./credential-kind.js";
 export * from "./credential.js";
 export * from "./environment-app.js";
 export * from "./environment-lifetime.js";
+export * from "./environment-snapshot.js";
 export * from "./environment.js";
 export * from "./error-response.js";
 export * from "./event-page.js";

package/esm/models/index.js

@@ -3,6 +3,7 @@
  */
 export * from "./actor.js";
 export * from "./api-profile.js";
+export * from "./app-instance-snapshot.js";
 export * from "./app.js";
 export * from "./catalog.js";
 export * from "./connection-secret.js";
@@ -12,6 +13,7 @@ export * from "./credential-kind.js";
 export * from "./credential.js";
 export * from "./environment-app.js";
 export * from "./environment-lifetime.js";
+export * from "./environment-snapshot.js";
 export * from "./environment.js";
 export * from "./error-response.js";
 export * from "./event-page.js";

package/esm/models/operations/capture-snapshot.d.ts

@@ -0,0 +1,41 @@
+import * as z from "zod/v4-mini";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdk-validation-error.js";
+import * as models from "../index.js";
+export type CaptureSnapshotRequestBody = {
+    appInstanceKeys?: Array<string> | undefined;
+    environmentId: string;
+    name?: string | undefined;
+};
+export type CaptureSnapshotRequest = {
+    workspaceId: string;
+    idempotencyKey: string;
+    body: CaptureSnapshotRequestBody;
+};
+/**
+ * Environment snapshot capture accepted
+ */
+export type CaptureSnapshotResponse = {
+    data: models.EnvironmentSnapshot;
+};
+/** @internal */
+export type CaptureSnapshotRequestBody$Outbound = {
+    appInstanceKeys?: Array<string> | undefined;
+    environmentId: string;
+    name?: string | undefined;
+};
+/** @internal */
+export declare const CaptureSnapshotRequestBody$outboundSchema: z.ZodMiniType<CaptureSnapshotRequestBody$Outbound, CaptureSnapshotRequestBody>;
+export declare function captureSnapshotRequestBodyToJSON(captureSnapshotRequestBody: CaptureSnapshotRequestBody): string;
+/** @internal */
+export type CaptureSnapshotRequest$Outbound = {
+    workspaceId: string;
+    "idempotency-key": string;
+    body: CaptureSnapshotRequestBody$Outbound;
+};
+/** @internal */
+export declare const CaptureSnapshotRequest$outboundSchema: z.ZodMiniType<CaptureSnapshotRequest$Outbound, CaptureSnapshotRequest>;
+export declare function captureSnapshotRequestToJSON(captureSnapshotRequest: CaptureSnapshotRequest): string;
+/** @internal */
+export declare const CaptureSnapshotResponse$inboundSchema: z.ZodMiniType<CaptureSnapshotResponse, unknown>;
+export declare function captureSnapshotResponseFromJSON(jsonString: string): SafeParseResult<CaptureSnapshotResponse, SDKValidationError>;

package/esm/models/operations/capture-snapshot.js

@@ -0,0 +1,36 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import * as models from "../index.js";
+/** @internal */
+export const CaptureSnapshotRequestBody$outboundSchema = z.object({
+    appInstanceKeys: z.optional(z.array(z.string())),
+    environmentId: z.string(),
+    name: z.optional(z.string()),
+});
+export function captureSnapshotRequestBodyToJSON(captureSnapshotRequestBody) {
+    return JSON.stringify(CaptureSnapshotRequestBody$outboundSchema.parse(captureSnapshotRequestBody));
+}
+/** @internal */
+export const CaptureSnapshotRequest$outboundSchema = z.pipe(z.object({
+    workspaceId: z.string(),
+    idempotencyKey: z.string(),
+    body: z.lazy(() => CaptureSnapshotRequestBody$outboundSchema),
+}), z.transform((v) => {
+    return remap$(v, {
+        idempotencyKey: "idempotency-key",
+    });
+}));
+export function captureSnapshotRequestToJSON(captureSnapshotRequest) {
+    return JSON.stringify(CaptureSnapshotRequest$outboundSchema.parse(captureSnapshotRequest));
+}
+/** @internal */
+export const CaptureSnapshotResponse$inboundSchema = z.object({
+    data: models.EnvironmentSnapshot$inboundSchema,
+});
+export function captureSnapshotResponseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CaptureSnapshotResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CaptureSnapshotResponse' from JSON`);
+}

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

@@ -0,0 +1,143 @@
+import * as z from "zod/v4-mini";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdk-validation-error.js";
+import * as models from "../index.js";
+export type From = {
+    snapshot: string;
+};
+export type CreateEnvironmentDefinitionRequestBody2 = {
+    from: From;
+    version?: number | undefined;
+};
+export type Apps = {
+    app: string;
+    /**
+     * Native values validated by the selected replica release.
+     */
+    configure?: {
+        [k: string]: any;
+    } | undefined;
+    /**
+     * Native values validated by the selected replica release.
+     */
+    connections?: {
+        [k: string]: any;
+    } | undefined;
+    defaultConnection?: string | undefined;
+    preset?: string | undefined;
+    release?: string | undefined;
+    /**
+     * Native values validated by the selected replica release.
+     */
+    resources?: {
+        [k: string]: any;
+    } | undefined;
+    /**
+     * Native values validated by the selected replica release.
+     */
+    settings?: {
+        [k: string]: any;
+    } | undefined;
+};
+export type AppsUnion = Array<string> | {
+    [k: string]: Apps;
+};
+export type CreateEnvironmentDefinitionRequestBody1 = {
+    apps: Array<string> | {
+        [k: string]: Apps;
+    };
+    labels?: {
+        [k: string]: string;
+    } | undefined;
+    lifetimeMinutes?: number | undefined;
+    name?: string | undefined;
+    version?: number | undefined;
+};
+export type CreateEnvironmentDefinitionRequestBody = CreateEnvironmentDefinitionRequestBody1 | CreateEnvironmentDefinitionRequestBody2;
+export type CreateEnvironmentDefinitionRequest = {
+    workspaceId: string;
+    idempotencyKey: string;
+    body: CreateEnvironmentDefinitionRequestBody1 | CreateEnvironmentDefinitionRequestBody2;
+};
+/**
+ * Environment accepted from its setup definition
+ */
+export type CreateEnvironmentDefinitionResponse = {
+    data: models.Environment;
+};
+/** @internal */
+export type From$Outbound = {
+    snapshot: string;
+};
+/** @internal */
+export declare const From$outboundSchema: z.ZodMiniType<From$Outbound, From>;
+export declare function fromToJSON(from: From): string;
+/** @internal */
+export type CreateEnvironmentDefinitionRequestBody2$Outbound = {
+    from: From$Outbound;
+    version: number;
+};
+/** @internal */
+export declare const CreateEnvironmentDefinitionRequestBody2$outboundSchema: z.ZodMiniType<CreateEnvironmentDefinitionRequestBody2$Outbound, CreateEnvironmentDefinitionRequestBody2>;
+export declare function createEnvironmentDefinitionRequestBody2ToJSON(createEnvironmentDefinitionRequestBody2: CreateEnvironmentDefinitionRequestBody2): string;
+/** @internal */
+export type Apps$Outbound = {
+    app: string;
+    configure?: {
+        [k: string]: any;
+    } | undefined;
+    connections?: {
+        [k: string]: any;
+    } | undefined;
+    defaultConnection?: string | undefined;
+    preset?: string | undefined;
+    release?: string | undefined;
+    resources?: {
+        [k: string]: any;
+    } | undefined;
+    settings?: {
+        [k: string]: any;
+    } | undefined;
+};
+/** @internal */
+export declare const Apps$outboundSchema: z.ZodMiniType<Apps$Outbound, Apps>;
+export declare function appsToJSON(apps: Apps): string;
+/** @internal */
+export type AppsUnion$Outbound = Array<string> | {
+    [k: string]: Apps$Outbound;
+};
+/** @internal */
+export declare const AppsUnion$outboundSchema: z.ZodMiniType<AppsUnion$Outbound, AppsUnion>;
+export declare function appsUnionToJSON(appsUnion: AppsUnion): string;
+/** @internal */
+export type CreateEnvironmentDefinitionRequestBody1$Outbound = {
+    apps: Array<string> | {
+        [k: string]: Apps$Outbound;
+    };
+    labels?: {
+        [k: string]: string;
+    } | undefined;
+    lifetimeMinutes?: number | undefined;
+    name?: string | undefined;
+    version: number;
+};
+/** @internal */
+export declare const CreateEnvironmentDefinitionRequestBody1$outboundSchema: z.ZodMiniType<CreateEnvironmentDefinitionRequestBody1$Outbound, CreateEnvironmentDefinitionRequestBody1>;
+export declare function createEnvironmentDefinitionRequestBody1ToJSON(createEnvironmentDefinitionRequestBody1: CreateEnvironmentDefinitionRequestBody1): string;
+/** @internal */
+export type CreateEnvironmentDefinitionRequestBody$Outbound = CreateEnvironmentDefinitionRequestBody1$Outbound | CreateEnvironmentDefinitionRequestBody2$Outbound;
+/** @internal */
+export declare const CreateEnvironmentDefinitionRequestBody$outboundSchema: z.ZodMiniType<CreateEnvironmentDefinitionRequestBody$Outbound, CreateEnvironmentDefinitionRequestBody>;
+export declare function createEnvironmentDefinitionRequestBodyToJSON(createEnvironmentDefinitionRequestBody: CreateEnvironmentDefinitionRequestBody): string;
+/** @internal */
+export type CreateEnvironmentDefinitionRequest$Outbound = {
+    workspaceId: string;
+    "idempotency-key": string;
+    body: CreateEnvironmentDefinitionRequestBody1$Outbound | CreateEnvironmentDefinitionRequestBody2$Outbound;
+};
+/** @internal */
+export declare const CreateEnvironmentDefinitionRequest$outboundSchema: z.ZodMiniType<CreateEnvironmentDefinitionRequest$Outbound, CreateEnvironmentDefinitionRequest>;
+export declare function createEnvironmentDefinitionRequestToJSON(createEnvironmentDefinitionRequest: CreateEnvironmentDefinitionRequest): string;
+/** @internal */
+export declare const CreateEnvironmentDefinitionResponse$inboundSchema: z.ZodMiniType<CreateEnvironmentDefinitionResponse, unknown>;
+export declare function createEnvironmentDefinitionResponseFromJSON(jsonString: string): SafeParseResult<CreateEnvironmentDefinitionResponse, SDKValidationError>;

package/esm/models/operations/create-environment-definition.js

@@ -0,0 +1,90 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { smartUnion } from "../../types/smart-union.js";
+import * as models from "../index.js";
+/** @internal */
+export const From$outboundSchema = z.object({
+    snapshot: z.string(),
+});
+export function fromToJSON(from) {
+    return JSON.stringify(From$outboundSchema.parse(from));
+}
+/** @internal */
+export const CreateEnvironmentDefinitionRequestBody2$outboundSchema = z.object({
+    from: z.lazy(() => From$outboundSchema),
+    version: z._default(z.number(), 1),
+});
+export function createEnvironmentDefinitionRequestBody2ToJSON(createEnvironmentDefinitionRequestBody2) {
+    return JSON.stringify(CreateEnvironmentDefinitionRequestBody2$outboundSchema.parse(createEnvironmentDefinitionRequestBody2));
+}
+/** @internal */
+export const Apps$outboundSchema = z.object({
+    app: z.string(),
+    configure: z.optional(z.record(z.string(), z.any())),
+    connections: z.optional(z.record(z.string(), z.any())),
+    defaultConnection: z.optional(z.string()),
+    preset: z.optional(z.string()),
+    release: z.optional(z.string()),
+    resources: z.optional(z.record(z.string(), z.any())),
+    settings: z.optional(z.record(z.string(), z.any())),
+});
+export function appsToJSON(apps) {
+    return JSON.stringify(Apps$outboundSchema.parse(apps));
+}
+/** @internal */
+export const AppsUnion$outboundSchema = smartUnion([
+    z.array(z.string()),
+    z.record(z.string(), z.lazy(() => Apps$outboundSchema)),
+]);
+export function appsUnionToJSON(appsUnion) {
+    return JSON.stringify(AppsUnion$outboundSchema.parse(appsUnion));
+}
+/** @internal */
+export const CreateEnvironmentDefinitionRequestBody1$outboundSchema = z.object({
+    apps: smartUnion([
+        z.array(z.string()),
+        z.record(z.string(), z.lazy(() => Apps$outboundSchema)),
+    ]),
+    labels: z.optional(z.record(z.string(), z.string())),
+    lifetimeMinutes: z.optional(z.int()),
+    name: z.optional(z.string()),
+    version: z._default(z.number(), 1),
+});
+export function createEnvironmentDefinitionRequestBody1ToJSON(createEnvironmentDefinitionRequestBody1) {
+    return JSON.stringify(CreateEnvironmentDefinitionRequestBody1$outboundSchema.parse(createEnvironmentDefinitionRequestBody1));
+}
+/** @internal */
+export const CreateEnvironmentDefinitionRequestBody$outboundSchema = smartUnion([
+    z.lazy(() => CreateEnvironmentDefinitionRequestBody1$outboundSchema),
+    z.lazy(() => CreateEnvironmentDefinitionRequestBody2$outboundSchema),
+]);
+export function createEnvironmentDefinitionRequestBodyToJSON(createEnvironmentDefinitionRequestBody) {
+    return JSON.stringify(CreateEnvironmentDefinitionRequestBody$outboundSchema.parse(createEnvironmentDefinitionRequestBody));
+}
+/** @internal */
+export const CreateEnvironmentDefinitionRequest$outboundSchema = z.pipe(z.object({
+    workspaceId: z.string(),
+    idempotencyKey: z.string(),
+    body: smartUnion([
+        z.lazy(() => CreateEnvironmentDefinitionRequestBody1$outboundSchema),
+        z.lazy(() => CreateEnvironmentDefinitionRequestBody2$outboundSchema),
+    ]),
+}), z.transform((v) => {
+    return remap$(v, {
+        idempotencyKey: "idempotency-key",
+    });
+}));
+export function createEnvironmentDefinitionRequestToJSON(createEnvironmentDefinitionRequest) {
+    return JSON.stringify(CreateEnvironmentDefinitionRequest$outboundSchema.parse(createEnvironmentDefinitionRequest));
+}
+/** @internal */
+export const CreateEnvironmentDefinitionResponse$inboundSchema = z.object({
+    data: models.Environment$inboundSchema,
+});
+export function createEnvironmentDefinitionResponseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CreateEnvironmentDefinitionResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CreateEnvironmentDefinitionResponse' from JSON`);
+}

package/esm/models/operations/delete-snapshot.d.ts

@@ -0,0 +1,23 @@
+import * as z from "zod/v4-mini";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdk-validation-error.js";
+import * as models from "../index.js";
+export type DeleteSnapshotRequest = {
+    snapshotId: string;
+};
+/**
+ * Environment snapshot removed from the library
+ */
+export type DeleteSnapshotResponse = {
+    data: models.EnvironmentSnapshot;
+};
+/** @internal */
+export type DeleteSnapshotRequest$Outbound = {
+    snapshotId: string;
+};
+/** @internal */
+export declare const DeleteSnapshotRequest$outboundSchema: z.ZodMiniType<DeleteSnapshotRequest$Outbound, DeleteSnapshotRequest>;
+export declare function deleteSnapshotRequestToJSON(deleteSnapshotRequest: DeleteSnapshotRequest): string;
+/** @internal */
+export declare const DeleteSnapshotResponse$inboundSchema: z.ZodMiniType<DeleteSnapshotResponse, unknown>;
+export declare function deleteSnapshotResponseFromJSON(jsonString: string): SafeParseResult<DeleteSnapshotResponse, SDKValidationError>;

package/esm/models/operations/delete-snapshot.js

@@ -0,0 +1,20 @@
+/*
+ * 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 models from "../index.js";
+/** @internal */
+export const DeleteSnapshotRequest$outboundSchema = z.object({
+    snapshotId: z.string(),
+});
+export function deleteSnapshotRequestToJSON(deleteSnapshotRequest) {
+    return JSON.stringify(DeleteSnapshotRequest$outboundSchema.parse(deleteSnapshotRequest));
+}
+/** @internal */
+export const DeleteSnapshotResponse$inboundSchema = z.object({
+    data: models.EnvironmentSnapshot$inboundSchema,
+});
+export function deleteSnapshotResponseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => DeleteSnapshotResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'DeleteSnapshotResponse' from JSON`);
+}

package/esm/models/operations/get-snapshot.d.ts

@@ -0,0 +1,23 @@
+import * as z from "zod/v4-mini";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdk-validation-error.js";
+import * as models from "../index.js";
+export type GetSnapshotRequest = {
+    snapshotId: string;
+};
+/**
+ * Environment snapshot and its app instance snapshots
+ */
+export type GetSnapshotResponse = {
+    data: models.EnvironmentSnapshot;
+};
+/** @internal */
+export type GetSnapshotRequest$Outbound = {
+    snapshotId: string;
+};
+/** @internal */
+export declare const GetSnapshotRequest$outboundSchema: z.ZodMiniType<GetSnapshotRequest$Outbound, GetSnapshotRequest>;
+export declare function getSnapshotRequestToJSON(getSnapshotRequest: GetSnapshotRequest): string;
+/** @internal */
+export declare const GetSnapshotResponse$inboundSchema: z.ZodMiniType<GetSnapshotResponse, unknown>;
+export declare function getSnapshotResponseFromJSON(jsonString: string): SafeParseResult<GetSnapshotResponse, SDKValidationError>;

package/esm/models/operations/get-snapshot.js

@@ -0,0 +1,20 @@
+/*
+ * 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 models from "../index.js";
+/** @internal */
+export const GetSnapshotRequest$outboundSchema = z.object({
+    snapshotId: z.string(),
+});
+export function getSnapshotRequestToJSON(getSnapshotRequest) {
+    return JSON.stringify(GetSnapshotRequest$outboundSchema.parse(getSnapshotRequest));
+}
+/** @internal */
+export const GetSnapshotResponse$inboundSchema = z.object({
+    data: models.EnvironmentSnapshot$inboundSchema,
+});
+export function getSnapshotResponseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => GetSnapshotResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'GetSnapshotResponse' from JSON`);
+}

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

@@ -1,13 +1,19 @@
+export * from "./capture-snapshot.js";
+export * from "./create-environment-definition.js";
 export * from "./create-environments.js";
+export * from "./delete-snapshot.js";
 export * from "./get-catalog.js";
 export * from "./get-connection.js";
 export * from "./get-credential.js";
 export * from "./get-environment.js";
 export * from "./get-release.js";
+export * from "./get-snapshot.js";
 export * from "./get-workspace.js";
 export * from "./list-environment-events.js";
 export * from "./list-environments.js";
+export * from "./list-snapshots.js";
 export * from "./list-workspace-events.js";
 export * from "./list-workspaces.js";
 export * from "./reveal-connection.js";
 export * from "./stop-environment.js";
+export * from "./update-snapshot.js";

package/esm/models/operations/index.js

@@ -1,16 +1,22 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
+export * from "./capture-snapshot.js";
+export * from "./create-environment-definition.js";
 export * from "./create-environments.js";
+export * from "./delete-snapshot.js";
 export * from "./get-catalog.js";
 export * from "./get-connection.js";
 export * from "./get-credential.js";
 export * from "./get-environment.js";
 export * from "./get-release.js";
+export * from "./get-snapshot.js";
 export * from "./get-workspace.js";
 export * from "./list-environment-events.js";
 export * from "./list-environments.js";
+export * from "./list-snapshots.js";
 export * from "./list-workspace-events.js";
 export * from "./list-workspaces.js";
 export * from "./reveal-connection.js";
 export * from "./stop-environment.js";
+export * from "./update-snapshot.js";

package/esm/models/operations/list-environments.d.ts

@@ -15,6 +15,7 @@ export type ListEnvironmentsRequest = {
     limit?: number | undefined;
     cursor?: string | undefined;
     status?: Status | undefined;
+    snapshotId?: string | undefined;
     search?: string | undefined;
     label?: string | Array<string> | undefined;
 };
@@ -38,6 +39,7 @@ export type ListEnvironmentsRequest$Outbound = {
     limit: number;
     cursor?: string | undefined;
     status: string;
+    snapshotId?: string | undefined;
     search?: string | undefined;
     label?: string | Array<string> | undefined;
 };

package/esm/models/operations/list-environments.js

@@ -24,6 +24,7 @@ export const ListEnvironmentsRequest$outboundSchema = z.object({
     limit: z._default(z.int(), 50),
     cursor: z.optional(z.string()),
     status: z._default(Status$outboundSchema, "all"),
+    snapshotId: z.optional(z.string()),
     search: z.optional(z.string()),
     label: z.optional(smartUnion([z.string(), z.array(z.string())])),
 });

package/esm/models/operations/list-snapshots.d.ts

@@ -0,0 +1,30 @@
+import * as z from "zod/v4-mini";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdk-validation-error.js";
+import * as models from "../index.js";
+export type ListSnapshotsRequest = {
+    workspaceId: string;
+    limit?: number | undefined;
+    cursor?: string | undefined;
+    sourceEnvironmentId?: string | undefined;
+};
+/**
+ * Workspace environment snapshots, newest first
+ */
+export type ListSnapshotsResponse = {
+    data: Array<models.EnvironmentSnapshot>;
+    nextCursor: string | null;
+};
+/** @internal */
+export type ListSnapshotsRequest$Outbound = {
+    workspaceId: string;
+    limit: number;
+    cursor?: string | undefined;
+    sourceEnvironmentId?: string | undefined;
+};
+/** @internal */
+export declare const ListSnapshotsRequest$outboundSchema: z.ZodMiniType<ListSnapshotsRequest$Outbound, ListSnapshotsRequest>;
+export declare function listSnapshotsRequestToJSON(listSnapshotsRequest: ListSnapshotsRequest): string;
+/** @internal */
+export declare const ListSnapshotsResponse$inboundSchema: z.ZodMiniType<ListSnapshotsResponse, unknown>;
+export declare function listSnapshotsResponseFromJSON(jsonString: string): SafeParseResult<ListSnapshotsResponse, SDKValidationError>;

package/esm/models/operations/list-snapshots.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 types from "../../types/primitives.js";
+import * as models from "../index.js";
+/** @internal */
+export const ListSnapshotsRequest$outboundSchema = z.object({
+    workspaceId: z.string(),
+    limit: z._default(z.int(), 50),
+    cursor: z.optional(z.string()),
+    sourceEnvironmentId: z.optional(z.string()),
+});
+export function listSnapshotsRequestToJSON(listSnapshotsRequest) {
+    return JSON.stringify(ListSnapshotsRequest$outboundSchema.parse(listSnapshotsRequest));
+}
+/** @internal */
+export const ListSnapshotsResponse$inboundSchema = z.object({
+    data: z.array(models.EnvironmentSnapshot$inboundSchema),
+    nextCursor: types.nullable(types.string()),
+});
+export function listSnapshotsResponseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ListSnapshotsResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ListSnapshotsResponse' from JSON`);
+}