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

package/esm/funcs/modelsList.js

@@ -7,6 +7,7 @@ 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";
 /**
@@ -64,7 +65,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 +73,12 @@ async function $do(client, request, options) {
         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.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);
+    }), 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/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.12";
     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.12 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.12",
     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.12 2.731.4 1.0.0 @openrouter/sdk",
 };
 //# sourceMappingURL=config.js.map

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>;

package/esm/models/chatmessagecontentitemaudio.js

@@ -5,7 +5,7 @@ import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { catchUnrecognizedEnum, } from "../types/enums.js";
-export const Format = {
+export const ChatMessageContentItemAudioFormat = {
     Wav: "wav",
     Mp3: "mp3",
     Flac: "flac",
@@ -15,37 +15,37 @@ export const Format = {
     Pcm24: "pcm24",
 };
 /** @internal */
-export const Format$inboundSchema = z
+export const ChatMessageContentItemAudioFormat$inboundSchema = z
     .union([
-    z.enum(Format),
+    z.enum(ChatMessageContentItemAudioFormat),
     z.string().transform(catchUnrecognizedEnum),
 ]);
 /** @internal */
-export const Format$outboundSchema = z.union([
-    z.enum(Format),
+export const ChatMessageContentItemAudioFormat$outboundSchema = z.union([
+    z.enum(ChatMessageContentItemAudioFormat),
     z.string().and(z.custom()),
 ]);
 /**
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export var Format$;
-(function (Format$) {
-    /** @deprecated use `Format$inboundSchema` instead. */
-    Format$.inboundSchema = Format$inboundSchema;
-    /** @deprecated use `Format$outboundSchema` instead. */
-    Format$.outboundSchema = Format$outboundSchema;
-})(Format$ || (Format$ = {}));
+export var ChatMessageContentItemAudioFormat$;
+(function (ChatMessageContentItemAudioFormat$) {
+    /** @deprecated use `ChatMessageContentItemAudioFormat$inboundSchema` instead. */
+    ChatMessageContentItemAudioFormat$.inboundSchema = ChatMessageContentItemAudioFormat$inboundSchema;
+    /** @deprecated use `ChatMessageContentItemAudioFormat$outboundSchema` instead. */
+    ChatMessageContentItemAudioFormat$.outboundSchema = ChatMessageContentItemAudioFormat$outboundSchema;
+})(ChatMessageContentItemAudioFormat$ || (ChatMessageContentItemAudioFormat$ = {}));
 /** @internal */
 export const InputAudio$inboundSchema = z
     .object({
     data: z.string(),
-    format: Format$inboundSchema,
+    format: ChatMessageContentItemAudioFormat$inboundSchema,
 });
 /** @internal */
 export const InputAudio$outboundSchema = z.object({
     data: z.string(),
-    format: Format$outboundSchema,
+    format: ChatMessageContentItemAudioFormat$outboundSchema,
 });
 /**
  * @internal

package/esm/models/chatstreamingresponsechunk.d.ts

@@ -7,7 +7,7 @@ export type ChatStreamingResponseChunkError = {
     message: string;
     code: number;
 };
-export type Data = {
+export type ChatStreamingResponseChunkData = {
     id: string;
     choices: Array<ChatStreamingChoice>;
     created: number;
@@ -18,7 +18,7 @@ export type Data = {
     usage?: ChatGenerationTokenUsage | undefined;
 };
 export type ChatStreamingResponseChunk = {
-    data: Data;
+    data: ChatStreamingResponseChunkData;
 };
 /** @internal */
 export declare const ChatStreamingResponseChunkError$inboundSchema: z.ZodType<ChatStreamingResponseChunkError, unknown>;
@@ -44,9 +44,9 @@ export declare namespace ChatStreamingResponseChunkError$ {
 export declare function chatStreamingResponseChunkErrorToJSON(chatStreamingResponseChunkError: ChatStreamingResponseChunkError): string;
 export declare function chatStreamingResponseChunkErrorFromJSON(jsonString: string): SafeParseResult<ChatStreamingResponseChunkError, SDKValidationError>;
 /** @internal */
-export declare const Data$inboundSchema: z.ZodType<Data, unknown>;
+export declare const ChatStreamingResponseChunkData$inboundSchema: z.ZodType<ChatStreamingResponseChunkData, unknown>;
 /** @internal */
-export type Data$Outbound = {
+export type ChatStreamingResponseChunkData$Outbound = {
     id: string;
     choices: Array<ChatStreamingChoice$Outbound>;
     created: number;
@@ -57,26 +57,26 @@ export type Data$Outbound = {
     usage?: ChatGenerationTokenUsage$Outbound | undefined;
 };
 /** @internal */
-export declare const Data$outboundSchema: z.ZodType<Data$Outbound, Data>;
+export declare const ChatStreamingResponseChunkData$outboundSchema: z.ZodType<ChatStreamingResponseChunkData$Outbound, ChatStreamingResponseChunkData>;
 /**
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export declare namespace Data$ {
-    /** @deprecated use `Data$inboundSchema` instead. */
-    const inboundSchema: z.ZodType<Data, unknown, z.core.$ZodTypeInternals<Data, unknown>>;
-    /** @deprecated use `Data$outboundSchema` instead. */
-    const outboundSchema: z.ZodType<Data$Outbound, Data, z.core.$ZodTypeInternals<Data$Outbound, Data>>;
-    /** @deprecated use `Data$Outbound` instead. */
-    type Outbound = Data$Outbound;
+export declare namespace ChatStreamingResponseChunkData$ {
+    /** @deprecated use `ChatStreamingResponseChunkData$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<ChatStreamingResponseChunkData, unknown, z.core.$ZodTypeInternals<ChatStreamingResponseChunkData, unknown>>;
+    /** @deprecated use `ChatStreamingResponseChunkData$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<ChatStreamingResponseChunkData$Outbound, ChatStreamingResponseChunkData, z.core.$ZodTypeInternals<ChatStreamingResponseChunkData$Outbound, ChatStreamingResponseChunkData>>;
+    /** @deprecated use `ChatStreamingResponseChunkData$Outbound` instead. */
+    type Outbound = ChatStreamingResponseChunkData$Outbound;
 }
-export declare function dataToJSON(data: Data): string;
-export declare function dataFromJSON(jsonString: string): SafeParseResult<Data, SDKValidationError>;
+export declare function chatStreamingResponseChunkDataToJSON(chatStreamingResponseChunkData: ChatStreamingResponseChunkData): string;
+export declare function chatStreamingResponseChunkDataFromJSON(jsonString: string): SafeParseResult<ChatStreamingResponseChunkData, SDKValidationError>;
 /** @internal */
 export declare const ChatStreamingResponseChunk$inboundSchema: z.ZodType<ChatStreamingResponseChunk, unknown>;
 /** @internal */
 export type ChatStreamingResponseChunk$Outbound = {
-    data: Data$Outbound;
+    data: ChatStreamingResponseChunkData$Outbound;
 };
 /** @internal */
 export declare const ChatStreamingResponseChunk$outboundSchema: z.ZodType<ChatStreamingResponseChunk$Outbound, ChatStreamingResponseChunk>;

package/esm/models/chatstreamingresponsechunk.js

@@ -34,7 +34,7 @@ export function chatStreamingResponseChunkErrorFromJSON(jsonString) {
     return safeParse(jsonString, (x) => ChatStreamingResponseChunkError$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatStreamingResponseChunkError' from JSON`);
 }
 /** @internal */
-export const Data$inboundSchema = z.object({
+export const ChatStreamingResponseChunkData$inboundSchema = z.object({
     id: z.string(),
     choices: z.array(ChatStreamingChoice$inboundSchema),
     created: z.number(),
@@ -49,7 +49,7 @@ export const Data$inboundSchema = z.object({
     });
 });
 /** @internal */
-export const Data$outboundSchema = z.object({
+export const ChatStreamingResponseChunkData$outboundSchema = z.object({
     id: z.string(),
     choices: z.array(ChatStreamingChoice$outboundSchema),
     created: z.number(),
@@ -68,18 +68,18 @@ export const Data$outboundSchema = z.object({
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export var Data$;
-(function (Data$) {
-    /** @deprecated use `Data$inboundSchema` instead. */
-    Data$.inboundSchema = Data$inboundSchema;
-    /** @deprecated use `Data$outboundSchema` instead. */
-    Data$.outboundSchema = Data$outboundSchema;
-})(Data$ || (Data$ = {}));
-export function dataToJSON(data) {
-    return JSON.stringify(Data$outboundSchema.parse(data));
+export var ChatStreamingResponseChunkData$;
+(function (ChatStreamingResponseChunkData$) {
+    /** @deprecated use `ChatStreamingResponseChunkData$inboundSchema` instead. */
+    ChatStreamingResponseChunkData$.inboundSchema = ChatStreamingResponseChunkData$inboundSchema;
+    /** @deprecated use `ChatStreamingResponseChunkData$outboundSchema` instead. */
+    ChatStreamingResponseChunkData$.outboundSchema = ChatStreamingResponseChunkData$outboundSchema;
+})(ChatStreamingResponseChunkData$ || (ChatStreamingResponseChunkData$ = {}));
+export function chatStreamingResponseChunkDataToJSON(chatStreamingResponseChunkData) {
+    return JSON.stringify(ChatStreamingResponseChunkData$outboundSchema.parse(chatStreamingResponseChunkData));
 }
-export function dataFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => Data$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Data' from JSON`);
+export function chatStreamingResponseChunkDataFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatStreamingResponseChunkData$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatStreamingResponseChunkData' from JSON`);
 }
 /** @internal */
 export const ChatStreamingResponseChunk$inboundSchema = z.object({
@@ -94,11 +94,11 @@ export const ChatStreamingResponseChunk$inboundSchema = z.object({
             });
             return z.NEVER;
         }
-    }).pipe(z.lazy(() => Data$inboundSchema)),
+    }).pipe(z.lazy(() => ChatStreamingResponseChunkData$inboundSchema)),
 });
 /** @internal */
 export const ChatStreamingResponseChunk$outboundSchema = z.object({
-    data: z.lazy(() => Data$outboundSchema),
+    data: z.lazy(() => ChatStreamingResponseChunkData$outboundSchema),
 });
 /**
  * @internal

package/esm/models/createchargerequest.d.ts

@@ -1,14 +1,43 @@
 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 ChainId: {
+    readonly One: 1;
+    readonly OneHundredAndThirtySeven: 137;
+    readonly EightThousandFourHundredAndFiftyThree: 8453;
+};
+export type ChainId = OpenEnum<typeof ChainId>;
 /**
  * Create a Coinbase charge for crypto payment
  */
-export type CreateChargeRequest = {};
+export type CreateChargeRequest = {
+    amount: number;
+    sender: string;
+    chainId: ChainId;
+};
+/** @internal */
+export declare const ChainId$inboundSchema: z.ZodType<ChainId, unknown>;
+/** @internal */
+export declare const ChainId$outboundSchema: z.ZodType<ChainId, ChainId>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ChainId$ {
+    /** @deprecated use `ChainId$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<ChainId, unknown, z.core.$ZodTypeInternals<ChainId, unknown>>;
+    /** @deprecated use `ChainId$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<ChainId, ChainId, z.core.$ZodTypeInternals<ChainId, ChainId>>;
+}
 /** @internal */
 export declare const CreateChargeRequest$inboundSchema: z.ZodType<CreateChargeRequest, unknown>;
 /** @internal */
-export type CreateChargeRequest$Outbound = {};
+export type CreateChargeRequest$Outbound = {
+    amount: number;
+    sender: string;
+    chain_id: number;
+};
 /** @internal */
 export declare const CreateChargeRequest$outboundSchema: z.ZodType<CreateChargeRequest$Outbound, CreateChargeRequest>;
 /**