@openrouter/sdk 0.9.11 → 0.11.2

package/esm/models/outputmessageitem.d.ts

@@ -0,0 +1,81 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { OpenAIResponsesRefusalContent } from "./openairesponsesrefusalcontent.js";
+import { ResponseOutputText } from "./responseoutputtext.js";
+export declare const OutputMessageItemRole: {
+    readonly Assistant: "assistant";
+};
+export type OutputMessageItemRole = ClosedEnum<typeof OutputMessageItemRole>;
+export declare const OutputMessageItemType: {
+    readonly Message: "message";
+};
+export type OutputMessageItemType = ClosedEnum<typeof OutputMessageItemType>;
+export declare const OutputMessageItemStatusInProgress: {
+    readonly InProgress: "in_progress";
+};
+export type OutputMessageItemStatusInProgress = ClosedEnum<typeof OutputMessageItemStatusInProgress>;
+export declare const OutputMessageItemStatusIncomplete: {
+    readonly Incomplete: "incomplete";
+};
+export type OutputMessageItemStatusIncomplete = ClosedEnum<typeof OutputMessageItemStatusIncomplete>;
+export declare const OutputMessageItemStatusCompleted: {
+    readonly Completed: "completed";
+};
+export type OutputMessageItemStatusCompleted = ClosedEnum<typeof OutputMessageItemStatusCompleted>;
+export type OutputMessageItemStatusUnion = OutputMessageItemStatusCompleted | OutputMessageItemStatusIncomplete | OutputMessageItemStatusInProgress;
+export type OutputMessageItemContent = ResponseOutputText | OpenAIResponsesRefusalContent;
+export declare const OutputMessageItemPhaseFinalAnswer: {
+    readonly FinalAnswer: "final_answer";
+};
+export type OutputMessageItemPhaseFinalAnswer = ClosedEnum<typeof OutputMessageItemPhaseFinalAnswer>;
+export declare const OutputMessageItemPhaseCommentary: {
+    readonly Commentary: "commentary";
+};
+export type OutputMessageItemPhaseCommentary = ClosedEnum<typeof OutputMessageItemPhaseCommentary>;
+/**
+ * The phase of an assistant message. Use `commentary` for an intermediate assistant message and `final_answer` for the final assistant message. For follow-up requests with models like `gpt-5.3-codex` and later, preserve and resend phase on all assistant messages. Omitting it can degrade performance. Not used for user messages.
+ */
+export type OutputMessageItemPhaseUnion = OutputMessageItemPhaseCommentary | OutputMessageItemPhaseFinalAnswer | any;
+/**
+ * An output message item
+ */
+export type OutputMessageItem = {
+    id: string;
+    role: OutputMessageItemRole;
+    type: OutputMessageItemType;
+    status?: OutputMessageItemStatusCompleted | OutputMessageItemStatusIncomplete | OutputMessageItemStatusInProgress | undefined;
+    content: Array<ResponseOutputText | OpenAIResponsesRefusalContent>;
+    /**
+     * The phase of an assistant message. Use `commentary` for an intermediate assistant message and `final_answer` for the final assistant message. For follow-up requests with models like `gpt-5.3-codex` and later, preserve and resend phase on all assistant messages. Omitting it can degrade performance. Not used for user messages.
+     */
+    phase?: OutputMessageItemPhaseCommentary | OutputMessageItemPhaseFinalAnswer | any | null | undefined;
+};
+/** @internal */
+export declare const OutputMessageItemRole$inboundSchema: z.ZodEnum<typeof OutputMessageItemRole>;
+/** @internal */
+export declare const OutputMessageItemType$inboundSchema: z.ZodEnum<typeof OutputMessageItemType>;
+/** @internal */
+export declare const OutputMessageItemStatusInProgress$inboundSchema: z.ZodEnum<typeof OutputMessageItemStatusInProgress>;
+/** @internal */
+export declare const OutputMessageItemStatusIncomplete$inboundSchema: z.ZodEnum<typeof OutputMessageItemStatusIncomplete>;
+/** @internal */
+export declare const OutputMessageItemStatusCompleted$inboundSchema: z.ZodEnum<typeof OutputMessageItemStatusCompleted>;
+/** @internal */
+export declare const OutputMessageItemStatusUnion$inboundSchema: z.ZodType<OutputMessageItemStatusUnion, unknown>;
+export declare function outputMessageItemStatusUnionFromJSON(jsonString: string): SafeParseResult<OutputMessageItemStatusUnion, SDKValidationError>;
+/** @internal */
+export declare const OutputMessageItemContent$inboundSchema: z.ZodType<OutputMessageItemContent, unknown>;
+export declare function outputMessageItemContentFromJSON(jsonString: string): SafeParseResult<OutputMessageItemContent, SDKValidationError>;
+/** @internal */
+export declare const OutputMessageItemPhaseFinalAnswer$inboundSchema: z.ZodEnum<typeof OutputMessageItemPhaseFinalAnswer>;
+/** @internal */
+export declare const OutputMessageItemPhaseCommentary$inboundSchema: z.ZodEnum<typeof OutputMessageItemPhaseCommentary>;
+/** @internal */
+export declare const OutputMessageItemPhaseUnion$inboundSchema: z.ZodType<OutputMessageItemPhaseUnion, unknown>;
+export declare function outputMessageItemPhaseUnionFromJSON(jsonString: string): SafeParseResult<OutputMessageItemPhaseUnion, SDKValidationError>;
+/** @internal */
+export declare const OutputMessageItem$inboundSchema: z.ZodType<OutputMessageItem, unknown>;
+export declare function outputMessageItemFromJSON(jsonString: string): SafeParseResult<OutputMessageItem, SDKValidationError>;
+//# sourceMappingURL=outputmessageitem.d.ts.map

package/esm/models/outputmessageitem.js

@@ -0,0 +1,93 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 7eb39195329c
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import { OpenAIResponsesRefusalContent$inboundSchema, } from "./openairesponsesrefusalcontent.js";
+import { ResponseOutputText$inboundSchema, } from "./responseoutputtext.js";
+export const OutputMessageItemRole = {
+    Assistant: "assistant",
+};
+export const OutputMessageItemType = {
+    Message: "message",
+};
+export const OutputMessageItemStatusInProgress = {
+    InProgress: "in_progress",
+};
+export const OutputMessageItemStatusIncomplete = {
+    Incomplete: "incomplete",
+};
+export const OutputMessageItemStatusCompleted = {
+    Completed: "completed",
+};
+export const OutputMessageItemPhaseFinalAnswer = {
+    FinalAnswer: "final_answer",
+};
+export const OutputMessageItemPhaseCommentary = {
+    Commentary: "commentary",
+};
+/** @internal */
+export const OutputMessageItemRole$inboundSchema = z.enum(OutputMessageItemRole);
+/** @internal */
+export const OutputMessageItemType$inboundSchema = z.enum(OutputMessageItemType);
+/** @internal */
+export const OutputMessageItemStatusInProgress$inboundSchema = z.enum(OutputMessageItemStatusInProgress);
+/** @internal */
+export const OutputMessageItemStatusIncomplete$inboundSchema = z.enum(OutputMessageItemStatusIncomplete);
+/** @internal */
+export const OutputMessageItemStatusCompleted$inboundSchema = z.enum(OutputMessageItemStatusCompleted);
+/** @internal */
+export const OutputMessageItemStatusUnion$inboundSchema = z.union([
+    OutputMessageItemStatusCompleted$inboundSchema,
+    OutputMessageItemStatusIncomplete$inboundSchema,
+    OutputMessageItemStatusInProgress$inboundSchema,
+]);
+export function outputMessageItemStatusUnionFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputMessageItemStatusUnion$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputMessageItemStatusUnion' from JSON`);
+}
+/** @internal */
+export const OutputMessageItemContent$inboundSchema = z.union([
+    ResponseOutputText$inboundSchema,
+    OpenAIResponsesRefusalContent$inboundSchema,
+]);
+export function outputMessageItemContentFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputMessageItemContent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputMessageItemContent' from JSON`);
+}
+/** @internal */
+export const OutputMessageItemPhaseFinalAnswer$inboundSchema = z.enum(OutputMessageItemPhaseFinalAnswer);
+/** @internal */
+export const OutputMessageItemPhaseCommentary$inboundSchema = z.enum(OutputMessageItemPhaseCommentary);
+/** @internal */
+export const OutputMessageItemPhaseUnion$inboundSchema = z.union([
+    OutputMessageItemPhaseCommentary$inboundSchema,
+    OutputMessageItemPhaseFinalAnswer$inboundSchema,
+    z.any(),
+]);
+export function outputMessageItemPhaseUnionFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputMessageItemPhaseUnion$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputMessageItemPhaseUnion' from JSON`);
+}
+/** @internal */
+export const OutputMessageItem$inboundSchema = z.object({
+    id: z.string(),
+    role: OutputMessageItemRole$inboundSchema,
+    type: OutputMessageItemType$inboundSchema,
+    status: z.union([
+        OutputMessageItemStatusCompleted$inboundSchema,
+        OutputMessageItemStatusIncomplete$inboundSchema,
+        OutputMessageItemStatusInProgress$inboundSchema,
+    ]).optional(),
+    content: z.array(z.union([
+        ResponseOutputText$inboundSchema,
+        OpenAIResponsesRefusalContent$inboundSchema,
+    ])),
+    phase: z.nullable(z.union([
+        OutputMessageItemPhaseCommentary$inboundSchema,
+        OutputMessageItemPhaseFinalAnswer$inboundSchema,
+        z.any(),
+    ])).optional(),
+});
+export function outputMessageItemFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputMessageItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputMessageItem' from JSON`);
+}
+//# sourceMappingURL=outputmessageitem.js.map

package/esm/models/outputmodality.d.ts

@@ -5,6 +5,7 @@ export declare const OutputModality: {
     readonly Image: "image";
     readonly Embeddings: "embeddings";
     readonly Audio: "audio";
+    readonly Video: "video";
 };
 export type OutputModality = OpenEnum<typeof OutputModality>;
 /** @internal */

package/esm/models/outputmodality.js

@@ -8,6 +8,7 @@ export const OutputModality = {
     Image: "image",
     Embeddings: "embeddings",
     Audio: "audio",
+    Video: "video",
 };
 /** @internal */
 export const OutputModality$inboundSchema = openEnums.inboundSchema(OutputModality);

package/esm/models/outputmodalityenum.d.ts

@@ -0,0 +1,10 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+export declare const OutputModalityEnum: {
+    readonly Text: "text";
+    readonly Image: "image";
+};
+export type OutputModalityEnum = OpenEnum<typeof OutputModalityEnum>;
+/** @internal */
+export declare const OutputModalityEnum$outboundSchema: z.ZodType<string, OutputModalityEnum>;
+//# sourceMappingURL=outputmodalityenum.d.ts.map

package/esm/models/outputmodalityenum.js

@@ -0,0 +1,12 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 732188d6b8fa
+ */
+import * as openEnums from "../types/enums.js";
+export const OutputModalityEnum = {
+    Text: "text",
+    Image: "image",
+};
+/** @internal */
+export const OutputModalityEnum$outboundSchema = openEnums.outboundSchema(OutputModalityEnum);
+//# sourceMappingURL=outputmodalityenum.js.map

package/esm/models/outputreasoningitem.d.ts

@@ -0,0 +1,74 @@
+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";
+import { ReasoningSummaryText } from "./reasoningsummarytext.js";
+import { ReasoningTextContent } from "./reasoningtextcontent.js";
+export declare const OutputReasoningItemType: {
+    readonly Reasoning: "reasoning";
+};
+export type OutputReasoningItemType = ClosedEnum<typeof OutputReasoningItemType>;
+export declare const OutputReasoningItemStatusInProgress: {
+    readonly InProgress: "in_progress";
+};
+export type OutputReasoningItemStatusInProgress = ClosedEnum<typeof OutputReasoningItemStatusInProgress>;
+export declare const OutputReasoningItemStatusIncomplete: {
+    readonly Incomplete: "incomplete";
+};
+export type OutputReasoningItemStatusIncomplete = ClosedEnum<typeof OutputReasoningItemStatusIncomplete>;
+export declare const OutputReasoningItemStatusCompleted: {
+    readonly Completed: "completed";
+};
+export type OutputReasoningItemStatusCompleted = ClosedEnum<typeof OutputReasoningItemStatusCompleted>;
+export type OutputReasoningItemStatusUnion = OutputReasoningItemStatusCompleted | OutputReasoningItemStatusIncomplete | OutputReasoningItemStatusInProgress;
+/**
+ * The format of the reasoning content
+ */
+export declare const OutputReasoningItemFormat: {
+    readonly Unknown: "unknown";
+    readonly OpenaiResponsesV1: "openai-responses-v1";
+    readonly AzureOpenaiResponsesV1: "azure-openai-responses-v1";
+    readonly XaiResponsesV1: "xai-responses-v1";
+    readonly AnthropicClaudeV1: "anthropic-claude-v1";
+    readonly GoogleGeminiV1: "google-gemini-v1";
+};
+/**
+ * The format of the reasoning content
+ */
+export type OutputReasoningItemFormat = OpenEnum<typeof OutputReasoningItemFormat>;
+/**
+ * An output item containing reasoning
+ */
+export type OutputReasoningItem = {
+    type: OutputReasoningItemType;
+    id: string;
+    content?: Array<ReasoningTextContent> | null | undefined;
+    summary: Array<ReasoningSummaryText>;
+    encryptedContent?: string | null | undefined;
+    status?: OutputReasoningItemStatusCompleted | OutputReasoningItemStatusIncomplete | OutputReasoningItemStatusInProgress | undefined;
+    /**
+     * A signature for the reasoning content, used for verification
+     */
+    signature?: string | null | undefined;
+    /**
+     * The format of the reasoning content
+     */
+    format?: OutputReasoningItemFormat | null | undefined;
+};
+/** @internal */
+export declare const OutputReasoningItemType$inboundSchema: z.ZodEnum<typeof OutputReasoningItemType>;
+/** @internal */
+export declare const OutputReasoningItemStatusInProgress$inboundSchema: z.ZodEnum<typeof OutputReasoningItemStatusInProgress>;
+/** @internal */
+export declare const OutputReasoningItemStatusIncomplete$inboundSchema: z.ZodEnum<typeof OutputReasoningItemStatusIncomplete>;
+/** @internal */
+export declare const OutputReasoningItemStatusCompleted$inboundSchema: z.ZodEnum<typeof OutputReasoningItemStatusCompleted>;
+/** @internal */
+export declare const OutputReasoningItemStatusUnion$inboundSchema: z.ZodType<OutputReasoningItemStatusUnion, unknown>;
+export declare function outputReasoningItemStatusUnionFromJSON(jsonString: string): SafeParseResult<OutputReasoningItemStatusUnion, SDKValidationError>;
+/** @internal */
+export declare const OutputReasoningItemFormat$inboundSchema: z.ZodType<OutputReasoningItemFormat, unknown>;
+/** @internal */
+export declare const OutputReasoningItem$inboundSchema: z.ZodType<OutputReasoningItem, unknown>;
+export declare function outputReasoningItemFromJSON(jsonString: string): SafeParseResult<OutputReasoningItem, SDKValidationError>;
+//# sourceMappingURL=outputreasoningitem.d.ts.map

package/esm/models/outputreasoningitem.js

@@ -0,0 +1,75 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 4ea30f8ad34c
+ */
+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";
+import { ReasoningSummaryText$inboundSchema, } from "./reasoningsummarytext.js";
+import { ReasoningTextContent$inboundSchema, } from "./reasoningtextcontent.js";
+export const OutputReasoningItemType = {
+    Reasoning: "reasoning",
+};
+export const OutputReasoningItemStatusInProgress = {
+    InProgress: "in_progress",
+};
+export const OutputReasoningItemStatusIncomplete = {
+    Incomplete: "incomplete",
+};
+export const OutputReasoningItemStatusCompleted = {
+    Completed: "completed",
+};
+/**
+ * The format of the reasoning content
+ */
+export const OutputReasoningItemFormat = {
+    Unknown: "unknown",
+    OpenaiResponsesV1: "openai-responses-v1",
+    AzureOpenaiResponsesV1: "azure-openai-responses-v1",
+    XaiResponsesV1: "xai-responses-v1",
+    AnthropicClaudeV1: "anthropic-claude-v1",
+    GoogleGeminiV1: "google-gemini-v1",
+};
+/** @internal */
+export const OutputReasoningItemType$inboundSchema = z.enum(OutputReasoningItemType);
+/** @internal */
+export const OutputReasoningItemStatusInProgress$inboundSchema = z.enum(OutputReasoningItemStatusInProgress);
+/** @internal */
+export const OutputReasoningItemStatusIncomplete$inboundSchema = z.enum(OutputReasoningItemStatusIncomplete);
+/** @internal */
+export const OutputReasoningItemStatusCompleted$inboundSchema = z.enum(OutputReasoningItemStatusCompleted);
+/** @internal */
+export const OutputReasoningItemStatusUnion$inboundSchema = z.union([
+    OutputReasoningItemStatusCompleted$inboundSchema,
+    OutputReasoningItemStatusIncomplete$inboundSchema,
+    OutputReasoningItemStatusInProgress$inboundSchema,
+]);
+export function outputReasoningItemStatusUnionFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputReasoningItemStatusUnion$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputReasoningItemStatusUnion' from JSON`);
+}
+/** @internal */
+export const OutputReasoningItemFormat$inboundSchema = openEnums.inboundSchema(OutputReasoningItemFormat);
+/** @internal */
+export const OutputReasoningItem$inboundSchema = z.object({
+    type: OutputReasoningItemType$inboundSchema,
+    id: z.string(),
+    content: z.nullable(z.array(ReasoningTextContent$inboundSchema)).optional(),
+    summary: z.array(ReasoningSummaryText$inboundSchema),
+    encrypted_content: z.nullable(z.string()).optional(),
+    status: z.union([
+        OutputReasoningItemStatusCompleted$inboundSchema,
+        OutputReasoningItemStatusIncomplete$inboundSchema,
+        OutputReasoningItemStatusInProgress$inboundSchema,
+    ]).optional(),
+    signature: z.nullable(z.string()).optional(),
+    format: z.nullable(OutputReasoningItemFormat$inboundSchema).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "encrypted_content": "encryptedContent",
+    });
+});
+export function outputReasoningItemFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputReasoningItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputReasoningItem' from JSON`);
+}
+//# sourceMappingURL=outputreasoningitem.js.map

package/esm/models/outputservertoolitem.d.ts

@@ -0,0 +1,42 @@
+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 OutputServerToolItemStatus: {
+    readonly Completed: "completed";
+    readonly InProgress: "in_progress";
+    readonly Incomplete: "incomplete";
+};
+export type OutputServerToolItemStatus = OpenEnum<typeof OutputServerToolItemStatus>;
+/**
+ * A generic OpenRouter server tool output item
+ */
+export type OutputServerToolItem = {
+    /**
+     * Server tool type (e.g. openrouter:datetime, openrouter:web_search)
+     */
+    type: string;
+    id?: string | undefined;
+    status: OutputServerToolItemStatus;
+    additionalProperties?: {
+        [k: string]: any | null;
+    } | undefined;
+};
+/** @internal */
+export declare const OutputServerToolItemStatus$inboundSchema: z.ZodType<OutputServerToolItemStatus, unknown>;
+/** @internal */
+export declare const OutputServerToolItemStatus$outboundSchema: z.ZodType<string, OutputServerToolItemStatus>;
+/** @internal */
+export declare const OutputServerToolItem$inboundSchema: z.ZodType<OutputServerToolItem, unknown>;
+/** @internal */
+export type OutputServerToolItem$Outbound = {
+    type: string;
+    id?: string | undefined;
+    status: string;
+    [additionalProperties: string]: unknown;
+};
+/** @internal */
+export declare const OutputServerToolItem$outboundSchema: z.ZodType<OutputServerToolItem$Outbound, OutputServerToolItem>;
+export declare function outputServerToolItemToJSON(outputServerToolItem: OutputServerToolItem): string;
+export declare function outputServerToolItemFromJSON(jsonString: string): SafeParseResult<OutputServerToolItem, SDKValidationError>;
+//# sourceMappingURL=outputservertoolitem.d.ts.map

package/esm/models/outputservertoolitem.js

@@ -0,0 +1,44 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: ca93d8ce3ebb
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { collectExtraKeys as collectExtraKeys$, safeParse, } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+export const OutputServerToolItemStatus = {
+    Completed: "completed",
+    InProgress: "in_progress",
+    Incomplete: "incomplete",
+};
+/** @internal */
+export const OutputServerToolItemStatus$inboundSchema = openEnums.inboundSchema(OutputServerToolItemStatus);
+/** @internal */
+export const OutputServerToolItemStatus$outboundSchema = openEnums.outboundSchema(OutputServerToolItemStatus);
+/** @internal */
+export const OutputServerToolItem$inboundSchema = collectExtraKeys$(z.object({
+    type: z.string(),
+    id: z.string().optional(),
+    status: OutputServerToolItemStatus$inboundSchema,
+}).catchall(z.any()), "additionalProperties", true);
+/** @internal */
+export const OutputServerToolItem$outboundSchema = z.object({
+    type: z.string(),
+    id: z.string().optional(),
+    status: OutputServerToolItemStatus$outboundSchema,
+    additionalProperties: z.record(z.string(), z.nullable(z.any())).optional(),
+}).transform((v) => {
+    return {
+        ...v.additionalProperties,
+        ...remap$(v, {
+            additionalProperties: null,
+        }),
+    };
+});
+export function outputServerToolItemToJSON(outputServerToolItem) {
+    return JSON.stringify(OutputServerToolItem$outboundSchema.parse(outputServerToolItem));
+}
+export function outputServerToolItemFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputServerToolItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputServerToolItem' from JSON`);
+}
+//# sourceMappingURL=outputservertoolitem.js.map

package/esm/models/outputwebsearchcallitem.d.ts

@@ -0,0 +1,116 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { WebSearchStatus } from "./websearchstatus.js";
+export declare const TypeWebSearchCall: {
+    readonly WebSearchCall: "web_search_call";
+};
+export type TypeWebSearchCall = ClosedEnum<typeof TypeWebSearchCall>;
+export type ActionFindInPage = {
+    type: "find_in_page";
+    pattern: string;
+    url: string;
+};
+export type ActionOpenPage = {
+    type: "open_page";
+    url?: string | null | undefined;
+};
+export declare const TypeURL: {
+    readonly Url: "url";
+};
+export type TypeURL = ClosedEnum<typeof TypeURL>;
+export type Source = {
+    type: TypeURL;
+    url: string;
+};
+export type ActionSearch = {
+    type: "search";
+    query: string;
+    queries?: Array<string> | undefined;
+    sources?: Array<Source> | undefined;
+};
+export type Action = ActionSearch | ActionOpenPage | ActionFindInPage;
+export type OutputWebSearchCallItem = {
+    type: TypeWebSearchCall;
+    id: string;
+    action: ActionSearch | ActionOpenPage | ActionFindInPage;
+    status: WebSearchStatus;
+};
+/** @internal */
+export declare const TypeWebSearchCall$inboundSchema: z.ZodEnum<typeof TypeWebSearchCall>;
+/** @internal */
+export declare const TypeWebSearchCall$outboundSchema: z.ZodEnum<typeof TypeWebSearchCall>;
+/** @internal */
+export declare const ActionFindInPage$inboundSchema: z.ZodType<ActionFindInPage, unknown>;
+/** @internal */
+export type ActionFindInPage$Outbound = {
+    type: "find_in_page";
+    pattern: string;
+    url: string;
+};
+/** @internal */
+export declare const ActionFindInPage$outboundSchema: z.ZodType<ActionFindInPage$Outbound, ActionFindInPage>;
+export declare function actionFindInPageToJSON(actionFindInPage: ActionFindInPage): string;
+export declare function actionFindInPageFromJSON(jsonString: string): SafeParseResult<ActionFindInPage, SDKValidationError>;
+/** @internal */
+export declare const ActionOpenPage$inboundSchema: z.ZodType<ActionOpenPage, unknown>;
+/** @internal */
+export type ActionOpenPage$Outbound = {
+    type: "open_page";
+    url?: string | null | undefined;
+};
+/** @internal */
+export declare const ActionOpenPage$outboundSchema: z.ZodType<ActionOpenPage$Outbound, ActionOpenPage>;
+export declare function actionOpenPageToJSON(actionOpenPage: ActionOpenPage): string;
+export declare function actionOpenPageFromJSON(jsonString: string): SafeParseResult<ActionOpenPage, SDKValidationError>;
+/** @internal */
+export declare const TypeURL$inboundSchema: z.ZodEnum<typeof TypeURL>;
+/** @internal */
+export declare const TypeURL$outboundSchema: z.ZodEnum<typeof TypeURL>;
+/** @internal */
+export declare const Source$inboundSchema: z.ZodType<Source, unknown>;
+/** @internal */
+export type Source$Outbound = {
+    type: string;
+    url: string;
+};
+/** @internal */
+export declare const Source$outboundSchema: z.ZodType<Source$Outbound, Source>;
+export declare function sourceToJSON(source: Source): string;
+export declare function sourceFromJSON(jsonString: string): SafeParseResult<Source, SDKValidationError>;
+/** @internal */
+export declare const ActionSearch$inboundSchema: z.ZodType<ActionSearch, unknown>;
+/** @internal */
+export type ActionSearch$Outbound = {
+    type: "search";
+    query: string;
+    queries?: Array<string> | undefined;
+    sources?: Array<Source$Outbound> | undefined;
+};
+/** @internal */
+export declare const ActionSearch$outboundSchema: z.ZodType<ActionSearch$Outbound, ActionSearch>;
+export declare function actionSearchToJSON(actionSearch: ActionSearch): string;
+export declare function actionSearchFromJSON(jsonString: string): SafeParseResult<ActionSearch, SDKValidationError>;
+/** @internal */
+export declare const Action$inboundSchema: z.ZodType<Action, unknown>;
+/** @internal */
+export type Action$Outbound = ActionSearch$Outbound | ActionOpenPage$Outbound | ActionFindInPage$Outbound;
+/** @internal */
+export declare const Action$outboundSchema: z.ZodType<Action$Outbound, Action>;
+export declare function actionToJSON(action: Action): string;
+export declare function actionFromJSON(jsonString: string): SafeParseResult<Action, SDKValidationError>;
+/** @internal */
+export declare const OutputWebSearchCallItem$inboundSchema: z.ZodType<OutputWebSearchCallItem, unknown>;
+/** @internal */
+export type OutputWebSearchCallItem$Outbound = {
+    type: string;
+    id: string;
+    action: ActionSearch$Outbound | ActionOpenPage$Outbound | ActionFindInPage$Outbound;
+    status: string;
+};
+/** @internal */
+export declare const OutputWebSearchCallItem$outboundSchema: z.ZodType<OutputWebSearchCallItem$Outbound, OutputWebSearchCallItem>;
+export declare function outputWebSearchCallItemToJSON(outputWebSearchCallItem: OutputWebSearchCallItem): string;
+export declare function outputWebSearchCallItemFromJSON(jsonString: string): SafeParseResult<OutputWebSearchCallItem, SDKValidationError>;
+//# sourceMappingURL=outputwebsearchcallitem.d.ts.map