@openrouter/sdk 0.11.2 → 0.12.1

package/esm/models/inputaudio.d.ts

@@ -2,26 +2,26 @@ 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 InputAudioFormat: {
+export declare const FormatEnum: {
     readonly Mp3: "mp3";
     readonly Wav: "wav";
 };
-export type InputAudioFormat = OpenEnum<typeof InputAudioFormat>;
+export type FormatEnum = OpenEnum<typeof FormatEnum>;
 export type InputAudioInputAudio = {
     data: string;
-    format: InputAudioFormat;
+    format: FormatEnum;
 };
 /**
  * Audio input content item
  */
 export type InputAudio = {
-    type: "input_audio";
     inputAudio: InputAudioInputAudio;
+    type: "input_audio";
 };
 /** @internal */
-export declare const InputAudioFormat$inboundSchema: z.ZodType<InputAudioFormat, unknown>;
+export declare const FormatEnum$inboundSchema: z.ZodType<FormatEnum, unknown>;
 /** @internal */
-export declare const InputAudioFormat$outboundSchema: z.ZodType<string, InputAudioFormat>;
+export declare const FormatEnum$outboundSchema: z.ZodType<string, FormatEnum>;
 /** @internal */
 export declare const InputAudioInputAudio$inboundSchema: z.ZodType<InputAudioInputAudio, unknown>;
 /** @internal */
@@ -37,8 +37,8 @@ export declare function inputAudioInputAudioFromJSON(jsonString: string): SafePa
 export declare const InputAudio$inboundSchema: z.ZodType<InputAudio, unknown>;
 /** @internal */
 export type InputAudio$Outbound = {
-    type: "input_audio";
     input_audio: InputAudioInputAudio$Outbound;
+    type: "input_audio";
 };
 /** @internal */
 export declare const InputAudio$outboundSchema: z.ZodType<InputAudio$Outbound, InputAudio>;

package/esm/models/inputaudio.js

@@ -6,23 +6,23 @@ import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import * as openEnums from "../types/enums.js";
-export const InputAudioFormat = {
+export const FormatEnum = {
     Mp3: "mp3",
     Wav: "wav",
 };
 /** @internal */
-export const InputAudioFormat$inboundSchema = openEnums.inboundSchema(InputAudioFormat);
+export const FormatEnum$inboundSchema = openEnums.inboundSchema(FormatEnum);
 /** @internal */
-export const InputAudioFormat$outboundSchema = openEnums.outboundSchema(InputAudioFormat);
+export const FormatEnum$outboundSchema = openEnums.outboundSchema(FormatEnum);
 /** @internal */
 export const InputAudioInputAudio$inboundSchema = z.object({
     data: z.string(),
-    format: InputAudioFormat$inboundSchema,
+    format: FormatEnum$inboundSchema,
 });
 /** @internal */
 export const InputAudioInputAudio$outboundSchema = z.object({
     data: z.string(),
-    format: InputAudioFormat$outboundSchema,
+    format: FormatEnum$outboundSchema,
 });
 export function inputAudioInputAudioToJSON(inputAudioInputAudio) {
     return JSON.stringify(InputAudioInputAudio$outboundSchema.parse(inputAudioInputAudio));
@@ -33,8 +33,8 @@ export function inputAudioInputAudioFromJSON(jsonString) {
 /** @internal */
 export const InputAudio$inboundSchema = z
     .object({
-    type: z.literal("input_audio"),
     input_audio: z.lazy(() => InputAudioInputAudio$inboundSchema),
+    type: z.literal("input_audio"),
 }).transform((v) => {
     return remap$(v, {
         "input_audio": "inputAudio",
@@ -42,8 +42,8 @@ export const InputAudio$inboundSchema = z
 });
 /** @internal */
 export const InputAudio$outboundSchema = z.object({
-    type: z.literal("input_audio"),
     inputAudio: z.lazy(() => InputAudioInputAudio$outboundSchema),
+    type: z.literal("input_audio"),
 }).transform((v) => {
     return remap$(v, {
         inputAudio: "input_audio",

package/esm/models/inputfile.d.ts

@@ -5,21 +5,21 @@ import { SDKValidationError } from "./errors/sdkvalidationerror.js";
  * File input content item
  */
 export type InputFile = {
-    type: "input_file";
-    fileId?: string | null | undefined;
     fileData?: string | undefined;
-    filename?: string | undefined;
+    fileId?: string | null | undefined;
     fileUrl?: string | undefined;
+    filename?: string | undefined;
+    type: "input_file";
 };
 /** @internal */
 export declare const InputFile$inboundSchema: z.ZodType<InputFile, unknown>;
 /** @internal */
 export type InputFile$Outbound = {
-    type: "input_file";
-    file_id?: string | null | undefined;
     file_data?: string | undefined;
-    filename?: string | undefined;
+    file_id?: string | null | undefined;
     file_url?: string | undefined;
+    filename?: string | undefined;
+    type: "input_file";
 };
 /** @internal */
 export declare const InputFile$outboundSchema: z.ZodType<InputFile$Outbound, InputFile>;

package/esm/models/inputfile.js

@@ -7,29 +7,29 @@ import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
 export const InputFile$inboundSchema = z.object({
-    type: z.literal("input_file"),
-    file_id: z.nullable(z.string()).optional(),
     file_data: z.string().optional(),
-    filename: z.string().optional(),
+    file_id: z.nullable(z.string()).optional(),
     file_url: z.string().optional(),
+    filename: z.string().optional(),
+    type: z.literal("input_file"),
 }).transform((v) => {
     return remap$(v, {
-        "file_id": "fileId",
         "file_data": "fileData",
+        "file_id": "fileId",
         "file_url": "fileUrl",
     });
 });
 /** @internal */
 export const InputFile$outboundSchema = z.object({
-    type: z.literal("input_file"),
-    fileId: z.nullable(z.string()).optional(),
     fileData: z.string().optional(),
-    filename: z.string().optional(),
+    fileId: z.nullable(z.string()).optional(),
     fileUrl: z.string().optional(),
+    filename: z.string().optional(),
+    type: z.literal("input_file"),
 }).transform((v) => {
     return remap$(v, {
-        fileId: "file_id",
         fileData: "file_data",
+        fileId: "file_id",
         fileUrl: "file_url",
     });
 });

package/esm/models/inputimage.d.ts

@@ -2,39 +2,39 @@ import * as z from "zod/v4";
 import { ClosedEnum, OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-export declare const InputImageTypeEnum: {
-    readonly InputImage: "input_image";
-};
-export type InputImageTypeEnum = ClosedEnum<typeof InputImageTypeEnum>;
 export declare const InputImageDetail: {
     readonly Auto: "auto";
     readonly High: "high";
     readonly Low: "low";
 };
 export type InputImageDetail = OpenEnum<typeof InputImageDetail>;
+export declare const InputImageTypeEnum: {
+    readonly InputImage: "input_image";
+};
+export type InputImageTypeEnum = ClosedEnum<typeof InputImageTypeEnum>;
 /**
  * Image input content item
  */
 export type InputImage = {
-    type: InputImageTypeEnum;
     detail: InputImageDetail;
     imageUrl?: string | null | undefined;
+    type: InputImageTypeEnum;
 };
 /** @internal */
-export declare const InputImageTypeEnum$inboundSchema: z.ZodEnum<typeof InputImageTypeEnum>;
-/** @internal */
-export declare const InputImageTypeEnum$outboundSchema: z.ZodEnum<typeof InputImageTypeEnum>;
-/** @internal */
 export declare const InputImageDetail$inboundSchema: z.ZodType<InputImageDetail, unknown>;
 /** @internal */
 export declare const InputImageDetail$outboundSchema: z.ZodType<string, InputImageDetail>;
 /** @internal */
+export declare const InputImageTypeEnum$inboundSchema: z.ZodEnum<typeof InputImageTypeEnum>;
+/** @internal */
+export declare const InputImageTypeEnum$outboundSchema: z.ZodEnum<typeof InputImageTypeEnum>;
+/** @internal */
 export declare const InputImage$inboundSchema: z.ZodType<InputImage, unknown>;
 /** @internal */
 export type InputImage$Outbound = {
-    type: string;
     detail: string;
     image_url?: string | null | undefined;
+    type: string;
 };
 /** @internal */
 export declare const InputImage$outboundSchema: z.ZodType<InputImage$Outbound, InputImage>;

package/esm/models/inputimage.js

@@ -6,28 +6,28 @@ import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import * as openEnums from "../types/enums.js";
-export const InputImageTypeEnum = {
-    InputImage: "input_image",
-};
 export const InputImageDetail = {
     Auto: "auto",
     High: "high",
     Low: "low",
 };
-/** @internal */
-export const InputImageTypeEnum$inboundSchema = z.enum(InputImageTypeEnum);
-/** @internal */
-export const InputImageTypeEnum$outboundSchema = InputImageTypeEnum$inboundSchema;
+export const InputImageTypeEnum = {
+    InputImage: "input_image",
+};
 /** @internal */
 export const InputImageDetail$inboundSchema = openEnums.inboundSchema(InputImageDetail);
 /** @internal */
 export const InputImageDetail$outboundSchema = openEnums.outboundSchema(InputImageDetail);
 /** @internal */
+export const InputImageTypeEnum$inboundSchema = z.enum(InputImageTypeEnum);
+/** @internal */
+export const InputImageTypeEnum$outboundSchema = InputImageTypeEnum$inboundSchema;
+/** @internal */
 export const InputImage$inboundSchema = z
     .object({
-    type: InputImageTypeEnum$inboundSchema,
     detail: InputImageDetail$inboundSchema,
     image_url: z.nullable(z.string()).optional(),
+    type: InputImageTypeEnum$inboundSchema,
 }).transform((v) => {
     return remap$(v, {
         "image_url": "imageUrl",
@@ -35,9 +35,9 @@ export const InputImage$inboundSchema = z
 });
 /** @internal */
 export const InputImage$outboundSchema = z.object({
-    type: InputImageTypeEnum$outboundSchema,
     detail: InputImageDetail$outboundSchema,
     imageUrl: z.nullable(z.string()).optional(),
+    type: InputImageTypeEnum$outboundSchema,
 }).transform((v) => {
     return remap$(v, {
         imageUrl: "image_url",

package/esm/models/inputmessageitem.d.ts

@@ -4,10 +4,21 @@ import { InputAudio, InputAudio$Outbound } from "./inputaudio.js";
 import { InputFile, InputFile$Outbound } from "./inputfile.js";
 import { InputText, InputText$Outbound } from "./inputtext.js";
 import { InputVideo, InputVideo$Outbound } from "./inputvideo.js";
-export declare const InputMessageItemTypeMessage: {
-    readonly Message: "message";
+export declare const InputMessageItemDetail: {
+    readonly Auto: "auto";
+    readonly High: "high";
+    readonly Low: "low";
 };
-export type InputMessageItemTypeMessage = ClosedEnum<typeof InputMessageItemTypeMessage>;
+export type InputMessageItemDetail = OpenEnum<typeof InputMessageItemDetail>;
+/**
+ * Image input content item
+ */
+export type InputMessageItemContentInputImage = {
+    detail: InputMessageItemDetail;
+    imageUrl?: string | null | undefined;
+    type: "input_image";
+};
+export type InputMessageItemContentUnion = InputText | InputMessageItemContentInputImage | InputFile | InputAudio | InputVideo;
 export declare const InputMessageItemRoleDeveloper: {
     readonly Developer: "developer";
 };
@@ -21,47 +32,23 @@ export declare const InputMessageItemRoleUser: {
 };
 export type InputMessageItemRoleUser = ClosedEnum<typeof InputMessageItemRoleUser>;
 export type InputMessageItemRoleUnion = InputMessageItemRoleUser | InputMessageItemRoleSystem | InputMessageItemRoleDeveloper;
-export declare const InputMessageItemDetail: {
-    readonly Auto: "auto";
-    readonly High: "high";
-    readonly Low: "low";
-};
-export type InputMessageItemDetail = OpenEnum<typeof InputMessageItemDetail>;
-/**
- * Image input content item
- */
-export type InputMessageItemContentInputImage = {
-    type: "input_image";
-    detail: InputMessageItemDetail;
-    imageUrl?: string | null | undefined;
+export declare const InputMessageItemTypeMessage: {
+    readonly Message: "message";
 };
-export type InputMessageItemContentUnion = InputText | InputMessageItemContentInputImage | InputFile | InputAudio | InputVideo;
+export type InputMessageItemTypeMessage = ClosedEnum<typeof InputMessageItemTypeMessage>;
 export type InputMessageItem = {
+    content?: Array<InputText | InputMessageItemContentInputImage | InputFile | InputAudio | InputVideo> | null | undefined;
     id?: string | undefined;
-    type?: InputMessageItemTypeMessage | undefined;
     role: InputMessageItemRoleUser | InputMessageItemRoleSystem | InputMessageItemRoleDeveloper;
-    content?: Array<InputText | InputMessageItemContentInputImage | InputFile | InputAudio | InputVideo> | null | undefined;
+    type?: InputMessageItemTypeMessage | undefined;
 };
 /** @internal */
-export declare const InputMessageItemTypeMessage$outboundSchema: z.ZodEnum<typeof InputMessageItemTypeMessage>;
-/** @internal */
-export declare const InputMessageItemRoleDeveloper$outboundSchema: z.ZodEnum<typeof InputMessageItemRoleDeveloper>;
-/** @internal */
-export declare const InputMessageItemRoleSystem$outboundSchema: z.ZodEnum<typeof InputMessageItemRoleSystem>;
-/** @internal */
-export declare const InputMessageItemRoleUser$outboundSchema: z.ZodEnum<typeof InputMessageItemRoleUser>;
-/** @internal */
-export type InputMessageItemRoleUnion$Outbound = string | string | string;
-/** @internal */
-export declare const InputMessageItemRoleUnion$outboundSchema: z.ZodType<InputMessageItemRoleUnion$Outbound, InputMessageItemRoleUnion>;
-export declare function inputMessageItemRoleUnionToJSON(inputMessageItemRoleUnion: InputMessageItemRoleUnion): string;
-/** @internal */
 export declare const InputMessageItemDetail$outboundSchema: z.ZodType<string, InputMessageItemDetail>;
 /** @internal */
 export type InputMessageItemContentInputImage$Outbound = {
-    type: "input_image";
     detail: string;
     image_url?: string | null | undefined;
+    type: "input_image";
 };
 /** @internal */
 export declare const InputMessageItemContentInputImage$outboundSchema: z.ZodType<InputMessageItemContentInputImage$Outbound, InputMessageItemContentInputImage>;
@@ -72,11 +59,24 @@ export type InputMessageItemContentUnion$Outbound = InputText$Outbound | InputMe
 export declare const InputMessageItemContentUnion$outboundSchema: z.ZodType<InputMessageItemContentUnion$Outbound, InputMessageItemContentUnion>;
 export declare function inputMessageItemContentUnionToJSON(inputMessageItemContentUnion: InputMessageItemContentUnion): string;
 /** @internal */
+export declare const InputMessageItemRoleDeveloper$outboundSchema: z.ZodEnum<typeof InputMessageItemRoleDeveloper>;
+/** @internal */
+export declare const InputMessageItemRoleSystem$outboundSchema: z.ZodEnum<typeof InputMessageItemRoleSystem>;
+/** @internal */
+export declare const InputMessageItemRoleUser$outboundSchema: z.ZodEnum<typeof InputMessageItemRoleUser>;
+/** @internal */
+export type InputMessageItemRoleUnion$Outbound = string | string | string;
+/** @internal */
+export declare const InputMessageItemRoleUnion$outboundSchema: z.ZodType<InputMessageItemRoleUnion$Outbound, InputMessageItemRoleUnion>;
+export declare function inputMessageItemRoleUnionToJSON(inputMessageItemRoleUnion: InputMessageItemRoleUnion): string;
+/** @internal */
+export declare const InputMessageItemTypeMessage$outboundSchema: z.ZodEnum<typeof InputMessageItemTypeMessage>;
+/** @internal */
 export type InputMessageItem$Outbound = {
+    content?: Array<InputText$Outbound | InputMessageItemContentInputImage$Outbound | InputFile$Outbound | InputAudio$Outbound | InputVideo$Outbound> | null | undefined;
     id?: string | undefined;
-    type?: string | undefined;
     role: string | string | string;
-    content?: Array<InputText$Outbound | InputMessageItemContentInputImage$Outbound | InputFile$Outbound | InputAudio$Outbound | InputVideo$Outbound> | null | undefined;
+    type?: string | undefined;
 };
 /** @internal */
 export declare const InputMessageItem$outboundSchema: z.ZodType<InputMessageItem$Outbound, InputMessageItem>;

package/esm/models/inputmessageitem.js

@@ -9,8 +9,10 @@ import { InputAudio$outboundSchema, } from "./inputaudio.js";
 import { InputFile$outboundSchema, } from "./inputfile.js";
 import { InputText$outboundSchema, } from "./inputtext.js";
 import { InputVideo$outboundSchema, } from "./inputvideo.js";
-export const InputMessageItemTypeMessage = {
-    Message: "message",
+export const InputMessageItemDetail = {
+    Auto: "auto",
+    High: "high",
+    Low: "low",
 };
 export const InputMessageItemRoleDeveloper = {
     Developer: "developer",
@@ -21,35 +23,16 @@ export const InputMessageItemRoleSystem = {
 export const InputMessageItemRoleUser = {
     User: "user",
 };
-export const InputMessageItemDetail = {
-    Auto: "auto",
-    High: "high",
-    Low: "low",
+export const InputMessageItemTypeMessage = {
+    Message: "message",
 };
 /** @internal */
-export const InputMessageItemTypeMessage$outboundSchema = z.enum(InputMessageItemTypeMessage);
-/** @internal */
-export const InputMessageItemRoleDeveloper$outboundSchema = z.enum(InputMessageItemRoleDeveloper);
-/** @internal */
-export const InputMessageItemRoleSystem$outboundSchema = z.enum(InputMessageItemRoleSystem);
-/** @internal */
-export const InputMessageItemRoleUser$outboundSchema = z.enum(InputMessageItemRoleUser);
-/** @internal */
-export const InputMessageItemRoleUnion$outboundSchema = z.union([
-    InputMessageItemRoleUser$outboundSchema,
-    InputMessageItemRoleSystem$outboundSchema,
-    InputMessageItemRoleDeveloper$outboundSchema,
-]);
-export function inputMessageItemRoleUnionToJSON(inputMessageItemRoleUnion) {
-    return JSON.stringify(InputMessageItemRoleUnion$outboundSchema.parse(inputMessageItemRoleUnion));
-}
-/** @internal */
 export const InputMessageItemDetail$outboundSchema = openEnums.outboundSchema(InputMessageItemDetail);
 /** @internal */
 export const InputMessageItemContentInputImage$outboundSchema = z.object({
-    type: z.literal("input_image"),
     detail: InputMessageItemDetail$outboundSchema,
     imageUrl: z.nullable(z.string()).optional(),
+    type: z.literal("input_image"),
 }).transform((v) => {
     return remap$(v, {
         imageUrl: "image_url",
@@ -70,14 +53,24 @@ export function inputMessageItemContentUnionToJSON(inputMessageItemContentUnion)
     return JSON.stringify(InputMessageItemContentUnion$outboundSchema.parse(inputMessageItemContentUnion));
 }
 /** @internal */
+export const InputMessageItemRoleDeveloper$outboundSchema = z.enum(InputMessageItemRoleDeveloper);
+/** @internal */
+export const InputMessageItemRoleSystem$outboundSchema = z.enum(InputMessageItemRoleSystem);
+/** @internal */
+export const InputMessageItemRoleUser$outboundSchema = z.enum(InputMessageItemRoleUser);
+/** @internal */
+export const InputMessageItemRoleUnion$outboundSchema = z.union([
+    InputMessageItemRoleUser$outboundSchema,
+    InputMessageItemRoleSystem$outboundSchema,
+    InputMessageItemRoleDeveloper$outboundSchema,
+]);
+export function inputMessageItemRoleUnionToJSON(inputMessageItemRoleUnion) {
+    return JSON.stringify(InputMessageItemRoleUnion$outboundSchema.parse(inputMessageItemRoleUnion));
+}
+/** @internal */
+export const InputMessageItemTypeMessage$outboundSchema = z.enum(InputMessageItemTypeMessage);
+/** @internal */
 export const InputMessageItem$outboundSchema = z.object({
-    id: z.string().optional(),
-    type: InputMessageItemTypeMessage$outboundSchema.optional(),
-    role: z.union([
-        InputMessageItemRoleUser$outboundSchema,
-        InputMessageItemRoleSystem$outboundSchema,
-        InputMessageItemRoleDeveloper$outboundSchema,
-    ]),
     content: z.nullable(z.array(z.union([
         InputText$outboundSchema,
         z.lazy(() => InputMessageItemContentInputImage$outboundSchema),
@@ -85,6 +78,13 @@ export const InputMessageItem$outboundSchema = z.object({
         InputAudio$outboundSchema,
         InputVideo$outboundSchema,
     ]))).optional(),
+    id: z.string().optional(),
+    role: z.union([
+        InputMessageItemRoleUser$outboundSchema,
+        InputMessageItemRoleSystem$outboundSchema,
+        InputMessageItemRoleDeveloper$outboundSchema,
+    ]),
+    type: InputMessageItemTypeMessage$outboundSchema.optional(),
 });
 export function inputMessageItemToJSON(inputMessageItem) {
     return JSON.stringify(InputMessageItem$outboundSchema.parse(inputMessageItem));