/**
 * @since 1.0.0
 */
import type * as HttpClient from "@effect/platform/HttpClient";
import * as HttpClientError from "@effect/platform/HttpClientError";
import * as HttpClientRequest from "@effect/platform/HttpClientRequest";
import * as HttpClientResponse from "@effect/platform/HttpClientResponse";
import * as Effect from "effect/Effect";
import type { ParseError } from "effect/ParseResult";
import * as S from "effect/Schema";
declare const CacheControlEphemeral_base: S.Class<CacheControlEphemeral, {
    type: S.Literal<["ephemeral"]>;
}, S.Struct.Encoded<{
    type: S.Literal<["ephemeral"]>;
}>, never, {
    readonly type: "ephemeral";
}, {}, {}>;
export declare class CacheControlEphemeral extends CacheControlEphemeral_base {
}
declare const OpenResponsesReasoningFormat_base: S.Literal<["unknown", "openai-responses-v1", "azure-openai-responses-v1", "xai-responses-v1", "anthropic-claude-v1", "google-gemini-v1"]>;
export declare class OpenResponsesReasoningFormat extends OpenResponsesReasoningFormat_base {
}
declare const OpenResponsesReasoningType_base: S.Literal<["reasoning"]>;
export declare class OpenResponsesReasoningType extends OpenResponsesReasoningType_base {
}
declare const ReasoningTextContentType_base: S.Literal<["reasoning_text"]>;
export declare class ReasoningTextContentType extends ReasoningTextContentType_base {
}
declare const ReasoningTextContent_base: S.Class<ReasoningTextContent, {
    type: typeof ReasoningTextContentType;
    text: typeof S.String;
}, S.Struct.Encoded<{
    type: typeof ReasoningTextContentType;
    text: typeof S.String;
}>, never, {
    readonly type: "reasoning_text";
} & {
    readonly text: string;
}, {}, {}>;
export declare class ReasoningTextContent extends ReasoningTextContent_base {
}
declare const ReasoningSummaryTextType_base: S.Literal<["summary_text"]>;
export declare class ReasoningSummaryTextType extends ReasoningSummaryTextType_base {
}
declare const ReasoningSummaryText_base: S.Class<ReasoningSummaryText, {
    type: typeof ReasoningSummaryTextType;
    text: typeof S.String;
}, S.Struct.Encoded<{
    type: typeof ReasoningSummaryTextType;
    text: typeof S.String;
}>, never, {
    readonly type: "summary_text";
} & {
    readonly text: string;
}, {}, {}>;
export declare class ReasoningSummaryText extends ReasoningSummaryText_base {
}
declare const OpenResponsesReasoningStatusEnum_base: S.Literal<["in_progress"]>;
export declare class OpenResponsesReasoningStatusEnum extends OpenResponsesReasoningStatusEnum_base {
}
declare const OpenResponsesReasoning_base: S.Class<OpenResponsesReasoning, {
    signature: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    format: S.optionalWith<typeof OpenResponsesReasoningFormat, {
        nullable: true;
    }>;
    type: typeof OpenResponsesReasoningType;
    id: typeof S.String;
    content: S.optionalWith<S.Array$<typeof ReasoningTextContent>, {
        nullable: true;
    }>;
    summary: S.Array$<typeof ReasoningSummaryText>;
    encrypted_content: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    status: S.optionalWith<S.Union<[typeof OpenResponsesReasoningStatusEnum, typeof OpenResponsesReasoningStatusEnum, typeof OpenResponsesReasoningStatusEnum]>, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    signature: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    format: S.optionalWith<typeof OpenResponsesReasoningFormat, {
        nullable: true;
    }>;
    type: typeof OpenResponsesReasoningType;
    id: typeof S.String;
    content: S.optionalWith<S.Array$<typeof ReasoningTextContent>, {
        nullable: true;
    }>;
    summary: S.Array$<typeof ReasoningSummaryText>;
    encrypted_content: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    status: S.optionalWith<S.Union<[typeof OpenResponsesReasoningStatusEnum, typeof OpenResponsesReasoningStatusEnum, typeof OpenResponsesReasoningStatusEnum]>, {
        nullable: true;
    }>;
}>, never, {
    readonly type: "reasoning";
} & {
    readonly id: string;
} & {
    readonly signature?: string | undefined;
} & {
    readonly format?: "unknown" | "openai-responses-v1" | "azure-openai-responses-v1" | "xai-responses-v1" | "anthropic-claude-v1" | "google-gemini-v1" | undefined;
} & {
    readonly content?: readonly ReasoningTextContent[] | undefined;
} & {
    readonly summary: readonly ReasoningSummaryText[];
} & {
    readonly encrypted_content?: string | undefined;
} & {
    readonly status?: "in_progress" | undefined;
}, {}, {}>;
export declare class OpenResponsesReasoning extends OpenResponsesReasoning_base {
}
declare const ReasoningDetailSummary_base: S.Class<ReasoningDetailSummary, {
    id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    type: S.Literal<["reasoning.summary"]>;
    index: S.optional<typeof S.Number>;
    format: S.optionalWith<typeof OpenResponsesReasoningFormat, {
        nullable: true;
    }>;
    summary: typeof S.String;
}, S.Struct.Encoded<{
    id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    type: S.Literal<["reasoning.summary"]>;
    index: S.optional<typeof S.Number>;
    format: S.optionalWith<typeof OpenResponsesReasoningFormat, {
        nullable: true;
    }>;
    summary: typeof S.String;
}>, never, {
    readonly type: "reasoning.summary";
} & {
    readonly id?: string | undefined;
} & {
    readonly format?: "unknown" | "openai-responses-v1" | "azure-openai-responses-v1" | "xai-responses-v1" | "anthropic-claude-v1" | "google-gemini-v1" | undefined;
} & {
    readonly summary: string;
} & {
    readonly index?: number | undefined;
}, {}, {}>;
export declare class ReasoningDetailSummary extends ReasoningDetailSummary_base {
}
declare const ReasoningDetailEncrypted_base: S.Class<ReasoningDetailEncrypted, {
    id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    type: S.Literal<["reasoning.encrypted"]>;
    index: S.optional<typeof S.Number>;
    format: S.optionalWith<typeof OpenResponsesReasoningFormat, {
        nullable: true;
    }>;
    data: typeof S.String;
}, S.Struct.Encoded<{
    id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    type: S.Literal<["reasoning.encrypted"]>;
    index: S.optional<typeof S.Number>;
    format: S.optionalWith<typeof OpenResponsesReasoningFormat, {
        nullable: true;
    }>;
    data: typeof S.String;
}>, never, {
    readonly type: "reasoning.encrypted";
} & {
    readonly id?: string | undefined;
} & {
    readonly format?: "unknown" | "openai-responses-v1" | "azure-openai-responses-v1" | "xai-responses-v1" | "anthropic-claude-v1" | "google-gemini-v1" | undefined;
} & {
    readonly index?: number | undefined;
} & {
    readonly data: string;
}, {}, {}>;
export declare class ReasoningDetailEncrypted extends ReasoningDetailEncrypted_base {
}
declare const ReasoningDetailText_base: S.Class<ReasoningDetailText, {
    id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    type: S.Literal<["reasoning.text"]>;
    index: S.optional<typeof S.Number>;
    format: S.optionalWith<typeof OpenResponsesReasoningFormat, {
        nullable: true;
    }>;
    text: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    signature: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    type: S.Literal<["reasoning.text"]>;
    index: S.optional<typeof S.Number>;
    format: S.optionalWith<typeof OpenResponsesReasoningFormat, {
        nullable: true;
    }>;
    text: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    signature: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}>, never, {
    readonly type: "reasoning.text";
} & {
    readonly text?: string | undefined;
} & {
    readonly id?: string | undefined;
} & {
    readonly signature?: string | undefined;
} & {
    readonly format?: "unknown" | "openai-responses-v1" | "azure-openai-responses-v1" | "xai-responses-v1" | "anthropic-claude-v1" | "google-gemini-v1" | undefined;
} & {
    readonly index?: number | undefined;
}, {}, {}>;
export declare class ReasoningDetailText extends ReasoningDetailText_base {
}
declare const ReasoningDetail_base: S.Union<[typeof ReasoningDetailSummary, typeof ReasoningDetailEncrypted, typeof ReasoningDetailText]>;
export declare class ReasoningDetail extends ReasoningDetail_base {
}
declare const FileAnnotationDetail_base: S.Class<FileAnnotationDetail, {
    type: S.Literal<["file"]>;
    file: S.Struct<{
        hash: typeof S.String;
        name: S.optionalWith<typeof S.String, {
            nullable: true;
        }>;
        content: S.Array$<S.Union<[S.Struct<{
            type: S.Literal<["text"]>;
            text: typeof S.String;
        }>, S.Struct<{
            type: S.Literal<["image_url"]>;
            image_url: S.Struct<{
                url: typeof S.String;
            }>;
        }>]>>;
    }>;
}, S.Struct.Encoded<{
    type: S.Literal<["file"]>;
    file: S.Struct<{
        hash: typeof S.String;
        name: S.optionalWith<typeof S.String, {
            nullable: true;
        }>;
        content: S.Array$<S.Union<[S.Struct<{
            type: S.Literal<["text"]>;
            text: typeof S.String;
        }>, S.Struct<{
            type: S.Literal<["image_url"]>;
            image_url: S.Struct<{
                url: typeof S.String;
            }>;
        }>]>>;
    }>;
}>, never, {
    readonly type: "file";
} & {
    readonly file: {
        readonly content: readonly ({
            readonly type: "text";
            readonly text: string;
        } | {
            readonly type: "image_url";
            readonly image_url: {
                readonly url: string;
            };
        })[];
        readonly hash: string;
        readonly name?: string | undefined;
    };
}, {}, {}>;
export declare class FileAnnotationDetail extends FileAnnotationDetail_base {
}
declare const URLCitationAnnotationDetail_base: S.Class<URLCitationAnnotationDetail, {
    type: S.Literal<["url_citation"]>;
    url_citation: S.Struct<{
        end_index: typeof S.Number;
        start_index: typeof S.Number;
        title: typeof S.String;
        url: typeof S.String;
        content: S.optionalWith<typeof S.String, {
            nullable: true;
        }>;
    }>;
}, S.Struct.Encoded<{
    type: S.Literal<["url_citation"]>;
    url_citation: S.Struct<{
        end_index: typeof S.Number;
        start_index: typeof S.Number;
        title: typeof S.String;
        url: typeof S.String;
        content: S.optionalWith<typeof S.String, {
            nullable: true;
        }>;
    }>;
}>, never, {
    readonly type: "url_citation";
} & {
    readonly url_citation: {
        readonly content?: string | undefined;
        readonly url: string;
        readonly end_index: number;
        readonly start_index: number;
        readonly title: string;
    };
}, {}, {}>;
export declare class URLCitationAnnotationDetail extends URLCitationAnnotationDetail_base {
}
declare const AnnotationDetail_base: S.Union<[typeof FileAnnotationDetail, typeof URLCitationAnnotationDetail]>;
export declare class AnnotationDetail extends AnnotationDetail_base {
}
declare const OpenResponsesEasyInputMessageType_base: S.Literal<["message"]>;
export declare class OpenResponsesEasyInputMessageType extends OpenResponsesEasyInputMessageType_base {
}
declare const OpenResponsesEasyInputMessageRoleEnum_base: S.Literal<["developer"]>;
export declare class OpenResponsesEasyInputMessageRoleEnum extends OpenResponsesEasyInputMessageRoleEnum_base {
}
declare const ResponseInputTextType_base: S.Literal<["input_text"]>;
export declare class ResponseInputTextType extends ResponseInputTextType_base {
}
declare const ResponseInputText_base: S.Class<ResponseInputText, {
    type: typeof ResponseInputTextType;
    text: typeof S.String;
}, S.Struct.Encoded<{
    type: typeof ResponseInputTextType;
    text: typeof S.String;
}>, never, {
    readonly type: "input_text";
} & {
    readonly text: string;
}, {}, {}>;
/**
 * Text input content item
 */
export declare class ResponseInputText extends ResponseInputText_base {
}
declare const ResponseInputFileType_base: S.Literal<["input_file"]>;
export declare class ResponseInputFileType extends ResponseInputFileType_base {
}
declare const ResponseInputFile_base: S.Class<ResponseInputFile, {
    type: typeof ResponseInputFileType;
    file_id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    file_data: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    filename: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    file_url: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    type: typeof ResponseInputFileType;
    file_id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    file_data: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    filename: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    file_url: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}>, never, {
    readonly type: "input_file";
} & {
    readonly file_id?: string | undefined;
} & {
    readonly file_data?: string | undefined;
} & {
    readonly filename?: string | undefined;
} & {
    readonly file_url?: string | undefined;
}, {}, {}>;
/**
 * File input content item
 */
export declare class ResponseInputFile extends ResponseInputFile_base {
}
declare const ResponseInputAudioType_base: S.Literal<["input_audio"]>;
export declare class ResponseInputAudioType extends ResponseInputAudioType_base {
}
declare const ResponseInputAudioInputAudioFormat_base: S.Literal<["mp3", "wav"]>;
export declare class ResponseInputAudioInputAudioFormat extends ResponseInputAudioInputAudioFormat_base {
}
declare const ResponseInputAudio_base: S.Class<ResponseInputAudio, {
    type: typeof ResponseInputAudioType;
    input_audio: S.Struct<{
        data: typeof S.String;
        format: typeof ResponseInputAudioInputAudioFormat;
    }>;
}, S.Struct.Encoded<{
    type: typeof ResponseInputAudioType;
    input_audio: S.Struct<{
        data: typeof S.String;
        format: typeof ResponseInputAudioInputAudioFormat;
    }>;
}>, never, {
    readonly type: "input_audio";
} & {
    readonly input_audio: {
        readonly format: "mp3" | "wav";
        readonly data: string;
    };
}, {}, {}>;
/**
 * Audio input content item
 */
export declare class ResponseInputAudio extends ResponseInputAudio_base {
}
declare const ResponseInputVideoType_base: S.Literal<["input_video"]>;
export declare class ResponseInputVideoType extends ResponseInputVideoType_base {
}
declare const ResponseInputVideo_base: S.Class<ResponseInputVideo, {
    type: typeof ResponseInputVideoType;
    /**
     * A base64 data URL or remote URL that resolves to a video file
     */
    video_url: typeof S.String;
}, S.Struct.Encoded<{
    type: typeof ResponseInputVideoType;
    /**
     * A base64 data URL or remote URL that resolves to a video file
     */
    video_url: typeof S.String;
}>, never, {
    readonly type: "input_video";
} & {
    readonly video_url: string;
}, {}, {}>;
/**
 * Video input content item
 */
export declare class ResponseInputVideo extends ResponseInputVideo_base {
}
declare const OpenResponsesEasyInputMessage_base: S.Class<OpenResponsesEasyInputMessage, {
    type: S.optionalWith<typeof OpenResponsesEasyInputMessageType, {
        nullable: true;
    }>;
    role: S.Union<[typeof OpenResponsesEasyInputMessageRoleEnum, typeof OpenResponsesEasyInputMessageRoleEnum, typeof OpenResponsesEasyInputMessageRoleEnum, typeof OpenResponsesEasyInputMessageRoleEnum]>;
    content: S.Union<[S.Array$<S.Union<[typeof ResponseInputText, S.Struct<{
        type: S.Literal<["input_image"]>;
        detail: S.Literal<["auto", "high", "low"]>;
        image_url: S.optionalWith<typeof S.String, {
            nullable: true;
        }>;
    }>, typeof ResponseInputFile, typeof ResponseInputAudio, typeof ResponseInputVideo]>>, typeof S.String]>;
}, S.Struct.Encoded<{
    type: S.optionalWith<typeof OpenResponsesEasyInputMessageType, {
        nullable: true;
    }>;
    role: S.Union<[typeof OpenResponsesEasyInputMessageRoleEnum, typeof OpenResponsesEasyInputMessageRoleEnum, typeof OpenResponsesEasyInputMessageRoleEnum, typeof OpenResponsesEasyInputMessageRoleEnum]>;
    content: S.Union<[S.Array$<S.Union<[typeof ResponseInputText, S.Struct<{
        type: S.Literal<["input_image"]>;
        detail: S.Literal<["auto", "high", "low"]>;
        image_url: S.optionalWith<typeof S.String, {
            nullable: true;
        }>;
    }>, typeof ResponseInputFile, typeof ResponseInputAudio, typeof ResponseInputVideo]>>, typeof S.String]>;
}>, never, {
    readonly type?: "message" | undefined;
} & {
    readonly content: string | readonly (ResponseInputText | ResponseInputFile | ResponseInputAudio | ResponseInputVideo | {
        readonly type: "input_image";
        readonly image_url?: string | undefined;
        readonly detail: "auto" | "high" | "low";
    })[];
} & {
    readonly role: "developer";
}, {}, {}>;
export declare class OpenResponsesEasyInputMessage extends OpenResponsesEasyInputMessage_base {
}
declare const OpenResponsesInputMessageItemType_base: S.Literal<["message"]>;
export declare class OpenResponsesInputMessageItemType extends OpenResponsesInputMessageItemType_base {
}
declare const OpenResponsesInputMessageItemRoleEnum_base: S.Literal<["developer"]>;
export declare class OpenResponsesInputMessageItemRoleEnum extends OpenResponsesInputMessageItemRoleEnum_base {
}
declare const OpenResponsesInputMessageItem_base: S.Class<OpenResponsesInputMessageItem, {
    id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    type: S.optionalWith<typeof OpenResponsesInputMessageItemType, {
        nullable: true;
    }>;
    role: S.Union<[typeof OpenResponsesInputMessageItemRoleEnum, typeof OpenResponsesInputMessageItemRoleEnum, typeof OpenResponsesInputMessageItemRoleEnum]>;
    content: S.Array$<S.Union<[typeof ResponseInputText, S.Struct<{
        type: S.Literal<["input_image"]>;
        detail: S.Literal<["auto", "high", "low"]>;
        image_url: S.optionalWith<typeof S.String, {
            nullable: true;
        }>;
    }>, typeof ResponseInputFile, typeof ResponseInputAudio, typeof ResponseInputVideo]>>;
}, S.Struct.Encoded<{
    id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    type: S.optionalWith<typeof OpenResponsesInputMessageItemType, {
        nullable: true;
    }>;
    role: S.Union<[typeof OpenResponsesInputMessageItemRoleEnum, typeof OpenResponsesInputMessageItemRoleEnum, typeof OpenResponsesInputMessageItemRoleEnum]>;
    content: S.Array$<S.Union<[typeof ResponseInputText, S.Struct<{
        type: S.Literal<["input_image"]>;
        detail: S.Literal<["auto", "high", "low"]>;
        image_url: S.optionalWith<typeof S.String, {
            nullable: true;
        }>;
    }>, typeof ResponseInputFile, typeof ResponseInputAudio, typeof ResponseInputVideo]>>;
}>, never, {
    readonly type?: "message" | undefined;
} & {
    readonly id?: string | undefined;
} & {
    readonly content: readonly (ResponseInputText | ResponseInputFile | ResponseInputAudio | ResponseInputVideo | {
        readonly type: "input_image";
        readonly image_url?: string | undefined;
        readonly detail: "auto" | "high" | "low";
    })[];
} & {
    readonly role: "developer";
}, {}, {}>;
export declare class OpenResponsesInputMessageItem extends OpenResponsesInputMessageItem_base {
}
declare const OpenResponsesFunctionToolCallType_base: S.Literal<["function_call"]>;
export declare class OpenResponsesFunctionToolCallType extends OpenResponsesFunctionToolCallType_base {
}
declare const ToolCallStatus_base: S.Literal<["in_progress", "completed", "incomplete"]>;
export declare class ToolCallStatus extends ToolCallStatus_base {
}
declare const OpenResponsesFunctionToolCall_base: S.Class<OpenResponsesFunctionToolCall, {
    type: typeof OpenResponsesFunctionToolCallType;
    call_id: typeof S.String;
    name: typeof S.String;
    arguments: typeof S.String;
    id: typeof S.String;
    status: S.optionalWith<typeof ToolCallStatus, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    type: typeof OpenResponsesFunctionToolCallType;
    call_id: typeof S.String;
    name: typeof S.String;
    arguments: typeof S.String;
    id: typeof S.String;
    status: S.optionalWith<typeof ToolCallStatus, {
        nullable: true;
    }>;
}>, never, {
    readonly type: "function_call";
} & {
    readonly id: string;
} & {
    readonly status?: "in_progress" | "completed" | "incomplete" | undefined;
} & {
    readonly name: string;
} & {
    readonly call_id: string;
} & {
    readonly arguments: string;
}, {}, {}>;
/**
 * A function call initiated by the model
 */
export declare class OpenResponsesFunctionToolCall extends OpenResponsesFunctionToolCall_base {
}
declare const OpenResponsesFunctionCallOutputType_base: S.Literal<["function_call_output"]>;
export declare class OpenResponsesFunctionCallOutputType extends OpenResponsesFunctionCallOutputType_base {
}
declare const OpenResponsesFunctionCallOutput_base: S.Class<OpenResponsesFunctionCallOutput, {
    type: typeof OpenResponsesFunctionCallOutputType;
    id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    call_id: typeof S.String;
    output: typeof S.String;
    status: S.optionalWith<typeof ToolCallStatus, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    type: typeof OpenResponsesFunctionCallOutputType;
    id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    call_id: typeof S.String;
    output: typeof S.String;
    status: S.optionalWith<typeof ToolCallStatus, {
        nullable: true;
    }>;
}>, never, {
    readonly type: "function_call_output";
} & {
    readonly id?: string | undefined;
} & {
    readonly status?: "in_progress" | "completed" | "incomplete" | undefined;
} & {
    readonly call_id: string;
} & {
    readonly output: string;
}, {}, {}>;
/**
 * The output from a function call execution
 */
export declare class OpenResponsesFunctionCallOutput extends OpenResponsesFunctionCallOutput_base {
}
declare const ResponsesOutputMessageRole_base: S.Literal<["assistant"]>;
export declare class ResponsesOutputMessageRole extends ResponsesOutputMessageRole_base {
}
declare const ResponsesOutputMessageType_base: S.Literal<["message"]>;
export declare class ResponsesOutputMessageType extends ResponsesOutputMessageType_base {
}
declare const ResponsesOutputMessageStatusEnum_base: S.Literal<["in_progress"]>;
export declare class ResponsesOutputMessageStatusEnum extends ResponsesOutputMessageStatusEnum_base {
}
declare const ResponseOutputTextType_base: S.Literal<["output_text"]>;
export declare class ResponseOutputTextType extends ResponseOutputTextType_base {
}
declare const FileCitationType_base: S.Literal<["file_citation"]>;
export declare class FileCitationType extends FileCitationType_base {
}
declare const FileCitation_base: S.Class<FileCitation, {
    type: typeof FileCitationType;
    file_id: typeof S.String;
    filename: typeof S.String;
    index: typeof S.Number;
}, S.Struct.Encoded<{
    type: typeof FileCitationType;
    file_id: typeof S.String;
    filename: typeof S.String;
    index: typeof S.Number;
}>, never, {
    readonly type: "file_citation";
} & {
    readonly index: number;
} & {
    readonly file_id: string;
} & {
    readonly filename: string;
}, {}, {}>;
export declare class FileCitation extends FileCitation_base {
}
declare const URLCitationType_base: S.Literal<["url_citation"]>;
export declare class URLCitationType extends URLCitationType_base {
}
declare const URLCitation_base: S.Class<URLCitation, {
    type: typeof URLCitationType;
    url: typeof S.String;
    title: typeof S.String;
    start_index: typeof S.Number;
    end_index: typeof S.Number;
}, S.Struct.Encoded<{
    type: typeof URLCitationType;
    url: typeof S.String;
    title: typeof S.String;
    start_index: typeof S.Number;
    end_index: typeof S.Number;
}>, never, {
    readonly type: "url_citation";
} & {
    readonly url: string;
} & {
    readonly end_index: number;
} & {
    readonly start_index: number;
} & {
    readonly title: string;
}, {}, {}>;
export declare class URLCitation extends URLCitation_base {
}
declare const FilePathType_base: S.Literal<["file_path"]>;
export declare class FilePathType extends FilePathType_base {
}
declare const FilePath_base: S.Class<FilePath, {
    type: typeof FilePathType;
    file_id: typeof S.String;
    index: typeof S.Number;
}, S.Struct.Encoded<{
    type: typeof FilePathType;
    file_id: typeof S.String;
    index: typeof S.Number;
}>, never, {
    readonly type: "file_path";
} & {
    readonly index: number;
} & {
    readonly file_id: string;
}, {}, {}>;
export declare class FilePath extends FilePath_base {
}
declare const OpenAIResponsesAnnotation_base: S.Union<[typeof FileCitation, typeof URLCitation, typeof FilePath]>;
export declare class OpenAIResponsesAnnotation extends OpenAIResponsesAnnotation_base {
}
declare const ResponseOutputText_base: S.Class<ResponseOutputText, {
    type: typeof ResponseOutputTextType;
    text: typeof S.String;
    annotations: S.optionalWith<S.Array$<typeof OpenAIResponsesAnnotation>, {
        nullable: true;
    }>;
    logprobs: S.optionalWith<S.Array$<S.Struct<{
        token: typeof S.String;
        bytes: S.Array$<typeof S.Number>;
        logprob: typeof S.Number;
        top_logprobs: S.Array$<S.Struct<{
            token: typeof S.String;
            bytes: S.Array$<typeof S.Number>;
            logprob: typeof S.Number;
        }>>;
    }>>, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    type: typeof ResponseOutputTextType;
    text: typeof S.String;
    annotations: S.optionalWith<S.Array$<typeof OpenAIResponsesAnnotation>, {
        nullable: true;
    }>;
    logprobs: S.optionalWith<S.Array$<S.Struct<{
        token: typeof S.String;
        bytes: S.Array$<typeof S.Number>;
        logprob: typeof S.Number;
        top_logprobs: S.Array$<S.Struct<{
            token: typeof S.String;
            bytes: S.Array$<typeof S.Number>;
            logprob: typeof S.Number;
        }>>;
    }>>, {
        nullable: true;
    }>;
}>, never, {
    readonly annotations?: readonly (FileCitation | URLCitation | FilePath)[] | undefined;
} & {
    readonly type: "output_text";
} & {
    readonly text: string;
} & {
    readonly logprobs?: readonly {
        readonly token: string;
        readonly bytes: readonly number[];
        readonly logprob: number;
        readonly top_logprobs: readonly {
            readonly token: string;
            readonly bytes: readonly number[];
            readonly logprob: number;
        }[];
    }[] | undefined;
}, {}, {}>;
export declare class ResponseOutputText extends ResponseOutputText_base {
}
declare const OpenAIResponsesRefusalContentType_base: S.Literal<["refusal"]>;
export declare class OpenAIResponsesRefusalContentType extends OpenAIResponsesRefusalContentType_base {
}
declare const OpenAIResponsesRefusalContent_base: S.Class<OpenAIResponsesRefusalContent, {
    type: typeof OpenAIResponsesRefusalContentType;
    refusal: typeof S.String;
}, S.Struct.Encoded<{
    type: typeof OpenAIResponsesRefusalContentType;
    refusal: typeof S.String;
}>, never, {
    readonly type: "refusal";
} & {
    readonly refusal: string;
}, {}, {}>;
export declare class OpenAIResponsesRefusalContent extends OpenAIResponsesRefusalContent_base {
}
declare const ResponsesOutputMessage_base: S.Class<ResponsesOutputMessage, {
    id: typeof S.String;
    role: typeof ResponsesOutputMessageRole;
    type: typeof ResponsesOutputMessageType;
    status: S.optionalWith<S.Union<[typeof ResponsesOutputMessageStatusEnum, typeof ResponsesOutputMessageStatusEnum, typeof ResponsesOutputMessageStatusEnum]>, {
        nullable: true;
    }>;
    content: S.Array$<S.Union<[typeof ResponseOutputText, typeof OpenAIResponsesRefusalContent]>>;
}, S.Struct.Encoded<{
    id: typeof S.String;
    role: typeof ResponsesOutputMessageRole;
    type: typeof ResponsesOutputMessageType;
    status: S.optionalWith<S.Union<[typeof ResponsesOutputMessageStatusEnum, typeof ResponsesOutputMessageStatusEnum, typeof ResponsesOutputMessageStatusEnum]>, {
        nullable: true;
    }>;
    content: S.Array$<S.Union<[typeof ResponseOutputText, typeof OpenAIResponsesRefusalContent]>>;
}>, never, {
    readonly type: "message";
} & {
    readonly id: string;
} & {
    readonly content: readonly (ResponseOutputText | OpenAIResponsesRefusalContent)[];
} & {
    readonly status?: "in_progress" | undefined;
} & {
    readonly role: "assistant";
}, {}, {}>;
export declare class ResponsesOutputMessage extends ResponsesOutputMessage_base {
}
declare const ResponsesOutputItemReasoningFormat_base: S.Literal<["unknown", "openai-responses-v1", "azure-openai-responses-v1", "xai-responses-v1", "anthropic-claude-v1", "google-gemini-v1"]>;
/**
 * The format of the reasoning content
 */
export declare class ResponsesOutputItemReasoningFormat extends ResponsesOutputItemReasoningFormat_base {
}
declare const ResponsesOutputItemReasoningType_base: S.Literal<["reasoning"]>;
export declare class ResponsesOutputItemReasoningType extends ResponsesOutputItemReasoningType_base {
}
declare const ResponsesOutputItemReasoningStatusEnum_base: S.Literal<["in_progress"]>;
export declare class ResponsesOutputItemReasoningStatusEnum extends ResponsesOutputItemReasoningStatusEnum_base {
}
declare const ResponsesOutputItemReasoning_base: S.Class<ResponsesOutputItemReasoning, {
    /**
     * A signature for the reasoning content, used for verification
     */
    signature: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    /**
     * The format of the reasoning content
     */
    format: S.optionalWith<typeof ResponsesOutputItemReasoningFormat, {
        nullable: true;
    }>;
    type: typeof ResponsesOutputItemReasoningType;
    id: typeof S.String;
    content: S.optionalWith<S.Array$<typeof ReasoningTextContent>, {
        nullable: true;
    }>;
    summary: S.Array$<typeof ReasoningSummaryText>;
    encrypted_content: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    status: S.optionalWith<S.Union<[typeof ResponsesOutputItemReasoningStatusEnum, typeof ResponsesOutputItemReasoningStatusEnum, typeof ResponsesOutputItemReasoningStatusEnum]>, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    /**
     * A signature for the reasoning content, used for verification
     */
    signature: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    /**
     * The format of the reasoning content
     */
    format: S.optionalWith<typeof ResponsesOutputItemReasoningFormat, {
        nullable: true;
    }>;
    type: typeof ResponsesOutputItemReasoningType;
    id: typeof S.String;
    content: S.optionalWith<S.Array$<typeof ReasoningTextContent>, {
        nullable: true;
    }>;
    summary: S.Array$<typeof ReasoningSummaryText>;
    encrypted_content: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    status: S.optionalWith<S.Union<[typeof ResponsesOutputItemReasoningStatusEnum, typeof ResponsesOutputItemReasoningStatusEnum, typeof ResponsesOutputItemReasoningStatusEnum]>, {
        nullable: true;
    }>;
}>, never, {
    readonly type: "reasoning";
} & {
    readonly id: string;
} & {
    readonly signature?: string | undefined;
} & {
    readonly format?: "unknown" | "openai-responses-v1" | "azure-openai-responses-v1" | "xai-responses-v1" | "anthropic-claude-v1" | "google-gemini-v1" | undefined;
} & {
    readonly content?: readonly ReasoningTextContent[] | undefined;
} & {
    readonly summary: readonly ReasoningSummaryText[];
} & {
    readonly encrypted_content?: string | undefined;
} & {
    readonly status?: "in_progress" | undefined;
}, {}, {}>;
export declare class ResponsesOutputItemReasoning extends ResponsesOutputItemReasoning_base {
}
declare const ResponsesOutputItemFunctionCallType_base: S.Literal<["function_call"]>;
export declare class ResponsesOutputItemFunctionCallType extends ResponsesOutputItemFunctionCallType_base {
}
declare const ResponsesOutputItemFunctionCallStatusEnum_base: S.Literal<["in_progress"]>;
export declare class ResponsesOutputItemFunctionCallStatusEnum extends ResponsesOutputItemFunctionCallStatusEnum_base {
}
declare const ResponsesOutputItemFunctionCall_base: S.Class<ResponsesOutputItemFunctionCall, {
    type: typeof ResponsesOutputItemFunctionCallType;
    id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    name: typeof S.String;
    arguments: typeof S.String;
    call_id: typeof S.String;
    status: S.optionalWith<S.Union<[typeof ResponsesOutputItemFunctionCallStatusEnum, typeof ResponsesOutputItemFunctionCallStatusEnum, typeof ResponsesOutputItemFunctionCallStatusEnum]>, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    type: typeof ResponsesOutputItemFunctionCallType;
    id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    name: typeof S.String;
    arguments: typeof S.String;
    call_id: typeof S.String;
    status: S.optionalWith<S.Union<[typeof ResponsesOutputItemFunctionCallStatusEnum, typeof ResponsesOutputItemFunctionCallStatusEnum, typeof ResponsesOutputItemFunctionCallStatusEnum]>, {
        nullable: true;
    }>;
}>, never, {
    readonly type: "function_call";
} & {
    readonly id?: string | undefined;
} & {
    readonly status?: "in_progress" | undefined;
} & {
    readonly name: string;
} & {
    readonly call_id: string;
} & {
    readonly arguments: string;
}, {}, {}>;
export declare class ResponsesOutputItemFunctionCall extends ResponsesOutputItemFunctionCall_base {
}
declare const ResponsesWebSearchCallOutputType_base: S.Literal<["web_search_call"]>;
export declare class ResponsesWebSearchCallOutputType extends ResponsesWebSearchCallOutputType_base {
}
declare const WebSearchStatus_base: S.Literal<["completed", "searching", "in_progress", "failed"]>;
export declare class WebSearchStatus extends WebSearchStatus_base {
}
declare const ResponsesWebSearchCallOutput_base: S.Class<ResponsesWebSearchCallOutput, {
    type: typeof ResponsesWebSearchCallOutputType;
    id: typeof S.String;
    status: typeof WebSearchStatus;
}, S.Struct.Encoded<{
    type: typeof ResponsesWebSearchCallOutputType;
    id: typeof S.String;
    status: typeof WebSearchStatus;
}>, never, {
    readonly type: "web_search_call";
} & {
    readonly id: string;
} & {
    readonly status: "in_progress" | "completed" | "searching" | "failed";
}, {}, {}>;
export declare class ResponsesWebSearchCallOutput extends ResponsesWebSearchCallOutput_base {
}
declare const ResponsesOutputItemFileSearchCallType_base: S.Literal<["file_search_call"]>;
export declare class ResponsesOutputItemFileSearchCallType extends ResponsesOutputItemFileSearchCallType_base {
}
declare const ResponsesOutputItemFileSearchCall_base: S.Class<ResponsesOutputItemFileSearchCall, {
    type: typeof ResponsesOutputItemFileSearchCallType;
    id: typeof S.String;
    queries: S.Array$<typeof S.String>;
    status: typeof WebSearchStatus;
}, S.Struct.Encoded<{
    type: typeof ResponsesOutputItemFileSearchCallType;
    id: typeof S.String;
    queries: S.Array$<typeof S.String>;
    status: typeof WebSearchStatus;
}>, never, {
    readonly type: "file_search_call";
} & {
    readonly id: string;
} & {
    readonly status: "in_progress" | "completed" | "searching" | "failed";
} & {
    readonly queries: readonly string[];
}, {}, {}>;
export declare class ResponsesOutputItemFileSearchCall extends ResponsesOutputItemFileSearchCall_base {
}
declare const ResponsesImageGenerationCallType_base: S.Literal<["image_generation_call"]>;
export declare class ResponsesImageGenerationCallType extends ResponsesImageGenerationCallType_base {
}
declare const ImageGenerationStatus_base: S.Literal<["in_progress", "completed", "generating", "failed"]>;
export declare class ImageGenerationStatus extends ImageGenerationStatus_base {
}
declare const ResponsesImageGenerationCall_base: S.Class<ResponsesImageGenerationCall, {
    type: typeof ResponsesImageGenerationCallType;
    id: typeof S.String;
    result: S.optionalWith<S.NullOr<typeof S.String>, {
        default: () => null;
    }>;
    status: typeof ImageGenerationStatus;
}, S.Struct.Encoded<{
    type: typeof ResponsesImageGenerationCallType;
    id: typeof S.String;
    result: S.optionalWith<S.NullOr<typeof S.String>, {
        default: () => null;
    }>;
    status: typeof ImageGenerationStatus;
}>, never, {
    readonly type: "image_generation_call";
} & {
    readonly id: string;
} & {
    readonly status: "in_progress" | "completed" | "failed" | "generating";
} & {
    readonly result?: string | null | undefined;
}, {}, {}>;
export declare class ResponsesImageGenerationCall extends ResponsesImageGenerationCall_base {
}
declare const OpenResponsesInput_base: S.Union<[typeof S.String, S.Array$<S.Union<[typeof OpenResponsesReasoning, typeof OpenResponsesEasyInputMessage, typeof OpenResponsesInputMessageItem, typeof OpenResponsesFunctionToolCall, typeof OpenResponsesFunctionCallOutput, typeof ResponsesOutputMessage, typeof ResponsesOutputItemReasoning, typeof ResponsesOutputItemFunctionCall, typeof ResponsesWebSearchCallOutput, typeof ResponsesOutputItemFileSearchCall, typeof ResponsesImageGenerationCall]>>]>;
/**
 * Input for a response request - can be a string or array of items
 */
export declare class OpenResponsesInput extends OpenResponsesInput_base {
}
declare const OpenResponsesRequestMetadata_base: S.Record$<typeof S.String, typeof S.Unknown>;
/**
 * Metadata key-value pairs for the request. Keys must be ≤64 characters and cannot contain brackets. Values must be ≤512 characters. Maximum 16 pairs allowed.
 */
export declare class OpenResponsesRequestMetadata extends OpenResponsesRequestMetadata_base {
}
declare const OpenResponsesWebSearchPreviewToolType_base: S.Literal<["web_search_preview"]>;
export declare class OpenResponsesWebSearchPreviewToolType extends OpenResponsesWebSearchPreviewToolType_base {
}
declare const ResponsesSearchContextSize_base: S.Literal<["low", "medium", "high"]>;
/**
 * Size of the search context for web search tools
 */
export declare class ResponsesSearchContextSize extends ResponsesSearchContextSize_base {
}
declare const WebSearchPreviewToolUserLocationType_base: S.Literal<["approximate"]>;
export declare class WebSearchPreviewToolUserLocationType extends WebSearchPreviewToolUserLocationType_base {
}
declare const WebSearchPreviewToolUserLocation_base: S.Class<WebSearchPreviewToolUserLocation, {
    type: typeof WebSearchPreviewToolUserLocationType;
    city: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    country: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    region: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    timezone: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    type: typeof WebSearchPreviewToolUserLocationType;
    city: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    country: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    region: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    timezone: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}>, never, {
    readonly type: "approximate";
} & {
    readonly city?: string | undefined;
} & {
    readonly country?: string | undefined;
} & {
    readonly region?: string | undefined;
} & {
    readonly timezone?: string | undefined;
}, {}, {}>;
export declare class WebSearchPreviewToolUserLocation extends WebSearchPreviewToolUserLocation_base {
}
declare const OpenResponsesWebSearchPreviewTool_base: S.Class<OpenResponsesWebSearchPreviewTool, {
    type: typeof OpenResponsesWebSearchPreviewToolType;
    search_context_size: S.optionalWith<typeof ResponsesSearchContextSize, {
        nullable: true;
    }>;
    user_location: S.optionalWith<typeof WebSearchPreviewToolUserLocation, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    type: typeof OpenResponsesWebSearchPreviewToolType;
    search_context_size: S.optionalWith<typeof ResponsesSearchContextSize, {
        nullable: true;
    }>;
    user_location: S.optionalWith<typeof WebSearchPreviewToolUserLocation, {
        nullable: true;
    }>;
}>, never, {
    readonly type: "web_search_preview";
} & {
    readonly search_context_size?: "high" | "low" | "medium" | undefined;
} & {
    readonly user_location?: WebSearchPreviewToolUserLocation | undefined;
}, {}, {}>;
/**
 * Web search preview tool configuration
 */
export declare class OpenResponsesWebSearchPreviewTool extends OpenResponsesWebSearchPreviewTool_base {
}
declare const OpenResponsesWebSearchPreview20250311ToolType_base: S.Literal<["web_search_preview_2025_03_11"]>;
export declare class OpenResponsesWebSearchPreview20250311ToolType extends OpenResponsesWebSearchPreview20250311ToolType_base {
}
declare const OpenResponsesWebSearchPreview20250311Tool_base: S.Class<OpenResponsesWebSearchPreview20250311Tool, {
    type: typeof OpenResponsesWebSearchPreview20250311ToolType;
    search_context_size: S.optionalWith<typeof ResponsesSearchContextSize, {
        nullable: true;
    }>;
    user_location: S.optionalWith<typeof WebSearchPreviewToolUserLocation, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    type: typeof OpenResponsesWebSearchPreview20250311ToolType;
    search_context_size: S.optionalWith<typeof ResponsesSearchContextSize, {
        nullable: true;
    }>;
    user_location: S.optionalWith<typeof WebSearchPreviewToolUserLocation, {
        nullable: true;
    }>;
}>, never, {
    readonly type: "web_search_preview_2025_03_11";
} & {
    readonly search_context_size?: "high" | "low" | "medium" | undefined;
} & {
    readonly user_location?: WebSearchPreviewToolUserLocation | undefined;
}, {}, {}>;
/**
 * Web search preview tool configuration (2025-03-11 version)
 */
export declare class OpenResponsesWebSearchPreview20250311Tool extends OpenResponsesWebSearchPreview20250311Tool_base {
}
declare const OpenResponsesWebSearchToolType_base: S.Literal<["web_search"]>;
export declare class OpenResponsesWebSearchToolType extends OpenResponsesWebSearchToolType_base {
}
declare const ResponsesWebSearchUserLocationType_base: S.Literal<["approximate"]>;
export declare class ResponsesWebSearchUserLocationType extends ResponsesWebSearchUserLocationType_base {
}
declare const ResponsesWebSearchUserLocation_base: S.Class<ResponsesWebSearchUserLocation, {
    type: S.optionalWith<typeof ResponsesWebSearchUserLocationType, {
        nullable: true;
    }>;
    city: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    country: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    region: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    timezone: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    type: S.optionalWith<typeof ResponsesWebSearchUserLocationType, {
        nullable: true;
    }>;
    city: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    country: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    region: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    timezone: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}>, never, {
    readonly type?: "approximate" | undefined;
} & {
    readonly city?: string | undefined;
} & {
    readonly country?: string | undefined;
} & {
    readonly region?: string | undefined;
} & {
    readonly timezone?: string | undefined;
}, {}, {}>;
/**
 * User location information for web search
 */
export declare class ResponsesWebSearchUserLocation extends ResponsesWebSearchUserLocation_base {
}
declare const OpenResponsesWebSearchTool_base: S.Class<OpenResponsesWebSearchTool, {
    type: typeof OpenResponsesWebSearchToolType;
    filters: S.optionalWith<S.Struct<{
        allowed_domains: S.optionalWith<S.Array$<typeof S.String>, {
            nullable: true;
        }>;
    }>, {
        nullable: true;
    }>;
    search_context_size: S.optionalWith<typeof ResponsesSearchContextSize, {
        nullable: true;
    }>;
    user_location: S.optionalWith<typeof ResponsesWebSearchUserLocation, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    type: typeof OpenResponsesWebSearchToolType;
    filters: S.optionalWith<S.Struct<{
        allowed_domains: S.optionalWith<S.Array$<typeof S.String>, {
            nullable: true;
        }>;
    }>, {
        nullable: true;
    }>;
    search_context_size: S.optionalWith<typeof ResponsesSearchContextSize, {
        nullable: true;
    }>;
    user_location: S.optionalWith<typeof ResponsesWebSearchUserLocation, {
        nullable: true;
    }>;
}>, never, {
    readonly type: "web_search";
} & {
    readonly search_context_size?: "high" | "low" | "medium" | undefined;
} & {
    readonly user_location?: ResponsesWebSearchUserLocation | undefined;
} & {
    readonly filters?: {
        readonly allowed_domains?: readonly string[] | undefined;
    } | undefined;
}, {}, {}>;
/**
 * Web search tool configuration
 */
export declare class OpenResponsesWebSearchTool extends OpenResponsesWebSearchTool_base {
}
declare const OpenResponsesWebSearch20250826ToolType_base: S.Literal<["web_search_2025_08_26"]>;
export declare class OpenResponsesWebSearch20250826ToolType extends OpenResponsesWebSearch20250826ToolType_base {
}
declare const OpenResponsesWebSearch20250826Tool_base: S.Class<OpenResponsesWebSearch20250826Tool, {
    type: typeof OpenResponsesWebSearch20250826ToolType;
    filters: S.optionalWith<S.Struct<{
        allowed_domains: S.optionalWith<S.Array$<typeof S.String>, {
            nullable: true;
        }>;
    }>, {
        nullable: true;
    }>;
    search_context_size: S.optionalWith<typeof ResponsesSearchContextSize, {
        nullable: true;
    }>;
    user_location: S.optionalWith<typeof ResponsesWebSearchUserLocation, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    type: typeof OpenResponsesWebSearch20250826ToolType;
    filters: S.optionalWith<S.Struct<{
        allowed_domains: S.optionalWith<S.Array$<typeof S.String>, {
            nullable: true;
        }>;
    }>, {
        nullable: true;
    }>;
    search_context_size: S.optionalWith<typeof ResponsesSearchContextSize, {
        nullable: true;
    }>;
    user_location: S.optionalWith<typeof ResponsesWebSearchUserLocation, {
        nullable: true;
    }>;
}>, never, {
    readonly type: "web_search_2025_08_26";
} & {
    readonly search_context_size?: "high" | "low" | "medium" | undefined;
} & {
    readonly user_location?: ResponsesWebSearchUserLocation | undefined;
} & {
    readonly filters?: {
        readonly allowed_domains?: readonly string[] | undefined;
    } | undefined;
}, {}, {}>;
/**
 * Web search tool configuration (2025-08-26 version)
 */
export declare class OpenResponsesWebSearch20250826Tool extends OpenResponsesWebSearch20250826Tool_base {
}
declare const OpenAIResponsesToolChoiceEnum_base: S.Literal<["required"]>;
export declare class OpenAIResponsesToolChoiceEnum extends OpenAIResponsesToolChoiceEnum_base {
}
declare const OpenAIResponsesToolChoiceEnumType_base: S.Literal<["function"]>;
export declare class OpenAIResponsesToolChoiceEnumType extends OpenAIResponsesToolChoiceEnumType_base {
}
declare const OpenAIResponsesToolChoiceEnumTypeEnum_base: S.Literal<["web_search_preview"]>;
export declare class OpenAIResponsesToolChoiceEnumTypeEnum extends OpenAIResponsesToolChoiceEnumTypeEnum_base {
}
declare const OpenAIResponsesToolChoice_base: S.Union<[typeof OpenAIResponsesToolChoiceEnum, typeof OpenAIResponsesToolChoiceEnum, typeof OpenAIResponsesToolChoiceEnum, S.Struct<{
    type: typeof OpenAIResponsesToolChoiceEnumType;
    name: typeof S.String;
}>, S.Struct<{
    type: S.Union<[typeof OpenAIResponsesToolChoiceEnumTypeEnum, typeof OpenAIResponsesToolChoiceEnumTypeEnum]>;
}>]>;
export declare class OpenAIResponsesToolChoice extends OpenAIResponsesToolChoice_base {
}
declare const ResponsesFormatTextType_base: S.Literal<["text"]>;
export declare class ResponsesFormatTextType extends ResponsesFormatTextType_base {
}
declare const ResponsesFormatText_base: S.Class<ResponsesFormatText, {
    type: typeof ResponsesFormatTextType;
}, S.Struct.Encoded<{
    type: typeof ResponsesFormatTextType;
}>, never, {
    readonly type: "text";
}, {}, {}>;
/**
 * Plain text response format
 */
export declare class ResponsesFormatText extends ResponsesFormatText_base {
}
declare const ResponsesFormatJSONObjectType_base: S.Literal<["json_object"]>;
export declare class ResponsesFormatJSONObjectType extends ResponsesFormatJSONObjectType_base {
}
declare const ResponsesFormatJSONObject_base: S.Class<ResponsesFormatJSONObject, {
    type: typeof ResponsesFormatJSONObjectType;
}, S.Struct.Encoded<{
    type: typeof ResponsesFormatJSONObjectType;
}>, never, {
    readonly type: "json_object";
}, {}, {}>;
/**
 * JSON object response format
 */
export declare class ResponsesFormatJSONObject extends ResponsesFormatJSONObject_base {
}
declare const ResponsesFormatTextJSONSchemaConfigType_base: S.Literal<["json_schema"]>;
export declare class ResponsesFormatTextJSONSchemaConfigType extends ResponsesFormatTextJSONSchemaConfigType_base {
}
declare const ResponsesFormatTextJSONSchemaConfig_base: S.Class<ResponsesFormatTextJSONSchemaConfig, {
    type: typeof ResponsesFormatTextJSONSchemaConfigType;
    name: typeof S.String;
    description: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    strict: S.optionalWith<typeof S.Boolean, {
        nullable: true;
    }>;
    schema: S.Record$<typeof S.String, typeof S.Unknown>;
}, S.Struct.Encoded<{
    type: typeof ResponsesFormatTextJSONSchemaConfigType;
    name: typeof S.String;
    description: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    strict: S.optionalWith<typeof S.Boolean, {
        nullable: true;
    }>;
    schema: S.Record$<typeof S.String, typeof S.Unknown>;
}>, never, {
    readonly type: "json_schema";
} & {
    readonly name: string;
} & {
    readonly description?: string | undefined;
} & {
    readonly strict?: boolean | undefined;
} & {
    readonly schema: {
        readonly [x: string]: unknown;
    };
}, {}, {}>;
/**
 * JSON schema constrained response format
 */
export declare class ResponsesFormatTextJSONSchemaConfig extends ResponsesFormatTextJSONSchemaConfig_base {
}
declare const ResponseFormatTextConfig_base: S.Union<[typeof ResponsesFormatText, typeof ResponsesFormatJSONObject, typeof ResponsesFormatTextJSONSchemaConfig]>;
/**
 * Text response format configuration
 */
export declare class ResponseFormatTextConfig extends ResponseFormatTextConfig_base {
}
declare const OpenResponsesResponseTextVerbosity_base: S.Literal<["high", "low", "medium"]>;
export declare class OpenResponsesResponseTextVerbosity extends OpenResponsesResponseTextVerbosity_base {
}
declare const OpenResponsesResponseText_base: S.Class<OpenResponsesResponseText, {
    format: S.optionalWith<typeof ResponseFormatTextConfig, {
        nullable: true;
    }>;
    verbosity: S.optionalWith<typeof OpenResponsesResponseTextVerbosity, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    format: S.optionalWith<typeof ResponseFormatTextConfig, {
        nullable: true;
    }>;
    verbosity: S.optionalWith<typeof OpenResponsesResponseTextVerbosity, {
        nullable: true;
    }>;
}>, never, {
    readonly format?: ResponsesFormatText | ResponsesFormatJSONObject | ResponsesFormatTextJSONSchemaConfig | undefined;
} & {
    readonly verbosity?: "high" | "low" | "medium" | undefined;
}, {}, {}>;
/**
 * Text output configuration including format and verbosity
 */
export declare class OpenResponsesResponseText extends OpenResponsesResponseText_base {
}
declare const OpenAIResponsesReasoningEffort_base: S.Literal<["xhigh", "high", "medium", "low", "minimal", "none"]>;
export declare class OpenAIResponsesReasoningEffort extends OpenAIResponsesReasoningEffort_base {
}
declare const ReasoningSummaryVerbosity_base: S.Literal<["auto", "concise", "detailed"]>;
export declare class ReasoningSummaryVerbosity extends ReasoningSummaryVerbosity_base {
}
declare const OpenResponsesReasoningConfig_base: S.Class<OpenResponsesReasoningConfig, {
    max_tokens: S.optionalWith<typeof S.Number, {
        nullable: true;
    }>;
    enabled: S.optionalWith<typeof S.Boolean, {
        nullable: true;
    }>;
    effort: S.optionalWith<typeof OpenAIResponsesReasoningEffort, {
        nullable: true;
    }>;
    summary: S.optionalWith<typeof ReasoningSummaryVerbosity, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    max_tokens: S.optionalWith<typeof S.Number, {
        nullable: true;
    }>;
    enabled: S.optionalWith<typeof S.Boolean, {
        nullable: true;
    }>;
    effort: S.optionalWith<typeof OpenAIResponsesReasoningEffort, {
        nullable: true;
    }>;
    summary: S.optionalWith<typeof ReasoningSummaryVerbosity, {
        nullable: true;
    }>;
}>, never, {
    readonly summary?: "auto" | "concise" | "detailed" | undefined;
} & {
    readonly max_tokens?: number | undefined;
} & {
    readonly enabled?: boolean | undefined;
} & {
    readonly effort?: "high" | "low" | "medium" | "xhigh" | "minimal" | "none" | undefined;
}, {}, {}>;
export declare class OpenResponsesReasoningConfig extends OpenResponsesReasoningConfig_base {
}
declare const ResponsesOutputModality_base: S.Literal<["text", "image"]>;
export declare class ResponsesOutputModality extends ResponsesOutputModality_base {
}
declare const OpenAIResponsesPrompt_base: S.Class<OpenAIResponsesPrompt, {
    id: typeof S.String;
    variables: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    id: typeof S.String;
    variables: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
        nullable: true;
    }>;
}>, never, {
    readonly id: string;
} & {
    readonly variables?: {
        readonly [x: string]: unknown;
    } | undefined;
}, {}, {}>;
export declare class OpenAIResponsesPrompt extends OpenAIResponsesPrompt_base {
}
declare const OpenAIResponsesIncludable_base: S.Literal<["file_search_call.results", "message.input_image.image_url", "computer_call_output.output.image_url", "reasoning.encrypted_content", "code_interpreter_call.outputs"]>;
export declare class OpenAIResponsesIncludable extends OpenAIResponsesIncludable_base {
}
declare const OpenResponsesRequestServiceTier_base: S.Literal<["auto"]>;
export declare class OpenResponsesRequestServiceTier extends OpenResponsesRequestServiceTier_base {
}
declare const OpenResponsesRequestTruncationEnum_base: S.Literal<["auto", "disabled"]>;
export declare class OpenResponsesRequestTruncationEnum extends OpenResponsesRequestTruncationEnum_base {
}
export declare class OpenResponsesRequestTruncation extends OpenResponsesRequestTruncationEnum {
}
declare const DataCollection_base: S.Literal<["deny", "allow"]>;
/**
 * Data collection setting. If no available model provider meets the requirement, your request will return an error.
 * - allow: (default) allow providers which store user data non-transiently and may train on it
 *
 * - deny: use only providers which do not collect user data.
 */
export declare class DataCollection extends DataCollection_base {
}
declare const ProviderName_base: S.Literal<["AI21", "AionLabs", "Alibaba", "Amazon Bedrock", "Amazon Nova", "Anthropic", "Arcee AI", "AtlasCloud", "Avian", "Azure", "BaseTen", "BytePlus", "Black Forest Labs", "Cerebras", "Chutes", "Cirrascale", "Clarifai", "Cloudflare", "Cohere", "Crusoe", "DeepInfra", "DeepSeek", "Featherless", "Fireworks", "Friendli", "GMICloud", "Google", "Google AI Studio", "Groq", "Hyperbolic", "Inception", "Inceptron", "InferenceNet", "Infermatic", "Inflection", "Liquid", "Mara", "Mancer 2", "Minimax", "ModelRun", "Mistral", "Modular", "Moonshot AI", "Morph", "NCompass", "Nebius", "NextBit", "Novita", "Nvidia", "OpenAI", "OpenInference", "Parasail", "Perplexity", "Phala", "Relace", "SambaNova", "Seed", "SiliconFlow", "Sourceful", "Stealth", "StreamLake", "Switchpoint", "Together", "Upstage", "Venice", "WandB", "Xiaomi", "xAI", "Z.AI", "FakeProvider"]>;
export declare class ProviderName extends ProviderName_base {
}
declare const Quantization_base: S.Literal<["int4", "int8", "fp4", "fp6", "fp8", "fp16", "bf16", "fp32", "unknown"]>;
export declare class Quantization extends Quantization_base {
}
declare const ProviderSort_base: S.Literal<["price", "throughput", "latency"]>;
export declare class ProviderSort extends ProviderSort_base {
}
declare const ProviderSortConfigPartitionEnum_base: S.Literal<["model", "none"]>;
export declare class ProviderSortConfigPartitionEnum extends ProviderSortConfigPartitionEnum_base {
}
declare const ProviderSortConfig_base: S.Class<ProviderSortConfig, {
    by: S.optionalWith<typeof ProviderSort, {
        nullable: true;
    }>;
    partition: S.optionalWith<typeof ProviderSortConfigPartitionEnum, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    by: S.optionalWith<typeof ProviderSort, {
        nullable: true;
    }>;
    partition: S.optionalWith<typeof ProviderSortConfigPartitionEnum, {
        nullable: true;
    }>;
}>, never, {
    readonly by?: "price" | "throughput" | "latency" | undefined;
} & {
    readonly partition?: "none" | "model" | undefined;
}, {}, {}>;
export declare class ProviderSortConfig extends ProviderSortConfig_base {
}
/**
 * A value in string format that is a large number
 */
export declare class BigNumberUnion extends S.String {
}
declare const PercentileThroughputCutoffs_base: S.Class<PercentileThroughputCutoffs, {
    /**
     * Minimum p50 throughput (tokens/sec)
     */
    p50: S.optionalWith<typeof S.Number, {
        nullable: true;
    }>;
    /**
     * Minimum p75 throughput (tokens/sec)
     */
    p75: S.optionalWith<typeof S.Number, {
        nullable: true;
    }>;
    /**
     * Minimum p90 throughput (tokens/sec)
     */
    p90: S.optionalWith<typeof S.Number, {
        nullable: true;
    }>;
    /**
     * Minimum p99 throughput (tokens/sec)
     */
    p99: S.optionalWith<typeof S.Number, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    /**
     * Minimum p50 throughput (tokens/sec)
     */
    p50: S.optionalWith<typeof S.Number, {
        nullable: true;
    }>;
    /**
     * Minimum p75 throughput (tokens/sec)
     */
    p75: S.optionalWith<typeof S.Number, {
        nullable: true;
    }>;
    /**
     * Minimum p90 throughput (tokens/sec)
     */
    p90: S.optionalWith<typeof S.Number, {
        nullable: true;
    }>;
    /**
     * Minimum p99 throughput (tokens/sec)
     */
    p99: S.optionalWith<typeof S.Number, {
        nullable: true;
    }>;
}>, never, {
    readonly p50?: number | undefined;
} & {
    readonly p75?: number | undefined;
} & {
    readonly p90?: number | undefined;
} & {
    readonly p99?: number | undefined;
}, {}, {}>;
/**
 * Percentile-based throughput cutoffs. All specified cutoffs must be met for an endpoint to be preferred.
 */
export declare class PercentileThroughputCutoffs extends PercentileThroughputCutoffs_base {
}
declare const PreferredMinThroughput_base: S.Union<[typeof S.Number, typeof PercentileThroughputCutoffs]>;
/**
 * Preferred minimum throughput (in tokens per second). Can be a number (applies to p50) or an object with percentile-specific cutoffs. Endpoints below the threshold(s) may still be used, but are deprioritized in routing. When using fallback models, this may cause a fallback model to be used instead of the primary model if it meets the threshold.
 */
export declare class PreferredMinThroughput extends PreferredMinThroughput_base {
}
declare const PercentileLatencyCutoffs_base: S.Class<PercentileLatencyCutoffs, {
    /**
     * Maximum p50 latency (seconds)
     */
    p50: S.optionalWith<typeof S.Number, {
        nullable: true;
    }>;
    /**
     * Maximum p75 latency (seconds)
     */
    p75: S.optionalWith<typeof S.Number, {
        nullable: true;
    }>;
    /**
     * Maximum p90 latency (seconds)
     */
    p90: S.optionalWith<typeof S.Number, {
        nullable: true;
    }>;
    /**
     * Maximum p99 latency (seconds)
     */
    p99: S.optionalWith<typeof S.Number, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    /**
     * Maximum p50 latency (seconds)
     */
    p50: S.optionalWith<typeof S.Number, {
        nullable: true;
    }>;
    /**
     * Maximum p75 latency (seconds)
     */
    p75: S.optionalWith<typeof S.Number, {
        nullable: true;
    }>;
    /**
     * Maximum p90 latency (seconds)
     */
    p90: S.optionalWith<typeof S.Number, {
        nullable: true;
    }>;
    /**
     * Maximum p99 latency (seconds)
     */
    p99: S.optionalWith<typeof S.Number, {
        nullable: true;
    }>;
}>, never, {
    readonly p50?: number | undefined;
} & {
    readonly p75?: number | undefined;
} & {
    readonly p90?: number | undefined;
} & {
    readonly p99?: number | undefined;
}, {}, {}>;
/**
 * Percentile-based latency cutoffs. All specified cutoffs must be met for an endpoint to be preferred.
 */
export declare class PercentileLatencyCutoffs extends PercentileLatencyCutoffs_base {
}
declare const PreferredMaxLatency_base: S.Union<[typeof S.Number, typeof PercentileLatencyCutoffs]>;
/**
 * Preferred maximum latency (in seconds). Can be a number (applies to p50) or an object with percentile-specific cutoffs. Endpoints above the threshold(s) may still be used, but are deprioritized in routing. When using fallback models, this may cause a fallback model to be used instead of the primary model if it meets the threshold.
 */
export declare class PreferredMaxLatency extends PreferredMaxLatency_base {
}
declare const WebSearchEngine_base: S.Literal<["native", "exa"]>;
/**
 * The search engine to use for web search.
 */
export declare class WebSearchEngine extends WebSearchEngine_base {
}
declare const PDFParserEngine_base: S.Literal<["mistral-ocr", "pdf-text", "native"]>;
/**
 * The engine to use for parsing PDF files.
 */
export declare class PDFParserEngine extends PDFParserEngine_base {
}
declare const PDFParserOptions_base: S.Class<PDFParserOptions, {
    engine: S.optionalWith<typeof PDFParserEngine, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    engine: S.optionalWith<typeof PDFParserEngine, {
        nullable: true;
    }>;
}>, never, {
    readonly engine?: "native" | "mistral-ocr" | "pdf-text" | undefined;
}, {}, {}>;
/**
 * Options for PDF parsing.
 */
export declare class PDFParserOptions extends PDFParserOptions_base {
}
declare const OpenResponsesRequestRoute_base: S.Literal<["fallback", "sort"]>;
/**
 * **DEPRECATED** Use providers.sort.partition instead. Backwards-compatible alias for providers.sort.partition. Accepts legacy values: "fallback" (maps to "model"), "sort" (maps to "none").
 */
export declare class OpenResponsesRequestRoute extends OpenResponsesRequestRoute_base {
}
declare const OpenResponsesRequest_base: S.Class<OpenResponsesRequest, {
    input: S.optionalWith<typeof OpenResponsesInput, {
        nullable: true;
    }>;
    instructions: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    metadata: S.optionalWith<typeof OpenResponsesRequestMetadata, {
        nullable: true;
    }>;
    tools: S.optionalWith<S.Array$<S.Union<[S.Struct<{}>, typeof OpenResponsesWebSearchPreviewTool, typeof OpenResponsesWebSearchPreview20250311Tool, typeof OpenResponsesWebSearchTool, typeof OpenResponsesWebSearch20250826Tool]>>, {
        nullable: true;
    }>;
    tool_choice: S.optionalWith<typeof OpenAIResponsesToolChoice, {
        nullable: true;
    }>;
    parallel_tool_calls: S.optionalWith<typeof S.Boolean, {
        nullable: true;
    }>;
    model: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    models: S.optionalWith<S.Array$<typeof S.String>, {
        nullable: true;
    }>;
    text: S.optionalWith<typeof OpenResponsesResponseText, {
        nullable: true;
    }>;
    reasoning: S.optionalWith<typeof OpenResponsesReasoningConfig, {
        nullable: true;
    }>;
    max_output_tokens: S.optionalWith<typeof S.Number, {
        nullable: true;
    }>;
    temperature: S.optionalWith<S.filter<S.filter<typeof S.Number>>, {
        nullable: true;
    }>;
    top_p: S.optionalWith<S.filter<typeof S.Number>, {
        nullable: true;
    }>;
    top_logprobs: S.optionalWith<S.filter<S.filter<typeof S.Int>>, {
        nullable: true;
    }>;
    max_tool_calls: S.optionalWith<typeof S.Int, {
        nullable: true;
    }>;
    presence_penalty: S.optionalWith<S.filter<S.filter<typeof S.Number>>, {
        nullable: true;
    }>;
    frequency_penalty: S.optionalWith<S.filter<S.filter<typeof S.Number>>, {
        nullable: true;
    }>;
    top_k: S.optionalWith<typeof S.Number, {
        nullable: true;
    }>;
    /**
     * Provider-specific image configuration options. Keys and values vary by model/provider. See https://openrouter.ai/docs/features/multimodal/image-generation for more details.
     */
    image_config: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
        nullable: true;
    }>;
    /**
     * Output modalities for the response. Supported values are "text" and "image".
     */
    modalities: S.optionalWith<S.Array$<typeof ResponsesOutputModality>, {
        nullable: true;
    }>;
    prompt_cache_key: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    previous_response_id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    prompt: S.optionalWith<typeof OpenAIResponsesPrompt, {
        nullable: true;
    }>;
    include: S.optionalWith<S.Array$<typeof OpenAIResponsesIncludable>, {
        nullable: true;
    }>;
    background: S.optionalWith<typeof S.Boolean, {
        nullable: true;
    }>;
    safety_identifier: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    store: S.optionalWith<S.Literal<[false]>, {
        nullable: true;
        default: () => false;
    }>;
    service_tier: S.optionalWith<typeof OpenResponsesRequestServiceTier, {
        nullable: true;
        default: () => "auto";
    }>;
    truncation: S.optionalWith<typeof OpenResponsesRequestTruncation, {
        nullable: true;
    }>;
    stream: S.optionalWith<typeof S.Boolean, {
        nullable: true;
        default: () => false;
    }>;
    /**
     * When multiple model providers are available, optionally indicate your routing preference.
     */
    provider: S.optionalWith<S.Struct<{
        /**
         * Whether to allow backup providers to serve requests
         * - true: (default) when the primary provider (or your custom providers in "order") is unavailable, use the next best provider.
         * - false: use only the primary/custom provider, and return the upstream error if it's unavailable.
         */
        allow_fallbacks: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
        /**
         * Whether to filter providers to only those that support the parameters you've provided. If this setting is omitted or set to false, then providers will receive only the parameters they support, and ignore the rest.
         */
        require_parameters: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
        data_collection: S.optionalWith<typeof DataCollection, {
            nullable: true;
        }>;
        /**
         * Whether to restrict routing to only ZDR (Zero Data Retention) endpoints. When true, only endpoints that do not retain prompts will be used.
         */
        zdr: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
        /**
         * Whether to restrict routing to only models that allow text distillation. When true, only models where the author has allowed distillation will be used.
         */
        enforce_distillable_text: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
        /**
         * An ordered list of provider slugs. The router will attempt to use the first provider in the subset of this list that supports your requested model, and fall back to the next if it is unavailable. If no providers are available, the request will fail with an error message.
         */
        order: S.optionalWith<S.Array$<S.Union<[typeof ProviderName, typeof S.String]>>, {
            nullable: true;
        }>;
        /**
         * List of provider slugs to allow. If provided, this list is merged with your account-wide allowed provider settings for this request.
         */
        only: S.optionalWith<S.Array$<S.Union<[typeof ProviderName, typeof S.String]>>, {
            nullable: true;
        }>;
        /**
         * List of provider slugs to ignore. If provided, this list is merged with your account-wide ignored provider settings for this request.
         */
        ignore: S.optionalWith<S.Array$<S.Union<[typeof ProviderName, typeof S.String]>>, {
            nullable: true;
        }>;
        /**
         * A list of quantization levels to filter the provider by.
         */
        quantizations: S.optionalWith<S.Array$<typeof Quantization>, {
            nullable: true;
        }>;
        /**
         * The sorting strategy to use for this request, if "order" is not specified. When set, no load balancing is performed.
         */
        sort: S.optionalWith<S.Union<[typeof ProviderSort, typeof ProviderSortConfig]>, {
            nullable: true;
        }>;
        /**
         * The object specifying the maximum price you want to pay for this request. USD price per million tokens, for prompt and completion.
         */
        max_price: S.optionalWith<S.Struct<{
            prompt: S.optionalWith<typeof BigNumberUnion, {
                nullable: true;
            }>;
            completion: S.optionalWith<typeof BigNumberUnion, {
                nullable: true;
            }>;
            image: S.optionalWith<typeof BigNumberUnion, {
                nullable: true;
            }>;
            audio: S.optionalWith<typeof BigNumberUnion, {
                nullable: true;
            }>;
            request: S.optionalWith<typeof BigNumberUnion, {
                nullable: true;
            }>;
        }>, {
            nullable: true;
        }>;
        preferred_min_throughput: S.optionalWith<typeof PreferredMinThroughput, {
            nullable: true;
        }>;
        preferred_max_latency: S.optionalWith<typeof PreferredMaxLatency, {
            nullable: true;
        }>;
    }>, {
        nullable: true;
    }>;
    /**
     * Plugins you want to enable for this request, including their settings.
     */
    plugins: S.optionalWith<S.Array$<S.Union<[S.Struct<{
        id: S.Literal<["auto-router"]>;
        /**
         * Set to false to disable the auto-router plugin for this request. Defaults to true.
         */
        enabled: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
        /**
         * List of model patterns to filter which models the auto-router can route between. Supports wildcards (e.g., "anthropic/*" matches all Anthropic models). When not specified, uses the default supported models list.
         */
        allowed_models: S.optionalWith<S.Array$<typeof S.String>, {
            nullable: true;
        }>;
    }>, S.Struct<{
        id: S.Literal<["moderation"]>;
    }>, S.Struct<{
        id: S.Literal<["web"]>;
        /**
         * Set to false to disable the web-search plugin for this request. Defaults to true.
         */
        enabled: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
        max_results: S.optionalWith<typeof S.Number, {
            nullable: true;
        }>;
        search_prompt: S.optionalWith<typeof S.String, {
            nullable: true;
        }>;
        engine: S.optionalWith<typeof WebSearchEngine, {
            nullable: true;
        }>;
    }>, S.Struct<{
        id: S.Literal<["file-parser"]>;
        /**
         * Set to false to disable the file-parser plugin for this request. Defaults to true.
         */
        enabled: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
        pdf: S.optionalWith<typeof PDFParserOptions, {
            nullable: true;
        }>;
    }>, S.Struct<{
        id: S.Literal<["response-healing"]>;
        /**
         * Set to false to disable the response-healing plugin for this request. Defaults to true.
         */
        enabled: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
    }>]>>, {
        nullable: true;
    }>;
    /**
     * **DEPRECATED** Use providers.sort.partition instead. Backwards-compatible alias for providers.sort.partition. Accepts legacy values: "fallback" (maps to "model"), "sort" (maps to "none").
     */
    route: S.optionalWith<typeof OpenResponsesRequestRoute, {
        nullable: true;
    }>;
    /**
     * A unique identifier representing your end-user, which helps distinguish between different users of your app. This allows your app to identify specific users in case of abuse reports, preventing your entire app from being affected by the actions of individual users. Maximum of 128 characters.
     */
    user: S.optionalWith<S.filter<typeof S.String>, {
        nullable: true;
    }>;
    /**
     * 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.
     */
    session_id: S.optionalWith<S.filter<typeof S.String>, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    input: S.optionalWith<typeof OpenResponsesInput, {
        nullable: true;
    }>;
    instructions: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    metadata: S.optionalWith<typeof OpenResponsesRequestMetadata, {
        nullable: true;
    }>;
    tools: S.optionalWith<S.Array$<S.Union<[S.Struct<{}>, typeof OpenResponsesWebSearchPreviewTool, typeof OpenResponsesWebSearchPreview20250311Tool, typeof OpenResponsesWebSearchTool, typeof OpenResponsesWebSearch20250826Tool]>>, {
        nullable: true;
    }>;
    tool_choice: S.optionalWith<typeof OpenAIResponsesToolChoice, {
        nullable: true;
    }>;
    parallel_tool_calls: S.optionalWith<typeof S.Boolean, {
        nullable: true;
    }>;
    model: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    models: S.optionalWith<S.Array$<typeof S.String>, {
        nullable: true;
    }>;
    text: S.optionalWith<typeof OpenResponsesResponseText, {
        nullable: true;
    }>;
    reasoning: S.optionalWith<typeof OpenResponsesReasoningConfig, {
        nullable: true;
    }>;
    max_output_tokens: S.optionalWith<typeof S.Number, {
        nullable: true;
    }>;
    temperature: S.optionalWith<S.filter<S.filter<typeof S.Number>>, {
        nullable: true;
    }>;
    top_p: S.optionalWith<S.filter<typeof S.Number>, {
        nullable: true;
    }>;
    top_logprobs: S.optionalWith<S.filter<S.filter<typeof S.Int>>, {
        nullable: true;
    }>;
    max_tool_calls: S.optionalWith<typeof S.Int, {
        nullable: true;
    }>;
    presence_penalty: S.optionalWith<S.filter<S.filter<typeof S.Number>>, {
        nullable: true;
    }>;
    frequency_penalty: S.optionalWith<S.filter<S.filter<typeof S.Number>>, {
        nullable: true;
    }>;
    top_k: S.optionalWith<typeof S.Number, {
        nullable: true;
    }>;
    /**
     * Provider-specific image configuration options. Keys and values vary by model/provider. See https://openrouter.ai/docs/features/multimodal/image-generation for more details.
     */
    image_config: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
        nullable: true;
    }>;
    /**
     * Output modalities for the response. Supported values are "text" and "image".
     */
    modalities: S.optionalWith<S.Array$<typeof ResponsesOutputModality>, {
        nullable: true;
    }>;
    prompt_cache_key: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    previous_response_id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    prompt: S.optionalWith<typeof OpenAIResponsesPrompt, {
        nullable: true;
    }>;
    include: S.optionalWith<S.Array$<typeof OpenAIResponsesIncludable>, {
        nullable: true;
    }>;
    background: S.optionalWith<typeof S.Boolean, {
        nullable: true;
    }>;
    safety_identifier: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    store: S.optionalWith<S.Literal<[false]>, {
        nullable: true;
        default: () => false;
    }>;
    service_tier: S.optionalWith<typeof OpenResponsesRequestServiceTier, {
        nullable: true;
        default: () => "auto";
    }>;
    truncation: S.optionalWith<typeof OpenResponsesRequestTruncation, {
        nullable: true;
    }>;
    stream: S.optionalWith<typeof S.Boolean, {
        nullable: true;
        default: () => false;
    }>;
    /**
     * When multiple model providers are available, optionally indicate your routing preference.
     */
    provider: S.optionalWith<S.Struct<{
        /**
         * Whether to allow backup providers to serve requests
         * - true: (default) when the primary provider (or your custom providers in "order") is unavailable, use the next best provider.
         * - false: use only the primary/custom provider, and return the upstream error if it's unavailable.
         */
        allow_fallbacks: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
        /**
         * Whether to filter providers to only those that support the parameters you've provided. If this setting is omitted or set to false, then providers will receive only the parameters they support, and ignore the rest.
         */
        require_parameters: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
        data_collection: S.optionalWith<typeof DataCollection, {
            nullable: true;
        }>;
        /**
         * Whether to restrict routing to only ZDR (Zero Data Retention) endpoints. When true, only endpoints that do not retain prompts will be used.
         */
        zdr: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
        /**
         * Whether to restrict routing to only models that allow text distillation. When true, only models where the author has allowed distillation will be used.
         */
        enforce_distillable_text: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
        /**
         * An ordered list of provider slugs. The router will attempt to use the first provider in the subset of this list that supports your requested model, and fall back to the next if it is unavailable. If no providers are available, the request will fail with an error message.
         */
        order: S.optionalWith<S.Array$<S.Union<[typeof ProviderName, typeof S.String]>>, {
            nullable: true;
        }>;
        /**
         * List of provider slugs to allow. If provided, this list is merged with your account-wide allowed provider settings for this request.
         */
        only: S.optionalWith<S.Array$<S.Union<[typeof ProviderName, typeof S.String]>>, {
            nullable: true;
        }>;
        /**
         * List of provider slugs to ignore. If provided, this list is merged with your account-wide ignored provider settings for this request.
         */
        ignore: S.optionalWith<S.Array$<S.Union<[typeof ProviderName, typeof S.String]>>, {
            nullable: true;
        }>;
        /**
         * A list of quantization levels to filter the provider by.
         */
        quantizations: S.optionalWith<S.Array$<typeof Quantization>, {
            nullable: true;
        }>;
        /**
         * The sorting strategy to use for this request, if "order" is not specified. When set, no load balancing is performed.
         */
        sort: S.optionalWith<S.Union<[typeof ProviderSort, typeof ProviderSortConfig]>, {
            nullable: true;
        }>;
        /**
         * The object specifying the maximum price you want to pay for this request. USD price per million tokens, for prompt and completion.
         */
        max_price: S.optionalWith<S.Struct<{
            prompt: S.optionalWith<typeof BigNumberUnion, {
                nullable: true;
            }>;
            completion: S.optionalWith<typeof BigNumberUnion, {
                nullable: true;
            }>;
            image: S.optionalWith<typeof BigNumberUnion, {
                nullable: true;
            }>;
            audio: S.optionalWith<typeof BigNumberUnion, {
                nullable: true;
            }>;
            request: S.optionalWith<typeof BigNumberUnion, {
                nullable: true;
            }>;
        }>, {
            nullable: true;
        }>;
        preferred_min_throughput: S.optionalWith<typeof PreferredMinThroughput, {
            nullable: true;
        }>;
        preferred_max_latency: S.optionalWith<typeof PreferredMaxLatency, {
            nullable: true;
        }>;
    }>, {
        nullable: true;
    }>;
    /**
     * Plugins you want to enable for this request, including their settings.
     */
    plugins: S.optionalWith<S.Array$<S.Union<[S.Struct<{
        id: S.Literal<["auto-router"]>;
        /**
         * Set to false to disable the auto-router plugin for this request. Defaults to true.
         */
        enabled: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
        /**
         * List of model patterns to filter which models the auto-router can route between. Supports wildcards (e.g., "anthropic/*" matches all Anthropic models). When not specified, uses the default supported models list.
         */
        allowed_models: S.optionalWith<S.Array$<typeof S.String>, {
            nullable: true;
        }>;
    }>, S.Struct<{
        id: S.Literal<["moderation"]>;
    }>, S.Struct<{
        id: S.Literal<["web"]>;
        /**
         * Set to false to disable the web-search plugin for this request. Defaults to true.
         */
        enabled: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
        max_results: S.optionalWith<typeof S.Number, {
            nullable: true;
        }>;
        search_prompt: S.optionalWith<typeof S.String, {
            nullable: true;
        }>;
        engine: S.optionalWith<typeof WebSearchEngine, {
            nullable: true;
        }>;
    }>, S.Struct<{
        id: S.Literal<["file-parser"]>;
        /**
         * Set to false to disable the file-parser plugin for this request. Defaults to true.
         */
        enabled: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
        pdf: S.optionalWith<typeof PDFParserOptions, {
            nullable: true;
        }>;
    }>, S.Struct<{
        id: S.Literal<["response-healing"]>;
        /**
         * Set to false to disable the response-healing plugin for this request. Defaults to true.
         */
        enabled: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
    }>]>>, {
        nullable: true;
    }>;
    /**
     * **DEPRECATED** Use providers.sort.partition instead. Backwards-compatible alias for providers.sort.partition. Accepts legacy values: "fallback" (maps to "model"), "sort" (maps to "none").
     */
    route: S.optionalWith<typeof OpenResponsesRequestRoute, {
        nullable: true;
    }>;
    /**
     * A unique identifier representing your end-user, which helps distinguish between different users of your app. This allows your app to identify specific users in case of abuse reports, preventing your entire app from being affected by the actions of individual users. Maximum of 128 characters.
     */
    user: S.optionalWith<S.filter<typeof S.String>, {
        nullable: true;
    }>;
    /**
     * 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.
     */
    session_id: S.optionalWith<S.filter<typeof S.String>, {
        nullable: true;
    }>;
}>, never, {
    readonly reasoning?: OpenResponsesReasoningConfig | undefined;
} & {
    readonly text?: OpenResponsesResponseText | undefined;
} & {
    readonly top_logprobs?: number | undefined;
} & {
    readonly model?: string | undefined;
} & {
    readonly input?: string | readonly (OpenResponsesReasoning | OpenResponsesEasyInputMessage | OpenResponsesInputMessageItem | OpenResponsesFunctionToolCall | OpenResponsesFunctionCallOutput | ResponsesOutputMessage | ResponsesOutputItemReasoning | ResponsesOutputItemFunctionCall | ResponsesWebSearchCallOutput | ResponsesOutputItemFileSearchCall | ResponsesImageGenerationCall)[] | undefined;
} & {
    readonly instructions?: string | undefined;
} & {
    readonly metadata?: {
        readonly [x: string]: unknown;
    } | undefined;
} & {
    readonly tools?: readonly (OpenResponsesWebSearchPreviewTool | OpenResponsesWebSearchPreview20250311Tool | OpenResponsesWebSearchTool | OpenResponsesWebSearch20250826Tool | {})[] | undefined;
} & {
    readonly tool_choice?: "required" | {
        readonly type: "function";
        readonly name: string;
    } | {
        readonly type: "web_search_preview";
    } | undefined;
} & {
    readonly parallel_tool_calls?: boolean | undefined;
} & {
    readonly models?: readonly string[] | undefined;
} & {
    readonly max_output_tokens?: number | undefined;
} & {
    readonly temperature?: number | undefined;
} & {
    readonly top_p?: number | undefined;
} & {
    readonly max_tool_calls?: number | undefined;
} & {
    readonly presence_penalty?: number | undefined;
} & {
    readonly frequency_penalty?: number | undefined;
} & {
    readonly top_k?: number | undefined;
} & {
    readonly image_config?: {
        readonly [x: string]: unknown;
    } | undefined;
} & {
    readonly modalities?: readonly ("text" | "image")[] | undefined;
} & {
    readonly prompt_cache_key?: string | undefined;
} & {
    readonly previous_response_id?: string | undefined;
} & {
    readonly prompt?: OpenAIResponsesPrompt | undefined;
} & {
    readonly include?: readonly ("file_search_call.results" | "message.input_image.image_url" | "computer_call_output.output.image_url" | "reasoning.encrypted_content" | "code_interpreter_call.outputs")[] | undefined;
} & {
    readonly background?: boolean | undefined;
} & {
    readonly safety_identifier?: string | undefined;
} & {
    readonly store?: false | undefined;
} & {
    readonly service_tier?: "auto" | undefined;
} & {
    readonly truncation?: "auto" | "disabled" | undefined;
} & {
    readonly stream?: boolean | undefined;
} & {
    readonly provider?: {
        readonly sort?: "price" | "throughput" | "latency" | ProviderSortConfig | undefined;
        readonly allow_fallbacks?: boolean | undefined;
        readonly require_parameters?: boolean | undefined;
        readonly data_collection?: "deny" | "allow" | undefined;
        readonly zdr?: boolean | undefined;
        readonly enforce_distillable_text?: boolean | undefined;
        readonly order?: readonly string[] | undefined;
        readonly only?: readonly string[] | undefined;
        readonly ignore?: readonly string[] | undefined;
        readonly quantizations?: readonly ("unknown" | "int4" | "int8" | "fp4" | "fp6" | "fp8" | "fp16" | "bf16" | "fp32")[] | undefined;
        readonly max_price?: {
            readonly image?: string | undefined;
            readonly prompt?: string | undefined;
            readonly completion?: string | undefined;
            readonly audio?: string | undefined;
            readonly request?: string | undefined;
        } | undefined;
        readonly preferred_min_throughput?: number | PercentileThroughputCutoffs | undefined;
        readonly preferred_max_latency?: number | PercentileLatencyCutoffs | undefined;
    } | undefined;
} & {
    readonly plugins?: readonly ({
        readonly id: "auto-router";
        readonly enabled?: boolean | undefined;
        readonly allowed_models?: readonly string[] | undefined;
    } | {
        readonly id: "moderation";
    } | {
        readonly id: "web";
        readonly enabled?: boolean | undefined;
        readonly engine?: "native" | "exa" | undefined;
        readonly max_results?: number | undefined;
        readonly search_prompt?: string | undefined;
    } | {
        readonly id: "file-parser";
        readonly enabled?: boolean | undefined;
        readonly pdf?: PDFParserOptions | undefined;
    } | {
        readonly id: "response-healing";
        readonly enabled?: boolean | undefined;
    })[] | undefined;
} & {
    readonly route?: "sort" | "fallback" | undefined;
} & {
    readonly user?: string | undefined;
} & {
    readonly session_id?: string | undefined;
}, {}, {}>;
/**
 * Request schema for Responses endpoint
 */
export declare class OpenResponsesRequest extends OpenResponsesRequest_base {
}
declare const OutputMessageRole_base: S.Literal<["assistant"]>;
export declare class OutputMessageRole extends OutputMessageRole_base {
}
declare const OutputMessageType_base: S.Literal<["message"]>;
export declare class OutputMessageType extends OutputMessageType_base {
}
declare const OutputMessageStatusEnum_base: S.Literal<["in_progress"]>;
export declare class OutputMessageStatusEnum extends OutputMessageStatusEnum_base {
}
declare const OutputMessage_base: S.Class<OutputMessage, {
    id: typeof S.String;
    role: typeof OutputMessageRole;
    type: typeof OutputMessageType;
    status: S.optionalWith<S.Union<[typeof OutputMessageStatusEnum, typeof OutputMessageStatusEnum, typeof OutputMessageStatusEnum]>, {
        nullable: true;
    }>;
    content: S.Array$<S.Union<[typeof ResponseOutputText, typeof OpenAIResponsesRefusalContent]>>;
}, S.Struct.Encoded<{
    id: typeof S.String;
    role: typeof OutputMessageRole;
    type: typeof OutputMessageType;
    status: S.optionalWith<S.Union<[typeof OutputMessageStatusEnum, typeof OutputMessageStatusEnum, typeof OutputMessageStatusEnum]>, {
        nullable: true;
    }>;
    content: S.Array$<S.Union<[typeof ResponseOutputText, typeof OpenAIResponsesRefusalContent]>>;
}>, never, {
    readonly type: "message";
} & {
    readonly id: string;
} & {
    readonly content: readonly (ResponseOutputText | OpenAIResponsesRefusalContent)[];
} & {
    readonly status?: "in_progress" | undefined;
} & {
    readonly role: "assistant";
}, {}, {}>;
export declare class OutputMessage extends OutputMessage_base {
}
declare const OutputItemReasoningType_base: S.Literal<["reasoning"]>;
export declare class OutputItemReasoningType extends OutputItemReasoningType_base {
}
declare const OutputItemReasoningStatusEnum_base: S.Literal<["in_progress"]>;
export declare class OutputItemReasoningStatusEnum extends OutputItemReasoningStatusEnum_base {
}
declare const OutputItemReasoning_base: S.Class<OutputItemReasoning, {
    type: typeof OutputItemReasoningType;
    id: typeof S.String;
    content: S.optionalWith<S.Array$<typeof ReasoningTextContent>, {
        nullable: true;
    }>;
    summary: S.Array$<typeof ReasoningSummaryText>;
    encrypted_content: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    status: S.optionalWith<S.Union<[typeof OutputItemReasoningStatusEnum, typeof OutputItemReasoningStatusEnum, typeof OutputItemReasoningStatusEnum]>, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    type: typeof OutputItemReasoningType;
    id: typeof S.String;
    content: S.optionalWith<S.Array$<typeof ReasoningTextContent>, {
        nullable: true;
    }>;
    summary: S.Array$<typeof ReasoningSummaryText>;
    encrypted_content: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    status: S.optionalWith<S.Union<[typeof OutputItemReasoningStatusEnum, typeof OutputItemReasoningStatusEnum, typeof OutputItemReasoningStatusEnum]>, {
        nullable: true;
    }>;
}>, never, {
    readonly type: "reasoning";
} & {
    readonly id: string;
} & {
    readonly content?: readonly ReasoningTextContent[] | undefined;
} & {
    readonly summary: readonly ReasoningSummaryText[];
} & {
    readonly encrypted_content?: string | undefined;
} & {
    readonly status?: "in_progress" | undefined;
}, {}, {}>;
export declare class OutputItemReasoning extends OutputItemReasoning_base {
}
declare const OutputItemFunctionCallType_base: S.Literal<["function_call"]>;
export declare class OutputItemFunctionCallType extends OutputItemFunctionCallType_base {
}
declare const OutputItemFunctionCallStatusEnum_base: S.Literal<["in_progress"]>;
export declare class OutputItemFunctionCallStatusEnum extends OutputItemFunctionCallStatusEnum_base {
}
declare const OutputItemFunctionCall_base: S.Class<OutputItemFunctionCall, {
    type: typeof OutputItemFunctionCallType;
    id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    name: typeof S.String;
    arguments: typeof S.String;
    call_id: typeof S.String;
    status: S.optionalWith<S.Union<[typeof OutputItemFunctionCallStatusEnum, typeof OutputItemFunctionCallStatusEnum, typeof OutputItemFunctionCallStatusEnum]>, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    type: typeof OutputItemFunctionCallType;
    id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    name: typeof S.String;
    arguments: typeof S.String;
    call_id: typeof S.String;
    status: S.optionalWith<S.Union<[typeof OutputItemFunctionCallStatusEnum, typeof OutputItemFunctionCallStatusEnum, typeof OutputItemFunctionCallStatusEnum]>, {
        nullable: true;
    }>;
}>, never, {
    readonly type: "function_call";
} & {
    readonly id?: string | undefined;
} & {
    readonly status?: "in_progress" | undefined;
} & {
    readonly name: string;
} & {
    readonly call_id: string;
} & {
    readonly arguments: string;
}, {}, {}>;
export declare class OutputItemFunctionCall extends OutputItemFunctionCall_base {
}
declare const OutputItemWebSearchCallType_base: S.Literal<["web_search_call"]>;
export declare class OutputItemWebSearchCallType extends OutputItemWebSearchCallType_base {
}
declare const OutputItemWebSearchCall_base: S.Class<OutputItemWebSearchCall, {
    type: typeof OutputItemWebSearchCallType;
    id: typeof S.String;
    status: typeof WebSearchStatus;
}, S.Struct.Encoded<{
    type: typeof OutputItemWebSearchCallType;
    id: typeof S.String;
    status: typeof WebSearchStatus;
}>, never, {
    readonly type: "web_search_call";
} & {
    readonly id: string;
} & {
    readonly status: "in_progress" | "completed" | "searching" | "failed";
}, {}, {}>;
export declare class OutputItemWebSearchCall extends OutputItemWebSearchCall_base {
}
declare const OutputItemFileSearchCallType_base: S.Literal<["file_search_call"]>;
export declare class OutputItemFileSearchCallType extends OutputItemFileSearchCallType_base {
}
declare const OutputItemFileSearchCall_base: S.Class<OutputItemFileSearchCall, {
    type: typeof OutputItemFileSearchCallType;
    id: typeof S.String;
    queries: S.Array$<typeof S.String>;
    status: typeof WebSearchStatus;
}, S.Struct.Encoded<{
    type: typeof OutputItemFileSearchCallType;
    id: typeof S.String;
    queries: S.Array$<typeof S.String>;
    status: typeof WebSearchStatus;
}>, never, {
    readonly type: "file_search_call";
} & {
    readonly id: string;
} & {
    readonly status: "in_progress" | "completed" | "searching" | "failed";
} & {
    readonly queries: readonly string[];
}, {}, {}>;
export declare class OutputItemFileSearchCall extends OutputItemFileSearchCall_base {
}
declare const OutputItemImageGenerationCallType_base: S.Literal<["image_generation_call"]>;
export declare class OutputItemImageGenerationCallType extends OutputItemImageGenerationCallType_base {
}
declare const OutputItemImageGenerationCall_base: S.Class<OutputItemImageGenerationCall, {
    type: typeof OutputItemImageGenerationCallType;
    id: typeof S.String;
    result: S.optionalWith<S.NullOr<typeof S.String>, {
        default: () => null;
    }>;
    status: typeof ImageGenerationStatus;
}, S.Struct.Encoded<{
    type: typeof OutputItemImageGenerationCallType;
    id: typeof S.String;
    result: S.optionalWith<S.NullOr<typeof S.String>, {
        default: () => null;
    }>;
    status: typeof ImageGenerationStatus;
}>, never, {
    readonly type: "image_generation_call";
} & {
    readonly id: string;
} & {
    readonly status: "in_progress" | "completed" | "failed" | "generating";
} & {
    readonly result?: string | null | undefined;
}, {}, {}>;
export declare class OutputItemImageGenerationCall extends OutputItemImageGenerationCall_base {
}
declare const OpenAIResponsesUsage_base: S.Class<OpenAIResponsesUsage, {
    input_tokens: typeof S.Number;
    input_tokens_details: S.Struct<{
        cached_tokens: typeof S.Number;
    }>;
    output_tokens: typeof S.Number;
    output_tokens_details: S.Struct<{
        reasoning_tokens: typeof S.Number;
    }>;
    total_tokens: typeof S.Number;
}, S.Struct.Encoded<{
    input_tokens: typeof S.Number;
    input_tokens_details: S.Struct<{
        cached_tokens: typeof S.Number;
    }>;
    output_tokens: typeof S.Number;
    output_tokens_details: S.Struct<{
        reasoning_tokens: typeof S.Number;
    }>;
    total_tokens: typeof S.Number;
}>, never, {
    readonly input_tokens: number;
} & {
    readonly output_tokens: number;
} & {
    readonly total_tokens: number;
} & {
    readonly input_tokens_details: {
        readonly cached_tokens: number;
    };
} & {
    readonly output_tokens_details: {
        readonly reasoning_tokens: number;
    };
}, {}, {}>;
export declare class OpenAIResponsesUsage extends OpenAIResponsesUsage_base {
}
declare const OpenResponsesNonStreamingResponseObject_base: S.Literal<["response"]>;
export declare class OpenResponsesNonStreamingResponseObject extends OpenResponsesNonStreamingResponseObject_base {
}
declare const OpenAIResponsesResponseStatus_base: S.Literal<["completed", "incomplete", "in_progress", "failed", "cancelled", "queued"]>;
export declare class OpenAIResponsesResponseStatus extends OpenAIResponsesResponseStatus_base {
}
declare const ResponsesErrorFieldCode_base: S.Literal<["server_error", "rate_limit_exceeded", "invalid_prompt", "vector_store_timeout", "invalid_image", "invalid_image_format", "invalid_base64_image", "invalid_image_url", "image_too_large", "image_too_small", "image_parse_error", "image_content_policy_violation", "invalid_image_mode", "image_file_too_large", "unsupported_image_media_type", "empty_image_file", "failed_to_download_image", "image_file_not_found"]>;
export declare class ResponsesErrorFieldCode extends ResponsesErrorFieldCode_base {
}
declare const ResponsesErrorField_base: S.Class<ResponsesErrorField, {
    code: typeof ResponsesErrorFieldCode;
    message: typeof S.String;
}, S.Struct.Encoded<{
    code: typeof ResponsesErrorFieldCode;
    message: typeof S.String;
}>, never, {
    readonly message: string;
} & {
    readonly code: "server_error" | "rate_limit_exceeded" | "invalid_prompt" | "vector_store_timeout" | "invalid_image" | "invalid_image_format" | "invalid_base64_image" | "invalid_image_url" | "image_too_large" | "image_too_small" | "image_parse_error" | "image_content_policy_violation" | "invalid_image_mode" | "image_file_too_large" | "unsupported_image_media_type" | "empty_image_file" | "failed_to_download_image" | "image_file_not_found";
}, {}, {}>;
/**
 * Error information returned from the API
 */
export declare class ResponsesErrorField extends ResponsesErrorField_base {
}
declare const OpenAIResponsesIncompleteDetailsReason_base: S.Literal<["max_output_tokens", "content_filter"]>;
export declare class OpenAIResponsesIncompleteDetailsReason extends OpenAIResponsesIncompleteDetailsReason_base {
}
declare const OpenAIResponsesIncompleteDetails_base: S.Class<OpenAIResponsesIncompleteDetails, {
    reason: S.optionalWith<typeof OpenAIResponsesIncompleteDetailsReason, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    reason: S.optionalWith<typeof OpenAIResponsesIncompleteDetailsReason, {
        nullable: true;
    }>;
}>, never, {
    readonly reason?: "max_output_tokens" | "content_filter" | undefined;
}, {}, {}>;
export declare class OpenAIResponsesIncompleteDetails extends OpenAIResponsesIncompleteDetails_base {
}
declare const ResponseInputImageType_base: S.Literal<["input_image"]>;
export declare class ResponseInputImageType extends ResponseInputImageType_base {
}
declare const ResponseInputImageDetail_base: S.Literal<["auto", "high", "low"]>;
export declare class ResponseInputImageDetail extends ResponseInputImageDetail_base {
}
declare const ResponseInputImage_base: S.Class<ResponseInputImage, {
    type: typeof ResponseInputImageType;
    detail: typeof ResponseInputImageDetail;
    image_url: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    type: typeof ResponseInputImageType;
    detail: typeof ResponseInputImageDetail;
    image_url: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}>, never, {
    readonly type: "input_image";
} & {
    readonly image_url?: string | undefined;
} & {
    readonly detail: "auto" | "high" | "low";
}, {}, {}>;
/**
 * Image input content item
 */
export declare class ResponseInputImage extends ResponseInputImage_base {
}
declare const OpenAIResponsesInput_base: S.Union<[typeof S.String, S.Array$<S.Union<[S.Struct<{
    type: S.optionalWith<S.Literal<["message"]>, {
        nullable: true;
    }>;
    role: S.Union<[S.Literal<["user"]>, S.Literal<["system"]>, S.Literal<["assistant"]>, S.Literal<["developer"]>]>;
    content: S.Union<[S.Array$<S.Union<[typeof ResponseInputText, typeof ResponseInputImage, typeof ResponseInputFile, typeof ResponseInputAudio]>>, typeof S.String]>;
}>, S.Struct<{
    id: typeof S.String;
    type: S.optionalWith<S.Literal<["message"]>, {
        nullable: true;
    }>;
    role: S.Union<[S.Literal<["user"]>, S.Literal<["system"]>, S.Literal<["developer"]>]>;
    content: S.Array$<S.Union<[typeof ResponseInputText, typeof ResponseInputImage, typeof ResponseInputFile, typeof ResponseInputAudio]>>;
}>, S.Struct<{
    type: S.Literal<["function_call_output"]>;
    id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    call_id: typeof S.String;
    output: typeof S.String;
    status: S.optionalWith<typeof ToolCallStatus, {
        nullable: true;
    }>;
}>, S.Struct<{
    type: S.Literal<["function_call"]>;
    call_id: typeof S.String;
    name: typeof S.String;
    arguments: typeof S.String;
    id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    status: S.optionalWith<typeof ToolCallStatus, {
        nullable: true;
    }>;
}>, typeof OutputItemImageGenerationCall, typeof OutputMessage]>>]>;
export declare class OpenAIResponsesInput extends OpenAIResponsesInput_base {
}
declare const OpenAIResponsesReasoningConfig_base: S.Class<OpenAIResponsesReasoningConfig, {
    effort: S.optionalWith<typeof OpenAIResponsesReasoningEffort, {
        nullable: true;
    }>;
    summary: S.optionalWith<typeof ReasoningSummaryVerbosity, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    effort: S.optionalWith<typeof OpenAIResponsesReasoningEffort, {
        nullable: true;
    }>;
    summary: S.optionalWith<typeof ReasoningSummaryVerbosity, {
        nullable: true;
    }>;
}>, never, {
    readonly summary?: "auto" | "concise" | "detailed" | undefined;
} & {
    readonly effort?: "high" | "low" | "medium" | "xhigh" | "minimal" | "none" | undefined;
}, {}, {}>;
export declare class OpenAIResponsesReasoningConfig extends OpenAIResponsesReasoningConfig_base {
}
declare const OpenAIResponsesServiceTier_base: S.Literal<["auto", "default", "flex", "priority", "scale"]>;
export declare class OpenAIResponsesServiceTier extends OpenAIResponsesServiceTier_base {
}
declare const OpenAIResponsesTruncation_base: S.Literal<["auto", "disabled"]>;
export declare class OpenAIResponsesTruncation extends OpenAIResponsesTruncation_base {
}
declare const ResponseTextConfigVerbosity_base: S.Literal<["high", "low", "medium"]>;
export declare class ResponseTextConfigVerbosity extends ResponseTextConfigVerbosity_base {
}
declare const ResponseTextConfig_base: S.Class<ResponseTextConfig, {
    format: S.optionalWith<typeof ResponseFormatTextConfig, {
        nullable: true;
    }>;
    verbosity: S.optionalWith<typeof ResponseTextConfigVerbosity, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    format: S.optionalWith<typeof ResponseFormatTextConfig, {
        nullable: true;
    }>;
    verbosity: S.optionalWith<typeof ResponseTextConfigVerbosity, {
        nullable: true;
    }>;
}>, never, {
    readonly format?: ResponsesFormatText | ResponsesFormatJSONObject | ResponsesFormatTextJSONSchemaConfig | undefined;
} & {
    readonly verbosity?: "high" | "low" | "medium" | undefined;
}, {}, {}>;
/**
 * Text output configuration including format and verbosity
 */
export declare class ResponseTextConfig extends ResponseTextConfig_base {
}
declare const OpenResponsesNonStreamingResponse_base: S.Class<OpenResponsesNonStreamingResponse, {
    output: S.Array$<S.Union<[typeof OutputMessage, typeof OutputItemReasoning, typeof OutputItemFunctionCall, typeof OutputItemWebSearchCall, typeof OutputItemFileSearchCall, typeof OutputItemImageGenerationCall]>>;
    usage: S.optionalWith<typeof OpenAIResponsesUsage, {
        nullable: true;
    }>;
    id: typeof S.String;
    object: typeof OpenResponsesNonStreamingResponseObject;
    created_at: typeof S.Number;
    model: typeof S.String;
    status: typeof OpenAIResponsesResponseStatus;
    completed_at: S.NullOr<typeof S.Number>;
    user: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    output_text: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    prompt_cache_key: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    safety_identifier: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    error: S.NullOr<typeof ResponsesErrorField>;
    incomplete_details: S.NullOr<typeof OpenAIResponsesIncompleteDetails>;
    max_tool_calls: S.optionalWith<typeof S.Number, {
        nullable: true;
    }>;
    top_logprobs: S.optionalWith<typeof S.Number, {
        nullable: true;
    }>;
    max_output_tokens: S.optionalWith<typeof S.Number, {
        nullable: true;
    }>;
    temperature: S.NullOr<typeof S.Number>;
    top_p: S.NullOr<typeof S.Number>;
    presence_penalty: S.NullOr<typeof S.Number>;
    frequency_penalty: S.NullOr<typeof S.Number>;
    instructions: typeof OpenAIResponsesInput;
    metadata: S.NullOr<typeof OpenResponsesRequestMetadata>;
    tools: S.Array$<S.Union<[S.Struct<{}>, typeof OpenResponsesWebSearchPreviewTool, typeof OpenResponsesWebSearchPreview20250311Tool, typeof OpenResponsesWebSearchTool, typeof OpenResponsesWebSearch20250826Tool]>>;
    tool_choice: typeof OpenAIResponsesToolChoice;
    parallel_tool_calls: typeof S.Boolean;
    prompt: S.optionalWith<typeof OpenAIResponsesPrompt, {
        nullable: true;
    }>;
    background: S.optionalWith<typeof S.Boolean, {
        nullable: true;
    }>;
    previous_response_id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    reasoning: S.optionalWith<typeof OpenAIResponsesReasoningConfig, {
        nullable: true;
    }>;
    service_tier: S.optionalWith<typeof OpenAIResponsesServiceTier, {
        nullable: true;
    }>;
    store: S.optionalWith<typeof S.Boolean, {
        nullable: true;
    }>;
    truncation: S.optionalWith<typeof OpenAIResponsesTruncation, {
        nullable: true;
    }>;
    text: S.optionalWith<typeof ResponseTextConfig, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    output: S.Array$<S.Union<[typeof OutputMessage, typeof OutputItemReasoning, typeof OutputItemFunctionCall, typeof OutputItemWebSearchCall, typeof OutputItemFileSearchCall, typeof OutputItemImageGenerationCall]>>;
    usage: S.optionalWith<typeof OpenAIResponsesUsage, {
        nullable: true;
    }>;
    id: typeof S.String;
    object: typeof OpenResponsesNonStreamingResponseObject;
    created_at: typeof S.Number;
    model: typeof S.String;
    status: typeof OpenAIResponsesResponseStatus;
    completed_at: S.NullOr<typeof S.Number>;
    user: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    output_text: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    prompt_cache_key: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    safety_identifier: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    error: S.NullOr<typeof ResponsesErrorField>;
    incomplete_details: S.NullOr<typeof OpenAIResponsesIncompleteDetails>;
    max_tool_calls: S.optionalWith<typeof S.Number, {
        nullable: true;
    }>;
    top_logprobs: S.optionalWith<typeof S.Number, {
        nullable: true;
    }>;
    max_output_tokens: S.optionalWith<typeof S.Number, {
        nullable: true;
    }>;
    temperature: S.NullOr<typeof S.Number>;
    top_p: S.NullOr<typeof S.Number>;
    presence_penalty: S.NullOr<typeof S.Number>;
    frequency_penalty: S.NullOr<typeof S.Number>;
    instructions: typeof OpenAIResponsesInput;
    metadata: S.NullOr<typeof OpenResponsesRequestMetadata>;
    tools: S.Array$<S.Union<[S.Struct<{}>, typeof OpenResponsesWebSearchPreviewTool, typeof OpenResponsesWebSearchPreview20250311Tool, typeof OpenResponsesWebSearchTool, typeof OpenResponsesWebSearch20250826Tool]>>;
    tool_choice: typeof OpenAIResponsesToolChoice;
    parallel_tool_calls: typeof S.Boolean;
    prompt: S.optionalWith<typeof OpenAIResponsesPrompt, {
        nullable: true;
    }>;
    background: S.optionalWith<typeof S.Boolean, {
        nullable: true;
    }>;
    previous_response_id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    reasoning: S.optionalWith<typeof OpenAIResponsesReasoningConfig, {
        nullable: true;
    }>;
    service_tier: S.optionalWith<typeof OpenAIResponsesServiceTier, {
        nullable: true;
    }>;
    store: S.optionalWith<typeof S.Boolean, {
        nullable: true;
    }>;
    truncation: S.optionalWith<typeof OpenAIResponsesTruncation, {
        nullable: true;
    }>;
    text: S.optionalWith<typeof ResponseTextConfig, {
        nullable: true;
    }>;
}>, never, {
    readonly object: "response";
} & {
    readonly reasoning?: OpenAIResponsesReasoningConfig | undefined;
} & {
    readonly text?: ResponseTextConfig | undefined;
} & {
    readonly id: string;
} & {
    readonly status: "in_progress" | "completed" | "incomplete" | "failed" | "cancelled" | "queued";
} & {
    readonly output: readonly (OutputMessage | OutputItemReasoning | OutputItemFunctionCall | OutputItemWebSearchCall | OutputItemFileSearchCall | OutputItemImageGenerationCall)[];
} & {
    readonly output_text?: string | undefined;
} & {
    readonly top_logprobs?: number | undefined;
} & {
    readonly model: string;
} & {
    readonly instructions: string | readonly (OutputMessage | OutputItemImageGenerationCall | {
        readonly type?: "message" | undefined;
        readonly content: string | readonly (ResponseInputText | ResponseInputFile | ResponseInputAudio | ResponseInputImage)[];
        readonly role: "developer" | "assistant" | "user" | "system";
    } | {
        readonly type?: "message" | undefined;
        readonly id: string;
        readonly content: readonly (ResponseInputText | ResponseInputFile | ResponseInputAudio | ResponseInputImage)[];
        readonly role: "developer" | "user" | "system";
    } | {
        readonly type: "function_call_output";
        readonly id?: string | undefined;
        readonly status?: "in_progress" | "completed" | "incomplete" | undefined;
        readonly call_id: string;
        readonly output: string;
    } | {
        readonly type: "function_call";
        readonly id?: string | undefined;
        readonly status?: "in_progress" | "completed" | "incomplete" | undefined;
        readonly name: string;
        readonly call_id: string;
        readonly arguments: string;
    })[];
} & {
    readonly metadata: {
        readonly [x: string]: unknown;
    } | null;
} & {
    readonly tools: readonly (OpenResponsesWebSearchPreviewTool | OpenResponsesWebSearchPreview20250311Tool | OpenResponsesWebSearchTool | OpenResponsesWebSearch20250826Tool | {})[];
} & {
    readonly tool_choice: "required" | {
        readonly type: "function";
        readonly name: string;
    } | {
        readonly type: "web_search_preview";
    };
} & {
    readonly parallel_tool_calls: boolean;
} & {
    readonly max_output_tokens?: number | undefined;
} & {
    readonly temperature: number | null;
} & {
    readonly top_p: number | null;
} & {
    readonly max_tool_calls?: number | undefined;
} & {
    readonly presence_penalty: number | null;
} & {
    readonly frequency_penalty: number | null;
} & {
    readonly prompt_cache_key?: string | undefined;
} & {
    readonly previous_response_id?: string | undefined;
} & {
    readonly prompt?: OpenAIResponsesPrompt | undefined;
} & {
    readonly background?: boolean | undefined;
} & {
    readonly safety_identifier?: string | undefined;
} & {
    readonly store?: boolean | undefined;
} & {
    readonly service_tier?: "default" | "auto" | "flex" | "priority" | "scale" | undefined;
} & {
    readonly truncation?: "auto" | "disabled" | undefined;
} & {
    readonly user?: string | undefined;
} & {
    readonly created_at: number;
} & {
    readonly usage?: OpenAIResponsesUsage | undefined;
} & {
    readonly completed_at: number | null;
} & {
    readonly error: ResponsesErrorField | null;
} & {
    readonly incomplete_details: OpenAIResponsesIncompleteDetails | null;
}, {}, {}>;
export declare class OpenResponsesNonStreamingResponse extends OpenResponsesNonStreamingResponse_base {
}
declare const BadRequestResponseErrorData_base: S.Class<BadRequestResponseErrorData, {
    code: typeof S.Int;
    message: typeof S.String;
    metadata: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    code: typeof S.Int;
    message: typeof S.String;
    metadata: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
        nullable: true;
    }>;
}>, never, {
    readonly message: string;
} & {
    readonly metadata?: {
        readonly [x: string]: unknown;
    } | undefined;
} & {
    readonly code: number;
}, {}, {}>;
/**
 * Error data for BadRequestResponse
 */
export declare class BadRequestResponseErrorData extends BadRequestResponseErrorData_base {
}
declare const BadRequestResponse_base: S.Class<BadRequestResponse, {
    error: typeof BadRequestResponseErrorData;
    user_id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    error: typeof BadRequestResponseErrorData;
    user_id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}>, never, {
    readonly error: BadRequestResponseErrorData;
} & {
    readonly user_id?: string | undefined;
}, {}, {}>;
/**
 * Bad Request - Invalid request parameters or malformed input
 */
export declare class BadRequestResponse extends BadRequestResponse_base {
}
declare const UnauthorizedResponseErrorData_base: S.Class<UnauthorizedResponseErrorData, {
    code: typeof S.Int;
    message: typeof S.String;
    metadata: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    code: typeof S.Int;
    message: typeof S.String;
    metadata: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
        nullable: true;
    }>;
}>, never, {
    readonly message: string;
} & {
    readonly metadata?: {
        readonly [x: string]: unknown;
    } | undefined;
} & {
    readonly code: number;
}, {}, {}>;
/**
 * Error data for UnauthorizedResponse
 */
export declare class UnauthorizedResponseErrorData extends UnauthorizedResponseErrorData_base {
}
declare const UnauthorizedResponse_base: S.Class<UnauthorizedResponse, {
    error: typeof UnauthorizedResponseErrorData;
    user_id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    error: typeof UnauthorizedResponseErrorData;
    user_id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}>, never, {
    readonly error: UnauthorizedResponseErrorData;
} & {
    readonly user_id?: string | undefined;
}, {}, {}>;
/**
 * Unauthorized - Authentication required or invalid credentials
 */
export declare class UnauthorizedResponse extends UnauthorizedResponse_base {
}
declare const PaymentRequiredResponseErrorData_base: S.Class<PaymentRequiredResponseErrorData, {
    code: typeof S.Int;
    message: typeof S.String;
    metadata: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    code: typeof S.Int;
    message: typeof S.String;
    metadata: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
        nullable: true;
    }>;
}>, never, {
    readonly message: string;
} & {
    readonly metadata?: {
        readonly [x: string]: unknown;
    } | undefined;
} & {
    readonly code: number;
}, {}, {}>;
/**
 * Error data for PaymentRequiredResponse
 */
export declare class PaymentRequiredResponseErrorData extends PaymentRequiredResponseErrorData_base {
}
declare const PaymentRequiredResponse_base: S.Class<PaymentRequiredResponse, {
    error: typeof PaymentRequiredResponseErrorData;
    user_id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    error: typeof PaymentRequiredResponseErrorData;
    user_id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}>, never, {
    readonly error: PaymentRequiredResponseErrorData;
} & {
    readonly user_id?: string | undefined;
}, {}, {}>;
/**
 * Payment Required - Insufficient credits or quota to complete request
 */
export declare class PaymentRequiredResponse extends PaymentRequiredResponse_base {
}
declare const NotFoundResponseErrorData_base: S.Class<NotFoundResponseErrorData, {
    code: typeof S.Int;
    message: typeof S.String;
    metadata: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    code: typeof S.Int;
    message: typeof S.String;
    metadata: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
        nullable: true;
    }>;
}>, never, {
    readonly message: string;
} & {
    readonly metadata?: {
        readonly [x: string]: unknown;
    } | undefined;
} & {
    readonly code: number;
}, {}, {}>;
/**
 * Error data for NotFoundResponse
 */
export declare class NotFoundResponseErrorData extends NotFoundResponseErrorData_base {
}
declare const NotFoundResponse_base: S.Class<NotFoundResponse, {
    error: typeof NotFoundResponseErrorData;
    user_id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    error: typeof NotFoundResponseErrorData;
    user_id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}>, never, {
    readonly error: NotFoundResponseErrorData;
} & {
    readonly user_id?: string | undefined;
}, {}, {}>;
/**
 * Not Found - Resource does not exist
 */
export declare class NotFoundResponse extends NotFoundResponse_base {
}
declare const RequestTimeoutResponseErrorData_base: S.Class<RequestTimeoutResponseErrorData, {
    code: typeof S.Int;
    message: typeof S.String;
    metadata: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    code: typeof S.Int;
    message: typeof S.String;
    metadata: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
        nullable: true;
    }>;
}>, never, {
    readonly message: string;
} & {
    readonly metadata?: {
        readonly [x: string]: unknown;
    } | undefined;
} & {
    readonly code: number;
}, {}, {}>;
/**
 * Error data for RequestTimeoutResponse
 */
export declare class RequestTimeoutResponseErrorData extends RequestTimeoutResponseErrorData_base {
}
declare const RequestTimeoutResponse_base: S.Class<RequestTimeoutResponse, {
    error: typeof RequestTimeoutResponseErrorData;
    user_id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    error: typeof RequestTimeoutResponseErrorData;
    user_id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}>, never, {
    readonly error: RequestTimeoutResponseErrorData;
} & {
    readonly user_id?: string | undefined;
}, {}, {}>;
/**
 * Request Timeout - Operation exceeded time limit
 */
export declare class RequestTimeoutResponse extends RequestTimeoutResponse_base {
}
declare const PayloadTooLargeResponseErrorData_base: S.Class<PayloadTooLargeResponseErrorData, {
    code: typeof S.Int;
    message: typeof S.String;
    metadata: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    code: typeof S.Int;
    message: typeof S.String;
    metadata: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
        nullable: true;
    }>;
}>, never, {
    readonly message: string;
} & {
    readonly metadata?: {
        readonly [x: string]: unknown;
    } | undefined;
} & {
    readonly code: number;
}, {}, {}>;
/**
 * Error data for PayloadTooLargeResponse
 */
export declare class PayloadTooLargeResponseErrorData extends PayloadTooLargeResponseErrorData_base {
}
declare const PayloadTooLargeResponse_base: S.Class<PayloadTooLargeResponse, {
    error: typeof PayloadTooLargeResponseErrorData;
    user_id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    error: typeof PayloadTooLargeResponseErrorData;
    user_id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}>, never, {
    readonly error: PayloadTooLargeResponseErrorData;
} & {
    readonly user_id?: string | undefined;
}, {}, {}>;
/**
 * Payload Too Large - Request payload exceeds size limits
 */
export declare class PayloadTooLargeResponse extends PayloadTooLargeResponse_base {
}
declare const UnprocessableEntityResponseErrorData_base: S.Class<UnprocessableEntityResponseErrorData, {
    code: typeof S.Int;
    message: typeof S.String;
    metadata: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    code: typeof S.Int;
    message: typeof S.String;
    metadata: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
        nullable: true;
    }>;
}>, never, {
    readonly message: string;
} & {
    readonly metadata?: {
        readonly [x: string]: unknown;
    } | undefined;
} & {
    readonly code: number;
}, {}, {}>;
/**
 * Error data for UnprocessableEntityResponse
 */
export declare class UnprocessableEntityResponseErrorData extends UnprocessableEntityResponseErrorData_base {
}
declare const UnprocessableEntityResponse_base: S.Class<UnprocessableEntityResponse, {
    error: typeof UnprocessableEntityResponseErrorData;
    user_id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    error: typeof UnprocessableEntityResponseErrorData;
    user_id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}>, never, {
    readonly error: UnprocessableEntityResponseErrorData;
} & {
    readonly user_id?: string | undefined;
}, {}, {}>;
/**
 * Unprocessable Entity - Semantic validation failure
 */
export declare class UnprocessableEntityResponse extends UnprocessableEntityResponse_base {
}
declare const TooManyRequestsResponseErrorData_base: S.Class<TooManyRequestsResponseErrorData, {
    code: typeof S.Int;
    message: typeof S.String;
    metadata: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    code: typeof S.Int;
    message: typeof S.String;
    metadata: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
        nullable: true;
    }>;
}>, never, {
    readonly message: string;
} & {
    readonly metadata?: {
        readonly [x: string]: unknown;
    } | undefined;
} & {
    readonly code: number;
}, {}, {}>;
/**
 * Error data for TooManyRequestsResponse
 */
export declare class TooManyRequestsResponseErrorData extends TooManyRequestsResponseErrorData_base {
}
declare const TooManyRequestsResponse_base: S.Class<TooManyRequestsResponse, {
    error: typeof TooManyRequestsResponseErrorData;
    user_id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    error: typeof TooManyRequestsResponseErrorData;
    user_id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}>, never, {
    readonly error: TooManyRequestsResponseErrorData;
} & {
    readonly user_id?: string | undefined;
}, {}, {}>;
/**
 * Too Many Requests - Rate limit exceeded
 */
export declare class TooManyRequestsResponse extends TooManyRequestsResponse_base {
}
declare const InternalServerResponseErrorData_base: S.Class<InternalServerResponseErrorData, {
    code: typeof S.Int;
    message: typeof S.String;
    metadata: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    code: typeof S.Int;
    message: typeof S.String;
    metadata: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
        nullable: true;
    }>;
}>, never, {
    readonly message: string;
} & {
    readonly metadata?: {
        readonly [x: string]: unknown;
    } | undefined;
} & {
    readonly code: number;
}, {}, {}>;
/**
 * Error data for InternalServerResponse
 */
export declare class InternalServerResponseErrorData extends InternalServerResponseErrorData_base {
}
declare const InternalServerResponse_base: S.Class<InternalServerResponse, {
    error: typeof InternalServerResponseErrorData;
    user_id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    error: typeof InternalServerResponseErrorData;
    user_id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}>, never, {
    readonly error: InternalServerResponseErrorData;
} & {
    readonly user_id?: string | undefined;
}, {}, {}>;
/**
 * Internal Server Error - Unexpected server error
 */
export declare class InternalServerResponse extends InternalServerResponse_base {
}
declare const BadGatewayResponseErrorData_base: S.Class<BadGatewayResponseErrorData, {
    code: typeof S.Int;
    message: typeof S.String;
    metadata: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    code: typeof S.Int;
    message: typeof S.String;
    metadata: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
        nullable: true;
    }>;
}>, never, {
    readonly message: string;
} & {
    readonly metadata?: {
        readonly [x: string]: unknown;
    } | undefined;
} & {
    readonly code: number;
}, {}, {}>;
/**
 * Error data for BadGatewayResponse
 */
export declare class BadGatewayResponseErrorData extends BadGatewayResponseErrorData_base {
}
declare const BadGatewayResponse_base: S.Class<BadGatewayResponse, {
    error: typeof BadGatewayResponseErrorData;
    user_id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    error: typeof BadGatewayResponseErrorData;
    user_id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}>, never, {
    readonly error: BadGatewayResponseErrorData;
} & {
    readonly user_id?: string | undefined;
}, {}, {}>;
/**
 * Bad Gateway - Provider/upstream API failure
 */
export declare class BadGatewayResponse extends BadGatewayResponse_base {
}
declare const ServiceUnavailableResponseErrorData_base: S.Class<ServiceUnavailableResponseErrorData, {
    code: typeof S.Int;
    message: typeof S.String;
    metadata: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    code: typeof S.Int;
    message: typeof S.String;
    metadata: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
        nullable: true;
    }>;
}>, never, {
    readonly message: string;
} & {
    readonly metadata?: {
        readonly [x: string]: unknown;
    } | undefined;
} & {
    readonly code: number;
}, {}, {}>;
/**
 * Error data for ServiceUnavailableResponse
 */
export declare class ServiceUnavailableResponseErrorData extends ServiceUnavailableResponseErrorData_base {
}
declare const ServiceUnavailableResponse_base: S.Class<ServiceUnavailableResponse, {
    error: typeof ServiceUnavailableResponseErrorData;
    user_id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    error: typeof ServiceUnavailableResponseErrorData;
    user_id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}>, never, {
    readonly error: ServiceUnavailableResponseErrorData;
} & {
    readonly user_id?: string | undefined;
}, {}, {}>;
/**
 * Service Unavailable - Service temporarily unavailable
 */
export declare class ServiceUnavailableResponse extends ServiceUnavailableResponse_base {
}
declare const EdgeNetworkTimeoutResponseErrorData_base: S.Class<EdgeNetworkTimeoutResponseErrorData, {
    code: typeof S.Int;
    message: typeof S.String;
    metadata: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    code: typeof S.Int;
    message: typeof S.String;
    metadata: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
        nullable: true;
    }>;
}>, never, {
    readonly message: string;
} & {
    readonly metadata?: {
        readonly [x: string]: unknown;
    } | undefined;
} & {
    readonly code: number;
}, {}, {}>;
/**
 * Error data for EdgeNetworkTimeoutResponse
 */
export declare class EdgeNetworkTimeoutResponseErrorData extends EdgeNetworkTimeoutResponseErrorData_base {
}
declare const EdgeNetworkTimeoutResponse_base: S.Class<EdgeNetworkTimeoutResponse, {
    error: typeof EdgeNetworkTimeoutResponseErrorData;
    user_id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    error: typeof EdgeNetworkTimeoutResponseErrorData;
    user_id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}>, never, {
    readonly error: EdgeNetworkTimeoutResponseErrorData;
} & {
    readonly user_id?: string | undefined;
}, {}, {}>;
/**
 * Infrastructure Timeout - Provider request timed out at edge network
 */
export declare class EdgeNetworkTimeoutResponse extends EdgeNetworkTimeoutResponse_base {
}
declare const ProviderOverloadedResponseErrorData_base: S.Class<ProviderOverloadedResponseErrorData, {
    code: typeof S.Int;
    message: typeof S.String;
    metadata: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    code: typeof S.Int;
    message: typeof S.String;
    metadata: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
        nullable: true;
    }>;
}>, never, {
    readonly message: string;
} & {
    readonly metadata?: {
        readonly [x: string]: unknown;
    } | undefined;
} & {
    readonly code: number;
}, {}, {}>;
/**
 * Error data for ProviderOverloadedResponse
 */
export declare class ProviderOverloadedResponseErrorData extends ProviderOverloadedResponseErrorData_base {
}
declare const ProviderOverloadedResponse_base: S.Class<ProviderOverloadedResponse, {
    error: typeof ProviderOverloadedResponseErrorData;
    user_id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    error: typeof ProviderOverloadedResponseErrorData;
    user_id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}>, never, {
    readonly error: ProviderOverloadedResponseErrorData;
} & {
    readonly user_id?: string | undefined;
}, {}, {}>;
/**
 * Provider Overloaded - Provider is temporarily overloaded
 */
export declare class ProviderOverloadedResponse extends ProviderOverloadedResponse_base {
}
declare const OpenRouterAnthropicMessageParamRole_base: S.Literal<["user", "assistant"]>;
export declare class OpenRouterAnthropicMessageParamRole extends OpenRouterAnthropicMessageParamRole_base {
}
declare const OpenRouterAnthropicMessageParam_base: S.Class<OpenRouterAnthropicMessageParam, {
    role: typeof OpenRouterAnthropicMessageParamRole;
    content: S.Union<[typeof S.String, S.Array$<S.Union<[S.Struct<{
        type: S.Literal<["text"]>;
        text: typeof S.String;
        citations: S.optionalWith<S.Array$<S.Union<[S.Struct<{
            type: S.Literal<["char_location"]>;
            cited_text: typeof S.String;
            document_index: typeof S.Number;
            document_title: S.NullOr<typeof S.String>;
            start_char_index: typeof S.Number;
            end_char_index: typeof S.Number;
        }>, S.Struct<{
            type: S.Literal<["page_location"]>;
            cited_text: typeof S.String;
            document_index: typeof S.Number;
            document_title: S.NullOr<typeof S.String>;
            start_page_number: typeof S.Number;
            end_page_number: typeof S.Number;
        }>, S.Struct<{
            type: S.Literal<["content_block_location"]>;
            cited_text: typeof S.String;
            document_index: typeof S.Number;
            document_title: S.NullOr<typeof S.String>;
            start_block_index: typeof S.Number;
            end_block_index: typeof S.Number;
        }>, S.Struct<{
            type: S.Literal<["web_search_result_location"]>;
            cited_text: typeof S.String;
            encrypted_index: typeof S.String;
            title: S.NullOr<typeof S.String>;
            url: typeof S.String;
        }>, S.Struct<{
            type: S.Literal<["search_result_location"]>;
            cited_text: typeof S.String;
            search_result_index: typeof S.Number;
            source: typeof S.String;
            title: S.NullOr<typeof S.String>;
            start_block_index: typeof S.Number;
            end_block_index: typeof S.Number;
        }>]>>, {
            nullable: true;
        }>;
        cache_control: S.optionalWith<S.Struct<{
            type: S.Literal<["ephemeral"]>;
            ttl: S.optionalWith<S.Literal<["5m", "1h"]>, {
                nullable: true;
            }>;
        }>, {
            nullable: true;
        }>;
    }>, S.Struct<{
        type: S.Literal<["image"]>;
        source: S.Union<[S.Struct<{
            type: S.Literal<["base64"]>;
            media_type: S.Literal<["image/jpeg", "image/png", "image/gif", "image/webp"]>;
            data: typeof S.String;
        }>, S.Struct<{
            type: S.Literal<["url"]>;
            url: typeof S.String;
        }>]>;
        cache_control: S.optionalWith<S.Struct<{
            type: S.Literal<["ephemeral"]>;
            ttl: S.optionalWith<S.Literal<["5m", "1h"]>, {
                nullable: true;
            }>;
        }>, {
            nullable: true;
        }>;
    }>, S.Struct<{
        type: S.Literal<["document"]>;
        source: S.Union<[S.Struct<{
            type: S.Literal<["base64"]>;
            media_type: S.Literal<["application/pdf"]>;
            data: typeof S.String;
        }>, S.Struct<{
            type: S.Literal<["text"]>;
            media_type: S.Literal<["text/plain"]>;
            data: typeof S.String;
        }>, S.Struct<{
            type: S.Literal<["content"]>;
            content: S.Union<[typeof S.String, S.Array$<S.Union<[S.Struct<{
                type: S.Literal<["text"]>;
                text: typeof S.String;
                citations: S.optionalWith<S.Array$<S.Union<[S.Struct<{
                    type: S.Literal<["char_location"]>;
                    cited_text: typeof S.String;
                    document_index: typeof S.Number;
                    document_title: S.NullOr<typeof S.String>;
                    start_char_index: typeof S.Number;
                    end_char_index: typeof S.Number;
                }>, S.Struct<{
                    type: S.Literal<["page_location"]>;
                    cited_text: typeof S.String;
                    document_index: typeof S.Number;
                    document_title: S.NullOr<typeof S.String>;
                    start_page_number: typeof S.Number;
                    end_page_number: typeof S.Number;
                }>, S.Struct<{
                    type: S.Literal<["content_block_location"]>;
                    cited_text: typeof S.String;
                    document_index: typeof S.Number;
                    document_title: S.NullOr<typeof S.String>;
                    start_block_index: typeof S.Number;
                    end_block_index: typeof S.Number;
                }>, S.Struct<{
                    type: S.Literal<["web_search_result_location"]>;
                    cited_text: typeof S.String;
                    encrypted_index: typeof S.String;
                    title: S.NullOr<typeof S.String>;
                    url: typeof S.String;
                }>, S.Struct<{
                    type: S.Literal<["search_result_location"]>;
                    cited_text: typeof S.String;
                    search_result_index: typeof S.Number;
                    source: typeof S.String;
                    title: S.NullOr<typeof S.String>;
                    start_block_index: typeof S.Number;
                    end_block_index: typeof S.Number;
                }>]>>, {
                    nullable: true;
                }>;
                cache_control: S.optionalWith<S.Struct<{
                    type: S.Literal<["ephemeral"]>;
                    ttl: S.optionalWith<S.Literal<["5m", "1h"]>, {
                        nullable: true;
                    }>;
                }>, {
                    nullable: true;
                }>;
            }>, S.Struct<{
                type: S.Literal<["image"]>;
                source: S.Union<[S.Struct<{
                    type: S.Literal<["base64"]>;
                    media_type: S.Literal<["image/jpeg", "image/png", "image/gif", "image/webp"]>;
                    data: typeof S.String;
                }>, S.Struct<{
                    type: S.Literal<["url"]>;
                    url: typeof S.String;
                }>]>;
                cache_control: S.optionalWith<S.Struct<{
                    type: S.Literal<["ephemeral"]>;
                    ttl: S.optionalWith<S.Literal<["5m", "1h"]>, {
                        nullable: true;
                    }>;
                }>, {
                    nullable: true;
                }>;
            }>]>>]>;
        }>, S.Struct<{
            type: S.Literal<["url"]>;
            url: typeof S.String;
        }>]>;
        citations: S.optionalWith<S.Struct<{
            enabled: S.optionalWith<typeof S.Boolean, {
                nullable: true;
            }>;
        }>, {
            nullable: true;
        }>;
        context: S.optionalWith<typeof S.String, {
            nullable: true;
        }>;
        title: S.optionalWith<typeof S.String, {
            nullable: true;
        }>;
        cache_control: S.optionalWith<S.Struct<{
            type: S.Literal<["ephemeral"]>;
            ttl: S.optionalWith<S.Literal<["5m", "1h"]>, {
                nullable: true;
            }>;
        }>, {
            nullable: true;
        }>;
    }>, S.Struct<{
        type: S.Literal<["tool_use"]>;
        id: typeof S.String;
        name: typeof S.String;
        cache_control: S.optionalWith<S.Struct<{
            type: S.Literal<["ephemeral"]>;
            ttl: S.optionalWith<S.Literal<["5m", "1h"]>, {
                nullable: true;
            }>;
        }>, {
            nullable: true;
        }>;
    }>, S.Struct<{
        type: S.Literal<["tool_result"]>;
        tool_use_id: typeof S.String;
        content: S.optionalWith<S.Union<[typeof S.String, S.Array$<S.Union<[S.Struct<{
            type: S.Literal<["text"]>;
            text: typeof S.String;
            citations: S.optionalWith<S.Array$<S.Union<[S.Struct<{
                type: S.Literal<["char_location"]>;
                cited_text: typeof S.String;
                document_index: typeof S.Number;
                document_title: S.NullOr<typeof S.String>;
                start_char_index: typeof S.Number;
                end_char_index: typeof S.Number;
            }>, S.Struct<{
                type: S.Literal<["page_location"]>;
                cited_text: typeof S.String;
                document_index: typeof S.Number;
                document_title: S.NullOr<typeof S.String>;
                start_page_number: typeof S.Number;
                end_page_number: typeof S.Number;
            }>, S.Struct<{
                type: S.Literal<["content_block_location"]>;
                cited_text: typeof S.String;
                document_index: typeof S.Number;
                document_title: S.NullOr<typeof S.String>;
                start_block_index: typeof S.Number;
                end_block_index: typeof S.Number;
            }>, S.Struct<{
                type: S.Literal<["web_search_result_location"]>;
                cited_text: typeof S.String;
                encrypted_index: typeof S.String;
                title: S.NullOr<typeof S.String>;
                url: typeof S.String;
            }>, S.Struct<{
                type: S.Literal<["search_result_location"]>;
                cited_text: typeof S.String;
                search_result_index: typeof S.Number;
                source: typeof S.String;
                title: S.NullOr<typeof S.String>;
                start_block_index: typeof S.Number;
                end_block_index: typeof S.Number;
            }>]>>, {
                nullable: true;
            }>;
            cache_control: S.optionalWith<S.Struct<{
                type: S.Literal<["ephemeral"]>;
                ttl: S.optionalWith<S.Literal<["5m", "1h"]>, {
                    nullable: true;
                }>;
            }>, {
                nullable: true;
            }>;
        }>, S.Struct<{
            type: S.Literal<["image"]>;
            source: S.Union<[S.Struct<{
                type: S.Literal<["base64"]>;
                media_type: S.Literal<["image/jpeg", "image/png", "image/gif", "image/webp"]>;
                data: typeof S.String;
            }>, S.Struct<{
                type: S.Literal<["url"]>;
                url: typeof S.String;
            }>]>;
            cache_control: S.optionalWith<S.Struct<{
                type: S.Literal<["ephemeral"]>;
                ttl: S.optionalWith<S.Literal<["5m", "1h"]>, {
                    nullable: true;
                }>;
            }>, {
                nullable: true;
            }>;
        }>]>>]>, {
            nullable: true;
        }>;
        is_error: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
        cache_control: S.optionalWith<S.Struct<{
            type: S.Literal<["ephemeral"]>;
            ttl: S.optionalWith<S.Literal<["5m", "1h"]>, {
                nullable: true;
            }>;
        }>, {
            nullable: true;
        }>;
    }>, S.Struct<{
        type: S.Literal<["thinking"]>;
        thinking: typeof S.String;
        signature: typeof S.String;
    }>, S.Struct<{
        type: S.Literal<["redacted_thinking"]>;
        data: typeof S.String;
    }>, S.Struct<{
        type: S.Literal<["server_tool_use"]>;
        id: typeof S.String;
        name: S.Literal<["web_search"]>;
        cache_control: S.optionalWith<S.Struct<{
            type: S.Literal<["ephemeral"]>;
            ttl: S.optionalWith<S.Literal<["5m", "1h"]>, {
                nullable: true;
            }>;
        }>, {
            nullable: true;
        }>;
    }>, S.Struct<{
        type: S.Literal<["web_search_tool_result"]>;
        tool_use_id: typeof S.String;
        content: S.Union<[S.Array$<S.Struct<{
            type: S.Literal<["web_search_result"]>;
            encrypted_content: typeof S.String;
            title: typeof S.String;
            url: typeof S.String;
            page_age: S.optionalWith<typeof S.String, {
                nullable: true;
            }>;
        }>>, S.Struct<{
            type: S.Literal<["web_search_tool_result_error"]>;
            error_code: S.Literal<["invalid_tool_input", "unavailable", "max_uses_exceeded", "too_many_requests", "query_too_long"]>;
        }>]>;
        cache_control: S.optionalWith<S.Struct<{
            type: S.Literal<["ephemeral"]>;
            ttl: S.optionalWith<S.Literal<["5m", "1h"]>, {
                nullable: true;
            }>;
        }>, {
            nullable: true;
        }>;
    }>, S.Struct<{
        type: S.Literal<["search_result"]>;
        source: typeof S.String;
        title: typeof S.String;
        content: S.Array$<S.Struct<{
            type: S.Literal<["text"]>;
            text: typeof S.String;
            citations: S.optionalWith<S.Array$<S.Union<[S.Struct<{
                type: S.Literal<["char_location"]>;
                cited_text: typeof S.String;
                document_index: typeof S.Number;
                document_title: S.NullOr<typeof S.String>;
                start_char_index: typeof S.Number;
                end_char_index: typeof S.Number;
            }>, S.Struct<{
                type: S.Literal<["page_location"]>;
                cited_text: typeof S.String;
                document_index: typeof S.Number;
                document_title: S.NullOr<typeof S.String>;
                start_page_number: typeof S.Number;
                end_page_number: typeof S.Number;
            }>, S.Struct<{
                type: S.Literal<["content_block_location"]>;
                cited_text: typeof S.String;
                document_index: typeof S.Number;
                document_title: S.NullOr<typeof S.String>;
                start_block_index: typeof S.Number;
                end_block_index: typeof S.Number;
            }>, S.Struct<{
                type: S.Literal<["web_search_result_location"]>;
                cited_text: typeof S.String;
                encrypted_index: typeof S.String;
                title: S.NullOr<typeof S.String>;
                url: typeof S.String;
            }>, S.Struct<{
                type: S.Literal<["search_result_location"]>;
                cited_text: typeof S.String;
                search_result_index: typeof S.Number;
                source: typeof S.String;
                title: S.NullOr<typeof S.String>;
                start_block_index: typeof S.Number;
                end_block_index: typeof S.Number;
            }>]>>, {
                nullable: true;
            }>;
            cache_control: S.optionalWith<S.Struct<{
                type: S.Literal<["ephemeral"]>;
                ttl: S.optionalWith<S.Literal<["5m", "1h"]>, {
                    nullable: true;
                }>;
            }>, {
                nullable: true;
            }>;
        }>>;
        citations: S.optionalWith<S.Struct<{
            enabled: S.optionalWith<typeof S.Boolean, {
                nullable: true;
            }>;
        }>, {
            nullable: true;
        }>;
        cache_control: S.optionalWith<S.Struct<{
            type: S.Literal<["ephemeral"]>;
            ttl: S.optionalWith<S.Literal<["5m", "1h"]>, {
                nullable: true;
            }>;
        }>, {
            nullable: true;
        }>;
    }>]>>]>;
}, S.Struct.Encoded<{
    role: typeof OpenRouterAnthropicMessageParamRole;
    content: S.Union<[typeof S.String, S.Array$<S.Union<[S.Struct<{
        type: S.Literal<["text"]>;
        text: typeof S.String;
        citations: S.optionalWith<S.Array$<S.Union<[S.Struct<{
            type: S.Literal<["char_location"]>;
            cited_text: typeof S.String;
            document_index: typeof S.Number;
            document_title: S.NullOr<typeof S.String>;
            start_char_index: typeof S.Number;
            end_char_index: typeof S.Number;
        }>, S.Struct<{
            type: S.Literal<["page_location"]>;
            cited_text: typeof S.String;
            document_index: typeof S.Number;
            document_title: S.NullOr<typeof S.String>;
            start_page_number: typeof S.Number;
            end_page_number: typeof S.Number;
        }>, S.Struct<{
            type: S.Literal<["content_block_location"]>;
            cited_text: typeof S.String;
            document_index: typeof S.Number;
            document_title: S.NullOr<typeof S.String>;
            start_block_index: typeof S.Number;
            end_block_index: typeof S.Number;
        }>, S.Struct<{
            type: S.Literal<["web_search_result_location"]>;
            cited_text: typeof S.String;
            encrypted_index: typeof S.String;
            title: S.NullOr<typeof S.String>;
            url: typeof S.String;
        }>, S.Struct<{
            type: S.Literal<["search_result_location"]>;
            cited_text: typeof S.String;
            search_result_index: typeof S.Number;
            source: typeof S.String;
            title: S.NullOr<typeof S.String>;
            start_block_index: typeof S.Number;
            end_block_index: typeof S.Number;
        }>]>>, {
            nullable: true;
        }>;
        cache_control: S.optionalWith<S.Struct<{
            type: S.Literal<["ephemeral"]>;
            ttl: S.optionalWith<S.Literal<["5m", "1h"]>, {
                nullable: true;
            }>;
        }>, {
            nullable: true;
        }>;
    }>, S.Struct<{
        type: S.Literal<["image"]>;
        source: S.Union<[S.Struct<{
            type: S.Literal<["base64"]>;
            media_type: S.Literal<["image/jpeg", "image/png", "image/gif", "image/webp"]>;
            data: typeof S.String;
        }>, S.Struct<{
            type: S.Literal<["url"]>;
            url: typeof S.String;
        }>]>;
        cache_control: S.optionalWith<S.Struct<{
            type: S.Literal<["ephemeral"]>;
            ttl: S.optionalWith<S.Literal<["5m", "1h"]>, {
                nullable: true;
            }>;
        }>, {
            nullable: true;
        }>;
    }>, S.Struct<{
        type: S.Literal<["document"]>;
        source: S.Union<[S.Struct<{
            type: S.Literal<["base64"]>;
            media_type: S.Literal<["application/pdf"]>;
            data: typeof S.String;
        }>, S.Struct<{
            type: S.Literal<["text"]>;
            media_type: S.Literal<["text/plain"]>;
            data: typeof S.String;
        }>, S.Struct<{
            type: S.Literal<["content"]>;
            content: S.Union<[typeof S.String, S.Array$<S.Union<[S.Struct<{
                type: S.Literal<["text"]>;
                text: typeof S.String;
                citations: S.optionalWith<S.Array$<S.Union<[S.Struct<{
                    type: S.Literal<["char_location"]>;
                    cited_text: typeof S.String;
                    document_index: typeof S.Number;
                    document_title: S.NullOr<typeof S.String>;
                    start_char_index: typeof S.Number;
                    end_char_index: typeof S.Number;
                }>, S.Struct<{
                    type: S.Literal<["page_location"]>;
                    cited_text: typeof S.String;
                    document_index: typeof S.Number;
                    document_title: S.NullOr<typeof S.String>;
                    start_page_number: typeof S.Number;
                    end_page_number: typeof S.Number;
                }>, S.Struct<{
                    type: S.Literal<["content_block_location"]>;
                    cited_text: typeof S.String;
                    document_index: typeof S.Number;
                    document_title: S.NullOr<typeof S.String>;
                    start_block_index: typeof S.Number;
                    end_block_index: typeof S.Number;
                }>, S.Struct<{
                    type: S.Literal<["web_search_result_location"]>;
                    cited_text: typeof S.String;
                    encrypted_index: typeof S.String;
                    title: S.NullOr<typeof S.String>;
                    url: typeof S.String;
                }>, S.Struct<{
                    type: S.Literal<["search_result_location"]>;
                    cited_text: typeof S.String;
                    search_result_index: typeof S.Number;
                    source: typeof S.String;
                    title: S.NullOr<typeof S.String>;
                    start_block_index: typeof S.Number;
                    end_block_index: typeof S.Number;
                }>]>>, {
                    nullable: true;
                }>;
                cache_control: S.optionalWith<S.Struct<{
                    type: S.Literal<["ephemeral"]>;
                    ttl: S.optionalWith<S.Literal<["5m", "1h"]>, {
                        nullable: true;
                    }>;
                }>, {
                    nullable: true;
                }>;
            }>, S.Struct<{
                type: S.Literal<["image"]>;
                source: S.Union<[S.Struct<{
                    type: S.Literal<["base64"]>;
                    media_type: S.Literal<["image/jpeg", "image/png", "image/gif", "image/webp"]>;
                    data: typeof S.String;
                }>, S.Struct<{
                    type: S.Literal<["url"]>;
                    url: typeof S.String;
                }>]>;
                cache_control: S.optionalWith<S.Struct<{
                    type: S.Literal<["ephemeral"]>;
                    ttl: S.optionalWith<S.Literal<["5m", "1h"]>, {
                        nullable: true;
                    }>;
                }>, {
                    nullable: true;
                }>;
            }>]>>]>;
        }>, S.Struct<{
            type: S.Literal<["url"]>;
            url: typeof S.String;
        }>]>;
        citations: S.optionalWith<S.Struct<{
            enabled: S.optionalWith<typeof S.Boolean, {
                nullable: true;
            }>;
        }>, {
            nullable: true;
        }>;
        context: S.optionalWith<typeof S.String, {
            nullable: true;
        }>;
        title: S.optionalWith<typeof S.String, {
            nullable: true;
        }>;
        cache_control: S.optionalWith<S.Struct<{
            type: S.Literal<["ephemeral"]>;
            ttl: S.optionalWith<S.Literal<["5m", "1h"]>, {
                nullable: true;
            }>;
        }>, {
            nullable: true;
        }>;
    }>, S.Struct<{
        type: S.Literal<["tool_use"]>;
        id: typeof S.String;
        name: typeof S.String;
        cache_control: S.optionalWith<S.Struct<{
            type: S.Literal<["ephemeral"]>;
            ttl: S.optionalWith<S.Literal<["5m", "1h"]>, {
                nullable: true;
            }>;
        }>, {
            nullable: true;
        }>;
    }>, S.Struct<{
        type: S.Literal<["tool_result"]>;
        tool_use_id: typeof S.String;
        content: S.optionalWith<S.Union<[typeof S.String, S.Array$<S.Union<[S.Struct<{
            type: S.Literal<["text"]>;
            text: typeof S.String;
            citations: S.optionalWith<S.Array$<S.Union<[S.Struct<{
                type: S.Literal<["char_location"]>;
                cited_text: typeof S.String;
                document_index: typeof S.Number;
                document_title: S.NullOr<typeof S.String>;
                start_char_index: typeof S.Number;
                end_char_index: typeof S.Number;
            }>, S.Struct<{
                type: S.Literal<["page_location"]>;
                cited_text: typeof S.String;
                document_index: typeof S.Number;
                document_title: S.NullOr<typeof S.String>;
                start_page_number: typeof S.Number;
                end_page_number: typeof S.Number;
            }>, S.Struct<{
                type: S.Literal<["content_block_location"]>;
                cited_text: typeof S.String;
                document_index: typeof S.Number;
                document_title: S.NullOr<typeof S.String>;
                start_block_index: typeof S.Number;
                end_block_index: typeof S.Number;
            }>, S.Struct<{
                type: S.Literal<["web_search_result_location"]>;
                cited_text: typeof S.String;
                encrypted_index: typeof S.String;
                title: S.NullOr<typeof S.String>;
                url: typeof S.String;
            }>, S.Struct<{
                type: S.Literal<["search_result_location"]>;
                cited_text: typeof S.String;
                search_result_index: typeof S.Number;
                source: typeof S.String;
                title: S.NullOr<typeof S.String>;
                start_block_index: typeof S.Number;
                end_block_index: typeof S.Number;
            }>]>>, {
                nullable: true;
            }>;
            cache_control: S.optionalWith<S.Struct<{
                type: S.Literal<["ephemeral"]>;
                ttl: S.optionalWith<S.Literal<["5m", "1h"]>, {
                    nullable: true;
                }>;
            }>, {
                nullable: true;
            }>;
        }>, S.Struct<{
            type: S.Literal<["image"]>;
            source: S.Union<[S.Struct<{
                type: S.Literal<["base64"]>;
                media_type: S.Literal<["image/jpeg", "image/png", "image/gif", "image/webp"]>;
                data: typeof S.String;
            }>, S.Struct<{
                type: S.Literal<["url"]>;
                url: typeof S.String;
            }>]>;
            cache_control: S.optionalWith<S.Struct<{
                type: S.Literal<["ephemeral"]>;
                ttl: S.optionalWith<S.Literal<["5m", "1h"]>, {
                    nullable: true;
                }>;
            }>, {
                nullable: true;
            }>;
        }>]>>]>, {
            nullable: true;
        }>;
        is_error: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
        cache_control: S.optionalWith<S.Struct<{
            type: S.Literal<["ephemeral"]>;
            ttl: S.optionalWith<S.Literal<["5m", "1h"]>, {
                nullable: true;
            }>;
        }>, {
            nullable: true;
        }>;
    }>, S.Struct<{
        type: S.Literal<["thinking"]>;
        thinking: typeof S.String;
        signature: typeof S.String;
    }>, S.Struct<{
        type: S.Literal<["redacted_thinking"]>;
        data: typeof S.String;
    }>, S.Struct<{
        type: S.Literal<["server_tool_use"]>;
        id: typeof S.String;
        name: S.Literal<["web_search"]>;
        cache_control: S.optionalWith<S.Struct<{
            type: S.Literal<["ephemeral"]>;
            ttl: S.optionalWith<S.Literal<["5m", "1h"]>, {
                nullable: true;
            }>;
        }>, {
            nullable: true;
        }>;
    }>, S.Struct<{
        type: S.Literal<["web_search_tool_result"]>;
        tool_use_id: typeof S.String;
        content: S.Union<[S.Array$<S.Struct<{
            type: S.Literal<["web_search_result"]>;
            encrypted_content: typeof S.String;
            title: typeof S.String;
            url: typeof S.String;
            page_age: S.optionalWith<typeof S.String, {
                nullable: true;
            }>;
        }>>, S.Struct<{
            type: S.Literal<["web_search_tool_result_error"]>;
            error_code: S.Literal<["invalid_tool_input", "unavailable", "max_uses_exceeded", "too_many_requests", "query_too_long"]>;
        }>]>;
        cache_control: S.optionalWith<S.Struct<{
            type: S.Literal<["ephemeral"]>;
            ttl: S.optionalWith<S.Literal<["5m", "1h"]>, {
                nullable: true;
            }>;
        }>, {
            nullable: true;
        }>;
    }>, S.Struct<{
        type: S.Literal<["search_result"]>;
        source: typeof S.String;
        title: typeof S.String;
        content: S.Array$<S.Struct<{
            type: S.Literal<["text"]>;
            text: typeof S.String;
            citations: S.optionalWith<S.Array$<S.Union<[S.Struct<{
                type: S.Literal<["char_location"]>;
                cited_text: typeof S.String;
                document_index: typeof S.Number;
                document_title: S.NullOr<typeof S.String>;
                start_char_index: typeof S.Number;
                end_char_index: typeof S.Number;
            }>, S.Struct<{
                type: S.Literal<["page_location"]>;
                cited_text: typeof S.String;
                document_index: typeof S.Number;
                document_title: S.NullOr<typeof S.String>;
                start_page_number: typeof S.Number;
                end_page_number: typeof S.Number;
            }>, S.Struct<{
                type: S.Literal<["content_block_location"]>;
                cited_text: typeof S.String;
                document_index: typeof S.Number;
                document_title: S.NullOr<typeof S.String>;
                start_block_index: typeof S.Number;
                end_block_index: typeof S.Number;
            }>, S.Struct<{
                type: S.Literal<["web_search_result_location"]>;
                cited_text: typeof S.String;
                encrypted_index: typeof S.String;
                title: S.NullOr<typeof S.String>;
                url: typeof S.String;
            }>, S.Struct<{
                type: S.Literal<["search_result_location"]>;
                cited_text: typeof S.String;
                search_result_index: typeof S.Number;
                source: typeof S.String;
                title: S.NullOr<typeof S.String>;
                start_block_index: typeof S.Number;
                end_block_index: typeof S.Number;
            }>]>>, {
                nullable: true;
            }>;
            cache_control: S.optionalWith<S.Struct<{
                type: S.Literal<["ephemeral"]>;
                ttl: S.optionalWith<S.Literal<["5m", "1h"]>, {
                    nullable: true;
                }>;
            }>, {
                nullable: true;
            }>;
        }>>;
        citations: S.optionalWith<S.Struct<{
            enabled: S.optionalWith<typeof S.Boolean, {
                nullable: true;
            }>;
        }>, {
            nullable: true;
        }>;
        cache_control: S.optionalWith<S.Struct<{
            type: S.Literal<["ephemeral"]>;
            ttl: S.optionalWith<S.Literal<["5m", "1h"]>, {
                nullable: true;
            }>;
        }>, {
            nullable: true;
        }>;
    }>]>>]>;
}>, never, {
    readonly content: string | readonly ({
        readonly type: "text";
        readonly text: string;
        readonly citations?: readonly ({
            readonly type: "char_location";
            readonly cited_text: string;
            readonly document_index: number;
            readonly document_title: string | null;
            readonly start_char_index: number;
            readonly end_char_index: number;
        } | {
            readonly type: "page_location";
            readonly cited_text: string;
            readonly document_index: number;
            readonly document_title: string | null;
            readonly start_page_number: number;
            readonly end_page_number: number;
        } | {
            readonly type: "content_block_location";
            readonly cited_text: string;
            readonly document_index: number;
            readonly document_title: string | null;
            readonly start_block_index: number;
            readonly end_block_index: number;
        } | {
            readonly type: "web_search_result_location";
            readonly url: string;
            readonly title: string | null;
            readonly cited_text: string;
            readonly encrypted_index: string;
        } | {
            readonly type: "search_result_location";
            readonly title: string | null;
            readonly cited_text: string;
            readonly start_block_index: number;
            readonly end_block_index: number;
            readonly search_result_index: number;
            readonly source: string;
        })[] | undefined;
        readonly cache_control?: {
            readonly type: "ephemeral";
            readonly ttl?: "5m" | "1h" | undefined;
        } | undefined;
    } | {
        readonly type: "image";
        readonly cache_control?: {
            readonly type: "ephemeral";
            readonly ttl?: "5m" | "1h" | undefined;
        } | undefined;
        readonly source: {
            readonly type: "base64";
            readonly data: string;
            readonly media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
        } | {
            readonly type: "url";
            readonly url: string;
        };
    } | {
        readonly type: "document";
        readonly title?: string | undefined;
        readonly citations?: {
            readonly enabled?: boolean | undefined;
        } | undefined;
        readonly cache_control?: {
            readonly type: "ephemeral";
            readonly ttl?: "5m" | "1h" | undefined;
        } | undefined;
        readonly source: {
            readonly type: "base64";
            readonly data: string;
            readonly media_type: "application/pdf";
        } | {
            readonly type: "text";
            readonly data: string;
            readonly media_type: "text/plain";
        } | {
            readonly type: "content";
            readonly content: string | readonly ({
                readonly type: "text";
                readonly text: string;
                readonly citations?: readonly ({
                    readonly type: "char_location";
                    readonly cited_text: string;
                    readonly document_index: number;
                    readonly document_title: string | null;
                    readonly start_char_index: number;
                    readonly end_char_index: number;
                } | {
                    readonly type: "page_location";
                    readonly cited_text: string;
                    readonly document_index: number;
                    readonly document_title: string | null;
                    readonly start_page_number: number;
                    readonly end_page_number: number;
                } | {
                    readonly type: "content_block_location";
                    readonly cited_text: string;
                    readonly document_index: number;
                    readonly document_title: string | null;
                    readonly start_block_index: number;
                    readonly end_block_index: number;
                } | {
                    readonly type: "web_search_result_location";
                    readonly url: string;
                    readonly title: string | null;
                    readonly cited_text: string;
                    readonly encrypted_index: string;
                } | {
                    readonly type: "search_result_location";
                    readonly title: string | null;
                    readonly cited_text: string;
                    readonly start_block_index: number;
                    readonly end_block_index: number;
                    readonly search_result_index: number;
                    readonly source: string;
                })[] | undefined;
                readonly cache_control?: {
                    readonly type: "ephemeral";
                    readonly ttl?: "5m" | "1h" | undefined;
                } | undefined;
            } | {
                readonly type: "image";
                readonly cache_control?: {
                    readonly type: "ephemeral";
                    readonly ttl?: "5m" | "1h" | undefined;
                } | undefined;
                readonly source: {
                    readonly type: "base64";
                    readonly data: string;
                    readonly media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
                } | {
                    readonly type: "url";
                    readonly url: string;
                };
            })[];
        } | {
            readonly type: "url";
            readonly url: string;
        };
        readonly context?: string | undefined;
    } | {
        readonly type: "tool_use";
        readonly id: string;
        readonly name: string;
        readonly cache_control?: {
            readonly type: "ephemeral";
            readonly ttl?: "5m" | "1h" | undefined;
        } | undefined;
    } | {
        readonly type: "tool_result";
        readonly content?: string | readonly ({
            readonly type: "text";
            readonly text: string;
            readonly citations?: readonly ({
                readonly type: "char_location";
                readonly cited_text: string;
                readonly document_index: number;
                readonly document_title: string | null;
                readonly start_char_index: number;
                readonly end_char_index: number;
            } | {
                readonly type: "page_location";
                readonly cited_text: string;
                readonly document_index: number;
                readonly document_title: string | null;
                readonly start_page_number: number;
                readonly end_page_number: number;
            } | {
                readonly type: "content_block_location";
                readonly cited_text: string;
                readonly document_index: number;
                readonly document_title: string | null;
                readonly start_block_index: number;
                readonly end_block_index: number;
            } | {
                readonly type: "web_search_result_location";
                readonly url: string;
                readonly title: string | null;
                readonly cited_text: string;
                readonly encrypted_index: string;
            } | {
                readonly type: "search_result_location";
                readonly title: string | null;
                readonly cited_text: string;
                readonly start_block_index: number;
                readonly end_block_index: number;
                readonly search_result_index: number;
                readonly source: string;
            })[] | undefined;
            readonly cache_control?: {
                readonly type: "ephemeral";
                readonly ttl?: "5m" | "1h" | undefined;
            } | undefined;
        } | {
            readonly type: "image";
            readonly cache_control?: {
                readonly type: "ephemeral";
                readonly ttl?: "5m" | "1h" | undefined;
            } | undefined;
            readonly source: {
                readonly type: "base64";
                readonly data: string;
                readonly media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
            } | {
                readonly type: "url";
                readonly url: string;
            };
        })[] | undefined;
        readonly cache_control?: {
            readonly type: "ephemeral";
            readonly ttl?: "5m" | "1h" | undefined;
        } | undefined;
        readonly tool_use_id: string;
        readonly is_error?: boolean | undefined;
    } | {
        readonly type: "thinking";
        readonly signature: string;
        readonly thinking: string;
    } | {
        readonly type: "redacted_thinking";
        readonly data: string;
    } | {
        readonly type: "server_tool_use";
        readonly id: string;
        readonly name: "web_search";
        readonly cache_control?: {
            readonly type: "ephemeral";
            readonly ttl?: "5m" | "1h" | undefined;
        } | undefined;
    } | {
        readonly type: "web_search_tool_result";
        readonly content: readonly {
            readonly type: "web_search_result";
            readonly encrypted_content: string;
            readonly url: string;
            readonly title: string;
            readonly page_age?: string | undefined;
        }[] | {
            readonly type: "web_search_tool_result_error";
            readonly error_code: "invalid_tool_input" | "unavailable" | "max_uses_exceeded" | "too_many_requests" | "query_too_long";
        };
        readonly cache_control?: {
            readonly type: "ephemeral";
            readonly ttl?: "5m" | "1h" | undefined;
        } | undefined;
        readonly tool_use_id: string;
    } | {
        readonly type: "search_result";
        readonly content: readonly {
            readonly type: "text";
            readonly text: string;
            readonly citations?: readonly ({
                readonly type: "char_location";
                readonly cited_text: string;
                readonly document_index: number;
                readonly document_title: string | null;
                readonly start_char_index: number;
                readonly end_char_index: number;
            } | {
                readonly type: "page_location";
                readonly cited_text: string;
                readonly document_index: number;
                readonly document_title: string | null;
                readonly start_page_number: number;
                readonly end_page_number: number;
            } | {
                readonly type: "content_block_location";
                readonly cited_text: string;
                readonly document_index: number;
                readonly document_title: string | null;
                readonly start_block_index: number;
                readonly end_block_index: number;
            } | {
                readonly type: "web_search_result_location";
                readonly url: string;
                readonly title: string | null;
                readonly cited_text: string;
                readonly encrypted_index: string;
            } | {
                readonly type: "search_result_location";
                readonly title: string | null;
                readonly cited_text: string;
                readonly start_block_index: number;
                readonly end_block_index: number;
                readonly search_result_index: number;
                readonly source: string;
            })[] | undefined;
            readonly cache_control?: {
                readonly type: "ephemeral";
                readonly ttl?: "5m" | "1h" | undefined;
            } | undefined;
        }[];
        readonly title: string;
        readonly citations?: {
            readonly enabled?: boolean | undefined;
        } | undefined;
        readonly cache_control?: {
            readonly type: "ephemeral";
            readonly ttl?: "5m" | "1h" | undefined;
        } | undefined;
        readonly source: string;
    })[];
} & {
    readonly role: "assistant" | "user";
}, {}, {}>;
/**
 * Anthropic message with OpenRouter extensions
 */
export declare class OpenRouterAnthropicMessageParam extends OpenRouterAnthropicMessageParam_base {
}
declare const AnthropicMessagesRequestToolChoiceEnumType_base: S.Literal<["tool"]>;
export declare class AnthropicMessagesRequestToolChoiceEnumType extends AnthropicMessagesRequestToolChoiceEnumType_base {
}
declare const AnthropicMessagesRequestThinkingEnumType_base: S.Literal<["disabled"]>;
export declare class AnthropicMessagesRequestThinkingEnumType extends AnthropicMessagesRequestThinkingEnumType_base {
}
declare const AnthropicMessagesRequestServiceTier_base: S.Literal<["auto", "standard_only"]>;
export declare class AnthropicMessagesRequestServiceTier extends AnthropicMessagesRequestServiceTier_base {
}
declare const AnthropicMessagesRequestProviderSort_base: S.Literal<["price", "throughput", "latency"]>;
/**
 * The sorting strategy to use for this request, if "order" is not specified. When set, no load balancing is performed.
 */
export declare class AnthropicMessagesRequestProviderSort extends AnthropicMessagesRequestProviderSort_base {
}
declare const AnthropicMessagesRequestRoute_base: S.Literal<["fallback", "sort"]>;
/**
 * **DEPRECATED** Use providers.sort.partition instead. Backwards-compatible alias for providers.sort.partition. Accepts legacy values: "fallback" (maps to "model"), "sort" (maps to "none").
 */
export declare class AnthropicMessagesRequestRoute extends AnthropicMessagesRequestRoute_base {
}
declare const AnthropicMessagesRequest_base: S.Class<AnthropicMessagesRequest, {
    model: typeof S.String;
    max_tokens: typeof S.Number;
    messages: S.Array$<typeof OpenRouterAnthropicMessageParam>;
    system: S.optionalWith<S.Union<[typeof S.String, S.Array$<S.Struct<{
        type: S.Literal<["text"]>;
        text: typeof S.String;
        citations: S.optionalWith<S.Array$<S.Union<[S.Struct<{
            type: S.Literal<["char_location"]>;
            cited_text: typeof S.String;
            document_index: typeof S.Number;
            document_title: S.NullOr<typeof S.String>;
            start_char_index: typeof S.Number;
            end_char_index: typeof S.Number;
        }>, S.Struct<{
            type: S.Literal<["page_location"]>;
            cited_text: typeof S.String;
            document_index: typeof S.Number;
            document_title: S.NullOr<typeof S.String>;
            start_page_number: typeof S.Number;
            end_page_number: typeof S.Number;
        }>, S.Struct<{
            type: S.Literal<["content_block_location"]>;
            cited_text: typeof S.String;
            document_index: typeof S.Number;
            document_title: S.NullOr<typeof S.String>;
            start_block_index: typeof S.Number;
            end_block_index: typeof S.Number;
        }>, S.Struct<{
            type: S.Literal<["web_search_result_location"]>;
            cited_text: typeof S.String;
            encrypted_index: typeof S.String;
            title: S.NullOr<typeof S.String>;
            url: typeof S.String;
        }>, S.Struct<{
            type: S.Literal<["search_result_location"]>;
            cited_text: typeof S.String;
            search_result_index: typeof S.Number;
            source: typeof S.String;
            title: S.NullOr<typeof S.String>;
            start_block_index: typeof S.Number;
            end_block_index: typeof S.Number;
        }>]>>, {
            nullable: true;
        }>;
        cache_control: S.optionalWith<S.Struct<{
            type: S.Literal<["ephemeral"]>;
            ttl: S.optionalWith<S.Literal<["5m", "1h"]>, {
                nullable: true;
            }>;
        }>, {
            nullable: true;
        }>;
    }>>]>, {
        nullable: true;
    }>;
    metadata: S.optionalWith<S.Struct<{
        user_id: S.optionalWith<typeof S.String, {
            nullable: true;
        }>;
    }>, {
        nullable: true;
    }>;
    stop_sequences: S.optionalWith<S.Array$<typeof S.String>, {
        nullable: true;
    }>;
    stream: S.optionalWith<typeof S.Boolean, {
        nullable: true;
    }>;
    temperature: S.optionalWith<typeof S.Number, {
        nullable: true;
    }>;
    top_p: S.optionalWith<typeof S.Number, {
        nullable: true;
    }>;
    top_k: S.optionalWith<typeof S.Number, {
        nullable: true;
    }>;
    tools: S.optionalWith<S.Array$<S.Union<[S.Struct<{
        name: typeof S.String;
        description: S.optionalWith<typeof S.String, {
            nullable: true;
        }>;
        input_schema: S.Struct<{
            type: S.Literal<["object"]>;
            required: S.optionalWith<S.Array$<typeof S.String>, {
                nullable: true;
            }>;
        }>;
        type: S.optionalWith<S.Literal<["custom"]>, {
            nullable: true;
        }>;
        cache_control: S.optionalWith<S.Struct<{
            type: S.Literal<["ephemeral"]>;
            ttl: S.optionalWith<S.Literal<["5m", "1h"]>, {
                nullable: true;
            }>;
        }>, {
            nullable: true;
        }>;
    }>, S.Struct<{
        type: S.Literal<["bash_20250124"]>;
        name: S.Literal<["bash"]>;
        cache_control: S.optionalWith<S.Struct<{
            type: S.Literal<["ephemeral"]>;
            ttl: S.optionalWith<S.Literal<["5m", "1h"]>, {
                nullable: true;
            }>;
        }>, {
            nullable: true;
        }>;
    }>, S.Struct<{
        type: S.Literal<["text_editor_20250124"]>;
        name: S.Literal<["str_replace_editor"]>;
        cache_control: S.optionalWith<S.Struct<{
            type: S.Literal<["ephemeral"]>;
            ttl: S.optionalWith<S.Literal<["5m", "1h"]>, {
                nullable: true;
            }>;
        }>, {
            nullable: true;
        }>;
    }>, S.Struct<{
        type: S.Literal<["web_search_20250305"]>;
        name: S.Literal<["web_search"]>;
        allowed_domains: S.optionalWith<S.Array$<typeof S.String>, {
            nullable: true;
        }>;
        blocked_domains: S.optionalWith<S.Array$<typeof S.String>, {
            nullable: true;
        }>;
        max_uses: S.optionalWith<typeof S.Number, {
            nullable: true;
        }>;
        user_location: S.optionalWith<S.Struct<{
            type: S.Literal<["approximate"]>;
            city: S.optionalWith<typeof S.String, {
                nullable: true;
            }>;
            country: S.optionalWith<typeof S.String, {
                nullable: true;
            }>;
            region: S.optionalWith<typeof S.String, {
                nullable: true;
            }>;
            timezone: S.optionalWith<typeof S.String, {
                nullable: true;
            }>;
        }>, {
            nullable: true;
        }>;
        cache_control: S.optionalWith<S.Struct<{
            type: S.Literal<["ephemeral"]>;
            ttl: S.optionalWith<S.Literal<["5m", "1h"]>, {
                nullable: true;
            }>;
        }>, {
            nullable: true;
        }>;
    }>]>>, {
        nullable: true;
    }>;
    tool_choice: S.optionalWith<S.Union<[S.Struct<{
        type: typeof AnthropicMessagesRequestToolChoiceEnumType;
        disable_parallel_tool_use: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
    }>, S.Struct<{
        type: typeof AnthropicMessagesRequestToolChoiceEnumType;
        disable_parallel_tool_use: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
    }>, S.Struct<{
        type: typeof AnthropicMessagesRequestToolChoiceEnumType;
    }>, S.Struct<{
        type: typeof AnthropicMessagesRequestToolChoiceEnumType;
        name: typeof S.String;
        disable_parallel_tool_use: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
    }>]>, {
        nullable: true;
    }>;
    thinking: S.optionalWith<S.Union<[S.Struct<{
        type: typeof AnthropicMessagesRequestThinkingEnumType;
        budget_tokens: typeof S.Number;
    }>, S.Struct<{
        type: typeof AnthropicMessagesRequestThinkingEnumType;
    }>]>, {
        nullable: true;
    }>;
    service_tier: S.optionalWith<typeof AnthropicMessagesRequestServiceTier, {
        nullable: true;
    }>;
    /**
     * When multiple model providers are available, optionally indicate your routing preference.
     */
    provider: S.optionalWith<S.Struct<{
        /**
         * Whether to allow backup providers to serve requests
         * - true: (default) when the primary provider (or your custom providers in "order") is unavailable, use the next best provider.
         * - false: use only the primary/custom provider, and return the upstream error if it's unavailable.
         */
        allow_fallbacks: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
        /**
         * Whether to filter providers to only those that support the parameters you've provided. If this setting is omitted or set to false, then providers will receive only the parameters they support, and ignore the rest.
         */
        require_parameters: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
        data_collection: S.optionalWith<typeof DataCollection, {
            nullable: true;
        }>;
        /**
         * Whether to restrict routing to only ZDR (Zero Data Retention) endpoints. When true, only endpoints that do not retain prompts will be used.
         */
        zdr: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
        /**
         * Whether to restrict routing to only models that allow text distillation. When true, only models where the author has allowed distillation will be used.
         */
        enforce_distillable_text: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
        /**
         * An ordered list of provider slugs. The router will attempt to use the first provider in the subset of this list that supports your requested model, and fall back to the next if it is unavailable. If no providers are available, the request will fail with an error message.
         */
        order: S.optionalWith<S.Array$<S.Union<[typeof ProviderName, typeof S.String]>>, {
            nullable: true;
        }>;
        /**
         * List of provider slugs to allow. If provided, this list is merged with your account-wide allowed provider settings for this request.
         */
        only: S.optionalWith<S.Array$<S.Union<[typeof ProviderName, typeof S.String]>>, {
            nullable: true;
        }>;
        /**
         * List of provider slugs to ignore. If provided, this list is merged with your account-wide ignored provider settings for this request.
         */
        ignore: S.optionalWith<S.Array$<S.Union<[typeof ProviderName, typeof S.String]>>, {
            nullable: true;
        }>;
        /**
         * A list of quantization levels to filter the provider by.
         */
        quantizations: S.optionalWith<S.Array$<typeof Quantization>, {
            nullable: true;
        }>;
        sort: S.optionalWith<typeof AnthropicMessagesRequestProviderSort, {
            nullable: true;
        }>;
        /**
         * The object specifying the maximum price you want to pay for this request. USD price per million tokens, for prompt and completion.
         */
        max_price: S.optionalWith<S.Struct<{
            prompt: S.optionalWith<typeof BigNumberUnion, {
                nullable: true;
            }>;
            completion: S.optionalWith<typeof BigNumberUnion, {
                nullable: true;
            }>;
            image: S.optionalWith<typeof BigNumberUnion, {
                nullable: true;
            }>;
            audio: S.optionalWith<typeof BigNumberUnion, {
                nullable: true;
            }>;
            request: S.optionalWith<typeof BigNumberUnion, {
                nullable: true;
            }>;
        }>, {
            nullable: true;
        }>;
        preferred_min_throughput: S.optionalWith<typeof PreferredMinThroughput, {
            nullable: true;
        }>;
        preferred_max_latency: S.optionalWith<typeof PreferredMaxLatency, {
            nullable: true;
        }>;
    }>, {
        nullable: true;
    }>;
    /**
     * Plugins you want to enable for this request, including their settings.
     */
    plugins: S.optionalWith<S.Array$<S.Union<[S.Struct<{
        id: S.Literal<["auto-router"]>;
        /**
         * Set to false to disable the auto-router plugin for this request. Defaults to true.
         */
        enabled: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
        /**
         * List of model patterns to filter which models the auto-router can route between. Supports wildcards (e.g., "anthropic/*" matches all Anthropic models). When not specified, uses the default supported models list.
         */
        allowed_models: S.optionalWith<S.Array$<typeof S.String>, {
            nullable: true;
        }>;
    }>, S.Struct<{
        id: S.Literal<["moderation"]>;
    }>, S.Struct<{
        id: S.Literal<["web"]>;
        /**
         * Set to false to disable the web-search plugin for this request. Defaults to true.
         */
        enabled: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
        max_results: S.optionalWith<typeof S.Number, {
            nullable: true;
        }>;
        search_prompt: S.optionalWith<typeof S.String, {
            nullable: true;
        }>;
        engine: S.optionalWith<typeof WebSearchEngine, {
            nullable: true;
        }>;
    }>, S.Struct<{
        id: S.Literal<["file-parser"]>;
        /**
         * Set to false to disable the file-parser plugin for this request. Defaults to true.
         */
        enabled: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
        pdf: S.optionalWith<typeof PDFParserOptions, {
            nullable: true;
        }>;
    }>, S.Struct<{
        id: S.Literal<["response-healing"]>;
        /**
         * Set to false to disable the response-healing plugin for this request. Defaults to true.
         */
        enabled: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
    }>]>>, {
        nullable: true;
    }>;
    /**
     * **DEPRECATED** Use providers.sort.partition instead. Backwards-compatible alias for providers.sort.partition. Accepts legacy values: "fallback" (maps to "model"), "sort" (maps to "none").
     */
    route: S.optionalWith<typeof AnthropicMessagesRequestRoute, {
        nullable: true;
    }>;
    /**
     * A unique identifier representing your end-user, which helps distinguish between different users of your app. This allows your app to identify specific users in case of abuse reports, preventing your entire app from being affected by the actions of individual users. Maximum of 128 characters.
     */
    user: S.optionalWith<S.filter<typeof S.String>, {
        nullable: true;
    }>;
    /**
     * 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.
     */
    session_id: S.optionalWith<S.filter<typeof S.String>, {
        nullable: true;
    }>;
    models: S.optionalWith<S.Array$<typeof S.String>, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    model: typeof S.String;
    max_tokens: typeof S.Number;
    messages: S.Array$<typeof OpenRouterAnthropicMessageParam>;
    system: S.optionalWith<S.Union<[typeof S.String, S.Array$<S.Struct<{
        type: S.Literal<["text"]>;
        text: typeof S.String;
        citations: S.optionalWith<S.Array$<S.Union<[S.Struct<{
            type: S.Literal<["char_location"]>;
            cited_text: typeof S.String;
            document_index: typeof S.Number;
            document_title: S.NullOr<typeof S.String>;
            start_char_index: typeof S.Number;
            end_char_index: typeof S.Number;
        }>, S.Struct<{
            type: S.Literal<["page_location"]>;
            cited_text: typeof S.String;
            document_index: typeof S.Number;
            document_title: S.NullOr<typeof S.String>;
            start_page_number: typeof S.Number;
            end_page_number: typeof S.Number;
        }>, S.Struct<{
            type: S.Literal<["content_block_location"]>;
            cited_text: typeof S.String;
            document_index: typeof S.Number;
            document_title: S.NullOr<typeof S.String>;
            start_block_index: typeof S.Number;
            end_block_index: typeof S.Number;
        }>, S.Struct<{
            type: S.Literal<["web_search_result_location"]>;
            cited_text: typeof S.String;
            encrypted_index: typeof S.String;
            title: S.NullOr<typeof S.String>;
            url: typeof S.String;
        }>, S.Struct<{
            type: S.Literal<["search_result_location"]>;
            cited_text: typeof S.String;
            search_result_index: typeof S.Number;
            source: typeof S.String;
            title: S.NullOr<typeof S.String>;
            start_block_index: typeof S.Number;
            end_block_index: typeof S.Number;
        }>]>>, {
            nullable: true;
        }>;
        cache_control: S.optionalWith<S.Struct<{
            type: S.Literal<["ephemeral"]>;
            ttl: S.optionalWith<S.Literal<["5m", "1h"]>, {
                nullable: true;
            }>;
        }>, {
            nullable: true;
        }>;
    }>>]>, {
        nullable: true;
    }>;
    metadata: S.optionalWith<S.Struct<{
        user_id: S.optionalWith<typeof S.String, {
            nullable: true;
        }>;
    }>, {
        nullable: true;
    }>;
    stop_sequences: S.optionalWith<S.Array$<typeof S.String>, {
        nullable: true;
    }>;
    stream: S.optionalWith<typeof S.Boolean, {
        nullable: true;
    }>;
    temperature: S.optionalWith<typeof S.Number, {
        nullable: true;
    }>;
    top_p: S.optionalWith<typeof S.Number, {
        nullable: true;
    }>;
    top_k: S.optionalWith<typeof S.Number, {
        nullable: true;
    }>;
    tools: S.optionalWith<S.Array$<S.Union<[S.Struct<{
        name: typeof S.String;
        description: S.optionalWith<typeof S.String, {
            nullable: true;
        }>;
        input_schema: S.Struct<{
            type: S.Literal<["object"]>;
            required: S.optionalWith<S.Array$<typeof S.String>, {
                nullable: true;
            }>;
        }>;
        type: S.optionalWith<S.Literal<["custom"]>, {
            nullable: true;
        }>;
        cache_control: S.optionalWith<S.Struct<{
            type: S.Literal<["ephemeral"]>;
            ttl: S.optionalWith<S.Literal<["5m", "1h"]>, {
                nullable: true;
            }>;
        }>, {
            nullable: true;
        }>;
    }>, S.Struct<{
        type: S.Literal<["bash_20250124"]>;
        name: S.Literal<["bash"]>;
        cache_control: S.optionalWith<S.Struct<{
            type: S.Literal<["ephemeral"]>;
            ttl: S.optionalWith<S.Literal<["5m", "1h"]>, {
                nullable: true;
            }>;
        }>, {
            nullable: true;
        }>;
    }>, S.Struct<{
        type: S.Literal<["text_editor_20250124"]>;
        name: S.Literal<["str_replace_editor"]>;
        cache_control: S.optionalWith<S.Struct<{
            type: S.Literal<["ephemeral"]>;
            ttl: S.optionalWith<S.Literal<["5m", "1h"]>, {
                nullable: true;
            }>;
        }>, {
            nullable: true;
        }>;
    }>, S.Struct<{
        type: S.Literal<["web_search_20250305"]>;
        name: S.Literal<["web_search"]>;
        allowed_domains: S.optionalWith<S.Array$<typeof S.String>, {
            nullable: true;
        }>;
        blocked_domains: S.optionalWith<S.Array$<typeof S.String>, {
            nullable: true;
        }>;
        max_uses: S.optionalWith<typeof S.Number, {
            nullable: true;
        }>;
        user_location: S.optionalWith<S.Struct<{
            type: S.Literal<["approximate"]>;
            city: S.optionalWith<typeof S.String, {
                nullable: true;
            }>;
            country: S.optionalWith<typeof S.String, {
                nullable: true;
            }>;
            region: S.optionalWith<typeof S.String, {
                nullable: true;
            }>;
            timezone: S.optionalWith<typeof S.String, {
                nullable: true;
            }>;
        }>, {
            nullable: true;
        }>;
        cache_control: S.optionalWith<S.Struct<{
            type: S.Literal<["ephemeral"]>;
            ttl: S.optionalWith<S.Literal<["5m", "1h"]>, {
                nullable: true;
            }>;
        }>, {
            nullable: true;
        }>;
    }>]>>, {
        nullable: true;
    }>;
    tool_choice: S.optionalWith<S.Union<[S.Struct<{
        type: typeof AnthropicMessagesRequestToolChoiceEnumType;
        disable_parallel_tool_use: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
    }>, S.Struct<{
        type: typeof AnthropicMessagesRequestToolChoiceEnumType;
        disable_parallel_tool_use: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
    }>, S.Struct<{
        type: typeof AnthropicMessagesRequestToolChoiceEnumType;
    }>, S.Struct<{
        type: typeof AnthropicMessagesRequestToolChoiceEnumType;
        name: typeof S.String;
        disable_parallel_tool_use: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
    }>]>, {
        nullable: true;
    }>;
    thinking: S.optionalWith<S.Union<[S.Struct<{
        type: typeof AnthropicMessagesRequestThinkingEnumType;
        budget_tokens: typeof S.Number;
    }>, S.Struct<{
        type: typeof AnthropicMessagesRequestThinkingEnumType;
    }>]>, {
        nullable: true;
    }>;
    service_tier: S.optionalWith<typeof AnthropicMessagesRequestServiceTier, {
        nullable: true;
    }>;
    /**
     * When multiple model providers are available, optionally indicate your routing preference.
     */
    provider: S.optionalWith<S.Struct<{
        /**
         * Whether to allow backup providers to serve requests
         * - true: (default) when the primary provider (or your custom providers in "order") is unavailable, use the next best provider.
         * - false: use only the primary/custom provider, and return the upstream error if it's unavailable.
         */
        allow_fallbacks: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
        /**
         * Whether to filter providers to only those that support the parameters you've provided. If this setting is omitted or set to false, then providers will receive only the parameters they support, and ignore the rest.
         */
        require_parameters: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
        data_collection: S.optionalWith<typeof DataCollection, {
            nullable: true;
        }>;
        /**
         * Whether to restrict routing to only ZDR (Zero Data Retention) endpoints. When true, only endpoints that do not retain prompts will be used.
         */
        zdr: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
        /**
         * Whether to restrict routing to only models that allow text distillation. When true, only models where the author has allowed distillation will be used.
         */
        enforce_distillable_text: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
        /**
         * An ordered list of provider slugs. The router will attempt to use the first provider in the subset of this list that supports your requested model, and fall back to the next if it is unavailable. If no providers are available, the request will fail with an error message.
         */
        order: S.optionalWith<S.Array$<S.Union<[typeof ProviderName, typeof S.String]>>, {
            nullable: true;
        }>;
        /**
         * List of provider slugs to allow. If provided, this list is merged with your account-wide allowed provider settings for this request.
         */
        only: S.optionalWith<S.Array$<S.Union<[typeof ProviderName, typeof S.String]>>, {
            nullable: true;
        }>;
        /**
         * List of provider slugs to ignore. If provided, this list is merged with your account-wide ignored provider settings for this request.
         */
        ignore: S.optionalWith<S.Array$<S.Union<[typeof ProviderName, typeof S.String]>>, {
            nullable: true;
        }>;
        /**
         * A list of quantization levels to filter the provider by.
         */
        quantizations: S.optionalWith<S.Array$<typeof Quantization>, {
            nullable: true;
        }>;
        sort: S.optionalWith<typeof AnthropicMessagesRequestProviderSort, {
            nullable: true;
        }>;
        /**
         * The object specifying the maximum price you want to pay for this request. USD price per million tokens, for prompt and completion.
         */
        max_price: S.optionalWith<S.Struct<{
            prompt: S.optionalWith<typeof BigNumberUnion, {
                nullable: true;
            }>;
            completion: S.optionalWith<typeof BigNumberUnion, {
                nullable: true;
            }>;
            image: S.optionalWith<typeof BigNumberUnion, {
                nullable: true;
            }>;
            audio: S.optionalWith<typeof BigNumberUnion, {
                nullable: true;
            }>;
            request: S.optionalWith<typeof BigNumberUnion, {
                nullable: true;
            }>;
        }>, {
            nullable: true;
        }>;
        preferred_min_throughput: S.optionalWith<typeof PreferredMinThroughput, {
            nullable: true;
        }>;
        preferred_max_latency: S.optionalWith<typeof PreferredMaxLatency, {
            nullable: true;
        }>;
    }>, {
        nullable: true;
    }>;
    /**
     * Plugins you want to enable for this request, including their settings.
     */
    plugins: S.optionalWith<S.Array$<S.Union<[S.Struct<{
        id: S.Literal<["auto-router"]>;
        /**
         * Set to false to disable the auto-router plugin for this request. Defaults to true.
         */
        enabled: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
        /**
         * List of model patterns to filter which models the auto-router can route between. Supports wildcards (e.g., "anthropic/*" matches all Anthropic models). When not specified, uses the default supported models list.
         */
        allowed_models: S.optionalWith<S.Array$<typeof S.String>, {
            nullable: true;
        }>;
    }>, S.Struct<{
        id: S.Literal<["moderation"]>;
    }>, S.Struct<{
        id: S.Literal<["web"]>;
        /**
         * Set to false to disable the web-search plugin for this request. Defaults to true.
         */
        enabled: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
        max_results: S.optionalWith<typeof S.Number, {
            nullable: true;
        }>;
        search_prompt: S.optionalWith<typeof S.String, {
            nullable: true;
        }>;
        engine: S.optionalWith<typeof WebSearchEngine, {
            nullable: true;
        }>;
    }>, S.Struct<{
        id: S.Literal<["file-parser"]>;
        /**
         * Set to false to disable the file-parser plugin for this request. Defaults to true.
         */
        enabled: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
        pdf: S.optionalWith<typeof PDFParserOptions, {
            nullable: true;
        }>;
    }>, S.Struct<{
        id: S.Literal<["response-healing"]>;
        /**
         * Set to false to disable the response-healing plugin for this request. Defaults to true.
         */
        enabled: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
    }>]>>, {
        nullable: true;
    }>;
    /**
     * **DEPRECATED** Use providers.sort.partition instead. Backwards-compatible alias for providers.sort.partition. Accepts legacy values: "fallback" (maps to "model"), "sort" (maps to "none").
     */
    route: S.optionalWith<typeof AnthropicMessagesRequestRoute, {
        nullable: true;
    }>;
    /**
     * A unique identifier representing your end-user, which helps distinguish between different users of your app. This allows your app to identify specific users in case of abuse reports, preventing your entire app from being affected by the actions of individual users. Maximum of 128 characters.
     */
    user: S.optionalWith<S.filter<typeof S.String>, {
        nullable: true;
    }>;
    /**
     * 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.
     */
    session_id: S.optionalWith<S.filter<typeof S.String>, {
        nullable: true;
    }>;
    models: S.optionalWith<S.Array$<typeof S.String>, {
        nullable: true;
    }>;
}>, never, {
    readonly max_tokens: number;
} & {
    readonly model: string;
} & {
    readonly metadata?: {
        readonly user_id?: string | undefined;
    } | undefined;
} & {
    readonly tools?: readonly ({
        readonly type?: "custom" | undefined;
        readonly name: string;
        readonly description?: string | undefined;
        readonly cache_control?: {
            readonly type: "ephemeral";
            readonly ttl?: "5m" | "1h" | undefined;
        } | undefined;
        readonly input_schema: {
            readonly type: "object";
            readonly required?: readonly string[] | undefined;
        };
    } | {
        readonly type: "bash_20250124";
        readonly name: "bash";
        readonly cache_control?: {
            readonly type: "ephemeral";
            readonly ttl?: "5m" | "1h" | undefined;
        } | undefined;
    } | {
        readonly type: "text_editor_20250124";
        readonly name: "str_replace_editor";
        readonly cache_control?: {
            readonly type: "ephemeral";
            readonly ttl?: "5m" | "1h" | undefined;
        } | undefined;
    } | {
        readonly type: "web_search_20250305";
        readonly name: "web_search";
        readonly user_location?: {
            readonly type: "approximate";
            readonly city?: string | undefined;
            readonly country?: string | undefined;
            readonly region?: string | undefined;
            readonly timezone?: string | undefined;
        } | undefined;
        readonly allowed_domains?: readonly string[] | undefined;
        readonly cache_control?: {
            readonly type: "ephemeral";
            readonly ttl?: "5m" | "1h" | undefined;
        } | undefined;
        readonly blocked_domains?: readonly string[] | undefined;
        readonly max_uses?: number | undefined;
    })[] | undefined;
} & {
    readonly tool_choice?: {
        readonly type: "tool";
        readonly disable_parallel_tool_use?: boolean | undefined;
    } | {
        readonly type: "tool";
        readonly disable_parallel_tool_use?: boolean | undefined;
    } | {
        readonly type: "tool";
    } | {
        readonly type: "tool";
        readonly name: string;
        readonly disable_parallel_tool_use?: boolean | undefined;
    } | undefined;
} & {
    readonly models?: readonly string[] | undefined;
} & {
    readonly temperature?: number | undefined;
} & {
    readonly top_p?: number | undefined;
} & {
    readonly top_k?: number | undefined;
} & {
    readonly service_tier?: "auto" | "standard_only" | undefined;
} & {
    readonly stream?: boolean | undefined;
} & {
    readonly provider?: {
        readonly sort?: "price" | "throughput" | "latency" | undefined;
        readonly allow_fallbacks?: boolean | undefined;
        readonly require_parameters?: boolean | undefined;
        readonly data_collection?: "deny" | "allow" | undefined;
        readonly zdr?: boolean | undefined;
        readonly enforce_distillable_text?: boolean | undefined;
        readonly order?: readonly string[] | undefined;
        readonly only?: readonly string[] | undefined;
        readonly ignore?: readonly string[] | undefined;
        readonly quantizations?: readonly ("unknown" | "int4" | "int8" | "fp4" | "fp6" | "fp8" | "fp16" | "bf16" | "fp32")[] | undefined;
        readonly max_price?: {
            readonly image?: string | undefined;
            readonly prompt?: string | undefined;
            readonly completion?: string | undefined;
            readonly audio?: string | undefined;
            readonly request?: string | undefined;
        } | undefined;
        readonly preferred_min_throughput?: number | PercentileThroughputCutoffs | undefined;
        readonly preferred_max_latency?: number | PercentileLatencyCutoffs | undefined;
    } | undefined;
} & {
    readonly plugins?: readonly ({
        readonly id: "auto-router";
        readonly enabled?: boolean | undefined;
        readonly allowed_models?: readonly string[] | undefined;
    } | {
        readonly id: "moderation";
    } | {
        readonly id: "web";
        readonly enabled?: boolean | undefined;
        readonly engine?: "native" | "exa" | undefined;
        readonly max_results?: number | undefined;
        readonly search_prompt?: string | undefined;
    } | {
        readonly id: "file-parser";
        readonly enabled?: boolean | undefined;
        readonly pdf?: PDFParserOptions | undefined;
    } | {
        readonly id: "response-healing";
        readonly enabled?: boolean | undefined;
    })[] | undefined;
} & {
    readonly route?: "sort" | "fallback" | undefined;
} & {
    readonly user?: string | undefined;
} & {
    readonly session_id?: string | undefined;
} & {
    readonly system?: string | readonly {
        readonly type: "text";
        readonly text: string;
        readonly citations?: readonly ({
            readonly type: "char_location";
            readonly cited_text: string;
            readonly document_index: number;
            readonly document_title: string | null;
            readonly start_char_index: number;
            readonly end_char_index: number;
        } | {
            readonly type: "page_location";
            readonly cited_text: string;
            readonly document_index: number;
            readonly document_title: string | null;
            readonly start_page_number: number;
            readonly end_page_number: number;
        } | {
            readonly type: "content_block_location";
            readonly cited_text: string;
            readonly document_index: number;
            readonly document_title: string | null;
            readonly start_block_index: number;
            readonly end_block_index: number;
        } | {
            readonly type: "web_search_result_location";
            readonly url: string;
            readonly title: string | null;
            readonly cited_text: string;
            readonly encrypted_index: string;
        } | {
            readonly type: "search_result_location";
            readonly title: string | null;
            readonly cited_text: string;
            readonly start_block_index: number;
            readonly end_block_index: number;
            readonly search_result_index: number;
            readonly source: string;
        })[] | undefined;
        readonly cache_control?: {
            readonly type: "ephemeral";
            readonly ttl?: "5m" | "1h" | undefined;
        } | undefined;
    }[] | undefined;
} & {
    readonly thinking?: {
        readonly type: "disabled";
        readonly budget_tokens: number;
    } | {
        readonly type: "disabled";
    } | undefined;
} & {
    readonly messages: readonly OpenRouterAnthropicMessageParam[];
} & {
    readonly stop_sequences?: readonly string[] | undefined;
}, {}, {}>;
/**
 * Request schema for Anthropic Messages API endpoint
 */
export declare class AnthropicMessagesRequest extends AnthropicMessagesRequest_base {
}
declare const AnthropicMessagesResponseType_base: S.Literal<["message"]>;
export declare class AnthropicMessagesResponseType extends AnthropicMessagesResponseType_base {
}
declare const AnthropicMessagesResponseRole_base: S.Literal<["assistant"]>;
export declare class AnthropicMessagesResponseRole extends AnthropicMessagesResponseRole_base {
}
declare const AnthropicMessagesResponseStopReason_base: S.Literal<["end_turn", "max_tokens", "stop_sequence", "tool_use", "pause_turn", "refusal", "model_context_window_exceeded"]>;
export declare class AnthropicMessagesResponseStopReason extends AnthropicMessagesResponseStopReason_base {
}
declare const AnthropicMessagesResponseUsageServiceTier_base: S.Literal<["standard", "priority", "batch"]>;
export declare class AnthropicMessagesResponseUsageServiceTier extends AnthropicMessagesResponseUsageServiceTier_base {
}
declare const AnthropicMessagesResponse_base: S.Class<AnthropicMessagesResponse, {
    id: typeof S.String;
    type: typeof AnthropicMessagesResponseType;
    role: typeof AnthropicMessagesResponseRole;
    content: S.Array$<S.Union<[S.Struct<{
        type: S.Literal<["text"]>;
        text: typeof S.String;
        citations: S.NullOr<S.Array$<S.Union<[S.Struct<{
            type: S.Literal<["char_location"]>;
            cited_text: typeof S.String;
            document_index: typeof S.Number;
            document_title: S.NullOr<typeof S.String>;
            start_char_index: typeof S.Number;
            end_char_index: typeof S.Number;
            file_id: S.NullOr<typeof S.String>;
        }>, S.Struct<{
            type: S.Literal<["page_location"]>;
            cited_text: typeof S.String;
            document_index: typeof S.Number;
            document_title: S.NullOr<typeof S.String>;
            start_page_number: typeof S.Number;
            end_page_number: typeof S.Number;
            file_id: S.NullOr<typeof S.String>;
        }>, S.Struct<{
            type: S.Literal<["content_block_location"]>;
            cited_text: typeof S.String;
            document_index: typeof S.Number;
            document_title: S.NullOr<typeof S.String>;
            start_block_index: typeof S.Number;
            end_block_index: typeof S.Number;
            file_id: S.NullOr<typeof S.String>;
        }>, S.Struct<{
            type: S.Literal<["web_search_result_location"]>;
            cited_text: typeof S.String;
            encrypted_index: typeof S.String;
            title: S.NullOr<typeof S.String>;
            url: typeof S.String;
        }>, S.Struct<{
            type: S.Literal<["search_result_location"]>;
            cited_text: typeof S.String;
            search_result_index: typeof S.Number;
            source: typeof S.String;
            title: S.NullOr<typeof S.String>;
            start_block_index: typeof S.Number;
            end_block_index: typeof S.Number;
        }>]>>>;
    }>, S.Struct<{
        type: S.Literal<["tool_use"]>;
        id: typeof S.String;
        name: typeof S.String;
    }>, S.Struct<{
        type: S.Literal<["thinking"]>;
        thinking: typeof S.String;
        signature: typeof S.String;
    }>, S.Struct<{
        type: S.Literal<["redacted_thinking"]>;
        data: typeof S.String;
    }>, S.Struct<{
        type: S.Literal<["server_tool_use"]>;
        id: typeof S.String;
        name: S.Literal<["web_search"]>;
    }>, S.Struct<{
        type: S.Literal<["web_search_tool_result"]>;
        tool_use_id: typeof S.String;
        content: S.Union<[S.Array$<S.Struct<{
            type: S.Literal<["web_search_result"]>;
            encrypted_content: typeof S.String;
            page_age: S.NullOr<typeof S.String>;
            title: typeof S.String;
            url: typeof S.String;
        }>>, S.Struct<{
            type: S.Literal<["web_search_tool_result_error"]>;
            error_code: S.Literal<["invalid_tool_input", "unavailable", "max_uses_exceeded", "too_many_requests", "query_too_long"]>;
        }>]>;
    }>]>>;
    model: typeof S.String;
    stop_reason: S.NullOr<typeof AnthropicMessagesResponseStopReason>;
    stop_sequence: S.NullOr<typeof S.String>;
    usage: S.Struct<{
        input_tokens: typeof S.Number;
        output_tokens: typeof S.Number;
        cache_creation_input_tokens: S.NullOr<typeof S.Number>;
        cache_read_input_tokens: S.NullOr<typeof S.Number>;
        cache_creation: S.NullOr<S.Struct<{
            ephemeral_5m_input_tokens: typeof S.Number;
            ephemeral_1h_input_tokens: typeof S.Number;
        }>>;
        server_tool_use: S.NullOr<S.Struct<{
            web_search_requests: typeof S.Number;
        }>>;
        service_tier: S.NullOr<typeof AnthropicMessagesResponseUsageServiceTier>;
    }>;
}, S.Struct.Encoded<{
    id: typeof S.String;
    type: typeof AnthropicMessagesResponseType;
    role: typeof AnthropicMessagesResponseRole;
    content: S.Array$<S.Union<[S.Struct<{
        type: S.Literal<["text"]>;
        text: typeof S.String;
        citations: S.NullOr<S.Array$<S.Union<[S.Struct<{
            type: S.Literal<["char_location"]>;
            cited_text: typeof S.String;
            document_index: typeof S.Number;
            document_title: S.NullOr<typeof S.String>;
            start_char_index: typeof S.Number;
            end_char_index: typeof S.Number;
            file_id: S.NullOr<typeof S.String>;
        }>, S.Struct<{
            type: S.Literal<["page_location"]>;
            cited_text: typeof S.String;
            document_index: typeof S.Number;
            document_title: S.NullOr<typeof S.String>;
            start_page_number: typeof S.Number;
            end_page_number: typeof S.Number;
            file_id: S.NullOr<typeof S.String>;
        }>, S.Struct<{
            type: S.Literal<["content_block_location"]>;
            cited_text: typeof S.String;
            document_index: typeof S.Number;
            document_title: S.NullOr<typeof S.String>;
            start_block_index: typeof S.Number;
            end_block_index: typeof S.Number;
            file_id: S.NullOr<typeof S.String>;
        }>, S.Struct<{
            type: S.Literal<["web_search_result_location"]>;
            cited_text: typeof S.String;
            encrypted_index: typeof S.String;
            title: S.NullOr<typeof S.String>;
            url: typeof S.String;
        }>, S.Struct<{
            type: S.Literal<["search_result_location"]>;
            cited_text: typeof S.String;
            search_result_index: typeof S.Number;
            source: typeof S.String;
            title: S.NullOr<typeof S.String>;
            start_block_index: typeof S.Number;
            end_block_index: typeof S.Number;
        }>]>>>;
    }>, S.Struct<{
        type: S.Literal<["tool_use"]>;
        id: typeof S.String;
        name: typeof S.String;
    }>, S.Struct<{
        type: S.Literal<["thinking"]>;
        thinking: typeof S.String;
        signature: typeof S.String;
    }>, S.Struct<{
        type: S.Literal<["redacted_thinking"]>;
        data: typeof S.String;
    }>, S.Struct<{
        type: S.Literal<["server_tool_use"]>;
        id: typeof S.String;
        name: S.Literal<["web_search"]>;
    }>, S.Struct<{
        type: S.Literal<["web_search_tool_result"]>;
        tool_use_id: typeof S.String;
        content: S.Union<[S.Array$<S.Struct<{
            type: S.Literal<["web_search_result"]>;
            encrypted_content: typeof S.String;
            page_age: S.NullOr<typeof S.String>;
            title: typeof S.String;
            url: typeof S.String;
        }>>, S.Struct<{
            type: S.Literal<["web_search_tool_result_error"]>;
            error_code: S.Literal<["invalid_tool_input", "unavailable", "max_uses_exceeded", "too_many_requests", "query_too_long"]>;
        }>]>;
    }>]>>;
    model: typeof S.String;
    stop_reason: S.NullOr<typeof AnthropicMessagesResponseStopReason>;
    stop_sequence: S.NullOr<typeof S.String>;
    usage: S.Struct<{
        input_tokens: typeof S.Number;
        output_tokens: typeof S.Number;
        cache_creation_input_tokens: S.NullOr<typeof S.Number>;
        cache_read_input_tokens: S.NullOr<typeof S.Number>;
        cache_creation: S.NullOr<S.Struct<{
            ephemeral_5m_input_tokens: typeof S.Number;
            ephemeral_1h_input_tokens: typeof S.Number;
        }>>;
        server_tool_use: S.NullOr<S.Struct<{
            web_search_requests: typeof S.Number;
        }>>;
        service_tier: S.NullOr<typeof AnthropicMessagesResponseUsageServiceTier>;
    }>;
}>, never, {
    readonly type: "message";
} & {
    readonly id: string;
} & {
    readonly content: readonly ({
        readonly type: "text";
        readonly text: string;
        readonly citations: readonly ({
            readonly type: "char_location";
            readonly file_id: string | null;
            readonly cited_text: string;
            readonly document_index: number;
            readonly document_title: string | null;
            readonly start_char_index: number;
            readonly end_char_index: number;
        } | {
            readonly type: "page_location";
            readonly file_id: string | null;
            readonly cited_text: string;
            readonly document_index: number;
            readonly document_title: string | null;
            readonly start_page_number: number;
            readonly end_page_number: number;
        } | {
            readonly type: "content_block_location";
            readonly file_id: string | null;
            readonly cited_text: string;
            readonly document_index: number;
            readonly document_title: string | null;
            readonly start_block_index: number;
            readonly end_block_index: number;
        } | {
            readonly type: "web_search_result_location";
            readonly url: string;
            readonly title: string | null;
            readonly cited_text: string;
            readonly encrypted_index: string;
        } | {
            readonly type: "search_result_location";
            readonly title: string | null;
            readonly cited_text: string;
            readonly start_block_index: number;
            readonly end_block_index: number;
            readonly search_result_index: number;
            readonly source: string;
        })[] | null;
    } | {
        readonly type: "tool_use";
        readonly id: string;
        readonly name: string;
    } | {
        readonly type: "thinking";
        readonly signature: string;
        readonly thinking: string;
    } | {
        readonly type: "redacted_thinking";
        readonly data: string;
    } | {
        readonly type: "server_tool_use";
        readonly id: string;
        readonly name: "web_search";
    } | {
        readonly type: "web_search_tool_result";
        readonly content: readonly {
            readonly type: "web_search_result";
            readonly encrypted_content: string;
            readonly url: string;
            readonly title: string;
            readonly page_age: string | null;
        }[] | {
            readonly type: "web_search_tool_result_error";
            readonly error_code: "invalid_tool_input" | "unavailable" | "max_uses_exceeded" | "too_many_requests" | "query_too_long";
        };
        readonly tool_use_id: string;
    })[];
} & {
    readonly role: "assistant";
} & {
    readonly model: string;
} & {
    readonly usage: {
        readonly service_tier: "priority" | "standard" | "batch" | null;
        readonly input_tokens: number;
        readonly output_tokens: number;
        readonly server_tool_use: {
            readonly web_search_requests: number;
        } | null;
        readonly cache_creation_input_tokens: number | null;
        readonly cache_read_input_tokens: number | null;
        readonly cache_creation: {
            readonly ephemeral_5m_input_tokens: number;
            readonly ephemeral_1h_input_tokens: number;
        } | null;
    };
} & {
    readonly stop_sequence: string | null;
} & {
    readonly stop_reason: "refusal" | "max_tokens" | "tool_use" | "end_turn" | "stop_sequence" | "pause_turn" | "model_context_window_exceeded" | null;
}, {}, {}>;
export declare class AnthropicMessagesResponse extends AnthropicMessagesResponse_base {
}
declare const CreateMessages400Type_base: S.Literal<["error"]>;
export declare class CreateMessages400Type extends CreateMessages400Type_base {
}
declare const CreateMessages400_base: S.Struct<{
    type: typeof CreateMessages400Type;
    error: S.Struct<{
        type: typeof S.String;
        message: typeof S.String;
    }>;
}>;
export declare class CreateMessages400 extends CreateMessages400_base {
}
declare const CreateMessages401Type_base: S.Literal<["error"]>;
export declare class CreateMessages401Type extends CreateMessages401Type_base {
}
declare const CreateMessages401_base: S.Struct<{
    type: typeof CreateMessages401Type;
    error: S.Struct<{
        type: typeof S.String;
        message: typeof S.String;
    }>;
}>;
export declare class CreateMessages401 extends CreateMessages401_base {
}
declare const CreateMessages403Type_base: S.Literal<["error"]>;
export declare class CreateMessages403Type extends CreateMessages403Type_base {
}
declare const CreateMessages403_base: S.Struct<{
    type: typeof CreateMessages403Type;
    error: S.Struct<{
        type: typeof S.String;
        message: typeof S.String;
    }>;
}>;
export declare class CreateMessages403 extends CreateMessages403_base {
}
declare const CreateMessages404Type_base: S.Literal<["error"]>;
export declare class CreateMessages404Type extends CreateMessages404Type_base {
}
declare const CreateMessages404_base: S.Struct<{
    type: typeof CreateMessages404Type;
    error: S.Struct<{
        type: typeof S.String;
        message: typeof S.String;
    }>;
}>;
export declare class CreateMessages404 extends CreateMessages404_base {
}
declare const CreateMessages429Type_base: S.Literal<["error"]>;
export declare class CreateMessages429Type extends CreateMessages429Type_base {
}
declare const CreateMessages429_base: S.Struct<{
    type: typeof CreateMessages429Type;
    error: S.Struct<{
        type: typeof S.String;
        message: typeof S.String;
    }>;
}>;
export declare class CreateMessages429 extends CreateMessages429_base {
}
declare const CreateMessages500Type_base: S.Literal<["error"]>;
export declare class CreateMessages500Type extends CreateMessages500Type_base {
}
declare const CreateMessages500_base: S.Struct<{
    type: typeof CreateMessages500Type;
    error: S.Struct<{
        type: typeof S.String;
        message: typeof S.String;
    }>;
}>;
export declare class CreateMessages500 extends CreateMessages500_base {
}
declare const CreateMessages503Type_base: S.Literal<["error"]>;
export declare class CreateMessages503Type extends CreateMessages503Type_base {
}
declare const CreateMessages503_base: S.Struct<{
    type: typeof CreateMessages503Type;
    error: S.Struct<{
        type: typeof S.String;
        message: typeof S.String;
    }>;
}>;
export declare class CreateMessages503 extends CreateMessages503_base {
}
declare const CreateMessages529Type_base: S.Literal<["error"]>;
export declare class CreateMessages529Type extends CreateMessages529Type_base {
}
declare const CreateMessages529_base: S.Struct<{
    type: typeof CreateMessages529Type;
    error: S.Struct<{
        type: typeof S.String;
        message: typeof S.String;
    }>;
}>;
export declare class CreateMessages529 extends CreateMessages529_base {
}
declare const GetUserActivityParams_base: S.Struct<{
    /**
     * Filter by a single UTC date in the last 30 days (YYYY-MM-DD format).
     */
    date: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}>;
export declare class GetUserActivityParams extends GetUserActivityParams_base {
}
declare const ActivityItem_base: S.Class<ActivityItem, {
    /**
     * Date of the activity (YYYY-MM-DD format)
     */
    date: typeof S.String;
    /**
     * Model slug (e.g., "openai/gpt-4.1")
     */
    model: typeof S.String;
    /**
     * Model permaslug (e.g., "openai/gpt-4.1-2025-04-14")
     */
    model_permaslug: typeof S.String;
    /**
     * Unique identifier for the endpoint
     */
    endpoint_id: typeof S.String;
    /**
     * Name of the provider serving this endpoint
     */
    provider_name: typeof S.String;
    /**
     * Total cost in USD (OpenRouter credits spent)
     */
    usage: typeof S.Number;
    /**
     * BYOK inference cost in USD (external credits spent)
     */
    byok_usage_inference: typeof S.Number;
    /**
     * Number of requests made
     */
    requests: typeof S.Number;
    /**
     * Total prompt tokens used
     */
    prompt_tokens: typeof S.Number;
    /**
     * Total completion tokens generated
     */
    completion_tokens: typeof S.Number;
    /**
     * Total reasoning tokens used
     */
    reasoning_tokens: typeof S.Number;
}, S.Struct.Encoded<{
    /**
     * Date of the activity (YYYY-MM-DD format)
     */
    date: typeof S.String;
    /**
     * Model slug (e.g., "openai/gpt-4.1")
     */
    model: typeof S.String;
    /**
     * Model permaslug (e.g., "openai/gpt-4.1-2025-04-14")
     */
    model_permaslug: typeof S.String;
    /**
     * Unique identifier for the endpoint
     */
    endpoint_id: typeof S.String;
    /**
     * Name of the provider serving this endpoint
     */
    provider_name: typeof S.String;
    /**
     * Total cost in USD (OpenRouter credits spent)
     */
    usage: typeof S.Number;
    /**
     * BYOK inference cost in USD (external credits spent)
     */
    byok_usage_inference: typeof S.Number;
    /**
     * Number of requests made
     */
    requests: typeof S.Number;
    /**
     * Total prompt tokens used
     */
    prompt_tokens: typeof S.Number;
    /**
     * Total completion tokens generated
     */
    completion_tokens: typeof S.Number;
    /**
     * Total reasoning tokens used
     */
    reasoning_tokens: typeof S.Number;
}>, never, {
    readonly model: string;
} & {
    readonly reasoning_tokens: number;
} & {
    readonly usage: number;
} & {
    readonly date: string;
} & {
    readonly model_permaslug: string;
} & {
    readonly endpoint_id: string;
} & {
    readonly provider_name: string;
} & {
    readonly byok_usage_inference: number;
} & {
    readonly requests: number;
} & {
    readonly prompt_tokens: number;
} & {
    readonly completion_tokens: number;
}, {}, {}>;
export declare class ActivityItem extends ActivityItem_base {
}
declare const GetUserActivity200_base: S.Struct<{
    /**
     * List of activity items
     */
    data: S.Array$<typeof ActivityItem>;
}>;
export declare class GetUserActivity200 extends GetUserActivity200_base {
}
declare const ForbiddenResponseErrorData_base: S.Class<ForbiddenResponseErrorData, {
    code: typeof S.Int;
    message: typeof S.String;
    metadata: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    code: typeof S.Int;
    message: typeof S.String;
    metadata: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
        nullable: true;
    }>;
}>, never, {
    readonly message: string;
} & {
    readonly metadata?: {
        readonly [x: string]: unknown;
    } | undefined;
} & {
    readonly code: number;
}, {}, {}>;
/**
 * Error data for ForbiddenResponse
 */
export declare class ForbiddenResponseErrorData extends ForbiddenResponseErrorData_base {
}
declare const ForbiddenResponse_base: S.Class<ForbiddenResponse, {
    error: typeof ForbiddenResponseErrorData;
    user_id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    error: typeof ForbiddenResponseErrorData;
    user_id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}>, never, {
    readonly error: ForbiddenResponseErrorData;
} & {
    readonly user_id?: string | undefined;
}, {}, {}>;
/**
 * Forbidden - Authentication successful but insufficient permissions
 */
export declare class ForbiddenResponse extends ForbiddenResponse_base {
}
declare const GetCredits200_base: S.Struct<{
    data: S.Struct<{
        /**
         * Total credits purchased
         */
        total_credits: typeof S.Number;
        /**
         * Total credits used
         */
        total_usage: typeof S.Number;
    }>;
}>;
/**
 * Total credits purchased and used
 */
export declare class GetCredits200 extends GetCredits200_base {
}
declare const CreateChargeRequestChainId_base: S.Literal<[1, 137, 8453]>;
export declare class CreateChargeRequestChainId extends CreateChargeRequestChainId_base {
}
declare const CreateChargeRequest_base: S.Class<CreateChargeRequest, {
    amount: typeof S.Number;
    sender: typeof S.String;
    chain_id: typeof CreateChargeRequestChainId;
}, S.Struct.Encoded<{
    amount: typeof S.Number;
    sender: typeof S.String;
    chain_id: typeof CreateChargeRequestChainId;
}>, never, {
    readonly amount: number;
} & {
    readonly sender: string;
} & {
    readonly chain_id: 1 | 137 | 8453;
}, {}, {}>;
/**
 * Create a Coinbase charge for crypto payment
 */
export declare class CreateChargeRequest extends CreateChargeRequest_base {
}
declare const CreateCoinbaseCharge200_base: S.Struct<{
    data: S.Struct<{
        id: typeof S.String;
        created_at: typeof S.String;
        expires_at: typeof S.String;
        web3_data: S.Struct<{
            transfer_intent: S.Struct<{
                call_data: S.Struct<{
                    deadline: typeof S.String;
                    fee_amount: typeof S.String;
                    id: typeof S.String;
                    operator: typeof S.String;
                    prefix: typeof S.String;
                    recipient: typeof S.String;
                    recipient_amount: typeof S.String;
                    recipient_currency: typeof S.String;
                    refund_destination: typeof S.String;
                    signature: typeof S.String;
                }>;
                metadata: S.Struct<{
                    chain_id: typeof S.Number;
                    contract_address: typeof S.String;
                    sender: typeof S.String;
                }>;
            }>;
        }>;
    }>;
}>;
export declare class CreateCoinbaseCharge200 extends CreateCoinbaseCharge200_base {
}
declare const CreateEmbeddingsRequestEncodingFormat_base: S.Literal<["float", "base64"]>;
export declare class CreateEmbeddingsRequestEncodingFormat extends CreateEmbeddingsRequestEncodingFormat_base {
}
declare const ProviderPreferencesSort_base: S.Literal<["price", "throughput", "latency"]>;
/**
 * The sorting strategy to use for this request, if "order" is not specified. When set, no load balancing is performed.
 */
export declare class ProviderPreferencesSort extends ProviderPreferencesSort_base {
}
declare const ProviderPreferences_base: S.Class<ProviderPreferences, {
    /**
     * Whether to allow backup providers to serve requests
     * - true: (default) when the primary provider (or your custom providers in "order") is unavailable, use the next best provider.
     * - false: use only the primary/custom provider, and return the upstream error if it's unavailable.
     */
    allow_fallbacks: S.optionalWith<typeof S.Boolean, {
        nullable: true;
    }>;
    /**
     * Whether to filter providers to only those that support the parameters you've provided. If this setting is omitted or set to false, then providers will receive only the parameters they support, and ignore the rest.
     */
    require_parameters: S.optionalWith<typeof S.Boolean, {
        nullable: true;
    }>;
    data_collection: S.optionalWith<typeof DataCollection, {
        nullable: true;
    }>;
    /**
     * Whether to restrict routing to only ZDR (Zero Data Retention) endpoints. When true, only endpoints that do not retain prompts will be used.
     */
    zdr: S.optionalWith<typeof S.Boolean, {
        nullable: true;
    }>;
    /**
     * Whether to restrict routing to only models that allow text distillation. When true, only models where the author has allowed distillation will be used.
     */
    enforce_distillable_text: S.optionalWith<typeof S.Boolean, {
        nullable: true;
    }>;
    /**
     * An ordered list of provider slugs. The router will attempt to use the first provider in the subset of this list that supports your requested model, and fall back to the next if it is unavailable. If no providers are available, the request will fail with an error message.
     */
    order: S.optionalWith<S.Array$<S.Union<[typeof ProviderName, typeof S.String]>>, {
        nullable: true;
    }>;
    /**
     * List of provider slugs to allow. If provided, this list is merged with your account-wide allowed provider settings for this request.
     */
    only: S.optionalWith<S.Array$<S.Union<[typeof ProviderName, typeof S.String]>>, {
        nullable: true;
    }>;
    /**
     * List of provider slugs to ignore. If provided, this list is merged with your account-wide ignored provider settings for this request.
     */
    ignore: S.optionalWith<S.Array$<S.Union<[typeof ProviderName, typeof S.String]>>, {
        nullable: true;
    }>;
    /**
     * A list of quantization levels to filter the provider by.
     */
    quantizations: S.optionalWith<S.Array$<typeof Quantization>, {
        nullable: true;
    }>;
    sort: S.optionalWith<typeof ProviderPreferencesSort, {
        nullable: true;
    }>;
    /**
     * The object specifying the maximum price you want to pay for this request. USD price per million tokens, for prompt and completion.
     */
    max_price: S.optionalWith<S.Struct<{
        prompt: S.optionalWith<typeof BigNumberUnion, {
            nullable: true;
        }>;
        completion: S.optionalWith<typeof BigNumberUnion, {
            nullable: true;
        }>;
        image: S.optionalWith<typeof BigNumberUnion, {
            nullable: true;
        }>;
        audio: S.optionalWith<typeof BigNumberUnion, {
            nullable: true;
        }>;
        request: S.optionalWith<typeof BigNumberUnion, {
            nullable: true;
        }>;
    }>, {
        nullable: true;
    }>;
    preferred_min_throughput: S.optionalWith<typeof PreferredMinThroughput, {
        nullable: true;
    }>;
    preferred_max_latency: S.optionalWith<typeof PreferredMaxLatency, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    /**
     * Whether to allow backup providers to serve requests
     * - true: (default) when the primary provider (or your custom providers in "order") is unavailable, use the next best provider.
     * - false: use only the primary/custom provider, and return the upstream error if it's unavailable.
     */
    allow_fallbacks: S.optionalWith<typeof S.Boolean, {
        nullable: true;
    }>;
    /**
     * Whether to filter providers to only those that support the parameters you've provided. If this setting is omitted or set to false, then providers will receive only the parameters they support, and ignore the rest.
     */
    require_parameters: S.optionalWith<typeof S.Boolean, {
        nullable: true;
    }>;
    data_collection: S.optionalWith<typeof DataCollection, {
        nullable: true;
    }>;
    /**
     * Whether to restrict routing to only ZDR (Zero Data Retention) endpoints. When true, only endpoints that do not retain prompts will be used.
     */
    zdr: S.optionalWith<typeof S.Boolean, {
        nullable: true;
    }>;
    /**
     * Whether to restrict routing to only models that allow text distillation. When true, only models where the author has allowed distillation will be used.
     */
    enforce_distillable_text: S.optionalWith<typeof S.Boolean, {
        nullable: true;
    }>;
    /**
     * An ordered list of provider slugs. The router will attempt to use the first provider in the subset of this list that supports your requested model, and fall back to the next if it is unavailable. If no providers are available, the request will fail with an error message.
     */
    order: S.optionalWith<S.Array$<S.Union<[typeof ProviderName, typeof S.String]>>, {
        nullable: true;
    }>;
    /**
     * List of provider slugs to allow. If provided, this list is merged with your account-wide allowed provider settings for this request.
     */
    only: S.optionalWith<S.Array$<S.Union<[typeof ProviderName, typeof S.String]>>, {
        nullable: true;
    }>;
    /**
     * List of provider slugs to ignore. If provided, this list is merged with your account-wide ignored provider settings for this request.
     */
    ignore: S.optionalWith<S.Array$<S.Union<[typeof ProviderName, typeof S.String]>>, {
        nullable: true;
    }>;
    /**
     * A list of quantization levels to filter the provider by.
     */
    quantizations: S.optionalWith<S.Array$<typeof Quantization>, {
        nullable: true;
    }>;
    sort: S.optionalWith<typeof ProviderPreferencesSort, {
        nullable: true;
    }>;
    /**
     * The object specifying the maximum price you want to pay for this request. USD price per million tokens, for prompt and completion.
     */
    max_price: S.optionalWith<S.Struct<{
        prompt: S.optionalWith<typeof BigNumberUnion, {
            nullable: true;
        }>;
        completion: S.optionalWith<typeof BigNumberUnion, {
            nullable: true;
        }>;
        image: S.optionalWith<typeof BigNumberUnion, {
            nullable: true;
        }>;
        audio: S.optionalWith<typeof BigNumberUnion, {
            nullable: true;
        }>;
        request: S.optionalWith<typeof BigNumberUnion, {
            nullable: true;
        }>;
    }>, {
        nullable: true;
    }>;
    preferred_min_throughput: S.optionalWith<typeof PreferredMinThroughput, {
        nullable: true;
    }>;
    preferred_max_latency: S.optionalWith<typeof PreferredMaxLatency, {
        nullable: true;
    }>;
}>, never, {
    readonly sort?: "price" | "throughput" | "latency" | undefined;
} & {
    readonly allow_fallbacks?: boolean | undefined;
} & {
    readonly require_parameters?: boolean | undefined;
} & {
    readonly data_collection?: "deny" | "allow" | undefined;
} & {
    readonly zdr?: boolean | undefined;
} & {
    readonly enforce_distillable_text?: boolean | undefined;
} & {
    readonly order?: readonly string[] | undefined;
} & {
    readonly only?: readonly string[] | undefined;
} & {
    readonly ignore?: readonly string[] | undefined;
} & {
    readonly quantizations?: readonly ("unknown" | "int4" | "int8" | "fp4" | "fp6" | "fp8" | "fp16" | "bf16" | "fp32")[] | undefined;
} & {
    readonly max_price?: {
        readonly image?: string | undefined;
        readonly prompt?: string | undefined;
        readonly completion?: string | undefined;
        readonly audio?: string | undefined;
        readonly request?: string | undefined;
    } | undefined;
} & {
    readonly preferred_min_throughput?: number | PercentileThroughputCutoffs | undefined;
} & {
    readonly preferred_max_latency?: number | PercentileLatencyCutoffs | undefined;
}, {}, {}>;
/**
 * Provider routing preferences for the request.
 */
export declare class ProviderPreferences extends ProviderPreferences_base {
}
declare const CreateEmbeddingsRequest_base: S.Class<CreateEmbeddingsRequest, {
    input: S.Union<[typeof S.String, S.Array$<typeof S.String>, S.Array$<typeof S.Number>, S.Array$<S.Array$<typeof S.Number>>, S.Array$<S.Struct<{
        content: S.Array$<S.Union<[S.Struct<{
            type: S.Literal<["text"]>;
            text: typeof S.String;
        }>, S.Struct<{
            type: S.Literal<["image_url"]>;
            image_url: S.Struct<{
                url: typeof S.String;
            }>;
        }>]>>;
    }>>]>;
    model: typeof S.String;
    encoding_format: S.optionalWith<typeof CreateEmbeddingsRequestEncodingFormat, {
        nullable: true;
    }>;
    dimensions: S.optionalWith<S.filter<typeof S.Int>, {
        nullable: true;
    }>;
    user: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    provider: S.optionalWith<typeof ProviderPreferences, {
        nullable: true;
    }>;
    input_type: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    input: S.Union<[typeof S.String, S.Array$<typeof S.String>, S.Array$<typeof S.Number>, S.Array$<S.Array$<typeof S.Number>>, S.Array$<S.Struct<{
        content: S.Array$<S.Union<[S.Struct<{
            type: S.Literal<["text"]>;
            text: typeof S.String;
        }>, S.Struct<{
            type: S.Literal<["image_url"]>;
            image_url: S.Struct<{
                url: typeof S.String;
            }>;
        }>]>>;
    }>>]>;
    model: typeof S.String;
    encoding_format: S.optionalWith<typeof CreateEmbeddingsRequestEncodingFormat, {
        nullable: true;
    }>;
    dimensions: S.optionalWith<S.filter<typeof S.Int>, {
        nullable: true;
    }>;
    user: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    provider: S.optionalWith<typeof ProviderPreferences, {
        nullable: true;
    }>;
    input_type: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}>, never, {
    readonly model: string;
} & {
    readonly input: string | readonly number[] | readonly (readonly number[])[] | readonly string[] | readonly {
        readonly content: readonly ({
            readonly type: "text";
            readonly text: string;
        } | {
            readonly type: "image_url";
            readonly image_url: {
                readonly url: string;
            };
        })[];
    }[];
} & {
    readonly provider?: ProviderPreferences | undefined;
} & {
    readonly user?: string | undefined;
} & {
    readonly encoding_format?: "base64" | "float" | undefined;
} & {
    readonly dimensions?: number | undefined;
} & {
    readonly input_type?: string | undefined;
}, {}, {}>;
export declare class CreateEmbeddingsRequest extends CreateEmbeddingsRequest_base {
}
declare const CreateEmbeddings200Object_base: S.Literal<["list"]>;
export declare class CreateEmbeddings200Object extends CreateEmbeddings200Object_base {
}
declare const CreateEmbeddings200_base: S.Struct<{
    id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    object: typeof CreateEmbeddings200Object;
    data: S.Array$<S.Struct<{
        object: S.Literal<["embedding"]>;
        embedding: S.Union<[S.Array$<typeof S.Number>, typeof S.String]>;
        index: S.optionalWith<typeof S.Number, {
            nullable: true;
        }>;
    }>>;
    model: typeof S.String;
    usage: S.optionalWith<S.Struct<{
        prompt_tokens: typeof S.Number;
        total_tokens: typeof S.Number;
        cost: S.optionalWith<typeof S.Number, {
            nullable: true;
        }>;
    }>, {
        nullable: true;
    }>;
}>;
export declare class CreateEmbeddings200 extends CreateEmbeddings200_base {
}
declare const PublicPricing_base: S.Class<PublicPricing, {
    prompt: typeof BigNumberUnion;
    completion: typeof BigNumberUnion;
    request: S.optionalWith<typeof BigNumberUnion, {
        nullable: true;
    }>;
    image: S.optionalWith<typeof BigNumberUnion, {
        nullable: true;
    }>;
    image_token: S.optionalWith<typeof BigNumberUnion, {
        nullable: true;
    }>;
    image_output: S.optionalWith<typeof BigNumberUnion, {
        nullable: true;
    }>;
    audio: S.optionalWith<typeof BigNumberUnion, {
        nullable: true;
    }>;
    audio_output: S.optionalWith<typeof BigNumberUnion, {
        nullable: true;
    }>;
    input_audio_cache: S.optionalWith<typeof BigNumberUnion, {
        nullable: true;
    }>;
    web_search: S.optionalWith<typeof BigNumberUnion, {
        nullable: true;
    }>;
    internal_reasoning: S.optionalWith<typeof BigNumberUnion, {
        nullable: true;
    }>;
    input_cache_read: S.optionalWith<typeof BigNumberUnion, {
        nullable: true;
    }>;
    input_cache_write: S.optionalWith<typeof BigNumberUnion, {
        nullable: true;
    }>;
    discount: S.optionalWith<typeof S.Number, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    prompt: typeof BigNumberUnion;
    completion: typeof BigNumberUnion;
    request: S.optionalWith<typeof BigNumberUnion, {
        nullable: true;
    }>;
    image: S.optionalWith<typeof BigNumberUnion, {
        nullable: true;
    }>;
    image_token: S.optionalWith<typeof BigNumberUnion, {
        nullable: true;
    }>;
    image_output: S.optionalWith<typeof BigNumberUnion, {
        nullable: true;
    }>;
    audio: S.optionalWith<typeof BigNumberUnion, {
        nullable: true;
    }>;
    audio_output: S.optionalWith<typeof BigNumberUnion, {
        nullable: true;
    }>;
    input_audio_cache: S.optionalWith<typeof BigNumberUnion, {
        nullable: true;
    }>;
    web_search: S.optionalWith<typeof BigNumberUnion, {
        nullable: true;
    }>;
    internal_reasoning: S.optionalWith<typeof BigNumberUnion, {
        nullable: true;
    }>;
    input_cache_read: S.optionalWith<typeof BigNumberUnion, {
        nullable: true;
    }>;
    input_cache_write: S.optionalWith<typeof BigNumberUnion, {
        nullable: true;
    }>;
    discount: S.optionalWith<typeof S.Number, {
        nullable: true;
    }>;
}>, never, {
    readonly web_search?: string | undefined;
} & {
    readonly image?: string | undefined;
} & {
    readonly prompt: string;
} & {
    readonly completion: string;
} & {
    readonly audio?: string | undefined;
} & {
    readonly request?: string | undefined;
} & {
    readonly image_token?: string | undefined;
} & {
    readonly image_output?: string | undefined;
} & {
    readonly audio_output?: string | undefined;
} & {
    readonly input_audio_cache?: string | undefined;
} & {
    readonly internal_reasoning?: string | undefined;
} & {
    readonly input_cache_read?: string | undefined;
} & {
    readonly input_cache_write?: string | undefined;
} & {
    readonly discount?: number | undefined;
}, {}, {}>;
/**
 * Pricing information for the model
 */
export declare class PublicPricing extends PublicPricing_base {
}
declare const ModelGroup_base: S.Literal<["Router", "Media", "Other", "GPT", "Claude", "Gemini", "Grok", "Cohere", "Nova", "Qwen", "Yi", "DeepSeek", "Mistral", "Llama2", "Llama3", "Llama4", "PaLM", "RWKV", "Qwen3"]>;
/**
 * Tokenizer type used by the model
 */
export declare class ModelGroup extends ModelGroup_base {
}
declare const ModelArchitectureInstructType_base: S.Literal<["none", "airoboros", "alpaca", "alpaca-modif", "chatml", "claude", "code-llama", "gemma", "llama2", "llama3", "mistral", "nemotron", "neural", "openchat", "phi3", "rwkv", "vicuna", "zephyr", "deepseek-r1", "deepseek-v3.1", "qwq", "qwen3"]>;
/**
 * Instruction format type
 */
export declare class ModelArchitectureInstructType extends ModelArchitectureInstructType_base {
}
declare const InputModality_base: S.Literal<["text", "image", "file", "audio", "video"]>;
export declare class InputModality extends InputModality_base {
}
declare const OutputModality_base: S.Literal<["text", "image", "embeddings", "audio"]>;
export declare class OutputModality extends OutputModality_base {
}
declare const ModelArchitecture_base: S.Class<ModelArchitecture, {
    tokenizer: S.optionalWith<typeof ModelGroup, {
        nullable: true;
    }>;
    /**
     * Instruction format type
     */
    instruct_type: S.optionalWith<typeof ModelArchitectureInstructType, {
        nullable: true;
    }>;
    /**
     * Primary modality of the model
     */
    modality: S.NullOr<typeof S.String>;
    /**
     * Supported input modalities
     */
    input_modalities: S.Array$<typeof InputModality>;
    /**
     * Supported output modalities
     */
    output_modalities: S.Array$<typeof OutputModality>;
}, S.Struct.Encoded<{
    tokenizer: S.optionalWith<typeof ModelGroup, {
        nullable: true;
    }>;
    /**
     * Instruction format type
     */
    instruct_type: S.optionalWith<typeof ModelArchitectureInstructType, {
        nullable: true;
    }>;
    /**
     * Primary modality of the model
     */
    modality: S.NullOr<typeof S.String>;
    /**
     * Supported input modalities
     */
    input_modalities: S.Array$<typeof InputModality>;
    /**
     * Supported output modalities
     */
    output_modalities: S.Array$<typeof OutputModality>;
}>, never, {
    readonly tokenizer?: "Cohere" | "DeepSeek" | "Mistral" | "Router" | "Media" | "Other" | "GPT" | "Claude" | "Gemini" | "Grok" | "Nova" | "Qwen" | "Yi" | "Llama2" | "Llama3" | "Llama4" | "PaLM" | "RWKV" | "Qwen3" | undefined;
} & {
    readonly instruct_type?: "none" | "airoboros" | "alpaca" | "alpaca-modif" | "chatml" | "claude" | "code-llama" | "gemma" | "llama2" | "llama3" | "mistral" | "nemotron" | "neural" | "openchat" | "phi3" | "rwkv" | "vicuna" | "zephyr" | "deepseek-r1" | "deepseek-v3.1" | "qwq" | "qwen3" | undefined;
} & {
    readonly modality: string | null;
} & {
    readonly input_modalities: readonly ("text" | "file" | "image" | "audio" | "video")[];
} & {
    readonly output_modalities: readonly ("text" | "image" | "audio" | "embeddings")[];
}, {}, {}>;
/**
 * Model architecture information
 */
export declare class ModelArchitecture extends ModelArchitecture_base {
}
declare const TopProviderInfo_base: S.Class<TopProviderInfo, {
    /**
     * Context length from the top provider
     */
    context_length: S.optionalWith<typeof S.Number, {
        nullable: true;
    }>;
    /**
     * Maximum completion tokens from the top provider
     */
    max_completion_tokens: S.optionalWith<typeof S.Number, {
        nullable: true;
    }>;
    /**
     * Whether the top provider moderates content
     */
    is_moderated: typeof S.Boolean;
}, S.Struct.Encoded<{
    /**
     * Context length from the top provider
     */
    context_length: S.optionalWith<typeof S.Number, {
        nullable: true;
    }>;
    /**
     * Maximum completion tokens from the top provider
     */
    max_completion_tokens: S.optionalWith<typeof S.Number, {
        nullable: true;
    }>;
    /**
     * Whether the top provider moderates content
     */
    is_moderated: typeof S.Boolean;
}>, never, {
    readonly is_moderated: boolean;
} & {
    readonly context_length?: number | undefined;
} & {
    readonly max_completion_tokens?: number | undefined;
}, {}, {}>;
/**
 * Information about the top provider for this model
 */
export declare class TopProviderInfo extends TopProviderInfo_base {
}
declare const PerRequestLimits_base: S.Class<PerRequestLimits, {
    /**
     * Maximum prompt tokens per request
     */
    prompt_tokens: typeof S.Number;
    /**
     * Maximum completion tokens per request
     */
    completion_tokens: typeof S.Number;
}, S.Struct.Encoded<{
    /**
     * Maximum prompt tokens per request
     */
    prompt_tokens: typeof S.Number;
    /**
     * Maximum completion tokens per request
     */
    completion_tokens: typeof S.Number;
}>, never, {
    readonly prompt_tokens: number;
} & {
    readonly completion_tokens: number;
}, {}, {}>;
/**
 * Per-request token limits
 */
export declare class PerRequestLimits extends PerRequestLimits_base {
}
declare const Parameter_base: S.Literal<["temperature", "top_p", "top_k", "min_p", "top_a", "frequency_penalty", "presence_penalty", "repetition_penalty", "max_tokens", "logit_bias", "logprobs", "top_logprobs", "seed", "response_format", "structured_outputs", "stop", "tools", "tool_choice", "parallel_tool_calls", "include_reasoning", "reasoning", "reasoning_effort", "web_search_options", "verbosity"]>;
export declare class Parameter extends Parameter_base {
}
declare const DefaultParameters_base: S.Class<DefaultParameters, {
    temperature: S.optionalWith<S.filter<S.filter<typeof S.Number>>, {
        nullable: true;
    }>;
    top_p: S.optionalWith<S.filter<S.filter<typeof S.Number>>, {
        nullable: true;
    }>;
    frequency_penalty: S.optionalWith<S.filter<S.filter<typeof S.Number>>, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    temperature: S.optionalWith<S.filter<S.filter<typeof S.Number>>, {
        nullable: true;
    }>;
    top_p: S.optionalWith<S.filter<S.filter<typeof S.Number>>, {
        nullable: true;
    }>;
    frequency_penalty: S.optionalWith<S.filter<S.filter<typeof S.Number>>, {
        nullable: true;
    }>;
}>, never, {
    readonly temperature?: number | undefined;
} & {
    readonly top_p?: number | undefined;
} & {
    readonly frequency_penalty?: number | undefined;
}, {}, {}>;
/**
 * Default parameters for this model
 */
export declare class DefaultParameters extends DefaultParameters_base {
}
declare const Model_base: S.Class<Model, {
    /**
     * Unique identifier for the model
     */
    id: typeof S.String;
    /**
     * Canonical slug for the model
     */
    canonical_slug: typeof S.String;
    /**
     * Hugging Face model identifier, if applicable
     */
    hugging_face_id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    /**
     * Display name of the model
     */
    name: typeof S.String;
    /**
     * Unix timestamp of when the model was created
     */
    created: typeof S.Number;
    /**
     * Description of the model
     */
    description: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    pricing: typeof PublicPricing;
    /**
     * Maximum context length in tokens
     */
    context_length: S.NullOr<typeof S.Number>;
    architecture: typeof ModelArchitecture;
    top_provider: typeof TopProviderInfo;
    per_request_limits: S.NullOr<typeof PerRequestLimits>;
    /**
     * List of supported parameters for this model
     */
    supported_parameters: S.Array$<typeof Parameter>;
    default_parameters: S.NullOr<typeof DefaultParameters>;
    /**
     * The date after which the model may be removed. ISO 8601 date string (YYYY-MM-DD) or null if no expiration.
     */
    expiration_date: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    /**
     * Unique identifier for the model
     */
    id: typeof S.String;
    /**
     * Canonical slug for the model
     */
    canonical_slug: typeof S.String;
    /**
     * Hugging Face model identifier, if applicable
     */
    hugging_face_id: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    /**
     * Display name of the model
     */
    name: typeof S.String;
    /**
     * Unix timestamp of when the model was created
     */
    created: typeof S.Number;
    /**
     * Description of the model
     */
    description: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    pricing: typeof PublicPricing;
    /**
     * Maximum context length in tokens
     */
    context_length: S.NullOr<typeof S.Number>;
    architecture: typeof ModelArchitecture;
    top_provider: typeof TopProviderInfo;
    per_request_limits: S.NullOr<typeof PerRequestLimits>;
    /**
     * List of supported parameters for this model
     */
    supported_parameters: S.Array$<typeof Parameter>;
    default_parameters: S.NullOr<typeof DefaultParameters>;
    /**
     * The date after which the model may be removed. ISO 8601 date string (YYYY-MM-DD) or null if no expiration.
     */
    expiration_date: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}>, never, {
    readonly id: string;
} & {
    readonly name: string;
} & {
    readonly description?: string | undefined;
} & {
    readonly context_length: number | null;
} & {
    readonly canonical_slug: string;
} & {
    readonly created: number;
} & {
    readonly pricing: PublicPricing;
} & {
    readonly architecture: ModelArchitecture;
} & {
    readonly top_provider: TopProviderInfo;
} & {
    readonly hugging_face_id?: string | undefined;
} & {
    readonly per_request_limits: PerRequestLimits | null;
} & {
    readonly supported_parameters: readonly ("reasoning" | "logprobs" | "top_logprobs" | "verbosity" | "max_tokens" | "tools" | "tool_choice" | "parallel_tool_calls" | "temperature" | "top_p" | "presence_penalty" | "frequency_penalty" | "top_k" | "min_p" | "top_a" | "repetition_penalty" | "logit_bias" | "seed" | "response_format" | "structured_outputs" | "stop" | "include_reasoning" | "reasoning_effort" | "web_search_options")[];
} & {
    readonly default_parameters: DefaultParameters | null;
} & {
    readonly expiration_date?: string | undefined;
}, {}, {}>;
/**
 * Information about an AI model available on OpenRouter
 */
export declare class Model extends Model_base {
}
declare const ModelsListResponseData_base: S.Array$<typeof Model>;
/**
 * List of available models
 */
export declare class ModelsListResponseData extends ModelsListResponseData_base {
}
declare const ModelsListResponse_base: S.Class<ModelsListResponse, {
    data: typeof ModelsListResponseData;
}, S.Struct.Encoded<{
    data: typeof ModelsListResponseData;
}>, never, {
    readonly data: readonly Model[];
}, {}, {}>;
/**
 * List of available models
 */
export declare class ModelsListResponse extends ModelsListResponse_base {
}
declare const GetGenerationParams_base: S.Struct<{
    id: S.filter<typeof S.String>;
}>;
export declare class GetGenerationParams extends GetGenerationParams_base {
}
declare const GetGeneration200DataApiType_base: S.Literal<["completions", "embeddings"]>;
/**
 * Type of API used for the generation
 */
export declare class GetGeneration200DataApiType extends GetGeneration200DataApiType_base {
}
declare const GetGeneration200_base: S.Struct<{
    /**
     * Generation data
     */
    data: S.Struct<{
        /**
         * Unique identifier for the generation
         */
        id: typeof S.String;
        /**
         * Upstream provider's identifier for this generation
         */
        upstream_id: S.NullOr<typeof S.String>;
        /**
         * Total cost of the generation in USD
         */
        total_cost: typeof S.Number;
        /**
         * Discount applied due to caching
         */
        cache_discount: S.NullOr<typeof S.Number>;
        /**
         * Cost charged by the upstream provider
         */
        upstream_inference_cost: S.NullOr<typeof S.Number>;
        /**
         * ISO 8601 timestamp of when the generation was created
         */
        created_at: typeof S.String;
        /**
         * Model used for the generation
         */
        model: typeof S.String;
        /**
         * ID of the app that made the request
         */
        app_id: S.NullOr<typeof S.Number>;
        /**
         * Whether the response was streamed
         */
        streamed: S.NullOr<typeof S.Boolean>;
        /**
         * Whether the generation was cancelled
         */
        cancelled: S.NullOr<typeof S.Boolean>;
        /**
         * Name of the provider that served the request
         */
        provider_name: S.NullOr<typeof S.String>;
        /**
         * Total latency in milliseconds
         */
        latency: S.NullOr<typeof S.Number>;
        /**
         * Moderation latency in milliseconds
         */
        moderation_latency: S.NullOr<typeof S.Number>;
        /**
         * Time taken for generation in milliseconds
         */
        generation_time: S.NullOr<typeof S.Number>;
        /**
         * Reason the generation finished
         */
        finish_reason: S.NullOr<typeof S.String>;
        /**
         * Number of tokens in the prompt
         */
        tokens_prompt: S.NullOr<typeof S.Number>;
        /**
         * Number of tokens in the completion
         */
        tokens_completion: S.NullOr<typeof S.Number>;
        /**
         * Native prompt tokens as reported by provider
         */
        native_tokens_prompt: S.NullOr<typeof S.Number>;
        /**
         * Native completion tokens as reported by provider
         */
        native_tokens_completion: S.NullOr<typeof S.Number>;
        /**
         * Native completion image tokens as reported by provider
         */
        native_tokens_completion_images: S.NullOr<typeof S.Number>;
        /**
         * Native reasoning tokens as reported by provider
         */
        native_tokens_reasoning: S.NullOr<typeof S.Number>;
        /**
         * Native cached tokens as reported by provider
         */
        native_tokens_cached: S.NullOr<typeof S.Number>;
        /**
         * Number of media items in the prompt
         */
        num_media_prompt: S.NullOr<typeof S.Number>;
        /**
         * Number of audio inputs in the prompt
         */
        num_input_audio_prompt: S.NullOr<typeof S.Number>;
        /**
         * Number of media items in the completion
         */
        num_media_completion: S.NullOr<typeof S.Number>;
        /**
         * Number of search results included
         */
        num_search_results: S.NullOr<typeof S.Number>;
        /**
         * Origin URL of the request
         */
        origin: typeof S.String;
        /**
         * Usage amount in USD
         */
        usage: typeof S.Number;
        /**
         * Whether this used bring-your-own-key
         */
        is_byok: typeof S.Boolean;
        /**
         * Native finish reason as reported by provider
         */
        native_finish_reason: S.NullOr<typeof S.String>;
        /**
         * External user identifier
         */
        external_user: S.NullOr<typeof S.String>;
        /**
         * Type of API used for the generation
         */
        api_type: S.NullOr<typeof GetGeneration200DataApiType>;
        /**
         * Router used for the request (e.g., openrouter/auto)
         */
        router: S.NullOr<typeof S.String>;
    }>;
}>;
/**
 * Generation response
 */
export declare class GetGeneration200 extends GetGeneration200_base {
}
declare const ModelsCountResponse_base: S.Class<ModelsCountResponse, {
    /**
     * Model count data
     */
    data: S.Struct<{
        /**
         * Total number of available models
         */
        count: typeof S.Number;
    }>;
}, S.Struct.Encoded<{
    /**
     * Model count data
     */
    data: S.Struct<{
        /**
         * Total number of available models
         */
        count: typeof S.Number;
    }>;
}>, never, {
    readonly data: {
        readonly count: number;
    };
}, {}, {}>;
/**
 * Model count data
 */
export declare class ModelsCountResponse extends ModelsCountResponse_base {
}
declare const GetModelsParamsCategory_base: S.Literal<["programming", "roleplay", "marketing", "marketing/seo", "technology", "science", "translation", "legal", "finance", "health", "trivia", "academia"]>;
/**
 * Filter models by use case category
 */
export declare class GetModelsParamsCategory extends GetModelsParamsCategory_base {
}
declare const GetModelsParams_base: S.Struct<{
    /**
     * Filter models by use case category
     */
    category: S.optionalWith<typeof GetModelsParamsCategory, {
        nullable: true;
    }>;
    supported_parameters: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}>;
export declare class GetModelsParams extends GetModelsParams_base {
}
declare const ListEndpointsResponseArchitectureEnumInstructType_base: S.Literal<["none", "airoboros", "alpaca", "alpaca-modif", "chatml", "claude", "code-llama", "gemma", "llama2", "llama3", "mistral", "nemotron", "neural", "openchat", "phi3", "rwkv", "vicuna", "zephyr", "deepseek-r1", "deepseek-v3.1", "qwq", "qwen3"]>;
/**
 * Instruction format type
 */
export declare class ListEndpointsResponseArchitectureEnumInstructType extends ListEndpointsResponseArchitectureEnumInstructType_base {
}
declare const ListEndpointsResponseArchitecture_base: S.Struct<{
    tokenizer: typeof ModelGroup;
    /**
     * Instruction format type
     */
    instruct_type: S.NullOr<S.Literal<["none", "airoboros", "alpaca", "alpaca-modif", "chatml", "claude", "code-llama", "gemma", "llama2", "llama3", "mistral", "nemotron", "neural", "openchat", "phi3", "rwkv", "vicuna", "zephyr", "deepseek-r1", "deepseek-v3.1", "qwq", "qwen3"]>>;
    /**
     * Primary modality of the model
     */
    modality: S.NullOr<typeof S.String>;
    /**
     * Supported input modalities
     */
    input_modalities: S.Array$<typeof InputModality>;
    /**
     * Supported output modalities
     */
    output_modalities: S.Array$<typeof OutputModality>;
}>;
/**
 * Model architecture information
 */
export declare class ListEndpointsResponseArchitecture extends ListEndpointsResponseArchitecture_base {
}
declare const PublicEndpointQuantizationEnum_base: S.Literal<["int4", "int8", "fp4", "fp6", "fp8", "fp16", "bf16", "fp32", "unknown"]>;
export declare class PublicEndpointQuantizationEnum extends PublicEndpointQuantizationEnum_base {
}
export declare class PublicEndpointQuantization extends PublicEndpointQuantizationEnum {
}
declare const EndpointStatus_base: S.Literal<[0, -1, -2, -3, -5, -10]>;
export declare class EndpointStatus extends EndpointStatus_base {
}
declare const PercentileStats_base: S.Class<PercentileStats, {
    /**
     * Median (50th percentile)
     */
    p50: typeof S.Number;
    /**
     * 75th percentile
     */
    p75: typeof S.Number;
    /**
     * 90th percentile
     */
    p90: typeof S.Number;
    /**
     * 99th percentile
     */
    p99: typeof S.Number;
}, S.Struct.Encoded<{
    /**
     * Median (50th percentile)
     */
    p50: typeof S.Number;
    /**
     * 75th percentile
     */
    p75: typeof S.Number;
    /**
     * 90th percentile
     */
    p90: typeof S.Number;
    /**
     * 99th percentile
     */
    p99: typeof S.Number;
}>, never, {
    readonly p50: number;
} & {
    readonly p75: number;
} & {
    readonly p90: number;
} & {
    readonly p99: number;
}, {}, {}>;
/**
 * Latency percentiles in milliseconds over the last 30 minutes. Latency measures time to first token. Only visible when authenticated with an API key or cookie; returns null for unauthenticated requests.
 */
export declare class PercentileStats extends PercentileStats_base {
}
declare const PublicEndpointThroughputLast30M_base: S.Struct<{
    /**
     * Median (50th percentile)
     */
    p50: typeof S.Number;
    /**
     * 75th percentile
     */
    p75: typeof S.Number;
    /**
     * 90th percentile
     */
    p90: typeof S.Number;
    /**
     * 99th percentile
     */
    p99: typeof S.Number;
}>;
/**
 * Throughput percentiles in tokens per second over the last 30 minutes. Throughput measures output token generation speed. Only visible when authenticated with an API key or cookie; returns null for unauthenticated requests.
 */
export declare class PublicEndpointThroughputLast30M extends PublicEndpointThroughputLast30M_base {
}
declare const PublicEndpoint_base: S.Class<PublicEndpoint, {
    name: typeof S.String;
    /**
     * The unique identifier for the model (permaslug)
     */
    model_id: typeof S.String;
    model_name: typeof S.String;
    context_length: typeof S.Number;
    pricing: S.Struct<{
        prompt: typeof BigNumberUnion;
        completion: typeof BigNumberUnion;
        request: S.optionalWith<typeof BigNumberUnion, {
            nullable: true;
        }>;
        image: S.optionalWith<typeof BigNumberUnion, {
            nullable: true;
        }>;
        image_token: S.optionalWith<typeof BigNumberUnion, {
            nullable: true;
        }>;
        image_output: S.optionalWith<typeof BigNumberUnion, {
            nullable: true;
        }>;
        audio: S.optionalWith<typeof BigNumberUnion, {
            nullable: true;
        }>;
        audio_output: S.optionalWith<typeof BigNumberUnion, {
            nullable: true;
        }>;
        input_audio_cache: S.optionalWith<typeof BigNumberUnion, {
            nullable: true;
        }>;
        web_search: S.optionalWith<typeof BigNumberUnion, {
            nullable: true;
        }>;
        internal_reasoning: S.optionalWith<typeof BigNumberUnion, {
            nullable: true;
        }>;
        input_cache_read: S.optionalWith<typeof BigNumberUnion, {
            nullable: true;
        }>;
        input_cache_write: S.optionalWith<typeof BigNumberUnion, {
            nullable: true;
        }>;
        discount: S.optionalWith<typeof S.Number, {
            nullable: true;
        }>;
    }>;
    provider_name: typeof ProviderName;
    tag: typeof S.String;
    quantization: typeof PublicEndpointQuantization;
    max_completion_tokens: S.NullOr<typeof S.Number>;
    max_prompt_tokens: S.NullOr<typeof S.Number>;
    supported_parameters: S.Array$<typeof Parameter>;
    status: S.optionalWith<typeof EndpointStatus, {
        nullable: true;
    }>;
    uptime_last_30m: S.NullOr<typeof S.Number>;
    supports_implicit_caching: typeof S.Boolean;
    latency_last_30m: S.NullOr<typeof PercentileStats>;
    throughput_last_30m: typeof PublicEndpointThroughputLast30M;
}, S.Struct.Encoded<{
    name: typeof S.String;
    /**
     * The unique identifier for the model (permaslug)
     */
    model_id: typeof S.String;
    model_name: typeof S.String;
    context_length: typeof S.Number;
    pricing: S.Struct<{
        prompt: typeof BigNumberUnion;
        completion: typeof BigNumberUnion;
        request: S.optionalWith<typeof BigNumberUnion, {
            nullable: true;
        }>;
        image: S.optionalWith<typeof BigNumberUnion, {
            nullable: true;
        }>;
        image_token: S.optionalWith<typeof BigNumberUnion, {
            nullable: true;
        }>;
        image_output: S.optionalWith<typeof BigNumberUnion, {
            nullable: true;
        }>;
        audio: S.optionalWith<typeof BigNumberUnion, {
            nullable: true;
        }>;
        audio_output: S.optionalWith<typeof BigNumberUnion, {
            nullable: true;
        }>;
        input_audio_cache: S.optionalWith<typeof BigNumberUnion, {
            nullable: true;
        }>;
        web_search: S.optionalWith<typeof BigNumberUnion, {
            nullable: true;
        }>;
        internal_reasoning: S.optionalWith<typeof BigNumberUnion, {
            nullable: true;
        }>;
        input_cache_read: S.optionalWith<typeof BigNumberUnion, {
            nullable: true;
        }>;
        input_cache_write: S.optionalWith<typeof BigNumberUnion, {
            nullable: true;
        }>;
        discount: S.optionalWith<typeof S.Number, {
            nullable: true;
        }>;
    }>;
    provider_name: typeof ProviderName;
    tag: typeof S.String;
    quantization: typeof PublicEndpointQuantization;
    max_completion_tokens: S.NullOr<typeof S.Number>;
    max_prompt_tokens: S.NullOr<typeof S.Number>;
    supported_parameters: S.Array$<typeof Parameter>;
    status: S.optionalWith<typeof EndpointStatus, {
        nullable: true;
    }>;
    uptime_last_30m: S.NullOr<typeof S.Number>;
    supports_implicit_caching: typeof S.Boolean;
    latency_last_30m: S.NullOr<typeof PercentileStats>;
    throughput_last_30m: typeof PublicEndpointThroughputLast30M;
}>, never, {
    readonly status?: 0 | -2 | -1 | -3 | -5 | -10 | undefined;
} & {
    readonly name: string;
} & {
    readonly provider_name: "AI21" | "AionLabs" | "Alibaba" | "Amazon Bedrock" | "Amazon Nova" | "Anthropic" | "Arcee AI" | "AtlasCloud" | "Avian" | "Azure" | "BaseTen" | "BytePlus" | "Black Forest Labs" | "Cerebras" | "Chutes" | "Cirrascale" | "Clarifai" | "Cloudflare" | "Cohere" | "Crusoe" | "DeepInfra" | "DeepSeek" | "Featherless" | "Fireworks" | "Friendli" | "GMICloud" | "Google" | "Google AI Studio" | "Groq" | "Hyperbolic" | "Inception" | "Inceptron" | "InferenceNet" | "Infermatic" | "Inflection" | "Liquid" | "Mara" | "Mancer 2" | "Minimax" | "ModelRun" | "Mistral" | "Modular" | "Moonshot AI" | "Morph" | "NCompass" | "Nebius" | "NextBit" | "Novita" | "Nvidia" | "OpenAI" | "OpenInference" | "Parasail" | "Perplexity" | "Phala" | "Relace" | "SambaNova" | "Seed" | "SiliconFlow" | "Sourceful" | "Stealth" | "StreamLake" | "Switchpoint" | "Together" | "Upstage" | "Venice" | "WandB" | "Xiaomi" | "xAI" | "Z.AI" | "FakeProvider";
} & {
    readonly context_length: number;
} & {
    readonly max_completion_tokens: number | null;
} & {
    readonly pricing: {
        readonly web_search?: string | undefined;
        readonly image?: string | undefined;
        readonly prompt: string;
        readonly completion: string;
        readonly audio?: string | undefined;
        readonly request?: string | undefined;
        readonly image_token?: string | undefined;
        readonly image_output?: string | undefined;
        readonly audio_output?: string | undefined;
        readonly input_audio_cache?: string | undefined;
        readonly internal_reasoning?: string | undefined;
        readonly input_cache_read?: string | undefined;
        readonly input_cache_write?: string | undefined;
        readonly discount?: number | undefined;
    };
} & {
    readonly supported_parameters: readonly ("reasoning" | "logprobs" | "top_logprobs" | "verbosity" | "max_tokens" | "tools" | "tool_choice" | "parallel_tool_calls" | "temperature" | "top_p" | "presence_penalty" | "frequency_penalty" | "top_k" | "min_p" | "top_a" | "repetition_penalty" | "logit_bias" | "seed" | "response_format" | "structured_outputs" | "stop" | "include_reasoning" | "reasoning_effort" | "web_search_options")[];
} & {
    readonly model_id: string;
} & {
    readonly model_name: string;
} & {
    readonly tag: string;
} & {
    readonly quantization: "unknown" | "int4" | "int8" | "fp4" | "fp6" | "fp8" | "fp16" | "bf16" | "fp32";
} & {
    readonly supports_implicit_caching: boolean;
} & {
    readonly throughput_last_30m: {
        readonly p50: number;
        readonly p75: number;
        readonly p90: number;
        readonly p99: number;
    };
} & {
    readonly max_prompt_tokens: number | null;
} & {
    readonly uptime_last_30m: number | null;
} & {
    readonly latency_last_30m: PercentileStats | null;
}, {}, {}>;
/**
 * Information about a specific model endpoint
 */
export declare class PublicEndpoint extends PublicEndpoint_base {
}
declare const ListEndpointsResponse_base: S.Class<ListEndpointsResponse, {
    /**
     * Unique identifier for the model
     */
    id: typeof S.String;
    /**
     * Display name of the model
     */
    name: typeof S.String;
    /**
     * Unix timestamp of when the model was created
     */
    created: typeof S.Number;
    /**
     * Description of the model
     */
    description: typeof S.String;
    architecture: typeof ListEndpointsResponseArchitecture;
    /**
     * List of available endpoints for this model
     */
    endpoints: S.Array$<typeof PublicEndpoint>;
}, S.Struct.Encoded<{
    /**
     * Unique identifier for the model
     */
    id: typeof S.String;
    /**
     * Display name of the model
     */
    name: typeof S.String;
    /**
     * Unix timestamp of when the model was created
     */
    created: typeof S.Number;
    /**
     * Description of the model
     */
    description: typeof S.String;
    architecture: typeof ListEndpointsResponseArchitecture;
    /**
     * List of available endpoints for this model
     */
    endpoints: S.Array$<typeof PublicEndpoint>;
}>, never, {
    readonly id: string;
} & {
    readonly name: string;
} & {
    readonly description: string;
} & {
    readonly created: number;
} & {
    readonly architecture: {
        readonly tokenizer: "Cohere" | "DeepSeek" | "Mistral" | "Router" | "Media" | "Other" | "GPT" | "Claude" | "Gemini" | "Grok" | "Nova" | "Qwen" | "Yi" | "Llama2" | "Llama3" | "Llama4" | "PaLM" | "RWKV" | "Qwen3";
        readonly instruct_type: "none" | "airoboros" | "alpaca" | "alpaca-modif" | "chatml" | "claude" | "code-llama" | "gemma" | "llama2" | "llama3" | "mistral" | "nemotron" | "neural" | "openchat" | "phi3" | "rwkv" | "vicuna" | "zephyr" | "deepseek-r1" | "deepseek-v3.1" | "qwq" | "qwen3" | null;
        readonly modality: string | null;
        readonly input_modalities: readonly ("text" | "file" | "image" | "audio" | "video")[];
        readonly output_modalities: readonly ("text" | "image" | "audio" | "embeddings")[];
    };
} & {
    readonly endpoints: readonly PublicEndpoint[];
}, {}, {}>;
/**
 * List of available endpoints for a model
 */
export declare class ListEndpointsResponse extends ListEndpointsResponse_base {
}
declare const ListEndpoints200_base: S.Struct<{
    data: typeof ListEndpointsResponse;
}>;
export declare class ListEndpoints200 extends ListEndpoints200_base {
}
declare const ListEndpointsZdr200_base: S.Struct<{
    data: S.Array$<typeof PublicEndpoint>;
}>;
export declare class ListEndpointsZdr200 extends ListEndpointsZdr200_base {
}
declare const ListProviders200_base: S.Struct<{
    data: S.Array$<S.Struct<{
        /**
         * Display name of the provider
         */
        name: typeof S.String;
        /**
         * URL-friendly identifier for the provider
         */
        slug: typeof S.String;
        /**
         * URL to the provider's privacy policy
         */
        privacy_policy_url: S.NullOr<typeof S.String>;
        /**
         * URL to the provider's terms of service
         */
        terms_of_service_url: S.optionalWith<typeof S.String, {
            nullable: true;
        }>;
        /**
         * URL to the provider's status page
         */
        status_page_url: S.optionalWith<typeof S.String, {
            nullable: true;
        }>;
    }>>;
}>;
export declare class ListProviders200 extends ListProviders200_base {
}
declare const ListParams_base: S.Struct<{
    /**
     * Whether to include disabled API keys in the response
     */
    include_disabled: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    /**
     * Number of API keys to skip for pagination
     */
    offset: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}>;
export declare class ListParams extends ListParams_base {
}
declare const List200_base: S.Struct<{
    /**
     * List of API keys
     */
    data: S.Array$<S.Struct<{
        /**
         * Unique hash identifier for the API key
         */
        hash: typeof S.String;
        /**
         * Name of the API key
         */
        name: typeof S.String;
        /**
         * Human-readable label for the API key
         */
        label: typeof S.String;
        /**
         * Whether the API key is disabled
         */
        disabled: typeof S.Boolean;
        /**
         * Spending limit for the API key in USD
         */
        limit: S.NullOr<typeof S.Number>;
        /**
         * Remaining spending limit in USD
         */
        limit_remaining: S.NullOr<typeof S.Number>;
        /**
         * Type of limit reset for the API key
         */
        limit_reset: S.NullOr<typeof S.String>;
        /**
         * Whether to include external BYOK usage in the credit limit
         */
        include_byok_in_limit: typeof S.Boolean;
        /**
         * Total OpenRouter credit usage (in USD) for the API key
         */
        usage: typeof S.Number;
        /**
         * OpenRouter credit usage (in USD) for the current UTC day
         */
        usage_daily: typeof S.Number;
        /**
         * OpenRouter credit usage (in USD) for the current UTC week (Monday-Sunday)
         */
        usage_weekly: typeof S.Number;
        /**
         * OpenRouter credit usage (in USD) for the current UTC month
         */
        usage_monthly: typeof S.Number;
        /**
         * Total external BYOK usage (in USD) for the API key
         */
        byok_usage: typeof S.Number;
        /**
         * External BYOK usage (in USD) for the current UTC day
         */
        byok_usage_daily: typeof S.Number;
        /**
         * External BYOK usage (in USD) for the current UTC week (Monday-Sunday)
         */
        byok_usage_weekly: typeof S.Number;
        /**
         * External BYOK usage (in USD) for current UTC month
         */
        byok_usage_monthly: typeof S.Number;
        /**
         * ISO 8601 timestamp of when the API key was created
         */
        created_at: typeof S.String;
        /**
         * ISO 8601 timestamp of when the API key was last updated
         */
        updated_at: S.NullOr<typeof S.String>;
        /**
         * ISO 8601 UTC timestamp when the API key expires, or null if no expiration
         */
        expires_at: S.optionalWith<typeof S.String, {
            nullable: true;
        }>;
    }>>;
}>;
export declare class List200 extends List200_base {
}
declare const CreateKeysRequestLimitReset_base: S.Literal<["daily", "weekly", "monthly"]>;
/**
 * Type of limit reset for the API key (daily, weekly, monthly, or null for no reset). Resets happen automatically at midnight UTC, and weeks are Monday through Sunday.
 */
export declare class CreateKeysRequestLimitReset extends CreateKeysRequestLimitReset_base {
}
declare const CreateKeysRequest_base: S.Class<CreateKeysRequest, {
    /**
     * Name for the new API key
     */
    name: S.filter<typeof S.String>;
    /**
     * Optional spending limit for the API key in USD
     */
    limit: S.optionalWith<typeof S.Number, {
        nullable: true;
    }>;
    /**
     * Type of limit reset for the API key (daily, weekly, monthly, or null for no reset). Resets happen automatically at midnight UTC, and weeks are Monday through Sunday.
     */
    limit_reset: S.optionalWith<typeof CreateKeysRequestLimitReset, {
        nullable: true;
    }>;
    /**
     * Whether to include BYOK usage in the limit
     */
    include_byok_in_limit: S.optionalWith<typeof S.Boolean, {
        nullable: true;
    }>;
    /**
     * Optional ISO 8601 UTC timestamp when the API key should expire. Must be UTC, other timezones will be rejected
     */
    expires_at: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    /**
     * Name for the new API key
     */
    name: S.filter<typeof S.String>;
    /**
     * Optional spending limit for the API key in USD
     */
    limit: S.optionalWith<typeof S.Number, {
        nullable: true;
    }>;
    /**
     * Type of limit reset for the API key (daily, weekly, monthly, or null for no reset). Resets happen automatically at midnight UTC, and weeks are Monday through Sunday.
     */
    limit_reset: S.optionalWith<typeof CreateKeysRequestLimitReset, {
        nullable: true;
    }>;
    /**
     * Whether to include BYOK usage in the limit
     */
    include_byok_in_limit: S.optionalWith<typeof S.Boolean, {
        nullable: true;
    }>;
    /**
     * Optional ISO 8601 UTC timestamp when the API key should expire. Must be UTC, other timezones will be rejected
     */
    expires_at: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}>, never, {
    readonly name: string;
} & {
    readonly expires_at?: string | undefined;
} & {
    readonly limit?: number | undefined;
} & {
    readonly limit_reset?: "daily" | "weekly" | "monthly" | undefined;
} & {
    readonly include_byok_in_limit?: boolean | undefined;
}, {}, {}>;
export declare class CreateKeysRequest extends CreateKeysRequest_base {
}
declare const CreateKeys201_base: S.Struct<{
    /**
     * The created API key information
     */
    data: S.Struct<{
        /**
         * Unique hash identifier for the API key
         */
        hash: typeof S.String;
        /**
         * Name of the API key
         */
        name: typeof S.String;
        /**
         * Human-readable label for the API key
         */
        label: typeof S.String;
        /**
         * Whether the API key is disabled
         */
        disabled: typeof S.Boolean;
        /**
         * Spending limit for the API key in USD
         */
        limit: S.NullOr<typeof S.Number>;
        /**
         * Remaining spending limit in USD
         */
        limit_remaining: S.NullOr<typeof S.Number>;
        /**
         * Type of limit reset for the API key
         */
        limit_reset: S.NullOr<typeof S.String>;
        /**
         * Whether to include external BYOK usage in the credit limit
         */
        include_byok_in_limit: typeof S.Boolean;
        /**
         * Total OpenRouter credit usage (in USD) for the API key
         */
        usage: typeof S.Number;
        /**
         * OpenRouter credit usage (in USD) for the current UTC day
         */
        usage_daily: typeof S.Number;
        /**
         * OpenRouter credit usage (in USD) for the current UTC week (Monday-Sunday)
         */
        usage_weekly: typeof S.Number;
        /**
         * OpenRouter credit usage (in USD) for the current UTC month
         */
        usage_monthly: typeof S.Number;
        /**
         * Total external BYOK usage (in USD) for the API key
         */
        byok_usage: typeof S.Number;
        /**
         * External BYOK usage (in USD) for the current UTC day
         */
        byok_usage_daily: typeof S.Number;
        /**
         * External BYOK usage (in USD) for the current UTC week (Monday-Sunday)
         */
        byok_usage_weekly: typeof S.Number;
        /**
         * External BYOK usage (in USD) for current UTC month
         */
        byok_usage_monthly: typeof S.Number;
        /**
         * ISO 8601 timestamp of when the API key was created
         */
        created_at: typeof S.String;
        /**
         * ISO 8601 timestamp of when the API key was last updated
         */
        updated_at: S.NullOr<typeof S.String>;
        /**
         * ISO 8601 UTC timestamp when the API key expires, or null if no expiration
         */
        expires_at: S.optionalWith<typeof S.String, {
            nullable: true;
        }>;
    }>;
    /**
     * The actual API key string (only shown once)
     */
    key: typeof S.String;
}>;
export declare class CreateKeys201 extends CreateKeys201_base {
}
declare const GetKey200_base: S.Struct<{
    /**
     * The API key information
     */
    data: S.Struct<{
        /**
         * Unique hash identifier for the API key
         */
        hash: typeof S.String;
        /**
         * Name of the API key
         */
        name: typeof S.String;
        /**
         * Human-readable label for the API key
         */
        label: typeof S.String;
        /**
         * Whether the API key is disabled
         */
        disabled: typeof S.Boolean;
        /**
         * Spending limit for the API key in USD
         */
        limit: S.NullOr<typeof S.Number>;
        /**
         * Remaining spending limit in USD
         */
        limit_remaining: S.NullOr<typeof S.Number>;
        /**
         * Type of limit reset for the API key
         */
        limit_reset: S.NullOr<typeof S.String>;
        /**
         * Whether to include external BYOK usage in the credit limit
         */
        include_byok_in_limit: typeof S.Boolean;
        /**
         * Total OpenRouter credit usage (in USD) for the API key
         */
        usage: typeof S.Number;
        /**
         * OpenRouter credit usage (in USD) for the current UTC day
         */
        usage_daily: typeof S.Number;
        /**
         * OpenRouter credit usage (in USD) for the current UTC week (Monday-Sunday)
         */
        usage_weekly: typeof S.Number;
        /**
         * OpenRouter credit usage (in USD) for the current UTC month
         */
        usage_monthly: typeof S.Number;
        /**
         * Total external BYOK usage (in USD) for the API key
         */
        byok_usage: typeof S.Number;
        /**
         * External BYOK usage (in USD) for the current UTC day
         */
        byok_usage_daily: typeof S.Number;
        /**
         * External BYOK usage (in USD) for the current UTC week (Monday-Sunday)
         */
        byok_usage_weekly: typeof S.Number;
        /**
         * External BYOK usage (in USD) for current UTC month
         */
        byok_usage_monthly: typeof S.Number;
        /**
         * ISO 8601 timestamp of when the API key was created
         */
        created_at: typeof S.String;
        /**
         * ISO 8601 timestamp of when the API key was last updated
         */
        updated_at: S.NullOr<typeof S.String>;
        /**
         * ISO 8601 UTC timestamp when the API key expires, or null if no expiration
         */
        expires_at: S.optionalWith<typeof S.String, {
            nullable: true;
        }>;
    }>;
}>;
export declare class GetKey200 extends GetKey200_base {
}
declare const DeleteKeys200_base: S.Struct<{
    /**
     * Confirmation that the API key was deleted
     */
    deleted: S.Literal<[true]>;
}>;
export declare class DeleteKeys200 extends DeleteKeys200_base {
}
declare const UpdateKeysRequestLimitReset_base: S.Literal<["daily", "weekly", "monthly"]>;
/**
 * New limit reset type for the API key (daily, weekly, monthly, or null for no reset). Resets happen automatically at midnight UTC, and weeks are Monday through Sunday.
 */
export declare class UpdateKeysRequestLimitReset extends UpdateKeysRequestLimitReset_base {
}
declare const UpdateKeysRequest_base: S.Class<UpdateKeysRequest, {
    /**
     * New name for the API key
     */
    name: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    /**
     * Whether to disable the API key
     */
    disabled: S.optionalWith<typeof S.Boolean, {
        nullable: true;
    }>;
    /**
     * New spending limit for the API key in USD
     */
    limit: S.optionalWith<typeof S.Number, {
        nullable: true;
    }>;
    /**
     * New limit reset type for the API key (daily, weekly, monthly, or null for no reset). Resets happen automatically at midnight UTC, and weeks are Monday through Sunday.
     */
    limit_reset: S.optionalWith<typeof UpdateKeysRequestLimitReset, {
        nullable: true;
    }>;
    /**
     * Whether to include BYOK usage in the limit
     */
    include_byok_in_limit: S.optionalWith<typeof S.Boolean, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    /**
     * New name for the API key
     */
    name: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    /**
     * Whether to disable the API key
     */
    disabled: S.optionalWith<typeof S.Boolean, {
        nullable: true;
    }>;
    /**
     * New spending limit for the API key in USD
     */
    limit: S.optionalWith<typeof S.Number, {
        nullable: true;
    }>;
    /**
     * New limit reset type for the API key (daily, weekly, monthly, or null for no reset). Resets happen automatically at midnight UTC, and weeks are Monday through Sunday.
     */
    limit_reset: S.optionalWith<typeof UpdateKeysRequestLimitReset, {
        nullable: true;
    }>;
    /**
     * Whether to include BYOK usage in the limit
     */
    include_byok_in_limit: S.optionalWith<typeof S.Boolean, {
        nullable: true;
    }>;
}>, never, {
    readonly name?: string | undefined;
} & {
    readonly disabled?: boolean | undefined;
} & {
    readonly limit?: number | undefined;
} & {
    readonly limit_reset?: "daily" | "weekly" | "monthly" | undefined;
} & {
    readonly include_byok_in_limit?: boolean | undefined;
}, {}, {}>;
export declare class UpdateKeysRequest extends UpdateKeysRequest_base {
}
declare const UpdateKeys200_base: S.Struct<{
    /**
     * The updated API key information
     */
    data: S.Struct<{
        /**
         * Unique hash identifier for the API key
         */
        hash: typeof S.String;
        /**
         * Name of the API key
         */
        name: typeof S.String;
        /**
         * Human-readable label for the API key
         */
        label: typeof S.String;
        /**
         * Whether the API key is disabled
         */
        disabled: typeof S.Boolean;
        /**
         * Spending limit for the API key in USD
         */
        limit: S.NullOr<typeof S.Number>;
        /**
         * Remaining spending limit in USD
         */
        limit_remaining: S.NullOr<typeof S.Number>;
        /**
         * Type of limit reset for the API key
         */
        limit_reset: S.NullOr<typeof S.String>;
        /**
         * Whether to include external BYOK usage in the credit limit
         */
        include_byok_in_limit: typeof S.Boolean;
        /**
         * Total OpenRouter credit usage (in USD) for the API key
         */
        usage: typeof S.Number;
        /**
         * OpenRouter credit usage (in USD) for the current UTC day
         */
        usage_daily: typeof S.Number;
        /**
         * OpenRouter credit usage (in USD) for the current UTC week (Monday-Sunday)
         */
        usage_weekly: typeof S.Number;
        /**
         * OpenRouter credit usage (in USD) for the current UTC month
         */
        usage_monthly: typeof S.Number;
        /**
         * Total external BYOK usage (in USD) for the API key
         */
        byok_usage: typeof S.Number;
        /**
         * External BYOK usage (in USD) for the current UTC day
         */
        byok_usage_daily: typeof S.Number;
        /**
         * External BYOK usage (in USD) for the current UTC week (Monday-Sunday)
         */
        byok_usage_weekly: typeof S.Number;
        /**
         * External BYOK usage (in USD) for current UTC month
         */
        byok_usage_monthly: typeof S.Number;
        /**
         * ISO 8601 timestamp of when the API key was created
         */
        created_at: typeof S.String;
        /**
         * ISO 8601 timestamp of when the API key was last updated
         */
        updated_at: S.NullOr<typeof S.String>;
        /**
         * ISO 8601 UTC timestamp when the API key expires, or null if no expiration
         */
        expires_at: S.optionalWith<typeof S.String, {
            nullable: true;
        }>;
    }>;
}>;
export declare class UpdateKeys200 extends UpdateKeys200_base {
}
declare const ListGuardrailsParams_base: S.Struct<{
    /**
     * Number of records to skip for pagination
     */
    offset: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    /**
     * Maximum number of records to return (max 100)
     */
    limit: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}>;
export declare class ListGuardrailsParams extends ListGuardrailsParams_base {
}
declare const ListGuardrails200_base: S.Struct<{
    /**
     * List of guardrails
     */
    data: S.Array$<S.Struct<{
        /**
         * Unique identifier for the guardrail
         */
        id: typeof S.String;
        /**
         * Name of the guardrail
         */
        name: typeof S.String;
        /**
         * Description of the guardrail
         */
        description: S.optionalWith<typeof S.String, {
            nullable: true;
        }>;
        /**
         * Spending limit in USD
         */
        limit_usd: S.optionalWith<S.filter<typeof S.Number>, {
            nullable: true;
        }>;
        /**
         * Interval at which the limit resets (daily, weekly, monthly)
         */
        reset_interval: S.optionalWith<S.Literal<["daily", "weekly", "monthly"]>, {
            nullable: true;
        }>;
        /**
         * List of allowed provider IDs
         */
        allowed_providers: S.optionalWith<S.Array$<typeof S.String>, {
            nullable: true;
        }>;
        /**
         * Array of model canonical_slugs (immutable identifiers)
         */
        allowed_models: S.optionalWith<S.Array$<typeof S.String>, {
            nullable: true;
        }>;
        /**
         * Whether to enforce zero data retention
         */
        enforce_zdr: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
        /**
         * ISO 8601 timestamp of when the guardrail was created
         */
        created_at: typeof S.String;
        /**
         * ISO 8601 timestamp of when the guardrail was last updated
         */
        updated_at: S.optionalWith<typeof S.String, {
            nullable: true;
        }>;
    }>>;
    /**
     * Total number of guardrails
     */
    total_count: typeof S.Number;
}>;
export declare class ListGuardrails200 extends ListGuardrails200_base {
}
declare const CreateGuardrailRequestResetInterval_base: S.Literal<["daily", "weekly", "monthly"]>;
/**
 * Interval at which the limit resets (daily, weekly, monthly)
 */
export declare class CreateGuardrailRequestResetInterval extends CreateGuardrailRequestResetInterval_base {
}
declare const CreateGuardrailRequest_base: S.Class<CreateGuardrailRequest, {
    /**
     * Name for the new guardrail
     */
    name: S.filter<S.filter<typeof S.String>>;
    /**
     * Description of the guardrail
     */
    description: S.optionalWith<S.filter<typeof S.String>, {
        nullable: true;
    }>;
    /**
     * Spending limit in USD
     */
    limit_usd: S.optionalWith<S.filter<typeof S.Number>, {
        nullable: true;
    }>;
    /**
     * Interval at which the limit resets (daily, weekly, monthly)
     */
    reset_interval: S.optionalWith<typeof CreateGuardrailRequestResetInterval, {
        nullable: true;
    }>;
    /**
     * List of allowed provider IDs
     */
    allowed_providers: S.optionalWith<S.filter<S.NonEmptyArray<typeof S.String>>, {
        nullable: true;
    }>;
    /**
     * Array of model identifiers (slug or canonical_slug accepted)
     */
    allowed_models: S.optionalWith<S.filter<S.NonEmptyArray<typeof S.String>>, {
        nullable: true;
    }>;
    /**
     * Whether to enforce zero data retention
     */
    enforce_zdr: S.optionalWith<typeof S.Boolean, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    /**
     * Name for the new guardrail
     */
    name: S.filter<S.filter<typeof S.String>>;
    /**
     * Description of the guardrail
     */
    description: S.optionalWith<S.filter<typeof S.String>, {
        nullable: true;
    }>;
    /**
     * Spending limit in USD
     */
    limit_usd: S.optionalWith<S.filter<typeof S.Number>, {
        nullable: true;
    }>;
    /**
     * Interval at which the limit resets (daily, weekly, monthly)
     */
    reset_interval: S.optionalWith<typeof CreateGuardrailRequestResetInterval, {
        nullable: true;
    }>;
    /**
     * List of allowed provider IDs
     */
    allowed_providers: S.optionalWith<S.filter<S.NonEmptyArray<typeof S.String>>, {
        nullable: true;
    }>;
    /**
     * Array of model identifiers (slug or canonical_slug accepted)
     */
    allowed_models: S.optionalWith<S.filter<S.NonEmptyArray<typeof S.String>>, {
        nullable: true;
    }>;
    /**
     * Whether to enforce zero data retention
     */
    enforce_zdr: S.optionalWith<typeof S.Boolean, {
        nullable: true;
    }>;
}>, never, {
    readonly name: string;
} & {
    readonly description?: string | undefined;
} & {
    readonly allowed_models?: readonly [string, ...string[]] | undefined;
} & {
    readonly limit_usd?: number | undefined;
} & {
    readonly reset_interval?: "daily" | "weekly" | "monthly" | undefined;
} & {
    readonly allowed_providers?: readonly [string, ...string[]] | undefined;
} & {
    readonly enforce_zdr?: boolean | undefined;
}, {}, {}>;
export declare class CreateGuardrailRequest extends CreateGuardrailRequest_base {
}
declare const CreateGuardrail201DataResetInterval_base: S.Literal<["daily", "weekly", "monthly"]>;
/**
 * Interval at which the limit resets (daily, weekly, monthly)
 */
export declare class CreateGuardrail201DataResetInterval extends CreateGuardrail201DataResetInterval_base {
}
declare const CreateGuardrail201_base: S.Struct<{
    /**
     * The created guardrail
     */
    data: S.Struct<{
        /**
         * Unique identifier for the guardrail
         */
        id: typeof S.String;
        /**
         * Name of the guardrail
         */
        name: typeof S.String;
        /**
         * Description of the guardrail
         */
        description: S.optionalWith<typeof S.String, {
            nullable: true;
        }>;
        /**
         * Spending limit in USD
         */
        limit_usd: S.optionalWith<S.filter<typeof S.Number>, {
            nullable: true;
        }>;
        /**
         * Interval at which the limit resets (daily, weekly, monthly)
         */
        reset_interval: S.optionalWith<typeof CreateGuardrail201DataResetInterval, {
            nullable: true;
        }>;
        /**
         * List of allowed provider IDs
         */
        allowed_providers: S.optionalWith<S.Array$<typeof S.String>, {
            nullable: true;
        }>;
        /**
         * Array of model canonical_slugs (immutable identifiers)
         */
        allowed_models: S.optionalWith<S.Array$<typeof S.String>, {
            nullable: true;
        }>;
        /**
         * Whether to enforce zero data retention
         */
        enforce_zdr: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
        /**
         * ISO 8601 timestamp of when the guardrail was created
         */
        created_at: typeof S.String;
        /**
         * ISO 8601 timestamp of when the guardrail was last updated
         */
        updated_at: S.optionalWith<typeof S.String, {
            nullable: true;
        }>;
    }>;
}>;
export declare class CreateGuardrail201 extends CreateGuardrail201_base {
}
declare const GetGuardrail200DataResetInterval_base: S.Literal<["daily", "weekly", "monthly"]>;
/**
 * Interval at which the limit resets (daily, weekly, monthly)
 */
export declare class GetGuardrail200DataResetInterval extends GetGuardrail200DataResetInterval_base {
}
declare const GetGuardrail200_base: S.Struct<{
    /**
     * The guardrail
     */
    data: S.Struct<{
        /**
         * Unique identifier for the guardrail
         */
        id: typeof S.String;
        /**
         * Name of the guardrail
         */
        name: typeof S.String;
        /**
         * Description of the guardrail
         */
        description: S.optionalWith<typeof S.String, {
            nullable: true;
        }>;
        /**
         * Spending limit in USD
         */
        limit_usd: S.optionalWith<S.filter<typeof S.Number>, {
            nullable: true;
        }>;
        /**
         * Interval at which the limit resets (daily, weekly, monthly)
         */
        reset_interval: S.optionalWith<typeof GetGuardrail200DataResetInterval, {
            nullable: true;
        }>;
        /**
         * List of allowed provider IDs
         */
        allowed_providers: S.optionalWith<S.Array$<typeof S.String>, {
            nullable: true;
        }>;
        /**
         * Array of model canonical_slugs (immutable identifiers)
         */
        allowed_models: S.optionalWith<S.Array$<typeof S.String>, {
            nullable: true;
        }>;
        /**
         * Whether to enforce zero data retention
         */
        enforce_zdr: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
        /**
         * ISO 8601 timestamp of when the guardrail was created
         */
        created_at: typeof S.String;
        /**
         * ISO 8601 timestamp of when the guardrail was last updated
         */
        updated_at: S.optionalWith<typeof S.String, {
            nullable: true;
        }>;
    }>;
}>;
export declare class GetGuardrail200 extends GetGuardrail200_base {
}
declare const DeleteGuardrail200_base: S.Struct<{
    /**
     * Confirmation that the guardrail was deleted
     */
    deleted: S.Literal<[true]>;
}>;
export declare class DeleteGuardrail200 extends DeleteGuardrail200_base {
}
declare const UpdateGuardrailRequestResetInterval_base: S.Literal<["daily", "weekly", "monthly"]>;
/**
 * Interval at which the limit resets (daily, weekly, monthly)
 */
export declare class UpdateGuardrailRequestResetInterval extends UpdateGuardrailRequestResetInterval_base {
}
declare const UpdateGuardrailRequest_base: S.Class<UpdateGuardrailRequest, {
    /**
     * New name for the guardrail
     */
    name: S.optionalWith<S.filter<S.filter<typeof S.String>>, {
        nullable: true;
    }>;
    /**
     * New description for the guardrail
     */
    description: S.optionalWith<S.filter<typeof S.String>, {
        nullable: true;
    }>;
    /**
     * New spending limit in USD
     */
    limit_usd: S.optionalWith<S.filter<typeof S.Number>, {
        nullable: true;
    }>;
    /**
     * Interval at which the limit resets (daily, weekly, monthly)
     */
    reset_interval: S.optionalWith<typeof UpdateGuardrailRequestResetInterval, {
        nullable: true;
    }>;
    /**
     * New list of allowed provider IDs
     */
    allowed_providers: S.optionalWith<S.filter<S.NonEmptyArray<typeof S.String>>, {
        nullable: true;
    }>;
    /**
     * Array of model identifiers (slug or canonical_slug accepted)
     */
    allowed_models: S.optionalWith<S.filter<S.NonEmptyArray<typeof S.String>>, {
        nullable: true;
    }>;
    /**
     * Whether to enforce zero data retention
     */
    enforce_zdr: S.optionalWith<typeof S.Boolean, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    /**
     * New name for the guardrail
     */
    name: S.optionalWith<S.filter<S.filter<typeof S.String>>, {
        nullable: true;
    }>;
    /**
     * New description for the guardrail
     */
    description: S.optionalWith<S.filter<typeof S.String>, {
        nullable: true;
    }>;
    /**
     * New spending limit in USD
     */
    limit_usd: S.optionalWith<S.filter<typeof S.Number>, {
        nullable: true;
    }>;
    /**
     * Interval at which the limit resets (daily, weekly, monthly)
     */
    reset_interval: S.optionalWith<typeof UpdateGuardrailRequestResetInterval, {
        nullable: true;
    }>;
    /**
     * New list of allowed provider IDs
     */
    allowed_providers: S.optionalWith<S.filter<S.NonEmptyArray<typeof S.String>>, {
        nullable: true;
    }>;
    /**
     * Array of model identifiers (slug or canonical_slug accepted)
     */
    allowed_models: S.optionalWith<S.filter<S.NonEmptyArray<typeof S.String>>, {
        nullable: true;
    }>;
    /**
     * Whether to enforce zero data retention
     */
    enforce_zdr: S.optionalWith<typeof S.Boolean, {
        nullable: true;
    }>;
}>, never, {
    readonly name?: string | undefined;
} & {
    readonly description?: string | undefined;
} & {
    readonly allowed_models?: readonly [string, ...string[]] | undefined;
} & {
    readonly limit_usd?: number | undefined;
} & {
    readonly reset_interval?: "daily" | "weekly" | "monthly" | undefined;
} & {
    readonly allowed_providers?: readonly [string, ...string[]] | undefined;
} & {
    readonly enforce_zdr?: boolean | undefined;
}, {}, {}>;
export declare class UpdateGuardrailRequest extends UpdateGuardrailRequest_base {
}
declare const UpdateGuardrail200DataResetInterval_base: S.Literal<["daily", "weekly", "monthly"]>;
/**
 * Interval at which the limit resets (daily, weekly, monthly)
 */
export declare class UpdateGuardrail200DataResetInterval extends UpdateGuardrail200DataResetInterval_base {
}
declare const UpdateGuardrail200_base: S.Struct<{
    /**
     * The updated guardrail
     */
    data: S.Struct<{
        /**
         * Unique identifier for the guardrail
         */
        id: typeof S.String;
        /**
         * Name of the guardrail
         */
        name: typeof S.String;
        /**
         * Description of the guardrail
         */
        description: S.optionalWith<typeof S.String, {
            nullable: true;
        }>;
        /**
         * Spending limit in USD
         */
        limit_usd: S.optionalWith<S.filter<typeof S.Number>, {
            nullable: true;
        }>;
        /**
         * Interval at which the limit resets (daily, weekly, monthly)
         */
        reset_interval: S.optionalWith<typeof UpdateGuardrail200DataResetInterval, {
            nullable: true;
        }>;
        /**
         * List of allowed provider IDs
         */
        allowed_providers: S.optionalWith<S.Array$<typeof S.String>, {
            nullable: true;
        }>;
        /**
         * Array of model canonical_slugs (immutable identifiers)
         */
        allowed_models: S.optionalWith<S.Array$<typeof S.String>, {
            nullable: true;
        }>;
        /**
         * Whether to enforce zero data retention
         */
        enforce_zdr: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
        /**
         * ISO 8601 timestamp of when the guardrail was created
         */
        created_at: typeof S.String;
        /**
         * ISO 8601 timestamp of when the guardrail was last updated
         */
        updated_at: S.optionalWith<typeof S.String, {
            nullable: true;
        }>;
    }>;
}>;
export declare class UpdateGuardrail200 extends UpdateGuardrail200_base {
}
declare const ListKeyAssignmentsParams_base: S.Struct<{
    /**
     * Number of records to skip for pagination
     */
    offset: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    /**
     * Maximum number of records to return (max 100)
     */
    limit: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}>;
export declare class ListKeyAssignmentsParams extends ListKeyAssignmentsParams_base {
}
declare const ListKeyAssignments200_base: S.Struct<{
    /**
     * List of key assignments
     */
    data: S.Array$<S.Struct<{
        /**
         * Unique identifier for the assignment
         */
        id: typeof S.String;
        /**
         * Hash of the assigned API key
         */
        key_hash: typeof S.String;
        /**
         * ID of the guardrail
         */
        guardrail_id: typeof S.String;
        /**
         * Name of the API key
         */
        key_name: typeof S.String;
        /**
         * Label of the API key
         */
        key_label: typeof S.String;
        /**
         * User ID of who made the assignment
         */
        assigned_by: S.NullOr<typeof S.String>;
        /**
         * ISO 8601 timestamp of when the assignment was created
         */
        created_at: typeof S.String;
    }>>;
    /**
     * Total number of key assignments for this guardrail
     */
    total_count: typeof S.Number;
}>;
export declare class ListKeyAssignments200 extends ListKeyAssignments200_base {
}
declare const ListMemberAssignmentsParams_base: S.Struct<{
    /**
     * Number of records to skip for pagination
     */
    offset: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    /**
     * Maximum number of records to return (max 100)
     */
    limit: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}>;
export declare class ListMemberAssignmentsParams extends ListMemberAssignmentsParams_base {
}
declare const ListMemberAssignments200_base: S.Struct<{
    /**
     * List of member assignments
     */
    data: S.Array$<S.Struct<{
        /**
         * Unique identifier for the assignment
         */
        id: typeof S.String;
        /**
         * Clerk user ID of the assigned member
         */
        user_id: typeof S.String;
        /**
         * Organization ID
         */
        organization_id: typeof S.String;
        /**
         * ID of the guardrail
         */
        guardrail_id: typeof S.String;
        /**
         * User ID of who made the assignment
         */
        assigned_by: S.NullOr<typeof S.String>;
        /**
         * ISO 8601 timestamp of when the assignment was created
         */
        created_at: typeof S.String;
    }>>;
    /**
     * Total number of member assignments
     */
    total_count: typeof S.Number;
}>;
export declare class ListMemberAssignments200 extends ListMemberAssignments200_base {
}
declare const ListGuardrailKeyAssignmentsParams_base: S.Struct<{
    /**
     * Number of records to skip for pagination
     */
    offset: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    /**
     * Maximum number of records to return (max 100)
     */
    limit: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}>;
export declare class ListGuardrailKeyAssignmentsParams extends ListGuardrailKeyAssignmentsParams_base {
}
declare const ListGuardrailKeyAssignments200_base: S.Struct<{
    /**
     * List of key assignments
     */
    data: S.Array$<S.Struct<{
        /**
         * Unique identifier for the assignment
         */
        id: typeof S.String;
        /**
         * Hash of the assigned API key
         */
        key_hash: typeof S.String;
        /**
         * ID of the guardrail
         */
        guardrail_id: typeof S.String;
        /**
         * Name of the API key
         */
        key_name: typeof S.String;
        /**
         * Label of the API key
         */
        key_label: typeof S.String;
        /**
         * User ID of who made the assignment
         */
        assigned_by: S.NullOr<typeof S.String>;
        /**
         * ISO 8601 timestamp of when the assignment was created
         */
        created_at: typeof S.String;
    }>>;
    /**
     * Total number of key assignments for this guardrail
     */
    total_count: typeof S.Number;
}>;
export declare class ListGuardrailKeyAssignments200 extends ListGuardrailKeyAssignments200_base {
}
declare const BulkAssignKeysToGuardrailRequest_base: S.Class<BulkAssignKeysToGuardrailRequest, {
    /**
     * Array of API key hashes to assign to the guardrail
     */
    key_hashes: S.filter<S.NonEmptyArray<S.filter<typeof S.String>>>;
}, S.Struct.Encoded<{
    /**
     * Array of API key hashes to assign to the guardrail
     */
    key_hashes: S.filter<S.NonEmptyArray<S.filter<typeof S.String>>>;
}>, never, {
    readonly key_hashes: readonly [string, ...string[]];
}, {}, {}>;
export declare class BulkAssignKeysToGuardrailRequest extends BulkAssignKeysToGuardrailRequest_base {
}
declare const BulkAssignKeysToGuardrail200_base: S.Struct<{
    /**
     * Number of keys successfully assigned
     */
    assigned_count: typeof S.Number;
}>;
export declare class BulkAssignKeysToGuardrail200 extends BulkAssignKeysToGuardrail200_base {
}
declare const ListGuardrailMemberAssignmentsParams_base: S.Struct<{
    /**
     * Number of records to skip for pagination
     */
    offset: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    /**
     * Maximum number of records to return (max 100)
     */
    limit: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}>;
export declare class ListGuardrailMemberAssignmentsParams extends ListGuardrailMemberAssignmentsParams_base {
}
declare const ListGuardrailMemberAssignments200_base: S.Struct<{
    /**
     * List of member assignments
     */
    data: S.Array$<S.Struct<{
        /**
         * Unique identifier for the assignment
         */
        id: typeof S.String;
        /**
         * Clerk user ID of the assigned member
         */
        user_id: typeof S.String;
        /**
         * Organization ID
         */
        organization_id: typeof S.String;
        /**
         * ID of the guardrail
         */
        guardrail_id: typeof S.String;
        /**
         * User ID of who made the assignment
         */
        assigned_by: S.NullOr<typeof S.String>;
        /**
         * ISO 8601 timestamp of when the assignment was created
         */
        created_at: typeof S.String;
    }>>;
    /**
     * Total number of member assignments
     */
    total_count: typeof S.Number;
}>;
export declare class ListGuardrailMemberAssignments200 extends ListGuardrailMemberAssignments200_base {
}
declare const BulkAssignMembersToGuardrailRequest_base: S.Class<BulkAssignMembersToGuardrailRequest, {
    /**
     * Array of member user IDs to assign to the guardrail
     */
    member_user_ids: S.filter<S.NonEmptyArray<S.filter<typeof S.String>>>;
}, S.Struct.Encoded<{
    /**
     * Array of member user IDs to assign to the guardrail
     */
    member_user_ids: S.filter<S.NonEmptyArray<S.filter<typeof S.String>>>;
}>, never, {
    readonly member_user_ids: readonly [string, ...string[]];
}, {}, {}>;
export declare class BulkAssignMembersToGuardrailRequest extends BulkAssignMembersToGuardrailRequest_base {
}
declare const BulkAssignMembersToGuardrail200_base: S.Struct<{
    /**
     * Number of members successfully assigned
     */
    assigned_count: typeof S.Number;
}>;
export declare class BulkAssignMembersToGuardrail200 extends BulkAssignMembersToGuardrail200_base {
}
declare const BulkUnassignKeysFromGuardrailRequest_base: S.Class<BulkUnassignKeysFromGuardrailRequest, {
    /**
     * Array of API key hashes to unassign from the guardrail
     */
    key_hashes: S.filter<S.NonEmptyArray<S.filter<typeof S.String>>>;
}, S.Struct.Encoded<{
    /**
     * Array of API key hashes to unassign from the guardrail
     */
    key_hashes: S.filter<S.NonEmptyArray<S.filter<typeof S.String>>>;
}>, never, {
    readonly key_hashes: readonly [string, ...string[]];
}, {}, {}>;
export declare class BulkUnassignKeysFromGuardrailRequest extends BulkUnassignKeysFromGuardrailRequest_base {
}
declare const BulkUnassignKeysFromGuardrail200_base: S.Struct<{
    /**
     * Number of keys successfully unassigned
     */
    unassigned_count: typeof S.Number;
}>;
export declare class BulkUnassignKeysFromGuardrail200 extends BulkUnassignKeysFromGuardrail200_base {
}
declare const BulkUnassignMembersFromGuardrailRequest_base: S.Class<BulkUnassignMembersFromGuardrailRequest, {
    /**
     * Array of member user IDs to unassign from the guardrail
     */
    member_user_ids: S.filter<S.NonEmptyArray<S.filter<typeof S.String>>>;
}, S.Struct.Encoded<{
    /**
     * Array of member user IDs to unassign from the guardrail
     */
    member_user_ids: S.filter<S.NonEmptyArray<S.filter<typeof S.String>>>;
}>, never, {
    readonly member_user_ids: readonly [string, ...string[]];
}, {}, {}>;
export declare class BulkUnassignMembersFromGuardrailRequest extends BulkUnassignMembersFromGuardrailRequest_base {
}
declare const BulkUnassignMembersFromGuardrail200_base: S.Struct<{
    /**
     * Number of members successfully unassigned
     */
    unassigned_count: typeof S.Number;
}>;
export declare class BulkUnassignMembersFromGuardrail200 extends BulkUnassignMembersFromGuardrail200_base {
}
declare const GetCurrentKey200_base: S.Struct<{
    /**
     * Current API key information
     */
    data: S.Struct<{
        /**
         * Human-readable label for the API key
         */
        label: typeof S.String;
        /**
         * Spending limit for the API key in USD
         */
        limit: S.NullOr<typeof S.Number>;
        /**
         * Total OpenRouter credit usage (in USD) for the API key
         */
        usage: typeof S.Number;
        /**
         * OpenRouter credit usage (in USD) for the current UTC day
         */
        usage_daily: typeof S.Number;
        /**
         * OpenRouter credit usage (in USD) for the current UTC week (Monday-Sunday)
         */
        usage_weekly: typeof S.Number;
        /**
         * OpenRouter credit usage (in USD) for the current UTC month
         */
        usage_monthly: typeof S.Number;
        /**
         * Total external BYOK usage (in USD) for the API key
         */
        byok_usage: typeof S.Number;
        /**
         * External BYOK usage (in USD) for the current UTC day
         */
        byok_usage_daily: typeof S.Number;
        /**
         * External BYOK usage (in USD) for the current UTC week (Monday-Sunday)
         */
        byok_usage_weekly: typeof S.Number;
        /**
         * External BYOK usage (in USD) for current UTC month
         */
        byok_usage_monthly: typeof S.Number;
        /**
         * Whether this is a free tier API key
         */
        is_free_tier: typeof S.Boolean;
        /**
         * Whether this is a provisioning key
         */
        is_provisioning_key: typeof S.Boolean;
        /**
         * Remaining spending limit in USD
         */
        limit_remaining: S.NullOr<typeof S.Number>;
        /**
         * Type of limit reset for the API key
         */
        limit_reset: S.NullOr<typeof S.String>;
        /**
         * Whether to include external BYOK usage in the credit limit
         */
        include_byok_in_limit: typeof S.Boolean;
        /**
         * ISO 8601 UTC timestamp when the API key expires, or null if no expiration
         */
        expires_at: S.optionalWith<typeof S.String, {
            nullable: true;
        }>;
        /**
         * Legacy rate limit information about a key. Will always return -1.
         */
        rate_limit: S.Struct<{
            /**
             * Number of requests allowed per interval
             */
            requests: typeof S.Number;
            /**
             * Rate limit interval
             */
            interval: typeof S.String;
            /**
             * Note about the rate limit
             */
            note: typeof S.String;
        }>;
    }>;
}>;
export declare class GetCurrentKey200 extends GetCurrentKey200_base {
}
declare const ExchangeAuthCodeForAPIKeyRequestCodeChallengeMethod_base: S.Literal<["S256", "plain"]>;
/**
 * The method used to generate the code challenge
 */
export declare class ExchangeAuthCodeForAPIKeyRequestCodeChallengeMethod extends ExchangeAuthCodeForAPIKeyRequestCodeChallengeMethod_base {
}
declare const ExchangeAuthCodeForAPIKeyRequest_base: S.Class<ExchangeAuthCodeForAPIKeyRequest, {
    /**
     * The authorization code received from the OAuth redirect
     */
    code: typeof S.String;
    /**
     * The code verifier if code_challenge was used in the authorization request
     */
    code_verifier: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    /**
     * The method used to generate the code challenge
     */
    code_challenge_method: S.optionalWith<typeof ExchangeAuthCodeForAPIKeyRequestCodeChallengeMethod, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    /**
     * The authorization code received from the OAuth redirect
     */
    code: typeof S.String;
    /**
     * The code verifier if code_challenge was used in the authorization request
     */
    code_verifier: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    /**
     * The method used to generate the code challenge
     */
    code_challenge_method: S.optionalWith<typeof ExchangeAuthCodeForAPIKeyRequestCodeChallengeMethod, {
        nullable: true;
    }>;
}>, never, {
    readonly code: string;
} & {
    readonly code_verifier?: string | undefined;
} & {
    readonly code_challenge_method?: "S256" | "plain" | undefined;
}, {}, {}>;
export declare class ExchangeAuthCodeForAPIKeyRequest extends ExchangeAuthCodeForAPIKeyRequest_base {
}
declare const ExchangeAuthCodeForAPIKey200_base: S.Struct<{
    /**
     * The API key to use for OpenRouter requests
     */
    key: typeof S.String;
    /**
     * User ID associated with the API key
     */
    user_id: S.NullOr<typeof S.String>;
}>;
export declare class ExchangeAuthCodeForAPIKey200 extends ExchangeAuthCodeForAPIKey200_base {
}
declare const CreateAuthKeysCodeRequestCodeChallengeMethod_base: S.Literal<["S256", "plain"]>;
/**
 * The method used to generate the code challenge
 */
export declare class CreateAuthKeysCodeRequestCodeChallengeMethod extends CreateAuthKeysCodeRequestCodeChallengeMethod_base {
}
declare const CreateAuthKeysCodeRequest_base: S.Class<CreateAuthKeysCodeRequest, {
    /**
     * The callback URL to redirect to after authorization. Note, only https URLs on ports 443 and 3000 are allowed.
     */
    callback_url: typeof S.String;
    /**
     * PKCE code challenge for enhanced security
     */
    code_challenge: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    /**
     * The method used to generate the code challenge
     */
    code_challenge_method: S.optionalWith<typeof CreateAuthKeysCodeRequestCodeChallengeMethod, {
        nullable: true;
    }>;
    /**
     * Credit limit for the API key to be created
     */
    limit: S.optionalWith<typeof S.Number, {
        nullable: true;
    }>;
    /**
     * Optional expiration time for the API key to be created
     */
    expires_at: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    /**
     * The callback URL to redirect to after authorization. Note, only https URLs on ports 443 and 3000 are allowed.
     */
    callback_url: typeof S.String;
    /**
     * PKCE code challenge for enhanced security
     */
    code_challenge: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    /**
     * The method used to generate the code challenge
     */
    code_challenge_method: S.optionalWith<typeof CreateAuthKeysCodeRequestCodeChallengeMethod, {
        nullable: true;
    }>;
    /**
     * Credit limit for the API key to be created
     */
    limit: S.optionalWith<typeof S.Number, {
        nullable: true;
    }>;
    /**
     * Optional expiration time for the API key to be created
     */
    expires_at: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}>, never, {
    readonly expires_at?: string | undefined;
} & {
    readonly limit?: number | undefined;
} & {
    readonly code_challenge_method?: "S256" | "plain" | undefined;
} & {
    readonly callback_url: string;
} & {
    readonly code_challenge?: string | undefined;
}, {}, {}>;
export declare class CreateAuthKeysCodeRequest extends CreateAuthKeysCodeRequest_base {
}
declare const CreateAuthKeysCode200_base: S.Struct<{
    /**
     * Auth code data
     */
    data: S.Struct<{
        /**
         * The authorization code ID to use in the exchange request
         */
        id: typeof S.String;
        /**
         * The application ID associated with this auth code
         */
        app_id: typeof S.Number;
        /**
         * ISO 8601 timestamp of when the auth code was created
         */
        created_at: typeof S.String;
    }>;
}>;
export declare class CreateAuthKeysCode200 extends CreateAuthKeysCode200_base {
}
declare const ChatGenerationParamsProviderEnumDataCollectionEnum_base: S.Literal<["deny", "allow"]>;
export declare class ChatGenerationParamsProviderEnumDataCollectionEnum extends ChatGenerationParamsProviderEnumDataCollectionEnum_base {
}
declare const Schema0_base: S.Array$<S.Union<[S.Literal<["AI21", "AionLabs", "Alibaba", "Amazon Bedrock", "Amazon Nova", "Anthropic", "Arcee AI", "AtlasCloud", "Avian", "Azure", "BaseTen", "BytePlus", "Black Forest Labs", "Cerebras", "Chutes", "Cirrascale", "Clarifai", "Cloudflare", "Cohere", "Crusoe", "DeepInfra", "DeepSeek", "Featherless", "Fireworks", "Friendli", "GMICloud", "Google", "Google AI Studio", "Groq", "Hyperbolic", "Inception", "Inceptron", "InferenceNet", "Infermatic", "Inflection", "Liquid", "Mara", "Mancer 2", "Minimax", "ModelRun", "Mistral", "Modular", "Moonshot AI", "Morph", "NCompass", "Nebius", "NextBit", "Novita", "Nvidia", "OpenAI", "OpenInference", "Parasail", "Perplexity", "Phala", "Relace", "SambaNova", "Seed", "SiliconFlow", "Sourceful", "Stealth", "StreamLake", "Switchpoint", "Together", "Upstage", "Venice", "WandB", "Xiaomi", "xAI", "Z.AI", "FakeProvider"]>, typeof S.String]>>;
export declare class Schema0 extends Schema0_base {
}
declare const ProviderSortUnion_base: S.Union<[typeof ProviderSort, typeof ProviderSortConfig]>;
export declare class ProviderSortUnion extends ProviderSortUnion_base {
}
declare const Schema1_base: S.Union<[typeof S.Number, typeof S.String, typeof S.Number]>;
export declare class Schema1 extends Schema1_base {
}
declare const ChatGenerationParamsRouteEnum_base: S.Literal<["fallback", "sort"]>;
export declare class ChatGenerationParamsRouteEnum extends ChatGenerationParamsRouteEnum_base {
}
declare const ChatMessageContentItemCacheControlTtl_base: S.Literal<["5m", "1h"]>;
export declare class ChatMessageContentItemCacheControlTtl extends ChatMessageContentItemCacheControlTtl_base {
}
declare const ChatMessageContentItemCacheControl_base: S.Class<ChatMessageContentItemCacheControl, {
    type: S.Literal<["ephemeral"]>;
    ttl: S.optionalWith<typeof ChatMessageContentItemCacheControlTtl, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    type: S.Literal<["ephemeral"]>;
    ttl: S.optionalWith<typeof ChatMessageContentItemCacheControlTtl, {
        nullable: true;
    }>;
}>, never, {
    readonly type: "ephemeral";
} & {
    readonly ttl?: "5m" | "1h" | undefined;
}, {}, {}>;
export declare class ChatMessageContentItemCacheControl extends ChatMessageContentItemCacheControl_base {
}
declare const ChatMessageContentItemText_base: S.Class<ChatMessageContentItemText, {
    type: S.Literal<["text"]>;
    text: typeof S.String;
    cache_control: S.optionalWith<typeof ChatMessageContentItemCacheControl, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    type: S.Literal<["text"]>;
    text: typeof S.String;
    cache_control: S.optionalWith<typeof ChatMessageContentItemCacheControl, {
        nullable: true;
    }>;
}>, never, {
    readonly type: "text";
} & {
    readonly text: string;
} & {
    readonly cache_control?: ChatMessageContentItemCacheControl | undefined;
}, {}, {}>;
export declare class ChatMessageContentItemText extends ChatMessageContentItemText_base {
}
declare const SystemMessage_base: S.Class<SystemMessage, {
    role: S.Literal<["system"]>;
    content: S.Union<[typeof S.String, S.Array$<typeof ChatMessageContentItemText>]>;
    name: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    role: S.Literal<["system"]>;
    content: S.Union<[typeof S.String, S.Array$<typeof ChatMessageContentItemText>]>;
    name: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}>, never, {
    readonly content: string | readonly ChatMessageContentItemText[];
} & {
    readonly name?: string | undefined;
} & {
    readonly role: "system";
}, {}, {}>;
export declare class SystemMessage extends SystemMessage_base {
}
declare const ChatMessageContentItemImageImageUrlDetail_base: S.Literal<["auto", "low", "high"]>;
export declare class ChatMessageContentItemImageImageUrlDetail extends ChatMessageContentItemImageImageUrlDetail_base {
}
declare const ChatMessageContentItemImage_base: S.Class<ChatMessageContentItemImage, {
    type: S.Literal<["image_url"]>;
    image_url: S.Struct<{
        url: typeof S.String;
        detail: S.optionalWith<typeof ChatMessageContentItemImageImageUrlDetail, {
            nullable: true;
        }>;
    }>;
}, S.Struct.Encoded<{
    type: S.Literal<["image_url"]>;
    image_url: S.Struct<{
        url: typeof S.String;
        detail: S.optionalWith<typeof ChatMessageContentItemImageImageUrlDetail, {
            nullable: true;
        }>;
    }>;
}>, never, {
    readonly type: "image_url";
} & {
    readonly image_url: {
        readonly url: string;
        readonly detail?: "auto" | "high" | "low" | undefined;
    };
}, {}, {}>;
export declare class ChatMessageContentItemImage extends ChatMessageContentItemImage_base {
}
declare const ChatMessageContentItemAudio_base: S.Class<ChatMessageContentItemAudio, {
    type: S.Literal<["input_audio"]>;
    input_audio: S.Struct<{
        data: typeof S.String;
        format: typeof S.String;
    }>;
}, S.Struct.Encoded<{
    type: S.Literal<["input_audio"]>;
    input_audio: S.Struct<{
        data: typeof S.String;
        format: typeof S.String;
    }>;
}>, never, {
    readonly type: "input_audio";
} & {
    readonly input_audio: {
        readonly format: string;
        readonly data: string;
    };
}, {}, {}>;
export declare class ChatMessageContentItemAudio extends ChatMessageContentItemAudio_base {
}
declare const ChatMessageContentItemVideo_base: S.Record$<typeof S.String, typeof S.Unknown>;
export declare class ChatMessageContentItemVideo extends ChatMessageContentItemVideo_base {
}
declare const ChatMessageContentItem_base: S.Record$<typeof S.String, typeof S.Unknown>;
export declare class ChatMessageContentItem extends ChatMessageContentItem_base {
}
declare const UserMessage_base: S.Class<UserMessage, {
    role: S.Literal<["user"]>;
    content: S.Union<[typeof S.String, S.Array$<typeof ChatMessageContentItem>]>;
    name: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    role: S.Literal<["user"]>;
    content: S.Union<[typeof S.String, S.Array$<typeof ChatMessageContentItem>]>;
    name: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}>, never, {
    readonly content: string | readonly {
        readonly [x: string]: unknown;
    }[];
} & {
    readonly name?: string | undefined;
} & {
    readonly role: "user";
}, {}, {}>;
export declare class UserMessage extends UserMessage_base {
}
declare const ChatMessageToolCall_base: S.Class<ChatMessageToolCall, {
    id: typeof S.String;
    type: S.Literal<["function"]>;
    function: S.Struct<{
        name: typeof S.String;
        arguments: typeof S.String;
    }>;
}, S.Struct.Encoded<{
    id: typeof S.String;
    type: S.Literal<["function"]>;
    function: S.Struct<{
        name: typeof S.String;
        arguments: typeof S.String;
    }>;
}>, never, {
    readonly function: {
        readonly name: string;
        readonly arguments: string;
    };
} & {
    readonly type: "function";
} & {
    readonly id: string;
}, {}, {}>;
export declare class ChatMessageToolCall extends ChatMessageToolCall_base {
}
declare const Schema3_base: S.Union<[typeof S.String, typeof S.Null]>;
export declare class Schema3 extends Schema3_base {
}
declare const Schema4Enum_base: S.Literal<["unknown", "openai-responses-v1", "azure-openai-responses-v1", "xai-responses-v1", "anthropic-claude-v1", "google-gemini-v1"]>;
export declare class Schema4Enum extends Schema4Enum_base {
}
declare const Schema4_base: S.Union<[typeof Schema4Enum, typeof S.Null]>;
export declare class Schema4 extends Schema4_base {
}
export declare class Schema5 extends S.Number {
}
declare const Schema2_base: S.Record$<typeof S.String, typeof S.Unknown>;
export declare class Schema2 extends Schema2_base {
}
declare const AssistantMessage_base: S.Class<AssistantMessage, {
    role: S.Literal<["assistant"]>;
    content: S.optionalWith<S.Union<[typeof S.String, S.Array$<typeof ChatMessageContentItem>]>, {
        nullable: true;
    }>;
    name: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    tool_calls: S.optionalWith<S.Array$<typeof ChatMessageToolCall>, {
        nullable: true;
    }>;
    refusal: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    reasoning: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    reasoning_details: S.optionalWith<S.Array$<typeof ReasoningDetail>, {
        nullable: true;
    }>;
    images: S.optionalWith<S.Array$<S.Struct<{
        image_url: S.Struct<{
            url: typeof S.String;
        }>;
    }>>, {
        nullable: true;
    }>;
    annotations: S.optionalWith<S.Array$<typeof AnnotationDetail>, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    role: S.Literal<["assistant"]>;
    content: S.optionalWith<S.Union<[typeof S.String, S.Array$<typeof ChatMessageContentItem>]>, {
        nullable: true;
    }>;
    name: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    tool_calls: S.optionalWith<S.Array$<typeof ChatMessageToolCall>, {
        nullable: true;
    }>;
    refusal: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    reasoning: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    reasoning_details: S.optionalWith<S.Array$<typeof ReasoningDetail>, {
        nullable: true;
    }>;
    images: S.optionalWith<S.Array$<S.Struct<{
        image_url: S.Struct<{
            url: typeof S.String;
        }>;
    }>>, {
        nullable: true;
    }>;
    annotations: S.optionalWith<S.Array$<typeof AnnotationDetail>, {
        nullable: true;
    }>;
}>, never, {
    readonly annotations?: readonly (FileAnnotationDetail | URLCitationAnnotationDetail)[] | undefined;
} & {
    readonly reasoning?: string | undefined;
} & {
    readonly content?: string | readonly {
        readonly [x: string]: unknown;
    }[] | undefined;
} & {
    readonly name?: string | undefined;
} & {
    readonly role: "assistant";
} & {
    readonly refusal?: string | undefined;
} & {
    readonly tool_calls?: readonly ChatMessageToolCall[] | undefined;
} & {
    readonly reasoning_details?: readonly (ReasoningDetailSummary | ReasoningDetailEncrypted | ReasoningDetailText)[] | undefined;
} & {
    readonly images?: readonly {
        readonly image_url: {
            readonly url: string;
        };
    }[] | undefined;
}, {}, {}>;
export declare class AssistantMessage extends AssistantMessage_base {
}
declare const ToolResponseMessage_base: S.Class<ToolResponseMessage, {
    role: S.Literal<["tool"]>;
    content: S.Union<[typeof S.String, S.Array$<typeof ChatMessageContentItem>]>;
    tool_call_id: typeof S.String;
}, S.Struct.Encoded<{
    role: S.Literal<["tool"]>;
    content: S.Union<[typeof S.String, S.Array$<typeof ChatMessageContentItem>]>;
    tool_call_id: typeof S.String;
}>, never, {
    readonly content: string | readonly {
        readonly [x: string]: unknown;
    }[];
} & {
    readonly role: "tool";
} & {
    readonly tool_call_id: string;
}, {}, {}>;
export declare class ToolResponseMessage extends ToolResponseMessage_base {
}
declare const Message_base: S.Record$<typeof S.String, typeof S.Unknown>;
export declare class Message extends Message_base {
}
export declare class ModelName extends S.String {
}
declare const ChatGenerationParamsReasoningEffortEnum_base: S.Literal<["xhigh", "high", "medium", "low", "minimal", "none"]>;
export declare class ChatGenerationParamsReasoningEffortEnum extends ChatGenerationParamsReasoningEffortEnum_base {
}
declare const JSONSchemaConfig_base: S.Class<JSONSchemaConfig, {
    name: S.filter<typeof S.String>;
    description: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    schema: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
        nullable: true;
    }>;
    strict: S.optionalWith<typeof S.Boolean, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    name: S.filter<typeof S.String>;
    description: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    schema: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
        nullable: true;
    }>;
    strict: S.optionalWith<typeof S.Boolean, {
        nullable: true;
    }>;
}>, never, {
    readonly name: string;
} & {
    readonly description?: string | undefined;
} & {
    readonly strict?: boolean | undefined;
} & {
    readonly schema?: {
        readonly [x: string]: unknown;
    } | undefined;
}, {}, {}>;
export declare class JSONSchemaConfig extends JSONSchemaConfig_base {
}
declare const ResponseFormatJSONSchema_base: S.Class<ResponseFormatJSONSchema, {
    type: S.Literal<["json_schema"]>;
    json_schema: typeof JSONSchemaConfig;
}, S.Struct.Encoded<{
    type: S.Literal<["json_schema"]>;
    json_schema: typeof JSONSchemaConfig;
}>, never, {
    readonly type: "json_schema";
} & {
    readonly json_schema: JSONSchemaConfig;
}, {}, {}>;
export declare class ResponseFormatJSONSchema extends ResponseFormatJSONSchema_base {
}
declare const ResponseFormatTextGrammar_base: S.Class<ResponseFormatTextGrammar, {
    type: S.Literal<["grammar"]>;
    grammar: typeof S.String;
}, S.Struct.Encoded<{
    type: S.Literal<["grammar"]>;
    grammar: typeof S.String;
}>, never, {
    readonly type: "grammar";
} & {
    readonly grammar: string;
}, {}, {}>;
export declare class ResponseFormatTextGrammar extends ResponseFormatTextGrammar_base {
}
declare const ChatStreamOptions_base: S.Class<ChatStreamOptions, {
    include_usage: S.optionalWith<typeof S.Boolean, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    include_usage: S.optionalWith<typeof S.Boolean, {
        nullable: true;
    }>;
}>, never, {
    readonly include_usage?: boolean | undefined;
}, {}, {}>;
export declare class ChatStreamOptions extends ChatStreamOptions_base {
}
declare const NamedToolChoice_base: S.Class<NamedToolChoice, {
    type: S.Literal<["function"]>;
    function: S.Struct<{
        name: typeof S.String;
    }>;
}, S.Struct.Encoded<{
    type: S.Literal<["function"]>;
    function: S.Struct<{
        name: typeof S.String;
    }>;
}>, never, {
    readonly function: {
        readonly name: string;
    };
} & {
    readonly type: "function";
}, {}, {}>;
export declare class NamedToolChoice extends NamedToolChoice_base {
}
declare const ToolChoiceOption_base: S.Union<[S.Literal<["none"]>, S.Literal<["auto"]>, S.Literal<["required"]>, typeof NamedToolChoice]>;
export declare class ToolChoiceOption extends ToolChoiceOption_base {
}
declare const ToolDefinitionJson_base: S.Class<ToolDefinitionJson, {
    type: S.Literal<["function"]>;
    function: S.Struct<{
        name: S.filter<typeof S.String>;
        description: S.optionalWith<typeof S.String, {
            nullable: true;
        }>;
        parameters: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
            nullable: true;
        }>;
        strict: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
    }>;
}, S.Struct.Encoded<{
    type: S.Literal<["function"]>;
    function: S.Struct<{
        name: S.filter<typeof S.String>;
        description: S.optionalWith<typeof S.String, {
            nullable: true;
        }>;
        parameters: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
            nullable: true;
        }>;
        strict: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
    }>;
}>, never, {
    readonly function: {
        readonly name: string;
        readonly description?: string | undefined;
        readonly strict?: boolean | undefined;
        readonly parameters?: {
            readonly [x: string]: unknown;
        } | undefined;
    };
} & {
    readonly type: "function";
}, {}, {}>;
export declare class ToolDefinitionJson extends ToolDefinitionJson_base {
}
declare const ChatGenerationParams_base: S.Class<ChatGenerationParams, {
    /**
     * When multiple model providers are available, optionally indicate your routing preference.
     */
    provider: S.optionalWith<S.Struct<{
        /**
         * Whether to allow backup providers to serve requests
         * - true: (default) when the primary provider (or your custom providers in "order") is unavailable, use the next best provider.
         * - false: use only the primary/custom provider, and return the upstream error if it's unavailable.
         */
        allow_fallbacks: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
        /**
         * Whether to filter providers to only those that support the parameters you've provided. If this setting is omitted or set to false, then providers will receive only the parameters they support, and ignore the rest.
         */
        require_parameters: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
        /**
         * Data collection setting. If no available model provider meets the requirement, your request will return an error.
         * - allow: (default) allow providers which store user data non-transiently and may train on it
         *
         * - deny: use only providers which do not collect user data.
         */
        data_collection: S.optionalWith<S.Literal<["deny", "allow"]>, {
            nullable: true;
        }>;
        zdr: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
        enforce_distillable_text: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
        /**
         * An ordered list of provider slugs. The router will attempt to use the first provider in the subset of this list that supports your requested model, and fall back to the next if it is unavailable. If no providers are available, the request will fail with an error message.
         */
        order: S.optionalWith<typeof Schema0, {
            nullable: true;
        }>;
        /**
         * List of provider slugs to allow. If provided, this list is merged with your account-wide allowed provider settings for this request.
         */
        only: S.optionalWith<typeof Schema0, {
            nullable: true;
        }>;
        /**
         * List of provider slugs to ignore. If provided, this list is merged with your account-wide ignored provider settings for this request.
         */
        ignore: S.optionalWith<typeof Schema0, {
            nullable: true;
        }>;
        /**
         * A list of quantization levels to filter the provider by.
         */
        quantizations: S.optionalWith<S.Array$<S.Literal<["int4", "int8", "fp4", "fp6", "fp8", "fp16", "bf16", "fp32", "unknown"]>>, {
            nullable: true;
        }>;
        /**
         * The sorting strategy to use for this request, if "order" is not specified. When set, no load balancing is performed.
         */
        sort: S.optionalWith<typeof ProviderSortUnion, {
            nullable: true;
        }>;
        /**
         * The object specifying the maximum price you want to pay for this request. USD price per million tokens, for prompt and completion.
         */
        max_price: S.optionalWith<S.Struct<{
            prompt: S.optionalWith<typeof Schema1, {
                nullable: true;
            }>;
            completion: S.optionalWith<typeof Schema1, {
                nullable: true;
            }>;
            image: S.optionalWith<typeof Schema1, {
                nullable: true;
            }>;
            audio: S.optionalWith<typeof Schema1, {
                nullable: true;
            }>;
            request: S.optionalWith<typeof Schema1, {
                nullable: true;
            }>;
        }>, {
            nullable: true;
        }>;
        /**
         * Preferred minimum throughput (in tokens per second). Can be a number (applies to p50) or an object with percentile-specific cutoffs. Endpoints below the threshold(s) may still be used, but are deprioritized in routing. When using fallback models, this may cause a fallback model to be used instead of the primary model if it meets the threshold.
         */
        preferred_min_throughput: S.optionalWith<S.Union<[typeof S.Number, S.Struct<{
            p50: S.optionalWith<typeof S.Number, {
                nullable: true;
            }>;
            p75: S.optionalWith<typeof S.Number, {
                nullable: true;
            }>;
            p90: S.optionalWith<typeof S.Number, {
                nullable: true;
            }>;
            p99: S.optionalWith<typeof S.Number, {
                nullable: true;
            }>;
        }>]>, {
            nullable: true;
        }>;
        /**
         * Preferred maximum latency (in seconds). Can be a number (applies to p50) or an object with percentile-specific cutoffs. Endpoints above the threshold(s) may still be used, but are deprioritized in routing. When using fallback models, this may cause a fallback model to be used instead of the primary model if it meets the threshold.
         */
        preferred_max_latency: S.optionalWith<S.Union<[typeof S.Number, S.Struct<{
            p50: S.optionalWith<typeof S.Number, {
                nullable: true;
            }>;
            p75: S.optionalWith<typeof S.Number, {
                nullable: true;
            }>;
            p90: S.optionalWith<typeof S.Number, {
                nullable: true;
            }>;
            p99: S.optionalWith<typeof S.Number, {
                nullable: true;
            }>;
        }>]>, {
            nullable: true;
        }>;
    }>, {
        nullable: true;
    }>;
    /**
     * Plugins you want to enable for this request, including their settings.
     */
    plugins: S.optionalWith<S.Array$<S.Record$<typeof S.String, typeof S.Unknown>>, {
        nullable: true;
    }>;
    route: S.optionalWith<typeof ChatGenerationParamsRouteEnum, {
        nullable: true;
    }>;
    user: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    /**
     * 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.
     */
    session_id: S.optionalWith<S.filter<typeof S.String>, {
        nullable: true;
    }>;
    messages: S.filter<S.NonEmptyArray<typeof Message>>;
    model: S.optionalWith<typeof ModelName, {
        nullable: true;
    }>;
    models: S.optionalWith<S.Array$<typeof ModelName>, {
        nullable: true;
    }>;
    frequency_penalty: S.optionalWith<S.filter<S.filter<typeof S.Number>>, {
        nullable: true;
    }>;
    logit_bias: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
        nullable: true;
    }>;
    logprobs: S.optionalWith<typeof S.Boolean, {
        nullable: true;
    }>;
    top_logprobs: S.optionalWith<S.filter<S.filter<typeof S.Number>>, {
        nullable: true;
    }>;
    max_completion_tokens: S.optionalWith<S.filter<typeof S.Number>, {
        nullable: true;
    }>;
    max_tokens: S.optionalWith<S.filter<typeof S.Number>, {
        nullable: true;
    }>;
    metadata: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
        nullable: true;
    }>;
    presence_penalty: S.optionalWith<S.filter<S.filter<typeof S.Number>>, {
        nullable: true;
    }>;
    reasoning: S.optionalWith<S.Struct<{
        effort: S.optionalWith<typeof ChatGenerationParamsReasoningEffortEnum, {
            nullable: true;
        }>;
        summary: S.optionalWith<typeof ReasoningSummaryVerbosity, {
            nullable: true;
        }>;
    }>, {
        nullable: true;
    }>;
    response_format: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
        nullable: true;
    }>;
    seed: S.optionalWith<S.filter<S.filter<typeof S.Int>>, {
        nullable: true;
    }>;
    stop: S.optionalWith<S.Union<[typeof S.String, S.filter<S.Array$<typeof S.String>>]>, {
        nullable: true;
    }>;
    stream: S.optionalWith<typeof S.Boolean, {
        nullable: true;
        default: () => false;
    }>;
    stream_options: S.optionalWith<typeof ChatStreamOptions, {
        nullable: true;
    }>;
    temperature: S.optionalWith<S.filter<S.filter<typeof S.Number>>, {
        nullable: true;
        default: () => 1;
    }>;
    tool_choice: S.optionalWith<typeof ToolChoiceOption, {
        nullable: true;
    }>;
    tools: S.optionalWith<S.Array$<typeof ToolDefinitionJson>, {
        nullable: true;
    }>;
    top_p: S.optionalWith<S.filter<S.filter<typeof S.Number>>, {
        nullable: true;
        default: () => 1;
    }>;
    debug: S.optionalWith<S.Struct<{
        echo_upstream_body: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
    }>, {
        nullable: true;
    }>;
    image_config: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
        nullable: true;
    }>;
    modalities: S.optionalWith<S.Array$<S.Literal<["text", "image"]>>, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    /**
     * When multiple model providers are available, optionally indicate your routing preference.
     */
    provider: S.optionalWith<S.Struct<{
        /**
         * Whether to allow backup providers to serve requests
         * - true: (default) when the primary provider (or your custom providers in "order") is unavailable, use the next best provider.
         * - false: use only the primary/custom provider, and return the upstream error if it's unavailable.
         */
        allow_fallbacks: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
        /**
         * Whether to filter providers to only those that support the parameters you've provided. If this setting is omitted or set to false, then providers will receive only the parameters they support, and ignore the rest.
         */
        require_parameters: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
        /**
         * Data collection setting. If no available model provider meets the requirement, your request will return an error.
         * - allow: (default) allow providers which store user data non-transiently and may train on it
         *
         * - deny: use only providers which do not collect user data.
         */
        data_collection: S.optionalWith<S.Literal<["deny", "allow"]>, {
            nullable: true;
        }>;
        zdr: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
        enforce_distillable_text: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
        /**
         * An ordered list of provider slugs. The router will attempt to use the first provider in the subset of this list that supports your requested model, and fall back to the next if it is unavailable. If no providers are available, the request will fail with an error message.
         */
        order: S.optionalWith<typeof Schema0, {
            nullable: true;
        }>;
        /**
         * List of provider slugs to allow. If provided, this list is merged with your account-wide allowed provider settings for this request.
         */
        only: S.optionalWith<typeof Schema0, {
            nullable: true;
        }>;
        /**
         * List of provider slugs to ignore. If provided, this list is merged with your account-wide ignored provider settings for this request.
         */
        ignore: S.optionalWith<typeof Schema0, {
            nullable: true;
        }>;
        /**
         * A list of quantization levels to filter the provider by.
         */
        quantizations: S.optionalWith<S.Array$<S.Literal<["int4", "int8", "fp4", "fp6", "fp8", "fp16", "bf16", "fp32", "unknown"]>>, {
            nullable: true;
        }>;
        /**
         * The sorting strategy to use for this request, if "order" is not specified. When set, no load balancing is performed.
         */
        sort: S.optionalWith<typeof ProviderSortUnion, {
            nullable: true;
        }>;
        /**
         * The object specifying the maximum price you want to pay for this request. USD price per million tokens, for prompt and completion.
         */
        max_price: S.optionalWith<S.Struct<{
            prompt: S.optionalWith<typeof Schema1, {
                nullable: true;
            }>;
            completion: S.optionalWith<typeof Schema1, {
                nullable: true;
            }>;
            image: S.optionalWith<typeof Schema1, {
                nullable: true;
            }>;
            audio: S.optionalWith<typeof Schema1, {
                nullable: true;
            }>;
            request: S.optionalWith<typeof Schema1, {
                nullable: true;
            }>;
        }>, {
            nullable: true;
        }>;
        /**
         * Preferred minimum throughput (in tokens per second). Can be a number (applies to p50) or an object with percentile-specific cutoffs. Endpoints below the threshold(s) may still be used, but are deprioritized in routing. When using fallback models, this may cause a fallback model to be used instead of the primary model if it meets the threshold.
         */
        preferred_min_throughput: S.optionalWith<S.Union<[typeof S.Number, S.Struct<{
            p50: S.optionalWith<typeof S.Number, {
                nullable: true;
            }>;
            p75: S.optionalWith<typeof S.Number, {
                nullable: true;
            }>;
            p90: S.optionalWith<typeof S.Number, {
                nullable: true;
            }>;
            p99: S.optionalWith<typeof S.Number, {
                nullable: true;
            }>;
        }>]>, {
            nullable: true;
        }>;
        /**
         * Preferred maximum latency (in seconds). Can be a number (applies to p50) or an object with percentile-specific cutoffs. Endpoints above the threshold(s) may still be used, but are deprioritized in routing. When using fallback models, this may cause a fallback model to be used instead of the primary model if it meets the threshold.
         */
        preferred_max_latency: S.optionalWith<S.Union<[typeof S.Number, S.Struct<{
            p50: S.optionalWith<typeof S.Number, {
                nullable: true;
            }>;
            p75: S.optionalWith<typeof S.Number, {
                nullable: true;
            }>;
            p90: S.optionalWith<typeof S.Number, {
                nullable: true;
            }>;
            p99: S.optionalWith<typeof S.Number, {
                nullable: true;
            }>;
        }>]>, {
            nullable: true;
        }>;
    }>, {
        nullable: true;
    }>;
    /**
     * Plugins you want to enable for this request, including their settings.
     */
    plugins: S.optionalWith<S.Array$<S.Record$<typeof S.String, typeof S.Unknown>>, {
        nullable: true;
    }>;
    route: S.optionalWith<typeof ChatGenerationParamsRouteEnum, {
        nullable: true;
    }>;
    user: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    /**
     * 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.
     */
    session_id: S.optionalWith<S.filter<typeof S.String>, {
        nullable: true;
    }>;
    messages: S.filter<S.NonEmptyArray<typeof Message>>;
    model: S.optionalWith<typeof ModelName, {
        nullable: true;
    }>;
    models: S.optionalWith<S.Array$<typeof ModelName>, {
        nullable: true;
    }>;
    frequency_penalty: S.optionalWith<S.filter<S.filter<typeof S.Number>>, {
        nullable: true;
    }>;
    logit_bias: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
        nullable: true;
    }>;
    logprobs: S.optionalWith<typeof S.Boolean, {
        nullable: true;
    }>;
    top_logprobs: S.optionalWith<S.filter<S.filter<typeof S.Number>>, {
        nullable: true;
    }>;
    max_completion_tokens: S.optionalWith<S.filter<typeof S.Number>, {
        nullable: true;
    }>;
    max_tokens: S.optionalWith<S.filter<typeof S.Number>, {
        nullable: true;
    }>;
    metadata: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
        nullable: true;
    }>;
    presence_penalty: S.optionalWith<S.filter<S.filter<typeof S.Number>>, {
        nullable: true;
    }>;
    reasoning: S.optionalWith<S.Struct<{
        effort: S.optionalWith<typeof ChatGenerationParamsReasoningEffortEnum, {
            nullable: true;
        }>;
        summary: S.optionalWith<typeof ReasoningSummaryVerbosity, {
            nullable: true;
        }>;
    }>, {
        nullable: true;
    }>;
    response_format: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
        nullable: true;
    }>;
    seed: S.optionalWith<S.filter<S.filter<typeof S.Int>>, {
        nullable: true;
    }>;
    stop: S.optionalWith<S.Union<[typeof S.String, S.filter<S.Array$<typeof S.String>>]>, {
        nullable: true;
    }>;
    stream: S.optionalWith<typeof S.Boolean, {
        nullable: true;
        default: () => false;
    }>;
    stream_options: S.optionalWith<typeof ChatStreamOptions, {
        nullable: true;
    }>;
    temperature: S.optionalWith<S.filter<S.filter<typeof S.Number>>, {
        nullable: true;
        default: () => 1;
    }>;
    tool_choice: S.optionalWith<typeof ToolChoiceOption, {
        nullable: true;
    }>;
    tools: S.optionalWith<S.Array$<typeof ToolDefinitionJson>, {
        nullable: true;
    }>;
    top_p: S.optionalWith<S.filter<S.filter<typeof S.Number>>, {
        nullable: true;
        default: () => 1;
    }>;
    debug: S.optionalWith<S.Struct<{
        echo_upstream_body: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
    }>, {
        nullable: true;
    }>;
    image_config: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
        nullable: true;
    }>;
    modalities: S.optionalWith<S.Array$<S.Literal<["text", "image"]>>, {
        nullable: true;
    }>;
}>, never, {
    readonly reasoning?: {
        readonly summary?: "auto" | "concise" | "detailed" | undefined;
        readonly effort?: "high" | "low" | "medium" | "xhigh" | "minimal" | "none" | undefined;
    } | undefined;
} & {
    readonly logprobs?: boolean | undefined;
} & {
    readonly top_logprobs?: number | undefined;
} & {
    readonly max_tokens?: number | undefined;
} & {
    readonly model?: string | undefined;
} & {
    readonly metadata?: {
        readonly [x: string]: unknown;
    } | undefined;
} & {
    readonly tools?: readonly ToolDefinitionJson[] | undefined;
} & {
    readonly tool_choice?: "auto" | "required" | "none" | NamedToolChoice | undefined;
} & {
    readonly models?: readonly string[] | undefined;
} & {
    readonly temperature?: number | undefined;
} & {
    readonly top_p?: number | undefined;
} & {
    readonly presence_penalty?: number | undefined;
} & {
    readonly frequency_penalty?: number | undefined;
} & {
    readonly image_config?: {
        readonly [x: string]: unknown;
    } | undefined;
} & {
    readonly modalities?: readonly ("text" | "image")[] | undefined;
} & {
    readonly stream?: boolean | undefined;
} & {
    readonly provider?: {
        readonly sort?: "price" | "throughput" | "latency" | ProviderSortConfig | undefined;
        readonly allow_fallbacks?: boolean | undefined;
        readonly require_parameters?: boolean | undefined;
        readonly data_collection?: "deny" | "allow" | undefined;
        readonly zdr?: boolean | undefined;
        readonly enforce_distillable_text?: boolean | undefined;
        readonly order?: readonly string[] | undefined;
        readonly only?: readonly string[] | undefined;
        readonly ignore?: readonly string[] | undefined;
        readonly quantizations?: readonly ("unknown" | "int4" | "int8" | "fp4" | "fp6" | "fp8" | "fp16" | "bf16" | "fp32")[] | undefined;
        readonly max_price?: {
            readonly image?: string | number | undefined;
            readonly prompt?: string | number | undefined;
            readonly completion?: string | number | undefined;
            readonly audio?: string | number | undefined;
            readonly request?: string | number | undefined;
        } | undefined;
        readonly preferred_min_throughput?: number | {
            readonly p50?: number | undefined;
            readonly p75?: number | undefined;
            readonly p90?: number | undefined;
            readonly p99?: number | undefined;
        } | undefined;
        readonly preferred_max_latency?: number | {
            readonly p50?: number | undefined;
            readonly p75?: number | undefined;
            readonly p90?: number | undefined;
            readonly p99?: number | undefined;
        } | undefined;
    } | undefined;
} & {
    readonly plugins?: readonly {
        readonly [x: string]: unknown;
    }[] | undefined;
} & {
    readonly route?: "sort" | "fallback" | undefined;
} & {
    readonly user?: string | undefined;
} & {
    readonly session_id?: string | undefined;
} & {
    readonly messages: readonly [{
        readonly [x: string]: unknown;
    }, ...{
        readonly [x: string]: unknown;
    }[]];
} & {
    readonly max_completion_tokens?: number | undefined;
} & {
    readonly logit_bias?: {
        readonly [x: string]: unknown;
    } | undefined;
} & {
    readonly seed?: number | undefined;
} & {
    readonly response_format?: {
        readonly [x: string]: unknown;
    } | undefined;
} & {
    readonly stop?: string | readonly string[] | undefined;
} & {
    readonly stream_options?: ChatStreamOptions | undefined;
} & {
    readonly debug?: {
        readonly echo_upstream_body?: boolean | undefined;
    } | undefined;
}, {}, {}>;
export declare class ChatGenerationParams extends ChatGenerationParams_base {
}
declare const ChatCompletionFinishReason_base: S.Literal<["tool_calls", "stop", "length", "content_filter", "error"]>;
export declare class ChatCompletionFinishReason extends ChatCompletionFinishReason_base {
}
declare const Schema6_base: S.Union<[typeof ChatCompletionFinishReason, typeof S.Null]>;
export declare class Schema6 extends Schema6_base {
}
declare const ChatMessageTokenLogprob_base: S.Class<ChatMessageTokenLogprob, {
    token: typeof S.String;
    logprob: typeof S.Number;
    bytes: S.NullOr<S.Array$<typeof S.Number>>;
    top_logprobs: S.Array$<S.Struct<{
        token: typeof S.String;
        logprob: typeof S.Number;
        bytes: S.NullOr<S.Array$<typeof S.Number>>;
    }>>;
}, S.Struct.Encoded<{
    token: typeof S.String;
    logprob: typeof S.Number;
    bytes: S.NullOr<S.Array$<typeof S.Number>>;
    top_logprobs: S.Array$<S.Struct<{
        token: typeof S.String;
        logprob: typeof S.Number;
        bytes: S.NullOr<S.Array$<typeof S.Number>>;
    }>>;
}>, never, {
    readonly token: string;
} & {
    readonly bytes: readonly number[] | null;
} & {
    readonly logprob: number;
} & {
    readonly top_logprobs: readonly {
        readonly token: string;
        readonly bytes: readonly number[] | null;
        readonly logprob: number;
    }[];
}, {}, {}>;
export declare class ChatMessageTokenLogprob extends ChatMessageTokenLogprob_base {
}
declare const ChatMessageTokenLogprobs_base: S.Class<ChatMessageTokenLogprobs, {
    content: S.optionalWith<S.Array$<typeof ChatMessageTokenLogprob>, {
        nullable: true;
    }>;
    refusal: S.optionalWith<S.Array$<typeof ChatMessageTokenLogprob>, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    content: S.optionalWith<S.Array$<typeof ChatMessageTokenLogprob>, {
        nullable: true;
    }>;
    refusal: S.optionalWith<S.Array$<typeof ChatMessageTokenLogprob>, {
        nullable: true;
    }>;
}>, never, {
    readonly content?: readonly ChatMessageTokenLogprob[] | undefined;
} & {
    readonly refusal?: readonly ChatMessageTokenLogprob[] | undefined;
}, {}, {}>;
export declare class ChatMessageTokenLogprobs extends ChatMessageTokenLogprobs_base {
}
declare const ChatResponseChoice_base: S.Class<ChatResponseChoice, {
    finish_reason: S.NullOr<typeof ChatCompletionFinishReason>;
    index: typeof S.Number;
    message: typeof AssistantMessage;
    logprobs: S.optionalWith<typeof ChatMessageTokenLogprobs, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    finish_reason: S.NullOr<typeof ChatCompletionFinishReason>;
    index: typeof S.Number;
    message: typeof AssistantMessage;
    logprobs: S.optionalWith<typeof ChatMessageTokenLogprobs, {
        nullable: true;
    }>;
}>, never, {
    readonly index: number;
} & {
    readonly message: AssistantMessage;
} & {
    readonly logprobs?: ChatMessageTokenLogprobs | undefined;
} & {
    readonly finish_reason: "length" | "content_filter" | "error" | "stop" | "tool_calls" | null;
}, {}, {}>;
export declare class ChatResponseChoice extends ChatResponseChoice_base {
}
declare const ChatGenerationTokenUsage_base: S.Class<ChatGenerationTokenUsage, {
    completion_tokens: typeof S.Number;
    prompt_tokens: typeof S.Number;
    total_tokens: typeof S.Number;
    completion_tokens_details: S.optionalWith<S.Struct<{
        reasoning_tokens: S.optionalWith<typeof S.Number, {
            nullable: true;
        }>;
        audio_tokens: S.optionalWith<typeof S.Number, {
            nullable: true;
        }>;
        accepted_prediction_tokens: S.optionalWith<typeof S.Number, {
            nullable: true;
        }>;
        rejected_prediction_tokens: S.optionalWith<typeof S.Number, {
            nullable: true;
        }>;
    }>, {
        nullable: true;
    }>;
    prompt_tokens_details: S.optionalWith<S.Struct<{
        cached_tokens: S.optionalWith<typeof S.Number, {
            nullable: true;
        }>;
        cache_write_tokens: S.optionalWith<typeof S.Number, {
            nullable: true;
        }>;
        audio_tokens: S.optionalWith<typeof S.Number, {
            nullable: true;
        }>;
        video_tokens: S.optionalWith<typeof S.Number, {
            nullable: true;
        }>;
    }>, {
        nullable: true;
    }>;
    cost: S.optionalWith<typeof S.Number, {
        nullable: true;
    }>;
    cost_details: S.optionalWith<S.Struct<{
        upstream_inference_cost: S.optionalWith<typeof S.Number, {
            nullable: true;
        }>;
    }>, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    completion_tokens: typeof S.Number;
    prompt_tokens: typeof S.Number;
    total_tokens: typeof S.Number;
    completion_tokens_details: S.optionalWith<S.Struct<{
        reasoning_tokens: S.optionalWith<typeof S.Number, {
            nullable: true;
        }>;
        audio_tokens: S.optionalWith<typeof S.Number, {
            nullable: true;
        }>;
        accepted_prediction_tokens: S.optionalWith<typeof S.Number, {
            nullable: true;
        }>;
        rejected_prediction_tokens: S.optionalWith<typeof S.Number, {
            nullable: true;
        }>;
    }>, {
        nullable: true;
    }>;
    prompt_tokens_details: S.optionalWith<S.Struct<{
        cached_tokens: S.optionalWith<typeof S.Number, {
            nullable: true;
        }>;
        cache_write_tokens: S.optionalWith<typeof S.Number, {
            nullable: true;
        }>;
        audio_tokens: S.optionalWith<typeof S.Number, {
            nullable: true;
        }>;
        video_tokens: S.optionalWith<typeof S.Number, {
            nullable: true;
        }>;
    }>, {
        nullable: true;
    }>;
    cost: S.optionalWith<typeof S.Number, {
        nullable: true;
    }>;
    cost_details: S.optionalWith<S.Struct<{
        upstream_inference_cost: S.optionalWith<typeof S.Number, {
            nullable: true;
        }>;
    }>, {
        nullable: true;
    }>;
}>, never, {
    readonly total_tokens: number;
} & {
    readonly prompt_tokens: number;
} & {
    readonly completion_tokens: number;
} & {
    readonly cost?: number | undefined;
} & {
    readonly completion_tokens_details?: {
        readonly reasoning_tokens?: number | undefined;
        readonly audio_tokens?: number | undefined;
        readonly accepted_prediction_tokens?: number | undefined;
        readonly rejected_prediction_tokens?: number | undefined;
    } | undefined;
} & {
    readonly prompt_tokens_details?: {
        readonly cached_tokens?: number | undefined;
        readonly audio_tokens?: number | undefined;
        readonly cache_write_tokens?: number | undefined;
        readonly video_tokens?: number | undefined;
    } | undefined;
} & {
    readonly cost_details?: {
        readonly upstream_inference_cost?: number | undefined;
    } | undefined;
}, {}, {}>;
export declare class ChatGenerationTokenUsage extends ChatGenerationTokenUsage_base {
}
declare const ChatResponse_base: S.Class<ChatResponse, {
    id: typeof S.String;
    provider: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    choices: S.Array$<typeof ChatResponseChoice>;
    created: typeof S.Number;
    model: typeof S.String;
    object: S.Literal<["chat.completion"]>;
    system_fingerprint: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    usage: S.optionalWith<typeof ChatGenerationTokenUsage, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    id: typeof S.String;
    provider: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    choices: S.Array$<typeof ChatResponseChoice>;
    created: typeof S.Number;
    model: typeof S.String;
    object: S.Literal<["chat.completion"]>;
    system_fingerprint: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    usage: S.optionalWith<typeof ChatGenerationTokenUsage, {
        nullable: true;
    }>;
}>, never, {
    readonly object: "chat.completion";
} & {
    readonly id: string;
} & {
    readonly model: string;
} & {
    readonly provider?: string | undefined;
} & {
    readonly usage?: ChatGenerationTokenUsage | undefined;
} & {
    readonly created: number;
} & {
    readonly choices: readonly ChatResponseChoice[];
} & {
    readonly system_fingerprint?: string | undefined;
}, {}, {}>;
export declare class ChatResponse extends ChatResponse_base {
}
declare const ChatError_base: S.Class<ChatError, {
    error: S.Struct<{
        code: S.NullOr<S.Union<[typeof S.String, typeof S.Number]>>;
        message: typeof S.String;
        param: S.optionalWith<typeof S.String, {
            nullable: true;
        }>;
        type: S.optionalWith<typeof S.String, {
            nullable: true;
        }>;
    }>;
}, S.Struct.Encoded<{
    error: S.Struct<{
        code: S.NullOr<S.Union<[typeof S.String, typeof S.Number]>>;
        message: typeof S.String;
        param: S.optionalWith<typeof S.String, {
            nullable: true;
        }>;
        type: S.optionalWith<typeof S.String, {
            nullable: true;
        }>;
    }>;
}>, never, {
    readonly error: {
        readonly type?: string | undefined;
        readonly message: string;
        readonly code: string | number | null;
        readonly param?: string | undefined;
    };
}, {}, {}>;
export declare class ChatError extends ChatError_base {
}
declare const CompletionCreateParams_base: S.Class<CompletionCreateParams, {
    model: S.optionalWith<typeof ModelName, {
        nullable: true;
    }>;
    models: S.optionalWith<S.Array$<typeof ModelName>, {
        nullable: true;
    }>;
    prompt: S.Union<[typeof S.String, S.Array$<typeof S.String>, S.Array$<typeof S.Number>, S.Array$<S.Array$<typeof S.Number>>]>;
    best_of: S.optionalWith<S.filter<S.filter<typeof S.Int>>, {
        nullable: true;
    }>;
    echo: S.optionalWith<typeof S.Boolean, {
        nullable: true;
    }>;
    frequency_penalty: S.optionalWith<S.filter<S.filter<typeof S.Number>>, {
        nullable: true;
    }>;
    logit_bias: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
        nullable: true;
    }>;
    logprobs: S.optionalWith<S.filter<S.filter<typeof S.Int>>, {
        nullable: true;
    }>;
    max_tokens: S.optionalWith<S.filter<S.filter<typeof S.Int>>, {
        nullable: true;
    }>;
    n: S.optionalWith<S.filter<S.filter<typeof S.Int>>, {
        nullable: true;
    }>;
    presence_penalty: S.optionalWith<S.filter<S.filter<typeof S.Number>>, {
        nullable: true;
    }>;
    seed: S.optionalWith<S.filter<S.filter<typeof S.Int>>, {
        nullable: true;
    }>;
    stop: S.optionalWith<S.Union<[typeof S.String, S.Array$<typeof S.String>]>, {
        nullable: true;
    }>;
    stream: S.optionalWith<typeof S.Boolean, {
        nullable: true;
        default: () => false;
    }>;
    stream_options: S.optionalWith<S.Struct<{
        include_usage: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
    }>, {
        nullable: true;
    }>;
    suffix: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    temperature: S.optionalWith<S.filter<S.filter<typeof S.Number>>, {
        nullable: true;
    }>;
    top_p: S.optionalWith<S.filter<S.filter<typeof S.Number>>, {
        nullable: true;
    }>;
    user: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    metadata: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
        nullable: true;
    }>;
    response_format: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    model: S.optionalWith<typeof ModelName, {
        nullable: true;
    }>;
    models: S.optionalWith<S.Array$<typeof ModelName>, {
        nullable: true;
    }>;
    prompt: S.Union<[typeof S.String, S.Array$<typeof S.String>, S.Array$<typeof S.Number>, S.Array$<S.Array$<typeof S.Number>>]>;
    best_of: S.optionalWith<S.filter<S.filter<typeof S.Int>>, {
        nullable: true;
    }>;
    echo: S.optionalWith<typeof S.Boolean, {
        nullable: true;
    }>;
    frequency_penalty: S.optionalWith<S.filter<S.filter<typeof S.Number>>, {
        nullable: true;
    }>;
    logit_bias: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
        nullable: true;
    }>;
    logprobs: S.optionalWith<S.filter<S.filter<typeof S.Int>>, {
        nullable: true;
    }>;
    max_tokens: S.optionalWith<S.filter<S.filter<typeof S.Int>>, {
        nullable: true;
    }>;
    n: S.optionalWith<S.filter<S.filter<typeof S.Int>>, {
        nullable: true;
    }>;
    presence_penalty: S.optionalWith<S.filter<S.filter<typeof S.Number>>, {
        nullable: true;
    }>;
    seed: S.optionalWith<S.filter<S.filter<typeof S.Int>>, {
        nullable: true;
    }>;
    stop: S.optionalWith<S.Union<[typeof S.String, S.Array$<typeof S.String>]>, {
        nullable: true;
    }>;
    stream: S.optionalWith<typeof S.Boolean, {
        nullable: true;
        default: () => false;
    }>;
    stream_options: S.optionalWith<S.Struct<{
        include_usage: S.optionalWith<typeof S.Boolean, {
            nullable: true;
        }>;
    }>, {
        nullable: true;
    }>;
    suffix: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    temperature: S.optionalWith<S.filter<S.filter<typeof S.Number>>, {
        nullable: true;
    }>;
    top_p: S.optionalWith<S.filter<S.filter<typeof S.Number>>, {
        nullable: true;
    }>;
    user: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    metadata: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
        nullable: true;
    }>;
    response_format: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
        nullable: true;
    }>;
}>, never, {
    readonly logprobs?: number | undefined;
} & {
    readonly max_tokens?: number | undefined;
} & {
    readonly model?: string | undefined;
} & {
    readonly metadata?: {
        readonly [x: string]: unknown;
    } | undefined;
} & {
    readonly models?: readonly string[] | undefined;
} & {
    readonly temperature?: number | undefined;
} & {
    readonly top_p?: number | undefined;
} & {
    readonly presence_penalty?: number | undefined;
} & {
    readonly frequency_penalty?: number | undefined;
} & {
    readonly prompt: string | readonly number[] | readonly (readonly number[])[] | readonly string[];
} & {
    readonly stream?: boolean | undefined;
} & {
    readonly user?: string | undefined;
} & {
    readonly logit_bias?: {
        readonly [x: string]: unknown;
    } | undefined;
} & {
    readonly seed?: number | undefined;
} & {
    readonly response_format?: {
        readonly [x: string]: unknown;
    } | undefined;
} & {
    readonly stop?: string | readonly string[] | undefined;
} & {
    readonly stream_options?: {
        readonly include_usage?: boolean | undefined;
    } | undefined;
} & {
    readonly best_of?: number | undefined;
} & {
    readonly echo?: boolean | undefined;
} & {
    readonly n?: number | undefined;
} & {
    readonly suffix?: string | undefined;
}, {}, {}>;
export declare class CompletionCreateParams extends CompletionCreateParams_base {
}
declare const CompletionLogprobs_base: S.Class<CompletionLogprobs, {
    tokens: S.Array$<typeof S.String>;
    token_logprobs: S.Array$<typeof S.Number>;
    top_logprobs: S.NullOr<S.Array$<S.Record$<typeof S.String, typeof S.Unknown>>>;
    text_offset: S.Array$<typeof S.Number>;
}, S.Struct.Encoded<{
    tokens: S.Array$<typeof S.String>;
    token_logprobs: S.Array$<typeof S.Number>;
    top_logprobs: S.NullOr<S.Array$<S.Record$<typeof S.String, typeof S.Unknown>>>;
    text_offset: S.Array$<typeof S.Number>;
}>, never, {
    readonly top_logprobs: readonly {
        readonly [x: string]: unknown;
    }[] | null;
} & {
    readonly tokens: readonly string[];
} & {
    readonly token_logprobs: readonly number[];
} & {
    readonly text_offset: readonly number[];
}, {}, {}>;
export declare class CompletionLogprobs extends CompletionLogprobs_base {
}
declare const CompletionFinishReasonEnum_base: S.Literal<["stop", "length", "content_filter"]>;
export declare class CompletionFinishReasonEnum extends CompletionFinishReasonEnum_base {
}
declare const CompletionFinishReason_base: S.Union<[typeof CompletionFinishReasonEnum, typeof S.Null]>;
export declare class CompletionFinishReason extends CompletionFinishReason_base {
}
declare const CompletionChoice_base: S.Class<CompletionChoice, {
    text: typeof S.String;
    index: typeof S.Number;
    logprobs: S.NullOr<typeof CompletionLogprobs>;
    finish_reason: S.NullOr<S.Literal<["stop", "length", "content_filter"]>>;
    native_finish_reason: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    reasoning: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    text: typeof S.String;
    index: typeof S.Number;
    logprobs: S.NullOr<typeof CompletionLogprobs>;
    finish_reason: S.NullOr<S.Literal<["stop", "length", "content_filter"]>>;
    native_finish_reason: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    reasoning: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
}>, never, {
    readonly reasoning?: string | undefined;
} & {
    readonly text: string;
} & {
    readonly index: number;
} & {
    readonly logprobs: CompletionLogprobs | null;
} & {
    readonly finish_reason: "length" | "content_filter" | "stop" | null;
} & {
    readonly native_finish_reason?: string | undefined;
}, {}, {}>;
export declare class CompletionChoice extends CompletionChoice_base {
}
declare const CompletionUsage_base: S.Class<CompletionUsage, {
    prompt_tokens: typeof S.Number;
    completion_tokens: typeof S.Number;
    total_tokens: typeof S.Number;
}, S.Struct.Encoded<{
    prompt_tokens: typeof S.Number;
    completion_tokens: typeof S.Number;
    total_tokens: typeof S.Number;
}>, never, {
    readonly total_tokens: number;
} & {
    readonly prompt_tokens: number;
} & {
    readonly completion_tokens: number;
}, {}, {}>;
export declare class CompletionUsage extends CompletionUsage_base {
}
declare const CompletionResponse_base: S.Class<CompletionResponse, {
    id: typeof S.String;
    object: S.Literal<["text_completion"]>;
    created: typeof S.Number;
    model: typeof S.String;
    provider: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    system_fingerprint: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    choices: S.Array$<typeof CompletionChoice>;
    usage: S.optionalWith<typeof CompletionUsage, {
        nullable: true;
    }>;
}, S.Struct.Encoded<{
    id: typeof S.String;
    object: S.Literal<["text_completion"]>;
    created: typeof S.Number;
    model: typeof S.String;
    provider: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    system_fingerprint: S.optionalWith<typeof S.String, {
        nullable: true;
    }>;
    choices: S.Array$<typeof CompletionChoice>;
    usage: S.optionalWith<typeof CompletionUsage, {
        nullable: true;
    }>;
}>, never, {
    readonly object: "text_completion";
} & {
    readonly id: string;
} & {
    readonly model: string;
} & {
    readonly provider?: string | undefined;
} & {
    readonly usage?: CompletionUsage | undefined;
} & {
    readonly created: number;
} & {
    readonly choices: readonly CompletionChoice[];
} & {
    readonly system_fingerprint?: string | undefined;
}, {}, {}>;
export declare class CompletionResponse extends CompletionResponse_base {
}
export declare const make: (httpClient: HttpClient.HttpClient, options?: {
    readonly transformClient?: ((client: HttpClient.HttpClient) => Effect.Effect<HttpClient.HttpClient>) | undefined;
}) => Client;
export interface Client {
    readonly httpClient: HttpClient.HttpClient;
    /**
     * Creates a streaming or non-streaming response using OpenResponses API format
     */
    readonly "createResponses": (options: typeof OpenResponsesRequest.Encoded) => Effect.Effect<typeof OpenResponsesNonStreamingResponse.Type, HttpClientError.HttpClientError | ParseError | ClientError<"BadRequestResponse", typeof BadRequestResponse.Type> | ClientError<"UnauthorizedResponse", typeof UnauthorizedResponse.Type> | ClientError<"PaymentRequiredResponse", typeof PaymentRequiredResponse.Type> | ClientError<"NotFoundResponse", typeof NotFoundResponse.Type> | ClientError<"RequestTimeoutResponse", typeof RequestTimeoutResponse.Type> | ClientError<"PayloadTooLargeResponse", typeof PayloadTooLargeResponse.Type> | ClientError<"UnprocessableEntityResponse", typeof UnprocessableEntityResponse.Type> | ClientError<"TooManyRequestsResponse", typeof TooManyRequestsResponse.Type> | ClientError<"InternalServerResponse", typeof InternalServerResponse.Type> | ClientError<"BadGatewayResponse", typeof BadGatewayResponse.Type> | ClientError<"ServiceUnavailableResponse", typeof ServiceUnavailableResponse.Type> | ClientError<"EdgeNetworkTimeoutResponse", typeof EdgeNetworkTimeoutResponse.Type> | ClientError<"ProviderOverloadedResponse", typeof ProviderOverloadedResponse.Type>>;
    /**
     * Creates a message using the Anthropic Messages API format. Supports text, images, PDFs, tools, and extended thinking.
     */
    readonly "createMessages": (options: typeof AnthropicMessagesRequest.Encoded) => Effect.Effect<typeof AnthropicMessagesResponse.Type, HttpClientError.HttpClientError | ParseError | ClientError<"CreateMessages400", typeof CreateMessages400.Type> | ClientError<"CreateMessages401", typeof CreateMessages401.Type> | ClientError<"CreateMessages403", typeof CreateMessages403.Type> | ClientError<"CreateMessages404", typeof CreateMessages404.Type> | ClientError<"CreateMessages429", typeof CreateMessages429.Type> | ClientError<"CreateMessages500", typeof CreateMessages500.Type> | ClientError<"CreateMessages503", typeof CreateMessages503.Type> | ClientError<"CreateMessages529", typeof CreateMessages529.Type>>;
    /**
     * Returns user activity data grouped by endpoint for the last 30 (completed) UTC days. [Provisioning key](/docs/guides/overview/auth/provisioning-api-keys) required.
     */
    readonly "getUserActivity": (options?: typeof GetUserActivityParams.Encoded | undefined) => Effect.Effect<typeof GetUserActivity200.Type, HttpClientError.HttpClientError | ParseError | ClientError<"BadRequestResponse", typeof BadRequestResponse.Type> | ClientError<"UnauthorizedResponse", typeof UnauthorizedResponse.Type> | ClientError<"ForbiddenResponse", typeof ForbiddenResponse.Type> | ClientError<"InternalServerResponse", typeof InternalServerResponse.Type>>;
    /**
     * Get total credits purchased and used for the authenticated user. [Provisioning key](/docs/guides/overview/auth/provisioning-api-keys) required.
     */
    readonly "getCredits": () => Effect.Effect<typeof GetCredits200.Type, HttpClientError.HttpClientError | ParseError | ClientError<"UnauthorizedResponse", typeof UnauthorizedResponse.Type> | ClientError<"ForbiddenResponse", typeof ForbiddenResponse.Type> | ClientError<"InternalServerResponse", typeof InternalServerResponse.Type>>;
    /**
     * Create a Coinbase charge for crypto payment
     */
    readonly "createCoinbaseCharge": (options: typeof CreateChargeRequest.Encoded) => Effect.Effect<typeof CreateCoinbaseCharge200.Type, HttpClientError.HttpClientError | ParseError | ClientError<"BadRequestResponse", typeof BadRequestResponse.Type> | ClientError<"UnauthorizedResponse", typeof UnauthorizedResponse.Type> | ClientError<"TooManyRequestsResponse", typeof TooManyRequestsResponse.Type> | ClientError<"InternalServerResponse", typeof InternalServerResponse.Type>>;
    /**
     * Submits an embedding request to the embeddings router
     */
    readonly "createEmbeddings": (options: typeof CreateEmbeddingsRequest.Encoded) => Effect.Effect<typeof CreateEmbeddings200.Type, HttpClientError.HttpClientError | ParseError | ClientError<"BadRequestResponse", typeof BadRequestResponse.Type> | ClientError<"UnauthorizedResponse", typeof UnauthorizedResponse.Type> | ClientError<"PaymentRequiredResponse", typeof PaymentRequiredResponse.Type> | ClientError<"NotFoundResponse", typeof NotFoundResponse.Type> | ClientError<"TooManyRequestsResponse", typeof TooManyRequestsResponse.Type> | ClientError<"InternalServerResponse", typeof InternalServerResponse.Type> | ClientError<"BadGatewayResponse", typeof BadGatewayResponse.Type> | ClientError<"ServiceUnavailableResponse", typeof ServiceUnavailableResponse.Type> | ClientError<"EdgeNetworkTimeoutResponse", typeof EdgeNetworkTimeoutResponse.Type> | ClientError<"ProviderOverloadedResponse", typeof ProviderOverloadedResponse.Type>>;
    /**
     * Returns a list of all available embeddings models and their properties
     */
    readonly "listEmbeddingsModels": () => Effect.Effect<typeof ModelsListResponse.Type, HttpClientError.HttpClientError | ParseError | ClientError<"BadRequestResponse", typeof BadRequestResponse.Type> | ClientError<"InternalServerResponse", typeof InternalServerResponse.Type>>;
    /**
     * Get request & usage metadata for a generation
     */
    readonly "getGeneration": (options: typeof GetGenerationParams.Encoded) => Effect.Effect<typeof GetGeneration200.Type, HttpClientError.HttpClientError | ParseError | ClientError<"UnauthorizedResponse", typeof UnauthorizedResponse.Type> | ClientError<"PaymentRequiredResponse", typeof PaymentRequiredResponse.Type> | ClientError<"NotFoundResponse", typeof NotFoundResponse.Type> | ClientError<"TooManyRequestsResponse", typeof TooManyRequestsResponse.Type> | ClientError<"InternalServerResponse", typeof InternalServerResponse.Type> | ClientError<"BadGatewayResponse", typeof BadGatewayResponse.Type> | ClientError<"EdgeNetworkTimeoutResponse", typeof EdgeNetworkTimeoutResponse.Type> | ClientError<"ProviderOverloadedResponse", typeof ProviderOverloadedResponse.Type>>;
    /**
     * Get total count of available models
     */
    readonly "listModelsCount": () => Effect.Effect<typeof ModelsCountResponse.Type, HttpClientError.HttpClientError | ParseError | ClientError<"InternalServerResponse", typeof InternalServerResponse.Type>>;
    /**
     * List all models and their properties
     */
    readonly "getModels": (options?: typeof GetModelsParams.Encoded | undefined) => Effect.Effect<typeof ModelsListResponse.Type, HttpClientError.HttpClientError | ParseError | ClientError<"BadRequestResponse", typeof BadRequestResponse.Type> | ClientError<"InternalServerResponse", typeof InternalServerResponse.Type>>;
    /**
     * List models filtered by user provider preferences
     */
    readonly "listModelsUser": () => Effect.Effect<typeof ModelsListResponse.Type, HttpClientError.HttpClientError | ParseError | ClientError<"UnauthorizedResponse", typeof UnauthorizedResponse.Type> | ClientError<"InternalServerResponse", typeof InternalServerResponse.Type>>;
    /**
     * List all endpoints for a model
     */
    readonly "listEndpoints": (author: string, slug: string) => Effect.Effect<typeof ListEndpoints200.Type, HttpClientError.HttpClientError | ParseError | ClientError<"NotFoundResponse", typeof NotFoundResponse.Type> | ClientError<"InternalServerResponse", typeof InternalServerResponse.Type>>;
    /**
     * Preview the impact of ZDR on the available endpoints
     */
    readonly "listEndpointsZdr": () => Effect.Effect<typeof ListEndpointsZdr200.Type, HttpClientError.HttpClientError | ParseError | ClientError<"InternalServerResponse", typeof InternalServerResponse.Type>>;
    /**
     * List all providers
     */
    readonly "listProviders": () => Effect.Effect<typeof ListProviders200.Type, HttpClientError.HttpClientError | ParseError | ClientError<"InternalServerResponse", typeof InternalServerResponse.Type>>;
    /**
     * List all API keys for the authenticated user. [Provisioning key](/docs/guides/overview/auth/provisioning-api-keys) required.
     */
    readonly "list": (options?: typeof ListParams.Encoded | undefined) => Effect.Effect<typeof List200.Type, HttpClientError.HttpClientError | ParseError | ClientError<"UnauthorizedResponse", typeof UnauthorizedResponse.Type> | ClientError<"TooManyRequestsResponse", typeof TooManyRequestsResponse.Type> | ClientError<"InternalServerResponse", typeof InternalServerResponse.Type>>;
    /**
     * Create a new API key for the authenticated user. [Provisioning key](/docs/guides/overview/auth/provisioning-api-keys) required.
     */
    readonly "createKeys": (options: typeof CreateKeysRequest.Encoded) => Effect.Effect<typeof CreateKeys201.Type, HttpClientError.HttpClientError | ParseError | ClientError<"BadRequestResponse", typeof BadRequestResponse.Type> | ClientError<"UnauthorizedResponse", typeof UnauthorizedResponse.Type> | ClientError<"TooManyRequestsResponse", typeof TooManyRequestsResponse.Type> | ClientError<"InternalServerResponse", typeof InternalServerResponse.Type>>;
    /**
     * Get a single API key by hash. [Provisioning key](/docs/guides/overview/auth/provisioning-api-keys) required.
     */
    readonly "getKey": (hash: string) => Effect.Effect<typeof GetKey200.Type, HttpClientError.HttpClientError | ParseError | ClientError<"UnauthorizedResponse", typeof UnauthorizedResponse.Type> | ClientError<"NotFoundResponse", typeof NotFoundResponse.Type> | ClientError<"TooManyRequestsResponse", typeof TooManyRequestsResponse.Type> | ClientError<"InternalServerResponse", typeof InternalServerResponse.Type>>;
    /**
     * Delete an existing API key. [Provisioning key](/docs/guides/overview/auth/provisioning-api-keys) required.
     */
    readonly "deleteKeys": (hash: string) => Effect.Effect<typeof DeleteKeys200.Type, HttpClientError.HttpClientError | ParseError | ClientError<"UnauthorizedResponse", typeof UnauthorizedResponse.Type> | ClientError<"NotFoundResponse", typeof NotFoundResponse.Type> | ClientError<"TooManyRequestsResponse", typeof TooManyRequestsResponse.Type> | ClientError<"InternalServerResponse", typeof InternalServerResponse.Type>>;
    /**
     * Update an existing API key. [Provisioning key](/docs/guides/overview/auth/provisioning-api-keys) required.
     */
    readonly "updateKeys": (hash: string, options: typeof UpdateKeysRequest.Encoded) => Effect.Effect<typeof UpdateKeys200.Type, HttpClientError.HttpClientError | ParseError | ClientError<"BadRequestResponse", typeof BadRequestResponse.Type> | ClientError<"UnauthorizedResponse", typeof UnauthorizedResponse.Type> | ClientError<"NotFoundResponse", typeof NotFoundResponse.Type> | ClientError<"TooManyRequestsResponse", typeof TooManyRequestsResponse.Type> | ClientError<"InternalServerResponse", typeof InternalServerResponse.Type>>;
    /**
     * List all guardrails for the authenticated user. [Provisioning key](/docs/guides/overview/auth/provisioning-api-keys) required.
     */
    readonly "listGuardrails": (options?: typeof ListGuardrailsParams.Encoded | undefined) => Effect.Effect<typeof ListGuardrails200.Type, HttpClientError.HttpClientError | ParseError | ClientError<"UnauthorizedResponse", typeof UnauthorizedResponse.Type> | ClientError<"InternalServerResponse", typeof InternalServerResponse.Type>>;
    /**
     * Create a new guardrail for the authenticated user. [Provisioning key](/docs/guides/overview/auth/provisioning-api-keys) required.
     */
    readonly "createGuardrail": (options: typeof CreateGuardrailRequest.Encoded) => Effect.Effect<typeof CreateGuardrail201.Type, HttpClientError.HttpClientError | ParseError | ClientError<"BadRequestResponse", typeof BadRequestResponse.Type> | ClientError<"UnauthorizedResponse", typeof UnauthorizedResponse.Type> | ClientError<"InternalServerResponse", typeof InternalServerResponse.Type>>;
    /**
     * Get a single guardrail by ID. [Provisioning key](/docs/guides/overview/auth/provisioning-api-keys) required.
     */
    readonly "getGuardrail": (id: string) => Effect.Effect<typeof GetGuardrail200.Type, HttpClientError.HttpClientError | ParseError | ClientError<"UnauthorizedResponse", typeof UnauthorizedResponse.Type> | ClientError<"NotFoundResponse", typeof NotFoundResponse.Type> | ClientError<"InternalServerResponse", typeof InternalServerResponse.Type>>;
    /**
     * Delete an existing guardrail. [Provisioning key](/docs/guides/overview/auth/provisioning-api-keys) required.
     */
    readonly "deleteGuardrail": (id: string) => Effect.Effect<typeof DeleteGuardrail200.Type, HttpClientError.HttpClientError | ParseError | ClientError<"UnauthorizedResponse", typeof UnauthorizedResponse.Type> | ClientError<"NotFoundResponse", typeof NotFoundResponse.Type> | ClientError<"InternalServerResponse", typeof InternalServerResponse.Type>>;
    /**
     * Update an existing guardrail. [Provisioning key](/docs/guides/overview/auth/provisioning-api-keys) required.
     */
    readonly "updateGuardrail": (id: string, options: typeof UpdateGuardrailRequest.Encoded) => Effect.Effect<typeof UpdateGuardrail200.Type, HttpClientError.HttpClientError | ParseError | ClientError<"BadRequestResponse", typeof BadRequestResponse.Type> | ClientError<"UnauthorizedResponse", typeof UnauthorizedResponse.Type> | ClientError<"NotFoundResponse", typeof NotFoundResponse.Type> | ClientError<"InternalServerResponse", typeof InternalServerResponse.Type>>;
    /**
     * List all API key guardrail assignments for the authenticated user. [Provisioning key](/docs/guides/overview/auth/provisioning-api-keys) required.
     */
    readonly "listKeyAssignments": (options?: typeof ListKeyAssignmentsParams.Encoded | undefined) => Effect.Effect<typeof ListKeyAssignments200.Type, HttpClientError.HttpClientError | ParseError | ClientError<"UnauthorizedResponse", typeof UnauthorizedResponse.Type> | ClientError<"InternalServerResponse", typeof InternalServerResponse.Type>>;
    /**
     * List all organization member guardrail assignments for the authenticated user. [Provisioning key](/docs/guides/overview/auth/provisioning-api-keys) required.
     */
    readonly "listMemberAssignments": (options?: typeof ListMemberAssignmentsParams.Encoded | undefined) => Effect.Effect<typeof ListMemberAssignments200.Type, HttpClientError.HttpClientError | ParseError | ClientError<"UnauthorizedResponse", typeof UnauthorizedResponse.Type> | ClientError<"InternalServerResponse", typeof InternalServerResponse.Type>>;
    /**
     * List all API key assignments for a specific guardrail. [Provisioning key](/docs/guides/overview/auth/provisioning-api-keys) required.
     */
    readonly "listGuardrailKeyAssignments": (id: string, options?: typeof ListGuardrailKeyAssignmentsParams.Encoded | undefined) => Effect.Effect<typeof ListGuardrailKeyAssignments200.Type, HttpClientError.HttpClientError | ParseError | ClientError<"UnauthorizedResponse", typeof UnauthorizedResponse.Type> | ClientError<"NotFoundResponse", typeof NotFoundResponse.Type> | ClientError<"InternalServerResponse", typeof InternalServerResponse.Type>>;
    /**
     * Assign multiple API keys to a specific guardrail. [Provisioning key](/docs/guides/overview/auth/provisioning-api-keys) required.
     */
    readonly "bulkAssignKeysToGuardrail": (id: string, options: typeof BulkAssignKeysToGuardrailRequest.Encoded) => Effect.Effect<typeof BulkAssignKeysToGuardrail200.Type, HttpClientError.HttpClientError | ParseError | ClientError<"BadRequestResponse", typeof BadRequestResponse.Type> | ClientError<"UnauthorizedResponse", typeof UnauthorizedResponse.Type> | ClientError<"NotFoundResponse", typeof NotFoundResponse.Type> | ClientError<"InternalServerResponse", typeof InternalServerResponse.Type>>;
    /**
     * List all organization member assignments for a specific guardrail. [Provisioning key](/docs/guides/overview/auth/provisioning-api-keys) required.
     */
    readonly "listGuardrailMemberAssignments": (id: string, options?: typeof ListGuardrailMemberAssignmentsParams.Encoded | undefined) => Effect.Effect<typeof ListGuardrailMemberAssignments200.Type, HttpClientError.HttpClientError | ParseError | ClientError<"UnauthorizedResponse", typeof UnauthorizedResponse.Type> | ClientError<"NotFoundResponse", typeof NotFoundResponse.Type> | ClientError<"InternalServerResponse", typeof InternalServerResponse.Type>>;
    /**
     * Assign multiple organization members to a specific guardrail. [Provisioning key](/docs/guides/overview/auth/provisioning-api-keys) required.
     */
    readonly "bulkAssignMembersToGuardrail": (id: string, options: typeof BulkAssignMembersToGuardrailRequest.Encoded) => Effect.Effect<typeof BulkAssignMembersToGuardrail200.Type, HttpClientError.HttpClientError | ParseError | ClientError<"BadRequestResponse", typeof BadRequestResponse.Type> | ClientError<"UnauthorizedResponse", typeof UnauthorizedResponse.Type> | ClientError<"NotFoundResponse", typeof NotFoundResponse.Type> | ClientError<"InternalServerResponse", typeof InternalServerResponse.Type>>;
    /**
     * Unassign multiple API keys from a specific guardrail. [Provisioning key](/docs/guides/overview/auth/provisioning-api-keys) required.
     */
    readonly "bulkUnassignKeysFromGuardrail": (id: string, options: typeof BulkUnassignKeysFromGuardrailRequest.Encoded) => Effect.Effect<typeof BulkUnassignKeysFromGuardrail200.Type, HttpClientError.HttpClientError | ParseError | ClientError<"BadRequestResponse", typeof BadRequestResponse.Type> | ClientError<"UnauthorizedResponse", typeof UnauthorizedResponse.Type> | ClientError<"NotFoundResponse", typeof NotFoundResponse.Type> | ClientError<"InternalServerResponse", typeof InternalServerResponse.Type>>;
    /**
     * Unassign multiple organization members from a specific guardrail. [Provisioning key](/docs/guides/overview/auth/provisioning-api-keys) required.
     */
    readonly "bulkUnassignMembersFromGuardrail": (id: string, options: typeof BulkUnassignMembersFromGuardrailRequest.Encoded) => Effect.Effect<typeof BulkUnassignMembersFromGuardrail200.Type, HttpClientError.HttpClientError | ParseError | ClientError<"BadRequestResponse", typeof BadRequestResponse.Type> | ClientError<"UnauthorizedResponse", typeof UnauthorizedResponse.Type> | ClientError<"NotFoundResponse", typeof NotFoundResponse.Type> | ClientError<"InternalServerResponse", typeof InternalServerResponse.Type>>;
    /**
     * Get information on the API key associated with the current authentication session
     */
    readonly "getCurrentKey": () => Effect.Effect<typeof GetCurrentKey200.Type, HttpClientError.HttpClientError | ParseError | ClientError<"UnauthorizedResponse", typeof UnauthorizedResponse.Type> | ClientError<"InternalServerResponse", typeof InternalServerResponse.Type>>;
    /**
     * Exchange an authorization code from the PKCE flow for a user-controlled API key
     */
    readonly "exchangeAuthCodeForAPIKey": (options: typeof ExchangeAuthCodeForAPIKeyRequest.Encoded) => Effect.Effect<typeof ExchangeAuthCodeForAPIKey200.Type, HttpClientError.HttpClientError | ParseError | ClientError<"BadRequestResponse", typeof BadRequestResponse.Type> | ClientError<"ForbiddenResponse", typeof ForbiddenResponse.Type> | ClientError<"InternalServerResponse", typeof InternalServerResponse.Type>>;
    /**
     * Create an authorization code for the PKCE flow to generate a user-controlled API key
     */
    readonly "createAuthKeysCode": (options: typeof CreateAuthKeysCodeRequest.Encoded) => Effect.Effect<typeof CreateAuthKeysCode200.Type, HttpClientError.HttpClientError | ParseError | ClientError<"BadRequestResponse", typeof BadRequestResponse.Type> | ClientError<"UnauthorizedResponse", typeof UnauthorizedResponse.Type> | ClientError<"InternalServerResponse", typeof InternalServerResponse.Type>>;
    /**
     * Sends a request for a model response for the given chat conversation. Supports both streaming and non-streaming modes.
     */
    readonly "sendChatCompletionRequest": (options: typeof ChatGenerationParams.Encoded) => Effect.Effect<typeof ChatResponse.Type, HttpClientError.HttpClientError | ParseError | ClientError<"ChatError", typeof ChatError.Type> | ClientError<"ChatError", typeof ChatError.Type> | ClientError<"ChatError", typeof ChatError.Type> | ClientError<"ChatError", typeof ChatError.Type>>;
    /**
     * Creates a completion for the provided prompt and parameters. Supports both streaming and non-streaming modes.
     */
    readonly "createCompletions": (options: typeof CompletionCreateParams.Encoded) => Effect.Effect<typeof CompletionResponse.Type, HttpClientError.HttpClientError | ParseError | ClientError<"ChatError", typeof ChatError.Type> | ClientError<"ChatError", typeof ChatError.Type> | ClientError<"ChatError", typeof ChatError.Type> | ClientError<"ChatError", typeof ChatError.Type>>;
}
export interface ClientError<Tag extends string, E> {
    readonly _tag: Tag;
    readonly request: HttpClientRequest.HttpClientRequest;
    readonly response: HttpClientResponse.HttpClientResponse;
    readonly cause: E;
}
export declare const ClientError: <Tag extends string, E>(tag: Tag, cause: E, response: HttpClientResponse.HttpClientResponse) => ClientError<Tag, E>;
export {};
//# sourceMappingURL=Generated.d.ts.map