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

package/esm/models/responseserrorfield.js

@@ -4,7 +4,7 @@
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
 import { catchUnrecognizedEnum, } from "../types/enums.js";
-export const ResponsesErrorFieldCode = {
+export const CodeEnum = {
     ServerError: "server_error",
     RateLimitExceeded: "rate_limit_exceeded",
     InvalidPrompt: "invalid_prompt",
@@ -25,35 +25,35 @@ export const ResponsesErrorFieldCode = {
     ImageFileNotFound: "image_file_not_found",
 };
 /** @internal */
-export const ResponsesErrorFieldCode$inboundSchema = z
+export const CodeEnum$inboundSchema = z
     .union([
-    z.enum(ResponsesErrorFieldCode),
+    z.enum(CodeEnum),
     z.string().transform(catchUnrecognizedEnum),
 ]);
 /** @internal */
-export const ResponsesErrorFieldCode$outboundSchema = z.union([
-    z.enum(ResponsesErrorFieldCode),
+export const CodeEnum$outboundSchema = z.union([
+    z.enum(CodeEnum),
     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 ResponsesErrorFieldCode$;
-(function (ResponsesErrorFieldCode$) {
-    /** @deprecated use `ResponsesErrorFieldCode$inboundSchema` instead. */
-    ResponsesErrorFieldCode$.inboundSchema = ResponsesErrorFieldCode$inboundSchema;
-    /** @deprecated use `ResponsesErrorFieldCode$outboundSchema` instead. */
-    ResponsesErrorFieldCode$.outboundSchema = ResponsesErrorFieldCode$outboundSchema;
-})(ResponsesErrorFieldCode$ || (ResponsesErrorFieldCode$ = {}));
+export var CodeEnum$;
+(function (CodeEnum$) {
+    /** @deprecated use `CodeEnum$inboundSchema` instead. */
+    CodeEnum$.inboundSchema = CodeEnum$inboundSchema;
+    /** @deprecated use `CodeEnum$outboundSchema` instead. */
+    CodeEnum$.outboundSchema = CodeEnum$outboundSchema;
+})(CodeEnum$ || (CodeEnum$ = {}));
 /** @internal */
 export const ResponsesErrorField$inboundSchema = z.object({
-    code: ResponsesErrorFieldCode$inboundSchema,
+    code: CodeEnum$inboundSchema,
     message: z.string(),
 });
 /** @internal */
 export const ResponsesErrorField$outboundSchema = z.object({
-    code: ResponsesErrorFieldCode$outboundSchema,
+    code: CodeEnum$outboundSchema,
     message: z.string(),
 });
 /**

package/esm/models/responsetextconfig.d.ts

@@ -3,12 +3,12 @@ import { OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import { ResponseFormatTextConfig, ResponseFormatTextConfig$Outbound } from "./responseformattextconfig.js";
-export declare const Verbosity: {
+export declare const ResponseTextConfigVerbosity: {
     readonly High: "high";
     readonly Low: "low";
     readonly Medium: "medium";
 };
-export type Verbosity = OpenEnum<typeof Verbosity>;
+export type ResponseTextConfigVerbosity = OpenEnum<typeof ResponseTextConfigVerbosity>;
 /**
  * Text output configuration including format and verbosity
  */
@@ -17,21 +17,21 @@ export type ResponseTextConfig = {
      * Text response format configuration
      */
     format?: ResponseFormatTextConfig | undefined;
-    verbosity?: Verbosity | null | undefined;
+    verbosity?: ResponseTextConfigVerbosity | null | undefined;
 };
 /** @internal */
-export declare const Verbosity$inboundSchema: z.ZodType<Verbosity, unknown>;
+export declare const ResponseTextConfigVerbosity$inboundSchema: z.ZodType<ResponseTextConfigVerbosity, unknown>;
 /** @internal */
-export declare const Verbosity$outboundSchema: z.ZodType<Verbosity, Verbosity>;
+export declare const ResponseTextConfigVerbosity$outboundSchema: z.ZodType<ResponseTextConfigVerbosity, ResponseTextConfigVerbosity>;
 /**
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export declare namespace Verbosity$ {
-    /** @deprecated use `Verbosity$inboundSchema` instead. */
-    const inboundSchema: z.ZodType<Verbosity, unknown, z.core.$ZodTypeInternals<Verbosity, unknown>>;
-    /** @deprecated use `Verbosity$outboundSchema` instead. */
-    const outboundSchema: z.ZodType<Verbosity, Verbosity, z.core.$ZodTypeInternals<Verbosity, Verbosity>>;
+export declare namespace ResponseTextConfigVerbosity$ {
+    /** @deprecated use `ResponseTextConfigVerbosity$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<ResponseTextConfigVerbosity, unknown, z.core.$ZodTypeInternals<ResponseTextConfigVerbosity, unknown>>;
+    /** @deprecated use `ResponseTextConfigVerbosity$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<ResponseTextConfigVerbosity, ResponseTextConfigVerbosity, z.core.$ZodTypeInternals<ResponseTextConfigVerbosity, ResponseTextConfigVerbosity>>;
 }
 /** @internal */
 export declare const ResponseTextConfig$inboundSchema: z.ZodType<ResponseTextConfig, unknown>;

package/esm/models/responsetextconfig.js

@@ -5,43 +5,42 @@ import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
 import { catchUnrecognizedEnum, } from "../types/enums.js";
 import { ResponseFormatTextConfig$inboundSchema, ResponseFormatTextConfig$outboundSchema, } from "./responseformattextconfig.js";
-export const Verbosity = {
+export const ResponseTextConfigVerbosity = {
     High: "high",
     Low: "low",
     Medium: "medium",
 };
 /** @internal */
-export const Verbosity$inboundSchema = z
+export const ResponseTextConfigVerbosity$inboundSchema = z
     .union([
-    z.enum(Verbosity),
+    z.enum(ResponseTextConfigVerbosity),
     z.string().transform(catchUnrecognizedEnum),
 ]);
 /** @internal */
-export const Verbosity$outboundSchema = z
-    .union([
-    z.enum(Verbosity),
+export const ResponseTextConfigVerbosity$outboundSchema = z.union([
+    z.enum(ResponseTextConfigVerbosity),
     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 Verbosity$;
-(function (Verbosity$) {
-    /** @deprecated use `Verbosity$inboundSchema` instead. */
-    Verbosity$.inboundSchema = Verbosity$inboundSchema;
-    /** @deprecated use `Verbosity$outboundSchema` instead. */
-    Verbosity$.outboundSchema = Verbosity$outboundSchema;
-})(Verbosity$ || (Verbosity$ = {}));
+export var ResponseTextConfigVerbosity$;
+(function (ResponseTextConfigVerbosity$) {
+    /** @deprecated use `ResponseTextConfigVerbosity$inboundSchema` instead. */
+    ResponseTextConfigVerbosity$.inboundSchema = ResponseTextConfigVerbosity$inboundSchema;
+    /** @deprecated use `ResponseTextConfigVerbosity$outboundSchema` instead. */
+    ResponseTextConfigVerbosity$.outboundSchema = ResponseTextConfigVerbosity$outboundSchema;
+})(ResponseTextConfigVerbosity$ || (ResponseTextConfigVerbosity$ = {}));
 /** @internal */
 export const ResponseTextConfig$inboundSchema = z.object({
     format: ResponseFormatTextConfig$inboundSchema.optional(),
-    verbosity: z.nullable(Verbosity$inboundSchema).optional(),
+    verbosity: z.nullable(ResponseTextConfigVerbosity$inboundSchema).optional(),
 });
 /** @internal */
 export const ResponseTextConfig$outboundSchema = z.object({
     format: ResponseFormatTextConfig$outboundSchema.optional(),
-    verbosity: z.nullable(Verbosity$outboundSchema).optional(),
+    verbosity: z.nullable(ResponseTextConfigVerbosity$outboundSchema).optional(),
 });
 /**
  * @internal

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

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

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

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

package/esm/models/topproviderinfo.d.ts

@@ -0,0 +1,45 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Information about the top provider for this model
+ */
+export type TopProviderInfo = {
+    /**
+     * Context length from the top provider
+     */
+    contextLength?: number | null | undefined;
+    /**
+     * Maximum completion tokens from the top provider
+     */
+    maxCompletionTokens?: number | null | undefined;
+    /**
+     * Whether the top provider moderates content
+     */
+    isModerated: boolean;
+};
+/** @internal */
+export declare const TopProviderInfo$inboundSchema: z.ZodType<TopProviderInfo, unknown>;
+/** @internal */
+export type TopProviderInfo$Outbound = {
+    context_length?: number | null | undefined;
+    max_completion_tokens?: number | null | undefined;
+    is_moderated: boolean;
+};
+/** @internal */
+export declare const TopProviderInfo$outboundSchema: z.ZodType<TopProviderInfo$Outbound, TopProviderInfo>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace TopProviderInfo$ {
+    /** @deprecated use `TopProviderInfo$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<TopProviderInfo, unknown, z.core.$ZodTypeInternals<TopProviderInfo, unknown>>;
+    /** @deprecated use `TopProviderInfo$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<TopProviderInfo$Outbound, TopProviderInfo, z.core.$ZodTypeInternals<TopProviderInfo$Outbound, TopProviderInfo>>;
+    /** @deprecated use `TopProviderInfo$Outbound` instead. */
+    type Outbound = TopProviderInfo$Outbound;
+}
+export declare function topProviderInfoToJSON(topProviderInfo: TopProviderInfo): string;
+export declare function topProviderInfoFromJSON(jsonString: string): SafeParseResult<TopProviderInfo, SDKValidationError>;
+//# sourceMappingURL=topproviderinfo.d.ts.map

package/esm/models/topproviderinfo.js

@@ -0,0 +1,48 @@
+/*
+ * 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 TopProviderInfo$inboundSchema = z.object({
+    context_length: z.nullable(z.number()).optional(),
+    max_completion_tokens: z.nullable(z.number()).optional(),
+    is_moderated: z.boolean(),
+}).transform((v) => {
+    return remap$(v, {
+        "context_length": "contextLength",
+        "max_completion_tokens": "maxCompletionTokens",
+        "is_moderated": "isModerated",
+    });
+});
+/** @internal */
+export const TopProviderInfo$outboundSchema = z.object({
+    contextLength: z.nullable(z.number()).optional(),
+    maxCompletionTokens: z.nullable(z.number()).optional(),
+    isModerated: z.boolean(),
+}).transform((v) => {
+    return remap$(v, {
+        contextLength: "context_length",
+        maxCompletionTokens: "max_completion_tokens",
+        isModerated: "is_moderated",
+    });
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var TopProviderInfo$;
+(function (TopProviderInfo$) {
+    /** @deprecated use `TopProviderInfo$inboundSchema` instead. */
+    TopProviderInfo$.inboundSchema = TopProviderInfo$inboundSchema;
+    /** @deprecated use `TopProviderInfo$outboundSchema` instead. */
+    TopProviderInfo$.outboundSchema = TopProviderInfo$outboundSchema;
+})(TopProviderInfo$ || (TopProviderInfo$ = {}));
+export function topProviderInfoToJSON(topProviderInfo) {
+    return JSON.stringify(TopProviderInfo$outboundSchema.parse(topProviderInfo));
+}
+export function topProviderInfoFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => TopProviderInfo$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'TopProviderInfo' from JSON`);
+}
+//# sourceMappingURL=topproviderinfo.js.map

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

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

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

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

package/esm/react-query/modelsCount.d.ts

@@ -1,9 +1,9 @@
 import { InvalidateQueryFilters, QueryClient, QueryFunctionContext, QueryKey, UseQueryResult, UseSuspenseQueryResult } from "@tanstack/react-query";
 import { OpenRouterCore } from "../core.js";
 import { RequestOptions } from "../lib/sdks.js";
-import * as operations from "../models/operations/index.js";
+import * as models from "../models/index.js";
 import { QueryHookOptions, SuspenseQueryHookOptions } from "./_types.js";
-export type ModelsCountQueryData = operations.ListModelsCountResponse;
+export type ModelsCountQueryData = models.ModelsCountResponse;
 /**
  * Get total count of available models
  */

package/esm/react-query/modelsListForUser.d.ts

@@ -1,9 +1,10 @@
 import { InvalidateQueryFilters, QueryClient, QueryFunctionContext, QueryKey, UseQueryResult, UseSuspenseQueryResult } from "@tanstack/react-query";
 import { OpenRouterCore } from "../core.js";
 import { RequestOptions } from "../lib/sdks.js";
+import * as models from "../models/index.js";
 import * as operations from "../models/operations/index.js";
 import { QueryHookOptions, SuspenseQueryHookOptions } from "./_types.js";
-export type ModelsListForUserQueryData = operations.ListModelsUserResponse;
+export type ModelsListForUserQueryData = models.ModelsListResponse;
 /**
  * List models filtered by user provider preferences
  */

package/esm/sdk/models.d.ts

@@ -1,10 +1,11 @@
 import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as models from "../models/index.js";
 import * as operations from "../models/operations/index.js";
 export declare class Models extends ClientSDK {
     /**
      * Get total count of available models
      */
-    count(options?: RequestOptions): Promise<operations.ListModelsCountResponse>;
+    count(options?: RequestOptions): Promise<models.ModelsCountResponse>;
     /**
      * List all models and their properties
      */
@@ -12,6 +13,6 @@ export declare class Models extends ClientSDK {
     /**
      * List models filtered by user provider preferences
      */
-    listForUser(security: operations.ListModelsUserSecurity, options?: RequestOptions): Promise<operations.ListModelsUserResponse>;
+    listForUser(security: operations.ListModelsUserSecurity, options?: RequestOptions): Promise<models.ModelsListResponse>;
 }
 //# sourceMappingURL=models.d.ts.map

package/esm/sdk/responses.d.ts

@@ -1,3 +1,4 @@
+import { EventStream } from "../lib/event-streams.js";
 import { ClientSDK, RequestOptions } from "../lib/sdks.js";
 import * as models from "../models/index.js";
 import * as operations from "../models/operations/index.js";
@@ -8,6 +9,12 @@ export declare class Responses extends ClientSDK {
      * @remarks
      * Creates a streaming or non-streaming response using OpenResponses API format
      */
+    send(request: models.OpenResponsesRequest & {
+        stream?: false | undefined;
+    }, options?: RequestOptions): Promise<models.OpenResponsesNonStreamingResponse>;
+    send(request: models.OpenResponsesRequest & {
+        stream: true;
+    }, options?: RequestOptions): Promise<EventStream<operations.CreateApiAlphaResponsesResponseBody>>;
     send(request: models.OpenResponsesRequest, options?: RequestOptions): Promise<operations.CreateApiAlphaResponsesResponse>;
 }
 //# sourceMappingURL=responses.d.ts.map

package/esm/sdk/responses.js

@@ -5,12 +5,6 @@ import { betaResponsesSend } from "../funcs/betaResponsesSend.js";
 import { ClientSDK } from "../lib/sdks.js";
 import { unwrapAsync } from "../types/fp.js";
 export class Responses extends ClientSDK {
-    /**
-     * Create a response
-     *
-     * @remarks
-     * Creates a streaming or non-streaming response using OpenResponses API format
-     */
     async send(request, options) {
         return unwrapAsync(betaResponsesSend(this, request, options));
     }