@usestatemachines/sdk 0.2.0 → 0.4.0

package/esm/models/operations/get-environment-exchange.d.ts

@@ -0,0 +1,25 @@
+import * as z from "zod/v4-mini";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdk-validation-error.js";
+import * as models from "../index.js";
+export type GetEnvironmentExchangeRequest = {
+    environmentId: string;
+    exchangeId: string;
+};
+/**
+ * One exchange of the environment, with the position a fork after it starts from
+ */
+export type GetEnvironmentExchangeResponse = {
+    data: models.EnvironmentExchange;
+};
+/** @internal */
+export type GetEnvironmentExchangeRequest$Outbound = {
+    environmentId: string;
+    exchangeId: string;
+};
+/** @internal */
+export declare const GetEnvironmentExchangeRequest$outboundSchema: z.ZodMiniType<GetEnvironmentExchangeRequest$Outbound, GetEnvironmentExchangeRequest>;
+export declare function getEnvironmentExchangeRequestToJSON(getEnvironmentExchangeRequest: GetEnvironmentExchangeRequest): string;
+/** @internal */
+export declare const GetEnvironmentExchangeResponse$inboundSchema: z.ZodMiniType<GetEnvironmentExchangeResponse, unknown>;
+export declare function getEnvironmentExchangeResponseFromJSON(jsonString: string): SafeParseResult<GetEnvironmentExchangeResponse, SDKValidationError>;

package/esm/models/operations/get-environment-exchange.js

@@ -0,0 +1,21 @@
+/*
+ * 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 GetEnvironmentExchangeRequest$outboundSchema = z.object({
+    environmentId: z.string(),
+    exchangeId: z.string(),
+});
+export function getEnvironmentExchangeRequestToJSON(getEnvironmentExchangeRequest) {
+    return JSON.stringify(GetEnvironmentExchangeRequest$outboundSchema.parse(getEnvironmentExchangeRequest));
+}
+/** @internal */
+export const GetEnvironmentExchangeResponse$inboundSchema = z.object({
+    data: models.EnvironmentExchange$inboundSchema,
+});
+export function getEnvironmentExchangeResponseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => GetEnvironmentExchangeResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'GetEnvironmentExchangeResponse' from JSON`);
+}

package/esm/models/operations/get-environment-position.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 GetEnvironmentPositionRequest = {
+    environmentId: string;
+};
+/**
+ * Each app's current head position, as a fork from it would start
+ */
+export type GetEnvironmentPositionResponse = {
+    data: models.EnvironmentPosition;
+};
+/** @internal */
+export type GetEnvironmentPositionRequest$Outbound = {
+    environmentId: string;
+};
+/** @internal */
+export declare const GetEnvironmentPositionRequest$outboundSchema: z.ZodMiniType<GetEnvironmentPositionRequest$Outbound, GetEnvironmentPositionRequest>;
+export declare function getEnvironmentPositionRequestToJSON(getEnvironmentPositionRequest: GetEnvironmentPositionRequest): string;
+/** @internal */
+export declare const GetEnvironmentPositionResponse$inboundSchema: z.ZodMiniType<GetEnvironmentPositionResponse, unknown>;
+export declare function getEnvironmentPositionResponseFromJSON(jsonString: string): SafeParseResult<GetEnvironmentPositionResponse, SDKValidationError>;

package/esm/models/operations/get-environment-position.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 GetEnvironmentPositionRequest$outboundSchema = z.object({
+    environmentId: z.string(),
+});
+export function getEnvironmentPositionRequestToJSON(getEnvironmentPositionRequest) {
+    return JSON.stringify(GetEnvironmentPositionRequest$outboundSchema.parse(getEnvironmentPositionRequest));
+}
+/** @internal */
+export const GetEnvironmentPositionResponse$inboundSchema = z.object({
+    data: models.EnvironmentPosition$inboundSchema,
+});
+export function getEnvironmentPositionResponseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => GetEnvironmentPositionResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'GetEnvironmentPositionResponse' 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,14 +1,24 @@
+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-exchange.js";
+export * from "./get-environment-position.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-environment-history.js";
 export * from "./list-environments.js";
+export * from "./list-snapshots.js";
 export * from "./list-workspace-events.js";
 export * from "./list-workspaces.js";
+export * from "./resume-environment.js";
 export * from "./reveal-connection.js";
 export * from "./stop-environment.js";
+export * from "./suspend-environment.js";
+export * from "./update-snapshot.js";

package/esm/models/operations/index.js

@@ -1,17 +1,27 @@
 /*
  * 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-exchange.js";
+export * from "./get-environment-position.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-environment-history.js";
 export * from "./list-environments.js";
+export * from "./list-snapshots.js";
 export * from "./list-workspace-events.js";
 export * from "./list-workspaces.js";
+export * from "./resume-environment.js";
 export * from "./reveal-connection.js";
 export * from "./stop-environment.js";
+export * from "./suspend-environment.js";
+export * from "./update-snapshot.js";

package/esm/models/operations/list-environment-history.d.ts

@@ -0,0 +1,28 @@
+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 ListEnvironmentHistoryRequest = {
+    environmentId: string;
+    limit?: number | undefined;
+    cursor?: string | undefined;
+};
+/**
+ * The environment's exchanges in gateway order, each with its transactions and events
+ */
+export type ListEnvironmentHistoryResponse = {
+    data: Array<models.EnvironmentExchange>;
+    nextCursor: string | null;
+};
+/** @internal */
+export type ListEnvironmentHistoryRequest$Outbound = {
+    environmentId: string;
+    limit: number;
+    cursor?: string | undefined;
+};
+/** @internal */
+export declare const ListEnvironmentHistoryRequest$outboundSchema: z.ZodMiniType<ListEnvironmentHistoryRequest$Outbound, ListEnvironmentHistoryRequest>;
+export declare function listEnvironmentHistoryRequestToJSON(listEnvironmentHistoryRequest: ListEnvironmentHistoryRequest): string;
+/** @internal */
+export declare const ListEnvironmentHistoryResponse$inboundSchema: z.ZodMiniType<ListEnvironmentHistoryResponse, unknown>;
+export declare function listEnvironmentHistoryResponseFromJSON(jsonString: string): SafeParseResult<ListEnvironmentHistoryResponse, SDKValidationError>;

package/esm/models/operations/list-environment-history.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 types from "../../types/primitives.js";
+import * as models from "../index.js";
+/** @internal */
+export const ListEnvironmentHistoryRequest$outboundSchema = z.object({
+    environmentId: z.string(),
+    limit: z._default(z.int(), 50),
+    cursor: z.optional(z.string()),
+});
+export function listEnvironmentHistoryRequestToJSON(listEnvironmentHistoryRequest) {
+    return JSON.stringify(ListEnvironmentHistoryRequest$outboundSchema.parse(listEnvironmentHistoryRequest));
+}
+/** @internal */
+export const ListEnvironmentHistoryResponse$inboundSchema = z.object({
+    data: z.array(models.EnvironmentExchange$inboundSchema),
+    nextCursor: types.nullable(types.string()),
+});
+export function listEnvironmentHistoryResponseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ListEnvironmentHistoryResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ListEnvironmentHistoryResponse' from JSON`);
+}

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

package/esm/models/operations/resume-environment.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 ResumeEnvironmentRequest = {
+    environmentId: string;
+};
+/**
+ * Environment queued to run again on the data it was suspended with
+ */
+export type ResumeEnvironmentResponse = {
+    data: models.Environment;
+};
+/** @internal */
+export type ResumeEnvironmentRequest$Outbound = {
+    environmentId: string;
+};
+/** @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

@@ -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 ResumeEnvironmentRequest$outboundSchema = z.object({
+    environmentId: z.string(),
+});
+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/stop-environment.d.ts

@@ -6,7 +6,7 @@ export type StopEnvironmentRequest = {
     environmentId: string;
 };
 /**
- * Environment stopped or stopping
+ * Environment stopping or stopped; its data is discarded
  */
 export type StopEnvironmentResponse = {
     data: models.Environment;

package/esm/models/operations/suspend-environment.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 SuspendEnvironmentRequest = {
+    environmentId: string;
+};
+/**
+ * Environment suspending or suspended: its sandboxes go, its data stays for a resume
+ */
+export type SuspendEnvironmentResponse = {
+    data: models.Environment;
+};
+/** @internal */
+export type SuspendEnvironmentRequest$Outbound = {
+    environmentId: string;
+};
+/** @internal */
+export declare const SuspendEnvironmentRequest$outboundSchema: z.ZodMiniType<SuspendEnvironmentRequest$Outbound, SuspendEnvironmentRequest>;
+export declare function suspendEnvironmentRequestToJSON(suspendEnvironmentRequest: SuspendEnvironmentRequest): string;
+/** @internal */
+export declare const SuspendEnvironmentResponse$inboundSchema: z.ZodMiniType<SuspendEnvironmentResponse, unknown>;
+export declare function suspendEnvironmentResponseFromJSON(jsonString: string): SafeParseResult<SuspendEnvironmentResponse, SDKValidationError>;

package/esm/models/operations/suspend-environment.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 SuspendEnvironmentRequest$outboundSchema = z.object({
+    environmentId: z.string(),
+});
+export function suspendEnvironmentRequestToJSON(suspendEnvironmentRequest) {
+    return JSON.stringify(SuspendEnvironmentRequest$outboundSchema.parse(suspendEnvironmentRequest));
+}
+/** @internal */
+export const SuspendEnvironmentResponse$inboundSchema = z.object({
+    data: models.Environment$inboundSchema,
+});
+export function suspendEnvironmentResponseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => SuspendEnvironmentResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'SuspendEnvironmentResponse' from JSON`);
+}

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

@@ -0,0 +1,37 @@
+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 */
+export declare const UpdateSnapshotRequestBody$outboundSchema: z.ZodMiniType<UpdateSnapshotRequestBody$Outbound, UpdateSnapshotRequestBody>;
+export declare function updateSnapshotRequestBodyToJSON(updateSnapshotRequestBody: UpdateSnapshotRequestBody): string;
+/** @internal */
+export type UpdateSnapshotRequest$Outbound = {
+    snapshotId: string;
+    body: UpdateSnapshotRequestBody$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

@@ -0,0 +1,29 @@
+/*
+ * 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) {
+    return JSON.stringify(UpdateSnapshotRequestBody$outboundSchema.parse(updateSnapshotRequestBody));
+}
+/** @internal */
+export const UpdateSnapshotRequest$outboundSchema = z.object({
+    snapshotId: z.string(),
+    body: z.lazy(() => UpdateSnapshotRequestBody$outboundSchema),
+});
+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/release.d.ts

@@ -9,6 +9,14 @@ export declare const Qualification: {
     readonly Qualified: "qualified";
 };
 export type Qualification = OpenEnum<typeof Qualification>;
+export declare const ReleaseStatus: {
+    readonly Candidate: "candidate";
+    readonly Default: "default";
+    readonly Available: "available";
+    readonly Retired: "retired";
+    readonly Gone: "gone";
+};
+export type ReleaseStatus = OpenEnum<typeof ReleaseStatus>;
 export type Release = {
     actors: Array<ReleaseActor>;
     apis: Array<ApiProfile>;
@@ -17,10 +25,13 @@ export type Release = {
     id: string;
     qualification: Qualification;
     retiredAt: Date | null;
+    status: ReleaseStatus;
     version: string;
 };
 /** @internal */
 export declare const Qualification$inboundSchema: z.ZodMiniType<Qualification, unknown>;
 /** @internal */
+export declare const ReleaseStatus$inboundSchema: z.ZodMiniType<ReleaseStatus, unknown>;
+/** @internal */
 export declare const Release$inboundSchema: z.ZodMiniType<Release, unknown>;
 export declare function releaseFromJSON(jsonString: string): SafeParseResult<Release, SDKValidationError>;

package/esm/models/release.js

@@ -11,9 +11,18 @@ export const Qualification = {
     Development: "development",
     Qualified: "qualified",
 };
+export const ReleaseStatus = {
+    Candidate: "candidate",
+    Default: "default",
+    Available: "available",
+    Retired: "retired",
+    Gone: "gone",
+};
 /** @internal */
 export const Qualification$inboundSchema = openEnums.inboundSchema(Qualification);
 /** @internal */
+export const ReleaseStatus$inboundSchema = openEnums.inboundSchema(ReleaseStatus);
+/** @internal */
 export const Release$inboundSchema = z.object({
     actors: z.array(ReleaseActor$inboundSchema),
     apis: z.array(ApiProfile$inboundSchema),
@@ -22,6 +31,7 @@ export const Release$inboundSchema = z.object({
     id: types.string(),
     qualification: Qualification$inboundSchema,
     retiredAt: types.nullable(types.date()),
+    status: ReleaseStatus$inboundSchema,
     version: types.string(),
 });
 export function releaseFromJSON(jsonString) {

package/esm/sdk/environments.d.ts

@@ -6,7 +6,9 @@ export declare class Environments extends ClientSDK {
     getConnection(request: operations.GetConnectionRequest, options?: RequestOptions): Promise<operations.GetConnectionResponse>;
     reveal(request: operations.RevealConnectionRequest, options?: RequestOptions): Promise<operations.RevealConnectionResponse>;
     events(request: operations.ListEnvironmentEventsRequest, options?: RequestOptions): Promise<models.EventPage>;
+    resume(request: operations.ResumeEnvironmentRequest, options?: RequestOptions): Promise<operations.ResumeEnvironmentResponse>;
     stop(request: operations.StopEnvironmentRequest, options?: RequestOptions): Promise<operations.StopEnvironmentResponse>;
+    suspend(request: operations.SuspendEnvironmentRequest, options?: RequestOptions): Promise<operations.SuspendEnvironmentResponse>;
     list(request: operations.ListEnvironmentsRequest, options?: RequestOptions): Promise<operations.ListEnvironmentsResponse>;
     create(request: operations.CreateEnvironmentsRequest, options?: RequestOptions): Promise<operations.CreateEnvironmentsResponse>;
 }

package/esm/sdk/environments.js

@@ -6,8 +6,10 @@ import { environmentsEvents } from "../funcs/environments-events.js";
 import { environmentsGetConnection } from "../funcs/environments-get-connection.js";
 import { environmentsGet } from "../funcs/environments-get.js";
 import { environmentsList } from "../funcs/environments-list.js";
+import { environmentsResume } from "../funcs/environments-resume.js";
 import { environmentsReveal } from "../funcs/environments-reveal.js";
 import { environmentsStop } from "../funcs/environments-stop.js";
+import { environmentsSuspend } from "../funcs/environments-suspend.js";
 import { ClientSDK } from "../lib/sdks.js";
 import { unwrapAsync } from "../types/fp.js";
 export class Environments extends ClientSDK {
@@ -23,9 +25,15 @@ export class Environments extends ClientSDK {
     async events(request, options) {
         return unwrapAsync(environmentsEvents(this, request, options));
     }
+    async resume(request, options) {
+        return unwrapAsync(environmentsResume(this, request, options));
+    }
     async stop(request, options) {
         return unwrapAsync(environmentsStop(this, request, options));
     }
+    async suspend(request, options) {
+        return unwrapAsync(environmentsSuspend(this, request, options));
+    }
     async list(request, options) {
         return unwrapAsync(environmentsList(this, request, options));
     }

package/esm/sdk/sdk.d.ts

@@ -3,6 +3,7 @@ import * as operations from "../models/operations/index.js";
 import { Catalog } from "./catalog.js";
 import { Credential } from "./credential.js";
 import { Environments } from "./environments.js";
+import { Snapshots } from "./snapshots.js";
 import { Workspaces } from "./workspaces.js";
 export declare class StateMachines extends ClientSDK {
     private _catalog?;
@@ -11,7 +12,12 @@ export declare class StateMachines extends ClientSDK {
     get credential(): Credential;
     private _environments?;
     get environments(): Environments;
+    private _snapshots?;
+    get snapshots(): Snapshots;
     private _workspaces?;
     get workspaces(): Workspaces;
+    listEnvironmentHistory(request: operations.ListEnvironmentHistoryRequest, options?: RequestOptions): Promise<operations.ListEnvironmentHistoryResponse>;
+    getEnvironmentPosition(request: operations.GetEnvironmentPositionRequest, options?: RequestOptions): Promise<operations.GetEnvironmentPositionResponse>;
+    getEnvironmentExchange(request: operations.GetEnvironmentExchangeRequest, options?: RequestOptions): Promise<operations.GetEnvironmentExchangeResponse>;
     createEnvironmentDefinition(request: operations.CreateEnvironmentDefinitionRequest, options?: RequestOptions): Promise<operations.CreateEnvironmentDefinitionResponse>;
 }