@usestatemachines/sdk 0.3.0 → 0.5.0

package/esm/models/operations/resume-environment.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 ResumeEnvironmentRequest = {
+    environmentId: string;
+    idempotencyKey?: string | undefined;
+};
+/**
+ * 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;
+    "idempotency-key"?: string | undefined;
+};
+/** @internal */
+export declare const ResumeEnvironmentRequest$outboundSchema: z.ZodMiniType<ResumeEnvironmentRequest$Outbound, ResumeEnvironmentRequest>;
+export declare function resumeEnvironmentRequestToJSON(resumeEnvironmentRequest: ResumeEnvironmentRequest): string;
+/** @internal */
+export declare const ResumeEnvironmentResponse$inboundSchema: z.ZodMiniType<ResumeEnvironmentResponse, unknown>;
+export declare function resumeEnvironmentResponseFromJSON(jsonString: string): SafeParseResult<ResumeEnvironmentResponse, SDKValidationError>;

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

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

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

@@ -4,9 +4,10 @@ import { SDKValidationError } from "../errors/sdk-validation-error.js";
 import * as models from "../index.js";
 export type StopEnvironmentRequest = {
     environmentId: string;
+    idempotencyKey?: string | undefined;
 };
 /**
- * Environment stopped or stopping
+ * Environment stopping or stopped; its data is discarded
  */
 export type StopEnvironmentResponse = {
     data: models.Environment;
@@ -14,6 +15,7 @@ export type StopEnvironmentResponse = {
 /** @internal */
 export type StopEnvironmentRequest$Outbound = {
     environmentId: string;
+    "idempotency-key"?: string | undefined;
 };
 /** @internal */
 export declare const StopEnvironmentRequest$outboundSchema: z.ZodMiniType<StopEnvironmentRequest$Outbound, StopEnvironmentRequest>;

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

@@ -2,12 +2,18 @@
  * 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 StopEnvironmentRequest$outboundSchema = z.object({
+export const StopEnvironmentRequest$outboundSchema = z.pipe(z.object({
     environmentId: z.string(),
-});
+    idempotencyKey: z.optional(z.string()),
+}), z.transform((v) => {
+    return remap$(v, {
+        idempotencyKey: "idempotency-key",
+    });
+}));
 export function stopEnvironmentRequestToJSON(stopEnvironmentRequest) {
     return JSON.stringify(StopEnvironmentRequest$outboundSchema.parse(stopEnvironmentRequest));
 }

package/esm/models/operations/suspend-environment.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 SuspendEnvironmentRequest = {
+    environmentId: string;
+    idempotencyKey?: string | undefined;
+};
+/**
+ * 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;
+    "idempotency-key"?: string | undefined;
+};
+/** @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,26 @@
+/*
+ * 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 SuspendEnvironmentRequest$outboundSchema = z.pipe(z.object({
+    environmentId: z.string(),
+    idempotencyKey: z.optional(z.string()),
+}), z.transform((v) => {
+    return remap$(v, {
+        idempotencyKey: "idempotency-key",
+    });
+}));
+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/models/request-payload-preview.d.ts

@@ -0,0 +1,31 @@
+import * as z from "zod/v4-mini";
+import { OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+export declare const Coverage: {
+    readonly Captured: "captured";
+    readonly Redacted: "redacted";
+    readonly Omitted: "omitted";
+};
+export type Coverage = OpenEnum<typeof Coverage>;
+export declare const Encoding: {
+    readonly Utf8: "utf8";
+    readonly Binary: "binary";
+};
+export type Encoding = OpenEnum<typeof Encoding>;
+export type RequestPayloadPreview = {
+    bytes: number | null;
+    contentType: string | null;
+    coverage: Coverage;
+    encoding: Encoding;
+    preview: string | null;
+    previewTruncated: boolean;
+    reason: string | null;
+};
+/** @internal */
+export declare const Coverage$inboundSchema: z.ZodMiniType<Coverage, unknown>;
+/** @internal */
+export declare const Encoding$inboundSchema: z.ZodMiniType<Encoding, unknown>;
+/** @internal */
+export declare const RequestPayloadPreview$inboundSchema: z.ZodMiniType<RequestPayloadPreview, unknown>;
+export declare function requestPayloadPreviewFromJSON(jsonString: string): SafeParseResult<RequestPayloadPreview, SDKValidationError>;

package/esm/models/request-payload-preview.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 = {
+    Captured: "captured",
+    Redacted: "redacted",
+    Omitted: "omitted",
+};
+export const Encoding = {
+    Utf8: "utf8",
+    Binary: "binary",
+};
+/** @internal */
+export const Coverage$inboundSchema = openEnums.inboundSchema(Coverage);
+/** @internal */
+export const Encoding$inboundSchema = openEnums.inboundSchema(Encoding);
+/** @internal */
+export const RequestPayloadPreview$inboundSchema = z.object({
+    bytes: types.nullable(types.number()),
+    contentType: types.nullable(types.string()),
+    coverage: Coverage$inboundSchema,
+    encoding: Encoding$inboundSchema,
+    preview: types.nullable(types.string()),
+    previewTruncated: types.boolean(),
+    reason: types.nullable(types.string()),
+});
+export function requestPayloadPreviewFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => RequestPayloadPreview$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'RequestPayloadPreview' from JSON`);
+}

package/esm/sdk/environments.d.ts

@@ -6,7 +6,13 @@ 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>;
+    listRequests(request: operations.ListEnvironmentRequestsRequest, options?: RequestOptions): Promise<operations.ListEnvironmentRequestsResponse>;
+    getRequestStats(request: operations.GetEnvironmentRequestStatsRequest, options?: RequestOptions): Promise<operations.GetEnvironmentRequestStatsResponse>;
+    getRequest(request: operations.GetEnvironmentRequestRequest, options?: RequestOptions): Promise<operations.GetEnvironmentRequestResponse>;
+    getRequestPayload(request: operations.GetEnvironmentRequestPayloadRequest, options?: RequestOptions): Promise<ReadableStream<Uint8Array>>;
+    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

@@ -4,10 +4,16 @@
 import { environmentsCreate } from "../funcs/environments-create.js";
 import { environmentsEvents } from "../funcs/environments-events.js";
 import { environmentsGetConnection } from "../funcs/environments-get-connection.js";
+import { environmentsGetRequestPayload } from "../funcs/environments-get-request-payload.js";
+import { environmentsGetRequestStats } from "../funcs/environments-get-request-stats.js";
+import { environmentsGetRequest } from "../funcs/environments-get-request.js";
 import { environmentsGet } from "../funcs/environments-get.js";
+import { environmentsListRequests } from "../funcs/environments-list-requests.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 +29,27 @@ export class Environments extends ClientSDK {
     async events(request, options) {
         return unwrapAsync(environmentsEvents(this, request, options));
     }
+    async listRequests(request, options) {
+        return unwrapAsync(environmentsListRequests(this, request, options));
+    }
+    async getRequestStats(request, options) {
+        return unwrapAsync(environmentsGetRequestStats(this, request, options));
+    }
+    async getRequest(request, options) {
+        return unwrapAsync(environmentsGetRequest(this, request, options));
+    }
+    async getRequestPayload(request, options) {
+        return unwrapAsync(environmentsGetRequestPayload(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));
     }