@usestatemachines/sdk 0.4.0 → 0.6.0

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

@@ -3,17 +3,19 @@
  */
 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";
 export const Archived = {
-    Exclude: "exclude",
-    Include: "include",
-    Only: "only",
+    True: "true",
+    False: "false",
 };
 /** @internal */
 export const Archived$outboundSchema = z.enum(Archived);
 /** @internal */
 export const ListWorkspacesRequest$outboundSchema = z.object({
-    archived: z._default(Archived$outboundSchema, "exclude"),
+    limit: z._default(z.int(), 50),
+    cursor: z.optional(z.string()),
+    archived: z._default(Archived$outboundSchema, "false"),
 });
 export function listWorkspacesRequestToJSON(listWorkspacesRequest) {
     return JSON.stringify(ListWorkspacesRequest$outboundSchema.parse(listWorkspacesRequest));
@@ -21,6 +23,7 @@ export function listWorkspacesRequestToJSON(listWorkspacesRequest) {
 /** @internal */
 export const ListWorkspacesResponse$inboundSchema = z.object({
     data: z.array(models.Workspace$inboundSchema),
+    nextCursor: types.nullable(types.string()),
 });
 export function listWorkspacesResponseFromJSON(jsonString) {
     return safeParse(jsonString, (x) => ListWorkspacesResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ListWorkspacesResponse' from JSON`);

package/esm/models/operations/pause-environment.d.ts

@@ -0,0 +1,13 @@
+import * as z from "zod/v4-mini";
+export type PauseEnvironmentRequest = {
+    environmentId: string;
+    idempotencyKey?: string | undefined;
+};
+/** @internal */
+export type PauseEnvironmentRequest$Outbound = {
+    environmentId: string;
+    "idempotency-key"?: string | undefined;
+};
+/** @internal */
+export declare const PauseEnvironmentRequest$outboundSchema: z.ZodMiniType<PauseEnvironmentRequest$Outbound, PauseEnvironmentRequest>;
+export declare function pauseEnvironmentRequestToJSON(pauseEnvironmentRequest: PauseEnvironmentRequest): string;

package/esm/models/operations/pause-environment.js

@@ -0,0 +1,17 @@
+/*
+ * 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";
+/** @internal */
+export const PauseEnvironmentRequest$outboundSchema = z.pipe(z.object({
+    environmentId: z.string(),
+    idempotencyKey: z.optional(z.string()),
+}), z.transform((v) => {
+    return remap$(v, {
+        idempotencyKey: "idempotency-key",
+    });
+}));
+export function pauseEnvironmentRequestToJSON(pauseEnvironmentRequest) {
+    return JSON.stringify(PauseEnvironmentRequest$outboundSchema.parse(pauseEnvironmentRequest));
+}

package/esm/models/operations/resume-environment.d.ts

@@ -1,23 +1,13 @@
 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 ResumeEnvironmentRequest = {
     environmentId: string;
-};
-/**
- * Environment queued to run again on the data it was suspended with
- */
-export type ResumeEnvironmentResponse = {
-    data: models.Environment;
+    idempotencyKey?: string | undefined;
 };
 /** @internal */
 export type ResumeEnvironmentRequest$Outbound = {
     environmentId: string;
+    "idempotency-key"?: string | undefined;
 };
 /** @internal */
 export declare const ResumeEnvironmentRequest$outboundSchema: z.ZodMiniType<ResumeEnvironmentRequest$Outbound, ResumeEnvironmentRequest>;
 export declare function resumeEnvironmentRequestToJSON(resumeEnvironmentRequest: ResumeEnvironmentRequest): string;
-/** @internal */
-export declare const ResumeEnvironmentResponse$inboundSchema: z.ZodMiniType<ResumeEnvironmentResponse, unknown>;
-export declare function resumeEnvironmentResponseFromJSON(jsonString: string): SafeParseResult<ResumeEnvironmentResponse, SDKValidationError>;

package/esm/models/operations/resume-environment.js

@@ -2,19 +2,16 @@
  * 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";
+import { remap as remap$ } from "../../lib/primitives.js";
 /** @internal */
-export const ResumeEnvironmentRequest$outboundSchema = z.object({
+export const ResumeEnvironmentRequest$outboundSchema = z.pipe(z.object({
     environmentId: z.string(),
-});
+    idempotencyKey: z.optional(z.string()),
+}), z.transform((v) => {
+    return remap$(v, {
+        idempotencyKey: "idempotency-key",
+    });
+}));
 export function resumeEnvironmentRequestToJSON(resumeEnvironmentRequest) {
     return JSON.stringify(ResumeEnvironmentRequest$outboundSchema.parse(resumeEnvironmentRequest));
 }
-/** @internal */
-export const ResumeEnvironmentResponse$inboundSchema = z.object({
-    data: models.Environment$inboundSchema,
-});
-export function resumeEnvironmentResponseFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => ResumeEnvironmentResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ResumeEnvironmentResponse' from JSON`);
-}

package/esm/models/operations/update-environment.d.ts

@@ -0,0 +1,29 @@
+import * as z from "zod/v4-mini";
+export type UpdateEnvironmentRequestBody = {
+    labels?: {
+        [k: string]: string;
+    } | undefined;
+    name?: string | null | undefined;
+};
+export type UpdateEnvironmentRequest = {
+    environmentId: string;
+    body: UpdateEnvironmentRequestBody;
+};
+/** @internal */
+export type UpdateEnvironmentRequestBody$Outbound = {
+    labels?: {
+        [k: string]: string;
+    } | undefined;
+    name?: string | null | undefined;
+};
+/** @internal */
+export declare const UpdateEnvironmentRequestBody$outboundSchema: z.ZodMiniType<UpdateEnvironmentRequestBody$Outbound, UpdateEnvironmentRequestBody>;
+export declare function updateEnvironmentRequestBodyToJSON(updateEnvironmentRequestBody: UpdateEnvironmentRequestBody): string;
+/** @internal */
+export type UpdateEnvironmentRequest$Outbound = {
+    environmentId: string;
+    body: UpdateEnvironmentRequestBody$Outbound;
+};
+/** @internal */
+export declare const UpdateEnvironmentRequest$outboundSchema: z.ZodMiniType<UpdateEnvironmentRequest$Outbound, UpdateEnvironmentRequest>;
+export declare function updateEnvironmentRequestToJSON(updateEnvironmentRequest: UpdateEnvironmentRequest): string;

package/esm/models/operations/update-environment.js

@@ -0,0 +1,20 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4-mini";
+/** @internal */
+export const UpdateEnvironmentRequestBody$outboundSchema = z.object({
+    labels: z.optional(z.record(z.string(), z.string())),
+    name: z.optional(z.nullable(z.string())),
+});
+export function updateEnvironmentRequestBodyToJSON(updateEnvironmentRequestBody) {
+    return JSON.stringify(UpdateEnvironmentRequestBody$outboundSchema.parse(updateEnvironmentRequestBody));
+}
+/** @internal */
+export const UpdateEnvironmentRequest$outboundSchema = z.object({
+    environmentId: z.string(),
+    body: z.lazy(() => UpdateEnvironmentRequestBody$outboundSchema),
+});
+export function updateEnvironmentRequestToJSON(updateEnvironmentRequest) {
+    return JSON.stringify(UpdateEnvironmentRequest$outboundSchema.parse(updateEnvironmentRequest));
+}

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

@@ -1,24 +1,13 @@
 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 UpdateSnapshotRequestBody = {
-    expectedVersion: number;
     name: string | null;
 };
 export type UpdateSnapshotRequest = {
     snapshotId: string;
     body: UpdateSnapshotRequestBody;
 };
-/**
- * Environment snapshot renamed
- */
-export type UpdateSnapshotResponse = {
-    data: models.EnvironmentSnapshot;
-};
 /** @internal */
 export type UpdateSnapshotRequestBody$Outbound = {
-    expectedVersion: number;
     name: string | null;
 };
 /** @internal */
@@ -32,6 +21,3 @@ export type UpdateSnapshotRequest$Outbound = {
 /** @internal */
 export declare const UpdateSnapshotRequest$outboundSchema: z.ZodMiniType<UpdateSnapshotRequest$Outbound, UpdateSnapshotRequest>;
 export declare function updateSnapshotRequestToJSON(updateSnapshotRequest: UpdateSnapshotRequest): string;
-/** @internal */
-export declare const UpdateSnapshotResponse$inboundSchema: z.ZodMiniType<UpdateSnapshotResponse, unknown>;
-export declare function updateSnapshotResponseFromJSON(jsonString: string): SafeParseResult<UpdateSnapshotResponse, SDKValidationError>;

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

@@ -2,11 +2,8 @@
  * 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 UpdateSnapshotRequestBody$outboundSchema = z.object({
-    expectedVersion: z.int(),
     name: z.nullable(z.string()),
 });
 export function updateSnapshotRequestBodyToJSON(updateSnapshotRequestBody) {
@@ -20,10 +17,3 @@ export const UpdateSnapshotRequest$outboundSchema = z.object({
 export function updateSnapshotRequestToJSON(updateSnapshotRequest) {
     return JSON.stringify(UpdateSnapshotRequest$outboundSchema.parse(updateSnapshotRequest));
 }
-/** @internal */
-export const UpdateSnapshotResponse$inboundSchema = z.object({
-    data: models.EnvironmentSnapshot$inboundSchema,
-});
-export function updateSnapshotResponseFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => UpdateSnapshotResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'UpdateSnapshotResponse' from JSON`);
-}

package/esm/models/permission.d.ts

@@ -0,0 +1,17 @@
+import * as z from "zod/v4-mini";
+import { OpenEnum } from "../types/enums.js";
+export declare const Permission: {
+    readonly EnvironmentsRead: "environments:read";
+    readonly EnvironmentsWrite: "environments:write";
+    readonly EnvironmentsConnect: "environments:connect";
+    readonly SnapshotsRead: "snapshots:read";
+    readonly SnapshotsWrite: "snapshots:write";
+    readonly WorkspacesWrite: "workspaces:write";
+    readonly ApiKeysRead: "api_keys:read";
+    readonly ApiKeysWrite: "api_keys:write";
+    readonly MembersRead: "members:read";
+    readonly MembersWrite: "members:write";
+};
+export type Permission = OpenEnum<typeof Permission>;
+/** @internal */
+export declare const Permission$inboundSchema: z.ZodMiniType<Permission, unknown>;

package/esm/models/permission.js

@@ -0,0 +1,18 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as openEnums from "../types/enums.js";
+export const Permission = {
+    EnvironmentsRead: "environments:read",
+    EnvironmentsWrite: "environments:write",
+    EnvironmentsConnect: "environments:connect",
+    SnapshotsRead: "snapshots:read",
+    SnapshotsWrite: "snapshots:write",
+    WorkspacesWrite: "workspaces:write",
+    ApiKeysRead: "api_keys:read",
+    ApiKeysWrite: "api_keys:write",
+    MembersRead: "members:read",
+    MembersWrite: "members:write",
+};
+/** @internal */
+export const Permission$inboundSchema = openEnums.inboundSchema(Permission);

package/esm/models/principal.d.ts

@@ -0,0 +1,20 @@
+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 PrincipalType: {
+    readonly Member: "member";
+    readonly ApiKey: "api_key";
+    readonly System: "system";
+};
+export type PrincipalType = OpenEnum<typeof PrincipalType>;
+export type Principal = {
+    id: string | null;
+    name: string | null;
+    type: PrincipalType;
+};
+/** @internal */
+export declare const PrincipalType$inboundSchema: z.ZodMiniType<PrincipalType, unknown>;
+/** @internal */
+export declare const Principal$inboundSchema: z.ZodMiniType<Principal, unknown>;
+export declare function principalFromJSON(jsonString: string): SafeParseResult<Principal, SDKValidationError>;

package/esm/models/principal.js

@@ -0,0 +1,24 @@
+/*
+ * 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 PrincipalType = {
+    Member: "member",
+    ApiKey: "api_key",
+    System: "system",
+};
+/** @internal */
+export const PrincipalType$inboundSchema = openEnums.inboundSchema(PrincipalType);
+/** @internal */
+export const Principal$inboundSchema = z
+    .object({
+    id: types.nullable(types.string()),
+    name: types.nullable(types.string()),
+    type: PrincipalType$inboundSchema,
+});
+export function principalFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Principal$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Principal' from JSON`);
+}

package/esm/models/request-detail.d.ts

@@ -0,0 +1,39 @@
+import * as z from "zod/v4-mini";
+import { OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { BodyPreview } from "./body-preview.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+export declare const RequestDetailRespondedBy: {
+    readonly App: "app";
+    readonly Gateway: "gateway";
+};
+export type RequestDetailRespondedBy = OpenEnum<typeof RequestDetailRespondedBy>;
+export type RequestDetail = {
+    app: string;
+    completedAt: Date;
+    durationMs: number;
+    environmentId: string;
+    errorCode: string | null;
+    id: string;
+    method: string;
+    path: string;
+    query: string;
+    receivedAt: Date;
+    requestBytes: number | null;
+    respondedBy: RequestDetailRespondedBy;
+    responseBytes: number | null;
+    responseStatus: number;
+    requestBody: BodyPreview;
+    requestHeaders: {
+        [k: string]: string;
+    };
+    responseBody: BodyPreview;
+    responseHeaders: {
+        [k: string]: string;
+    };
+};
+/** @internal */
+export declare const RequestDetailRespondedBy$inboundSchema: z.ZodMiniType<RequestDetailRespondedBy, unknown>;
+/** @internal */
+export declare const RequestDetail$inboundSchema: z.ZodMiniType<RequestDetail, unknown>;
+export declare function requestDetailFromJSON(jsonString: string): SafeParseResult<RequestDetail, SDKValidationError>;

package/esm/models/request-detail.js

@@ -0,0 +1,38 @@
+/*
+ * 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 { BodyPreview$inboundSchema } from "./body-preview.js";
+export const RequestDetailRespondedBy = {
+    App: "app",
+    Gateway: "gateway",
+};
+/** @internal */
+export const RequestDetailRespondedBy$inboundSchema = openEnums.inboundSchema(RequestDetailRespondedBy);
+/** @internal */
+export const RequestDetail$inboundSchema = z.object({
+    app: types.string(),
+    completedAt: types.date(),
+    durationMs: types.number(),
+    environmentId: types.string(),
+    errorCode: types.nullable(types.string()),
+    id: types.string(),
+    method: types.string(),
+    path: types.string(),
+    query: types.string(),
+    receivedAt: types.date(),
+    requestBytes: types.nullable(types.number()),
+    respondedBy: RequestDetailRespondedBy$inboundSchema,
+    responseBytes: types.nullable(types.number()),
+    responseStatus: types.number(),
+    requestBody: BodyPreview$inboundSchema,
+    requestHeaders: z.record(z.string(), types.string()),
+    responseBody: BodyPreview$inboundSchema,
+    responseHeaders: z.record(z.string(), types.string()),
+});
+export function requestDetailFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => RequestDetail$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'RequestDetail' from JSON`);
+}

package/esm/models/request-stats.d.ts

@@ -0,0 +1,26 @@
+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 Bucket = {
+    clientError: number;
+    from: Date;
+    serverError: number;
+    success: number;
+};
+export type RequestStats = {
+    buckets: Array<Bucket>;
+    clientErrorCount: number;
+    count: number;
+    from: Date;
+    p50Ms: number | null;
+    p95Ms: number | null;
+    serverErrorCount: number;
+    successCount: number;
+    to: Date;
+};
+/** @internal */
+export declare const Bucket$inboundSchema: z.ZodMiniType<Bucket, unknown>;
+export declare function bucketFromJSON(jsonString: string): SafeParseResult<Bucket, SDKValidationError>;
+/** @internal */
+export declare const RequestStats$inboundSchema: z.ZodMiniType<RequestStats, unknown>;
+export declare function requestStatsFromJSON(jsonString: string): SafeParseResult<RequestStats, SDKValidationError>;

package/esm/models/request-stats.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 Bucket$inboundSchema = z.object({
+    clientError: types.number(),
+    from: types.date(),
+    serverError: types.number(),
+    success: types.number(),
+});
+export function bucketFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Bucket$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Bucket' from JSON`);
+}
+/** @internal */
+export const RequestStats$inboundSchema = z.object({
+    buckets: z.array(z.lazy(() => Bucket$inboundSchema)),
+    clientErrorCount: types.number(),
+    count: types.number(),
+    from: types.date(),
+    p50Ms: types.nullable(types.number()),
+    p95Ms: types.nullable(types.number()),
+    serverErrorCount: types.number(),
+    successCount: types.number(),
+    to: types.date(),
+});
+export function requestStatsFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => RequestStats$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'RequestStats' from JSON`);
+}

package/esm/models/request.d.ts

@@ -0,0 +1,30 @@
+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 RequestRespondedBy: {
+    readonly App: "app";
+    readonly Gateway: "gateway";
+};
+export type RequestRespondedBy = OpenEnum<typeof RequestRespondedBy>;
+export type RequestT = {
+    app: string;
+    completedAt: Date;
+    durationMs: number;
+    environmentId: string;
+    errorCode: string | null;
+    id: string;
+    method: string;
+    path: string;
+    query: string;
+    receivedAt: Date;
+    requestBytes: number | null;
+    respondedBy: RequestRespondedBy;
+    responseBytes: number | null;
+    responseStatus: number;
+};
+/** @internal */
+export declare const RequestRespondedBy$inboundSchema: z.ZodMiniType<RequestRespondedBy, unknown>;
+/** @internal */
+export declare const RequestT$inboundSchema: z.ZodMiniType<RequestT, unknown>;
+export declare function requestFromJSON(jsonString: string): SafeParseResult<RequestT, SDKValidationError>;

package/esm/models/request.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 RequestRespondedBy = {
+    App: "app",
+    Gateway: "gateway",
+};
+/** @internal */
+export const RequestRespondedBy$inboundSchema = openEnums.inboundSchema(RequestRespondedBy);
+/** @internal */
+export const RequestT$inboundSchema = z
+    .object({
+    app: types.string(),
+    completedAt: types.date(),
+    durationMs: types.number(),
+    environmentId: types.string(),
+    errorCode: types.nullable(types.string()),
+    id: types.string(),
+    method: types.string(),
+    path: types.string(),
+    query: types.string(),
+    receivedAt: types.date(),
+    requestBytes: types.nullable(types.number()),
+    respondedBy: RequestRespondedBy$inboundSchema,
+    responseBytes: types.nullable(types.number()),
+    responseStatus: types.number(),
+});
+export function requestFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => RequestT$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'RequestT' from JSON`);
+}

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

@@ -0,0 +1,13 @@
+import * as z from "zod/v4-mini";
+import { OpenEnum } from "../types/enums.js";
+export declare const SnapshotStatus: {
+    readonly Saving: "saving";
+    readonly Ready: "ready";
+    readonly Failed: "failed";
+    readonly Deleted: "deleted";
+};
+export type SnapshotStatus = OpenEnum<typeof SnapshotStatus>;
+/** @internal */
+export declare const SnapshotStatus$inboundSchema: z.ZodMiniType<SnapshotStatus, unknown>;
+/** @internal */
+export declare const SnapshotStatus$outboundSchema: z.ZodMiniType<string, SnapshotStatus>;

package/esm/models/snapshot-status.js

@@ -0,0 +1,14 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as openEnums from "../types/enums.js";
+export const SnapshotStatus = {
+    Saving: "saving",
+    Ready: "ready",
+    Failed: "failed",
+    Deleted: "deleted",
+};
+/** @internal */
+export const SnapshotStatus$inboundSchema = openEnums.inboundSchema(SnapshotStatus);
+/** @internal */
+export const SnapshotStatus$outboundSchema = openEnums.outboundSchema(SnapshotStatus);

package/esm/models/snapshot.d.ts

@@ -0,0 +1,47 @@
+import * as z from "zod/v4-mini";
+import { OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+import { Principal } from "./principal.js";
+import { SnapshotStatus } from "./snapshot-status.js";
+export type SnapshotApp = {
+    appId: string;
+    name: string;
+    sizeBytes: number | null;
+    version: string;
+    versionId: string;
+};
+export declare const SnapshotCode: {
+    readonly Interrupted: "interrupted";
+    readonly InternalError: "internal_error";
+};
+export type SnapshotCode = OpenEnum<typeof SnapshotCode>;
+export type Failure = {
+    code: SnapshotCode;
+    message: string;
+};
+export type Snapshot = {
+    apps: Array<SnapshotApp>;
+    createdAt: Date;
+    createdBy: Principal;
+    deletedAt: Date | null;
+    environmentId: string;
+    failure: Failure | null;
+    id: string;
+    name: string | null;
+    readyAt: Date | null;
+    sizeBytes: number | null;
+    status: SnapshotStatus;
+    workspaceId: string;
+};
+/** @internal */
+export declare const SnapshotApp$inboundSchema: z.ZodMiniType<SnapshotApp, unknown>;
+export declare function snapshotAppFromJSON(jsonString: string): SafeParseResult<SnapshotApp, SDKValidationError>;
+/** @internal */
+export declare const SnapshotCode$inboundSchema: z.ZodMiniType<SnapshotCode, unknown>;
+/** @internal */
+export declare const Failure$inboundSchema: z.ZodMiniType<Failure, unknown>;
+export declare function failureFromJSON(jsonString: string): SafeParseResult<Failure, SDKValidationError>;
+/** @internal */
+export declare const Snapshot$inboundSchema: z.ZodMiniType<Snapshot, unknown>;
+export declare function snapshotFromJSON(jsonString: string): SafeParseResult<Snapshot, SDKValidationError>;

package/esm/models/snapshot.js

@@ -0,0 +1,54 @@
+/*
+ * 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 { Principal$inboundSchema } from "./principal.js";
+import { SnapshotStatus$inboundSchema, } from "./snapshot-status.js";
+export const SnapshotCode = {
+    Interrupted: "interrupted",
+    InternalError: "internal_error",
+};
+/** @internal */
+export const SnapshotApp$inboundSchema = z
+    .object({
+    appId: types.string(),
+    name: types.string(),
+    sizeBytes: types.nullable(types.number()),
+    version: types.string(),
+    versionId: types.string(),
+});
+export function snapshotAppFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => SnapshotApp$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'SnapshotApp' from JSON`);
+}
+/** @internal */
+export const SnapshotCode$inboundSchema = openEnums.inboundSchema(SnapshotCode);
+/** @internal */
+export const Failure$inboundSchema = z.object({
+    code: SnapshotCode$inboundSchema,
+    message: types.string(),
+});
+export function failureFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Failure$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Failure' from JSON`);
+}
+/** @internal */
+export const Snapshot$inboundSchema = z
+    .object({
+    apps: z.array(z.lazy(() => SnapshotApp$inboundSchema)),
+    createdAt: types.date(),
+    createdBy: Principal$inboundSchema,
+    deletedAt: types.nullable(types.date()),
+    environmentId: types.string(),
+    failure: types.nullable(z.lazy(() => Failure$inboundSchema)),
+    id: types.string(),
+    name: types.nullable(types.string()),
+    readyAt: types.nullable(types.date()),
+    sizeBytes: types.nullable(types.number()),
+    status: SnapshotStatus$inboundSchema,
+    workspaceId: types.string(),
+});
+export function snapshotFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Snapshot$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Snapshot' from JSON`);
+}