@openrouter/sdk 0.0.1-beta.9 → 0.0.1

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

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

package/esm/models/errors/{errorresponse.js → notfoundresponseerror.js}

@@ -6,9 +6,9 @@ import { remap as remap$ } from "../../lib/primitives.js";
 import * as models from "../index.js";
 import { OpenRouterError } from "./openroutererror.js";
 /**
- * Error response
+ * Not Found - Resource does not exist
  */
-export class ErrorResponse extends OpenRouterError {
+export class NotFoundResponseError extends OpenRouterError {
     constructor(err, httpMeta) {
         const message = err.error?.message
             || `API error occurred: ${JSON.stringify(err)}`;
@@ -17,13 +17,12 @@ export class ErrorResponse extends OpenRouterError {
         this.error = err.error;
         if (err.userId != null)
             this.userId = err.userId;
-        this.name = "ErrorResponse";
+        this.name = "NotFoundResponseError";
     }
 }
 /** @internal */
-export const ErrorResponse$inboundSchema = z
-    .object({
-    error: z.lazy(() => models.ErrorResponseError$inboundSchema),
+export const NotFoundResponseError$inboundSchema = z.object({
+    error: models.NotFoundResponseErrorData$inboundSchema,
     user_id: z.nullable(z.string()).optional(),
     request$: z.custom(x => x instanceof Request),
     response$: z.custom(x => x instanceof Response),
@@ -33,17 +32,17 @@ export const ErrorResponse$inboundSchema = z
     const remapped = remap$(v, {
         "user_id": "userId",
     });
-    return new ErrorResponse(remapped, {
+    return new NotFoundResponseError(remapped, {
         request: v.request$,
         response: v.response$,
         body: v.body$,
     });
 });
 /** @internal */
-export const ErrorResponse$outboundSchema = z.custom(x => x instanceof ErrorResponse)
+export const NotFoundResponseError$outboundSchema = z.custom(x => x instanceof NotFoundResponseError)
     .transform(v => v.data$)
     .pipe(z.object({
-    error: z.lazy(() => models.ErrorResponseError$outboundSchema),
+    error: models.NotFoundResponseErrorData$outboundSchema,
     userId: z.nullable(z.string()).optional(),
 }).transform((v) => {
     return remap$(v, {
@@ -54,11 +53,11 @@ export const ErrorResponse$outboundSchema = z.custom(x => x instanceof ErrorResp
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export var ErrorResponse$;
-(function (ErrorResponse$) {
-    /** @deprecated use `ErrorResponse$inboundSchema` instead. */
-    ErrorResponse$.inboundSchema = ErrorResponse$inboundSchema;
-    /** @deprecated use `ErrorResponse$outboundSchema` instead. */
-    ErrorResponse$.outboundSchema = ErrorResponse$outboundSchema;
-})(ErrorResponse$ || (ErrorResponse$ = {}));
-//# sourceMappingURL=errorresponse.js.map
+export var NotFoundResponseError$;
+(function (NotFoundResponseError$) {
+    /** @deprecated use `NotFoundResponseError$inboundSchema` instead. */
+    NotFoundResponseError$.inboundSchema = NotFoundResponseError$inboundSchema;
+    /** @deprecated use `NotFoundResponseError$outboundSchema` instead. */
+    NotFoundResponseError$.outboundSchema = NotFoundResponseError$outboundSchema;
+})(NotFoundResponseError$ || (NotFoundResponseError$ = {}));
+//# sourceMappingURL=notfoundresponseerror.js.map

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

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

package/esm/models/errors/payloadtoolargeresponseerror.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";
+/**
+ * Payload Too Large - Request payload exceeds size limits
+ */
+export class PayloadTooLargeResponseError 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 = "PayloadTooLargeResponseError";
+    }
+}
+/** @internal */
+export const PayloadTooLargeResponseError$inboundSchema = z.object({
+    error: models.PayloadTooLargeResponseErrorData$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 PayloadTooLargeResponseError(remapped, {
+        request: v.request$,
+        response: v.response$,
+        body: v.body$,
+    });
+});
+/** @internal */
+export const PayloadTooLargeResponseError$outboundSchema = z.custom(x => x instanceof PayloadTooLargeResponseError)
+    .transform(v => v.data$)
+    .pipe(z.object({
+    error: models.PayloadTooLargeResponseErrorData$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 PayloadTooLargeResponseError$;
+(function (PayloadTooLargeResponseError$) {
+    /** @deprecated use `PayloadTooLargeResponseError$inboundSchema` instead. */
+    PayloadTooLargeResponseError$.inboundSchema = PayloadTooLargeResponseError$inboundSchema;
+    /** @deprecated use `PayloadTooLargeResponseError$outboundSchema` instead. */
+    PayloadTooLargeResponseError$.outboundSchema = PayloadTooLargeResponseError$outboundSchema;
+})(PayloadTooLargeResponseError$ || (PayloadTooLargeResponseError$ = {}));
+//# sourceMappingURL=payloadtoolargeresponseerror.js.map

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

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

package/esm/models/errors/paymentrequiredresponseerror.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";
+/**
+ * Payment Required - Insufficient credits or quota to complete request
+ */
+export class PaymentRequiredResponseError 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 = "PaymentRequiredResponseError";
+    }
+}
+/** @internal */
+export const PaymentRequiredResponseError$inboundSchema = z.object({
+    error: models.PaymentRequiredResponseErrorData$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 PaymentRequiredResponseError(remapped, {
+        request: v.request$,
+        response: v.response$,
+        body: v.body$,
+    });
+});
+/** @internal */
+export const PaymentRequiredResponseError$outboundSchema = z.custom(x => x instanceof PaymentRequiredResponseError)
+    .transform(v => v.data$)
+    .pipe(z.object({
+    error: models.PaymentRequiredResponseErrorData$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 PaymentRequiredResponseError$;
+(function (PaymentRequiredResponseError$) {
+    /** @deprecated use `PaymentRequiredResponseError$inboundSchema` instead. */
+    PaymentRequiredResponseError$.inboundSchema = PaymentRequiredResponseError$inboundSchema;
+    /** @deprecated use `PaymentRequiredResponseError$outboundSchema` instead. */
+    PaymentRequiredResponseError$.outboundSchema = PaymentRequiredResponseError$outboundSchema;
+})(PaymentRequiredResponseError$ || (PaymentRequiredResponseError$ = {}));
+//# sourceMappingURL=paymentrequiredresponseerror.js.map

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

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

package/esm/models/errors/provideroverloadedresponseerror.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";
+/**
+ * Provider Overloaded - Provider is temporarily overloaded
+ */
+export class ProviderOverloadedResponseError 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 = "ProviderOverloadedResponseError";
+    }
+}
+/** @internal */
+export const ProviderOverloadedResponseError$inboundSchema = z.object({
+    error: models.ProviderOverloadedResponseErrorData$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 ProviderOverloadedResponseError(remapped, {
+        request: v.request$,
+        response: v.response$,
+        body: v.body$,
+    });
+});
+/** @internal */
+export const ProviderOverloadedResponseError$outboundSchema = z.custom(x => x instanceof ProviderOverloadedResponseError)
+    .transform(v => v.data$)
+    .pipe(z.object({
+    error: models.ProviderOverloadedResponseErrorData$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 ProviderOverloadedResponseError$;
+(function (ProviderOverloadedResponseError$) {
+    /** @deprecated use `ProviderOverloadedResponseError$inboundSchema` instead. */
+    ProviderOverloadedResponseError$.inboundSchema = ProviderOverloadedResponseError$inboundSchema;
+    /** @deprecated use `ProviderOverloadedResponseError$outboundSchema` instead. */
+    ProviderOverloadedResponseError$.outboundSchema = ProviderOverloadedResponseError$outboundSchema;
+})(ProviderOverloadedResponseError$ || (ProviderOverloadedResponseError$ = {}));
+//# sourceMappingURL=provideroverloadedresponseerror.js.map

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

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

package/esm/models/errors/requesttimeoutresponseerror.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";
+/**
+ * Request Timeout - Operation exceeded time limit
+ */
+export class RequestTimeoutResponseError 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 = "RequestTimeoutResponseError";
+    }
+}
+/** @internal */
+export const RequestTimeoutResponseError$inboundSchema = z.object({
+    error: models.RequestTimeoutResponseErrorData$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 RequestTimeoutResponseError(remapped, {
+        request: v.request$,
+        response: v.response$,
+        body: v.body$,
+    });
+});
+/** @internal */
+export const RequestTimeoutResponseError$outboundSchema = z.custom(x => x instanceof RequestTimeoutResponseError)
+    .transform(v => v.data$)
+    .pipe(z.object({
+    error: models.RequestTimeoutResponseErrorData$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 RequestTimeoutResponseError$;
+(function (RequestTimeoutResponseError$) {
+    /** @deprecated use `RequestTimeoutResponseError$inboundSchema` instead. */
+    RequestTimeoutResponseError$.inboundSchema = RequestTimeoutResponseError$inboundSchema;
+    /** @deprecated use `RequestTimeoutResponseError$outboundSchema` instead. */
+    RequestTimeoutResponseError$.outboundSchema = RequestTimeoutResponseError$outboundSchema;
+})(RequestTimeoutResponseError$ || (RequestTimeoutResponseError$ = {}));
+//# sourceMappingURL=requesttimeoutresponseerror.js.map

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

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