@usestatemachines/sdk 0.2.0 → 0.4.0

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>;

package/esm/models/history-body.js

@@ -0,0 +1,33 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4-mini";
+import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+import * as types from "../types/primitives.js";
+export const Coverage = {
+    Complete: "complete",
+    Redacted: "redacted",
+    Truncated: "truncated",
+    Omitted: "omitted",
+};
+/** @internal */
+export const BlobT$inboundSchema = z.object({
+    bytes: types.number(),
+    sha256: types.string(),
+});
+export function blobFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => BlobT$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'BlobT' from JSON`);
+}
+/** @internal */
+export const Coverage$inboundSchema = openEnums.inboundSchema(Coverage);
+/** @internal */
+export const HistoryBody$inboundSchema = z
+    .object({
+    blob: types.nullable(z.lazy(() => BlobT$inboundSchema)),
+    coverage: Coverage$inboundSchema,
+    inline: types.nullable(types.string()),
+});
+export function historyBodyFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HistoryBody$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HistoryBody' from JSON`);
+}

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

@@ -0,0 +1,48 @@
+import * as z from "zod/v4-mini";
+import * as discriminatedUnionTypes from "../types/discriminated-union.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+export type HistoryCauseBootstrap = {
+    kind: "bootstrap";
+};
+export type HistoryCauseRestore = {
+    fromGeneration: number;
+    kind: "restore";
+    lsn: string;
+};
+export type HistoryCauseTimer = {
+    depth: number;
+    kind: "timer";
+    rootExchangeId: string | null;
+    timerId: string;
+};
+export type HistoryCauseReactor = {
+    depth: number;
+    eventId: string;
+    kind: "reactor";
+    reactor: string;
+    rootExchangeId: string | null;
+};
+export type HistoryCauseExchange = {
+    exchangeId: string;
+    kind: "exchange";
+};
+export type HistoryCause = HistoryCauseExchange | HistoryCauseReactor | HistoryCauseTimer | HistoryCauseRestore | HistoryCauseBootstrap | discriminatedUnionTypes.Unknown<"kind">;
+/** @internal */
+export declare const HistoryCauseBootstrap$inboundSchema: z.ZodMiniType<HistoryCauseBootstrap, unknown>;
+export declare function historyCauseBootstrapFromJSON(jsonString: string): SafeParseResult<HistoryCauseBootstrap, SDKValidationError>;
+/** @internal */
+export declare const HistoryCauseRestore$inboundSchema: z.ZodMiniType<HistoryCauseRestore, unknown>;
+export declare function historyCauseRestoreFromJSON(jsonString: string): SafeParseResult<HistoryCauseRestore, SDKValidationError>;
+/** @internal */
+export declare const HistoryCauseTimer$inboundSchema: z.ZodMiniType<HistoryCauseTimer, unknown>;
+export declare function historyCauseTimerFromJSON(jsonString: string): SafeParseResult<HistoryCauseTimer, SDKValidationError>;
+/** @internal */
+export declare const HistoryCauseReactor$inboundSchema: z.ZodMiniType<HistoryCauseReactor, unknown>;
+export declare function historyCauseReactorFromJSON(jsonString: string): SafeParseResult<HistoryCauseReactor, SDKValidationError>;
+/** @internal */
+export declare const HistoryCauseExchange$inboundSchema: z.ZodMiniType<HistoryCauseExchange, unknown>;
+export declare function historyCauseExchangeFromJSON(jsonString: string): SafeParseResult<HistoryCauseExchange, SDKValidationError>;
+/** @internal */
+export declare const HistoryCause$inboundSchema: z.ZodMiniType<HistoryCause, unknown>;
+export declare function historyCauseFromJSON(jsonString: string): SafeParseResult<HistoryCause, SDKValidationError>;

package/esm/models/history-cause.js

@@ -0,0 +1,63 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4-mini";
+import { safeParse } from "../lib/schemas.js";
+import { discriminatedUnion } from "../types/discriminated-union.js";
+import * as types from "../types/primitives.js";
+/** @internal */
+export const HistoryCauseBootstrap$inboundSchema = z.object({
+    kind: types.literal("bootstrap"),
+});
+export function historyCauseBootstrapFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HistoryCauseBootstrap$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HistoryCauseBootstrap' from JSON`);
+}
+/** @internal */
+export const HistoryCauseRestore$inboundSchema = z.object({
+    fromGeneration: types.number(),
+    kind: types.literal("restore"),
+    lsn: types.string(),
+});
+export function historyCauseRestoreFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HistoryCauseRestore$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HistoryCauseRestore' from JSON`);
+}
+/** @internal */
+export const HistoryCauseTimer$inboundSchema = z.object({
+    depth: types.number(),
+    kind: types.literal("timer"),
+    rootExchangeId: types.nullable(types.string()),
+    timerId: types.string(),
+});
+export function historyCauseTimerFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HistoryCauseTimer$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HistoryCauseTimer' from JSON`);
+}
+/** @internal */
+export const HistoryCauseReactor$inboundSchema = z.object({
+    depth: types.number(),
+    eventId: types.string(),
+    kind: types.literal("reactor"),
+    reactor: types.string(),
+    rootExchangeId: types.nullable(types.string()),
+});
+export function historyCauseReactorFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HistoryCauseReactor$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HistoryCauseReactor' from JSON`);
+}
+/** @internal */
+export const HistoryCauseExchange$inboundSchema = z.object({
+    exchangeId: types.string(),
+    kind: types.literal("exchange"),
+});
+export function historyCauseExchangeFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HistoryCauseExchange$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HistoryCauseExchange' from JSON`);
+}
+/** @internal */
+export const HistoryCause$inboundSchema = discriminatedUnion("kind", {
+    exchange: z.lazy(() => HistoryCauseExchange$inboundSchema),
+    reactor: z.lazy(() => HistoryCauseReactor$inboundSchema),
+    timer: z.lazy(() => HistoryCauseTimer$inboundSchema),
+    restore: z.lazy(() => HistoryCauseRestore$inboundSchema),
+    bootstrap: z.lazy(() => HistoryCauseBootstrap$inboundSchema),
+});
+export function historyCauseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HistoryCause$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HistoryCause' from JSON`);
+}

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

@@ -0,0 +1,11 @@
+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 HistoryPosition = {
+    generation: number;
+    lsn: string;
+    until: string | null;
+};
+/** @internal */
+export declare const HistoryPosition$inboundSchema: z.ZodMiniType<HistoryPosition, unknown>;
+export declare function historyPositionFromJSON(jsonString: string): SafeParseResult<HistoryPosition, SDKValidationError>;

package/esm/models/history-position.js

@@ -0,0 +1,15 @@
+/*
+ * 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 HistoryPosition$inboundSchema = z.object({
+    generation: types.number(),
+    lsn: types.string(),
+    until: types.nullable(types.string()),
+});
+export function historyPositionFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HistoryPosition$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HistoryPosition' from JSON`);
+}

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

@@ -0,0 +1,16 @@
+import * as z from "zod/v4-mini";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+import { HistoryCause } from "./history-cause.js";
+export type HistoryTransaction = {
+    cause: HistoryCause | null;
+    changes: number;
+    committedAt: Date;
+    generation: number;
+    lsn: string;
+    tables: Array<string>;
+    xid: number;
+};
+/** @internal */
+export declare const HistoryTransaction$inboundSchema: z.ZodMiniType<HistoryTransaction, unknown>;
+export declare function historyTransactionFromJSON(jsonString: string): SafeParseResult<HistoryTransaction, SDKValidationError>;

package/esm/models/history-transaction.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 types from "../types/primitives.js";
+import { HistoryCause$inboundSchema } from "./history-cause.js";
+/** @internal */
+export const HistoryTransaction$inboundSchema = z.object({
+    cause: types.nullable(HistoryCause$inboundSchema),
+    changes: types.number(),
+    committedAt: types.date(),
+    generation: types.number(),
+    lsn: types.string(),
+    tables: z.array(types.string()),
+    xid: types.number(),
+});
+export function historyTransactionFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HistoryTransaction$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HistoryTransaction' from JSON`);
+}

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";
@@ -8,11 +9,18 @@ export * from "./create-environment-input.js";
 export * from "./credential-kind.js";
 export * from "./credential.js";
 export * from "./environment-app.js";
+export * from "./environment-exchange.js";
 export * from "./environment-lifetime.js";
+export * from "./environment-position.js";
+export * from "./environment-snapshot.js";
 export * from "./environment.js";
 export * from "./error-response.js";
 export * from "./event-page.js";
 export * from "./event.js";
+export * from "./history-body.js";
+export * from "./history-cause.js";
+export * from "./history-position.js";
+export * from "./history-transaction.js";
 export * from "./release-actor.js";
 export * from "./release.js";
 export * from "./security.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";
@@ -11,11 +12,18 @@ export * from "./create-environment-input.js";
 export * from "./credential-kind.js";
 export * from "./credential.js";
 export * from "./environment-app.js";
+export * from "./environment-exchange.js";
 export * from "./environment-lifetime.js";
+export * from "./environment-position.js";
+export * from "./environment-snapshot.js";
 export * from "./environment.js";
 export * from "./error-response.js";
 export * from "./event-page.js";
 export * from "./event.js";
+export * from "./history-body.js";
+export * from "./history-cause.js";
+export * from "./history-position.js";
+export * from "./history-transaction.js";
 export * from "./release-actor.js";
 export * from "./release.js";
 export * from "./security.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

@@ -2,11 +2,40 @@ 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 = {
+export type At2 = {
+    exchangeId: string;
+};
+export type Position = {
+    generation: number;
+    lsn: string;
+};
+export type At1 = {
+    position: Position;
+};
+export type AtUnion = At1 | At2;
+export type From2 = {
+    at: At1 | At2;
+    environment: string;
+};
+export type CreateEnvironmentDefinitionRequestBody3 = {
+    from: From2;
+    labels?: {
+        [k: string]: string;
+    } | undefined;
+    lifetimeMinutes?: number | undefined;
+    name?: string | undefined;
+    version?: number | undefined;
+};
+export type From1 = {
     snapshot: string;
 };
 export type CreateEnvironmentDefinitionRequestBody2 = {
-    from: From;
+    from: From1;
+    labels?: {
+        [k: string]: string;
+    } | undefined;
+    lifetimeMinutes?: number | undefined;
+    name?: string | undefined;
     version?: number | undefined;
 };
 export type Apps = {
@@ -53,11 +82,11 @@ export type CreateEnvironmentDefinitionRequestBody1 = {
     name?: string | undefined;
     version?: number | undefined;
 };
-export type CreateEnvironmentDefinitionRequestBody = CreateEnvironmentDefinitionRequestBody1 | CreateEnvironmentDefinitionRequestBody2;
+export type CreateEnvironmentDefinitionRequestBody = CreateEnvironmentDefinitionRequestBody1 | CreateEnvironmentDefinitionRequestBody2 | CreateEnvironmentDefinitionRequestBody3;
 export type CreateEnvironmentDefinitionRequest = {
     workspaceId: string;
     idempotencyKey: string;
-    body: CreateEnvironmentDefinitionRequestBody1 | CreateEnvironmentDefinitionRequestBody2;
+    body: CreateEnvironmentDefinitionRequestBody1 | CreateEnvironmentDefinitionRequestBody2 | CreateEnvironmentDefinitionRequestBody3;
 };
 /**
  * Environment accepted from its setup definition
@@ -66,15 +95,68 @@ export type CreateEnvironmentDefinitionResponse = {
     data: models.Environment;
 };
 /** @internal */
-export type From$Outbound = {
+export type At2$Outbound = {
+    exchangeId: string;
+};
+/** @internal */
+export declare const At2$outboundSchema: z.ZodMiniType<At2$Outbound, At2>;
+export declare function at2ToJSON(at2: At2): string;
+/** @internal */
+export type Position$Outbound = {
+    generation: number;
+    lsn: string;
+};
+/** @internal */
+export declare const Position$outboundSchema: z.ZodMiniType<Position$Outbound, Position>;
+export declare function positionToJSON(position: Position): string;
+/** @internal */
+export type At1$Outbound = {
+    position: Position$Outbound;
+};
+/** @internal */
+export declare const At1$outboundSchema: z.ZodMiniType<At1$Outbound, At1>;
+export declare function at1ToJSON(at1: At1): string;
+/** @internal */
+export type AtUnion$Outbound = At1$Outbound | At2$Outbound;
+/** @internal */
+export declare const AtUnion$outboundSchema: z.ZodMiniType<AtUnion$Outbound, AtUnion>;
+export declare function atUnionToJSON(atUnion: AtUnion): string;
+/** @internal */
+export type From2$Outbound = {
+    at: At1$Outbound | At2$Outbound;
+    environment: string;
+};
+/** @internal */
+export declare const From2$outboundSchema: z.ZodMiniType<From2$Outbound, From2>;
+export declare function from2ToJSON(from2: From2): string;
+/** @internal */
+export type CreateEnvironmentDefinitionRequestBody3$Outbound = {
+    from: From2$Outbound;
+    labels?: {
+        [k: string]: string;
+    } | undefined;
+    lifetimeMinutes?: number | undefined;
+    name?: string | undefined;
+    version: number;
+};
+/** @internal */
+export declare const CreateEnvironmentDefinitionRequestBody3$outboundSchema: z.ZodMiniType<CreateEnvironmentDefinitionRequestBody3$Outbound, CreateEnvironmentDefinitionRequestBody3>;
+export declare function createEnvironmentDefinitionRequestBody3ToJSON(createEnvironmentDefinitionRequestBody3: CreateEnvironmentDefinitionRequestBody3): string;
+/** @internal */
+export type From1$Outbound = {
     snapshot: string;
 };
 /** @internal */
-export declare const From$outboundSchema: z.ZodMiniType<From$Outbound, From>;
-export declare function fromToJSON(from: From): string;
+export declare const From1$outboundSchema: z.ZodMiniType<From1$Outbound, From1>;
+export declare function from1ToJSON(from1: From1): string;
 /** @internal */
 export type CreateEnvironmentDefinitionRequestBody2$Outbound = {
-    from: From$Outbound;
+    from: From1$Outbound;
+    labels?: {
+        [k: string]: string;
+    } | undefined;
+    lifetimeMinutes?: number | undefined;
+    name?: string | undefined;
     version: number;
 };
 /** @internal */
@@ -125,7 +207,7 @@ export type CreateEnvironmentDefinitionRequestBody1$Outbound = {
 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;
+export type CreateEnvironmentDefinitionRequestBody$Outbound = CreateEnvironmentDefinitionRequestBody1$Outbound | CreateEnvironmentDefinitionRequestBody2$Outbound | CreateEnvironmentDefinitionRequestBody3$Outbound;
 /** @internal */
 export declare const CreateEnvironmentDefinitionRequestBody$outboundSchema: z.ZodMiniType<CreateEnvironmentDefinitionRequestBody$Outbound, CreateEnvironmentDefinitionRequestBody>;
 export declare function createEnvironmentDefinitionRequestBodyToJSON(createEnvironmentDefinitionRequestBody: CreateEnvironmentDefinitionRequestBody): string;
@@ -133,7 +215,7 @@ export declare function createEnvironmentDefinitionRequestBodyToJSON(createEnvir
 export type CreateEnvironmentDefinitionRequest$Outbound = {
     workspaceId: string;
     "idempotency-key": string;
-    body: CreateEnvironmentDefinitionRequestBody1$Outbound | CreateEnvironmentDefinitionRequestBody2$Outbound;
+    body: CreateEnvironmentDefinitionRequestBody1$Outbound | CreateEnvironmentDefinitionRequestBody2$Outbound | CreateEnvironmentDefinitionRequestBody3$Outbound;
 };
 /** @internal */
 export declare const CreateEnvironmentDefinitionRequest$outboundSchema: z.ZodMiniType<CreateEnvironmentDefinitionRequest$Outbound, CreateEnvironmentDefinitionRequest>;

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

@@ -7,15 +7,72 @@ 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({
+export const At2$outboundSchema = z.object({
+    exchangeId: z.string(),
+});
+export function at2ToJSON(at2) {
+    return JSON.stringify(At2$outboundSchema.parse(at2));
+}
+/** @internal */
+export const Position$outboundSchema = z.object({
+    generation: z.int(),
+    lsn: z.string(),
+});
+export function positionToJSON(position) {
+    return JSON.stringify(Position$outboundSchema.parse(position));
+}
+/** @internal */
+export const At1$outboundSchema = z.object({
+    position: z.lazy(() => Position$outboundSchema),
+});
+export function at1ToJSON(at1) {
+    return JSON.stringify(At1$outboundSchema.parse(at1));
+}
+/** @internal */
+export const AtUnion$outboundSchema = smartUnion([
+    z.lazy(() => At1$outboundSchema),
+    z.lazy(() => At2$outboundSchema),
+]);
+export function atUnionToJSON(atUnion) {
+    return JSON.stringify(AtUnion$outboundSchema.parse(atUnion));
+}
+/** @internal */
+export const From2$outboundSchema = z
+    .object({
+    at: smartUnion([
+        z.lazy(() => At1$outboundSchema),
+        z.lazy(() => At2$outboundSchema),
+    ]),
+    environment: z.string(),
+});
+export function from2ToJSON(from2) {
+    return JSON.stringify(From2$outboundSchema.parse(from2));
+}
+/** @internal */
+export const CreateEnvironmentDefinitionRequestBody3$outboundSchema = z.object({
+    from: z.lazy(() => From2$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 createEnvironmentDefinitionRequestBody3ToJSON(createEnvironmentDefinitionRequestBody3) {
+    return JSON.stringify(CreateEnvironmentDefinitionRequestBody3$outboundSchema.parse(createEnvironmentDefinitionRequestBody3));
+}
+/** @internal */
+export const From1$outboundSchema = z
+    .object({
     snapshot: z.string(),
 });
-export function fromToJSON(from) {
-    return JSON.stringify(From$outboundSchema.parse(from));
+export function from1ToJSON(from1) {
+    return JSON.stringify(From1$outboundSchema.parse(from1));
 }
 /** @internal */
 export const CreateEnvironmentDefinitionRequestBody2$outboundSchema = z.object({
-    from: z.lazy(() => From$outboundSchema),
+    from: z.lazy(() => From1$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 createEnvironmentDefinitionRequestBody2ToJSON(createEnvironmentDefinitionRequestBody2) {
@@ -61,6 +118,7 @@ export function createEnvironmentDefinitionRequestBody1ToJSON(createEnvironmentD
 export const CreateEnvironmentDefinitionRequestBody$outboundSchema = smartUnion([
     z.lazy(() => CreateEnvironmentDefinitionRequestBody1$outboundSchema),
     z.lazy(() => CreateEnvironmentDefinitionRequestBody2$outboundSchema),
+    z.lazy(() => CreateEnvironmentDefinitionRequestBody3$outboundSchema),
 ]);
 export function createEnvironmentDefinitionRequestBodyToJSON(createEnvironmentDefinitionRequestBody) {
     return JSON.stringify(CreateEnvironmentDefinitionRequestBody$outboundSchema.parse(createEnvironmentDefinitionRequestBody));
@@ -72,6 +130,7 @@ export const CreateEnvironmentDefinitionRequest$outboundSchema = z.pipe(z.object
     body: smartUnion([
         z.lazy(() => CreateEnvironmentDefinitionRequestBody1$outboundSchema),
         z.lazy(() => CreateEnvironmentDefinitionRequestBody2$outboundSchema),
+        z.lazy(() => CreateEnvironmentDefinitionRequestBody3$outboundSchema),
     ]),
 }), z.transform((v) => {
     return remap$(v, {

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`);
+}