@usestatemachines/sdk 0.1.1 → 0.3.0

package/esm/funcs/snapshots-get.js

@@ -0,0 +1,92 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4-mini";
+import { 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 snapshotsGet(client, request, options) {
+    return new APIPromise($do(client, request, options));
+}
+async function $do(client, request, options) {
+    const parsed = safeParse(request, (value) => z.parse(operations.GetSnapshotRequest$outboundSchema, value), "Input validation failed");
+    if (!parsed.ok) {
+        return [parsed, { status: "invalid" }];
+    }
+    const payload = parsed.value;
+    const body = null;
+    const pathParams = {
+        snapshotId: encodeSimple("snapshotId", payload.snapshotId, {
+            explode: false,
+            charEncoding: "percent",
+        }),
+    };
+    const path = pathToFunc("/v1/snapshots/{snapshotId}")(pathParams);
+    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: "getSnapshot",
+        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,
+        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.GetSnapshotResponse$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/funcs/snapshots-list.d.ts

@@ -0,0 +1,11 @@
+import { StateMachinesCore } from "../core.js";
+import { RequestOptions } from "../lib/sdks.js";
+import { ConnectionError, InvalidRequestError, RequestAbortedError, RequestTimeoutError, UnexpectedClientError } from "../models/errors/http-client-errors.js";
+import * as errors from "../models/errors/index.js";
+import { ResponseValidationError } from "../models/errors/response-validation-error.js";
+import { SDKValidationError } from "../models/errors/sdk-validation-error.js";
+import { StateMachinesHTTPError } from "../models/errors/state-machines-http-error.js";
+import * as operations from "../models/operations/index.js";
+import { APIPromise } from "../types/async.js";
+import { Result } from "../types/fp.js";
+export declare function snapshotsList(client: StateMachinesCore, request: operations.ListSnapshotsRequest, options?: RequestOptions): APIPromise<Result<operations.ListSnapshotsResponse, errors.ErrorResponse | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;

package/esm/funcs/snapshots-list.js

@@ -0,0 +1,98 @@
+/*
+ * 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 snapshotsList(client, request, options) {
+    return new APIPromise($do(client, request, options));
+}
+async function $do(client, request, options) {
+    const parsed = safeParse(request, (value) => z.parse(operations.ListSnapshotsRequest$outboundSchema, value), "Input validation failed");
+    if (!parsed.ok) {
+        return [parsed, { status: "invalid" }];
+    }
+    const payload = parsed.value;
+    const body = null;
+    const pathParams = {
+        workspaceId: encodeSimple("workspaceId", payload.workspaceId, {
+            explode: false,
+            charEncoding: "percent",
+        }),
+    };
+    const path = pathToFunc("/v1/workspaces/{workspaceId}/snapshots")(pathParams);
+    const query = encodeFormQuery({
+        "cursor": payload.cursor,
+        "limit": payload.limit,
+        "sourceEnvironmentId": payload.sourceEnvironmentId,
+    });
+    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: "listSnapshots",
+        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.ListSnapshotsResponse$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/funcs/snapshots-update.d.ts

@@ -0,0 +1,11 @@
+import { StateMachinesCore } from "../core.js";
+import { RequestOptions } from "../lib/sdks.js";
+import { ConnectionError, InvalidRequestError, RequestAbortedError, RequestTimeoutError, UnexpectedClientError } from "../models/errors/http-client-errors.js";
+import * as errors from "../models/errors/index.js";
+import { ResponseValidationError } from "../models/errors/response-validation-error.js";
+import { SDKValidationError } from "../models/errors/sdk-validation-error.js";
+import { StateMachinesHTTPError } from "../models/errors/state-machines-http-error.js";
+import * as operations from "../models/operations/index.js";
+import { APIPromise } from "../types/async.js";
+import { Result } from "../types/fp.js";
+export declare function snapshotsUpdate(client: StateMachinesCore, request: operations.UpdateSnapshotRequest, options?: RequestOptions): APIPromise<Result<operations.UpdateSnapshotResponse, errors.ErrorResponse | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;

package/esm/funcs/snapshots-update.js

@@ -0,0 +1,93 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4-mini";
+import { encodeJSON, 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 snapshotsUpdate(client, request, options) {
+    return new APIPromise($do(client, request, options));
+}
+async function $do(client, request, options) {
+    const parsed = safeParse(request, (value) => z.parse(operations.UpdateSnapshotRequest$outboundSchema, value), "Input validation failed");
+    if (!parsed.ok) {
+        return [parsed, { status: "invalid" }];
+    }
+    const payload = parsed.value;
+    const body = encodeJSON("body", payload.body, { explode: true });
+    const pathParams = {
+        snapshotId: encodeSimple("snapshotId", payload.snapshotId, {
+            explode: false,
+            charEncoding: "percent",
+        }),
+    };
+    const path = pathToFunc("/v1/snapshots/{snapshotId}")(pathParams);
+    const headers = new Headers(compactMap({
+        "Content-Type": "application/json",
+        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: "updateSnapshot",
+        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: "PATCH",
+        baseURL: options?.serverURL,
+        path: path,
+        headers: headers,
+        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.UpdateSnapshotResponse$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.1.1";
+    readonly sdkVersion: "0.3.0";
     readonly genVersion: "2.941.0";
-    readonly userAgent: "speakeasy-sdk/typescript 0.1.1 2.941.0 1.0.0 @usestatemachines/sdk";
+    readonly userAgent: "speakeasy-sdk/typescript 0.3.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.1.1",
+    sdkVersion: "0.3.0",
     genVersion: "2.941.0",
-    userAgent: "speakeasy-sdk/typescript 0.1.1 2.941.0 1.0.0 @usestatemachines/sdk",
+    userAgent: "speakeasy-sdk/typescript 0.3.0 2.941.0 1.0.0 @usestatemachines/sdk",
 };

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

@@ -0,0 +1,15 @@
+import * as z from "zod/v4-mini";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+export type AppInstanceSnapshot = {
+    appId: string;
+    appInstanceKey: string;
+    appReleaseId: string;
+    capturedAt: Date | null;
+    id: string;
+    sizeBytes: number | null;
+    sourceAppInstanceId: string;
+};
+/** @internal */
+export declare const AppInstanceSnapshot$inboundSchema: z.ZodMiniType<AppInstanceSnapshot, unknown>;
+export declare function appInstanceSnapshotFromJSON(jsonString: string): SafeParseResult<AppInstanceSnapshot, SDKValidationError>;

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

@@ -0,0 +1,19 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4-mini";
+import { safeParse } from "../lib/schemas.js";
+import * as types from "../types/primitives.js";
+/** @internal */
+export const AppInstanceSnapshot$inboundSchema = z.object({
+    appId: types.string(),
+    appInstanceKey: types.string(),
+    appReleaseId: types.string(),
+    capturedAt: types.nullable(types.date()),
+    id: types.string(),
+    sizeBytes: types.nullable(types.number()),
+    sourceAppInstanceId: types.string(),
+});
+export function appInstanceSnapshotFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AppInstanceSnapshot$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AppInstanceSnapshot' from JSON`);
+}

package/esm/models/connection-secret.d.ts

@@ -1,14 +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";
+export type Native = {
+    authentication: string;
+    baseUrl: string;
+    credentials: {
+        [k: string]: string;
+    };
+    key: string;
+    parameters: {
+        [k: string]: string;
+    };
+};
 export type ConnectionSecret = {
     actorId: string;
     actorToken: string;
     appKey: string;
+    connectionKey: string | null;
     environmentId: string;
     environmentToken: string;
     expiresAt: Date;
+    native?: Native | undefined;
 };
 /** @internal */
+export declare const Native$inboundSchema: z.ZodMiniType<Native, unknown>;
+export declare function nativeFromJSON(jsonString: string): SafeParseResult<Native, SDKValidationError>;
+/** @internal */
 export declare const ConnectionSecret$inboundSchema: z.ZodMiniType<ConnectionSecret, unknown>;
 export declare function connectionSecretFromJSON(jsonString: string): SafeParseResult<ConnectionSecret, SDKValidationError>;

package/esm/models/connection-secret.js

@@ -5,13 +5,26 @@ import * as z from "zod/v4-mini";
 import { safeParse } from "../lib/schemas.js";
 import * as types from "../types/primitives.js";
 /** @internal */
+export const Native$inboundSchema = z.object({
+    authentication: types.string(),
+    baseUrl: types.string(),
+    credentials: z.record(z.string(), types.string()),
+    key: types.string(),
+    parameters: z.record(z.string(), types.string()),
+});
+export function nativeFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Native$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Native' from JSON`);
+}
+/** @internal */
 export const ConnectionSecret$inboundSchema = z.object({
     actorId: types.string(),
     actorToken: types.string(),
     appKey: types.string(),
+    connectionKey: types.nullable(types.string()),
     environmentId: types.string(),
     environmentToken: types.string(),
     expiresAt: types.date(),
+    native: types.optional(z.lazy(() => Native$inboundSchema)),
 });
 export function connectionSecretFromJSON(jsonString) {
     return safeParse(jsonString, (x) => ConnectionSecret$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ConnectionSecret' from JSON`);

package/esm/models/connection.d.ts

@@ -4,6 +4,15 @@ import { Result as SafeParseResult } from "../types/fp.js";
 import { ApiProfile } from "./api-profile.js";
 import { SDKValidationError } from "./errors/sdk-validation-error.js";
 import { ReleaseActor } from "./release-actor.js";
+export type Connection1 = {
+    actorId: string;
+    authentication: string;
+    key: string;
+    parameters: {
+        [k: string]: string;
+    };
+    secrets: Array<string>;
+};
 export declare const ConnectionStatus: {
     readonly Starting: "starting";
     readonly Ready: "ready";
@@ -15,11 +24,16 @@ export type Connection = {
     apis: Array<ApiProfile>;
     appKey: string;
     baseUrl: string | null;
+    connections: Array<Connection1>;
+    defaultConnection: string | null;
     environmentId: string;
     expiresAt: Date | null;
     status: ConnectionStatus;
 };
 /** @internal */
+export declare const Connection1$inboundSchema: z.ZodMiniType<Connection1, unknown>;
+export declare function connection1FromJSON(jsonString: string): SafeParseResult<Connection1, SDKValidationError>;
+/** @internal */
 export declare const ConnectionStatus$inboundSchema: z.ZodMiniType<ConnectionStatus, unknown>;
 /** @internal */
 export declare const Connection$inboundSchema: z.ZodMiniType<Connection, unknown>;

package/esm/models/connection.js

@@ -13,6 +13,18 @@ export const ConnectionStatus = {
     Unavailable: "unavailable",
 };
 /** @internal */
+export const Connection1$inboundSchema = z
+    .object({
+    actorId: types.string(),
+    authentication: types.string(),
+    key: types.string(),
+    parameters: z.record(z.string(), types.string()),
+    secrets: z.array(types.string()),
+});
+export function connection1FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Connection1$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Connection1' from JSON`);
+}
+/** @internal */
 export const ConnectionStatus$inboundSchema = openEnums.inboundSchema(ConnectionStatus);
 /** @internal */
 export const Connection$inboundSchema = z
@@ -21,6 +33,8 @@ export const Connection$inboundSchema = z
     apis: z.array(ApiProfile$inboundSchema),
     appKey: types.string(),
     baseUrl: types.nullable(types.string()),
+    connections: z.array(z.lazy(() => Connection1$inboundSchema)),
+    defaultConnection: types.nullable(types.string()),
     environmentId: types.string(),
     expiresAt: types.nullable(types.date()),
     status: ConnectionStatus$inboundSchema,

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

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

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

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

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

@@ -30,6 +30,7 @@ export type EnvironmentApp = {
     provider: string;
     readyAt: Date | null;
     region: string | null;
+    sourceAppInstanceSnapshotId: string | null;
     status: EnvironmentAppStatus;
     stoppedAt: Date | null;
 };

package/esm/models/environment-app.js

@@ -36,6 +36,7 @@ export const EnvironmentApp$inboundSchema = z.object({
     provider: types.string(),
     readyAt: types.nullable(types.date()),
     region: types.nullable(types.string()),
+    sourceAppInstanceSnapshotId: z._default(z.nullable(types.string()), null),
     status: EnvironmentAppStatus$inboundSchema,
     stoppedAt: types.nullable(types.date()),
 });

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

package/esm/models/environment-snapshot.js

@@ -0,0 +1,41 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4-mini";
+import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+import * as types from "../types/primitives.js";
+import { Actor$inboundSchema } from "./actor.js";
+import { AppInstanceSnapshot$inboundSchema, } from "./app-instance-snapshot.js";
+export const Consistency = {
+    PerAppInstance: "per-app-instance",
+};
+export const EnvironmentSnapshotStatus = {
+    Capturing: "capturing",
+    Ready: "ready",
+    Failed: "failed",
+};
+/** @internal */
+export const Consistency$inboundSchema = openEnums.inboundSchema(Consistency);
+/** @internal */
+export const EnvironmentSnapshotStatus$inboundSchema = openEnums.inboundSchema(EnvironmentSnapshotStatus);
+/** @internal */
+export const EnvironmentSnapshot$inboundSchema = z.object({
+    appInstanceSnapshots: z.array(AppInstanceSnapshot$inboundSchema),
+    consistency: Consistency$inboundSchema,
+    createdAt: types.date(),
+    createdBy: types.nullable(Actor$inboundSchema),
+    deletedAt: types.nullable(types.date()),
+    errorCode: types.nullable(types.string()),
+    id: types.string(),
+    name: types.nullable(types.string()),
+    readyAt: types.nullable(types.date()),
+    sizeBytes: types.nullable(types.number()),
+    sourceEnvironmentId: types.string(),
+    status: EnvironmentSnapshotStatus$inboundSchema,
+    version: types.number(),
+    workspaceId: types.string(),
+});
+export function environmentSnapshotFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => EnvironmentSnapshot$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'EnvironmentSnapshot' from JSON`);
+}

package/esm/models/environment.d.ts

@@ -31,6 +31,7 @@ export type Environment = {
     };
     lifetimeMinutes: number;
     name: string | null;
+    sourceEnvironmentSnapshotId: string | null;
     startedAt: Date | null;
     status: EnvironmentStatus;
     stopReason: StopReason | null;

package/esm/models/environment.js

@@ -36,6 +36,7 @@ export const Environment$inboundSchema = z
     labels: z.record(z.string(), types.string()),
     lifetimeMinutes: types.number(),
     name: types.nullable(types.string()),
+    sourceEnvironmentSnapshotId: z._default(z.nullable(types.string()), null),
     startedAt: types.nullable(types.date()),
     status: EnvironmentStatus$inboundSchema,
     stopReason: types.nullable(StopReason$inboundSchema),