@openrouter/sdk 0.0.1-beta.11 → 0.0.1-beta.14

package/esm/funcs/modelsList.d.ts

@@ -1,14 +1,16 @@
 import { OpenRouterCore } from "../core.js";
 import { RequestOptions } from "../lib/sdks.js";
 import { ConnectionError, InvalidRequestError, RequestAbortedError, RequestTimeoutError, UnexpectedClientError } from "../models/errors/httpclienterrors.js";
+import * as errors from "../models/errors/index.js";
 import { OpenRouterError } from "../models/errors/openroutererror.js";
 import { ResponseValidationError } from "../models/errors/responsevalidationerror.js";
 import { SDKValidationError } from "../models/errors/sdkvalidationerror.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";
 /**
  * List all models and their properties
  */
-export declare function modelsList(client: OpenRouterCore, request?: operations.GetModelsRequest | undefined, options?: RequestOptions): APIPromise<Result<operations.GetModelsResponse, OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+export declare function modelsList(client: OpenRouterCore, request?: operations.GetModelsRequest | undefined, options?: RequestOptions): APIPromise<Result<models.ModelsListResponse, errors.BadRequestResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
 //# sourceMappingURL=modelsList.d.ts.map

package/esm/funcs/modelsList.js

@@ -7,6 +7,8 @@ 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 models from "../models/index.js";
 import * as operations from "../models/operations/index.js";
 import { APIPromise } from "../types/async.js";
 /**
@@ -26,11 +28,9 @@ async function $do(client, request, options) {
     const query = encodeFormQuery({
         "category": payload?.category,
         "supported_parameters": payload?.supported_parameters,
-        "use_rss": payload?.use_rss,
-        "use_rss_chat_links": payload?.use_rss_chat_links,
     });
     const headers = new Headers(compactMap({
-        Accept: "application/json;q=1, application/rss+xml;q=0",
+        Accept: "application/json",
     }));
     const secConfig = await extractSecurity(client._options.apiKey);
     const securityInput = secConfig == null ? {} : { apiKey: secConfig };
@@ -64,7 +64,7 @@ async function $do(client, request, options) {
     const req = requestRes.value;
     const doResult = await client._do(req, {
         context,
-        errorCodes: ["4XX", "5XX"],
+        errorCodes: ["400", "4XX", "500", "5XX"],
         retryConfig: context.retryConfig,
         retryCodes: context.retryCodes,
     });
@@ -72,9 +72,10 @@ async function $do(client, request, options) {
         return [doResult, { status: "request-error", request: req }];
     }
     const response = doResult.value;
-    const [result] = await M.match(M.json(200, operations.GetModelsResponse$inboundSchema), M.text(200, operations.GetModelsResponse$inboundSchema, {
-        ctype: "application/rss+xml",
-    }), M.fail("4XX"), M.fail("5XX"), M.json("default", operations.GetModelsResponse$inboundSchema))(response, req);
+    const responseFields = {
+        HttpMeta: { Response: response, Request: req },
+    };
+    const [result] = await M.match(M.json(200, models.ModelsListResponse$inboundSchema), M.jsonErr(400, errors.BadRequestResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/funcs/modelsListForUser.d.ts

@@ -1,14 +1,16 @@
 import { OpenRouterCore } from "../core.js";
 import { RequestOptions } from "../lib/sdks.js";
 import { ConnectionError, InvalidRequestError, RequestAbortedError, RequestTimeoutError, UnexpectedClientError } from "../models/errors/httpclienterrors.js";
+import * as errors from "../models/errors/index.js";
 import { OpenRouterError } from "../models/errors/openroutererror.js";
 import { ResponseValidationError } from "../models/errors/responsevalidationerror.js";
 import { SDKValidationError } from "../models/errors/sdkvalidationerror.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";
 /**
  * List models filtered by user provider preferences
  */
-export declare function modelsListForUser(client: OpenRouterCore, security: operations.ListModelsUserSecurity, options?: RequestOptions): APIPromise<Result<operations.ListModelsUserResponse, OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+export declare function modelsListForUser(client: OpenRouterCore, security: operations.ListModelsUserSecurity, options?: RequestOptions): APIPromise<Result<models.ModelsListResponse, errors.UnauthorizedResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
 //# sourceMappingURL=modelsListForUser.d.ts.map

package/esm/funcs/modelsListForUser.js

@@ -5,7 +5,8 @@ import * as M from "../lib/matchers.js";
 import { compactMap } from "../lib/primitives.js";
 import { resolveSecurity } from "../lib/security.js";
 import { pathToFunc } from "../lib/url.js";
-import * as operations from "../models/operations/index.js";
+import * as errors from "../models/errors/index.js";
+import * as models from "../models/index.js";
 import { APIPromise } from "../types/async.js";
 /**
  * List models filtered by user provider preferences
@@ -52,7 +53,7 @@ async function $do(client, security, options) {
     const req = requestRes.value;
     const doResult = await client._do(req, {
         context,
-        errorCodes: ["4XX", "5XX"],
+        errorCodes: ["401", "4XX", "500", "5XX"],
         retryConfig: context.retryConfig,
         retryCodes: context.retryCodes,
     });
@@ -60,7 +61,10 @@ async function $do(client, security, options) {
         return [doResult, { status: "request-error", request: req }];
     }
     const response = doResult.value;
-    const [result] = await M.match(M.json(200, operations.ListModelsUserResponse$inboundSchema), M.fail("4XX"), M.fail("5XX"), M.json("default", operations.ListModelsUserResponse$inboundSchema))(response, req);
+    const responseFields = {
+        HttpMeta: { Response: response, Request: req },
+    };
+    const [result] = await M.match(M.json(200, models.ModelsListResponse$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/funcs/oAuthCreateAuthCode.d.ts

@@ -0,0 +1,18 @@
+import { OpenRouterCore } from "../core.js";
+import { RequestOptions } from "../lib/sdks.js";
+import { ConnectionError, InvalidRequestError, RequestAbortedError, RequestTimeoutError, UnexpectedClientError } from "../models/errors/httpclienterrors.js";
+import * as errors from "../models/errors/index.js";
+import { OpenRouterError } from "../models/errors/openroutererror.js";
+import { ResponseValidationError } from "../models/errors/responsevalidationerror.js";
+import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
+import * as operations from "../models/operations/index.js";
+import { APIPromise } from "../types/async.js";
+import { Result } from "../types/fp.js";
+/**
+ * Create authorization code
+ *
+ * @remarks
+ * Create an authorization code for the PKCE flow to generate a user-controlled API key
+ */
+export declare function oAuthCreateAuthCode(client: OpenRouterCore, request: operations.CreateAuthKeysCodeRequest, options?: RequestOptions): APIPromise<Result<operations.CreateAuthKeysCodeResponse, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+//# sourceMappingURL=oAuthCreateAuthCode.d.ts.map

package/esm/funcs/oAuthCreateAuthCode.js

@@ -0,0 +1,82 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import { encodeJSON } from "../lib/encodings.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";
+/**
+ * Create authorization code
+ *
+ * @remarks
+ * Create an authorization code for the PKCE flow to generate a user-controlled API key
+ */
+export function oAuthCreateAuthCode(client, request, options) {
+    return new APIPromise($do(client, request, options));
+}
+async function $do(client, request, options) {
+    const parsed = safeParse(request, (value) => operations.CreateAuthKeysCodeRequest$outboundSchema.parse(value), "Input validation failed");
+    if (!parsed.ok) {
+        return [parsed, { status: "invalid" }];
+    }
+    const payload = parsed.value;
+    const body = encodeJSON("body", payload, { explode: true });
+    const path = pathToFunc("/auth/keys/code")();
+    const headers = new Headers(compactMap({
+        "Content-Type": "application/json",
+        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: "createAuthKeysCode",
+        oAuth2Scopes: null,
+        resolvedSecurity: requestSecurity,
+        securitySource: client._options.apiKey,
+        retryConfig: options?.retries
+            || client._options.retryConfig
+            || { strategy: "none" },
+        retryCodes: options?.retryCodes || ["429", "500", "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,
+        errorCodes: ["400", "401", "4XX", "500", "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.CreateAuthKeysCodeResponse$inboundSchema), M.jsonErr(400, errors.BadRequestResponseError$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$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 }];
+}
+//# sourceMappingURL=oAuthCreateAuthCode.js.map

package/esm/funcs/oAuthCreateAuthorizationUrl.d.ts

@@ -9,13 +9,13 @@ declare const CreateAuthorizationurlParamsSchema: z.ZodUnion<[z.ZodObject<{
     codeChallenge: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     callbackUrl: string | URL;
-    codeChallengeMethod: "S256" | "plain";
     codeChallenge: string;
+    codeChallengeMethod: "S256" | "plain";
     limit?: number | undefined;
 }, {
     callbackUrl: string | URL;
-    codeChallengeMethod: "S256" | "plain";
     codeChallenge: string;
+    codeChallengeMethod: "S256" | "plain";
     limit?: number | undefined;
 }>, z.ZodObject<{
     callbackUrl: z.ZodUnion<[z.ZodString, z.ZodType<URL, z.ZodTypeDef, URL>]>;

package/esm/funcs/oAuthExchangeAuthCodeForAPIKey.d.ts

@@ -0,0 +1,18 @@
+import { OpenRouterCore } from "../core.js";
+import { RequestOptions } from "../lib/sdks.js";
+import { ConnectionError, InvalidRequestError, RequestAbortedError, RequestTimeoutError, UnexpectedClientError } from "../models/errors/httpclienterrors.js";
+import * as errors from "../models/errors/index.js";
+import { OpenRouterError } from "../models/errors/openroutererror.js";
+import { ResponseValidationError } from "../models/errors/responsevalidationerror.js";
+import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
+import * as operations from "../models/operations/index.js";
+import { APIPromise } from "../types/async.js";
+import { Result } from "../types/fp.js";
+/**
+ * Exchange authorization code for API key
+ *
+ * @remarks
+ * Exchange an authorization code from the PKCE flow for a user-controlled API key
+ */
+export declare function oAuthExchangeAuthCodeForAPIKey(client: OpenRouterCore, request: operations.ExchangeAuthCodeForAPIKeyRequest, options?: RequestOptions): APIPromise<Result<operations.ExchangeAuthCodeForAPIKeyResponse, errors.BadRequestResponseError | errors.ForbiddenResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+//# sourceMappingURL=oAuthExchangeAuthCodeForAPIKey.d.ts.map

package/esm/funcs/oAuthExchangeAuthCodeForAPIKey.js

@@ -0,0 +1,82 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import { encodeJSON } from "../lib/encodings.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";
+/**
+ * Exchange authorization code for API key
+ *
+ * @remarks
+ * Exchange an authorization code from the PKCE flow for a user-controlled API key
+ */
+export function oAuthExchangeAuthCodeForAPIKey(client, request, options) {
+    return new APIPromise($do(client, request, options));
+}
+async function $do(client, request, options) {
+    const parsed = safeParse(request, (value) => operations.ExchangeAuthCodeForAPIKeyRequest$outboundSchema.parse(value), "Input validation failed");
+    if (!parsed.ok) {
+        return [parsed, { status: "invalid" }];
+    }
+    const payload = parsed.value;
+    const body = encodeJSON("body", payload, { explode: true });
+    const path = pathToFunc("/auth/keys")();
+    const headers = new Headers(compactMap({
+        "Content-Type": "application/json",
+        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: "exchangeAuthCodeForAPIKey",
+        oAuth2Scopes: null,
+        resolvedSecurity: requestSecurity,
+        securitySource: client._options.apiKey,
+        retryConfig: options?.retries
+            || client._options.retryConfig
+            || { strategy: "none" },
+        retryCodes: options?.retryCodes || ["429", "500", "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,
+        errorCodes: ["400", "403", "4XX", "500", "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.ExchangeAuthCodeForAPIKeyResponse$inboundSchema), M.jsonErr(400, errors.BadRequestResponseError$inboundSchema), M.jsonErr(403, errors.ForbiddenResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$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 }];
+}
+//# sourceMappingURL=oAuthExchangeAuthCodeForAPIKey.js.map

package/esm/funcs/parametersGetParameters.d.ts

@@ -11,5 +11,5 @@ import { Result } from "../types/fp.js";
 /**
  * Get a model's supported parameters and data about which are most popular
  */
-export declare function parametersGetParameters(client: OpenRouterCore, security: operations.GetParametersSecurity, request: operations.GetParametersRequest, options?: RequestOptions): APIPromise<Result<operations.GetParametersResponse, errors.ErrorResponse | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+export declare function parametersGetParameters(client: OpenRouterCore, security: operations.GetParametersSecurity, request: operations.GetParametersRequest, options?: RequestOptions): APIPromise<Result<operations.GetParametersResponse, errors.UnauthorizedResponseError | errors.NotFoundResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
 //# sourceMappingURL=parametersGetParameters.d.ts.map

package/esm/funcs/parametersGetParameters.js

@@ -76,7 +76,7 @@ async function $do(client, security, request, options) {
     const req = requestRes.value;
     const doResult = await client._do(req, {
         context,
-        errorCodes: ["4XX", "5XX"],
+        errorCodes: ["401", "404", "4XX", "500", "5XX"],
         retryConfig: context.retryConfig,
         retryCodes: context.retryCodes,
     });
@@ -87,7 +87,7 @@ async function $do(client, security, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, operations.GetParametersResponse$inboundSchema), M.jsonErr("4XX", errors.ErrorResponse$inboundSchema), M.jsonErr("5XX", errors.ErrorResponse$inboundSchema))(response, req, { extraFields: responseFields });
+    const [result] = await M.match(M.json(200, operations.GetParametersResponse$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(404, errors.NotFoundResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/funcs/providersList.d.ts

@@ -11,5 +11,5 @@ import { Result } from "../types/fp.js";
 /**
  * List all providers
  */
-export declare function providersList(client: OpenRouterCore, options?: RequestOptions): APIPromise<Result<operations.ListProvidersResponse, errors.InternalServerError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+export declare function providersList(client: OpenRouterCore, options?: RequestOptions): APIPromise<Result<operations.ListProvidersResponse, errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
 //# sourceMappingURL=providersList.d.ts.map

package/esm/funcs/providersList.js

@@ -60,7 +60,7 @@ async function $do(client, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, operations.ListProvidersResponse$inboundSchema), M.jsonErr(500, errors.InternalServerError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    const [result] = await M.match(M.json(200, operations.ListProvidersResponse$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/lib/config.d.ts

@@ -37,8 +37,8 @@ export declare function serverURLFromOptions(options: SDKOptions): URL | null;
 export declare const SDK_METADATA: {
     readonly language: "typescript";
     readonly openapiDocVersion: "1.0.0";
-    readonly sdkVersion: "0.0.1-beta.11";
+    readonly sdkVersion: "0.0.1-beta.14";
     readonly genVersion: "2.731.4";
-    readonly userAgent: "speakeasy-sdk/typescript 0.0.1-beta.11 2.731.4 1.0.0 @openrouter/sdk";
+    readonly userAgent: "speakeasy-sdk/typescript 0.0.1-beta.14 2.731.4 1.0.0 @openrouter/sdk";
 };
 //# sourceMappingURL=config.d.ts.map

package/esm/lib/config.js

@@ -25,8 +25,8 @@ export function serverURLFromOptions(options) {
 export const SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "1.0.0",
-    sdkVersion: "0.0.1-beta.11",
+    sdkVersion: "0.0.1-beta.14",
     genVersion: "2.731.4",
-    userAgent: "speakeasy-sdk/typescript 0.0.1-beta.11 2.731.4 1.0.0 @openrouter/sdk",
+    userAgent: "speakeasy-sdk/typescript 0.0.1-beta.14 2.731.4 1.0.0 @openrouter/sdk",
 };
 //# sourceMappingURL=config.js.map

package/esm/lib/event-streams.d.ts

@@ -4,7 +4,7 @@ export type SseMessage<T> = {
     id?: string | undefined;
     retry?: number | undefined;
 };
-export declare class EventStream<T extends SseMessage<unknown>> extends ReadableStream<T> {
+export declare class EventStream<T> extends ReadableStream<T> {
     constructor(responseBody: ReadableStream<Uint8Array>, parse: (x: SseMessage<string>) => IteratorResult<T, undefined>);
     [Symbol.asyncIterator](): AsyncIterableIterator<T>;
 }

package/esm/models/badgatewayresponseerrordata.d.ts

@@ -0,0 +1,40 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Error data for BadGatewayResponse
+ */
+export type BadGatewayResponseErrorData = {
+    code: number;
+    message: string;
+    metadata?: {
+        [k: string]: any | null;
+    } | null | undefined;
+};
+/** @internal */
+export declare const BadGatewayResponseErrorData$inboundSchema: z.ZodType<BadGatewayResponseErrorData, unknown>;
+/** @internal */
+export type BadGatewayResponseErrorData$Outbound = {
+    code: number;
+    message: string;
+    metadata?: {
+        [k: string]: any | null;
+    } | null | undefined;
+};
+/** @internal */
+export declare const BadGatewayResponseErrorData$outboundSchema: z.ZodType<BadGatewayResponseErrorData$Outbound, BadGatewayResponseErrorData>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace BadGatewayResponseErrorData$ {
+    /** @deprecated use `BadGatewayResponseErrorData$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<BadGatewayResponseErrorData, unknown, z.core.$ZodTypeInternals<BadGatewayResponseErrorData, unknown>>;
+    /** @deprecated use `BadGatewayResponseErrorData$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<BadGatewayResponseErrorData$Outbound, BadGatewayResponseErrorData, z.core.$ZodTypeInternals<BadGatewayResponseErrorData$Outbound, BadGatewayResponseErrorData>>;
+    /** @deprecated use `BadGatewayResponseErrorData$Outbound` instead. */
+    type Outbound = BadGatewayResponseErrorData$Outbound;
+}
+export declare function badGatewayResponseErrorDataToJSON(badGatewayResponseErrorData: BadGatewayResponseErrorData): string;
+export declare function badGatewayResponseErrorDataFromJSON(jsonString: string): SafeParseResult<BadGatewayResponseErrorData, SDKValidationError>;
+//# sourceMappingURL=badgatewayresponseerrordata.d.ts.map

package/esm/models/badgatewayresponseerrordata.js

@@ -0,0 +1,35 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const BadGatewayResponseErrorData$inboundSchema = z.object({
+    code: z.number().int(),
+    message: z.string(),
+    metadata: z.nullable(z.record(z.string(), z.nullable(z.any()))).optional(),
+});
+/** @internal */
+export const BadGatewayResponseErrorData$outboundSchema = z.object({
+    code: z.number().int(),
+    message: z.string(),
+    metadata: z.nullable(z.record(z.string(), z.nullable(z.any()))).optional(),
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var BadGatewayResponseErrorData$;
+(function (BadGatewayResponseErrorData$) {
+    /** @deprecated use `BadGatewayResponseErrorData$inboundSchema` instead. */
+    BadGatewayResponseErrorData$.inboundSchema = BadGatewayResponseErrorData$inboundSchema;
+    /** @deprecated use `BadGatewayResponseErrorData$outboundSchema` instead. */
+    BadGatewayResponseErrorData$.outboundSchema = BadGatewayResponseErrorData$outboundSchema;
+})(BadGatewayResponseErrorData$ || (BadGatewayResponseErrorData$ = {}));
+export function badGatewayResponseErrorDataToJSON(badGatewayResponseErrorData) {
+    return JSON.stringify(BadGatewayResponseErrorData$outboundSchema.parse(badGatewayResponseErrorData));
+}
+export function badGatewayResponseErrorDataFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => BadGatewayResponseErrorData$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'BadGatewayResponseErrorData' from JSON`);
+}
+//# sourceMappingURL=badgatewayresponseerrordata.js.map

package/esm/models/badrequestresponseerrordata.d.ts

@@ -0,0 +1,40 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Error data for BadRequestResponse
+ */
+export type BadRequestResponseErrorData = {
+    code: number;
+    message: string;
+    metadata?: {
+        [k: string]: any | null;
+    } | null | undefined;
+};
+/** @internal */
+export declare const BadRequestResponseErrorData$inboundSchema: z.ZodType<BadRequestResponseErrorData, unknown>;
+/** @internal */
+export type BadRequestResponseErrorData$Outbound = {
+    code: number;
+    message: string;
+    metadata?: {
+        [k: string]: any | null;
+    } | null | undefined;
+};
+/** @internal */
+export declare const BadRequestResponseErrorData$outboundSchema: z.ZodType<BadRequestResponseErrorData$Outbound, BadRequestResponseErrorData>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace BadRequestResponseErrorData$ {
+    /** @deprecated use `BadRequestResponseErrorData$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<BadRequestResponseErrorData, unknown, z.core.$ZodTypeInternals<BadRequestResponseErrorData, unknown>>;
+    /** @deprecated use `BadRequestResponseErrorData$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<BadRequestResponseErrorData$Outbound, BadRequestResponseErrorData, z.core.$ZodTypeInternals<BadRequestResponseErrorData$Outbound, BadRequestResponseErrorData>>;
+    /** @deprecated use `BadRequestResponseErrorData$Outbound` instead. */
+    type Outbound = BadRequestResponseErrorData$Outbound;
+}
+export declare function badRequestResponseErrorDataToJSON(badRequestResponseErrorData: BadRequestResponseErrorData): string;
+export declare function badRequestResponseErrorDataFromJSON(jsonString: string): SafeParseResult<BadRequestResponseErrorData, SDKValidationError>;
+//# sourceMappingURL=badrequestresponseerrordata.d.ts.map

package/esm/models/badrequestresponseerrordata.js

@@ -0,0 +1,35 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const BadRequestResponseErrorData$inboundSchema = z.object({
+    code: z.number().int(),
+    message: z.string(),
+    metadata: z.nullable(z.record(z.string(), z.nullable(z.any()))).optional(),
+});
+/** @internal */
+export const BadRequestResponseErrorData$outboundSchema = z.object({
+    code: z.number().int(),
+    message: z.string(),
+    metadata: z.nullable(z.record(z.string(), z.nullable(z.any()))).optional(),
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var BadRequestResponseErrorData$;
+(function (BadRequestResponseErrorData$) {
+    /** @deprecated use `BadRequestResponseErrorData$inboundSchema` instead. */
+    BadRequestResponseErrorData$.inboundSchema = BadRequestResponseErrorData$inboundSchema;
+    /** @deprecated use `BadRequestResponseErrorData$outboundSchema` instead. */
+    BadRequestResponseErrorData$.outboundSchema = BadRequestResponseErrorData$outboundSchema;
+})(BadRequestResponseErrorData$ || (BadRequestResponseErrorData$ = {}));
+export function badRequestResponseErrorDataToJSON(badRequestResponseErrorData) {
+    return JSON.stringify(BadRequestResponseErrorData$outboundSchema.parse(badRequestResponseErrorData));
+}
+export function badRequestResponseErrorDataFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => BadRequestResponseErrorData$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'BadRequestResponseErrorData' from JSON`);
+}
+//# sourceMappingURL=badrequestresponseerrordata.js.map

package/esm/models/chatmessagecontentitemaudio.d.ts

@@ -2,7 +2,7 @@ import * as z from "zod/v4";
 import { OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-export declare const Format: {
+export declare const ChatMessageContentItemAudioFormat: {
     readonly Wav: "wav";
     readonly Mp3: "mp3";
     readonly Flac: "flac";
@@ -11,28 +11,28 @@ export declare const Format: {
     readonly Pcm16: "pcm16";
     readonly Pcm24: "pcm24";
 };
-export type Format = OpenEnum<typeof Format>;
+export type ChatMessageContentItemAudioFormat = OpenEnum<typeof ChatMessageContentItemAudioFormat>;
 export type InputAudio = {
     data: string;
-    format: Format;
+    format: ChatMessageContentItemAudioFormat;
 };
 export type ChatMessageContentItemAudio = {
     type: "input_audio";
     inputAudio: InputAudio;
 };
 /** @internal */
-export declare const Format$inboundSchema: z.ZodType<Format, unknown>;
+export declare const ChatMessageContentItemAudioFormat$inboundSchema: z.ZodType<ChatMessageContentItemAudioFormat, unknown>;
 /** @internal */
-export declare const Format$outboundSchema: z.ZodType<Format, Format>;
+export declare const ChatMessageContentItemAudioFormat$outboundSchema: z.ZodType<ChatMessageContentItemAudioFormat, ChatMessageContentItemAudioFormat>;
 /**
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export declare namespace Format$ {
-    /** @deprecated use `Format$inboundSchema` instead. */
-    const inboundSchema: z.ZodType<Format, unknown, z.core.$ZodTypeInternals<Format, unknown>>;
-    /** @deprecated use `Format$outboundSchema` instead. */
-    const outboundSchema: z.ZodType<Format, Format, z.core.$ZodTypeInternals<Format, Format>>;
+export declare namespace ChatMessageContentItemAudioFormat$ {
+    /** @deprecated use `ChatMessageContentItemAudioFormat$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<ChatMessageContentItemAudioFormat, unknown, z.core.$ZodTypeInternals<ChatMessageContentItemAudioFormat, unknown>>;
+    /** @deprecated use `ChatMessageContentItemAudioFormat$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<ChatMessageContentItemAudioFormat, ChatMessageContentItemAudioFormat, z.core.$ZodTypeInternals<ChatMessageContentItemAudioFormat, ChatMessageContentItemAudioFormat>>;
 }
 /** @internal */
 export declare const InputAudio$inboundSchema: z.ZodType<InputAudio, unknown>;