@openrouter/sdk 0.0.1-beta.3 → 0.0.1-beta.5

package/lib/security.js

@@ -0,0 +1,136 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import { env } from "./env.js";
+export var SecurityErrorCode;
+(function (SecurityErrorCode) {
+    SecurityErrorCode["Incomplete"] = "incomplete";
+    SecurityErrorCode["UnrecognisedSecurityType"] = "unrecognized_security_type";
+})(SecurityErrorCode || (SecurityErrorCode = {}));
+export class SecurityError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "SecurityError";
+    }
+    static incomplete() {
+        return new SecurityError(SecurityErrorCode.Incomplete, "Security requirements not met in order to perform the operation");
+    }
+    static unrecognizedType(type) {
+        return new SecurityError(SecurityErrorCode.UnrecognisedSecurityType, `Unrecognised security type: ${type}`);
+    }
+}
+export function resolveSecurity(...options) {
+    const state = {
+        basic: {},
+        headers: {},
+        queryParams: {},
+        cookies: {},
+        oauth2: { type: "none" },
+    };
+    const option = options.find((opts) => {
+        return opts.every((o) => {
+            if (o.value == null) {
+                return false;
+            }
+            else if (o.type === "http:basic") {
+                return o.value.username != null || o.value.password != null;
+            }
+            else if (o.type === "http:custom") {
+                return null;
+            }
+            else if (o.type === "oauth2:password") {
+                return (typeof o.value === "string" && !!o.value);
+            }
+            else if (o.type === "oauth2:client_credentials") {
+                if (typeof o.value == "string") {
+                    return !!o.value;
+                }
+                return o.value.clientID != null || o.value.clientSecret != null;
+            }
+            else if (typeof o.value === "string") {
+                return !!o.value;
+            }
+            else {
+                throw new Error(`Unrecognized security type: ${o.type} (value type: ${typeof o
+                    .value})`);
+            }
+        });
+    });
+    if (option == null) {
+        return null;
+    }
+    option.forEach((spec) => {
+        if (spec.value == null) {
+            return;
+        }
+        const { type } = spec;
+        switch (type) {
+            case "apiKey:header":
+                state.headers[spec.fieldName] = spec.value;
+                break;
+            case "apiKey:query":
+                state.queryParams[spec.fieldName] = spec.value;
+                break;
+            case "apiKey:cookie":
+                state.cookies[spec.fieldName] = spec.value;
+                break;
+            case "http:basic":
+                applyBasic(state, spec);
+                break;
+            case "http:custom":
+                break;
+            case "http:bearer":
+                applyBearer(state, spec);
+                break;
+            case "oauth2":
+                applyBearer(state, spec);
+                break;
+            case "oauth2:password":
+                applyBearer(state, spec);
+                break;
+            case "oauth2:client_credentials":
+                break;
+            case "openIdConnect":
+                applyBearer(state, spec);
+                break;
+            default:
+                spec;
+                throw SecurityError.unrecognizedType(type);
+        }
+    });
+    return state;
+}
+function applyBasic(state, spec) {
+    if (spec.value == null) {
+        return;
+    }
+    state.basic = spec.value;
+}
+function applyBearer(state, spec) {
+    if (typeof spec.value !== "string" || !spec.value) {
+        return;
+    }
+    let value = spec.value;
+    if (value.slice(0, 7).toLowerCase() !== "bearer ") {
+        value = `Bearer ${value}`;
+    }
+    if (spec.fieldName !== undefined) {
+        state.headers[spec.fieldName] = value;
+    }
+}
+export function resolveGlobalSecurity(security) {
+    return resolveSecurity([
+        {
+            fieldName: "Authorization",
+            type: "http:bearer",
+            value: security?.apiKey ?? env().OPENROUTER_API_KEY,
+        },
+    ]);
+}
+export async function extractSecurity(sec) {
+    if (sec == null) {
+        return;
+    }
+    return typeof sec === "function" ? sec() : sec;
+}

package/lib/url.d.ts

@@ -0,0 +1,4 @@
+export type Params = Partial<Record<string, string | number>>;
+export declare function pathToFunc(pathPattern: string, options?: {
+    charEncoding?: "percent" | "none";
+}): (params?: Params) => string;

package/lib/url.js

@@ -0,0 +1,21 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+const hasOwn = Object.prototype.hasOwnProperty;
+export function pathToFunc(pathPattern, options) {
+    const paramRE = /\{([a-zA-Z0-9_][a-zA-Z0-9_-]*?)\}/g;
+    return function buildURLPath(params = {}) {
+        return pathPattern.replace(paramRE, function (_, placeholder) {
+            if (!hasOwn.call(params, placeholder)) {
+                throw new Error(`Parameter '${placeholder}' is required`);
+            }
+            const value = params[placeholder];
+            if (typeof value !== "string" && typeof value !== "number") {
+                throw new Error(`Parameter '${placeholder}' must be a string or number`);
+            }
+            return options?.charEncoding === "percent"
+                ? encodeURIComponent(`${value}`)
+                : `${value}`;
+        });
+    };
+}

package/models/activityitem.d.ts

@@ -0,0 +1,81 @@
+import * as z from "zod/v3";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type ActivityItem = {
+    /**
+     * Date of the activity (YYYY-MM-DD format)
+     */
+    date: string;
+    /**
+     * Model slug (e.g., "openai/gpt-4.1")
+     */
+    model: string;
+    /**
+     * Model permaslug (e.g., "openai/gpt-4.1-2025-04-14")
+     */
+    modelPermaslug: string;
+    /**
+     * Unique identifier for the endpoint
+     */
+    endpointId: string;
+    /**
+     * Name of the provider serving this endpoint
+     */
+    providerName: string;
+    /**
+     * Total cost in USD (OpenRouter credits spent)
+     */
+    usage: number;
+    /**
+     * BYOK inference cost in USD (external credits spent)
+     */
+    byokUsageInference: number;
+    /**
+     * Number of requests made
+     */
+    requests: number;
+    /**
+     * Total prompt tokens used
+     */
+    promptTokens: number;
+    /**
+     * Total completion tokens generated
+     */
+    completionTokens: number;
+    /**
+     * Total reasoning tokens used
+     */
+    reasoningTokens: number;
+};
+/** @internal */
+export declare const ActivityItem$inboundSchema: z.ZodType<ActivityItem, z.ZodTypeDef, unknown>;
+/** @internal */
+export type ActivityItem$Outbound = {
+    date: string;
+    model: string;
+    model_permaslug: string;
+    endpoint_id: string;
+    provider_name: string;
+    usage: number;
+    byok_usage_inference: number;
+    requests: number;
+    prompt_tokens: number;
+    completion_tokens: number;
+    reasoning_tokens: number;
+};
+/** @internal */
+export declare const ActivityItem$outboundSchema: z.ZodType<ActivityItem$Outbound, z.ZodTypeDef, ActivityItem>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ActivityItem$ {
+    /** @deprecated use `ActivityItem$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<ActivityItem, z.ZodTypeDef, unknown>;
+    /** @deprecated use `ActivityItem$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<ActivityItem$Outbound, z.ZodTypeDef, ActivityItem>;
+    /** @deprecated use `ActivityItem$Outbound` instead. */
+    type Outbound = ActivityItem$Outbound;
+}
+export declare function activityItemToJSON(activityItem: ActivityItem): string;
+export declare function activityItemFromJSON(jsonString: string): SafeParseResult<ActivityItem, SDKValidationError>;

package/models/activityitem.js

@@ -0,0 +1,71 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v3";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const ActivityItem$inboundSchema = z.object({
+    date: z.string(),
+    model: z.string(),
+    model_permaslug: z.string(),
+    endpoint_id: z.string(),
+    provider_name: z.string(),
+    usage: z.number(),
+    byok_usage_inference: z.number(),
+    requests: z.number(),
+    prompt_tokens: z.number(),
+    completion_tokens: z.number(),
+    reasoning_tokens: z.number(),
+}).transform((v) => {
+    return remap$(v, {
+        "model_permaslug": "modelPermaslug",
+        "endpoint_id": "endpointId",
+        "provider_name": "providerName",
+        "byok_usage_inference": "byokUsageInference",
+        "prompt_tokens": "promptTokens",
+        "completion_tokens": "completionTokens",
+        "reasoning_tokens": "reasoningTokens",
+    });
+});
+/** @internal */
+export const ActivityItem$outboundSchema = z.object({
+    date: z.string(),
+    model: z.string(),
+    modelPermaslug: z.string(),
+    endpointId: z.string(),
+    providerName: z.string(),
+    usage: z.number(),
+    byokUsageInference: z.number(),
+    requests: z.number(),
+    promptTokens: z.number(),
+    completionTokens: z.number(),
+    reasoningTokens: z.number(),
+}).transform((v) => {
+    return remap$(v, {
+        modelPermaslug: "model_permaslug",
+        endpointId: "endpoint_id",
+        providerName: "provider_name",
+        byokUsageInference: "byok_usage_inference",
+        promptTokens: "prompt_tokens",
+        completionTokens: "completion_tokens",
+        reasoningTokens: "reasoning_tokens",
+    });
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var ActivityItem$;
+(function (ActivityItem$) {
+    /** @deprecated use `ActivityItem$inboundSchema` instead. */
+    ActivityItem$.inboundSchema = ActivityItem$inboundSchema;
+    /** @deprecated use `ActivityItem$outboundSchema` instead. */
+    ActivityItem$.outboundSchema = ActivityItem$outboundSchema;
+})(ActivityItem$ || (ActivityItem$ = {}));
+export function activityItemToJSON(activityItem) {
+    return JSON.stringify(ActivityItem$outboundSchema.parse(activityItem));
+}
+export function activityItemFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ActivityItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ActivityItem' from JSON`);
+}

package/models/assistantmessage.d.ts

@@ -0,0 +1,61 @@
+import * as z from "zod/v3";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { ChatMessageContentItem, ChatMessageContentItem$Outbound } from "./chatmessagecontentitem.js";
+import { ChatMessageToolCall, ChatMessageToolCall$Outbound } from "./chatmessagetoolcall.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type AssistantMessageContent = string | Array<ChatMessageContentItem>;
+export type AssistantMessage = {
+    role: "assistant";
+    content?: string | Array<ChatMessageContentItem> | null | undefined;
+    name?: string | undefined;
+    toolCalls?: Array<ChatMessageToolCall> | undefined;
+    refusal?: string | null | undefined;
+    reasoning?: string | null | undefined;
+};
+/** @internal */
+export declare const AssistantMessageContent$inboundSchema: z.ZodType<AssistantMessageContent, z.ZodTypeDef, unknown>;
+/** @internal */
+export type AssistantMessageContent$Outbound = string | Array<ChatMessageContentItem$Outbound>;
+/** @internal */
+export declare const AssistantMessageContent$outboundSchema: z.ZodType<AssistantMessageContent$Outbound, z.ZodTypeDef, AssistantMessageContent>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace AssistantMessageContent$ {
+    /** @deprecated use `AssistantMessageContent$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<AssistantMessageContent, z.ZodTypeDef, unknown>;
+    /** @deprecated use `AssistantMessageContent$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<AssistantMessageContent$Outbound, z.ZodTypeDef, AssistantMessageContent>;
+    /** @deprecated use `AssistantMessageContent$Outbound` instead. */
+    type Outbound = AssistantMessageContent$Outbound;
+}
+export declare function assistantMessageContentToJSON(assistantMessageContent: AssistantMessageContent): string;
+export declare function assistantMessageContentFromJSON(jsonString: string): SafeParseResult<AssistantMessageContent, SDKValidationError>;
+/** @internal */
+export declare const AssistantMessage$inboundSchema: z.ZodType<AssistantMessage, z.ZodTypeDef, unknown>;
+/** @internal */
+export type AssistantMessage$Outbound = {
+    role: "assistant";
+    content?: string | Array<ChatMessageContentItem$Outbound> | null | undefined;
+    name?: string | undefined;
+    tool_calls?: Array<ChatMessageToolCall$Outbound> | undefined;
+    refusal?: string | null | undefined;
+    reasoning?: string | null | undefined;
+};
+/** @internal */
+export declare const AssistantMessage$outboundSchema: z.ZodType<AssistantMessage$Outbound, z.ZodTypeDef, AssistantMessage>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace AssistantMessage$ {
+    /** @deprecated use `AssistantMessage$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<AssistantMessage, z.ZodTypeDef, unknown>;
+    /** @deprecated use `AssistantMessage$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<AssistantMessage$Outbound, z.ZodTypeDef, AssistantMessage>;
+    /** @deprecated use `AssistantMessage$Outbound` instead. */
+    type Outbound = AssistantMessage$Outbound;
+}
+export declare function assistantMessageToJSON(assistantMessage: AssistantMessage): string;
+export declare function assistantMessageFromJSON(jsonString: string): SafeParseResult<AssistantMessage, SDKValidationError>;

package/models/assistantmessage.js

@@ -0,0 +1,72 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v3";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { ChatMessageContentItem$inboundSchema, ChatMessageContentItem$outboundSchema, } from "./chatmessagecontentitem.js";
+import { ChatMessageToolCall$inboundSchema, ChatMessageToolCall$outboundSchema, } from "./chatmessagetoolcall.js";
+/** @internal */
+export const AssistantMessageContent$inboundSchema = z.union([z.string(), z.array(ChatMessageContentItem$inboundSchema)]);
+/** @internal */
+export const AssistantMessageContent$outboundSchema = z.union([z.string(), z.array(ChatMessageContentItem$outboundSchema)]);
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var AssistantMessageContent$;
+(function (AssistantMessageContent$) {
+    /** @deprecated use `AssistantMessageContent$inboundSchema` instead. */
+    AssistantMessageContent$.inboundSchema = AssistantMessageContent$inboundSchema;
+    /** @deprecated use `AssistantMessageContent$outboundSchema` instead. */
+    AssistantMessageContent$.outboundSchema = AssistantMessageContent$outboundSchema;
+})(AssistantMessageContent$ || (AssistantMessageContent$ = {}));
+export function assistantMessageContentToJSON(assistantMessageContent) {
+    return JSON.stringify(AssistantMessageContent$outboundSchema.parse(assistantMessageContent));
+}
+export function assistantMessageContentFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AssistantMessageContent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AssistantMessageContent' from JSON`);
+}
+/** @internal */
+export const AssistantMessage$inboundSchema = z.object({
+    role: z.literal("assistant"),
+    content: z.nullable(z.union([z.string(), z.array(ChatMessageContentItem$inboundSchema)])).optional(),
+    name: z.string().optional(),
+    tool_calls: z.array(ChatMessageToolCall$inboundSchema).optional(),
+    refusal: z.nullable(z.string()).optional(),
+    reasoning: z.nullable(z.string()).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "tool_calls": "toolCalls",
+    });
+});
+/** @internal */
+export const AssistantMessage$outboundSchema = z.object({
+    role: z.literal("assistant"),
+    content: z.nullable(z.union([z.string(), z.array(ChatMessageContentItem$outboundSchema)])).optional(),
+    name: z.string().optional(),
+    toolCalls: z.array(ChatMessageToolCall$outboundSchema).optional(),
+    refusal: z.nullable(z.string()).optional(),
+    reasoning: z.nullable(z.string()).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        toolCalls: "tool_calls",
+    });
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var AssistantMessage$;
+(function (AssistantMessage$) {
+    /** @deprecated use `AssistantMessage$inboundSchema` instead. */
+    AssistantMessage$.inboundSchema = AssistantMessage$inboundSchema;
+    /** @deprecated use `AssistantMessage$outboundSchema` instead. */
+    AssistantMessage$.outboundSchema = AssistantMessage$outboundSchema;
+})(AssistantMessage$ || (AssistantMessage$ = {}));
+export function assistantMessageToJSON(assistantMessage) {
+    return JSON.stringify(AssistantMessage$outboundSchema.parse(assistantMessage));
+}
+export function assistantMessageFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AssistantMessage$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AssistantMessage' from JSON`);
+}

package/models/chatcompletionfinishreason.d.ts

@@ -0,0 +1,24 @@
+import * as z from "zod/v3";
+import { OpenEnum } from "../types/enums.js";
+export declare const ChatCompletionFinishReason: {
+    readonly ToolCalls: "tool_calls";
+    readonly Stop: "stop";
+    readonly Length: "length";
+    readonly ContentFilter: "content_filter";
+    readonly Error: "error";
+};
+export type ChatCompletionFinishReason = OpenEnum<typeof ChatCompletionFinishReason>;
+/** @internal */
+export declare const ChatCompletionFinishReason$inboundSchema: z.ZodType<ChatCompletionFinishReason, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const ChatCompletionFinishReason$outboundSchema: z.ZodType<ChatCompletionFinishReason, z.ZodTypeDef, ChatCompletionFinishReason>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ChatCompletionFinishReason$ {
+    /** @deprecated use `ChatCompletionFinishReason$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<ChatCompletionFinishReason, z.ZodTypeDef, unknown>;
+    /** @deprecated use `ChatCompletionFinishReason$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<ChatCompletionFinishReason, z.ZodTypeDef, ChatCompletionFinishReason>;
+}

package/models/chatcompletionfinishreason.js

@@ -0,0 +1,34 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v3";
+import { catchUnrecognizedEnum, } from "../types/enums.js";
+export const ChatCompletionFinishReason = {
+    ToolCalls: "tool_calls",
+    Stop: "stop",
+    Length: "length",
+    ContentFilter: "content_filter",
+    Error: "error",
+};
+/** @internal */
+export const ChatCompletionFinishReason$inboundSchema = z
+    .union([
+    z.nativeEnum(ChatCompletionFinishReason),
+    z.string().transform(catchUnrecognizedEnum),
+]);
+/** @internal */
+export const ChatCompletionFinishReason$outboundSchema = z.union([
+    z.nativeEnum(ChatCompletionFinishReason),
+    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 ChatCompletionFinishReason$;
+(function (ChatCompletionFinishReason$) {
+    /** @deprecated use `ChatCompletionFinishReason$inboundSchema` instead. */
+    ChatCompletionFinishReason$.inboundSchema = ChatCompletionFinishReason$inboundSchema;
+    /** @deprecated use `ChatCompletionFinishReason$outboundSchema` instead. */
+    ChatCompletionFinishReason$.outboundSchema = ChatCompletionFinishReason$outboundSchema;
+})(ChatCompletionFinishReason$ || (ChatCompletionFinishReason$ = {}));

package/models/chaterror.d.ts

@@ -0,0 +1,55 @@
+import * as z from "zod/v3";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type Code = string | number;
+export type ChatErrorError = {
+    code: string | number | null;
+    message: string;
+    param: string | null;
+    type: string;
+};
+/** @internal */
+export declare const Code$inboundSchema: z.ZodType<Code, z.ZodTypeDef, unknown>;
+/** @internal */
+export type Code$Outbound = string | number;
+/** @internal */
+export declare const Code$outboundSchema: z.ZodType<Code$Outbound, z.ZodTypeDef, Code>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace Code$ {
+    /** @deprecated use `Code$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<Code, z.ZodTypeDef, unknown>;
+    /** @deprecated use `Code$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<Code$Outbound, z.ZodTypeDef, Code>;
+    /** @deprecated use `Code$Outbound` instead. */
+    type Outbound = Code$Outbound;
+}
+export declare function codeToJSON(code: Code): string;
+export declare function codeFromJSON(jsonString: string): SafeParseResult<Code, SDKValidationError>;
+/** @internal */
+export declare const ChatErrorError$inboundSchema: z.ZodType<ChatErrorError, z.ZodTypeDef, unknown>;
+/** @internal */
+export type ChatErrorError$Outbound = {
+    code: string | number | null;
+    message: string;
+    param: string | null;
+    type: string;
+};
+/** @internal */
+export declare const ChatErrorError$outboundSchema: z.ZodType<ChatErrorError$Outbound, z.ZodTypeDef, ChatErrorError>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ChatErrorError$ {
+    /** @deprecated use `ChatErrorError$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<ChatErrorError, z.ZodTypeDef, unknown>;
+    /** @deprecated use `ChatErrorError$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<ChatErrorError$Outbound, z.ZodTypeDef, ChatErrorError>;
+    /** @deprecated use `ChatErrorError$Outbound` instead. */
+    type Outbound = ChatErrorError$Outbound;
+}
+export declare function chatErrorErrorToJSON(chatErrorError: ChatErrorError): string;
+export declare function chatErrorErrorFromJSON(jsonString: string): SafeParseResult<ChatErrorError, SDKValidationError>;

package/models/chaterror.js

@@ -0,0 +1,58 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v3";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const Code$inboundSchema = z
+    .union([z.string(), z.number()]);
+/** @internal */
+export const Code$outboundSchema = z.union([z.string(), z.number()]);
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var Code$;
+(function (Code$) {
+    /** @deprecated use `Code$inboundSchema` instead. */
+    Code$.inboundSchema = Code$inboundSchema;
+    /** @deprecated use `Code$outboundSchema` instead. */
+    Code$.outboundSchema = Code$outboundSchema;
+})(Code$ || (Code$ = {}));
+export function codeToJSON(code) {
+    return JSON.stringify(Code$outboundSchema.parse(code));
+}
+export function codeFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Code$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Code' from JSON`);
+}
+/** @internal */
+export const ChatErrorError$inboundSchema = z.object({
+    code: z.nullable(z.union([z.string(), z.number()])),
+    message: z.string(),
+    param: z.nullable(z.string()),
+    type: z.string(),
+});
+/** @internal */
+export const ChatErrorError$outboundSchema = z.object({
+    code: z.nullable(z.union([z.string(), z.number()])),
+    message: z.string(),
+    param: z.nullable(z.string()),
+    type: z.string(),
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var ChatErrorError$;
+(function (ChatErrorError$) {
+    /** @deprecated use `ChatErrorError$inboundSchema` instead. */
+    ChatErrorError$.inboundSchema = ChatErrorError$inboundSchema;
+    /** @deprecated use `ChatErrorError$outboundSchema` instead. */
+    ChatErrorError$.outboundSchema = ChatErrorError$outboundSchema;
+})(ChatErrorError$ || (ChatErrorError$ = {}));
+export function chatErrorErrorToJSON(chatErrorError) {
+    return JSON.stringify(ChatErrorError$outboundSchema.parse(chatErrorError));
+}
+export function chatErrorErrorFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatErrorError$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatErrorError' from JSON`);
+}