@usestatemachines/sdk 0.5.0 → 0.6.0

package/esm/funcs/environments-create.js

@@ -10,25 +10,20 @@ 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 models from "../models/index.js";
 import * as operations from "../models/operations/index.js";
 import { APIPromise } from "../types/async.js";
 export function environmentsCreate(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => z.parse(operations.CreateEnvironmentsRequest$outboundSchema, value), "Input validation failed");
+    const parsed = safeParse(request, (value) => z.parse(operations.CreateEnvironmentRequest$outboundSchema, value), "Input validation failed");
     if (!parsed.ok) {
         return [parsed, { status: "invalid" }];
     }
     const payload = parsed.value;
     const body = encodeJSON("body", payload.body, { explode: true });
-    const pathParams = {
-        workspaceId: encodeSimple("workspaceId", payload.workspaceId, {
-            explode: false,
-            charEncoding: "percent",
-        }),
-    };
-    const path = pathToFunc("/v1/workspaces/{workspaceId}/environments")(pathParams);
+    const path = pathToFunc("/v1/environments")();
     const headers = new Headers(compactMap({
         "Content-Type": "application/json",
         Accept: "application/json",
@@ -40,7 +35,7 @@ async function $do(client, request, options) {
     const context = {
         options: client._options,
         baseURL: options?.serverURL ?? client._baseURL ?? "",
-        operationID: "createEnvironments",
+        operationID: "createEnvironment",
         oAuth2Scopes: null,
         resolvedSecurity: requestSecurity,
         securitySource: client._options.apiKey,
@@ -86,7 +81,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(202, operations.CreateEnvironmentsResponse$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 });
+    const [result] = await M.match(M.json([200, 202], models.Environment$inboundSchema), M.jsonErr([400, 401, 403, 404, 409, 413, 422, 429], errors.ErrorT$inboundSchema), M.jsonErr([500, 503], errors.ErrorT$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/funcs/{environments-events.d.ts → environments-delete.d.ts}

@@ -9,4 +9,4 @@ import * as models from "../models/index.js";
 import * as operations from "../models/operations/index.js";
 import { APIPromise } from "../types/async.js";
 import { Result } from "../types/fp.js";
-export declare function environmentsEvents(client: StateMachinesCore, request: operations.ListEnvironmentEventsRequest, options?: RequestOptions): APIPromise<Result<models.EventPage, errors.ErrorResponse | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+export declare function environmentsDelete(client: StateMachinesCore, request: operations.DeleteEnvironmentRequest, options?: RequestOptions): APIPromise<Result<models.Environment, errors.ErrorT | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;

package/esm/funcs/{environments-stop.js → environments-delete.js}

@@ -10,13 +10,14 @@ 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 models from "../models/index.js";
 import * as operations from "../models/operations/index.js";
 import { APIPromise } from "../types/async.js";
-export function environmentsStop(client, request, options) {
+export function environmentsDelete(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => z.parse(operations.StopEnvironmentRequest$outboundSchema, value), "Input validation failed");
+    const parsed = safeParse(request, (value) => z.parse(operations.DeleteEnvironmentRequest$outboundSchema, value), "Input validation failed");
     if (!parsed.ok) {
         return [parsed, { status: "invalid" }];
     }
@@ -28,7 +29,7 @@ async function $do(client, request, options) {
             charEncoding: "percent",
         }),
     };
-    const path = pathToFunc("/v1/environments/{environmentId}/stop")(pathParams);
+    const path = pathToFunc("/v1/environments/{environmentId}")(pathParams);
     const headers = new Headers(compactMap({
         Accept: "application/json",
         "idempotency-key": encodeSimple("idempotency-key", payload["idempotency-key"], { explode: false, charEncoding: "none" }),
@@ -39,7 +40,7 @@ async function $do(client, request, options) {
     const context = {
         options: client._options,
         baseURL: options?.serverURL ?? client._baseURL ?? "",
-        operationID: "stopEnvironment",
+        operationID: "deleteEnvironment",
         oAuth2Scopes: null,
         resolvedSecurity: requestSecurity,
         securitySource: client._options.apiKey,
@@ -60,7 +61,7 @@ async function $do(client, request, options) {
     };
     const requestRes = client._createRequest(context, {
         security: requestSecurity,
-        method: "POST",
+        method: "DELETE",
         baseURL: options?.serverURL,
         path: path,
         headers: headers,
@@ -85,7 +86,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, operations.StopEnvironmentResponse$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 });
+    const [result] = await M.match(M.json(200, models.Environment$inboundSchema), M.jsonErr([400, 401, 403, 404, 409, 413, 422, 429], errors.ErrorT$inboundSchema), M.jsonErr([500, 503], errors.ErrorT$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/funcs/environments-get.d.ts

@@ -5,7 +5,8 @@ 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 models from "../models/index.js";
 import * as operations from "../models/operations/index.js";
 import { APIPromise } from "../types/async.js";
 import { Result } from "../types/fp.js";
-export declare function environmentsGet(client: StateMachinesCore, request: operations.GetEnvironmentRequest, options?: RequestOptions): APIPromise<Result<operations.GetEnvironmentResponse, errors.ErrorResponse | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+export declare function environmentsGet(client: StateMachinesCore, request: operations.GetEnvironmentRequest, options?: RequestOptions): APIPromise<Result<models.Environment, errors.ErrorT | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;

package/esm/funcs/environments-get.js

@@ -10,6 +10,7 @@ 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 models from "../models/index.js";
 import * as operations from "../models/operations/index.js";
 import { APIPromise } from "../types/async.js";
 export function environmentsGet(client, request, options) {
@@ -84,7 +85,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, operations.GetEnvironmentResponse$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 });
+    const [result] = await M.match(M.json(200, models.Environment$inboundSchema), M.jsonErr([400, 401, 403, 404, 409, 413, 422, 429], errors.ErrorT$inboundSchema), M.jsonErr([500, 503], errors.ErrorT$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/funcs/environments-list.d.ts

@@ -8,4 +8,4 @@ import { StateMachinesHTTPError } from "../models/errors/state-machines-http-err
 import * as operations from "../models/operations/index.js";
 import { APIPromise } from "../types/async.js";
 import { Result } from "../types/fp.js";
-export declare function environmentsList(client: StateMachinesCore, request: operations.ListEnvironmentsRequest, options?: RequestOptions): APIPromise<Result<operations.ListEnvironmentsResponse, errors.ErrorResponse | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+export declare function environmentsList(client: StateMachinesCore, request?: operations.ListEnvironmentsRequest | undefined, options?: RequestOptions): APIPromise<Result<operations.ListEnvironmentsResponse, errors.ErrorT | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;

package/esm/funcs/environments-list.js

@@ -2,7 +2,7 @@
  * 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 { encodeFormQuery } from "../lib/encodings.js";
 import { matchStatusCode } from "../lib/http.js";
 import * as M from "../lib/matchers.js";
 import { compactMap } from "../lib/primitives.js";
@@ -16,26 +16,21 @@ export function environmentsList(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => z.parse(operations.ListEnvironmentsRequest$outboundSchema, value), "Input validation failed");
+    const parsed = safeParse(request, (value) => z.parse(z.optional(operations.ListEnvironmentsRequest$outboundSchema), value), "Input validation failed");
     if (!parsed.ok) {
         return [parsed, { status: "invalid" }];
     }
     const payload = parsed.value;
     const body = null;
-    const pathParams = {
-        workspaceId: encodeSimple("workspaceId", payload.workspaceId, {
-            explode: false,
-            charEncoding: "percent",
-        }),
-    };
-    const path = pathToFunc("/v1/workspaces/{workspaceId}/environments")(pathParams);
+    const path = pathToFunc("/v1/environments")();
     const query = encodeFormQuery({
-        "cursor": payload.cursor,
-        "label": payload.label,
-        "limit": payload.limit,
-        "search": payload.search,
-        "snapshotId": payload.snapshotId,
-        "status": payload.status,
+        "cursor": payload?.cursor,
+        "label": payload?.label,
+        "limit": payload?.limit,
+        "search": payload?.search,
+        "snapshotId": payload?.snapshotId,
+        "status": payload?.status,
+        "workspaceId": payload?.workspaceId,
     });
     const headers = new Headers(compactMap({
         Accept: "application/json",
@@ -93,7 +88,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, operations.ListEnvironmentsResponse$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 });
+    const [result] = await M.match(M.json(200, operations.ListEnvironmentsResponse$inboundSchema), M.jsonErr([400, 401, 403, 404, 409, 413, 422, 429], errors.ErrorT$inboundSchema), M.jsonErr([500, 503], errors.ErrorT$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/funcs/environments-pause.d.ts

@@ -0,0 +1,12 @@
+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 models from "../models/index.js";
+import * as operations from "../models/operations/index.js";
+import { APIPromise } from "../types/async.js";
+import { Result } from "../types/fp.js";
+export declare function environmentsPause(client: StateMachinesCore, request: operations.PauseEnvironmentRequest, options?: RequestOptions): APIPromise<Result<models.Environment, errors.ErrorT | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;

package/esm/funcs/{environments-suspend.js → environments-pause.js}

@@ -10,13 +10,14 @@ 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 models from "../models/index.js";
 import * as operations from "../models/operations/index.js";
 import { APIPromise } from "../types/async.js";
-export function environmentsSuspend(client, request, options) {
+export function environmentsPause(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");
+    const parsed = safeParse(request, (value) => z.parse(operations.PauseEnvironmentRequest$outboundSchema, value), "Input validation failed");
     if (!parsed.ok) {
         return [parsed, { status: "invalid" }];
     }
@@ -28,7 +29,7 @@ async function $do(client, request, options) {
             charEncoding: "percent",
         }),
     };
-    const path = pathToFunc("/v1/environments/{environmentId}/suspend")(pathParams);
+    const path = pathToFunc("/v1/environments/{environmentId}/pause")(pathParams);
     const headers = new Headers(compactMap({
         Accept: "application/json",
         "idempotency-key": encodeSimple("idempotency-key", payload["idempotency-key"], { explode: false, charEncoding: "none" }),
@@ -39,7 +40,7 @@ async function $do(client, request, options) {
     const context = {
         options: client._options,
         baseURL: options?.serverURL ?? client._baseURL ?? "",
-        operationID: "suspendEnvironment",
+        operationID: "pauseEnvironment",
         oAuth2Scopes: null,
         resolvedSecurity: requestSecurity,
         securitySource: client._options.apiKey,
@@ -85,7 +86,7 @@ async function $do(client, request, options) {
     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 });
+    const [result] = await M.match(M.json(200, models.Environment$inboundSchema), M.jsonErr([400, 401, 403, 404, 409, 413, 422, 429], errors.ErrorT$inboundSchema), M.jsonErr([500, 503], errors.ErrorT$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/funcs/environments-resume.d.ts

@@ -5,7 +5,8 @@ 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 models from "../models/index.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>>;
+export declare function environmentsResume(client: StateMachinesCore, request: operations.ResumeEnvironmentRequest, options?: RequestOptions): APIPromise<Result<models.Environment, errors.ErrorT | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;

package/esm/funcs/environments-resume.js

@@ -10,6 +10,7 @@ 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 models from "../models/index.js";
 import * as operations from "../models/operations/index.js";
 import { APIPromise } from "../types/async.js";
 export function environmentsResume(client, request, options) {
@@ -85,7 +86,7 @@ async function $do(client, request, options) {
     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 });
+    const [result] = await M.match(M.json(200, models.Environment$inboundSchema), M.jsonErr([400, 401, 403, 404, 409, 413, 422, 429], errors.ErrorT$inboundSchema), M.jsonErr([500, 503], errors.ErrorT$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/funcs/environments-update.d.ts

@@ -0,0 +1,12 @@
+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 models from "../models/index.js";
+import * as operations from "../models/operations/index.js";
+import { APIPromise } from "../types/async.js";
+import { Result } from "../types/fp.js";
+export declare function environmentsUpdate(client: StateMachinesCore, request: operations.UpdateEnvironmentRequest, options?: RequestOptions): APIPromise<Result<models.Environment, errors.ErrorT | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;

package/esm/funcs/{environments-events.js → environments-update.js}

@@ -2,7 +2,7 @@
  * 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 { encodeJSON, encodeSimple } from "../lib/encodings.js";
 import { matchStatusCode } from "../lib/http.js";
 import * as M from "../lib/matchers.js";
 import { compactMap } from "../lib/primitives.js";
@@ -13,28 +13,25 @@ import * as errors from "../models/errors/index.js";
 import * as models from "../models/index.js";
 import * as operations from "../models/operations/index.js";
 import { APIPromise } from "../types/async.js";
-export function environmentsEvents(client, request, options) {
+export function environmentsUpdate(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => z.parse(operations.ListEnvironmentEventsRequest$outboundSchema, value), "Input validation failed");
+    const parsed = safeParse(request, (value) => z.parse(operations.UpdateEnvironmentRequest$outboundSchema, value), "Input validation failed");
     if (!parsed.ok) {
         return [parsed, { status: "invalid" }];
     }
     const payload = parsed.value;
-    const body = null;
+    const body = encodeJSON("body", payload.body, { explode: true });
     const pathParams = {
         environmentId: encodeSimple("environmentId", payload.environmentId, {
             explode: false,
             charEncoding: "percent",
         }),
     };
-    const path = pathToFunc("/v1/environments/{environmentId}/events")(pathParams);
-    const query = encodeFormQuery({
-        "cursor": payload.cursor,
-        "limit": payload.limit,
-    });
+    const path = pathToFunc("/v1/environments/{environmentId}")(pathParams);
     const headers = new Headers(compactMap({
+        "Content-Type": "application/json",
         Accept: "application/json",
     }));
     const secConfig = await extractSecurity(client._options.apiKey);
@@ -43,7 +40,7 @@ async function $do(client, request, options) {
     const context = {
         options: client._options,
         baseURL: options?.serverURL ?? client._baseURL ?? "",
-        operationID: "listEnvironmentEvents",
+        operationID: "updateEnvironment",
         oAuth2Scopes: null,
         resolvedSecurity: requestSecurity,
         securitySource: client._options.apiKey,
@@ -64,11 +61,10 @@ async function $do(client, request, options) {
     };
     const requestRes = client._createRequest(context, {
         security: requestSecurity,
-        method: "GET",
+        method: "PATCH",
         baseURL: options?.serverURL,
         path: path,
         headers: headers,
-        query: query,
         body: body,
         userAgent: client._options.userAgent,
         timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1,
@@ -90,7 +86,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, models.EventPage$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 });
+    const [result] = await M.match(M.json(200, models.Environment$inboundSchema), M.jsonErr([400, 401, 403, 404, 409, 413, 422, 429], errors.ErrorT$inboundSchema), M.jsonErr([500, 503], errors.ErrorT$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/funcs/me.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 models from "../models/index.js";
+import { APIPromise } from "../types/async.js";
+import { Result } from "../types/fp.js";
+export declare function me(client: StateMachinesCore, options?: RequestOptions): APIPromise<Result<models.Me, errors.ErrorT | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;

package/esm/funcs/{catalog-get.js → me.js}

@@ -7,13 +7,13 @@ import { compactMap } from "../lib/primitives.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 * as models from "../models/index.js";
 import { APIPromise } from "../types/async.js";
-export function catalogGet(client, options) {
+export function me(client, options) {
     return new APIPromise($do(client, options));
 }
 async function $do(client, options) {
-    const path = pathToFunc("/v1/catalog")();
+    const path = pathToFunc("/v1/me")();
     const headers = new Headers(compactMap({
         Accept: "application/json",
     }));
@@ -23,7 +23,7 @@ async function $do(client, options) {
     const context = {
         options: client._options,
         baseURL: options?.serverURL ?? client._baseURL ?? "",
-        operationID: "getCatalog",
+        operationID: "getMe",
         oAuth2Scopes: null,
         resolvedSecurity: requestSecurity,
         securitySource: client._options.apiKey,
@@ -68,7 +68,7 @@ async function $do(client, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, operations.GetCatalogResponse$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 });
+    const [result] = await M.match(M.json(200, models.Me$inboundSchema), M.jsonErr([400, 401, 403, 404, 409, 413, 422, 429], errors.ErrorT$inboundSchema), M.jsonErr([500, 503], errors.ErrorT$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/funcs/{catalog-get.d.ts → requests-body.d.ts}

@@ -8,4 +8,4 @@ import { StateMachinesHTTPError } from "../models/errors/state-machines-http-err
 import * as operations from "../models/operations/index.js";
 import { APIPromise } from "../types/async.js";
 import { Result } from "../types/fp.js";
-export declare function catalogGet(client: StateMachinesCore, options?: RequestOptions): APIPromise<Result<operations.GetCatalogResponse, errors.ErrorResponse | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+export declare function requestsBody(client: StateMachinesCore, request: operations.GetRequestBodyRequest, options?: RequestOptions): APIPromise<Result<ReadableStream<Uint8Array>, errors.ErrorT | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;

package/esm/funcs/{environments-get-request-payload.js → requests-body.js}

@@ -12,11 +12,11 @@ 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 environmentsGetRequestPayload(client, request, options) {
+export function requestsBody(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => z.parse(operations.GetEnvironmentRequestPayloadRequest$outboundSchema, value), "Input validation failed");
+    const parsed = safeParse(request, (value) => z.parse(operations.GetRequestBodyRequest$outboundSchema, value), "Input validation failed");
     if (!parsed.ok) {
         return [parsed, { status: "invalid" }];
     }
@@ -27,16 +27,12 @@ async function $do(client, request, options) {
             explode: false,
             charEncoding: "percent",
         }),
-        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}/payload/{direction}")(pathParams);
+    const path = pathToFunc("/v1/requests/{requestId}/body/{direction}")(pathParams);
     const headers = new Headers(compactMap({
         Accept: "application/octet-stream",
     }));
@@ -46,7 +42,7 @@ async function $do(client, request, options) {
     const context = {
         options: client._options,
         baseURL: options?.serverURL ?? client._baseURL ?? "",
-        operationID: "getEnvironmentRequestPayload",
+        operationID: "getRequestBody",
         oAuth2Scopes: null,
         resolvedSecurity: requestSecurity,
         securitySource: client._options.apiKey,
@@ -92,7 +88,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.stream(200, z.custom(x => x instanceof ReadableStream)), 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 });
+    const [result] = await M.match(M.stream(200, z.custom(x => x instanceof ReadableStream)), M.jsonErr([400, 401, 403, 404, 409, 413, 422, 429], errors.ErrorT$inboundSchema), M.jsonErr([500, 503], errors.ErrorT$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/funcs/{environments-get-request-stats.d.ts → requests-get.d.ts}

@@ -5,7 +5,8 @@ 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 models from "../models/index.js";
 import * as operations from "../models/operations/index.js";
 import { APIPromise } from "../types/async.js";
 import { Result } from "../types/fp.js";
-export declare function environmentsGetRequestStats(client: StateMachinesCore, request: operations.GetEnvironmentRequestStatsRequest, options?: RequestOptions): APIPromise<Result<operations.GetEnvironmentRequestStatsResponse, errors.ErrorResponse | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+export declare function requestsGet(client: StateMachinesCore, request: operations.GetRequestRequest, options?: RequestOptions): APIPromise<Result<models.RequestDetail, errors.ErrorT | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;

package/esm/funcs/{catalog-release.js → requests-get.js}

@@ -10,25 +10,26 @@ 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 models from "../models/index.js";
 import * as operations from "../models/operations/index.js";
 import { APIPromise } from "../types/async.js";
-export function catalogRelease(client, request, options) {
+export function requestsGet(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => z.parse(operations.GetReleaseRequest$outboundSchema, value), "Input validation failed");
+    const parsed = safeParse(request, (value) => z.parse(operations.GetRequestRequest$outboundSchema, value), "Input validation failed");
     if (!parsed.ok) {
         return [parsed, { status: "invalid" }];
     }
     const payload = parsed.value;
     const body = null;
     const pathParams = {
-        releaseId: encodeSimple("releaseId", payload.releaseId, {
+        requestId: encodeSimple("requestId", payload.requestId, {
             explode: false,
             charEncoding: "percent",
         }),
     };
-    const path = pathToFunc("/v1/catalog/releases/{releaseId}")(pathParams);
+    const path = pathToFunc("/v1/requests/{requestId}")(pathParams);
     const headers = new Headers(compactMap({
         Accept: "application/json",
     }));
@@ -38,7 +39,7 @@ async function $do(client, request, options) {
     const context = {
         options: client._options,
         baseURL: options?.serverURL ?? client._baseURL ?? "",
-        operationID: "getRelease",
+        operationID: "getRequest",
         oAuth2Scopes: null,
         resolvedSecurity: requestSecurity,
         securitySource: client._options.apiKey,
@@ -84,7 +85,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, operations.GetReleaseResponse$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 });
+    const [result] = await M.match(M.json(200, models.RequestDetail$inboundSchema), M.jsonErr([400, 401, 403, 404, 409, 413, 422, 429], errors.ErrorT$inboundSchema), M.jsonErr([500, 503], errors.ErrorT$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/funcs/{environments-stop.d.ts → requests-list.d.ts}

@@ -8,4 +8,4 @@ import { StateMachinesHTTPError } from "../models/errors/state-machines-http-err
 import * as operations from "../models/operations/index.js";
 import { APIPromise } from "../types/async.js";
 import { Result } from "../types/fp.js";
-export declare function environmentsStop(client: StateMachinesCore, request: operations.StopEnvironmentRequest, options?: RequestOptions): APIPromise<Result<operations.StopEnvironmentResponse, errors.ErrorResponse | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+export declare function requestsList(client: StateMachinesCore, request: operations.ListRequestsRequest, options?: RequestOptions): APIPromise<Result<operations.ListRequestsResponse, errors.ErrorT | StateMachinesHTTPError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;

package/esm/funcs/{environments-list-requests.js → requests-list.js}

@@ -2,7 +2,7 @@
  * 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 { encodeFormQuery } from "../lib/encodings.js";
 import { matchStatusCode } from "../lib/http.js";
 import * as M from "../lib/matchers.js";
 import { compactMap } from "../lib/primitives.js";
@@ -12,31 +12,26 @@ 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) {
+export function requestsList(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");
+    const parsed = safeParse(request, (value) => z.parse(operations.ListRequestsRequest$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 path = pathToFunc("/v1/requests")();
     const query = encodeFormQuery({
-        "appKey": payload.appKey,
+        "app": payload.app,
         "cursor": payload.cursor,
+        "environmentId": payload.environmentId,
         "from": payload.from,
         "limit": payload.limit,
         "method": payload.method,
+        "responseStatus": payload.responseStatus,
         "search": payload.search,
-        "status": payload.status,
         "statusClass": payload.statusClass,
         "to": payload.to,
         "writesOnly": payload.writesOnly,
@@ -50,7 +45,7 @@ async function $do(client, request, options) {
     const context = {
         options: client._options,
         baseURL: options?.serverURL ?? client._baseURL ?? "",
-        operationID: "listEnvironmentRequests",
+        operationID: "listRequests",
         oAuth2Scopes: null,
         resolvedSecurity: requestSecurity,
         securitySource: client._options.apiKey,
@@ -97,7 +92,7 @@ async function $do(client, request, options) {
     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 });
+    const [result] = await M.match(M.json(200, operations.ListRequestsResponse$inboundSchema), M.jsonErr([400, 401, 403, 404, 409, 413, 422, 429], errors.ErrorT$inboundSchema), M.jsonErr([500, 503], errors.ErrorT$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }