@openrouter/sdk 0.2.11 → 0.3.2

package/esm/lib/config.d.ts

@@ -45,8 +45,8 @@ export declare function serverURLFromOptions(options: SDKOptions): URL | null;
 export declare const SDK_METADATA: {
     readonly language: "typescript";
     readonly openapiDocVersion: "1.0.0";
-    readonly sdkVersion: "0.2.11";
-    readonly genVersion: "2.768.0";
-    readonly userAgent: "speakeasy-sdk/typescript 0.2.11 2.768.0 1.0.0 @openrouter/sdk";
+    readonly sdkVersion: "0.3.2";
+    readonly genVersion: "2.788.4";
+    readonly userAgent: "speakeasy-sdk/typescript 0.3.2 2.788.4 1.0.0 @openrouter/sdk";
 };
 //# sourceMappingURL=config.d.ts.map

package/esm/lib/config.js

@@ -25,8 +25,8 @@ export function serverURLFromOptions(options) {
 export const SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "1.0.0",
-    sdkVersion: "0.2.11",
-    genVersion: "2.768.0",
-    userAgent: "speakeasy-sdk/typescript 0.2.11 2.768.0 1.0.0 @openrouter/sdk",
+    sdkVersion: "0.3.2",
+    genVersion: "2.788.4",
+    userAgent: "speakeasy-sdk/typescript 0.3.2 2.788.4 1.0.0 @openrouter/sdk",
 };
 //# sourceMappingURL=config.js.map

package/esm/lib/event-streams.js

@@ -20,7 +20,7 @@ export class EventStream extends ReadableStream {
                         const message = buffer.slice(0, match.index);
                         buffer = buffer.slice(match.index + match.length);
                         const item = parseMessage(message, parse);
-                        if (item?.value)
+                        if (item && !item.done)
                             return downstream.enqueue(item.value);
                         if (item?.done) {
                             await upstream.cancel("done");

package/esm/models/chatgenerationparams.d.ts

@@ -2,6 +2,7 @@ import * as z from "zod/v4";
 import { OpenEnum } from "../types/enums.js";
 import { ChatStreamOptions, ChatStreamOptions$Outbound } from "./chatstreamoptions.js";
 import { Message, Message$Outbound } from "./message.js";
+import { ProviderSortUnion, ProviderSortUnion$Outbound } from "./providersortunion.js";
 import { ReasoningSummaryVerbosity } from "./reasoningsummaryverbosity.js";
 import { ResponseFormatJSONSchema, ResponseFormatJSONSchema$Outbound } from "./responseformatjsonschema.js";
 import { ResponseFormatTextGrammar, ResponseFormatTextGrammar$Outbound } from "./responseformattextgrammar.js";
@@ -24,12 +25,6 @@ export declare const Quantizations: {
     readonly Unknown: "unknown";
 };
 export type Quantizations = OpenEnum<typeof Quantizations>;
-export declare const Sort: {
-    readonly Price: "price";
-    readonly Throughput: "throughput";
-    readonly Latency: "latency";
-};
-export type Sort = OpenEnum<typeof Sort>;
 /**
  * The object specifying the maximum price you want to pay for this request. USD price per million tokens, for prompt and completion.
  */
@@ -83,67 +78,62 @@ export type ChatGenerationParamsProvider = {
     /**
      * The sorting strategy to use for this request, if "order" is not specified. When set, no load balancing is performed.
      */
-    sort?: Sort | null | undefined;
+    sort?: ProviderSortUnion | null | undefined;
     /**
      * The object specifying the maximum price you want to pay for this request. USD price per million tokens, for prompt and completion.
      */
     maxPrice?: ChatGenerationParamsMaxPrice | undefined;
-    /**
-     * The minimum throughput (in tokens per second) required for this request. Only providers serving the model with at least this throughput will be used.
-     */
+    preferredMinThroughput?: number | null | undefined;
+    preferredMaxLatency?: number | null | undefined;
     minThroughput?: number | null | undefined;
-    /**
-     * The maximum latency (in seconds) allowed for this request. Only providers serving the model with better than this latency will be used.
-     */
     maxLatency?: number | null | undefined;
 };
 export type ChatGenerationParamsPluginResponseHealing = {
     id: "response-healing";
     enabled?: boolean | undefined;
 };
-export declare const ChatGenerationParamsPdfEngine: {
+export declare const PdfEngine: {
     readonly MistralOcr: "mistral-ocr";
     readonly PdfText: "pdf-text";
     readonly Native: "native";
 };
-export type ChatGenerationParamsPdfEngine = OpenEnum<typeof ChatGenerationParamsPdfEngine>;
-export type ChatGenerationParamsPdf = {
-    engine?: ChatGenerationParamsPdfEngine | undefined;
+export type PdfEngine = OpenEnum<typeof PdfEngine>;
+export type Pdf = {
+    engine?: PdfEngine | undefined;
 };
 export type ChatGenerationParamsPluginFileParser = {
     id: "file-parser";
     enabled?: boolean | undefined;
-    maxFiles?: number | undefined;
-    pdf?: ChatGenerationParamsPdf | undefined;
+    pdf?: Pdf | undefined;
 };
-export declare const ChatGenerationParamsEngine: {
+export declare const Engine: {
     readonly Native: "native";
     readonly Exa: "exa";
 };
-export type ChatGenerationParamsEngine = OpenEnum<typeof ChatGenerationParamsEngine>;
+export type Engine = OpenEnum<typeof Engine>;
 export type ChatGenerationParamsPluginWeb = {
     id: "web";
     enabled?: boolean | undefined;
     maxResults?: number | undefined;
     searchPrompt?: string | undefined;
-    engine?: ChatGenerationParamsEngine | undefined;
+    engine?: Engine | undefined;
 };
 export type ChatGenerationParamsPluginModeration = {
     id: "moderation";
 };
 export type ChatGenerationParamsPluginUnion = ChatGenerationParamsPluginModeration | ChatGenerationParamsPluginWeb | ChatGenerationParamsPluginFileParser | ChatGenerationParamsPluginResponseHealing;
-export declare const ChatGenerationParamsRoute: {
+export declare const Route: {
     readonly Fallback: "fallback";
     readonly Sort: "sort";
 };
-export type ChatGenerationParamsRoute = OpenEnum<typeof ChatGenerationParamsRoute>;
+export type Route = OpenEnum<typeof Route>;
 export declare const Effort: {
-    readonly None: "none";
-    readonly Minimal: "minimal";
-    readonly Low: "low";
-    readonly Medium: "medium";
-    readonly High: "high";
     readonly Xhigh: "xhigh";
+    readonly High: "high";
+    readonly Medium: "medium";
+    readonly Low: "low";
+    readonly Minimal: "minimal";
+    readonly None: "none";
 };
 export type Effort = OpenEnum<typeof Effort>;
 export type Reasoning = {
@@ -173,10 +163,7 @@ export type ChatGenerationParams = {
      * Plugins you want to enable for this request, including their settings.
      */
     plugins?: Array<ChatGenerationParamsPluginModeration | ChatGenerationParamsPluginWeb | ChatGenerationParamsPluginFileParser | ChatGenerationParamsPluginResponseHealing> | undefined;
-    /**
-     * Routing strategy for multiple models: "fallback" (default) uses secondary models as backups, "sort" sorts all endpoints together by routing criteria.
-     */
-    route?: ChatGenerationParamsRoute | null | undefined;
+    route?: Route | null | undefined;
     user?: string | undefined;
     /**
      * A unique identifier for grouping related requests (e.g., a conversation or agent workflow) for observability. If provided in both the request body and the x-session-id header, the body value takes precedence. Maximum of 128 characters.
@@ -214,8 +201,6 @@ export declare const ChatGenerationParamsDataCollection$outboundSchema: z.ZodTyp
 /** @internal */
 export declare const Quantizations$outboundSchema: z.ZodType<string, Quantizations>;
 /** @internal */
-export declare const Sort$outboundSchema: z.ZodType<string, Sort>;
-/** @internal */
 export type ChatGenerationParamsMaxPrice$Outbound = {
     prompt?: any | undefined;
     completion?: any | undefined;
@@ -237,8 +222,10 @@ export type ChatGenerationParamsProvider$Outbound = {
     only?: Array<Schema0$Outbound> | null | undefined;
     ignore?: Array<Schema0$Outbound> | null | undefined;
     quantizations?: Array<string> | null | undefined;
-    sort?: string | null | undefined;
+    sort?: ProviderSortUnion$Outbound | null | undefined;
     max_price?: ChatGenerationParamsMaxPrice$Outbound | undefined;
+    preferred_min_throughput?: number | null | undefined;
+    preferred_max_latency?: number | null | undefined;
     min_throughput?: number | null | undefined;
     max_latency?: number | null | undefined;
 };
@@ -254,26 +241,25 @@ export type ChatGenerationParamsPluginResponseHealing$Outbound = {
 export declare const ChatGenerationParamsPluginResponseHealing$outboundSchema: z.ZodType<ChatGenerationParamsPluginResponseHealing$Outbound, ChatGenerationParamsPluginResponseHealing>;
 export declare function chatGenerationParamsPluginResponseHealingToJSON(chatGenerationParamsPluginResponseHealing: ChatGenerationParamsPluginResponseHealing): string;
 /** @internal */
-export declare const ChatGenerationParamsPdfEngine$outboundSchema: z.ZodType<string, ChatGenerationParamsPdfEngine>;
+export declare const PdfEngine$outboundSchema: z.ZodType<string, PdfEngine>;
 /** @internal */
-export type ChatGenerationParamsPdf$Outbound = {
+export type Pdf$Outbound = {
     engine?: string | undefined;
 };
 /** @internal */
-export declare const ChatGenerationParamsPdf$outboundSchema: z.ZodType<ChatGenerationParamsPdf$Outbound, ChatGenerationParamsPdf>;
-export declare function chatGenerationParamsPdfToJSON(chatGenerationParamsPdf: ChatGenerationParamsPdf): string;
+export declare const Pdf$outboundSchema: z.ZodType<Pdf$Outbound, Pdf>;
+export declare function pdfToJSON(pdf: Pdf): string;
 /** @internal */
 export type ChatGenerationParamsPluginFileParser$Outbound = {
     id: "file-parser";
     enabled?: boolean | undefined;
-    max_files?: number | undefined;
-    pdf?: ChatGenerationParamsPdf$Outbound | undefined;
+    pdf?: Pdf$Outbound | undefined;
 };
 /** @internal */
 export declare const ChatGenerationParamsPluginFileParser$outboundSchema: z.ZodType<ChatGenerationParamsPluginFileParser$Outbound, ChatGenerationParamsPluginFileParser>;
 export declare function chatGenerationParamsPluginFileParserToJSON(chatGenerationParamsPluginFileParser: ChatGenerationParamsPluginFileParser): string;
 /** @internal */
-export declare const ChatGenerationParamsEngine$outboundSchema: z.ZodType<string, ChatGenerationParamsEngine>;
+export declare const Engine$outboundSchema: z.ZodType<string, Engine>;
 /** @internal */
 export type ChatGenerationParamsPluginWeb$Outbound = {
     id: "web";
@@ -298,7 +284,7 @@ export type ChatGenerationParamsPluginUnion$Outbound = ChatGenerationParamsPlugi
 export declare const ChatGenerationParamsPluginUnion$outboundSchema: z.ZodType<ChatGenerationParamsPluginUnion$Outbound, ChatGenerationParamsPluginUnion>;
 export declare function chatGenerationParamsPluginUnionToJSON(chatGenerationParamsPluginUnion: ChatGenerationParamsPluginUnion): string;
 /** @internal */
-export declare const ChatGenerationParamsRoute$outboundSchema: z.ZodType<string, ChatGenerationParamsRoute>;
+export declare const Route$outboundSchema: z.ZodType<string, Route>;
 /** @internal */
 export declare const Effort$outboundSchema: z.ZodType<string, Effort>;
 /** @internal */

package/esm/models/chatgenerationparams.js

@@ -6,6 +6,7 @@ import { remap as remap$ } from "../lib/primitives.js";
 import * as openEnums from "../types/enums.js";
 import { ChatStreamOptions$outboundSchema, } from "./chatstreamoptions.js";
 import { Message$outboundSchema, } from "./message.js";
+import { ProviderSortUnion$outboundSchema, } from "./providersortunion.js";
 import { ReasoningSummaryVerbosity$outboundSchema, } from "./reasoningsummaryverbosity.js";
 import { ResponseFormatJSONSchema$outboundSchema, } from "./responseformatjsonschema.js";
 import { ResponseFormatTextGrammar$outboundSchema, } from "./responseformattextgrammar.js";
@@ -26,40 +27,32 @@ export const Quantizations = {
     Fp32: "fp32",
     Unknown: "unknown",
 };
-export const Sort = {
-    Price: "price",
-    Throughput: "throughput",
-    Latency: "latency",
-};
-export const ChatGenerationParamsPdfEngine = {
+export const PdfEngine = {
     MistralOcr: "mistral-ocr",
     PdfText: "pdf-text",
     Native: "native",
 };
-export const ChatGenerationParamsEngine = {
+export const Engine = {
     Native: "native",
     Exa: "exa",
 };
-export const ChatGenerationParamsRoute = {
+export const Route = {
     Fallback: "fallback",
     Sort: "sort",
 };
 export const Effort = {
-    None: "none",
-    Minimal: "minimal",
-    Low: "low",
-    Medium: "medium",
-    High: "high",
     Xhigh: "xhigh",
+    High: "high",
+    Medium: "medium",
+    Low: "low",
+    Minimal: "minimal",
+    None: "none",
 };
 /** @internal */
 export const ChatGenerationParamsDataCollection$outboundSchema = openEnums.outboundSchema(ChatGenerationParamsDataCollection);
 /** @internal */
 export const Quantizations$outboundSchema = openEnums.outboundSchema(Quantizations);
 /** @internal */
-export const Sort$outboundSchema = openEnums
-    .outboundSchema(Sort);
-/** @internal */
 export const ChatGenerationParamsMaxPrice$outboundSchema = z.object({
     prompt: z.any().optional(),
     completion: z.any().optional(),
@@ -82,9 +75,11 @@ export const ChatGenerationParamsProvider$outboundSchema = z.object({
     only: z.nullable(z.array(Schema0$outboundSchema)).optional(),
     ignore: z.nullable(z.array(Schema0$outboundSchema)).optional(),
     quantizations: z.nullable(z.array(Quantizations$outboundSchema)).optional(),
-    sort: z.nullable(Sort$outboundSchema).optional(),
+    sort: z.nullable(ProviderSortUnion$outboundSchema).optional(),
     maxPrice: z.lazy(() => ChatGenerationParamsMaxPrice$outboundSchema)
         .optional(),
+    preferredMinThroughput: z.nullable(z.number()).optional(),
+    preferredMaxLatency: z.nullable(z.number()).optional(),
     minThroughput: z.nullable(z.number()).optional(),
     maxLatency: z.nullable(z.number()).optional(),
 }).transform((v) => {
@@ -94,6 +89,8 @@ export const ChatGenerationParamsProvider$outboundSchema = z.object({
         dataCollection: "data_collection",
         enforceDistillableText: "enforce_distillable_text",
         maxPrice: "max_price",
+        preferredMinThroughput: "preferred_min_throughput",
+        preferredMaxLatency: "preferred_max_latency",
         minThroughput: "min_throughput",
         maxLatency: "max_latency",
     });
@@ -110,37 +107,34 @@ export function chatGenerationParamsPluginResponseHealingToJSON(chatGenerationPa
     return JSON.stringify(ChatGenerationParamsPluginResponseHealing$outboundSchema.parse(chatGenerationParamsPluginResponseHealing));
 }
 /** @internal */
-export const ChatGenerationParamsPdfEngine$outboundSchema = openEnums.outboundSchema(ChatGenerationParamsPdfEngine);
+export const PdfEngine$outboundSchema = openEnums
+    .outboundSchema(PdfEngine);
 /** @internal */
-export const ChatGenerationParamsPdf$outboundSchema = z.object({
-    engine: ChatGenerationParamsPdfEngine$outboundSchema.optional(),
+export const Pdf$outboundSchema = z.object({
+    engine: PdfEngine$outboundSchema.optional(),
 });
-export function chatGenerationParamsPdfToJSON(chatGenerationParamsPdf) {
-    return JSON.stringify(ChatGenerationParamsPdf$outboundSchema.parse(chatGenerationParamsPdf));
+export function pdfToJSON(pdf) {
+    return JSON.stringify(Pdf$outboundSchema.parse(pdf));
 }
 /** @internal */
 export const ChatGenerationParamsPluginFileParser$outboundSchema = z.object({
     id: z.literal("file-parser"),
     enabled: z.boolean().optional(),
-    maxFiles: z.number().optional(),
-    pdf: z.lazy(() => ChatGenerationParamsPdf$outboundSchema).optional(),
-}).transform((v) => {
-    return remap$(v, {
-        maxFiles: "max_files",
-    });
+    pdf: z.lazy(() => Pdf$outboundSchema).optional(),
 });
 export function chatGenerationParamsPluginFileParserToJSON(chatGenerationParamsPluginFileParser) {
     return JSON.stringify(ChatGenerationParamsPluginFileParser$outboundSchema.parse(chatGenerationParamsPluginFileParser));
 }
 /** @internal */
-export const ChatGenerationParamsEngine$outboundSchema = openEnums.outboundSchema(ChatGenerationParamsEngine);
+export const Engine$outboundSchema = openEnums
+    .outboundSchema(Engine);
 /** @internal */
 export const ChatGenerationParamsPluginWeb$outboundSchema = z.object({
     id: z.literal("web"),
     enabled: z.boolean().optional(),
     maxResults: z.number().optional(),
     searchPrompt: z.string().optional(),
-    engine: ChatGenerationParamsEngine$outboundSchema.optional(),
+    engine: Engine$outboundSchema.optional(),
 }).transform((v) => {
     return remap$(v, {
         maxResults: "max_results",
@@ -168,7 +162,8 @@ export function chatGenerationParamsPluginUnionToJSON(chatGenerationParamsPlugin
     return JSON.stringify(ChatGenerationParamsPluginUnion$outboundSchema.parse(chatGenerationParamsPluginUnion));
 }
 /** @internal */
-export const ChatGenerationParamsRoute$outboundSchema = openEnums.outboundSchema(ChatGenerationParamsRoute);
+export const Route$outboundSchema = openEnums
+    .outboundSchema(Route);
 /** @internal */
 export const Effort$outboundSchema = openEnums
     .outboundSchema(Effort);
@@ -237,7 +232,7 @@ export const ChatGenerationParams$outboundSchema = z.object({
         z.lazy(() => ChatGenerationParamsPluginFileParser$outboundSchema),
         z.lazy(() => ChatGenerationParamsPluginResponseHealing$outboundSchema),
     ])).optional(),
-    route: z.nullable(ChatGenerationParamsRoute$outboundSchema).optional(),
+    route: z.nullable(Route$outboundSchema).optional(),
     user: z.string().optional(),
     sessionId: z.string().optional(),
     messages: z.array(Message$outboundSchema),

package/esm/models/chatresponsechoice.d.ts

@@ -4,10 +4,12 @@ import { AssistantMessage } from "./assistantmessage.js";
 import { ChatCompletionFinishReason } from "./chatcompletionfinishreason.js";
 import { ChatMessageTokenLogprobs } from "./chatmessagetokenlogprobs.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { Schema3 } from "./schema3.js";
 export type ChatResponseChoice = {
     finishReason: ChatCompletionFinishReason | null;
     index: number;
     message: AssistantMessage;
+    reasoningDetails?: Array<Schema3> | undefined;
     logprobs?: ChatMessageTokenLogprobs | null | undefined;
 };
 /** @internal */

package/esm/models/chatresponsechoice.js

@@ -7,15 +7,18 @@ import { safeParse } from "../lib/schemas.js";
 import { AssistantMessage$inboundSchema, } from "./assistantmessage.js";
 import { ChatCompletionFinishReason$inboundSchema, } from "./chatcompletionfinishreason.js";
 import { ChatMessageTokenLogprobs$inboundSchema, } from "./chatmessagetokenlogprobs.js";
+import { Schema3$inboundSchema } from "./schema3.js";
 /** @internal */
 export const ChatResponseChoice$inboundSchema = z.object({
     finish_reason: z.nullable(ChatCompletionFinishReason$inboundSchema),
     index: z.number(),
     message: AssistantMessage$inboundSchema,
+    reasoning_details: z.array(Schema3$inboundSchema).optional(),
     logprobs: z.nullable(ChatMessageTokenLogprobs$inboundSchema).optional(),
 }).transform((v) => {
     return remap$(v, {
         "finish_reason": "finishReason",
+        "reasoning_details": "reasoningDetails",
     });
 });
 export function chatResponseChoiceFromJSON(jsonString) {

package/esm/models/chatstreamingmessagechunk.d.ts

@@ -3,6 +3,7 @@ import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { ChatStreamingMessageToolCall } from "./chatstreamingmessagetoolcall.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { Schema3 } from "./schema3.js";
 export declare const ChatStreamingMessageChunkRole: {
     readonly Assistant: "assistant";
 };
@@ -13,6 +14,7 @@ export type ChatStreamingMessageChunk = {
     reasoning?: string | null | undefined;
     refusal?: string | null | undefined;
     toolCalls?: Array<ChatStreamingMessageToolCall> | undefined;
+    reasoningDetails?: Array<Schema3> | undefined;
 };
 /** @internal */
 export declare const ChatStreamingMessageChunkRole$inboundSchema: z.ZodEnum<typeof ChatStreamingMessageChunkRole>;

package/esm/models/chatstreamingmessagechunk.js

@@ -5,6 +5,7 @@ import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { ChatStreamingMessageToolCall$inboundSchema, } from "./chatstreamingmessagetoolcall.js";
+import { Schema3$inboundSchema } from "./schema3.js";
 export const ChatStreamingMessageChunkRole = {
     Assistant: "assistant",
 };
@@ -17,9 +18,11 @@ export const ChatStreamingMessageChunk$inboundSchema = z.object({
     reasoning: z.nullable(z.string()).optional(),
     refusal: z.nullable(z.string()).optional(),
     tool_calls: z.array(ChatStreamingMessageToolCall$inboundSchema).optional(),
+    reasoning_details: z.array(Schema3$inboundSchema).optional(),
 }).transform((v) => {
     return remap$(v, {
         "tool_calls": "toolCalls",
+        "reasoning_details": "reasoningDetails",
     });
 });
 export function chatStreamingMessageChunkFromJSON(jsonString) {

package/esm/models/index.d.ts

@@ -95,10 +95,15 @@ export * from "./outputmodality.js";
 export * from "./parameter.js";
 export * from "./payloadtoolargeresponseerrordata.js";
 export * from "./paymentrequiredresponseerrordata.js";
+export * from "./pdfparserengine.js";
+export * from "./pdfparseroptions.js";
 export * from "./perrequestlimits.js";
 export * from "./providername.js";
 export * from "./provideroverloadedresponseerrordata.js";
+export * from "./providerpreferences.js";
 export * from "./providersort.js";
+export * from "./providersortconfig.js";
+export * from "./providersortunion.js";
 export * from "./publicendpoint.js";
 export * from "./publicpricing.js";
 export * from "./quantization.js";
@@ -129,6 +134,7 @@ export * from "./responseswebsearchcalloutput.js";
 export * from "./responseswebsearchuserlocation.js";
 export * from "./responsetextconfig.js";
 export * from "./schema0.js";
+export * from "./schema3.js";
 export * from "./security.js";
 export * from "./serviceunavailableresponseerrordata.js";
 export * from "./systemmessage.js";
@@ -141,6 +147,7 @@ export * from "./unauthorizedresponseerrordata.js";
 export * from "./unprocessableentityresponseerrordata.js";
 export * from "./urlcitation.js";
 export * from "./usermessage.js";
+export * from "./websearchengine.js";
 export * from "./websearchpreviewtooluserlocation.js";
 export * from "./websearchstatus.js";
 //# sourceMappingURL=index.d.ts.map

package/esm/models/index.js

@@ -98,10 +98,15 @@ export * from "./outputmodality.js";
 export * from "./parameter.js";
 export * from "./payloadtoolargeresponseerrordata.js";
 export * from "./paymentrequiredresponseerrordata.js";
+export * from "./pdfparserengine.js";
+export * from "./pdfparseroptions.js";
 export * from "./perrequestlimits.js";
 export * from "./providername.js";
 export * from "./provideroverloadedresponseerrordata.js";
+export * from "./providerpreferences.js";
 export * from "./providersort.js";
+export * from "./providersortconfig.js";
+export * from "./providersortunion.js";
 export * from "./publicendpoint.js";
 export * from "./publicpricing.js";
 export * from "./quantization.js";
@@ -132,6 +137,7 @@ export * from "./responseswebsearchcalloutput.js";
 export * from "./responseswebsearchuserlocation.js";
 export * from "./responsetextconfig.js";
 export * from "./schema0.js";
+export * from "./schema3.js";
 export * from "./security.js";
 export * from "./serviceunavailableresponseerrordata.js";
 export * from "./systemmessage.js";
@@ -144,6 +150,7 @@ export * from "./unauthorizedresponseerrordata.js";
 export * from "./unprocessableentityresponseerrordata.js";
 export * from "./urlcitation.js";
 export * from "./usermessage.js";
+export * from "./websearchengine.js";
 export * from "./websearchpreviewtooluserlocation.js";
 export * from "./websearchstatus.js";
 //# sourceMappingURL=index.js.map