@usestatemachines/sdk 0.3.0 → 0.5.0

package/esm/funcs/environments-get-request.js

@@ -0,0 +1,96 @@
+/*
+ * 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 environmentsGetRequest(client, request, options) {
+    return new APIPromise($do(client, request, options));
+}
+async function $do(client, request, options) {
+    const parsed = safeParse(request, (value) => z.parse(operations.GetEnvironmentRequestRequest$outboundSchema, value), "Input validation failed");
+    if (!parsed.ok) {
+        return [parsed, { status: "invalid" }];
+    }
+    const payload = parsed.value;
+    const body = null;
+    const pathParams = {
+        environmentId: encodeSimple("environmentId", payload.environmentId, {
+            explode: false,
+            charEncoding: "percent",
+        }),
+        requestId: encodeSimple("requestId", payload.requestId, {
+            explode: false,
+            charEncoding: "percent",
+        }),
+    };
+    const path = pathToFunc("/v1/environments/{environmentId}/requests/{requestId}")(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: "getEnvironmentRequest",
+        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.GetEnvironmentRequestResponse$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/environments-list-requests.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 environmentsListRequests(client: StateMachinesCore, request: operations.ListEnvironmentRequestsRequest, options?: RequestOptions): APIPromise<Result<operations.ListEnvironmentRequestsResponse, errors.ErrorResponse | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;

package/esm/funcs/environments-list-requests.js

@@ -0,0 +1,105 @@
+/*
+ * 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 environmentsListRequests(client, request, options) {
+    return new APIPromise($do(client, request, options));
+}
+async function $do(client, request, options) {
+    const parsed = safeParse(request, (value) => z.parse(operations.ListEnvironmentRequestsRequest$outboundSchema, value), "Input validation failed");
+    if (!parsed.ok) {
+        return [parsed, { status: "invalid" }];
+    }
+    const payload = parsed.value;
+    const body = null;
+    const pathParams = {
+        environmentId: encodeSimple("environmentId", payload.environmentId, {
+            explode: false,
+            charEncoding: "percent",
+        }),
+    };
+    const path = pathToFunc("/v1/environments/{environmentId}/requests")(pathParams);
+    const query = encodeFormQuery({
+        "appKey": payload.appKey,
+        "cursor": payload.cursor,
+        "from": payload.from,
+        "limit": payload.limit,
+        "method": payload.method,
+        "search": payload.search,
+        "status": payload.status,
+        "statusClass": payload.statusClass,
+        "to": payload.to,
+        "writesOnly": payload.writesOnly,
+    });
+    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: "listEnvironmentRequests",
+        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.ListEnvironmentRequestsResponse$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/environments-resume.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 environmentsResume(client: StateMachinesCore, request: operations.ResumeEnvironmentRequest, options?: RequestOptions): APIPromise<Result<operations.ResumeEnvironmentResponse, errors.ErrorResponse | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;

package/esm/funcs/environments-resume.js

@@ -0,0 +1,93 @@
+/*
+ * 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 environmentsResume(client, request, options) {
+    return new APIPromise($do(client, request, options));
+}
+async function $do(client, request, options) {
+    const parsed = safeParse(request, (value) => z.parse(operations.ResumeEnvironmentRequest$outboundSchema, value), "Input validation failed");
+    if (!parsed.ok) {
+        return [parsed, { status: "invalid" }];
+    }
+    const payload = parsed.value;
+    const body = null;
+    const pathParams = {
+        environmentId: encodeSimple("environmentId", payload.environmentId, {
+            explode: false,
+            charEncoding: "percent",
+        }),
+    };
+    const path = pathToFunc("/v1/environments/{environmentId}/resume")(pathParams);
+    const headers = new Headers(compactMap({
+        Accept: "application/json",
+        "idempotency-key": encodeSimple("idempotency-key", payload["idempotency-key"], { explode: false, charEncoding: "none" }),
+    }));
+    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: "resumeEnvironment",
+        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: "POST",
+        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.ResumeEnvironmentResponse$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/environments-stop.js

@@ -31,6 +31,7 @@ async function $do(client, request, options) {
     const path = pathToFunc("/v1/environments/{environmentId}/stop")(pathParams);
     const headers = new Headers(compactMap({
         Accept: "application/json",
+        "idempotency-key": encodeSimple("idempotency-key", payload["idempotency-key"], { explode: false, charEncoding: "none" }),
     }));
     const secConfig = await extractSecurity(client._options.apiKey);
     const securityInput = secConfig == null ? {} : { apiKey: secConfig };

package/esm/funcs/environments-suspend.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 environmentsSuspend(client: StateMachinesCore, request: operations.SuspendEnvironmentRequest, options?: RequestOptions): APIPromise<Result<operations.SuspendEnvironmentResponse, errors.ErrorResponse | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;

package/esm/funcs/environments-suspend.js

@@ -0,0 +1,93 @@
+/*
+ * 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 environmentsSuspend(client, request, options) {
+    return new APIPromise($do(client, request, options));
+}
+async function $do(client, request, options) {
+    const parsed = safeParse(request, (value) => z.parse(operations.SuspendEnvironmentRequest$outboundSchema, value), "Input validation failed");
+    if (!parsed.ok) {
+        return [parsed, { status: "invalid" }];
+    }
+    const payload = parsed.value;
+    const body = null;
+    const pathParams = {
+        environmentId: encodeSimple("environmentId", payload.environmentId, {
+            explode: false,
+            charEncoding: "percent",
+        }),
+    };
+    const path = pathToFunc("/v1/environments/{environmentId}/suspend")(pathParams);
+    const headers = new Headers(compactMap({
+        Accept: "application/json",
+        "idempotency-key": encodeSimple("idempotency-key", payload["idempotency-key"], { explode: false, charEncoding: "none" }),
+    }));
+    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: "suspendEnvironment",
+        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: "POST",
+        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.SuspendEnvironmentResponse$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.3.0";
+    readonly sdkVersion: "0.5.0";
     readonly genVersion: "2.941.0";
-    readonly userAgent: "speakeasy-sdk/typescript 0.3.0 2.941.0 1.0.0 @usestatemachines/sdk";
+    readonly userAgent: "speakeasy-sdk/typescript 0.5.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.3.0",
+    sdkVersion: "0.5.0",
     genVersion: "2.941.0",
-    userAgent: "speakeasy-sdk/typescript 0.3.0 2.941.0 1.0.0 @usestatemachines/sdk",
+    userAgent: "speakeasy-sdk/typescript 0.5.0 2.941.0 1.0.0 @usestatemachines/sdk",
 };

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

@@ -13,6 +13,8 @@ export declare const EnvironmentAppStatus: {
     readonly Pending: "pending";
     readonly Starting: "starting";
     readonly Ready: "ready";
+    readonly Recovering: "recovering";
+    readonly Suspended: "suspended";
     readonly Stopping: "stopping";
     readonly Stopped: "stopped";
     readonly Failed: "failed";

package/esm/models/environment-app.js

@@ -15,6 +15,8 @@ export const EnvironmentAppStatus = {
     Pending: "pending",
     Starting: "starting",
     Ready: "ready",
+    Recovering: "recovering",
+    Suspended: "suspended",
     Stopping: "stopping",
     Stopped: "stopped",
     Failed: "failed",

package/esm/models/environment-request-detail.d.ts

@@ -0,0 +1,40 @@
+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";
+import { RequestPayloadPreview } from "./request-payload-preview.js";
+export declare const EnvironmentRequestDetailOutcome: {
+    readonly ReplicaResponse: "replica_response";
+    readonly GatewayError: "gateway_error";
+};
+export type EnvironmentRequestDetailOutcome = OpenEnum<typeof EnvironmentRequestDetailOutcome>;
+export type EnvironmentRequestDetail = {
+    appInstanceId: string | null;
+    appKey: string;
+    completedAt: Date;
+    durationMs: number;
+    environmentId: string;
+    errorCode: string | null;
+    id: string;
+    method: string;
+    outcome: EnvironmentRequestDetailOutcome;
+    path: string;
+    query: string;
+    receivedAt: Date;
+    requestBytes: number | null;
+    responseBytes: number | null;
+    status: number;
+    requestBody: RequestPayloadPreview;
+    requestHeaders: {
+        [k: string]: string;
+    };
+    responseBody: RequestPayloadPreview;
+    responseHeaders: {
+        [k: string]: string;
+    };
+};
+/** @internal */
+export declare const EnvironmentRequestDetailOutcome$inboundSchema: z.ZodMiniType<EnvironmentRequestDetailOutcome, unknown>;
+/** @internal */
+export declare const EnvironmentRequestDetail$inboundSchema: z.ZodMiniType<EnvironmentRequestDetail, unknown>;
+export declare function environmentRequestDetailFromJSON(jsonString: string): SafeParseResult<EnvironmentRequestDetail, SDKValidationError>;

package/esm/models/environment-request-detail.js

@@ -0,0 +1,39 @@
+/*
+ * 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 { RequestPayloadPreview$inboundSchema, } from "./request-payload-preview.js";
+export const EnvironmentRequestDetailOutcome = {
+    ReplicaResponse: "replica_response",
+    GatewayError: "gateway_error",
+};
+/** @internal */
+export const EnvironmentRequestDetailOutcome$inboundSchema = openEnums.inboundSchema(EnvironmentRequestDetailOutcome);
+/** @internal */
+export const EnvironmentRequestDetail$inboundSchema = z.object({
+    appInstanceId: types.nullable(types.string()),
+    appKey: types.string(),
+    completedAt: types.date(),
+    durationMs: types.number(),
+    environmentId: types.string(),
+    errorCode: types.nullable(types.string()),
+    id: types.string(),
+    method: types.string(),
+    outcome: EnvironmentRequestDetailOutcome$inboundSchema,
+    path: types.string(),
+    query: types.string(),
+    receivedAt: types.date(),
+    requestBytes: types.nullable(types.number()),
+    responseBytes: types.nullable(types.number()),
+    status: types.number(),
+    requestBody: RequestPayloadPreview$inboundSchema,
+    requestHeaders: z.record(z.string(), types.string()),
+    responseBody: RequestPayloadPreview$inboundSchema,
+    responseHeaders: z.record(z.string(), types.string()),
+});
+export function environmentRequestDetailFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => EnvironmentRequestDetail$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'EnvironmentRequestDetail' from JSON`);
+}

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

@@ -0,0 +1,26 @@
+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 Bucket = {
+    clientError: number;
+    from: Date;
+    serverError: number;
+    success: number;
+};
+export type EnvironmentRequestStats = {
+    buckets: Array<Bucket>;
+    clientErrorCount: number;
+    count: number;
+    from: Date;
+    p50Ms: number | null;
+    p95Ms: number | null;
+    serverErrorCount: number;
+    successCount: number;
+    to: Date;
+};
+/** @internal */
+export declare const Bucket$inboundSchema: z.ZodMiniType<Bucket, unknown>;
+export declare function bucketFromJSON(jsonString: string): SafeParseResult<Bucket, SDKValidationError>;
+/** @internal */
+export declare const EnvironmentRequestStats$inboundSchema: z.ZodMiniType<EnvironmentRequestStats, unknown>;
+export declare function environmentRequestStatsFromJSON(jsonString: string): SafeParseResult<EnvironmentRequestStats, SDKValidationError>;

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

@@ -0,0 +1,31 @@
+/*
+ * 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 Bucket$inboundSchema = z.object({
+    clientError: types.number(),
+    from: types.date(),
+    serverError: types.number(),
+    success: types.number(),
+});
+export function bucketFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Bucket$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Bucket' from JSON`);
+}
+/** @internal */
+export const EnvironmentRequestStats$inboundSchema = z.object({
+    buckets: z.array(z.lazy(() => Bucket$inboundSchema)),
+    clientErrorCount: types.number(),
+    count: types.number(),
+    from: types.date(),
+    p50Ms: types.nullable(types.number()),
+    p95Ms: types.nullable(types.number()),
+    serverErrorCount: types.number(),
+    successCount: types.number(),
+    to: types.date(),
+});
+export function environmentRequestStatsFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => EnvironmentRequestStats$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'EnvironmentRequestStats' from JSON`);
+}

package/esm/models/environment-request.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 EnvironmentRequestOutcome: {
+    readonly ReplicaResponse: "replica_response";
+    readonly GatewayError: "gateway_error";
+};
+export type EnvironmentRequestOutcome = OpenEnum<typeof EnvironmentRequestOutcome>;
+export type EnvironmentRequest = {
+    appInstanceId: string | null;
+    appKey: string;
+    completedAt: Date;
+    durationMs: number;
+    environmentId: string;
+    errorCode: string | null;
+    id: string;
+    method: string;
+    outcome: EnvironmentRequestOutcome;
+    path: string;
+    query: string;
+    receivedAt: Date;
+    requestBytes: number | null;
+    responseBytes: number | null;
+    status: number;
+};
+/** @internal */
+export declare const EnvironmentRequestOutcome$inboundSchema: z.ZodMiniType<EnvironmentRequestOutcome, unknown>;
+/** @internal */
+export declare const EnvironmentRequest$inboundSchema: z.ZodMiniType<EnvironmentRequest, unknown>;
+export declare function environmentRequestFromJSON(jsonString: string): SafeParseResult<EnvironmentRequest, SDKValidationError>;