@usestatemachines/sdk 0.3.0 → 0.4.0

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

@@ -16,5 +16,8 @@ export declare class StateMachines extends ClientSDK {
     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>;
 }

package/esm/sdk/sdk.js

@@ -2,6 +2,9 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 import { createEnvironmentDefinition } from "../funcs/create-environment-definition.js";
+import { getEnvironmentExchange } from "../funcs/get-environment-exchange.js";
+import { getEnvironmentPosition } from "../funcs/get-environment-position.js";
+import { listEnvironmentHistory } from "../funcs/list-environment-history.js";
 import { ClientSDK } from "../lib/sdks.js";
 import { unwrapAsync } from "../types/fp.js";
 import { Catalog } from "./catalog.js";
@@ -30,6 +33,15 @@ export class StateMachines extends ClientSDK {
     get workspaces() {
         return (this._workspaces ?? (this._workspaces = new Workspaces(this._options)));
     }
+    async listEnvironmentHistory(request, options) {
+        return unwrapAsync(listEnvironmentHistory(this, request, options));
+    }
+    async getEnvironmentPosition(request, options) {
+        return unwrapAsync(getEnvironmentPosition(this, request, options));
+    }
+    async getEnvironmentExchange(request, options) {
+        return unwrapAsync(getEnvironmentExchange(this, request, options));
+    }
     async createEnvironmentDefinition(request, options) {
         return unwrapAsync(createEnvironmentDefinition(this, request, options));
     }

package/esm/types/discriminated-union.d.ts

@@ -0,0 +1,24 @@
+import * as z from "zod/v4-mini";
+export type Unknown<Discriminator extends string, UnknownValue = "UNKNOWN"> = {
+    [K in Discriminator]: UnknownValue;
+} & {
+    raw: unknown;
+    isUnknown: true;
+};
+export declare function isUnknown<Discriminator extends string>(value: unknown): value is Unknown<Discriminator>;
+/**
+ * Forward-compatible discriminated union parser.
+ *
+ * If the input does not match one of the predefined options, it will be
+ * captured and available as `{ raw: <original input>, [discriminator]: "UNKNOWN", isUnknown: true }`.
+ *
+ * @param inputPropertyName - The discriminator property name in the input payload
+ * @param options - Map of discriminator values to their corresponding schemas
+ * @param opts - Optional configuration object
+ * @param opts.unknownValue - The value to use for the discriminator when the input is unknown (default: "UNKNOWN")
+ * @param opts.outputPropertyName - Output property name if the sanitized (camelCase) property name differs from inputPropertyName
+ */
+export declare function discriminatedUnion<InputDiscriminator extends string, TOptions extends Readonly<Record<string, z.ZodMiniType>>, UnknownValue extends string = "UNKNOWN", OutputDiscriminator extends string = InputDiscriminator>(inputPropertyName: InputDiscriminator, options: TOptions, opts?: {
+    unknownValue?: UnknownValue;
+    outputPropertyName?: OutputDiscriminator;
+}): z.ZodMiniType<z.output<TOptions[keyof TOptions]> | Unknown<OutputDiscriminator, UnknownValue>, unknown>;

package/esm/types/discriminated-union.js

@@ -0,0 +1,60 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4-mini";
+import { startCountingDefaultToZeroValue } from "./default-to-zero-value.js";
+import { startCountingUnrecognized } from "./unrecognized.js";
+const UNKNOWN = Symbol("UNKNOWN");
+export function isUnknown(value) {
+    return typeof value === "object" && value !== null && UNKNOWN in value;
+}
+/**
+ * Forward-compatible discriminated union parser.
+ *
+ * If the input does not match one of the predefined options, it will be
+ * captured and available as `{ raw: <original input>, [discriminator]: "UNKNOWN", isUnknown: true }`.
+ *
+ * @param inputPropertyName - The discriminator property name in the input payload
+ * @param options - Map of discriminator values to their corresponding schemas
+ * @param opts - Optional configuration object
+ * @param opts.unknownValue - The value to use for the discriminator when the input is unknown (default: "UNKNOWN")
+ * @param opts.outputPropertyName - Output property name if the sanitized (camelCase) property name differs from inputPropertyName
+ */
+export function discriminatedUnion(inputPropertyName, options, opts = {}) {
+    const { unknownValue = "UNKNOWN", outputPropertyName } = opts;
+    return z.pipe(z.unknown(), z.transform((input) => {
+        const fallback = Object.defineProperties({
+            raw: input,
+            [outputPropertyName ?? inputPropertyName]: unknownValue,
+            isUnknown: true,
+        }, { [UNKNOWN]: { value: true, enumerable: false, configurable: false } });
+        const isObject = typeof input === "object" && input !== null;
+        if (!isObject)
+            return fallback;
+        const discriminator = input[inputPropertyName];
+        if (typeof discriminator !== "string")
+            return fallback;
+        if (!(discriminator in options))
+            return fallback;
+        const schema = options[discriminator];
+        if (!schema)
+            return fallback;
+        // Start counters before parsing to track nested unrecognized/zeroDefault values
+        const unrecognizedCtr = startCountingUnrecognized();
+        const zeroDefaultCtr = startCountingDefaultToZeroValue();
+        const result = z.safeParse(schema, input);
+        if (!result.success) {
+            // Parse failed - don't propagate any counts from the failed attempt
+            unrecognizedCtr.end(0);
+            zeroDefaultCtr.end(0);
+            return fallback;
+        }
+        // Parse succeeded - propagate the actual counts
+        unrecognizedCtr.end();
+        zeroDefaultCtr.end();
+        if (outputPropertyName) {
+            result.data[outputPropertyName] = discriminator;
+        }
+        return result.data;
+    }));
+}

package/esm/types/smart-union.js

@@ -4,6 +4,7 @@
 // Not needed if lax mode
 import * as z from "zod/v4-mini";
 import { startCountingDefaultToZeroValue } from "./default-to-zero-value.js";
+import { isUnknown as isDiscriminatedUnionUnknown } from "./discriminated-union.js";
 import { RFCDate } from "./rfcdate.js";
 import { startCountingUnrecognized } from "./unrecognized.js";
 /**
@@ -87,7 +88,7 @@ function countFieldsRecursive(parsed) {
     let index = 0;
     while (index < queue.length) {
         const value = queue[index++];
-        if (value === undefined) {
+        if (value === undefined || isDiscriminatedUnionUnknown(value)) {
             continue;
         }
         // Check if it's a primitive value