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

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

package/esm/models/createchargerequest.js

@@ -2,11 +2,56 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 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 ChainId = {
+    One: 1,
+    OneHundredAndThirtySeven: 137,
+    EightThousandFourHundredAndFiftyThree: 8453,
+};
 /** @internal */
-export const CreateChargeRequest$inboundSchema = z.object({});
+export const ChainId$inboundSchema = z
+    .union([
+    z.enum(ChainId),
+    z.number().transform(catchUnrecognizedEnum),
+]);
 /** @internal */
-export const CreateChargeRequest$outboundSchema = z.object({});
+export const ChainId$outboundSchema = z.union([
+    z.enum(ChainId),
+    z.number().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 ChainId$;
+(function (ChainId$) {
+    /** @deprecated use `ChainId$inboundSchema` instead. */
+    ChainId$.inboundSchema = ChainId$inboundSchema;
+    /** @deprecated use `ChainId$outboundSchema` instead. */
+    ChainId$.outboundSchema = ChainId$outboundSchema;
+})(ChainId$ || (ChainId$ = {}));
+/** @internal */
+export const CreateChargeRequest$inboundSchema = z.object({
+    amount: z.number(),
+    sender: z.string(),
+    chain_id: ChainId$inboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        "chain_id": "chainId",
+    });
+});
+/** @internal */
+export const CreateChargeRequest$outboundSchema = z.object({
+    amount: z.number(),
+    sender: z.string(),
+    chainId: ChainId$outboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        chainId: "chain_id",
+    });
+});
 /**
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.

package/esm/models/defaultparameters.d.ts

@@ -0,0 +1,36 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Default parameters for this model
+ */
+export type DefaultParameters = {
+    temperature?: number | null | undefined;
+    topP?: number | null | undefined;
+    frequencyPenalty?: number | null | undefined;
+};
+/** @internal */
+export declare const DefaultParameters$inboundSchema: z.ZodType<DefaultParameters, unknown>;
+/** @internal */
+export type DefaultParameters$Outbound = {
+    temperature?: number | null | undefined;
+    top_p?: number | null | undefined;
+    frequency_penalty?: number | null | undefined;
+};
+/** @internal */
+export declare const DefaultParameters$outboundSchema: z.ZodType<DefaultParameters$Outbound, DefaultParameters>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace DefaultParameters$ {
+    /** @deprecated use `DefaultParameters$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<DefaultParameters, unknown, z.core.$ZodTypeInternals<DefaultParameters, unknown>>;
+    /** @deprecated use `DefaultParameters$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<DefaultParameters$Outbound, DefaultParameters, z.core.$ZodTypeInternals<DefaultParameters$Outbound, DefaultParameters>>;
+    /** @deprecated use `DefaultParameters$Outbound` instead. */
+    type Outbound = DefaultParameters$Outbound;
+}
+export declare function defaultParametersToJSON(defaultParameters: DefaultParameters): string;
+export declare function defaultParametersFromJSON(jsonString: string): SafeParseResult<DefaultParameters, SDKValidationError>;
+//# sourceMappingURL=defaultparameters.d.ts.map

package/esm/models/defaultparameters.js

@@ -0,0 +1,46 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const DefaultParameters$inboundSchema = z.object({
+    temperature: z.nullable(z.number()).optional(),
+    top_p: z.nullable(z.number()).optional(),
+    frequency_penalty: z.nullable(z.number()).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "top_p": "topP",
+        "frequency_penalty": "frequencyPenalty",
+    });
+});
+/** @internal */
+export const DefaultParameters$outboundSchema = z.object({
+    temperature: z.nullable(z.number()).optional(),
+    topP: z.nullable(z.number()).optional(),
+    frequencyPenalty: z.nullable(z.number()).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        topP: "top_p",
+        frequencyPenalty: "frequency_penalty",
+    });
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var DefaultParameters$;
+(function (DefaultParameters$) {
+    /** @deprecated use `DefaultParameters$inboundSchema` instead. */
+    DefaultParameters$.inboundSchema = DefaultParameters$inboundSchema;
+    /** @deprecated use `DefaultParameters$outboundSchema` instead. */
+    DefaultParameters$.outboundSchema = DefaultParameters$outboundSchema;
+})(DefaultParameters$ || (DefaultParameters$ = {}));
+export function defaultParametersToJSON(defaultParameters) {
+    return JSON.stringify(DefaultParameters$outboundSchema.parse(defaultParameters));
+}
+export function defaultParametersFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => DefaultParameters$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'DefaultParameters' from JSON`);
+}
+//# sourceMappingURL=defaultparameters.js.map

package/esm/models/edgenetworktimeoutresponseerrordata.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 EdgeNetworkTimeoutResponse
+ */
+export type EdgeNetworkTimeoutResponseErrorData = {
+    code: number;
+    message: string;
+    metadata?: {
+        [k: string]: any | null;
+    } | null | undefined;
+};
+/** @internal */
+export declare const EdgeNetworkTimeoutResponseErrorData$inboundSchema: z.ZodType<EdgeNetworkTimeoutResponseErrorData, unknown>;
+/** @internal */
+export type EdgeNetworkTimeoutResponseErrorData$Outbound = {
+    code: number;
+    message: string;
+    metadata?: {
+        [k: string]: any | null;
+    } | null | undefined;
+};
+/** @internal */
+export declare const EdgeNetworkTimeoutResponseErrorData$outboundSchema: z.ZodType<EdgeNetworkTimeoutResponseErrorData$Outbound, EdgeNetworkTimeoutResponseErrorData>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace EdgeNetworkTimeoutResponseErrorData$ {
+    /** @deprecated use `EdgeNetworkTimeoutResponseErrorData$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<EdgeNetworkTimeoutResponseErrorData, unknown, z.core.$ZodTypeInternals<EdgeNetworkTimeoutResponseErrorData, unknown>>;
+    /** @deprecated use `EdgeNetworkTimeoutResponseErrorData$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<EdgeNetworkTimeoutResponseErrorData$Outbound, EdgeNetworkTimeoutResponseErrorData, z.core.$ZodTypeInternals<EdgeNetworkTimeoutResponseErrorData$Outbound, EdgeNetworkTimeoutResponseErrorData>>;
+    /** @deprecated use `EdgeNetworkTimeoutResponseErrorData$Outbound` instead. */
+    type Outbound = EdgeNetworkTimeoutResponseErrorData$Outbound;
+}
+export declare function edgeNetworkTimeoutResponseErrorDataToJSON(edgeNetworkTimeoutResponseErrorData: EdgeNetworkTimeoutResponseErrorData): string;
+export declare function edgeNetworkTimeoutResponseErrorDataFromJSON(jsonString: string): SafeParseResult<EdgeNetworkTimeoutResponseErrorData, SDKValidationError>;
+//# sourceMappingURL=edgenetworktimeoutresponseerrordata.d.ts.map

package/esm/models/edgenetworktimeoutresponseerrordata.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 EdgeNetworkTimeoutResponseErrorData$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 EdgeNetworkTimeoutResponseErrorData$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 EdgeNetworkTimeoutResponseErrorData$;
+(function (EdgeNetworkTimeoutResponseErrorData$) {
+    /** @deprecated use `EdgeNetworkTimeoutResponseErrorData$inboundSchema` instead. */
+    EdgeNetworkTimeoutResponseErrorData$.inboundSchema = EdgeNetworkTimeoutResponseErrorData$inboundSchema;
+    /** @deprecated use `EdgeNetworkTimeoutResponseErrorData$outboundSchema` instead. */
+    EdgeNetworkTimeoutResponseErrorData$.outboundSchema = EdgeNetworkTimeoutResponseErrorData$outboundSchema;
+})(EdgeNetworkTimeoutResponseErrorData$ || (EdgeNetworkTimeoutResponseErrorData$ = {}));
+export function edgeNetworkTimeoutResponseErrorDataToJSON(edgeNetworkTimeoutResponseErrorData) {
+    return JSON.stringify(EdgeNetworkTimeoutResponseErrorData$outboundSchema.parse(edgeNetworkTimeoutResponseErrorData));
+}
+export function edgeNetworkTimeoutResponseErrorDataFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => EdgeNetworkTimeoutResponseErrorData$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'EdgeNetworkTimeoutResponseErrorData' from JSON`);
+}
+//# sourceMappingURL=edgenetworktimeoutresponseerrordata.js.map

package/esm/models/endpointstatus.d.ts

@@ -0,0 +1,26 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+export declare const EndpointStatus: {
+    readonly Zero: 0;
+    readonly Minus1: -1;
+    readonly Minus2: -2;
+    readonly Minus3: -3;
+    readonly Minus5: -5;
+    readonly Minus10: -10;
+};
+export type EndpointStatus = OpenEnum<typeof EndpointStatus>;
+/** @internal */
+export declare const EndpointStatus$inboundSchema: z.ZodType<EndpointStatus, unknown>;
+/** @internal */
+export declare const EndpointStatus$outboundSchema: z.ZodType<EndpointStatus, EndpointStatus>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace EndpointStatus$ {
+    /** @deprecated use `EndpointStatus$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<EndpointStatus, unknown, z.core.$ZodTypeInternals<EndpointStatus, unknown>>;
+    /** @deprecated use `EndpointStatus$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<EndpointStatus, EndpointStatus, z.core.$ZodTypeInternals<EndpointStatus, EndpointStatus>>;
+}
+//# sourceMappingURL=endpointstatus.d.ts.map

package/esm/models/endpointstatus.js

@@ -0,0 +1,36 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4";
+import { catchUnrecognizedEnum, } from "../types/enums.js";
+export const EndpointStatus = {
+    Zero: 0,
+    Minus1: -1,
+    Minus2: -2,
+    Minus3: -3,
+    Minus5: -5,
+    Minus10: -10,
+};
+/** @internal */
+export const EndpointStatus$inboundSchema = z
+    .union([
+    z.enum(EndpointStatus),
+    z.number().transform(catchUnrecognizedEnum),
+]);
+/** @internal */
+export const EndpointStatus$outboundSchema = z.union([
+    z.enum(EndpointStatus),
+    z.number().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 EndpointStatus$;
+(function (EndpointStatus$) {
+    /** @deprecated use `EndpointStatus$inboundSchema` instead. */
+    EndpointStatus$.inboundSchema = EndpointStatus$inboundSchema;
+    /** @deprecated use `EndpointStatus$outboundSchema` instead. */
+    EndpointStatus$.outboundSchema = EndpointStatus$outboundSchema;
+})(EndpointStatus$ || (EndpointStatus$ = {}));
+//# sourceMappingURL=endpointstatus.js.map

package/esm/models/errors/badgatewayresponseerror.d.ts

@@ -0,0 +1,52 @@
+import * as z from "zod/v4";
+import * as models from "../index.js";
+import { OpenRouterError } from "./openroutererror.js";
+/**
+ * Bad Gateway - Provider/upstream API failure
+ */
+export type BadGatewayResponseErrorData = {
+    /**
+     * Error data for BadGatewayResponse
+     */
+    error: models.BadGatewayResponseErrorData;
+    userId?: string | null | undefined;
+};
+/**
+ * Bad Gateway - Provider/upstream API failure
+ */
+export declare class BadGatewayResponseError extends OpenRouterError {
+    /**
+     * Error data for BadGatewayResponse
+     */
+    error: models.BadGatewayResponseErrorData;
+    userId?: string | null | undefined;
+    /** The original data that was passed to this error instance. */
+    data$: BadGatewayResponseErrorData;
+    constructor(err: BadGatewayResponseErrorData, httpMeta: {
+        response: Response;
+        request: Request;
+        body: string;
+    });
+}
+/** @internal */
+export declare const BadGatewayResponseError$inboundSchema: z.ZodType<BadGatewayResponseError, unknown>;
+/** @internal */
+export type BadGatewayResponseError$Outbound = {
+    error: models.BadGatewayResponseErrorData$Outbound;
+    user_id?: string | null | undefined;
+};
+/** @internal */
+export declare const BadGatewayResponseError$outboundSchema: z.ZodType<BadGatewayResponseError$Outbound, BadGatewayResponseError>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace BadGatewayResponseError$ {
+    /** @deprecated use `BadGatewayResponseError$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<BadGatewayResponseError, unknown, z.core.$ZodTypeInternals<BadGatewayResponseError, unknown>>;
+    /** @deprecated use `BadGatewayResponseError$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<BadGatewayResponseError$Outbound, BadGatewayResponseError, z.core.$ZodTypeInternals<BadGatewayResponseError$Outbound, BadGatewayResponseError>>;
+    /** @deprecated use `BadGatewayResponseError$Outbound` instead. */
+    type Outbound = BadGatewayResponseError$Outbound;
+}
+//# sourceMappingURL=badgatewayresponseerror.d.ts.map

package/esm/models/errors/badgatewayresponseerror.js

@@ -0,0 +1,63 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import * as models from "../index.js";
+import { OpenRouterError } from "./openroutererror.js";
+/**
+ * Bad Gateway - Provider/upstream API failure
+ */
+export class BadGatewayResponseError extends OpenRouterError {
+    constructor(err, httpMeta) {
+        const message = err.error?.message
+            || `API error occurred: ${JSON.stringify(err)}`;
+        super(message, httpMeta);
+        this.data$ = err;
+        this.error = err.error;
+        if (err.userId != null)
+            this.userId = err.userId;
+        this.name = "BadGatewayResponseError";
+    }
+}
+/** @internal */
+export const BadGatewayResponseError$inboundSchema = z.object({
+    error: models.BadGatewayResponseErrorData$inboundSchema,
+    user_id: z.nullable(z.string()).optional(),
+    request$: z.custom(x => x instanceof Request),
+    response$: z.custom(x => x instanceof Response),
+    body$: z.string(),
+})
+    .transform((v) => {
+    const remapped = remap$(v, {
+        "user_id": "userId",
+    });
+    return new BadGatewayResponseError(remapped, {
+        request: v.request$,
+        response: v.response$,
+        body: v.body$,
+    });
+});
+/** @internal */
+export const BadGatewayResponseError$outboundSchema = z.custom(x => x instanceof BadGatewayResponseError)
+    .transform(v => v.data$)
+    .pipe(z.object({
+    error: models.BadGatewayResponseErrorData$outboundSchema,
+    userId: z.nullable(z.string()).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        userId: "user_id",
+    });
+}));
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var BadGatewayResponseError$;
+(function (BadGatewayResponseError$) {
+    /** @deprecated use `BadGatewayResponseError$inboundSchema` instead. */
+    BadGatewayResponseError$.inboundSchema = BadGatewayResponseError$inboundSchema;
+    /** @deprecated use `BadGatewayResponseError$outboundSchema` instead. */
+    BadGatewayResponseError$.outboundSchema = BadGatewayResponseError$outboundSchema;
+})(BadGatewayResponseError$ || (BadGatewayResponseError$ = {}));
+//# sourceMappingURL=badgatewayresponseerror.js.map