import * as z from "zod/v3";
import { EventStream } from "../../lib/event-streams.js";
import { ClosedEnum } from "../../types/enums.js";
import { Result as SafeParseResult } from "../../types/fp.js";
import * as components from "../components/index.js";
import { SDKValidationError } from "../errors/sdkvalidationerror.js";
/**
 * A file content part. Provide file_id, file_data (base64), or file_url.
 */
export type TwoFile = {
    /**
     * Base64-encoded file content.
     */
    fileData?: string | undefined;
    /**
     * The ID of a previously uploaded file.
     */
    fileId?: string | undefined;
    /**
     * A URL to fetch the file from.
     */
    fileUrl?: string | undefined;
    /**
     * The name of the file.
     */
    filename?: string | undefined;
    /**
     * The MIME type of the file (e.g., application/pdf).
     */
    mimeType?: string | undefined;
    type: "input_file";
};
/**
 * The detail level for image understanding.
 */
export declare const TwoDetail: {
    readonly Auto: "auto";
    readonly Low: "low";
    readonly High: "high";
};
/**
 * The detail level for image understanding.
 */
export type TwoDetail = ClosedEnum<typeof TwoDetail>;
/**
 * An image content part.
 */
export type Image = {
    /**
     * The detail level for image understanding.
     */
    detail?: TwoDetail | undefined;
    /**
     * The ID of a previously uploaded file.
     */
    fileId?: string | undefined;
    /**
     * The URL of the image.
     */
    imageUrl?: string | undefined;
    type: "input_image";
};
/**
 * A text content part.
 */
export type TwoText = {
    /**
     * The text content.
     */
    text: string;
    type: "input_text";
};
/**
 * A content part within a message.
 */
export type CreateRouterResponseContent2 = TwoText | Image | TwoFile;
/**
 * The content of the item: a string or an array of content parts.
 */
export type InputContent = string | Array<TwoText | Image | TwoFile>;
/**
 * The role of the message sender (for message items).
 */
export declare const InputRole: {
    readonly User: "user";
    readonly Assistant: "assistant";
    readonly System: "system";
    readonly Developer: "developer";
};
/**
 * The role of the message sender (for message items).
 */
export type InputRole = ClosedEnum<typeof InputRole>;
/**
 * The type of item.
 */
export declare const InputType: {
    readonly Message: "message";
    readonly FunctionCallOutput: "function_call_output";
    readonly ItemReference: "item_reference";
};
/**
 * The type of item.
 */
export type InputType = ClosedEnum<typeof InputType>;
/**
 * An input item. The "type" field determines the item kind: "message", "function_call_output", "item_reference", etc.
 */
export type CreateRouterResponseInput2 = {
    /**
     * The ID of the function call being responded to (for function_call_output type).
     */
    callId?: string | undefined;
    /**
     * The content of the item: a string or an array of content parts.
     */
    content?: string | Array<TwoText | Image | TwoFile> | undefined;
    /**
     * The ID of the item (for item_reference type).
     */
    id?: string | undefined;
    /**
     * The output of the function call (for function_call_output type).
     */
    output?: string | undefined;
    /**
     * The role of the message sender (for message items).
     */
    role?: InputRole | undefined;
    /**
     * The type of item.
     */
    type?: InputType | undefined;
};
/**
 * Input to the model: a string or an array of input items (messages, files, etc.).
 */
export type CreateRouterResponseInput = string | Array<CreateRouterResponseInput2>;
/**
 * Template engine for variable substitution in instructions. Defaults to the agent manifest's engine when invoking an agent, otherwise text.
 */
export declare const TemplateEngine: {
    readonly Text: "text";
    readonly Jinja: "jinja";
    readonly Mustache: "mustache";
};
/**
 * Template engine for variable substitution in instructions. Defaults to the agent manifest's engine when invoking an agent, otherwise text.
 */
export type TemplateEngine = ClosedEnum<typeof TemplateEngine>;
/**
 * The JSON Schema the output must conform to.
 */
export type FormatSchema = {};
export type FormatJSONSchema = {
    description?: string | undefined;
    name?: string | undefined;
    /**
     * The JSON Schema the output must conform to.
     */
    schema?: FormatSchema | undefined;
    strict?: boolean | undefined;
    type: "json_schema";
};
export type PlainText = {
    type: "text";
};
/**
 * The output format: plain text or structured JSON schema.
 */
export type CreateRouterResponseFormat = PlainText | FormatJSONSchema;
export declare const Verbosity: {
    readonly Low: "low";
    readonly Medium: "medium";
    readonly High: "high";
};
export type Verbosity = ClosedEnum<typeof Verbosity>;
/**
 * Configuration for text output.
 */
export type CreateRouterResponseText = {
    /**
     * The output format: plain text or structured JSON schema.
     */
    format?: PlainText | FormatJSONSchema | undefined;
    verbosity?: Verbosity | undefined;
};
export declare const CreateRouterResponseToolChoiceType: {
    readonly Function: "function";
};
export type CreateRouterResponseToolChoiceType = ClosedEnum<typeof CreateRouterResponseToolChoiceType>;
/**
 * Select a specific function tool by name.
 */
export type SpecificFunction = {
    /**
     * The name of the function to call.
     */
    name: string;
    type: CreateRouterResponseToolChoiceType;
};
/**
 * Shorthand: "auto" lets the model decide, "none" disables tools, "required" forces tool use.
 */
export declare const Shorthand: {
    readonly Auto: "auto";
    readonly None: "none";
    readonly Required: "required";
};
/**
 * Shorthand: "auto" lets the model decide, "none" disables tools, "required" forces tool use.
 */
export type Shorthand = ClosedEnum<typeof Shorthand>;
/**
 * How the model should use the provided tools. Can be a string shorthand or a specific function selector.
 */
export type CreateRouterResponseToolChoice = SpecificFunction | Shorthand;
/**
 * Filter which tools from the MCP server are exposed.
 */
export type AllowedTools = {
    /**
     * Only expose tools with readOnlyHint annotation.
     */
    readOnly?: boolean | undefined;
    /**
     * List of allowed tool names.
     */
    toolNames?: Array<string> | undefined;
};
/**
 * An MCP (Model Context Protocol) server tool. Provide server_url for inline mode, or key to reference a pre-configured MCP server.
 */
export type ToolsMCPTool = {
    /**
     * Filter which tools from the MCP server are exposed.
     */
    allowedTools?: AllowedTools | undefined;
    /**
     * Custom headers to send with MCP requests. Values support {{variable}} templates.
     */
    headers?: {
        [k: string]: string;
    } | undefined;
    /**
     * Unique identifier. Required for pre-configured MCP servers (lookup key). For inline servers, used as a trace/display label.
     */
    key?: string | undefined;
    /**
     * Human-readable description of the server.
     */
    serverDescription?: string | undefined;
    /**
     * The MCP server endpoint URL (inline mode).
     */
    serverUrl?: string | undefined;
    type: "mcp";
};
/**
 * The orq.ai tool type.
 */
export declare const CreateRouterResponseToolsResponsesType: {
    readonly OrqCurrentDate: "orq:current_date";
    readonly OrqGoogleSearch: "orq:google_search";
    readonly OrqWebScraper: "orq:web_scraper";
    readonly OrqMcp: "orq:mcp";
    readonly OrqHttp: "orq:http";
    readonly OrqFunction: "orq:function";
};
/**
 * The orq.ai tool type.
 */
export type CreateRouterResponseToolsResponsesType = ClosedEnum<typeof CreateRouterResponseToolsResponsesType>;
/**
 * An orq.ai platform tool reference. For MCP tools, prefer type 'mcp' with 'key' instead of 'orq:mcp' with 'tool_id'.
 */
export type OrqAiTool = {
    /**
     * The tool ID (for orq:mcp, orq:http, orq:function).
     */
    toolId?: string | undefined;
    /**
     * The orq.ai tool type.
     */
    type: CreateRouterResponseToolsResponsesType;
};
/**
 * The parameters the function accepts, as a JSON Schema object.
 */
export type ToolsParameters = {};
/**
 * A function tool the model can call.
 */
export type ToolsFunction = {
    /**
     * A description of what the function does.
     */
    description?: string | undefined;
    /**
     * The name of the function.
     */
    name: string;
    /**
     * The parameters the function accepts, as a JSON Schema object.
     */
    parameters?: ToolsParameters | undefined;
    /**
     * Whether to enforce strict parameter validation.
     */
    strict?: boolean | undefined;
    type: "function";
};
/**
 * A tool definition. The "type" field determines the tool kind.
 */
export type CreateRouterResponseTools = ToolsFunction | (OrqAiTool & {
    type: "orq:current_date";
}) | (OrqAiTool & {
    type: "orq:google_search";
}) | (OrqAiTool & {
    type: "orq:web_scraper";
}) | (OrqAiTool & {
    type: "orq:mcp";
}) | (OrqAiTool & {
    type: "orq:http";
}) | (OrqAiTool & {
    type: "orq:function";
}) | ToolsMCPTool;
export type CreateRouterResponseRequestBody = {
    conversation?: components.ConversationParam | undefined;
    /**
     * Fallback models to try if the primary model fails. Each entry specifies a model in provider/model format.
     */
    fallbacks?: Array<components.FallbackConfig> | null | undefined;
    /**
     * Penalize new tokens based on their frequency in the text so far. Between -2.0 and 2.0.
     */
    frequencyPenalty?: number | undefined;
    identity?: components.ResponseIdentity | undefined;
    /**
     * Input to the model: a string or an array of input items (messages, files, etc.).
     */
    input?: string | Array<CreateRouterResponseInput2> | undefined;
    /**
     * System prompt / instructions for the model.
     */
    instructions?: string | undefined;
    limits?: components.ResponseExecutionLimits | undefined;
    /**
     * Maximum number of tokens in the response output.
     */
    maxOutputTokens?: number | undefined;
    /**
     * Maximum number of tool call rounds in the agentic loop.
     */
    maxToolCalls?: number | undefined;
    memory?: components.MemoryParam | undefined;
    /**
     * Developer-defined key-value pairs attached to the response (OpenAI spec: Map<string, string>). Non-string values are rejected with a 400.
     */
    metadata?: {
        [k: string]: string;
    } | undefined;
    /**
     * The model to use in provider/model format (e.g. openai/gpt-4o). Use agent/<key> to invoke a pre-configured agent from the orq.ai platform.
     */
    model?: string | undefined;
    /**
     * Whether to allow parallel tool calls.
     */
    parallelToolCalls?: boolean | undefined;
    /**
     * Penalize new tokens based on their presence in the text so far. Between -2.0 and 2.0.
     */
    presencePenalty?: number | undefined;
    /**
     * The ID of a previous response to continue from. Requires store to be true (default) on the original response.
     */
    previousResponseId?: string | undefined;
    /**
     * Key for prompt caching across requests.
     */
    promptCacheKey?: string | undefined;
    reasoning?: components.ReasoningParam | undefined;
    retry?: components.ResponseRetryConfig | undefined;
    /**
     * Safety identifier for content filtering.
     */
    safetyIdentifier?: string | undefined;
    /**
     * Whether to persist the response (default: true). When false, the response cannot be retrieved later and previous_response_id will not work for follow-up requests.
     */
    store?: boolean | undefined;
    /**
     * If true, returns a stream of server-sent events.
     */
    stream?: boolean | undefined;
    streamOptions?: components.StreamOptions | undefined;
    /**
     * Sampling temperature between 0 and 2.
     */
    temperature?: number | undefined;
    /**
     * Template engine for variable substitution in instructions. Defaults to the agent manifest's engine when invoking an agent, otherwise text.
     */
    templateEngine?: TemplateEngine | undefined;
    /**
     * Configuration for text output.
     */
    text?: CreateRouterResponseText | undefined;
    thread?: components.ResponseThread | undefined;
    /**
     * How the model should use the provided tools. Can be a string shorthand or a specific function selector.
     */
    toolChoice?: SpecificFunction | Shorthand | undefined;
    /**
     * Tools available to the model.
     */
    tools?: Array<ToolsFunction | (OrqAiTool & {
        type: "orq:current_date";
    }) | (OrqAiTool & {
        type: "orq:google_search";
    }) | (OrqAiTool & {
        type: "orq:web_scraper";
    }) | (OrqAiTool & {
        type: "orq:mcp";
    }) | (OrqAiTool & {
        type: "orq:http";
    }) | (OrqAiTool & {
        type: "orq:function";
    }) | ToolsMCPTool> | undefined;
    /**
     * Number of most likely tokens to return at each position.
     */
    topLogprobs?: number | undefined;
    /**
     * Nucleus sampling parameter.
     */
    topP?: number | undefined;
    /**
     * Template variables for prompt substitution. Plain values fill {{variable}} placeholders in instructions. For secrets, use {"secret": true, "value": "sensitive-data"} — secrets are automatically passed to platform tools (Python, HTTP, MCP) and redacted from traces.
     */
    variables?: {
        [k: string]: any;
    } | undefined;
};
/**
 * The event type.
 */
export declare const CreateRouterResponseType: {
    readonly ResponseQueued: "response.queued";
    readonly ResponseCreated: "response.created";
    readonly ResponseInProgress: "response.in_progress";
    readonly ResponseCompleted: "response.completed";
    readonly ResponseFailed: "response.failed";
    readonly ResponseIncomplete: "response.incomplete";
    readonly ResponseOutputItemAdded: "response.output_item.added";
    readonly ResponseOutputItemDone: "response.output_item.done";
    readonly ResponseContentPartAdded: "response.content_part.added";
    readonly ResponseContentPartDone: "response.content_part.done";
    readonly ResponseOutputTextDelta: "response.output_text.delta";
    readonly ResponseOutputTextDone: "response.output_text.done";
    readonly ResponseFunctionCallArgumentsDelta: "response.function_call_arguments.delta";
    readonly ResponseFunctionCallArgumentsDone: "response.function_call_arguments.done";
    readonly ResponseMcpCallInProgress: "response.mcp_call.in_progress";
    readonly ResponseMcpCallCompleted: "response.mcp_call.completed";
    readonly ResponseMcpCallFailed: "response.mcp_call.failed";
    readonly ResponseMcpCallArgumentsDelta: "response.mcp_call_arguments.delta";
    readonly ResponseMcpCallArgumentsDone: "response.mcp_call_arguments.done";
    readonly ResponseReasoningDelta: "response.reasoning.delta";
    readonly ResponseReasoningDone: "response.reasoning.done";
    readonly Error: "error";
};
/**
 * The event type.
 */
export type CreateRouterResponseType = ClosedEnum<typeof CreateRouterResponseType>;
/**
 * A server-sent event in the response stream.
 */
export type CreateRouterResponseData = {
    /**
     * Monotonically increasing sequence number for ordering events.
     */
    sequenceNumber: number;
    /**
     * The event type.
     */
    type: CreateRouterResponseType;
};
/**
 * A server-sent event in the response stream.
 */
export type CreateRouterResponseResponsesResponseBody = {
    /**
     * A server-sent event in the response stream.
     */
    data?: CreateRouterResponseData | undefined;
};
export declare const CreateRouterResponseServiceTier: {
    readonly Auto: "auto";
    readonly Default: "default";
    readonly Flex: "flex";
    readonly Priority: "priority";
};
export type CreateRouterResponseServiceTier = ClosedEnum<typeof CreateRouterResponseServiceTier>;
export declare const CreateRouterResponseStatus: {
    readonly Queued: "queued";
    readonly InProgress: "in_progress";
    readonly Completed: "completed";
    readonly Failed: "failed";
    readonly Incomplete: "incomplete";
    readonly RequiresAction: "requires_action";
};
export type CreateRouterResponseStatus = ClosedEnum<typeof CreateRouterResponseStatus>;
export declare const CreateRouterResponseTruncation: {
    readonly Disabled: "disabled";
    readonly Auto: "auto";
};
export type CreateRouterResponseTruncation = ClosedEnum<typeof CreateRouterResponseTruncation>;
/**
 * Returns a response object or a stream of events.
 */
export type CreateRouterResponseResponseBody = {
    background: boolean;
    completedAt: number | null;
    conversation?: components.ConversationParam | undefined;
    createdAt: number;
    error: components.ResponseError;
    frequencyPenalty: number;
    id: string;
    incompleteDetails: components.IncompleteDetails;
    /**
     * Array of input items (messages, function call outputs, etc.)
     */
    input: Array<any> | null;
    instructions: string | null;
    maxOutputTokens: number | null;
    maxToolCalls: number | null;
    memory?: components.MemoryParam | undefined;
    /**
     * Developer-defined key-value pairs attached to the response (OpenAI spec: Map<string, string>).
     */
    metadata: {
        [k: string]: string;
    };
    model: string;
    /**
     * Always "response"
     */
    object: string;
    /**
     * Array of output items (messages, function calls, reasoning, etc.)
     */
    output: Array<any> | null;
    parallelToolCalls: boolean;
    presencePenalty: number;
    previousResponseId: string | null;
    promptCacheKey: string | null;
    promptCacheRetention: string | null;
    reasoning: components.Reasoning;
    safetyIdentifier: string | null;
    serviceTier: CreateRouterResponseServiceTier;
    status: CreateRouterResponseStatus;
    store: boolean;
    temperature: number;
    /**
     * Text output configuration including format and verbosity
     */
    text?: any | undefined;
    /**
     * Tool choice setting: "auto", "none", "required", or a specific function
     */
    toolChoice?: any | undefined;
    /**
     * Array of tool configurations used in this response
     */
    tools: Array<any> | null;
    topLogprobs: number;
    topP: number;
    truncation: CreateRouterResponseTruncation;
    usage: components.PublicUsage;
    user: string | null;
    variables?: {
        [k: string]: any;
    } | undefined;
};
export type CreateRouterResponseResponse = CreateRouterResponseResponseBody | EventStream<CreateRouterResponseResponsesResponseBody>;
/** @internal */
export type TwoFile$Outbound = {
    file_data?: string | undefined;
    file_id?: string | undefined;
    file_url?: string | undefined;
    filename?: string | undefined;
    mime_type?: string | undefined;
    type: "input_file";
};
/** @internal */
export declare const TwoFile$outboundSchema: z.ZodType<TwoFile$Outbound, z.ZodTypeDef, TwoFile>;
export declare function twoFileToJSON(twoFile: TwoFile): string;
/** @internal */
export declare const TwoDetail$outboundSchema: z.ZodNativeEnum<typeof TwoDetail>;
/** @internal */
export type Image$Outbound = {
    detail?: string | undefined;
    file_id?: string | undefined;
    image_url?: string | undefined;
    type: "input_image";
};
/** @internal */
export declare const Image$outboundSchema: z.ZodType<Image$Outbound, z.ZodTypeDef, Image>;
export declare function imageToJSON(image: Image): string;
/** @internal */
export type TwoText$Outbound = {
    text: string;
    type: "input_text";
};
/** @internal */
export declare const TwoText$outboundSchema: z.ZodType<TwoText$Outbound, z.ZodTypeDef, TwoText>;
export declare function twoTextToJSON(twoText: TwoText): string;
/** @internal */
export type CreateRouterResponseContent2$Outbound = TwoText$Outbound | Image$Outbound | TwoFile$Outbound;
/** @internal */
export declare const CreateRouterResponseContent2$outboundSchema: z.ZodType<CreateRouterResponseContent2$Outbound, z.ZodTypeDef, CreateRouterResponseContent2>;
export declare function createRouterResponseContent2ToJSON(createRouterResponseContent2: CreateRouterResponseContent2): string;
/** @internal */
export type InputContent$Outbound = string | Array<TwoText$Outbound | Image$Outbound | TwoFile$Outbound>;
/** @internal */
export declare const InputContent$outboundSchema: z.ZodType<InputContent$Outbound, z.ZodTypeDef, InputContent>;
export declare function inputContentToJSON(inputContent: InputContent): string;
/** @internal */
export declare const InputRole$outboundSchema: z.ZodNativeEnum<typeof InputRole>;
/** @internal */
export declare const InputType$outboundSchema: z.ZodNativeEnum<typeof InputType>;
/** @internal */
export type CreateRouterResponseInput2$Outbound = {
    call_id?: string | undefined;
    content?: string | Array<TwoText$Outbound | Image$Outbound | TwoFile$Outbound> | undefined;
    id?: string | undefined;
    output?: string | undefined;
    role?: string | undefined;
    type?: string | undefined;
};
/** @internal */
export declare const CreateRouterResponseInput2$outboundSchema: z.ZodType<CreateRouterResponseInput2$Outbound, z.ZodTypeDef, CreateRouterResponseInput2>;
export declare function createRouterResponseInput2ToJSON(createRouterResponseInput2: CreateRouterResponseInput2): string;
/** @internal */
export type CreateRouterResponseInput$Outbound = string | Array<CreateRouterResponseInput2$Outbound>;
/** @internal */
export declare const CreateRouterResponseInput$outboundSchema: z.ZodType<CreateRouterResponseInput$Outbound, z.ZodTypeDef, CreateRouterResponseInput>;
export declare function createRouterResponseInputToJSON(createRouterResponseInput: CreateRouterResponseInput): string;
/** @internal */
export declare const TemplateEngine$outboundSchema: z.ZodNativeEnum<typeof TemplateEngine>;
/** @internal */
export type FormatSchema$Outbound = {};
/** @internal */
export declare const FormatSchema$outboundSchema: z.ZodType<FormatSchema$Outbound, z.ZodTypeDef, FormatSchema>;
export declare function formatSchemaToJSON(formatSchema: FormatSchema): string;
/** @internal */
export type FormatJSONSchema$Outbound = {
    description?: string | undefined;
    name?: string | undefined;
    schema?: FormatSchema$Outbound | undefined;
    strict?: boolean | undefined;
    type: "json_schema";
};
/** @internal */
export declare const FormatJSONSchema$outboundSchema: z.ZodType<FormatJSONSchema$Outbound, z.ZodTypeDef, FormatJSONSchema>;
export declare function formatJSONSchemaToJSON(formatJSONSchema: FormatJSONSchema): string;
/** @internal */
export type PlainText$Outbound = {
    type: "text";
};
/** @internal */
export declare const PlainText$outboundSchema: z.ZodType<PlainText$Outbound, z.ZodTypeDef, PlainText>;
export declare function plainTextToJSON(plainText: PlainText): string;
/** @internal */
export type CreateRouterResponseFormat$Outbound = PlainText$Outbound | FormatJSONSchema$Outbound;
/** @internal */
export declare const CreateRouterResponseFormat$outboundSchema: z.ZodType<CreateRouterResponseFormat$Outbound, z.ZodTypeDef, CreateRouterResponseFormat>;
export declare function createRouterResponseFormatToJSON(createRouterResponseFormat: CreateRouterResponseFormat): string;
/** @internal */
export declare const Verbosity$outboundSchema: z.ZodNativeEnum<typeof Verbosity>;
/** @internal */
export type CreateRouterResponseText$Outbound = {
    format?: PlainText$Outbound | FormatJSONSchema$Outbound | undefined;
    verbosity?: string | undefined;
};
/** @internal */
export declare const CreateRouterResponseText$outboundSchema: z.ZodType<CreateRouterResponseText$Outbound, z.ZodTypeDef, CreateRouterResponseText>;
export declare function createRouterResponseTextToJSON(createRouterResponseText: CreateRouterResponseText): string;
/** @internal */
export declare const CreateRouterResponseToolChoiceType$outboundSchema: z.ZodNativeEnum<typeof CreateRouterResponseToolChoiceType>;
/** @internal */
export type SpecificFunction$Outbound = {
    name: string;
    type: string;
};
/** @internal */
export declare const SpecificFunction$outboundSchema: z.ZodType<SpecificFunction$Outbound, z.ZodTypeDef, SpecificFunction>;
export declare function specificFunctionToJSON(specificFunction: SpecificFunction): string;
/** @internal */
export declare const Shorthand$outboundSchema: z.ZodNativeEnum<typeof Shorthand>;
/** @internal */
export type CreateRouterResponseToolChoice$Outbound = SpecificFunction$Outbound | string;
/** @internal */
export declare const CreateRouterResponseToolChoice$outboundSchema: z.ZodType<CreateRouterResponseToolChoice$Outbound, z.ZodTypeDef, CreateRouterResponseToolChoice>;
export declare function createRouterResponseToolChoiceToJSON(createRouterResponseToolChoice: CreateRouterResponseToolChoice): string;
/** @internal */
export type AllowedTools$Outbound = {
    read_only?: boolean | undefined;
    tool_names?: Array<string> | undefined;
};
/** @internal */
export declare const AllowedTools$outboundSchema: z.ZodType<AllowedTools$Outbound, z.ZodTypeDef, AllowedTools>;
export declare function allowedToolsToJSON(allowedTools: AllowedTools): string;
/** @internal */
export type ToolsMCPTool$Outbound = {
    allowed_tools?: AllowedTools$Outbound | undefined;
    headers?: {
        [k: string]: string;
    } | undefined;
    key?: string | undefined;
    server_description?: string | undefined;
    server_url?: string | undefined;
    type: "mcp";
};
/** @internal */
export declare const ToolsMCPTool$outboundSchema: z.ZodType<ToolsMCPTool$Outbound, z.ZodTypeDef, ToolsMCPTool>;
export declare function toolsMCPToolToJSON(toolsMCPTool: ToolsMCPTool): string;
/** @internal */
export declare const CreateRouterResponseToolsResponsesType$outboundSchema: z.ZodNativeEnum<typeof CreateRouterResponseToolsResponsesType>;
/** @internal */
export type OrqAiTool$Outbound = {
    tool_id?: string | undefined;
    type: string;
};
/** @internal */
export declare const OrqAiTool$outboundSchema: z.ZodType<OrqAiTool$Outbound, z.ZodTypeDef, OrqAiTool>;
export declare function orqAiToolToJSON(orqAiTool: OrqAiTool): string;
/** @internal */
export type ToolsParameters$Outbound = {};
/** @internal */
export declare const ToolsParameters$outboundSchema: z.ZodType<ToolsParameters$Outbound, z.ZodTypeDef, ToolsParameters>;
export declare function toolsParametersToJSON(toolsParameters: ToolsParameters): string;
/** @internal */
export type ToolsFunction$Outbound = {
    description?: string | undefined;
    name: string;
    parameters?: ToolsParameters$Outbound | undefined;
    strict?: boolean | undefined;
    type: "function";
};
/** @internal */
export declare const ToolsFunction$outboundSchema: z.ZodType<ToolsFunction$Outbound, z.ZodTypeDef, ToolsFunction>;
export declare function toolsFunctionToJSON(toolsFunction: ToolsFunction): string;
/** @internal */
export type CreateRouterResponseTools$Outbound = ToolsFunction$Outbound | (OrqAiTool$Outbound & {
    type: "orq:current_date";
}) | (OrqAiTool$Outbound & {
    type: "orq:google_search";
}) | (OrqAiTool$Outbound & {
    type: "orq:web_scraper";
}) | (OrqAiTool$Outbound & {
    type: "orq:mcp";
}) | (OrqAiTool$Outbound & {
    type: "orq:http";
}) | (OrqAiTool$Outbound & {
    type: "orq:function";
}) | ToolsMCPTool$Outbound;
/** @internal */
export declare const CreateRouterResponseTools$outboundSchema: z.ZodType<CreateRouterResponseTools$Outbound, z.ZodTypeDef, CreateRouterResponseTools>;
export declare function createRouterResponseToolsToJSON(createRouterResponseTools: CreateRouterResponseTools): string;
/** @internal */
export type CreateRouterResponseRequestBody$Outbound = {
    conversation?: components.ConversationParam$Outbound | undefined;
    fallbacks?: Array<components.FallbackConfig$Outbound> | null | undefined;
    frequency_penalty?: number | undefined;
    identity?: components.ResponseIdentity$Outbound | undefined;
    input?: string | Array<CreateRouterResponseInput2$Outbound> | undefined;
    instructions?: string | undefined;
    limits?: components.ResponseExecutionLimits$Outbound | undefined;
    max_output_tokens?: number | undefined;
    max_tool_calls?: number | undefined;
    memory?: components.MemoryParam$Outbound | undefined;
    metadata?: {
        [k: string]: string;
    } | undefined;
    model?: string | undefined;
    parallel_tool_calls?: boolean | undefined;
    presence_penalty?: number | undefined;
    previous_response_id?: string | undefined;
    prompt_cache_key?: string | undefined;
    reasoning?: components.ReasoningParam$Outbound | undefined;
    retry?: components.ResponseRetryConfig$Outbound | undefined;
    safety_identifier?: string | undefined;
    store?: boolean | undefined;
    stream?: boolean | undefined;
    stream_options?: components.StreamOptions$Outbound | undefined;
    temperature?: number | undefined;
    template_engine?: string | undefined;
    text?: CreateRouterResponseText$Outbound | undefined;
    thread?: components.ResponseThread$Outbound | undefined;
    tool_choice?: SpecificFunction$Outbound | string | undefined;
    tools?: Array<ToolsFunction$Outbound | (OrqAiTool$Outbound & {
        type: "orq:current_date";
    }) | (OrqAiTool$Outbound & {
        type: "orq:google_search";
    }) | (OrqAiTool$Outbound & {
        type: "orq:web_scraper";
    }) | (OrqAiTool$Outbound & {
        type: "orq:mcp";
    }) | (OrqAiTool$Outbound & {
        type: "orq:http";
    }) | (OrqAiTool$Outbound & {
        type: "orq:function";
    }) | ToolsMCPTool$Outbound> | undefined;
    top_logprobs?: number | undefined;
    top_p?: number | undefined;
    variables?: {
        [k: string]: any;
    } | undefined;
};
/** @internal */
export declare const CreateRouterResponseRequestBody$outboundSchema: z.ZodType<CreateRouterResponseRequestBody$Outbound, z.ZodTypeDef, CreateRouterResponseRequestBody>;
export declare function createRouterResponseRequestBodyToJSON(createRouterResponseRequestBody: CreateRouterResponseRequestBody): string;
/** @internal */
export declare const CreateRouterResponseType$inboundSchema: z.ZodNativeEnum<typeof CreateRouterResponseType>;
/** @internal */
export declare const CreateRouterResponseData$inboundSchema: z.ZodType<CreateRouterResponseData, z.ZodTypeDef, unknown>;
export declare function createRouterResponseDataFromJSON(jsonString: string): SafeParseResult<CreateRouterResponseData, SDKValidationError>;
/** @internal */
export declare const CreateRouterResponseResponsesResponseBody$inboundSchema: z.ZodType<CreateRouterResponseResponsesResponseBody, z.ZodTypeDef, unknown>;
export declare function createRouterResponseResponsesResponseBodyFromJSON(jsonString: string): SafeParseResult<CreateRouterResponseResponsesResponseBody, SDKValidationError>;
/** @internal */
export declare const CreateRouterResponseServiceTier$inboundSchema: z.ZodNativeEnum<typeof CreateRouterResponseServiceTier>;
/** @internal */
export declare const CreateRouterResponseStatus$inboundSchema: z.ZodNativeEnum<typeof CreateRouterResponseStatus>;
/** @internal */
export declare const CreateRouterResponseTruncation$inboundSchema: z.ZodNativeEnum<typeof CreateRouterResponseTruncation>;
/** @internal */
export declare const CreateRouterResponseResponseBody$inboundSchema: z.ZodType<CreateRouterResponseResponseBody, z.ZodTypeDef, unknown>;
export declare function createRouterResponseResponseBodyFromJSON(jsonString: string): SafeParseResult<CreateRouterResponseResponseBody, SDKValidationError>;
/** @internal */
export declare const CreateRouterResponseResponse$inboundSchema: z.ZodType<CreateRouterResponseResponse, z.ZodTypeDef, unknown>;
export declare function createRouterResponseResponseFromJSON(jsonString: string): SafeParseResult<CreateRouterResponseResponse, SDKValidationError>;
//# sourceMappingURL=createrouterresponse.d.ts.map