@usestatemachines/sdk 0.4.0 → 0.5.0

package/esm/models/operations/create-environment-definition.d.ts

@@ -2,35 +2,11 @@ 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 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 = {
+export type From = {
     snapshot: string;
 };
 export type CreateEnvironmentDefinitionRequestBody2 = {
-    from: From1;
+    from: From;
     labels?: {
         [k: string]: string;
     } | undefined;
@@ -82,11 +58,11 @@ export type CreateEnvironmentDefinitionRequestBody1 = {
     name?: string | undefined;
     version?: number | undefined;
 };
-export type CreateEnvironmentDefinitionRequestBody = CreateEnvironmentDefinitionRequestBody1 | CreateEnvironmentDefinitionRequestBody2 | CreateEnvironmentDefinitionRequestBody3;
+export type CreateEnvironmentDefinitionRequestBody = CreateEnvironmentDefinitionRequestBody1 | CreateEnvironmentDefinitionRequestBody2;
 export type CreateEnvironmentDefinitionRequest = {
     workspaceId: string;
     idempotencyKey: string;
-    body: CreateEnvironmentDefinitionRequestBody1 | CreateEnvironmentDefinitionRequestBody2 | CreateEnvironmentDefinitionRequestBody3;
+    body: CreateEnvironmentDefinitionRequestBody1 | CreateEnvironmentDefinitionRequestBody2;
 };
 /**
  * Environment accepted from its setup definition
@@ -95,63 +71,15 @@ export type CreateEnvironmentDefinitionResponse = {
     data: models.Environment;
 };
 /** @internal */
-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 = {
+export type From$Outbound = {
     snapshot: string;
 };
 /** @internal */
-export declare const From1$outboundSchema: z.ZodMiniType<From1$Outbound, From1>;
-export declare function from1ToJSON(from1: From1): string;
+export declare const From$outboundSchema: z.ZodMiniType<From$Outbound, From>;
+export declare function fromToJSON(from: From): string;
 /** @internal */
 export type CreateEnvironmentDefinitionRequestBody2$Outbound = {
-    from: From1$Outbound;
+    from: From$Outbound;
     labels?: {
         [k: string]: string;
     } | undefined;
@@ -207,7 +135,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 | CreateEnvironmentDefinitionRequestBody3$Outbound;
+export type CreateEnvironmentDefinitionRequestBody$Outbound = CreateEnvironmentDefinitionRequestBody1$Outbound | CreateEnvironmentDefinitionRequestBody2$Outbound;
 /** @internal */
 export declare const CreateEnvironmentDefinitionRequestBody$outboundSchema: z.ZodMiniType<CreateEnvironmentDefinitionRequestBody$Outbound, CreateEnvironmentDefinitionRequestBody>;
 export declare function createEnvironmentDefinitionRequestBodyToJSON(createEnvironmentDefinitionRequestBody: CreateEnvironmentDefinitionRequestBody): string;
@@ -215,7 +143,7 @@ export declare function createEnvironmentDefinitionRequestBodyToJSON(createEnvir
 export type CreateEnvironmentDefinitionRequest$Outbound = {
     workspaceId: string;
     "idempotency-key": string;
-    body: CreateEnvironmentDefinitionRequestBody1$Outbound | CreateEnvironmentDefinitionRequestBody2$Outbound | CreateEnvironmentDefinitionRequestBody3$Outbound;
+    body: CreateEnvironmentDefinitionRequestBody1$Outbound | CreateEnvironmentDefinitionRequestBody2$Outbound;
 };
 /** @internal */
 export declare const CreateEnvironmentDefinitionRequest$outboundSchema: z.ZodMiniType<CreateEnvironmentDefinitionRequest$Outbound, CreateEnvironmentDefinitionRequest>;

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

@@ -7,69 +7,15 @@ import { safeParse } from "../../lib/schemas.js";
 import { smartUnion } from "../../types/smart-union.js";
 import * as models from "../index.js";
 /** @internal */
-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({
+export const From$outboundSchema = z.object({
     snapshot: z.string(),
 });
-export function from1ToJSON(from1) {
-    return JSON.stringify(From1$outboundSchema.parse(from1));
+export function fromToJSON(from) {
+    return JSON.stringify(From$outboundSchema.parse(from));
 }
 /** @internal */
 export const CreateEnvironmentDefinitionRequestBody2$outboundSchema = z.object({
-    from: z.lazy(() => From1$outboundSchema),
+    from: z.lazy(() => From$outboundSchema),
     labels: z.optional(z.record(z.string(), z.string())),
     lifetimeMinutes: z.optional(z.int()),
     name: z.optional(z.string()),
@@ -118,7 +64,6 @@ 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));
@@ -130,7 +75,6 @@ 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/get-environment-request-payload.d.ts

@@ -0,0 +1,23 @@
+import * as z from "zod/v4-mini";
+import { ClosedEnum } from "../../types/enums.js";
+export declare const Direction: {
+    readonly Request: "request";
+    readonly Response: "response";
+};
+export type Direction = ClosedEnum<typeof Direction>;
+export type GetEnvironmentRequestPayloadRequest = {
+    environmentId: string;
+    requestId: string;
+    direction: Direction;
+};
+/** @internal */
+export declare const Direction$outboundSchema: z.ZodMiniEnum<typeof Direction>;
+/** @internal */
+export type GetEnvironmentRequestPayloadRequest$Outbound = {
+    environmentId: string;
+    requestId: string;
+    direction: string;
+};
+/** @internal */
+export declare const GetEnvironmentRequestPayloadRequest$outboundSchema: z.ZodMiniType<GetEnvironmentRequestPayloadRequest$Outbound, GetEnvironmentRequestPayloadRequest>;
+export declare function getEnvironmentRequestPayloadRequestToJSON(getEnvironmentRequestPayloadRequest: GetEnvironmentRequestPayloadRequest): string;

package/esm/models/operations/get-environment-request-payload.js

@@ -0,0 +1,19 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4-mini";
+export const Direction = {
+    Request: "request",
+    Response: "response",
+};
+/** @internal */
+export const Direction$outboundSchema = z.enum(Direction);
+/** @internal */
+export const GetEnvironmentRequestPayloadRequest$outboundSchema = z.object({
+    environmentId: z.string(),
+    requestId: z.string(),
+    direction: Direction$outboundSchema,
+});
+export function getEnvironmentRequestPayloadRequestToJSON(getEnvironmentRequestPayloadRequest) {
+    return JSON.stringify(GetEnvironmentRequestPayloadRequest$outboundSchema.parse(getEnvironmentRequestPayloadRequest));
+}

package/esm/models/operations/get-environment-request-stats.d.ts

@@ -0,0 +1,70 @@
+import * as z from "zod/v4-mini";
+import { ClosedEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdk-validation-error.js";
+import * as models from "../index.js";
+export declare const GetEnvironmentRequestStatsStatusClass: {
+    readonly Twoxx: "2xx";
+    readonly Threexx: "3xx";
+    readonly Fourxx: "4xx";
+    readonly Fivexx: "5xx";
+};
+export type GetEnvironmentRequestStatsStatusClass = ClosedEnum<typeof GetEnvironmentRequestStatsStatusClass>;
+export declare const GetEnvironmentRequestStatsMethod: {
+    readonly Get: "GET";
+    readonly Head: "HEAD";
+    readonly Post: "POST";
+    readonly Put: "PUT";
+    readonly Patch: "PATCH";
+    readonly Delete: "DELETE";
+    readonly Options: "OPTIONS";
+    readonly Connect: "CONNECT";
+    readonly Trace: "TRACE";
+};
+export type GetEnvironmentRequestStatsMethod = ClosedEnum<typeof GetEnvironmentRequestStatsMethod>;
+export declare const GetEnvironmentRequestStatsWritesOnly: {
+    readonly True: "true";
+    readonly False: "false";
+};
+export type GetEnvironmentRequestStatsWritesOnly = ClosedEnum<typeof GetEnvironmentRequestStatsWritesOnly>;
+export type GetEnvironmentRequestStatsRequest = {
+    environmentId: string;
+    appKey?: string | undefined;
+    status?: number | undefined;
+    statusClass?: GetEnvironmentRequestStatsStatusClass | undefined;
+    method?: GetEnvironmentRequestStatsMethod | undefined;
+    search?: string | undefined;
+    writesOnly?: GetEnvironmentRequestStatsWritesOnly | undefined;
+    from: Date;
+    to: Date;
+};
+/**
+ * Recorded request statistics across the selected time window
+ */
+export type GetEnvironmentRequestStatsResponse = {
+    data: models.EnvironmentRequestStats;
+};
+/** @internal */
+export declare const GetEnvironmentRequestStatsStatusClass$outboundSchema: z.ZodMiniEnum<typeof GetEnvironmentRequestStatsStatusClass>;
+/** @internal */
+export declare const GetEnvironmentRequestStatsMethod$outboundSchema: z.ZodMiniEnum<typeof GetEnvironmentRequestStatsMethod>;
+/** @internal */
+export declare const GetEnvironmentRequestStatsWritesOnly$outboundSchema: z.ZodMiniEnum<typeof GetEnvironmentRequestStatsWritesOnly>;
+/** @internal */
+export type GetEnvironmentRequestStatsRequest$Outbound = {
+    environmentId: string;
+    appKey?: string | undefined;
+    status?: number | undefined;
+    statusClass?: string | undefined;
+    method?: string | undefined;
+    search?: string | undefined;
+    writesOnly?: string | undefined;
+    from: string;
+    to: string;
+};
+/** @internal */
+export declare const GetEnvironmentRequestStatsRequest$outboundSchema: z.ZodMiniType<GetEnvironmentRequestStatsRequest$Outbound, GetEnvironmentRequestStatsRequest>;
+export declare function getEnvironmentRequestStatsRequestToJSON(getEnvironmentRequestStatsRequest: GetEnvironmentRequestStatsRequest): string;
+/** @internal */
+export declare const GetEnvironmentRequestStatsResponse$inboundSchema: z.ZodMiniType<GetEnvironmentRequestStatsResponse, unknown>;
+export declare function getEnvironmentRequestStatsResponseFromJSON(jsonString: string): SafeParseResult<GetEnvironmentRequestStatsResponse, SDKValidationError>;

package/esm/models/operations/get-environment-request-stats.js

@@ -0,0 +1,55 @@
+/*
+ * 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";
+export const GetEnvironmentRequestStatsStatusClass = {
+    Twoxx: "2xx",
+    Threexx: "3xx",
+    Fourxx: "4xx",
+    Fivexx: "5xx",
+};
+export const GetEnvironmentRequestStatsMethod = {
+    Get: "GET",
+    Head: "HEAD",
+    Post: "POST",
+    Put: "PUT",
+    Patch: "PATCH",
+    Delete: "DELETE",
+    Options: "OPTIONS",
+    Connect: "CONNECT",
+    Trace: "TRACE",
+};
+export const GetEnvironmentRequestStatsWritesOnly = {
+    True: "true",
+    False: "false",
+};
+/** @internal */
+export const GetEnvironmentRequestStatsStatusClass$outboundSchema = z.enum(GetEnvironmentRequestStatsStatusClass);
+/** @internal */
+export const GetEnvironmentRequestStatsMethod$outboundSchema = z.enum(GetEnvironmentRequestStatsMethod);
+/** @internal */
+export const GetEnvironmentRequestStatsWritesOnly$outboundSchema = z.enum(GetEnvironmentRequestStatsWritesOnly);
+/** @internal */
+export const GetEnvironmentRequestStatsRequest$outboundSchema = z.object({
+    environmentId: z.string(),
+    appKey: z.optional(z.string()),
+    status: z.optional(z.int()),
+    statusClass: z.optional(GetEnvironmentRequestStatsStatusClass$outboundSchema),
+    method: z.optional(GetEnvironmentRequestStatsMethod$outboundSchema),
+    search: z.optional(z.string()),
+    writesOnly: z.optional(GetEnvironmentRequestStatsWritesOnly$outboundSchema),
+    from: z.pipe(z.date(), z.transform(v => v.toISOString())),
+    to: z.pipe(z.date(), z.transform(v => v.toISOString())),
+});
+export function getEnvironmentRequestStatsRequestToJSON(getEnvironmentRequestStatsRequest) {
+    return JSON.stringify(GetEnvironmentRequestStatsRequest$outboundSchema.parse(getEnvironmentRequestStatsRequest));
+}
+/** @internal */
+export const GetEnvironmentRequestStatsResponse$inboundSchema = z.object({
+    data: models.EnvironmentRequestStats$inboundSchema,
+});
+export function getEnvironmentRequestStatsResponseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => GetEnvironmentRequestStatsResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'GetEnvironmentRequestStatsResponse' from JSON`);
+}

package/esm/models/operations/get-environment-request.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 GetEnvironmentRequestRequest = {
+    environmentId: string;
+    requestId: string;
+};
+/**
+ * Recorded request with bounded payload previews
+ */
+export type GetEnvironmentRequestResponse = {
+    data: models.EnvironmentRequestDetail;
+};
+/** @internal */
+export type GetEnvironmentRequestRequest$Outbound = {
+    environmentId: string;
+    requestId: string;
+};
+/** @internal */
+export declare const GetEnvironmentRequestRequest$outboundSchema: z.ZodMiniType<GetEnvironmentRequestRequest$Outbound, GetEnvironmentRequestRequest>;
+export declare function getEnvironmentRequestRequestToJSON(getEnvironmentRequestRequest: GetEnvironmentRequestRequest): string;
+/** @internal */
+export declare const GetEnvironmentRequestResponse$inboundSchema: z.ZodMiniType<GetEnvironmentRequestResponse, unknown>;
+export declare function getEnvironmentRequestResponseFromJSON(jsonString: string): SafeParseResult<GetEnvironmentRequestResponse, SDKValidationError>;

package/esm/models/operations/get-environment-request.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 GetEnvironmentRequestRequest$outboundSchema = z.object({
+    environmentId: z.string(),
+    requestId: z.string(),
+});
+export function getEnvironmentRequestRequestToJSON(getEnvironmentRequestRequest) {
+    return JSON.stringify(GetEnvironmentRequestRequest$outboundSchema.parse(getEnvironmentRequestRequest));
+}
+/** @internal */
+export const GetEnvironmentRequestResponse$inboundSchema = z.object({
+    data: models.EnvironmentRequestDetail$inboundSchema,
+});
+export function getEnvironmentRequestResponseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => GetEnvironmentRequestResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'GetEnvironmentRequestResponse' from JSON`);
+}

package/esm/models/operations/index.d.ts

@@ -5,14 +5,15 @@ 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-request-payload.js";
+export * from "./get-environment-request-stats.js";
+export * from "./get-environment-request.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-environment-requests.js";
 export * from "./list-environments.js";
 export * from "./list-snapshots.js";
 export * from "./list-workspace-events.js";

package/esm/models/operations/index.js

@@ -8,14 +8,15 @@ 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-request-payload.js";
+export * from "./get-environment-request-stats.js";
+export * from "./get-environment-request.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-environment-requests.js";
 export * from "./list-environments.js";
 export * from "./list-snapshots.js";
 export * from "./list-workspace-events.js";

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

@@ -0,0 +1,75 @@
+import * as z from "zod/v4-mini";
+import { ClosedEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdk-validation-error.js";
+import * as models from "../index.js";
+export declare const ListEnvironmentRequestsStatusClass: {
+    readonly Twoxx: "2xx";
+    readonly Threexx: "3xx";
+    readonly Fourxx: "4xx";
+    readonly Fivexx: "5xx";
+};
+export type ListEnvironmentRequestsStatusClass = ClosedEnum<typeof ListEnvironmentRequestsStatusClass>;
+export declare const ListEnvironmentRequestsMethod: {
+    readonly Get: "GET";
+    readonly Head: "HEAD";
+    readonly Post: "POST";
+    readonly Put: "PUT";
+    readonly Patch: "PATCH";
+    readonly Delete: "DELETE";
+    readonly Options: "OPTIONS";
+    readonly Connect: "CONNECT";
+    readonly Trace: "TRACE";
+};
+export type ListEnvironmentRequestsMethod = ClosedEnum<typeof ListEnvironmentRequestsMethod>;
+export declare const ListEnvironmentRequestsWritesOnly: {
+    readonly True: "true";
+    readonly False: "false";
+};
+export type ListEnvironmentRequestsWritesOnly = ClosedEnum<typeof ListEnvironmentRequestsWritesOnly>;
+export type ListEnvironmentRequestsRequest = {
+    environmentId: string;
+    limit?: number | undefined;
+    cursor?: string | undefined;
+    appKey?: string | undefined;
+    status?: number | undefined;
+    statusClass?: ListEnvironmentRequestsStatusClass | undefined;
+    method?: ListEnvironmentRequestsMethod | undefined;
+    search?: string | undefined;
+    writesOnly?: ListEnvironmentRequestsWritesOnly | undefined;
+    from?: Date | undefined;
+    to?: Date | undefined;
+};
+/**
+ * Best-effort recorded replica requests, newest first
+ */
+export type ListEnvironmentRequestsResponse = {
+    data: Array<models.EnvironmentRequest>;
+    nextCursor: string | null;
+};
+/** @internal */
+export declare const ListEnvironmentRequestsStatusClass$outboundSchema: z.ZodMiniEnum<typeof ListEnvironmentRequestsStatusClass>;
+/** @internal */
+export declare const ListEnvironmentRequestsMethod$outboundSchema: z.ZodMiniEnum<typeof ListEnvironmentRequestsMethod>;
+/** @internal */
+export declare const ListEnvironmentRequestsWritesOnly$outboundSchema: z.ZodMiniEnum<typeof ListEnvironmentRequestsWritesOnly>;
+/** @internal */
+export type ListEnvironmentRequestsRequest$Outbound = {
+    environmentId: string;
+    limit: number;
+    cursor?: string | undefined;
+    appKey?: string | undefined;
+    status?: number | undefined;
+    statusClass?: string | undefined;
+    method?: string | undefined;
+    search?: string | undefined;
+    writesOnly?: string | undefined;
+    from?: string | undefined;
+    to?: string | undefined;
+};
+/** @internal */
+export declare const ListEnvironmentRequestsRequest$outboundSchema: z.ZodMiniType<ListEnvironmentRequestsRequest$Outbound, ListEnvironmentRequestsRequest>;
+export declare function listEnvironmentRequestsRequestToJSON(listEnvironmentRequestsRequest: ListEnvironmentRequestsRequest): string;
+/** @internal */
+export declare const ListEnvironmentRequestsResponse$inboundSchema: z.ZodMiniType<ListEnvironmentRequestsResponse, unknown>;
+export declare function listEnvironmentRequestsResponseFromJSON(jsonString: string): SafeParseResult<ListEnvironmentRequestsResponse, SDKValidationError>;

package/esm/models/operations/list-environment-requests.js

@@ -0,0 +1,59 @@
+/*
+ * 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";
+export const ListEnvironmentRequestsStatusClass = {
+    Twoxx: "2xx",
+    Threexx: "3xx",
+    Fourxx: "4xx",
+    Fivexx: "5xx",
+};
+export const ListEnvironmentRequestsMethod = {
+    Get: "GET",
+    Head: "HEAD",
+    Post: "POST",
+    Put: "PUT",
+    Patch: "PATCH",
+    Delete: "DELETE",
+    Options: "OPTIONS",
+    Connect: "CONNECT",
+    Trace: "TRACE",
+};
+export const ListEnvironmentRequestsWritesOnly = {
+    True: "true",
+    False: "false",
+};
+/** @internal */
+export const ListEnvironmentRequestsStatusClass$outboundSchema = z.enum(ListEnvironmentRequestsStatusClass);
+/** @internal */
+export const ListEnvironmentRequestsMethod$outboundSchema = z.enum(ListEnvironmentRequestsMethod);
+/** @internal */
+export const ListEnvironmentRequestsWritesOnly$outboundSchema = z.enum(ListEnvironmentRequestsWritesOnly);
+/** @internal */
+export const ListEnvironmentRequestsRequest$outboundSchema = z.object({
+    environmentId: z.string(),
+    limit: z._default(z.int(), 50),
+    cursor: z.optional(z.string()),
+    appKey: z.optional(z.string()),
+    status: z.optional(z.int()),
+    statusClass: z.optional(ListEnvironmentRequestsStatusClass$outboundSchema),
+    method: z.optional(ListEnvironmentRequestsMethod$outboundSchema),
+    search: z.optional(z.string()),
+    writesOnly: z.optional(ListEnvironmentRequestsWritesOnly$outboundSchema),
+    from: z.optional(z.pipe(z.date(), z.transform(v => v.toISOString()))),
+    to: z.optional(z.pipe(z.date(), z.transform(v => v.toISOString()))),
+});
+export function listEnvironmentRequestsRequestToJSON(listEnvironmentRequestsRequest) {
+    return JSON.stringify(ListEnvironmentRequestsRequest$outboundSchema.parse(listEnvironmentRequestsRequest));
+}
+/** @internal */
+export const ListEnvironmentRequestsResponse$inboundSchema = z.object({
+    data: z.array(models.EnvironmentRequest$inboundSchema),
+    nextCursor: types.nullable(types.string()),
+});
+export function listEnvironmentRequestsResponseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ListEnvironmentRequestsResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ListEnvironmentRequestsResponse' from JSON`);
+}

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

@@ -4,6 +4,7 @@ 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
@@ -14,6 +15,7 @@ export type ResumeEnvironmentResponse = {
 /** @internal */
 export type ResumeEnvironmentRequest$Outbound = {
     environmentId: string;
+    "idempotency-key"?: string | undefined;
 };
 /** @internal */
 export declare const ResumeEnvironmentRequest$outboundSchema: z.ZodMiniType<ResumeEnvironmentRequest$Outbound, ResumeEnvironmentRequest>;

package/esm/models/operations/resume-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 ResumeEnvironmentRequest$outboundSchema = z.object({
+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));
 }