@homeflare/distilled-litellm 0.2.0

package/dist/services/model_management.d.ts

@@ -0,0 +1,1649 @@
+import * as S from "@distilled.cloud/core/schema";
+import * as API from "@distilled.cloud/core/api";
+import { type LitellmOpError, type LitellmOpContext } from "../protocol.ts";
+export type { LitellmOpError, LitellmOpContext };
+declare const BadRequest_base: S.Class<BadRequest, S.TaggedStruct<"BadRequest", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
+export declare class BadRequest extends /*@__PURE__*/ BadRequest_base {
+}
+declare const UnprocessableEntity_base: S.Class<UnprocessableEntity, S.TaggedStruct<"UnprocessableEntity", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
+export declare class UnprocessableEntity extends /*@__PURE__*/ UnprocessableEntity_base {
+}
+export type LiteLLMParamsAdaptiveRouterConfigMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const LiteLLMParamsAdaptiveRouterConfigMap: S.Schema<LiteLLMParamsAdaptiveRouterConfigMap>;
+export type LiteLLMParamsBedrockTagsList = Array<unknown>;
+export declare const LiteLLMParamsBedrockTagsList: S.Schema<LiteLLMParamsBedrockTagsList>;
+export type LiteLLMParamsComplexityRouterConfigMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const LiteLLMParamsComplexityRouterConfigMap: S.Schema<LiteLLMParamsComplexityRouterConfigMap>;
+export interface ConfigurableClientsideParamsCustomAuthInput {
+    api_base: string;
+}
+export declare const ConfigurableClientsideParamsCustomAuthInput: S.Schema<ConfigurableClientsideParamsCustomAuthInput>;
+export type LiteLLMParamsConfigurableClientsideAuthParamsItem = string | ConfigurableClientsideParamsCustomAuthInput;
+export declare const LiteLLMParamsConfigurableClientsideAuthParamsItem: S.Schema<LiteLLMParamsConfigurableClientsideAuthParamsItem>;
+export type LiteLLMParamsConfigurableClientsideAuthParamsList = Array<LiteLLMParamsConfigurableClientsideAuthParamsItem>;
+export declare const LiteLLMParamsConfigurableClientsideAuthParamsList: S.Schema<LiteLLMParamsConfigurableClientsideAuthParamsList>;
+export type LiteLLMParamsMilvusPartitionNamesList = Array<string>;
+export declare const LiteLLMParamsMilvusPartitionNamesList: S.Schema<LiteLLMParamsMilvusPartitionNamesList>;
+export type ChoicesFinishReason = "stop" | "content_filter" | "function_call" | "tool_calls" | "length" | "guardrail_intervened" | "eos" | "finish_reason_unspecified" | "malformed_function_call";
+export declare const ChoicesFinishReason: any;
+export type ChatCompletionTokenLogprobBytesList = Array<number>;
+export declare const ChatCompletionTokenLogprobBytesList: S.Schema<ChatCompletionTokenLogprobBytesList>;
+export type TopLogprobBytesList = Array<number>;
+export declare const TopLogprobBytesList: S.Schema<TopLogprobBytesList>;
+export interface TopLogprob {
+    bytes?: TopLogprobBytesList | null;
+    logprob: number;
+    token: string;
+}
+export declare const TopLogprob: S.Schema<TopLogprob>;
+export type ChatCompletionTokenLogprobTopLogprobsList = Array<TopLogprob>;
+export declare const ChatCompletionTokenLogprobTopLogprobsList: S.Schema<ChatCompletionTokenLogprobTopLogprobsList>;
+export interface ChatCompletionTokenLogprob {
+    bytes?: ChatCompletionTokenLogprobBytesList | null;
+    logprob: number;
+    token: string;
+    top_logprobs: ChatCompletionTokenLogprobTopLogprobsList;
+}
+export declare const ChatCompletionTokenLogprob: S.Schema<ChatCompletionTokenLogprob>;
+export type ChoiceLogprobsContentList = Array<ChatCompletionTokenLogprob>;
+export declare const ChoiceLogprobsContentList: S.Schema<ChoiceLogprobsContentList>;
+export interface ChoiceLogprobs {
+    content?: ChoiceLogprobsContentList | null;
+}
+export declare const ChoiceLogprobs: S.Schema<ChoiceLogprobs>;
+export type ChoicesLogprobs = ChoiceLogprobs | unknown;
+export declare const ChoicesLogprobs: S.Schema<ChoicesLogprobs>;
+export interface ChatCompletionAnnotationURLCitation {
+    end_index?: number;
+    start_index?: number;
+    title?: string;
+    url?: string;
+}
+export declare const ChatCompletionAnnotationURLCitation: S.Schema<ChatCompletionAnnotationURLCitation>;
+export interface ChatCompletionAnnotation {
+    type?: string;
+    url_citation?: ChatCompletionAnnotationURLCitation;
+}
+export declare const ChatCompletionAnnotation: S.Schema<ChatCompletionAnnotation>;
+export type MessageAnnotationsList = Array<ChatCompletionAnnotation>;
+export declare const MessageAnnotationsList: S.Schema<MessageAnnotationsList>;
+export interface ChatCompletionAudioResponse {
+    data: string;
+    expires_at: number;
+    id: string;
+    transcript: string;
+}
+export declare const ChatCompletionAudioResponse: S.Schema<ChatCompletionAudioResponse>;
+export interface FunctionCall {
+    arguments: string;
+    name?: string | null;
+}
+export declare const FunctionCall: S.Schema<FunctionCall>;
+export interface ImageURLObject {
+    detail?: string | null;
+    url: string;
+}
+export declare const ImageURLObject: S.Schema<ImageURLObject>;
+export interface ImageURLListItem {
+    image_url: ImageURLObject;
+    index: number;
+    type: string;
+}
+export declare const ImageURLListItem: S.Schema<ImageURLListItem>;
+export type MessageImagesList = Array<ImageURLListItem>;
+export declare const MessageImagesList: S.Schema<MessageImagesList>;
+export type MessageProviderSpecificFieldsMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const MessageProviderSpecificFieldsMap: S.Schema<MessageProviderSpecificFieldsMap>;
+export interface ChatCompletionReasoningSummaryTextBlock {
+    text?: string;
+    type: string;
+}
+export declare const ChatCompletionReasoningSummaryTextBlock: S.Schema<ChatCompletionReasoningSummaryTextBlock>;
+export type ChatCompletionReasoningItemSummaryList = Array<ChatCompletionReasoningSummaryTextBlock>;
+export declare const ChatCompletionReasoningItemSummaryList: S.Schema<ChatCompletionReasoningItemSummaryList>;
+/** Represents an OpenAI Responses API reasoning item for round-tripping in conversation history. */
+export interface ChatCompletionReasoningItem {
+    encrypted_content?: string | null;
+    id?: string;
+    summary?: ChatCompletionReasoningItemSummaryList;
+    type: string;
+}
+export declare const ChatCompletionReasoningItem: S.Schema<ChatCompletionReasoningItem>;
+export type MessageReasoningItemsList = Array<ChatCompletionReasoningItem>;
+export declare const MessageReasoningItemsList: S.Schema<MessageReasoningItemsList>;
+export type MessageRole = "assistant" | "user" | "system" | "tool" | "function";
+export declare const MessageRole: any;
+export type ChatCompletionThinkingBlockCacheControlCase0Map = {
+    [key: string]: unknown | undefined;
+};
+export declare const ChatCompletionThinkingBlockCacheControlCase0Map: S.Schema<ChatCompletionThinkingBlockCacheControlCase0Map>;
+export type ChatCompletionCachedContentTtl = "5m" | "1h";
+export declare const ChatCompletionCachedContentTtl: any;
+export interface ChatCompletionCachedContent {
+    ttl?: ChatCompletionCachedContentTtl | (string & {});
+    type: string;
+}
+export declare const ChatCompletionCachedContent: S.Schema<ChatCompletionCachedContent>;
+export type ChatCompletionThinkingBlockCacheControl = ChatCompletionThinkingBlockCacheControlCase0Map | ChatCompletionCachedContent;
+export declare const ChatCompletionThinkingBlockCacheControl: S.Schema<ChatCompletionThinkingBlockCacheControl>;
+export interface ChatCompletionThinkingBlock {
+    cache_control?: ChatCompletionThinkingBlockCacheControl | null;
+    signature?: string | null;
+    thinking?: string;
+    type: string;
+}
+export declare const ChatCompletionThinkingBlock: S.Schema<ChatCompletionThinkingBlock>;
+export type ChatCompletionRedactedThinkingBlockCacheControlCase0Map = {
+    [key: string]: unknown | undefined;
+};
+export declare const ChatCompletionRedactedThinkingBlockCacheControlCase0Map: S.Schema<ChatCompletionRedactedThinkingBlockCacheControlCase0Map>;
+export type ChatCompletionRedactedThinkingBlockCacheControl = ChatCompletionRedactedThinkingBlockCacheControlCase0Map | ChatCompletionCachedContent;
+export declare const ChatCompletionRedactedThinkingBlockCacheControl: S.Schema<ChatCompletionRedactedThinkingBlockCacheControl>;
+export interface ChatCompletionRedactedThinkingBlock {
+    cache_control?: ChatCompletionRedactedThinkingBlockCacheControl | null;
+    data?: string;
+    type: string;
+}
+export declare const ChatCompletionRedactedThinkingBlock: S.Schema<ChatCompletionRedactedThinkingBlock>;
+export type MessageThinkingBlocksItem = ChatCompletionThinkingBlock | ChatCompletionRedactedThinkingBlock;
+export declare const MessageThinkingBlocksItem: S.Schema<MessageThinkingBlocksItem>;
+export type MessageThinkingBlocksList = Array<MessageThinkingBlocksItem>;
+export declare const MessageThinkingBlocksList: S.Schema<MessageThinkingBlocksList>;
+export type ChatCompletionMessageToolCall = {
+    [key: string]: unknown | undefined;
+};
+export declare const ChatCompletionMessageToolCall: S.Schema<ChatCompletionMessageToolCall>;
+export interface ChatCompletionCustomToolCallPayload {
+    input: string;
+    name: string;
+}
+export declare const ChatCompletionCustomToolCallPayload: S.Schema<ChatCompletionCustomToolCallPayload>;
+export interface ChatCompletionMessageCustomToolCall {
+    custom: ChatCompletionCustomToolCallPayload;
+    id: string;
+    type?: string;
+}
+export declare const ChatCompletionMessageCustomToolCall: S.Schema<ChatCompletionMessageCustomToolCall>;
+export type MessageToolCallsItem = ChatCompletionMessageToolCall | ChatCompletionMessageCustomToolCall;
+export declare const MessageToolCallsItem: S.Schema<MessageToolCallsItem>;
+export type MessageToolCallsList = Array<MessageToolCallsItem>;
+export declare const MessageToolCallsList: S.Schema<MessageToolCallsList>;
+export interface Message {
+    annotations?: MessageAnnotationsList | null;
+    audio?: ChatCompletionAudioResponse | null;
+    content: string | null;
+    function_call: FunctionCall | null;
+    images?: MessageImagesList | null;
+    provider_specific_fields?: MessageProviderSpecificFieldsMap | null;
+    reasoning_content?: string | null;
+    reasoning_items?: MessageReasoningItemsList | null;
+    role: MessageRole | (string & {});
+    thinking_blocks?: MessageThinkingBlocksList | null;
+    tool_calls: MessageToolCallsList | null;
+}
+export declare const Message: S.Schema<Message>;
+export type ChoicesProviderSpecificFieldsMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const ChoicesProviderSpecificFieldsMap: S.Schema<ChoicesProviderSpecificFieldsMap>;
+export interface Choices {
+    finish_reason: ChoicesFinishReason | (string & {});
+    index: number;
+    logprobs?: ChoicesLogprobs | null;
+    message: Message;
+    provider_specific_fields?: ChoicesProviderSpecificFieldsMap | null;
+}
+export declare const Choices: S.Schema<Choices>;
+export type ModelResponseChoicesList = Array<Choices>;
+export declare const ModelResponseChoicesList: S.Schema<ModelResponseChoicesList>;
+export interface ModelResponse {
+    choices: ModelResponseChoicesList;
+    created: number;
+    id: string;
+    model?: string | null;
+    object: string;
+    system_fingerprint?: string | null;
+}
+export declare const ModelResponse: S.Schema<ModelResponse>;
+export type LiteLLMParamsMockResponse = string | ModelResponse | unknown;
+export declare const LiteLLMParamsMockResponse: S.Schema<LiteLLMParamsMockResponse>;
+export type LiteLLMParamsModelInfoMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const LiteLLMParamsModelInfoMap: S.Schema<LiteLLMParamsModelInfoMap>;
+export type LiteLLMParamsQualityRouterConfigMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const LiteLLMParamsQualityRouterConfigMap: S.Schema<LiteLLMParamsQualityRouterConfigMap>;
+export type LiteLLMParamsSearchContextCostPerQueryMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const LiteLLMParamsSearchContextCostPerQueryMap: S.Schema<LiteLLMParamsSearchContextCostPerQueryMap>;
+export type LiteLLMParamsStreamTimeout = number | string;
+export declare const LiteLLMParamsStreamTimeout: S.Schema<LiteLLMParamsStreamTimeout>;
+export type LiteLLMParamsTagRegexList = Array<string>;
+export declare const LiteLLMParamsTagRegexList: S.Schema<LiteLLMParamsTagRegexList>;
+export type LiteLLMParamsTagsList = Array<string>;
+export declare const LiteLLMParamsTagsList: S.Schema<LiteLLMParamsTagsList>;
+export type LiteLLMParamsTieredPricingItemMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const LiteLLMParamsTieredPricingItemMap: S.Schema<LiteLLMParamsTieredPricingItemMap>;
+export type LiteLLMParamsTieredPricingList = Array<LiteLLMParamsTieredPricingItemMap>;
+export declare const LiteLLMParamsTieredPricingList: S.Schema<LiteLLMParamsTieredPricingList>;
+export type LiteLLMParamsTimeout = number | string;
+export declare const LiteLLMParamsTimeout: S.Schema<LiteLLMParamsTimeout>;
+export type LiteLLMParamsVertexCredentialsCase1Map = {
+    [key: string]: unknown | undefined;
+};
+export declare const LiteLLMParamsVertexCredentialsCase1Map: S.Schema<LiteLLMParamsVertexCredentialsCase1Map>;
+export type LiteLLMParamsVertexCredentials = string | LiteLLMParamsVertexCredentialsCase1Map;
+export declare const LiteLLMParamsVertexCredentials: S.Schema<LiteLLMParamsVertexCredentials>;
+/** LiteLLM Params with 'model' requirement - used for completions */
+export interface LiteLLMParams {
+    adaptive_router_config?: LiteLLMParamsAdaptiveRouterConfigMap | null;
+    adaptive_router_default_model?: string | null;
+    allow_client_keepalive_override?: boolean | null;
+    annotation_cost_per_page?: number | null;
+    api_base?: string | null;
+    api_key?: string | null;
+    api_version?: string | null;
+    auto_router_config?: string | null;
+    auto_router_config_path?: string | null;
+    auto_router_default_model?: string | null;
+    auto_router_embedding_model?: string | null;
+    auto_router_max_input_chars?: number | null;
+    aws_access_key_id?: string | null;
+    aws_batch_role_arn?: string | null;
+    aws_bedrock_project_id?: string | null;
+    aws_bedrock_runtime_endpoint?: string | null;
+    aws_external_id?: string | null;
+    aws_profile_name?: string | null;
+    aws_region_name?: string | null;
+    aws_role_name?: string | null;
+    aws_secret_access_key?: string | null;
+    aws_session_name?: string | null;
+    aws_session_token?: string | null;
+    aws_sts_endpoint?: string | null;
+    aws_web_identity_token?: string | null;
+    azure_ad_token?: string | null;
+    bedrock_tags?: LiteLLMParamsBedrockTagsList | null;
+    budget_duration?: string | null;
+    cache_creation_input_audio_token_cost?: number | null;
+    cache_creation_input_token_cost?: number | null;
+    cache_creation_input_token_cost_above_1hr?: number | null;
+    cache_creation_input_token_cost_above_200k_tokens?: number | null;
+    cache_creation_input_token_cost_above_272k_tokens?: number | null;
+    cache_creation_input_token_cost_above_272k_tokens_flex?: number | null;
+    cache_creation_input_token_cost_above_272k_tokens_priority?: number | null;
+    cache_creation_input_token_cost_flex?: number | null;
+    cache_creation_input_token_cost_priority?: number | null;
+    cache_creation_input_token_cost_ultrafast?: number | null;
+    cache_read_input_audio_token_cost?: number | null;
+    cache_read_input_token_cost?: number | null;
+    cache_read_input_token_cost_above_200k_tokens?: number | null;
+    cache_read_input_token_cost_above_200k_tokens_priority?: number | null;
+    cache_read_input_token_cost_above_272k_tokens?: number | null;
+    cache_read_input_token_cost_above_272k_tokens_flex?: number | null;
+    cache_read_input_token_cost_above_272k_tokens_priority?: number | null;
+    cache_read_input_token_cost_above_512k_tokens?: number | null;
+    cache_read_input_token_cost_flex?: number | null;
+    cache_read_input_token_cost_priority?: number | null;
+    cache_read_input_token_cost_ultrafast?: number | null;
+    citation_cost_per_token?: number | null;
+    complexity_router_config?: LiteLLMParamsComplexityRouterConfigMap | null;
+    complexity_router_default_model?: string | null;
+    configurable_clientside_auth_params?: LiteLLMParamsConfigurableClientsideAuthParamsList | null;
+    custom_llm_provider?: string | null;
+    default_api_key_rpm_limit?: number | null;
+    default_api_key_tpm_limit?: number | null;
+    gcs_bucket_name?: string | null;
+    google_maps_grounding_cost_per_query?: number | null;
+    input_cost_per_audio_per_second?: number | null;
+    input_cost_per_audio_per_second_above_128k_tokens?: number | null;
+    input_cost_per_audio_token?: number | null;
+    input_cost_per_character?: number | null;
+    input_cost_per_character_above_128k_tokens?: number | null;
+    input_cost_per_image?: number | null;
+    input_cost_per_image_above_128k_tokens?: number | null;
+    input_cost_per_image_token?: number | null;
+    input_cost_per_pixel?: number | null;
+    input_cost_per_query?: number | null;
+    input_cost_per_second?: number | null;
+    input_cost_per_token?: number | null;
+    input_cost_per_token_above_128k_tokens?: number | null;
+    input_cost_per_token_above_200k_tokens?: number | null;
+    input_cost_per_token_above_200k_tokens_priority?: number | null;
+    input_cost_per_token_above_272k_tokens?: number | null;
+    input_cost_per_token_above_272k_tokens_flex?: number | null;
+    input_cost_per_token_above_272k_tokens_priority?: number | null;
+    input_cost_per_token_above_512k_tokens?: number | null;
+    input_cost_per_token_batches?: number | null;
+    input_cost_per_token_cache_hit?: number | null;
+    input_cost_per_token_flex?: number | null;
+    input_cost_per_token_priority?: number | null;
+    input_cost_per_token_ultrafast?: number | null;
+    input_cost_per_video_per_second?: number | null;
+    input_cost_per_video_per_second_above_128k_tokens?: number | null;
+    input_cost_per_video_per_second_above_15s_interval?: number | null;
+    input_cost_per_video_per_second_above_8s_interval?: number | null;
+    input_cost_per_video_token?: number | null;
+    itpm?: number | null;
+    keepalive_seconds?: number | null;
+    litellm_credential_name?: string | null;
+    litellm_trace_id?: string | null;
+    max_budget?: number | null;
+    max_file_size_mb?: number | null;
+    max_retries?: number | null;
+    merge_reasoning_content_in_choices?: boolean | null;
+    milvus_db_name?: string | null;
+    milvus_partition_names?: LiteLLMParamsMilvusPartitionNamesList | null;
+    milvus_text_field?: string | null;
+    mock_response?: LiteLLMParamsMockResponse | null;
+    model: string;
+    model_info?: LiteLLMParamsModelInfoMap | null;
+    ocr_cost_per_credit?: number | null;
+    ocr_cost_per_page?: number | null;
+    organization?: string | null;
+    otpm?: number | null;
+    output_cost_per_audio_per_second?: number | null;
+    output_cost_per_audio_token?: number | null;
+    output_cost_per_character?: number | null;
+    output_cost_per_character_above_128k_tokens?: number | null;
+    output_cost_per_image?: number | null;
+    output_cost_per_image_token?: number | null;
+    output_cost_per_pixel?: number | null;
+    output_cost_per_reasoning_token?: number | null;
+    output_cost_per_reasoning_token_flex?: number | null;
+    output_cost_per_reasoning_token_priority?: number | null;
+    output_cost_per_second?: number | null;
+    output_cost_per_second_1080p?: number | null;
+    output_cost_per_second_480p?: number | null;
+    output_cost_per_second_4k?: number | null;
+    output_cost_per_token?: number | null;
+    output_cost_per_token_above_128k_tokens?: number | null;
+    output_cost_per_token_above_200k_tokens?: number | null;
+    output_cost_per_token_above_200k_tokens_priority?: number | null;
+    output_cost_per_token_above_272k_tokens?: number | null;
+    output_cost_per_token_above_272k_tokens_flex?: number | null;
+    output_cost_per_token_above_272k_tokens_priority?: number | null;
+    output_cost_per_token_above_512k_tokens?: number | null;
+    output_cost_per_token_batches?: number | null;
+    output_cost_per_token_flex?: number | null;
+    output_cost_per_token_priority?: number | null;
+    output_cost_per_token_ultrafast?: number | null;
+    output_cost_per_video_per_second?: number | null;
+    output_cost_per_video_token?: number | null;
+    output_vector_size?: number | null;
+    quality_router_config?: LiteLLMParamsQualityRouterConfigMap | null;
+    quality_router_default_model?: string | null;
+    region_name?: string | null;
+    regional_endpoint_uplift_multiplier?: number | null;
+    regional_processing_uplift_multiplier_eu?: number | null;
+    regional_processing_uplift_multiplier_us?: number | null;
+    rpm?: number | null;
+    s3_bucket_name?: string | null;
+    s3_encryption_key_id?: string | null;
+    s3_output_bucket_name?: string | null;
+    s3_region_name?: string | null;
+    search_context_cost_per_query?: LiteLLMParamsSearchContextCostPerQueryMap | null;
+    stream_timeout?: LiteLLMParamsStreamTimeout | null;
+    tag_regex?: LiteLLMParamsTagRegexList | null;
+    tags?: LiteLLMParamsTagsList | null;
+    tiered_pricing?: LiteLLMParamsTieredPricingList | null;
+    timeout?: LiteLLMParamsTimeout | null;
+    tpm?: number | null;
+    use_chat_completions_api?: boolean | null;
+    use_in_pass_through?: boolean | null;
+    use_litellm_proxy?: boolean | null;
+    /** Use stored xAI OAuth credentials when no xAI API key is configured. */
+    use_xai_oauth?: boolean | null;
+    valkey_embedding_field?: string | null;
+    valkey_host?: string | null;
+    valkey_password?: string | null;
+    valkey_port?: number | null;
+    valkey_ssl?: boolean | null;
+    valkey_text_field?: string | null;
+    vector_store_id?: string | null;
+    vertex_credentials?: LiteLLMParamsVertexCredentials | null;
+    vertex_location?: string | null;
+    vertex_project?: string | null;
+    watsonx_region_name?: string | null;
+}
+export declare const LiteLLMParams: S.Schema<LiteLLMParams>;
+export type LitellmTypesRouterModelInfoTier = "free" | "paid";
+export declare const LitellmTypesRouterModelInfoTier: any;
+export type LitellmTypesRouterModelInfoTieredPricingItemMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const LitellmTypesRouterModelInfoTieredPricingItemMap: S.Schema<LitellmTypesRouterModelInfoTieredPricingItemMap>;
+export type LitellmTypesRouterModelInfoTieredPricingList = Array<LitellmTypesRouterModelInfoTieredPricingItemMap>;
+export declare const LitellmTypesRouterModelInfoTieredPricingList: S.Schema<LitellmTypesRouterModelInfoTieredPricingList>;
+export interface LitellmTypesRouterModelInfo {
+    allow_fail_open?: boolean | null;
+    base_model?: string | null;
+    blocked?: boolean | null;
+    cache_creation_input_token_cost?: number | null;
+    cache_read_input_token_cost?: number | null;
+    cost_per_ptu_per_hour?: number | null;
+    created_at?: string | null;
+    created_by?: string | null;
+    db_model?: boolean;
+    enable_tag_filtering?: boolean | null;
+    id: string | null;
+    input_cost_per_character?: number | null;
+    input_cost_per_token?: number | null;
+    output_cost_per_character?: number | null;
+    output_cost_per_token?: number | null;
+    ptu_count?: number | null;
+    ptu_effective_from?: string | null;
+    ptu_effective_to?: string | null;
+    team_id?: string | null;
+    team_public_model_name?: string | null;
+    tier?: LitellmTypesRouterModelInfoTier | (string & {}) | null;
+    tiered_pricing?: LitellmTypesRouterModelInfoTieredPricingList | null;
+    updated_at?: string | null;
+    updated_by?: string | null;
+}
+export declare const LitellmTypesRouterModelInfo: S.Schema<LitellmTypesRouterModelInfo>;
+export interface AddNewModelModelNewPostRequest {
+    litellm_params: LiteLLMParams;
+    model_info: LitellmTypesRouterModelInfo;
+    model_name: string;
+}
+export declare const AddNewModelModelNewPostRequest: S.Schema<AddNewModelModelNewPostRequest>;
+export interface AddNewModelModelNewPostResponse {
+    body: unknown;
+}
+export declare const AddNewModelModelNewPostResponse: S.Schema<AddNewModelModelNewPostResponse>;
+export interface CancelAnthropicBetaHeadersReloadScheduleAnthropicBetaHeadersReloadDeleteRequest {
+}
+export declare const CancelAnthropicBetaHeadersReloadScheduleAnthropicBetaHeadersReloadDeleteRequest: S.Schema<CancelAnthropicBetaHeadersReloadScheduleAnthropicBetaHeadersReloadDeleteRequest>;
+export interface CancelAnthropicBetaHeadersReloadScheduleAnthropicBetaHeadersReloadDeleteResponse {
+    body: unknown;
+}
+export declare const CancelAnthropicBetaHeadersReloadScheduleAnthropicBetaHeadersReloadDeleteResponse: S.Schema<CancelAnthropicBetaHeadersReloadScheduleAnthropicBetaHeadersReloadDeleteResponse>;
+export interface CancelModelCostMapReloadScheduleModelCostMapReloadDeleteRequest {
+}
+export declare const CancelModelCostMapReloadScheduleModelCostMapReloadDeleteRequest: S.Schema<CancelModelCostMapReloadScheduleModelCostMapReloadDeleteRequest>;
+export interface CancelModelCostMapReloadScheduleModelCostMapReloadDeleteResponse {
+    body: unknown;
+}
+export declare const CancelModelCostMapReloadScheduleModelCostMapReloadDeleteResponse: S.Schema<CancelModelCostMapReloadScheduleModelCostMapReloadDeleteResponse>;
+export type CreateModelGroupAccessGroupNewPostRequestModelIdsList = Array<string>;
+export declare const CreateModelGroupAccessGroupNewPostRequestModelIdsList: S.Schema<CreateModelGroupAccessGroupNewPostRequestModelIdsList>;
+export type CreateModelGroupAccessGroupNewPostRequestModelNamesList = Array<string>;
+export declare const CreateModelGroupAccessGroupNewPostRequestModelNamesList: S.Schema<CreateModelGroupAccessGroupNewPostRequestModelNamesList>;
+export interface CreateModelGroupAccessGroupNewPostRequest {
+    access_group: string;
+    model_ids?: CreateModelGroupAccessGroupNewPostRequestModelIdsList | null;
+    model_names?: CreateModelGroupAccessGroupNewPostRequestModelNamesList | null;
+}
+export declare const CreateModelGroupAccessGroupNewPostRequest: S.Schema<CreateModelGroupAccessGroupNewPostRequest>;
+export type NewModelGroupResponseModelIdsList = Array<string>;
+export declare const NewModelGroupResponseModelIdsList: S.Schema<NewModelGroupResponseModelIdsList>;
+export type NewModelGroupResponseModelNamesList = Array<string>;
+export declare const NewModelGroupResponseModelNamesList: S.Schema<NewModelGroupResponseModelNamesList>;
+export interface NewModelGroupResponse {
+    access_group: string;
+    model_ids?: NewModelGroupResponseModelIdsList | null;
+    model_names?: NewModelGroupResponseModelNamesList | null;
+    models_updated: number;
+}
+export declare const NewModelGroupResponse: S.Schema<NewModelGroupResponse>;
+export interface DeleteAccessGroupAccessGroupAccessGroupDeleteDeleteRequest {
+    access_group: string;
+}
+export declare const DeleteAccessGroupAccessGroupAccessGroupDeleteDeleteRequest: S.Schema<DeleteAccessGroupAccessGroupAccessGroupDeleteDeleteRequest>;
+export interface DeleteModelGroupResponse {
+    access_group: string;
+    message: string;
+    models_updated: number;
+}
+export declare const DeleteModelGroupResponse: S.Schema<DeleteModelGroupResponse>;
+export interface DeleteAccessGroupBudgetAccessGroupAccessGroupBudgetDeleteRequest {
+    access_group: string;
+}
+export declare const DeleteAccessGroupBudgetAccessGroupAccessGroupBudgetDeleteRequest: S.Schema<DeleteAccessGroupBudgetAccessGroupAccessGroupBudgetDeleteRequest>;
+export interface DeleteAccessGroupBudgetResponse {
+    access_group: string;
+    budget_deleted: boolean;
+    message: string;
+}
+export declare const DeleteAccessGroupBudgetResponse: S.Schema<DeleteAccessGroupBudgetResponse>;
+export interface DeleteModelModelDeletePostRequest {
+    id: string;
+}
+export declare const DeleteModelModelDeletePostRequest: S.Schema<DeleteModelModelDeletePostRequest>;
+export interface DeleteModelModelDeletePostResponse {
+    body: unknown;
+}
+export declare const DeleteModelModelDeletePostResponse: S.Schema<DeleteModelModelDeletePostResponse>;
+export interface GetAccessGroupBudgetAccessGroupAccessGroupBudgetGetRequest {
+    access_group: string;
+}
+export declare const GetAccessGroupBudgetAccessGroupAccessGroupBudgetGetRequest: S.Schema<GetAccessGroupBudgetAccessGroupAccessGroupBudgetGetRequest>;
+export interface AccessGroupBudget {
+    budget_duration?: string | null;
+    budget_id: string;
+    budget_reset_at?: string | null;
+    max_budget?: number | null;
+    soft_budget?: number | null;
+}
+export declare const AccessGroupBudget: S.Schema<AccessGroupBudget>;
+export interface AccessGroupBudgetResponse {
+    access_group: string;
+    budget?: AccessGroupBudget | null;
+    spend: number;
+}
+export declare const AccessGroupBudgetResponse: S.Schema<AccessGroupBudgetResponse>;
+export interface GetAccessGroupInfoAccessGroupAccessGroupInfoGetRequest {
+    access_group: string;
+}
+export declare const GetAccessGroupInfoAccessGroupAccessGroupInfoGetRequest: S.Schema<GetAccessGroupInfoAccessGroupAccessGroupInfoGetRequest>;
+export type AccessGroupInfoModelNamesList = Array<string>;
+export declare const AccessGroupInfoModelNamesList: S.Schema<AccessGroupInfoModelNamesList>;
+export interface AccessGroupInfo {
+    access_group: string;
+    budget?: AccessGroupBudget | null;
+    deployment_count: number;
+    model_names: AccessGroupInfoModelNamesList;
+    spend?: number | null;
+}
+export declare const AccessGroupInfo: S.Schema<AccessGroupInfo>;
+export interface GetAnthropicBetaHeadersReloadStatusScheduleAnthropicBetaHeadersReloadStatusGetRequest {
+}
+export declare const GetAnthropicBetaHeadersReloadStatusScheduleAnthropicBetaHeadersReloadStatusGetRequest: S.Schema<GetAnthropicBetaHeadersReloadStatusScheduleAnthropicBetaHeadersReloadStatusGetRequest>;
+export interface GetAnthropicBetaHeadersReloadStatusScheduleAnthropicBetaHeadersReloadStatusGetResponse {
+    body: unknown;
+}
+export declare const GetAnthropicBetaHeadersReloadStatusScheduleAnthropicBetaHeadersReloadStatusGetResponse: S.Schema<GetAnthropicBetaHeadersReloadStatusScheduleAnthropicBetaHeadersReloadStatusGetResponse>;
+/** Which calibration examples, and for BUSINESS which tier criteria, the built-in classifier rubric carries. */
+export type ClassificationRubric = "legacy" | "agentic" | "chat" | "business";
+export declare const ClassificationRubric: any;
+export interface GetAutoRouterClassifierDefaultPromptAutoRouterClassifierDefaultPromptGetRequest {
+    context_window_size?: number;
+    tier_labels?: string;
+    classification_rubric?: ClassificationRubric | (string & {});
+}
+export declare const GetAutoRouterClassifierDefaultPromptAutoRouterClassifierDefaultPromptGetRequest: S.Schema<GetAutoRouterClassifierDefaultPromptAutoRouterClassifierDefaultPromptGetRequest>;
+/** The built-in system prompt an auto-router's LLM classifier uses when none is configured. Served so the dashboard's prompt editor prefills the rubric the proxy actually sends, rather than a copy in the frontend that drifts the moment the rubric is edited. */
+export interface AutoRouterClassifierDefaultPromptResponse {
+    system_prompt: string;
+}
+export declare const AutoRouterClassifierDefaultPromptResponse: S.Schema<AutoRouterClassifierDefaultPromptResponse>;
+export interface GetModelCostMapReloadStatusScheduleModelCostMapReloadStatusGetRequest {
+}
+export declare const GetModelCostMapReloadStatusScheduleModelCostMapReloadStatusGetRequest: S.Schema<GetModelCostMapReloadStatusScheduleModelCostMapReloadStatusGetRequest>;
+export interface GetModelCostMapReloadStatusScheduleModelCostMapReloadStatusGetResponse {
+    body: unknown;
+}
+export declare const GetModelCostMapReloadStatusScheduleModelCostMapReloadStatusGetResponse: S.Schema<GetModelCostMapReloadStatusScheduleModelCostMapReloadStatusGetResponse>;
+export interface GetModelCostMapSourceModelCostMapSourceGetRequest {
+}
+export declare const GetModelCostMapSourceModelCostMapSourceGetRequest: S.Schema<GetModelCostMapSourceModelCostMapSourceGetRequest>;
+export interface GetModelCostMapSourceModelCostMapSourceGetResponse {
+    body: unknown;
+}
+export declare const GetModelCostMapSourceModelCostMapSourceGetResponse: S.Schema<GetModelCostMapSourceModelCostMapSourceGetResponse>;
+export interface GetModelDeprecationsModelDeprecationRequest {
+    warn_within_days?: number;
+}
+export declare const GetModelDeprecationsModelDeprecationRequest: S.Schema<GetModelDeprecationsModelDeprecationRequest>;
+/** 'deprecated' if the date has passed, 'imminent' if it falls within warn_within_days, 'upcoming' otherwise. */
+export type ModelDeprecationInfoStatus = "upcoming" | "imminent" | "deprecated";
+export declare const ModelDeprecationInfoStatus: any;
+export interface ModelDeprecationInfo {
+    /** Days remaining until the deprecation date. Negative if the model is already deprecated. */
+    days_until_deprecation: number;
+    /** The date (UTC) when the model becomes deprecated. */
+    deprecation_date: string;
+    /** The underlying litellm model string the deprecation date is sourced from. */
+    litellm_model?: string | null;
+    /** The provider this model belongs to. */
+    litellm_provider?: string | null;
+    /** The public name of the model on the proxy (model_group). */
+    model_name: string;
+    /** 'deprecated' if the date has passed, 'imminent' if it falls within warn_within_days, 'upcoming' otherwise. */
+    status: ModelDeprecationInfoStatus;
+}
+export declare const ModelDeprecationInfo: S.Schema<ModelDeprecationInfo>;
+/** Models whose deprecation date has already passed. */
+export type ModelDeprecationResponseDeprecatedList = Array<ModelDeprecationInfo>;
+export declare const ModelDeprecationResponseDeprecatedList: S.Schema<ModelDeprecationResponseDeprecatedList>;
+/** Models whose deprecation date is within warn_within_days from today and require immediate migration planning. */
+export type ModelDeprecationResponseImminentList = Array<ModelDeprecationInfo>;
+export declare const ModelDeprecationResponseImminentList: S.Schema<ModelDeprecationResponseImminentList>;
+/** Models with a future deprecation date outside the warn window. */
+export type ModelDeprecationResponseUpcomingList = Array<ModelDeprecationInfo>;
+export declare const ModelDeprecationResponseUpcomingList: S.Schema<ModelDeprecationResponseUpcomingList>;
+export interface ModelDeprecationResponse {
+    /** UTC timestamp when the deprecation snapshot was generated. */
+    checked_at: string;
+    /** Models whose deprecation date has already passed. */
+    deprecated?: ModelDeprecationResponseDeprecatedList;
+    /** Models whose deprecation date is within warn_within_days from today and require immediate migration planning. */
+    imminent?: ModelDeprecationResponseImminentList;
+    /** Models with a future deprecation date outside the warn window. */
+    upcoming?: ModelDeprecationResponseUpcomingList;
+    /** The window (in days) used to bucket 'imminent' models. */
+    warn_within_days: number;
+}
+export declare const ModelDeprecationResponse: S.Schema<ModelDeprecationResponse>;
+export interface GetModelDeprecationsV1ModelDeprecationRequest {
+    warn_within_days?: number;
+}
+export declare const GetModelDeprecationsV1ModelDeprecationRequest: S.Schema<GetModelDeprecationsV1ModelDeprecationRequest>;
+export interface GetModelGroupInfoModelGroupInfoRequest {
+    model_group?: string;
+}
+export declare const GetModelGroupInfoModelGroupInfoRequest: S.Schema<GetModelGroupInfoModelGroupInfoRequest>;
+export interface GetModelGroupInfoModelGroupInfoResponse {
+    body: unknown;
+}
+export declare const GetModelGroupInfoModelGroupInfoResponse: S.Schema<GetModelGroupInfoModelGroupInfoResponse>;
+export interface GetModelInfoModelsModelIdRequest {
+    model_id: string;
+    team_id?: string;
+    healthy_only?: boolean;
+}
+export declare const GetModelInfoModelsModelIdRequest: S.Schema<GetModelInfoModelsModelIdRequest>;
+export interface GetModelInfoModelsModelIdResponse {
+    body: unknown;
+}
+export declare const GetModelInfoModelsModelIdResponse: S.Schema<GetModelInfoModelsModelIdResponse>;
+export interface GetModelInfoV1ModelInfoRequest {
+    litellm_model_id?: string;
+    /** When true, filter to deployments the caller can use via direct access or team membership. */
+    include_team_models?: boolean;
+    /** Filter models by team ID. Returns models with direct_access=True or teamId in access_via_team_ids */
+    teamId?: string;
+    healthy_only?: boolean;
+}
+export declare const GetModelInfoV1ModelInfoRequest: S.Schema<GetModelInfoV1ModelInfoRequest>;
+export interface GetModelInfoV1ModelInfoResponse {
+    body: unknown;
+}
+export declare const GetModelInfoV1ModelInfoResponse: S.Schema<GetModelInfoV1ModelInfoResponse>;
+export interface GetModelInfoV1ModelsModelIdRequest {
+    model_id: string;
+    team_id?: string;
+    healthy_only?: boolean;
+}
+export declare const GetModelInfoV1ModelsModelIdRequest: S.Schema<GetModelInfoV1ModelsModelIdRequest>;
+export interface GetModelInfoV1ModelsModelIdResponse {
+    body: unknown;
+}
+export declare const GetModelInfoV1ModelsModelIdResponse: S.Schema<GetModelInfoV1ModelsModelIdResponse>;
+export interface GetModelInfoV1V1ModelInfoRequest {
+    litellm_model_id?: string;
+    /** When true, filter to deployments the caller can use via direct access or team membership. */
+    include_team_models?: boolean;
+    /** Filter models by team ID. Returns models with direct_access=True or teamId in access_via_team_ids */
+    teamId?: string;
+    healthy_only?: boolean;
+}
+export declare const GetModelInfoV1V1ModelInfoRequest: S.Schema<GetModelInfoV1V1ModelInfoRequest>;
+export interface GetModelInfoV1V1ModelInfoResponse {
+    body: unknown;
+}
+export declare const GetModelInfoV1V1ModelInfoResponse: S.Schema<GetModelInfoV1V1ModelInfoResponse>;
+export interface GetModelInfoV2V2ModelInfoRequest {
+    /** Specify the model name (optional) */
+    model?: string;
+    /** Only return models added by this user */
+    user_models_only?: boolean;
+    /** Return all models across all teams user is in. */
+    include_team_models?: boolean;
+    debug?: boolean;
+    /** Page number */
+    page?: number;
+    /** Page size */
+    size?: number;
+    /** Search model names (case-insensitive partial match) */
+    search?: string;
+    /** Search for a specific model by its unique ID */
+    modelId?: string;
+    /** Filter models by team ID. Returns models with direct_access=True or teamId in access_via_team_ids */
+    teamId?: string;
+    /** Field to sort by. Options: model_name, created_at, updated_at, costs, status */
+    sortBy?: string;
+    /** Sort order. Options: asc, desc */
+    sortOrder?: string;
+    /** Omit auto-router deployments (litellm model prefixed `auto_router/`). They select among deployments rather than being deployments themselves, so a caller rendering a deployment list can leave them out. Defaults to false, so existing callers are unaffected */
+    exclude_auto_routers?: boolean;
+}
+export declare const GetModelInfoV2V2ModelInfoRequest: S.Schema<GetModelInfoV2V2ModelInfoRequest>;
+export interface GetModelInfoV2V2ModelInfoResponse {
+    body: unknown;
+}
+export declare const GetModelInfoV2V2ModelInfoResponse: S.Schema<GetModelInfoV2V2ModelInfoResponse>;
+export interface GetModelMetricsExceptionsModelMetricsExceptionRequest {
+    _selected_model_group?: string;
+    startTime?: string;
+    endTime?: string;
+    api_key?: string;
+    customer?: string;
+}
+export declare const GetModelMetricsExceptionsModelMetricsExceptionRequest: S.Schema<GetModelMetricsExceptionsModelMetricsExceptionRequest>;
+export interface GetModelMetricsExceptionsModelMetricsExceptionResponse {
+    body: unknown;
+}
+export declare const GetModelMetricsExceptionsModelMetricsExceptionResponse: S.Schema<GetModelMetricsExceptionsModelMetricsExceptionResponse>;
+export interface GetModelMetricsModelMetricsRequest {
+    _selected_model_group?: string;
+    startTime?: string;
+    endTime?: string;
+    api_key?: string;
+    customer?: string;
+}
+export declare const GetModelMetricsModelMetricsRequest: S.Schema<GetModelMetricsModelMetricsRequest>;
+export interface GetModelMetricsModelMetricsResponse {
+    body: unknown;
+}
+export declare const GetModelMetricsModelMetricsResponse: S.Schema<GetModelMetricsModelMetricsResponse>;
+export interface GetModelMetricsSlowResponsesModelMetricsSlowResponseRequest {
+    _selected_model_group?: string;
+    startTime?: string;
+    endTime?: string;
+    api_key?: string;
+    customer?: string;
+}
+export declare const GetModelMetricsSlowResponsesModelMetricsSlowResponseRequest: S.Schema<GetModelMetricsSlowResponsesModelMetricsSlowResponseRequest>;
+export interface GetModelMetricsSlowResponsesModelMetricsSlowResponseResponse {
+    body: unknown;
+}
+export declare const GetModelMetricsSlowResponsesModelMetricsSlowResponseResponse: S.Schema<GetModelMetricsSlowResponsesModelMetricsSlowResponseResponse>;
+export interface GetModelSettingsModelSettingsRequest {
+}
+export declare const GetModelSettingsModelSettingsRequest: S.Schema<GetModelSettingsModelSettingsRequest>;
+export interface GetModelSettingsModelSettingsResponse {
+    body: unknown;
+}
+export declare const GetModelSettingsModelSettingsResponse: S.Schema<GetModelSettingsModelSettingsResponse>;
+export interface GetModelStreamingMetricsModelStreamingMetricsRequest {
+    _selected_model_group?: string;
+    startTime?: string;
+    endTime?: string;
+}
+export declare const GetModelStreamingMetricsModelStreamingMetricsRequest: S.Schema<GetModelStreamingMetricsModelStreamingMetricsRequest>;
+export interface GetModelStreamingMetricsModelStreamingMetricsResponse {
+    body: unknown;
+}
+export declare const GetModelStreamingMetricsModelStreamingMetricsResponse: S.Schema<GetModelStreamingMetricsModelStreamingMetricsResponse>;
+export interface ListAccessGroupsAccessGroupListGetRequest {
+}
+export declare const ListAccessGroupsAccessGroupListGetRequest: S.Schema<ListAccessGroupsAccessGroupListGetRequest>;
+export type ListAccessGroupsResponseAccessGroupsList = Array<AccessGroupInfo>;
+export declare const ListAccessGroupsResponseAccessGroupsList: S.Schema<ListAccessGroupsResponseAccessGroupsList>;
+export interface ListAccessGroupsResponse {
+    access_groups: ListAccessGroupsResponseAccessGroupsList;
+}
+export declare const ListAccessGroupsResponse: S.Schema<ListAccessGroupsResponse>;
+export interface ModelListModelsGetRequest {
+    return_wildcard_routes?: boolean;
+    team_id?: string;
+    include_model_access_groups?: boolean;
+    only_model_access_groups?: boolean;
+    include_metadata?: boolean;
+    fallback_type?: string;
+    scope?: string;
+    healthy_only?: boolean;
+}
+export declare const ModelListModelsGetRequest: S.Schema<ModelListModelsGetRequest>;
+export interface ModelListModelsGetResponse {
+    body: unknown;
+}
+export declare const ModelListModelsGetResponse: S.Schema<ModelListModelsGetResponse>;
+export interface ModelListV1ModelsGetRequest {
+    return_wildcard_routes?: boolean;
+    team_id?: string;
+    include_model_access_groups?: boolean;
+    only_model_access_groups?: boolean;
+    include_metadata?: boolean;
+    fallback_type?: string;
+    scope?: string;
+    healthy_only?: boolean;
+}
+export declare const ModelListV1ModelsGetRequest: S.Schema<ModelListV1ModelsGetRequest>;
+export interface ModelListV1ModelsGetResponse {
+    body: unknown;
+}
+export declare const ModelListV1ModelsGetResponse: S.Schema<ModelListV1ModelsGetResponse>;
+export type UpdateLiteLLMParamsAdaptiveRouterConfigMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const UpdateLiteLLMParamsAdaptiveRouterConfigMap: S.Schema<UpdateLiteLLMParamsAdaptiveRouterConfigMap>;
+export type UpdateLiteLLMParamsBedrockTagsList = Array<unknown>;
+export declare const UpdateLiteLLMParamsBedrockTagsList: S.Schema<UpdateLiteLLMParamsBedrockTagsList>;
+export type UpdateLiteLLMParamsComplexityRouterConfigMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const UpdateLiteLLMParamsComplexityRouterConfigMap: S.Schema<UpdateLiteLLMParamsComplexityRouterConfigMap>;
+export type UpdateLiteLLMParamsConfigurableClientsideAuthParamsItem = string | ConfigurableClientsideParamsCustomAuthInput;
+export declare const UpdateLiteLLMParamsConfigurableClientsideAuthParamsItem: S.Schema<UpdateLiteLLMParamsConfigurableClientsideAuthParamsItem>;
+export type UpdateLiteLLMParamsConfigurableClientsideAuthParamsList = Array<UpdateLiteLLMParamsConfigurableClientsideAuthParamsItem>;
+export declare const UpdateLiteLLMParamsConfigurableClientsideAuthParamsList: S.Schema<UpdateLiteLLMParamsConfigurableClientsideAuthParamsList>;
+export type UpdateLiteLLMParamsMilvusPartitionNamesList = Array<string>;
+export declare const UpdateLiteLLMParamsMilvusPartitionNamesList: S.Schema<UpdateLiteLLMParamsMilvusPartitionNamesList>;
+export type UpdateLiteLLMParamsMockResponse = string | ModelResponse | unknown;
+export declare const UpdateLiteLLMParamsMockResponse: S.Schema<UpdateLiteLLMParamsMockResponse>;
+export type UpdateLiteLLMParamsModelInfoMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const UpdateLiteLLMParamsModelInfoMap: S.Schema<UpdateLiteLLMParamsModelInfoMap>;
+export type UpdateLiteLLMParamsQualityRouterConfigMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const UpdateLiteLLMParamsQualityRouterConfigMap: S.Schema<UpdateLiteLLMParamsQualityRouterConfigMap>;
+export type UpdateLiteLLMParamsSearchContextCostPerQueryMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const UpdateLiteLLMParamsSearchContextCostPerQueryMap: S.Schema<UpdateLiteLLMParamsSearchContextCostPerQueryMap>;
+export type UpdateLiteLLMParamsStreamTimeout = number | string;
+export declare const UpdateLiteLLMParamsStreamTimeout: S.Schema<UpdateLiteLLMParamsStreamTimeout>;
+export type UpdateLiteLLMParamsTagRegexList = Array<string>;
+export declare const UpdateLiteLLMParamsTagRegexList: S.Schema<UpdateLiteLLMParamsTagRegexList>;
+export type UpdateLiteLLMParamsTagsList = Array<string>;
+export declare const UpdateLiteLLMParamsTagsList: S.Schema<UpdateLiteLLMParamsTagsList>;
+export type UpdateLiteLLMParamsTieredPricingItemMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const UpdateLiteLLMParamsTieredPricingItemMap: S.Schema<UpdateLiteLLMParamsTieredPricingItemMap>;
+export type UpdateLiteLLMParamsTieredPricingList = Array<UpdateLiteLLMParamsTieredPricingItemMap>;
+export declare const UpdateLiteLLMParamsTieredPricingList: S.Schema<UpdateLiteLLMParamsTieredPricingList>;
+export type UpdateLiteLLMParamsTimeout = number | string;
+export declare const UpdateLiteLLMParamsTimeout: S.Schema<UpdateLiteLLMParamsTimeout>;
+export type UpdateLiteLLMParamsVertexCredentialsCase1Map = {
+    [key: string]: unknown | undefined;
+};
+export declare const UpdateLiteLLMParamsVertexCredentialsCase1Map: S.Schema<UpdateLiteLLMParamsVertexCredentialsCase1Map>;
+export type UpdateLiteLLMParamsVertexCredentials = string | UpdateLiteLLMParamsVertexCredentialsCase1Map;
+export declare const UpdateLiteLLMParamsVertexCredentials: S.Schema<UpdateLiteLLMParamsVertexCredentials>;
+export interface UpdateLiteLLMParams {
+    adaptive_router_config?: UpdateLiteLLMParamsAdaptiveRouterConfigMap | null;
+    adaptive_router_default_model?: string | null;
+    allow_client_keepalive_override?: boolean | null;
+    annotation_cost_per_page?: number | null;
+    api_base?: string | null;
+    api_key?: string | null;
+    api_version?: string | null;
+    auto_router_config?: string | null;
+    auto_router_config_path?: string | null;
+    auto_router_default_model?: string | null;
+    auto_router_embedding_model?: string | null;
+    auto_router_max_input_chars?: number | null;
+    aws_access_key_id?: string | null;
+    aws_batch_role_arn?: string | null;
+    aws_bedrock_project_id?: string | null;
+    aws_bedrock_runtime_endpoint?: string | null;
+    aws_external_id?: string | null;
+    aws_profile_name?: string | null;
+    aws_region_name?: string | null;
+    aws_role_name?: string | null;
+    aws_secret_access_key?: string | null;
+    aws_session_name?: string | null;
+    aws_session_token?: string | null;
+    aws_sts_endpoint?: string | null;
+    aws_web_identity_token?: string | null;
+    azure_ad_token?: string | null;
+    bedrock_tags?: UpdateLiteLLMParamsBedrockTagsList | null;
+    budget_duration?: string | null;
+    cache_creation_input_audio_token_cost?: number | null;
+    cache_creation_input_token_cost?: number | null;
+    cache_creation_input_token_cost_above_1hr?: number | null;
+    cache_creation_input_token_cost_above_200k_tokens?: number | null;
+    cache_creation_input_token_cost_above_272k_tokens?: number | null;
+    cache_creation_input_token_cost_above_272k_tokens_flex?: number | null;
+    cache_creation_input_token_cost_above_272k_tokens_priority?: number | null;
+    cache_creation_input_token_cost_flex?: number | null;
+    cache_creation_input_token_cost_priority?: number | null;
+    cache_creation_input_token_cost_ultrafast?: number | null;
+    cache_read_input_audio_token_cost?: number | null;
+    cache_read_input_token_cost?: number | null;
+    cache_read_input_token_cost_above_200k_tokens?: number | null;
+    cache_read_input_token_cost_above_200k_tokens_priority?: number | null;
+    cache_read_input_token_cost_above_272k_tokens?: number | null;
+    cache_read_input_token_cost_above_272k_tokens_flex?: number | null;
+    cache_read_input_token_cost_above_272k_tokens_priority?: number | null;
+    cache_read_input_token_cost_above_512k_tokens?: number | null;
+    cache_read_input_token_cost_flex?: number | null;
+    cache_read_input_token_cost_priority?: number | null;
+    cache_read_input_token_cost_ultrafast?: number | null;
+    citation_cost_per_token?: number | null;
+    complexity_router_config?: UpdateLiteLLMParamsComplexityRouterConfigMap | null;
+    complexity_router_default_model?: string | null;
+    configurable_clientside_auth_params?: UpdateLiteLLMParamsConfigurableClientsideAuthParamsList | null;
+    custom_llm_provider?: string | null;
+    default_api_key_rpm_limit?: number | null;
+    default_api_key_tpm_limit?: number | null;
+    gcs_bucket_name?: string | null;
+    google_maps_grounding_cost_per_query?: number | null;
+    input_cost_per_audio_per_second?: number | null;
+    input_cost_per_audio_per_second_above_128k_tokens?: number | null;
+    input_cost_per_audio_token?: number | null;
+    input_cost_per_character?: number | null;
+    input_cost_per_character_above_128k_tokens?: number | null;
+    input_cost_per_image?: number | null;
+    input_cost_per_image_above_128k_tokens?: number | null;
+    input_cost_per_image_token?: number | null;
+    input_cost_per_pixel?: number | null;
+    input_cost_per_query?: number | null;
+    input_cost_per_second?: number | null;
+    input_cost_per_token?: number | null;
+    input_cost_per_token_above_128k_tokens?: number | null;
+    input_cost_per_token_above_200k_tokens?: number | null;
+    input_cost_per_token_above_200k_tokens_priority?: number | null;
+    input_cost_per_token_above_272k_tokens?: number | null;
+    input_cost_per_token_above_272k_tokens_flex?: number | null;
+    input_cost_per_token_above_272k_tokens_priority?: number | null;
+    input_cost_per_token_above_512k_tokens?: number | null;
+    input_cost_per_token_batches?: number | null;
+    input_cost_per_token_cache_hit?: number | null;
+    input_cost_per_token_flex?: number | null;
+    input_cost_per_token_priority?: number | null;
+    input_cost_per_token_ultrafast?: number | null;
+    input_cost_per_video_per_second?: number | null;
+    input_cost_per_video_per_second_above_128k_tokens?: number | null;
+    input_cost_per_video_per_second_above_15s_interval?: number | null;
+    input_cost_per_video_per_second_above_8s_interval?: number | null;
+    input_cost_per_video_token?: number | null;
+    itpm?: number | null;
+    keepalive_seconds?: number | null;
+    litellm_credential_name?: string | null;
+    litellm_trace_id?: string | null;
+    max_budget?: number | null;
+    max_file_size_mb?: number | null;
+    max_retries?: number | null;
+    merge_reasoning_content_in_choices?: boolean | null;
+    milvus_db_name?: string | null;
+    milvus_partition_names?: UpdateLiteLLMParamsMilvusPartitionNamesList | null;
+    milvus_text_field?: string | null;
+    mock_response?: UpdateLiteLLMParamsMockResponse | null;
+    model?: string | null;
+    model_info?: UpdateLiteLLMParamsModelInfoMap | null;
+    ocr_cost_per_credit?: number | null;
+    ocr_cost_per_page?: number | null;
+    organization?: string | null;
+    otpm?: number | null;
+    output_cost_per_audio_per_second?: number | null;
+    output_cost_per_audio_token?: number | null;
+    output_cost_per_character?: number | null;
+    output_cost_per_character_above_128k_tokens?: number | null;
+    output_cost_per_image?: number | null;
+    output_cost_per_image_token?: number | null;
+    output_cost_per_pixel?: number | null;
+    output_cost_per_reasoning_token?: number | null;
+    output_cost_per_reasoning_token_flex?: number | null;
+    output_cost_per_reasoning_token_priority?: number | null;
+    output_cost_per_second?: number | null;
+    output_cost_per_second_1080p?: number | null;
+    output_cost_per_second_480p?: number | null;
+    output_cost_per_second_4k?: number | null;
+    output_cost_per_token?: number | null;
+    output_cost_per_token_above_128k_tokens?: number | null;
+    output_cost_per_token_above_200k_tokens?: number | null;
+    output_cost_per_token_above_200k_tokens_priority?: number | null;
+    output_cost_per_token_above_272k_tokens?: number | null;
+    output_cost_per_token_above_272k_tokens_flex?: number | null;
+    output_cost_per_token_above_272k_tokens_priority?: number | null;
+    output_cost_per_token_above_512k_tokens?: number | null;
+    output_cost_per_token_batches?: number | null;
+    output_cost_per_token_flex?: number | null;
+    output_cost_per_token_priority?: number | null;
+    output_cost_per_token_ultrafast?: number | null;
+    output_cost_per_video_per_second?: number | null;
+    output_cost_per_video_token?: number | null;
+    output_vector_size?: number | null;
+    quality_router_config?: UpdateLiteLLMParamsQualityRouterConfigMap | null;
+    quality_router_default_model?: string | null;
+    region_name?: string | null;
+    regional_endpoint_uplift_multiplier?: number | null;
+    regional_processing_uplift_multiplier_eu?: number | null;
+    regional_processing_uplift_multiplier_us?: number | null;
+    rpm?: number | null;
+    s3_bucket_name?: string | null;
+    s3_encryption_key_id?: string | null;
+    s3_output_bucket_name?: string | null;
+    s3_region_name?: string | null;
+    search_context_cost_per_query?: UpdateLiteLLMParamsSearchContextCostPerQueryMap | null;
+    stream_timeout?: UpdateLiteLLMParamsStreamTimeout | null;
+    tag_regex?: UpdateLiteLLMParamsTagRegexList | null;
+    tags?: UpdateLiteLLMParamsTagsList | null;
+    tiered_pricing?: UpdateLiteLLMParamsTieredPricingList | null;
+    timeout?: UpdateLiteLLMParamsTimeout | null;
+    tpm?: number | null;
+    use_chat_completions_api?: boolean | null;
+    use_in_pass_through?: boolean | null;
+    use_litellm_proxy?: boolean | null;
+    /** Use stored xAI OAuth credentials when no xAI API key is configured. */
+    use_xai_oauth?: boolean | null;
+    valkey_embedding_field?: string | null;
+    valkey_host?: string | null;
+    valkey_password?: string | null;
+    valkey_port?: number | null;
+    valkey_ssl?: boolean | null;
+    valkey_text_field?: string | null;
+    vector_store_id?: string | null;
+    vertex_credentials?: UpdateLiteLLMParamsVertexCredentials | null;
+    vertex_location?: string | null;
+    vertex_project?: string | null;
+    watsonx_region_name?: string | null;
+}
+export declare const UpdateLiteLLMParams: S.Schema<UpdateLiteLLMParams>;
+export interface PatchModelModelModelIdUpdatePatchRequest {
+    model_id: string;
+    blocked?: boolean | null;
+    litellm_params?: UpdateLiteLLMParams | null;
+    model_info?: LitellmTypesRouterModelInfo | null;
+    model_name?: string | null;
+}
+export declare const PatchModelModelModelIdUpdatePatchRequest: S.Schema<PatchModelModelModelIdUpdatePatchRequest>;
+export interface PatchModelModelModelIdUpdatePatchResponse {
+    body: unknown;
+}
+export declare const PatchModelModelModelIdUpdatePatchResponse: S.Schema<PatchModelModelModelIdUpdatePatchResponse>;
+export interface PostBlockModelModelBlockRequest {
+    model_id: string;
+}
+export declare const PostBlockModelModelBlockRequest: S.Schema<PostBlockModelModelBlockRequest>;
+export type LiteLLMProxyModelTableLitellmParamsMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const LiteLLMProxyModelTableLitellmParamsMap: S.Schema<LiteLLMProxyModelTableLitellmParamsMap>;
+export type LiteLLMProxyModelTableModelInfoMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const LiteLLMProxyModelTableModelInfoMap: S.Schema<LiteLLMProxyModelTableModelInfoMap>;
+export interface LiteLLMProxyModelTable {
+    blocked?: boolean;
+    created_at?: string | null;
+    created_by?: string | null;
+    litellm_params: LiteLLMProxyModelTableLitellmParamsMap;
+    model_id: string;
+    model_info?: LiteLLMProxyModelTableModelInfoMap | null;
+    model_name: string;
+    updated_at?: string | null;
+    updated_by?: string | null;
+}
+export declare const LiteLLMProxyModelTable: S.Schema<LiteLLMProxyModelTable>;
+export interface PostBlockModelModelBlockResponse {
+    body: LiteLLMProxyModelTable | null;
+}
+export declare const PostBlockModelModelBlockResponse: S.Schema<PostBlockModelModelBlockResponse>;
+/** An operator-defined tier: the name the LLM classifier must return and its rubric description. */
+export interface TierDefinition {
+    /** What belongs in this tier; rendered as this tier's bullet in the classifier rubric. Required unless the name is a built-in tier (SIMPLE/MEDIUM/COMPLEX/REASONING), which inherits the built-in criteria when omitted */
+    description?: string | null;
+    /** Tier name; becomes a value the LLM classifier can return and a key of `tiers` */
+    name: string;
+}
+export declare const TierDefinition: S.Schema<TierDefinition>;
+export type PostPreviewAutoRouterClassifierPromptAutoRouterClassifierDefaultPromptRequestTierDefinitionsList = Array<TierDefinition>;
+export declare const PostPreviewAutoRouterClassifierPromptAutoRouterClassifierDefaultPromptRequestTierDefinitionsList: S.Schema<PostPreviewAutoRouterClassifierPromptAutoRouterClassifierDefaultPromptRequestTierDefinitionsList>;
+export interface PostPreviewAutoRouterClassifierPromptAutoRouterClassifierDefaultPromptRequest {
+    classification_prompt?: string | null;
+    context_window_size?: number;
+    tier_definitions: PostPreviewAutoRouterClassifierPromptAutoRouterClassifierDefaultPromptRequestTierDefinitionsList;
+}
+export declare const PostPreviewAutoRouterClassifierPromptAutoRouterClassifierDefaultPromptRequest: S.Schema<PostPreviewAutoRouterClassifierPromptAutoRouterClassifierDefaultPromptRequest>;
+/** When adaptive=True: 'all' scores every pool model with a tier-distance penalty (soft floors); 'classified_tier' Thompson-samples only inside the classified tier's pool */
+export type RequestComplexityRouterConfigAdaptiveEligible = "all" | "classified_tier";
+export declare const RequestComplexityRouterConfigAdaptiveEligible: any;
+export interface AdaptiveRouterWeights {
+    cost?: number;
+    quality?: number;
+}
+export declare const AdaptiveRouterWeights: S.Schema<AdaptiveRouterWeights>;
+/** What classifies the request when the LLM classifier errors, times out, or returns an unparseable response. 'heuristic' runs the local complexity scorer, which is right when the classifier grades complexity too. 'default_model' skips scoring and routes to default_model, which is what a classifier on some other taxonomy wants: a prompt that grades data sensitivity has no use for a complexity score, and scoring one produces a tier unrelated to what the operator configured. Requires default_model when set to 'default_model'. Only applies when classifier_type is 'llm', 'custom', or 'heuristic_first'. */
+export type RequestComplexityRouterConfigClassifierFallback = "heuristic" | "default_model";
+export declare const RequestComplexityRouterConfigClassifierFallback: any;
+/** Configuration for the LLM-based complexity classifier. */
+export interface ClassifierLLMConfig {
+    /** Which calibration examples the built-in rubric carries. 'agentic' anchors routine installs, builds, multi-file edits, and standard debugging at MEDIUM, so ordinary engineering does not route to the most expensive tier; it suits agent, terminal, and coding-assistant traffic as well as mixed traffic. 'chat' omits those engineering anchors, for a deployment serving only conversational traffic. 'business' carries business/sales anchors and business-flavored tier criteria that keep routine drafting and summarizing off the expensive tiers and reserve the top tier for committing to decisions under tradeoffs; it suits sales, support, and go-to-market traffic. Every preset keeps the same four tiers, so this moves where the boundary sits without changing the taxonomy. Leave unset for 'legacy', the rubric as it shipped before calibration examples existed, so an existing router's tier decisions and spend do not move on upgrade. Mutually exclusive with system_prompt, which replaces the rubric this would select. Only applies when classifier_type is 'llm'. */
+    classification_rubric?: ClassificationRubric | (string & {}) | null;
+    /** Model name (from the router's model_list) to call for classification */
+    model: string;
+    /** Replaces the built-in complexity rubric as the classifier's entire system role. When set, neither the default rubric nor the context-window closing line is appended, so the prompt owns the whole taxonomy and the tier names SIMPLE/MEDIUM/COMPLEX/REASONING become whatever buckets it defines: a prompt that classifies data sensitivity routes on that instead of on difficulty. Two consequences of full replacement. The default rubric's closing paragraph is the classifier's prompt-injection defense, telling it that the caller's quoted system prompt and prior turns are material to judge and never instructions; a replacement that omits it lets a caller ask for a tier and get it. And the heuristic fallback still scores complexity, so a router on some other taxonomy wants classifier_fallback='default_model'. Leave unset for the built-in rubric. Only applies when classifier_type is 'llm'. */
+    system_prompt?: string | null;
+    /** Timeout budget for the classification call, in milliseconds */
+    timeout_ms?: number;
+}
+export declare const ClassifierLLMConfig: S.Schema<ClassifierLLMConfig>;
+/** Classification strategy: local regex/keyword scoring, an LLM call, a custom classifier plugin, or 'heuristic_first', which scores locally and only pays for the LLM classifier when the local scorer does not confidently land a cheap tier */
+export type RequestComplexityRouterConfigClassifierType = "heuristic" | "llm" | "custom" | "heuristic_first";
+export declare const RequestComplexityRouterConfigClassifierType: any;
+export type RequestComplexityRouterConfigCodeKeywordsList = Array<string>;
+export declare const RequestComplexityRouterConfigCodeKeywordsList: S.Schema<RequestComplexityRouterConfigCodeKeywordsList>;
+export type RequestComplexityRouterConfigCustomTechnicalKeywordsList = Array<string>;
+export declare const RequestComplexityRouterConfigCustomTechnicalKeywordsList: S.Schema<RequestComplexityRouterConfigCustomTechnicalKeywordsList>;
+/** Weights for each scoring dimension */
+export type RequestComplexityRouterConfigDimensionWeightsMap = {
+    [key: string]: number | undefined;
+};
+export declare const RequestComplexityRouterConfigDimensionWeightsMap: S.Schema<RequestComplexityRouterConfigDimensionWeightsMap>;
+export type RequestComplexityRouterConfigEscalationKeywordsList = Array<string>;
+export declare const RequestComplexityRouterConfigEscalationKeywordsList: S.Schema<RequestComplexityRouterConfigEscalationKeywordsList>;
+export type RequestComplexityRouterConfigHousekeepingPatternsList = Array<string>;
+export declare const RequestComplexityRouterConfigHousekeepingPatternsList: S.Schema<RequestComplexityRouterConfigHousekeepingPatternsList>;
+/** Keywords/phrases that trigger this rule (lexical or semantic match) */
+export type KeywordTierRuleKeywordsList = Array<string>;
+export declare const KeywordTierRuleKeywordsList: S.Schema<KeywordTierRuleKeywordsList>;
+/** A deterministic override: if any keyword matches, route to this tier. */
+export interface KeywordTierRule {
+    /** Keywords/phrases that trigger this rule (lexical or semantic match) */
+    keywords: KeywordTierRuleKeywordsList;
+    /** Tier to route to when this rule matches: a built-in tier name, or with tier_definitions set, one of the defined tier names */
+    tier: string;
+}
+export declare const KeywordTierRule: S.Schema<KeywordTierRule>;
+export type RequestComplexityRouterConfigKeywordTierRulesList = Array<KeywordTierRule>;
+export declare const RequestComplexityRouterConfigKeywordTierRulesList: S.Schema<RequestComplexityRouterConfigKeywordTierRulesList>;
+export type RequestComplexityRouterConfigPlanModePatternsList = Array<string>;
+export declare const RequestComplexityRouterConfigPlanModePatternsList: S.Schema<RequestComplexityRouterConfigPlanModePatternsList>;
+export type RequestComplexityRouterConfigReasoningKeywordsList = Array<string>;
+export declare const RequestComplexityRouterConfigReasoningKeywordsList: S.Schema<RequestComplexityRouterConfigReasoningKeywordsList>;
+/** One open/close delimiter pair a harness wraps injected context in. Normalizing here rather than at the scan is what makes matching case-insensitive: markers reach the scan already lowered, so it lowercases only the haystack and never the needles. Stripping keeps YAML indentation whitespace from becoming part of the delimiter. */
+export interface ReminderMarkerPair {
+    /** Closing delimiter, e.g. '</system-reminder>' */
+    close: string;
+    /** Opening delimiter, e.g. '<system-reminder>' */
+    open: string;
+}
+export declare const ReminderMarkerPair: S.Schema<ReminderMarkerPair>;
+export type RequestComplexityRouterConfigReminderMarkersList = Array<ReminderMarkerPair>;
+export declare const RequestComplexityRouterConfigReminderMarkersList: S.Schema<RequestComplexityRouterConfigReminderMarkersList>;
+export type RequestComplexityRouterConfigSimpleKeywordsList = Array<string>;
+export declare const RequestComplexityRouterConfigSimpleKeywordsList: S.Schema<RequestComplexityRouterConfigSimpleKeywordsList>;
+export type RequestComplexityRouterConfigTechnicalKeywordsList = Array<string>;
+export declare const RequestComplexityRouterConfigTechnicalKeywordsList: S.Schema<RequestComplexityRouterConfigTechnicalKeywordsList>;
+/** Score boundaries between tiers. These keys (simple_medium, medium_complex, complex_reasoning) name the gaps between the default tier names and are not renameable by tier_labels; they are scorer knobs persisted by name on every routing decision */
+export type RequestComplexityRouterConfigTierBoundariesMap = {
+    [key: string]: number | undefined;
+};
+export declare const RequestComplexityRouterConfigTierBoundariesMap: S.Schema<RequestComplexityRouterConfigTierBoundariesMap>;
+export type RequestComplexityRouterConfigTierDefinitionsList = Array<TierDefinition>;
+export declare const RequestComplexityRouterConfigTierDefinitionsList: S.Schema<RequestComplexityRouterConfigTierDefinitionsList>;
+/** Display names for the complexity tiers, so a deployment can use its own vocabulary (e.g. Cheap/Standard/Premium/Deep) in the dashboard, spend logs, and the LLM classifier rubric. Purely operator-facing: config keys stay canonical (tiers, keyword_tier_rules[].tier, tier_boundaries), API callers never see these names, and the heuristic scorer never reads them. Unlisted tiers keep their canonical name. Partial maps are allowed. */
+export type RequestComplexityRouterConfigTierLabelsMap = {
+    [key: string]: string | undefined;
+};
+export declare const RequestComplexityRouterConfigTierLabelsMap: S.Schema<RequestComplexityRouterConfigTierLabelsMap>;
+export type ComplexityTierModelLitellmParamsMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const ComplexityTierModelLitellmParamsMap: S.Schema<ComplexityTierModelLitellmParamsMap>;
+export interface ComplexityTierModel {
+    litellm_params?: ComplexityTierModelLitellmParamsMap;
+    model_name: string;
+}
+export declare const ComplexityTierModel: S.Schema<ComplexityTierModel>;
+export type RequestComplexityRouterConfigTierModelConfigsValueList = Array<ComplexityTierModel>;
+export declare const RequestComplexityRouterConfigTierModelConfigsValueList: S.Schema<RequestComplexityRouterConfigTierModelConfigsValueList>;
+export type RequestComplexityRouterConfigTierModelConfigsMap = {
+    [key: string]: RequestComplexityRouterConfigTierModelConfigsValueList | undefined;
+};
+export declare const RequestComplexityRouterConfigTierModelConfigsMap: S.Schema<RequestComplexityRouterConfigTierModelConfigsMap>;
+export type RequestComplexityRouterConfigTiersValueCase1List = Array<string>;
+export declare const RequestComplexityRouterConfigTiersValueCase1List: S.Schema<RequestComplexityRouterConfigTiersValueCase1List>;
+export type RequestComplexityRouterConfigTiersValue = string | RequestComplexityRouterConfigTiersValueCase1List;
+export declare const RequestComplexityRouterConfigTiersValue: S.Schema<RequestComplexityRouterConfigTiersValue>;
+/** Mapping of complexity tiers to a model or model pool. A list is randomly picked from when adaptive=False, and used as a soft-floor home pool when adaptive=True */
+export type RequestComplexityRouterConfigTiersMap = {
+    [key: string]: RequestComplexityRouterConfigTiersValue | undefined;
+};
+export declare const RequestComplexityRouterConfigTiersMap: S.Schema<RequestComplexityRouterConfigTiersMap>;
+/** Token count thresholds for simple/complex classification */
+export type RequestComplexityRouterConfigTokenThresholdsMap = {
+    [key: string]: number | undefined;
+};
+export declare const RequestComplexityRouterConfigTokenThresholdsMap: S.Schema<RequestComplexityRouterConfigTokenThresholdsMap>;
+/** The part of a complexity-router config a request can carry. `plugins` holds live RoutingPlugin objects, which no JSON body can express and which have no OpenAPI schema, so it is closed off here rather than left as an arbitrary-type field. */
+export interface RequestComplexityRouterConfig {
+    /** Enable adaptive bandit selection with soft complexity floors */
+    adaptive?: boolean;
+    /** When adaptive=True: 'all' scores every pool model with a tier-distance penalty (soft floors); 'classified_tier' Thompson-samples only inside the classified tier's pool */
+    adaptive_eligible?: RequestComplexityRouterConfigAdaptiveEligible | (string & {});
+    /** Quality vs cost weights for adaptive selection (used when adaptive=True) */
+    adaptive_weights?: AdaptiveRouterWeights;
+    /** Replaces the opening instructions of the LLM classifier rubric (the judging-criteria prose) for a custom tier set. The per-tier bullets and the trust-boundary paragraph telling the classifier to ignore tier requests embedded in quoted caller text are always appended after it and cannot be overridden. Requires tier_definitions; a built-in-tier router customizes its prompt via classifier_llm_config.system_prompt or classification_rubric instead. */
+    classification_prompt?: string | null;
+    /** Maximum characters of prior-turn text quoted to the LLM classifier, across the whole context window, per classification call. Turns are taken newest first and quoted whole while they fit, so a conversation small enough to quote entirely is never cut; once the budget runs out the older turns are dropped whole and only the turn straddling the boundary is truncated, into whatever space is left. The current ask and the caller's system prompt sit outside this budget and are always sent in full, as does the numbering each quoted turn carries. A budget under 120 leaves no room to quote a turn and suppresses the block; set classifier_context_window_size to 0 to turn context off deliberately. Only applies when classifier_type is 'llm'. */
+    classifier_context_budget_chars?: number;
+    /** Include assistant turns in the classifier context window, so difficulty stated by the model rather than by the user stays visible: a plan the assistant calls complex, which the user approves with 'yes', is classified on the work being approved instead of on the word 'yes'. When enabled, classifier_context_window_size counts the last N turns of the conversation across both roles rather than the last N user turns, and assistant text is sent to the classifier model, which may be a different deployment or provider than the routed completion model. Assistant replies spend classifier_context_budget_chars alongside user turns, so raise it if the oldest turns stop being quoted once replies join the window. Off by default because enabling it shifts tier decisions, and therefore spend, for an already-deployed router. Only applies when classifier_type is 'llm'. */
+    classifier_context_include_assistant_turns?: boolean;
+    /** Optional cap on each individual prior turn's text, applied before classifier_context_budget_chars bounds the block. Unset by default, so one long turn may spend the whole budget, which is usually what a follow-up needs; set it when no single turn should dominate the context the classifier sees. A capped turn keeps its opening and its ending with the middle elided. Only applies when classifier_type is 'llm'. */
+    classifier_context_per_turn_chars?: number | null;
+    /** Number of prior user turns (tool output and harness reminders excluded) to include as context in the LLM classifier prompt, so a follow-up like 'now do the same for the streaming path' is classified against what it refers to. Counts turns of both roles when classifier_context_include_assistant_turns is enabled. These turns are sent to the classifier model, which may be a different deployment or provider than the routed completion model; that call already carries the current user ask and the caller's system prompt in full. Set to 0 to send neither prior turns nor any conversation context beyond the current ask. Only applies when classifier_type is 'llm'. */
+    classifier_context_window_size?: number;
+    /** What classifies the request when the LLM classifier errors, times out, or returns an unparseable response. 'heuristic' runs the local complexity scorer, which is right when the classifier grades complexity too. 'default_model' skips scoring and routes to default_model, which is what a classifier on some other taxonomy wants: a prompt that grades data sensitivity has no use for a complexity score, and scoring one produces a tier unrelated to what the operator configured. Requires default_model when set to 'default_model'. Only applies when classifier_type is 'llm', 'custom', or 'heuristic_first'. */
+    classifier_fallback?: RequestComplexityRouterConfigClassifierFallback | (string & {});
+    /** Configuration for the LLM classifier; required when classifier_type is 'llm' or 'heuristic_first' */
+    classifier_llm_config?: ClassifierLLMConfig | null;
+    /** Not settable over HTTP; the classifier plugin is a runtime object */
+    classifier_plugin?: unknown | null;
+    /** Timeout budget for the classifier plugin call, in milliseconds. On expiry the fallback path decides the tier. Only applies when classifier_type is 'custom'. */
+    classifier_plugin_timeout_ms?: number;
+    /** Classification strategy: local regex/keyword scoring, an LLM call, a custom classifier plugin, or 'heuristic_first', which scores locally and only pays for the LLM classifier when the local scorer does not confidently land a cheap tier */
+    classifier_type?: RequestComplexityRouterConfigClassifierType | (string & {});
+    /** Keywords indicating code-related content */
+    code_keywords?: RequestComplexityRouterConfigCodeKeywordsList | null;
+    /** Domain-specific technical keywords appended to the effective base list (technical_keywords if set, otherwise DEFAULT_TECHNICAL_KEYWORDS). Order is preserved; duplicates are removed case-insensitively against the base list and within this list. */
+    custom_technical_keywords?: RequestComplexityRouterConfigCustomTechnicalKeywordsList | null;
+    /** Default model to use if tier cannot be determined */
+    default_model?: string | null;
+    /** When True and a session_id is resolvable on the request, pin the deployment chosen inside each routed model group and reuse it whenever the session returns to that group, without pinning which group the session routes to. Independent of session_affinity, which pins the model group instead (and always carries this deployment pin with it): with session_affinity off, every turn is still classified on its own merits while a session that escalates to a stronger tier and comes back still lands on the deployment it used before, which is what keeps a provider prompt cache warm. Pins are held per model group, so switching tiers does not disturb the pin left behind in the previous group. On by default because re-shuffling a conversation across deployments of the same model discards that cache for no benefit; set False to keep every turn load-balanced across the group, which is what a deployment set with tight per-deployment rate limits wants. Inert when no session_id is resolvable, since there is nothing to key a pin on, and suppressed when plugins are configured, for the same reason session_affinity is. */
+    deployment_affinity?: boolean;
+    /** Weights for each scoring dimension */
+    dimension_weights?: RequestComplexityRouterConfigDimensionWeightsMap;
+    /** Embedding model (LiteLLM model name) used when semantic_keyword_matching is enabled */
+    embedding_model?: string | null;
+    /** Case-sensitive phrases a user can include to force a bump to the next-higher complexity tier when they aren't satisfied with results (they can force a stronger model, but not choose which one). Defaults to ['LITELLM ESCALATE'] when unset; set to an empty list to disable. */
+    escalation_keywords?: RequestComplexityRouterConfigEscalationKeywordsList | null;
+    /** Tier routed to when the LLM classifier fails (timeout, provider error, or an unparseable reply). Required with tier_definitions and must name a defined tier; the heuristic scorer cannot produce custom tiers, so this replaces the heuristic fallback for custom tier sets. */
+    fallback_tier?: string | null;
+    /** The highest tier the local scorer may decide on its own; required when classifier_type is 'heuristic_first' and rejected otherwise. A request whose heuristic tier is at or below this one skips the LLM classifier and routes straight to that heuristic tier, so the classifier call is only paid for on traffic the scorer could not place cheaply. The scorer must also have produced at least one signal: a prompt where no dimension fired scores 0.0 and would otherwise land SIMPLE by default rather than by evidence, which is how a chained router would silently send unclassified traffic to the cheapest model. Names a built-in tier, and may not name the highest one, since that would make the LLM classifier unreachable. */
+    heuristic_first_max_tier?: string | null;
+    /** Additional case-sensitive literal sentinels that mark a request as client housekeeping, on top of the built-in conversation-title ones. For clients whose wording the built-ins don't cover, or after a client release changes its strings. */
+    housekeeping_patterns?: RequestComplexityRouterConfigHousekeepingPatternsList | null;
+    /** Rules that force a specific tier when their keywords match the prompt */
+    keyword_tier_rules?: RequestComplexityRouterConfigKeywordTierRulesList | null;
+    /** Minimum cosine similarity for a semantic keyword match */
+    match_threshold?: number;
+    /** When set, requests carrying a coding-agent plan-mode sentinel (Claude Code plan mode, VS Code Copilot Plan mode, Copilot CLI's exit_plan_mode tool) are routed to at least this tier: the classified tier still wins when it is higher, and the floor also overrides a session-affinity pin to a lower tier for exactly the turns carrying the sentinel, without rewriting the pin -- the first turn after plan mode exits routes as if plan mode had never happened. Names a built-in tier, or with tier_definitions set, one of the defined tier names (list order is ascending severity, same as keyword_tier_rules). Unset disables detection entirely. The sentinels ride in client-injected prompt text, so a caller who pastes one can spend up to this tier's models -- never down, and never outside the configured pools. */
+    plan_mode_min_tier?: string | null;
+    /** Additional case-sensitive literal sentinels that mark a request as plan mode, on top of the built-in Claude Code and Copilot ones. For clients whose plan-mode wording the built-ins don't cover, or after a client release changes its strings. */
+    plan_mode_patterns?: RequestComplexityRouterConfigPlanModePatternsList | null;
+    /** Not settable over HTTP; routing plugins are runtime objects */
+    plugins?: unknown | null;
+    /** Keywords indicating reasoning-required content */
+    reasoning_keywords?: RequestComplexityRouterConfigReasoningKeywordsList | null;
+    /** Minimum weighted score a request must reach before 2+ reasoning markers may promote it to the reasoning tier. Unset tracks tier_boundaries.simple_medium, so the override never rescues a request the scorer placed in the cheapest tier; 0 restores the unconditional override */
+    reasoning_override_min_score?: number | null;
+    /** Override the delimiter pairs used to recognize and strip harness-injected reminder blocks before classification. A harness that wraps injected context differently per agent type (main, subagent, cron) lists every pair it emits. Replaces, rather than adds to, the built-in default of ('<system-reminder>', '</system-reminder>'), so a harness that also emits that pair lists it too. Matching is case-insensitive. */
+    reminder_markers?: RequestComplexityRouterConfigReminderMarkersList | null;
+    /** Return the resolved raw model name in the response model field instead of the client-requested complexity-router alias */
+    return_raw_model_name?: boolean;
+    /** Route a coding agent's own housekeeping calls to the cheapest configured tier without classifying them. A client names the conversation by quoting the whole session and asking for a title, so the ask reads as the session's engineering work and lands on the most expensive tier, which is the reverse of what the call is worth. Detection is a literal match against client-owned sentinels on the newest ask only, so it cannot fire on an earlier turn, and it never lowers what anyone else asked for: a keyword_tier_rule or a session pin still decides instead, and an escalation keyword or the plan-mode floor still raises the tier from here. Only the classifier is displaced, and its call is skipped, so a matched request costs nothing to route. Set false to classify these calls like any other. */
+    route_housekeeping_to_cheapest_tier?: boolean;
+    /** Match keyword_tier_rules by embedding similarity instead of literal text */
+    semantic_keyword_matching?: boolean;
+    /** When True and a session_id is resolvable on the request, pin the model chosen on the session's first turn and reuse it for every later turn, skipping re-classification. Off by default so every turn is classified on its own merits and routed to the cheapest adequate tier. Set True to keep a multi-turn session on one model, which preserves provider prompt caches and avoids cross-model conversation-history errors. Always implies the deployment pin regardless of deployment_affinity: the session sticks to one deployment of the pinned model, since freezing the model while re-shuffling its deployments would still go cache-cold. */
+    session_affinity?: boolean;
+    /** TTL for the session affinity pin; refreshed on every cache hit. Bounds both the session_affinity model pin and the deployment_affinity deployment pin, so it measures idle time for the session's routing decisions rather than total session length */
+    session_affinity_ttl_seconds?: number;
+    /** Keywords indicating simple/basic queries */
+    simple_keywords?: RequestComplexityRouterConfigSimpleKeywordsList | null;
+    /** Keywords indicating technical content */
+    technical_keywords?: RequestComplexityRouterConfigTechnicalKeywordsList | null;
+    /** Score boundaries between tiers. These keys (simple_medium, medium_complex, complex_reasoning) name the gaps between the default tier names and are not renameable by tier_labels; they are scorer knobs persisted by name on every routing decision */
+    tier_boundaries?: RequestComplexityRouterConfigTierBoundariesMap;
+    /** Operator-defined tier set replacing the built-in SIMPLE/MEDIUM/COMPLEX/REASONING. Each entry's name becomes a value the LLM classifier can return and its description becomes that tier's rubric bullet; entries named after a built-in tier may omit the description and inherit the built-in criteria. List order is ascending severity and decides which tier wins when several keyword_tier_rules match. Requires classifier_type 'llm' or 'custom', a fallback_tier, and `tiers` keys matching the defined names exactly. Escalation, adaptive selection, session affinity, plugins, tier_labels, and the calibration-example rubric presets are unavailable with a custom tier set: the first four are built on the built-in tier ladder, and the last two rename or exemplify tiers the set replaces. */
+    tier_definitions?: RequestComplexityRouterConfigTierDefinitionsList | null;
+    /** Score penalty per tier-step away from the classified tier when adaptive=True */
+    tier_distance_penalty?: number;
+    /** Display names for the complexity tiers, so a deployment can use its own vocabulary (e.g. Cheap/Standard/Premium/Deep) in the dashboard, spend logs, and the LLM classifier rubric. Purely operator-facing: config keys stay canonical (tiers, keyword_tier_rules[].tier, tier_boundaries), API callers never see these names, and the heuristic scorer never reads them. Unlisted tiers keep their canonical name. Partial maps are allowed. */
+    tier_labels?: RequestComplexityRouterConfigTierLabelsMap;
+    tier_model_configs?: RequestComplexityRouterConfigTierModelConfigsMap;
+    /** Mapping of complexity tiers to a model or model pool. A list is randomly picked from when adaptive=False, and used as a soft-floor home pool when adaptive=True */
+    tiers?: RequestComplexityRouterConfigTiersMap;
+    /** Token count thresholds for simple/complex classification */
+    token_thresholds?: RequestComplexityRouterConfigTokenThresholdsMap;
+}
+export declare const RequestComplexityRouterConfig: S.Schema<RequestComplexityRouterConfig>;
+export type PostPreviewAutoRouterRoutingAutoRouterTestRoutingRequestMessagesItemMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const PostPreviewAutoRouterRoutingAutoRouterTestRoutingRequestMessagesItemMap: S.Schema<PostPreviewAutoRouterRoutingAutoRouterTestRoutingRequestMessagesItemMap>;
+export type PostPreviewAutoRouterRoutingAutoRouterTestRoutingRequestMessagesList = Array<PostPreviewAutoRouterRoutingAutoRouterTestRoutingRequestMessagesItemMap>;
+export declare const PostPreviewAutoRouterRoutingAutoRouterTestRoutingRequestMessagesList: S.Schema<PostPreviewAutoRouterRoutingAutoRouterTestRoutingRequestMessagesList>;
+export type PostPreviewAutoRouterRoutingAutoRouterTestRoutingRequestSystemCase1ItemMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const PostPreviewAutoRouterRoutingAutoRouterTestRoutingRequestSystemCase1ItemMap: S.Schema<PostPreviewAutoRouterRoutingAutoRouterTestRoutingRequestSystemCase1ItemMap>;
+export type PostPreviewAutoRouterRoutingAutoRouterTestRoutingRequestSystemCase1List = Array<PostPreviewAutoRouterRoutingAutoRouterTestRoutingRequestSystemCase1ItemMap>;
+export declare const PostPreviewAutoRouterRoutingAutoRouterTestRoutingRequestSystemCase1List: S.Schema<PostPreviewAutoRouterRoutingAutoRouterTestRoutingRequestSystemCase1List>;
+/** The top-level system prompt an Anthropic /v1/messages body carries beside its messages */
+export type PostPreviewAutoRouterRoutingAutoRouterTestRoutingRequestSystem = string | PostPreviewAutoRouterRoutingAutoRouterTestRoutingRequestSystemCase1List;
+export declare const PostPreviewAutoRouterRoutingAutoRouterTestRoutingRequestSystem: S.Schema<PostPreviewAutoRouterRoutingAutoRouterTestRoutingRequestSystem>;
+export type PostPreviewAutoRouterRoutingAutoRouterTestRoutingRequestToolsItemMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const PostPreviewAutoRouterRoutingAutoRouterTestRoutingRequestToolsItemMap: S.Schema<PostPreviewAutoRouterRoutingAutoRouterTestRoutingRequestToolsItemMap>;
+export type PostPreviewAutoRouterRoutingAutoRouterTestRoutingRequestToolsList = Array<PostPreviewAutoRouterRoutingAutoRouterTestRoutingRequestToolsItemMap>;
+export declare const PostPreviewAutoRouterRoutingAutoRouterTestRoutingRequestToolsList: S.Schema<PostPreviewAutoRouterRoutingAutoRouterTestRoutingRequestToolsList>;
+export interface PostPreviewAutoRouterRoutingAutoRouterTestRoutingRequest {
+    /** The complexity router config to route against, in the shape /model/new accepts */
+    complexity_router_config: RequestComplexityRouterConfig;
+    /** Model to route to when no tier resolves, i.e. complexity_router_default_model */
+    default_model?: string | null;
+    /** The full message list to route, exactly as the serving path would receive it. Mutually exclusive with prompt */
+    messages?: PostPreviewAutoRouterRoutingAutoRouterTestRoutingRequestMessagesList | null;
+    /** A single ask to route, as an end user would send it. Mutually exclusive with messages */
+    prompt?: string | null;
+    /** Name reported as the router in the routing decision. Display only */
+    router_name?: string;
+    /** The top-level system prompt an Anthropic /v1/messages body carries beside its messages */
+    system?: PostPreviewAutoRouterRoutingAutoRouterTestRoutingRequestSystem | null;
+    /** Team the router is being created for. Required for a team admin, who may only test their own team's routers */
+    team_id?: string | null;
+    /** The tool definitions the request advertises, which decide whether the plan-mode floor applies */
+    tools?: PostPreviewAutoRouterRoutingAutoRouterTestRoutingRequestToolsList | null;
+}
+export declare const PostPreviewAutoRouterRoutingAutoRouterTestRoutingRequest: S.Schema<PostPreviewAutoRouterRoutingAutoRouterTestRoutingRequest>;
+export type StandardLoggingRoutingDecisionCause = "heuristic_scorer" | "reasoning_override" | "llm_classifier" | "heuristic_first_short_circuit" | "classifier_plugin" | "classifier_fallback" | "default_model_fallback" | "literal_keyword_match" | "semantic_keyword_match" | "plan_mode" | "housekeeping" | "session_affinity_pin" | "session_affinity_escalation" | "default_fallback" | "keyword" | "quality_tier" | "bandit";
+export declare const StandardLoggingRoutingDecisionCause: any;
+export type StandardLoggingRoutingDecisionRouterType = "complexity" | "adaptive" | "quality";
+export declare const StandardLoggingRoutingDecisionRouterType: any;
+export type StandardLoggingRoutingDecisionSignalsList = Array<string>;
+export declare const StandardLoggingRoutingDecisionSignalsList: S.Schema<StandardLoggingRoutingDecisionSignalsList>;
+/** Snapshot of the complexity scorer's tier boundaries at decision time, so a historical spend log row stays explainable after the router config changes. */
+export interface StandardLoggingRoutingDecisionTierBoundaries {
+    complex_reasoning: number;
+    medium_complex: number;
+    simple_medium: number;
+}
+export declare const StandardLoggingRoutingDecisionTierBoundaries: S.Schema<StandardLoggingRoutingDecisionTierBoundaries>;
+export type StandardLoggingRoutingDecisionTierLitellmParamsMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const StandardLoggingRoutingDecisionTierLitellmParamsMap: S.Schema<StandardLoggingRoutingDecisionTierLitellmParamsMap>;
+/** Per-request provenance for a pre-routing strategy (auto-router) decision. */
+export interface StandardLoggingRoutingDecision {
+    cause?: StandardLoggingRoutingDecisionCause;
+    classifier_cost?: number;
+    classifier_model?: string;
+    conversation_continuing?: boolean;
+    escalated?: boolean;
+    escalation_keyword?: string;
+    matched_keyword?: string;
+    reasoning_override_min_score?: number;
+    request_type?: string;
+    routed_model?: string;
+    router_model_name?: string;
+    router_type?: StandardLoggingRoutingDecisionRouterType;
+    savings_baseline_deployment_id?: string;
+    savings_baseline_model?: string;
+    score?: number;
+    signals?: StandardLoggingRoutingDecisionSignalsList;
+    tier?: string;
+    tier_boundaries?: StandardLoggingRoutingDecisionTierBoundaries;
+    tier_label?: string;
+    tier_litellm_params?: StandardLoggingRoutingDecisionTierLitellmParamsMap;
+}
+export declare const StandardLoggingRoutingDecision: S.Schema<StandardLoggingRoutingDecision>;
+/** Where one prompt would have been routed, and why. */
+export interface AutoRouterRoutingTestResponse {
+    /** The model group the router picked */
+    routed_model: string;
+    /** Whether routed_model is a model group available to the caller, scoped to team_id when given. Never confirms models the caller could not use */
+    routed_model_configured: boolean;
+    /** The decision record this request would have written to its log row */
+    routing_decision: StandardLoggingRoutingDecision;
+}
+export declare const AutoRouterRoutingTestResponse: S.Schema<AutoRouterRoutingTestResponse>;
+export interface PostReloadAnthropicBetaHeadersReloadAnthropicBetaHeaderRequest {
+}
+export declare const PostReloadAnthropicBetaHeadersReloadAnthropicBetaHeaderRequest: S.Schema<PostReloadAnthropicBetaHeadersReloadAnthropicBetaHeaderRequest>;
+export interface PostReloadAnthropicBetaHeadersReloadAnthropicBetaHeaderResponse {
+    body: unknown;
+}
+export declare const PostReloadAnthropicBetaHeadersReloadAnthropicBetaHeaderResponse: S.Schema<PostReloadAnthropicBetaHeadersReloadAnthropicBetaHeaderResponse>;
+export interface PostReloadModelCostMapReloadModelCostMapRequest {
+}
+export declare const PostReloadModelCostMapReloadModelCostMapRequest: S.Schema<PostReloadModelCostMapReloadModelCostMapRequest>;
+export interface PostReloadModelCostMapReloadModelCostMapResponse {
+    body: unknown;
+}
+export declare const PostReloadModelCostMapReloadModelCostMapResponse: S.Schema<PostReloadModelCostMapReloadModelCostMapResponse>;
+export interface PostScheduleAnthropicBetaHeadersReloadScheduleAnthropicBetaHeadersReloadRequest {
+    hours: number;
+}
+export declare const PostScheduleAnthropicBetaHeadersReloadScheduleAnthropicBetaHeadersReloadRequest: S.Schema<PostScheduleAnthropicBetaHeadersReloadScheduleAnthropicBetaHeadersReloadRequest>;
+export interface PostScheduleAnthropicBetaHeadersReloadScheduleAnthropicBetaHeadersReloadResponse {
+    body: unknown;
+}
+export declare const PostScheduleAnthropicBetaHeadersReloadScheduleAnthropicBetaHeadersReloadResponse: S.Schema<PostScheduleAnthropicBetaHeadersReloadScheduleAnthropicBetaHeadersReloadResponse>;
+export interface PostScheduleModelCostMapReloadScheduleModelCostMapReloadRequest {
+    hours: number;
+}
+export declare const PostScheduleModelCostMapReloadScheduleModelCostMapReloadRequest: S.Schema<PostScheduleModelCostMapReloadScheduleModelCostMapReloadRequest>;
+export interface PostScheduleModelCostMapReloadScheduleModelCostMapReloadResponse {
+    body: unknown;
+}
+export declare const PostScheduleModelCostMapReloadScheduleModelCostMapReloadResponse: S.Schema<PostScheduleModelCostMapReloadScheduleModelCostMapReloadResponse>;
+export interface PutSetAccessGroupBudgetAccessGroupAccessGroupBudgetRequest {
+    access_group: string;
+    budget_duration?: string | null;
+    budget_id?: string | null;
+    max_budget?: number | null;
+    soft_budget?: number | null;
+}
+export declare const PutSetAccessGroupBudgetAccessGroupAccessGroupBudgetRequest: S.Schema<PutSetAccessGroupBudgetAccessGroupAccessGroupBudgetRequest>;
+export interface UnblockModelModelUnblockPostRequest {
+    model_id: string;
+}
+export declare const UnblockModelModelUnblockPostRequest: S.Schema<UnblockModelModelUnblockPostRequest>;
+export interface UnblockModelModelUnblockPostResponse {
+    body: LiteLLMProxyModelTable | null;
+}
+export declare const UnblockModelModelUnblockPostResponse: S.Schema<UnblockModelModelUnblockPostResponse>;
+export type UpdateAccessGroupAccessGroupAccessGroupUpdatePutRequestModelIdsList = Array<string>;
+export declare const UpdateAccessGroupAccessGroupAccessGroupUpdatePutRequestModelIdsList: S.Schema<UpdateAccessGroupAccessGroupAccessGroupUpdatePutRequestModelIdsList>;
+export type UpdateAccessGroupAccessGroupAccessGroupUpdatePutRequestModelNamesList = Array<string>;
+export declare const UpdateAccessGroupAccessGroupAccessGroupUpdatePutRequestModelNamesList: S.Schema<UpdateAccessGroupAccessGroupAccessGroupUpdatePutRequestModelNamesList>;
+export interface UpdateAccessGroupAccessGroupAccessGroupUpdatePutRequest {
+    access_group: string;
+    model_ids?: UpdateAccessGroupAccessGroupAccessGroupUpdatePutRequestModelIdsList | null;
+    model_names?: UpdateAccessGroupAccessGroupAccessGroupUpdatePutRequestModelNamesList | null;
+}
+export declare const UpdateAccessGroupAccessGroupAccessGroupUpdatePutRequest: S.Schema<UpdateAccessGroupAccessGroupAccessGroupUpdatePutRequest>;
+export interface UpdateModelModelUpdatePostRequest {
+    blocked?: boolean | null;
+    litellm_params?: UpdateLiteLLMParams | null;
+    model_info?: LitellmTypesRouterModelInfo | null;
+    model_name?: string | null;
+}
+export declare const UpdateModelModelUpdatePostRequest: S.Schema<UpdateModelModelUpdatePostRequest>;
+export interface UpdateModelModelUpdatePostResponse {
+    body: unknown;
+}
+export declare const UpdateModelModelUpdatePostResponse: S.Schema<UpdateModelModelUpdatePostResponse>;
+/** List of model group names to make public */
+export type UpdatePublicModelGroupsModelGroupMakePublicPostRequestModelGroupsList = Array<string>;
+export declare const UpdatePublicModelGroupsModelGroupMakePublicPostRequestModelGroupsList: S.Schema<UpdatePublicModelGroupsModelGroupMakePublicPostRequestModelGroupsList>;
+export interface UpdatePublicModelGroupsModelGroupMakePublicPostRequest {
+    /** List of model group names to make public */
+    model_groups: UpdatePublicModelGroupsModelGroupMakePublicPostRequestModelGroupsList;
+}
+export declare const UpdatePublicModelGroupsModelGroupMakePublicPostRequest: S.Schema<UpdatePublicModelGroupsModelGroupMakePublicPostRequest>;
+export interface UpdatePublicModelGroupsModelGroupMakePublicPostResponse {
+    body: unknown;
+}
+export declare const UpdatePublicModelGroupsModelGroupMakePublicPostResponse: S.Schema<UpdatePublicModelGroupsModelGroupMakePublicPostResponse>;
+export type UpdateUsefulLinksModelHubUpdateUsefulLinksPostRequestUsefulLinksValueCase1Map = {
+    [key: string]: unknown | undefined;
+};
+export declare const UpdateUsefulLinksModelHubUpdateUsefulLinksPostRequestUsefulLinksValueCase1Map: S.Schema<UpdateUsefulLinksModelHubUpdateUsefulLinksPostRequestUsefulLinksValueCase1Map>;
+export type UpdateUsefulLinksModelHubUpdateUsefulLinksPostRequestUsefulLinksValue = string | UpdateUsefulLinksModelHubUpdateUsefulLinksPostRequestUsefulLinksValueCase1Map;
+export declare const UpdateUsefulLinksModelHubUpdateUsefulLinksPostRequestUsefulLinksValue: S.Schema<UpdateUsefulLinksModelHubUpdateUsefulLinksPostRequestUsefulLinksValue>;
+export type UpdateUsefulLinksModelHubUpdateUsefulLinksPostRequestUsefulLinksMap = {
+    [key: string]: UpdateUsefulLinksModelHubUpdateUsefulLinksPostRequestUsefulLinksValue | undefined;
+};
+export declare const UpdateUsefulLinksModelHubUpdateUsefulLinksPostRequestUsefulLinksMap: S.Schema<UpdateUsefulLinksModelHubUpdateUsefulLinksPostRequestUsefulLinksMap>;
+export interface UpdateUsefulLinksModelHubUpdateUsefulLinksPostRequest {
+    useful_links: UpdateUsefulLinksModelHubUpdateUsefulLinksPostRequestUsefulLinksMap;
+}
+export declare const UpdateUsefulLinksModelHubUpdateUsefulLinksPostRequest: S.Schema<UpdateUsefulLinksModelHubUpdateUsefulLinksPostRequest>;
+export interface UpdateUsefulLinksModelHubUpdateUsefulLinksPostResponse {
+    body: unknown;
+}
+export declare const UpdateUsefulLinksModelHubUpdateUsefulLinksPostResponse: S.Schema<UpdateUsefulLinksModelHubUpdateUsefulLinksPostResponse>;
+export type ValidateComplexityRouterConfigAutoRouterValidateComplexityRouterConfigPostRequestComplexityRouterConfigMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const ValidateComplexityRouterConfigAutoRouterValidateComplexityRouterConfigPostRequestComplexityRouterConfigMap: S.Schema<ValidateComplexityRouterConfigAutoRouterValidateComplexityRouterConfigPostRequestComplexityRouterConfigMap>;
+export interface ValidateComplexityRouterConfigAutoRouterValidateComplexityRouterConfigPostRequest {
+    complexity_router_config: ValidateComplexityRouterConfigAutoRouterValidateComplexityRouterConfigPostRequestComplexityRouterConfigMap;
+    /** Team the router is being created for. Required for a team admin, who may only validate their own team's routers */
+    team_id?: string | null;
+}
+export declare const ValidateComplexityRouterConfigAutoRouterValidateComplexityRouterConfigPostRequest: S.Schema<ValidateComplexityRouterConfigAutoRouterValidateComplexityRouterConfigPostRequest>;
+export interface ComplexityRouterConfigValidationResponse {
+    error?: string | null;
+    valid: boolean;
+}
+export declare const ComplexityRouterConfigValidationResponse: S.Schema<ComplexityRouterConfigValidationResponse>;
+export type AddNewModelModelNewPostError = UnprocessableEntity | LitellmOpError;
+/** Add New Model Allows adding new models to the model list in the config.yaml */
+export declare const addNewModelModelNewPost: API.OperationMethod<AddNewModelModelNewPostRequest, AddNewModelModelNewPostResponse, AddNewModelModelNewPostError, LitellmOpContext>;
+export type CancelAnthropicBetaHeadersReloadScheduleAnthropicBetaHeadersReloadDeleteError = LitellmOpError;
+/** Cancel Anthropic Beta Headers Reload ADMIN ONLY / MASTER KEY Only Endpoint Cancel the scheduled periodic reload of the Anthropic beta headers configuration. */
+export declare const cancelAnthropicBetaHeadersReloadScheduleAnthropicBetaHeadersReloadDelete: API.OperationMethod<CancelAnthropicBetaHeadersReloadScheduleAnthropicBetaHeadersReloadDeleteRequest, CancelAnthropicBetaHeadersReloadScheduleAnthropicBetaHeadersReloadDeleteResponse, CancelAnthropicBetaHeadersReloadScheduleAnthropicBetaHeadersReloadDeleteError, LitellmOpContext>;
+export type CancelModelCostMapReloadScheduleModelCostMapReloadDeleteError = LitellmOpError;
+/** Cancel Model Cost Map Reload ADMIN ONLY / MASTER KEY Only Endpoint Cancel the scheduled periodic reload of the model cost map. */
+export declare const cancelModelCostMapReloadScheduleModelCostMapReloadDelete: API.OperationMethod<CancelModelCostMapReloadScheduleModelCostMapReloadDeleteRequest, CancelModelCostMapReloadScheduleModelCostMapReloadDeleteResponse, CancelModelCostMapReloadScheduleModelCostMapReloadDeleteError, LitellmOpContext>;
+export type CreateModelGroupAccessGroupNewPostError = UnprocessableEntity | LitellmOpError;
+/** Create Model Group Create a new access group containing multiple model names. An access group is a named collection of model groups that can be referenced by teams/keys for simplified access control. Example: ```bash curl -X POST 'http://localhost:4000/access_group/new' \ -H 'Authorization: Bearer sk-1234' \ -H 'Content-Type: application/json' \ -d '{ "access_group": "production-models", "model_names": ["gpt-4", "claude-3-opus", "gemini-pro"] }' ``` Parameters: - access_group: str - The access group name (e.g., "production-models") - model_names: List[str] - List of existing model groups to include Returns: - NewModelGroupResponse with the created access group details Raises: - HTTPException 400: If any model names don't exist - HTTPException 500: If database operations fail */
+export declare const createModelGroupAccessGroupNewPost: API.OperationMethod<CreateModelGroupAccessGroupNewPostRequest, NewModelGroupResponse, CreateModelGroupAccessGroupNewPostError, LitellmOpContext>;
+export type DeleteAccessGroupAccessGroupAccessGroupDeleteDeleteError = UnprocessableEntity | LitellmOpError;
+/** Delete Access Group Delete an access group. Removes the access group from all deployments that have it. Example: ```bash curl -X DELETE 'http://localhost:4000/access_group/production-models/delete' \ -H 'Authorization: Bearer sk-1234' ``` Parameters: - access_group: str - The access group name (URL path parameter) Returns: - DeleteModelGroupResponse with deletion details Raises: - HTTPException 404: If access group not found */
+export declare const deleteAccessGroupAccessGroupAccessGroupDeleteDelete: API.OperationMethod<DeleteAccessGroupAccessGroupAccessGroupDeleteDeleteRequest, DeleteModelGroupResponse, DeleteAccessGroupAccessGroupAccessGroupDeleteDeleteError, LitellmOpContext>;
+export type DeleteAccessGroupBudgetAccessGroupAccessGroupBudgetDeleteError = UnprocessableEntity | LitellmOpError;
+/** Delete Access Group Budget Clear the shared budget of an access group, leaving the group itself in place. Example: ```bash curl -X DELETE 'http://localhost:4000/access_group/production-models/budget' \ -H 'Authorization: Bearer sk-1234' ``` Parameters: - access_group: str - The access group name (URL path parameter) Returns: - DeleteAccessGroupBudgetResponse; budget_deleted is false when there was nothing to clear Raises: - HTTPException 404: If access group not found */
+export declare const deleteAccessGroupBudgetAccessGroupAccessGroupBudgetDelete: API.OperationMethod<DeleteAccessGroupBudgetAccessGroupAccessGroupBudgetDeleteRequest, DeleteAccessGroupBudgetResponse, DeleteAccessGroupBudgetAccessGroupAccessGroupBudgetDeleteError, LitellmOpContext>;
+export type DeleteModelModelDeletePostError = BadRequest | UnprocessableEntity | LitellmOpError;
+/** Delete Model Allows deleting models in the model list in the config.yaml */
+export declare const deleteModelModelDeletePost: API.OperationMethod<DeleteModelModelDeletePostRequest, DeleteModelModelDeletePostResponse, DeleteModelModelDeletePostError, LitellmOpContext>;
+export type GetAccessGroupBudgetAccessGroupAccessGroupBudgetGetError = UnprocessableEntity | LitellmOpError;
+/** Get Access Group Budget Get the shared budget of an access group, and the spend drawn against it. Example: ```bash curl -X GET 'http://localhost:4000/access_group/production-models/budget' \ -H 'Authorization: Bearer sk-1234' ``` Parameters: - access_group: str - The access group name (URL path parameter) Returns: - AccessGroupBudgetResponse; budget is null when the group has no budget set Raises: - HTTPException 404: If access group not found */
+export declare const getAccessGroupBudgetAccessGroupAccessGroupBudgetGet: API.OperationMethod<GetAccessGroupBudgetAccessGroupAccessGroupBudgetGetRequest, AccessGroupBudgetResponse, GetAccessGroupBudgetAccessGroupAccessGroupBudgetGetError, LitellmOpContext>;
+export type GetAccessGroupInfoAccessGroupAccessGroupInfoGetError = UnprocessableEntity | LitellmOpError;
+/** Get Access Group Info Get information about a specific access group. Example: ```bash curl -X GET 'http://localhost:4000/access_group/production-models/info' \ -H 'Authorization: Bearer sk-1234' ``` Parameters: - access_group: str - The access group name (URL path parameter) Returns: - AccessGroupInfo with the access group details, its shared budget and its spend Raises: - HTTPException 404: If access group not found */
+export declare const getAccessGroupInfoAccessGroupAccessGroupInfoGet: API.OperationMethod<GetAccessGroupInfoAccessGroupAccessGroupInfoGetRequest, AccessGroupInfo, GetAccessGroupInfoAccessGroupAccessGroupInfoGetError, LitellmOpContext>;
+export type GetAnthropicBetaHeadersReloadStatusScheduleAnthropicBetaHeadersReloadStatusGetError = LitellmOpError;
+/** Get Anthropic Beta Headers Reload Status ADMIN ONLY / MASTER KEY Only Endpoint Get the status of the scheduled Anthropic beta headers reload job. */
+export declare const getAnthropicBetaHeadersReloadStatusScheduleAnthropicBetaHeadersReloadStatusGet: API.OperationMethod<GetAnthropicBetaHeadersReloadStatusScheduleAnthropicBetaHeadersReloadStatusGetRequest, GetAnthropicBetaHeadersReloadStatusScheduleAnthropicBetaHeadersReloadStatusGetResponse, GetAnthropicBetaHeadersReloadStatusScheduleAnthropicBetaHeadersReloadStatusGetError, LitellmOpContext>;
+export type GetAutoRouterClassifierDefaultPromptAutoRouterClassifierDefaultPromptGetError = UnprocessableEntity | LitellmOpError;
+/** Get Auto Router Classifier Default Prompt Get the built-in system prompt used by an auto-router's LLM classifier */
+export declare const getAutoRouterClassifierDefaultPromptAutoRouterClassifierDefaultPromptGet: API.OperationMethod<GetAutoRouterClassifierDefaultPromptAutoRouterClassifierDefaultPromptGetRequest, AutoRouterClassifierDefaultPromptResponse, GetAutoRouterClassifierDefaultPromptAutoRouterClassifierDefaultPromptGetError, LitellmOpContext>;
+export type GetModelCostMapReloadStatusScheduleModelCostMapReloadStatusGetError = LitellmOpError;
+/** Get Model Cost Map Reload Status ADMIN ONLY / MASTER KEY Only Endpoint Get the status of the scheduled model cost map reload job. */
+export declare const getModelCostMapReloadStatusScheduleModelCostMapReloadStatusGet: API.OperationMethod<GetModelCostMapReloadStatusScheduleModelCostMapReloadStatusGetRequest, GetModelCostMapReloadStatusScheduleModelCostMapReloadStatusGetResponse, GetModelCostMapReloadStatusScheduleModelCostMapReloadStatusGetError, LitellmOpContext>;
+export type GetModelCostMapSourceModelCostMapSourceGetError = LitellmOpError;
+/** Get Model Cost Map Source ADMIN ONLY / MASTER KEY Only Endpoint Returns information about where the current model cost/pricing data was loaded from. Response fields: - source: "local" (bundled backup) or "remote" (fetched from URL) - url: the remote URL that was attempted (null when env-forced local) - is_env_forced: true if LITELLM_LOCAL_MODEL_COST_MAP=True forced local usage - fallback_reason: human-readable reason why remote failed (null on success) - model_count: number of models in the currently loaded cost map */
+export declare const getModelCostMapSourceModelCostMapSourceGet: API.OperationMethod<GetModelCostMapSourceModelCostMapSourceGetRequest, GetModelCostMapSourceModelCostMapSourceGetResponse, GetModelCostMapSourceModelCostMapSourceGetError, LitellmOpContext>;
+export type GetModelDeprecationsModelDeprecationError = UnprocessableEntity | LitellmOpError;
+/** Model Deprecations List models with known deprecation/sunset dates, bucketed by urgency. Reads `deprecation_date` metadata from `model_prices_and_context_window.json` (and any per-deployment `model_info.deprecation_date` overrides) for the models configured on this proxy. Parameters: warn_within_days: Window (in days) used to bucket "imminent" models, 30 by default. Returns: A payload with three lists of `ModelDeprecationInfo` entries: - `deprecated`: deprecation date is in the past, so these requests may fail at any time. - `imminent`: deprecation date is within `warn_within_days` from today. - `upcoming`: deprecation date is further out. Example: ```shell curl -X GET 'http://localhost:4000/model/deprecations' \ -H 'Authorization: Bearer sk-1234' ``` */
+export declare const getModelDeprecationsModelDeprecation: API.OperationMethod<GetModelDeprecationsModelDeprecationRequest, ModelDeprecationResponse, GetModelDeprecationsModelDeprecationError, LitellmOpContext>;
+export type GetModelDeprecationsV1ModelDeprecationError = UnprocessableEntity | LitellmOpError;
+/** Model Deprecations List models with known deprecation/sunset dates, bucketed by urgency. Reads `deprecation_date` metadata from `model_prices_and_context_window.json` (and any per-deployment `model_info.deprecation_date` overrides) for the models configured on this proxy. Parameters: warn_within_days: Window (in days) used to bucket "imminent" models, 30 by default. Returns: A payload with three lists of `ModelDeprecationInfo` entries: - `deprecated`: deprecation date is in the past, so these requests may fail at any time. - `imminent`: deprecation date is within `warn_within_days` from today. - `upcoming`: deprecation date is further out. Example: ```shell curl -X GET 'http://localhost:4000/model/deprecations' \ -H 'Authorization: Bearer sk-1234' ``` */
+export declare const getModelDeprecationsV1ModelDeprecation: API.OperationMethod<GetModelDeprecationsV1ModelDeprecationRequest, ModelDeprecationResponse, GetModelDeprecationsV1ModelDeprecationError, LitellmOpContext>;
+export type GetModelGroupInfoModelGroupInfoError = UnprocessableEntity | LitellmOpError;
+/** Model Group Info Get information about all the deployments on litellm proxy, including config.yaml descriptions (except api key and api base) - /model_group/info returns all model groups. End users of proxy should use /model_group/info since those models will be used for /chat/completions, /embeddings, etc. - /model_group/info?model_group=rerank-english-v3.0 returns all model groups for a specific model group (`model_name` in config.yaml) Example Request (All Models): ```shell curl -X 'GET' 'http://localhost:4000/model_group/info' -H 'accept: application/json' -H 'x-api-key: sk-1234' ``` Example Request (Specific Model Group): ```shell curl -X 'GET' 'http://localhost:4000/model_group/info?model_group=rerank-english-v3.0' -H 'accept: application/json' -H 'Authorization: Bearer sk-1234' ``` Example Request (Specific Wildcard Model Group): (e.g. `model_name: openai/*` on config.yaml) ```shell curl -X 'GET' 'http://localhost:4000/model_group/info?model_group=openai/tts-1' -H 'accept: application/json' -H 'Authorization: Bearersk-1234' ``` Learn how to use and set wildcard models [here](https://docs.litellm.ai/docs/wildcard_routing) Example Response: ```json { "data": [ { "model_group": "rerank-english-v3.0", "providers": [ "cohere" ], "max_input_tokens": null, "max_output_tokens": null, "input_cost_per_token": 0.0, "output_cost_per_token": 0.0, "mode": null, "tpm": null, "rpm": null, "supports_parallel_function_calling": false, "supports_vision": false, "supports_function_calling": false, "supported_openai_params": [ "stream", "temperature", "max_tokens", "logit_bias", "top_p", "frequency_penalty", "presence_penalty", "stop", "n", "extra_headers" ] }, { "model_group": "gpt-3.5-turbo", "providers": [ "openai" ], "max_input_tokens": 16385.0, "max_output_tokens": 4096.0, "input_cost_per_token": 1.5e-06, "output_cost_per_token": 2e-06, "mode": "chat", "tpm": null, "rpm": null, "supports_parallel_function_calling": false, "supports_vision": false, "supports_function_calling": true, "supported_openai_params": [ "frequency_penalty", "logit_bias", "logprobs", "top_logprobs", "max_tokens", "max_completion_tokens", "n", "presence_penalty", "seed", "stop", "stream", "stream_options", "temperature", "top_p", "tools", "tool_choice", "function_call", "functions", "max_retries", "extra_headers", "parallel_tool_calls", "response_format" ] }, { "model_group": "llava-hf", "providers": [ "openai" ], "max_input_tokens": null, "max_output_tokens": null, "input_cost_per_token": 0.0, "output_cost_per_token": 0.0, "mode": null, "tpm": null, "rpm": null, "supports_parallel_function_calling": false, "supports_vision": true, "supports_function_calling": false, "supported_openai_params": [ "frequency_penalty", "logit_bias", "logprobs", "top_logprobs", "max_tokens", "max_completion_tokens", "n", "presence_penalty", "seed", "stop", "stream", "stream_options", "temperature", "top_p", "tools", "tool_choice", "function_call", "functions", "max_retries", "extra_headers", "parallel_tool_calls", "response_format" ] } ] } ``` */
+export declare const getModelGroupInfoModelGroupInfo: API.OperationMethod<GetModelGroupInfoModelGroupInfoRequest, GetModelGroupInfoModelGroupInfoResponse, GetModelGroupInfoModelGroupInfoError, LitellmOpContext>;
+export type GetModelInfoModelsModelIdError = UnprocessableEntity | LitellmOpError;
+/** Model Info Retrieve information about a specific model accessible to your API key. Returns model details only if the model is available to your API key/team. Returns 404 if the model doesn't exist or is not accessible. Follows OpenAI API specification for individual model retrieval. https://platform.openai.com/docs/api-reference/models/retrieve Query parameters mirror `/v1/models` so the same caller context (team scoping, health filtering, paused deployments) drives both endpoints; the listing's public id must resolve to the same internal deployment here. */
+export declare const getModelInfoModelsModelId: API.OperationMethod<GetModelInfoModelsModelIdRequest, GetModelInfoModelsModelIdResponse, GetModelInfoModelsModelIdError, LitellmOpContext>;
+export type GetModelInfoV1ModelInfoError = UnprocessableEntity | LitellmOpError;
+/** Model Info V1 Provides more info about each model in /models, including config.yaml descriptions (except api key and api base) Parameters: litellm_model_id: Optional[str] = None (this is the value of `x-litellm-model-id` returned in response headers) - When litellm_model_id is passed, it will return the info for that specific model - When litellm_model_id is not passed, it will return the info for all models - include_team_models: When true, filter to deployments the caller can use (same as /v2/model/info). - teamId: Filter to models accessible by the given team. - healthy_only: When true, hide models whose backing deployments are all marked unhealthy by background health checks, matching `/v1/models?healthy_only=true`. Set `general_settings.model_list_healthy_only: true` to apply this to every caller without the query parameter. Requires `background_health_checks: true`, plus either `model_list_healthy_only` or `enable_health_check_routing` to keep deployment health state cached; without health state the listing is returned unfiltered (fail open). Ignored when `litellm_model_id` is passed, since that is a direct lookup of one deployment rather than a listing. Hiding is presentation-only: a hidden model can still be called directly. Each model in the list response includes `model_info.access_via_team_ids` and `model_info.direct_access` when the proxy database is connected. Returns: Returns a dictionary containing information about each model. Example Response: ```json { "data": [ { "model_name": "fake-openai-endpoint", "litellm_params": { "api_base": "https://exampleopenaiendpoint-production.up.railway.app/", "model": "openai/fake" }, "model_info": { "id": "112f74fab24a7a5245d2ced3536dd8f5f9192c57ee6e332af0f0512e08bed5af", "db_model": false } } ] } ``` */
+export declare const getModelInfoV1ModelInfo: API.OperationMethod<GetModelInfoV1ModelInfoRequest, GetModelInfoV1ModelInfoResponse, GetModelInfoV1ModelInfoError, LitellmOpContext>;
+export type GetModelInfoV1ModelsModelIdError = UnprocessableEntity | LitellmOpError;
+/** Model Info Retrieve information about a specific model accessible to your API key. Returns model details only if the model is available to your API key/team. Returns 404 if the model doesn't exist or is not accessible. Follows OpenAI API specification for individual model retrieval. https://platform.openai.com/docs/api-reference/models/retrieve Query parameters mirror `/v1/models` so the same caller context (team scoping, health filtering, paused deployments) drives both endpoints; the listing's public id must resolve to the same internal deployment here. */
+export declare const getModelInfoV1ModelsModelId: API.OperationMethod<GetModelInfoV1ModelsModelIdRequest, GetModelInfoV1ModelsModelIdResponse, GetModelInfoV1ModelsModelIdError, LitellmOpContext>;
+export type GetModelInfoV1V1ModelInfoError = UnprocessableEntity | LitellmOpError;
+/** Model Info V1 Provides more info about each model in /models, including config.yaml descriptions (except api key and api base) Parameters: litellm_model_id: Optional[str] = None (this is the value of `x-litellm-model-id` returned in response headers) - When litellm_model_id is passed, it will return the info for that specific model - When litellm_model_id is not passed, it will return the info for all models - include_team_models: When true, filter to deployments the caller can use (same as /v2/model/info). - teamId: Filter to models accessible by the given team. - healthy_only: When true, hide models whose backing deployments are all marked unhealthy by background health checks, matching `/v1/models?healthy_only=true`. Set `general_settings.model_list_healthy_only: true` to apply this to every caller without the query parameter. Requires `background_health_checks: true`, plus either `model_list_healthy_only` or `enable_health_check_routing` to keep deployment health state cached; without health state the listing is returned unfiltered (fail open). Ignored when `litellm_model_id` is passed, since that is a direct lookup of one deployment rather than a listing. Hiding is presentation-only: a hidden model can still be called directly. Each model in the list response includes `model_info.access_via_team_ids` and `model_info.direct_access` when the proxy database is connected. Returns: Returns a dictionary containing information about each model. Example Response: ```json { "data": [ { "model_name": "fake-openai-endpoint", "litellm_params": { "api_base": "https://exampleopenaiendpoint-production.up.railway.app/", "model": "openai/fake" }, "model_info": { "id": "112f74fab24a7a5245d2ced3536dd8f5f9192c57ee6e332af0f0512e08bed5af", "db_model": false } } ] } ``` */
+export declare const getModelInfoV1V1ModelInfo: API.OperationMethod<GetModelInfoV1V1ModelInfoRequest, GetModelInfoV1V1ModelInfoResponse, GetModelInfoV1V1ModelInfoError, LitellmOpContext>;
+export type GetModelInfoV2V2ModelInfoError = UnprocessableEntity | LitellmOpError;
+/** Model Info V2 Paginated model metadata for proxy deployments (pricing, provider, team access). Returns configured router deployments with enriched `model_info` (costs, provider, context window, etc.). Sensitive fields such as API keys and api_base are omitted. Query parameters: model: Filter to a single public `model_name`. user_models_only: When true, only return models created by the calling user. include_team_models: When true, populate `access_via_team_ids` and `direct_access` on each model and filter to deployments the caller can use. page / size: Pagination controls (defaults: page=1, size=50). search: Case-insensitive partial match on model name or team public name. modelId: Return a single deployment by LiteLLM model id. teamId: Filter to models with direct access or team membership for this team id. sortBy / sortOrder: Sort by model_name, created_at, updated_at, costs, or status. Example request: ``` curl -X GET 'http://localhost:4000/v2/model/info?include_team_models=true&page=1&size=50' \ --header 'Authorization: Bearer sk-1234' ``` Example response: ```json { "data": [ { "model_name": "gpt-4", "litellm_params": {"model": "openai/gpt-4.1"}, "model_info": { "id": "abc123", "litellm_provider": "openai", "access_via_team_ids": ["team-1"], "direct_access": true } } ], "total_count": 1, "current_page": 1, "total_pages": 1, "size": 50 } ``` */
+export declare const getModelInfoV2V2ModelInfo: API.OperationMethod<GetModelInfoV2V2ModelInfoRequest, GetModelInfoV2V2ModelInfoResponse, GetModelInfoV2V2ModelInfoError, LitellmOpContext>;
+export type GetModelMetricsExceptionsModelMetricsExceptionError = UnprocessableEntity | LitellmOpError;
+/** Model Metrics Exceptions View number of failed requests per model on config.yaml */
+export declare const getModelMetricsExceptionsModelMetricsException: API.OperationMethod<GetModelMetricsExceptionsModelMetricsExceptionRequest, GetModelMetricsExceptionsModelMetricsExceptionResponse, GetModelMetricsExceptionsModelMetricsExceptionError, LitellmOpContext>;
+export type GetModelMetricsModelMetricsError = UnprocessableEntity | LitellmOpError;
+/** Model Metrics View number of requests & avg latency per model on config.yaml */
+export declare const getModelMetricsModelMetrics: API.OperationMethod<GetModelMetricsModelMetricsRequest, GetModelMetricsModelMetricsResponse, GetModelMetricsModelMetricsError, LitellmOpContext>;
+export type GetModelMetricsSlowResponsesModelMetricsSlowResponseError = UnprocessableEntity | LitellmOpError;
+/** Model Metrics Slow Responses View number of hanging requests per model_group */
+export declare const getModelMetricsSlowResponsesModelMetricsSlowResponse: API.OperationMethod<GetModelMetricsSlowResponsesModelMetricsSlowResponseRequest, GetModelMetricsSlowResponsesModelMetricsSlowResponseResponse, GetModelMetricsSlowResponsesModelMetricsSlowResponseError, LitellmOpContext>;
+export type GetModelSettingsModelSettingsError = LitellmOpError;
+/** Model Settings Returns provider name, description, and required parameters for each provider */
+export declare const getModelSettingsModelSettings: API.OperationMethod<GetModelSettingsModelSettingsRequest, GetModelSettingsModelSettingsResponse, GetModelSettingsModelSettingsError, LitellmOpContext>;
+export type GetModelStreamingMetricsModelStreamingMetricsError = UnprocessableEntity | LitellmOpError;
+/** Model Streaming Metrics View time to first token for models in spend logs */
+export declare const getModelStreamingMetricsModelStreamingMetrics: API.OperationMethod<GetModelStreamingMetricsModelStreamingMetricsRequest, GetModelStreamingMetricsModelStreamingMetricsResponse, GetModelStreamingMetricsModelStreamingMetricsError, LitellmOpContext>;
+export type ListAccessGroupsAccessGroupListGetError = LitellmOpError;
+/** List Access Groups List all access groups. Returns a list of all access groups with their model names, deployment counts, shared budget and the spend drawn against it. Example: ```bash curl -X GET 'http://localhost:4000/access_group/list' \ -H 'Authorization: Bearer sk-1234' ``` Returns: - ListAccessGroupsResponse with all access groups */
+export declare const listAccessGroupsAccessGroupListGet: API.OperationMethod<ListAccessGroupsAccessGroupListGetRequest, ListAccessGroupsResponse, ListAccessGroupsAccessGroupListGetError, LitellmOpContext>;
+export type ModelListModelsGetError = BadRequest | UnprocessableEntity | LitellmOpError;
+/** Model List Use `/model/info` - to get detailed model information, example - pricing, mode, etc. This is just for compatibility with openai projects like aider. Query Parameters: - include_metadata: Include additional metadata in the response with fallback information - fallback_type: Type of fallbacks to include ("general", "context_window", "content_policy") Defaults to "general" when include_metadata=true - scope: Optional scope parameter. Currently only accepts "expand". When scope=expand is passed, proxy admins, team admins, and org admins will receive all proxy models as if they are a proxy admin. - healthy_only: When true, hide models whose backing deployments are all marked unhealthy by background health checks. Set `general_settings.model_list_healthy_only: true` to apply this to every caller without the query parameter. Requires `background_health_checks: true` in general_settings, plus either `model_list_healthy_only` or `enable_health_check_routing` to keep deployment health state cached; without health state the listing is returned unfiltered (fail open). Models expanded from wildcard routes (e.g. `openai/*`) are not filtered, and nothing is hidden when `allowed_fails_policy` is configured (cooldown remains the sole exclusion mechanism). Hiding is presentation-only: a hidden model can still be called directly. */
+export declare const modelListModelsGet: API.OperationMethod<ModelListModelsGetRequest, ModelListModelsGetResponse, ModelListModelsGetError, LitellmOpContext>;
+export type ModelListV1ModelsGetError = UnprocessableEntity | LitellmOpError;
+/** Model List Use `/model/info` - to get detailed model information, example - pricing, mode, etc. This is just for compatibility with openai projects like aider. Query Parameters: - include_metadata: Include additional metadata in the response with fallback information - fallback_type: Type of fallbacks to include ("general", "context_window", "content_policy") Defaults to "general" when include_metadata=true - scope: Optional scope parameter. Currently only accepts "expand". When scope=expand is passed, proxy admins, team admins, and org admins will receive all proxy models as if they are a proxy admin. - healthy_only: When true, hide models whose backing deployments are all marked unhealthy by background health checks. Set `general_settings.model_list_healthy_only: true` to apply this to every caller without the query parameter. Requires `background_health_checks: true` in general_settings, plus either `model_list_healthy_only` or `enable_health_check_routing` to keep deployment health state cached; without health state the listing is returned unfiltered (fail open). Models expanded from wildcard routes (e.g. `openai/*`) are not filtered, and nothing is hidden when `allowed_fails_policy` is configured (cooldown remains the sole exclusion mechanism). Hiding is presentation-only: a hidden model can still be called directly. */
+export declare const modelListV1ModelsGet: API.OperationMethod<ModelListV1ModelsGetRequest, ModelListV1ModelsGetResponse, ModelListV1ModelsGetError, LitellmOpContext>;
+export type PatchModelModelModelIdUpdatePatchError = UnprocessableEntity | LitellmOpError;
+/** Patch Model PATCH Endpoint for partial model updates. Only updates the fields specified in the request while preserving other existing values. Follows proper PATCH semantics by only modifying provided fields. Args: model_id: The ID of the model to update patch_data: The fields to update and their new values user_api_key_dict: User authentication information Returns: Updated model information Raises: ProxyException: For various error conditions including authentication and database errors */
+export declare const patchModelModelModelIdUpdatePatch: API.OperationMethod<PatchModelModelModelIdUpdatePatchRequest, PatchModelModelModelIdUpdatePatchResponse, PatchModelModelModelIdUpdatePatchError, LitellmOpContext>;
+export type PostBlockModelModelBlockError = UnprocessableEntity | LitellmOpError;
+/** Block Model Block a DB-stored model deployment from serving requests. Parameters: - model_id: str - The model deployment id to block. */
+export declare const postBlockModelModelBlock: API.OperationMethod<PostBlockModelModelBlockRequest, PostBlockModelModelBlockResponse, PostBlockModelModelBlockError, LitellmOpContext>;
+export type PostPreviewAutoRouterClassifierPromptAutoRouterClassifierDefaultPromptError = UnprocessableEntity | LitellmOpError;
+/** Preview Auto Router Classifier Prompt Get the system prompt an auto-router's LLM classifier sends for an edited tier set */
+export declare const postPreviewAutoRouterClassifierPromptAutoRouterClassifierDefaultPrompt: API.OperationMethod<PostPreviewAutoRouterClassifierPromptAutoRouterClassifierDefaultPromptRequest, AutoRouterClassifierDefaultPromptResponse, PostPreviewAutoRouterClassifierPromptAutoRouterClassifierDefaultPromptError, LitellmOpContext>;
+export type PostPreviewAutoRouterRoutingAutoRouterTestRoutingError = UnprocessableEntity | LitellmOpError;
+/** Preview Auto Router Routing Route a single request through a complexity-router config and report where it landed. Answers "which model would this request get?" for a config that only exists in a form, so an auto router can be checked before it is created. The request is classified by the same pre-routing hook a live request runs, over the same messages, system prompt and tool definitions, then dropped: nothing is sent to the model it routed to, and no auto router is created. A heuristic config therefore spends nothing, while an `llm` classifier or semantic keyword matching bills its classifier/embedding call to the calling key, like Test Connection does. Send `messages` to classify a real turn, with `system` and `tools` beside it when the surface carries them top level, as Anthropic /v1/messages does. `prompt` is the single-ask shorthand and routes as one user turn with nothing around it. **Example Request:** ```json { "messages": [ {"role": "system", "content": "You are a database migration assistant"}, {"role": "user", "content": "the index is not unique"}, {"role": "assistant", "content": "Then two workers can both insert. Add a unique index"}, {"role": "user", "content": "ok do it"} ], "tools": [{"type": "function", "function": {"name": "Bash", "description": "Run a command"}}], "complexity_router_config": { "tiers": {"SIMPLE": ["gpt-4o-mini"], "REASONING": ["o3"]}, "classifier_type": "heuristic" } } ``` */
+export declare const postPreviewAutoRouterRoutingAutoRouterTestRouting: API.OperationMethod<PostPreviewAutoRouterRoutingAutoRouterTestRoutingRequest, AutoRouterRoutingTestResponse, PostPreviewAutoRouterRoutingAutoRouterTestRoutingError, LitellmOpContext>;
+export type PostReloadAnthropicBetaHeadersReloadAnthropicBetaHeaderError = LitellmOpError;
+/** Reload Anthropic Beta Headers ADMIN ONLY / MASTER KEY Only Endpoint Manually reload the Anthropic beta headers configuration from the remote source. This will fetch fresh configuration from the anthropic_beta_headers_config.json file. */
+export declare const postReloadAnthropicBetaHeadersReloadAnthropicBetaHeader: API.OperationMethod<PostReloadAnthropicBetaHeadersReloadAnthropicBetaHeaderRequest, PostReloadAnthropicBetaHeadersReloadAnthropicBetaHeaderResponse, PostReloadAnthropicBetaHeadersReloadAnthropicBetaHeaderError, LitellmOpContext>;
+export type PostReloadModelCostMapReloadModelCostMapError = LitellmOpError;
+/** Reload Model Cost Map ADMIN ONLY / MASTER KEY Only Endpoint Manually reload the model cost map from the remote source. This will fetch fresh pricing data from the model_prices_and_context_window.json file. */
+export declare const postReloadModelCostMapReloadModelCostMap: API.OperationMethod<PostReloadModelCostMapReloadModelCostMapRequest, PostReloadModelCostMapReloadModelCostMapResponse, PostReloadModelCostMapReloadModelCostMapError, LitellmOpContext>;
+export type PostScheduleAnthropicBetaHeadersReloadScheduleAnthropicBetaHeadersReloadError = UnprocessableEntity | LitellmOpError;
+/** Schedule Anthropic Beta Headers Reload ADMIN ONLY / MASTER KEY Only Endpoint Schedule periodic reload of the Anthropic beta headers configuration. This will create a background job that reloads the configuration every specified hours. */
+export declare const postScheduleAnthropicBetaHeadersReloadScheduleAnthropicBetaHeadersReload: API.OperationMethod<PostScheduleAnthropicBetaHeadersReloadScheduleAnthropicBetaHeadersReloadRequest, PostScheduleAnthropicBetaHeadersReloadScheduleAnthropicBetaHeadersReloadResponse, PostScheduleAnthropicBetaHeadersReloadScheduleAnthropicBetaHeadersReloadError, LitellmOpContext>;
+export type PostScheduleModelCostMapReloadScheduleModelCostMapReloadError = UnprocessableEntity | LitellmOpError;
+/** Schedule Model Cost Map Reload ADMIN ONLY / MASTER KEY Only Endpoint Schedule periodic reload of the model cost map. This will create a background job that reloads the model cost map every specified hours. */
+export declare const postScheduleModelCostMapReloadScheduleModelCostMapReload: API.OperationMethod<PostScheduleModelCostMapReloadScheduleModelCostMapReloadRequest, PostScheduleModelCostMapReloadScheduleModelCostMapReloadResponse, PostScheduleModelCostMapReloadScheduleModelCostMapReloadError, LitellmOpContext>;
+export type PutSetAccessGroupBudgetAccessGroupAccessGroupBudgetError = UnprocessableEntity | LitellmOpError;
+/** Set Access Group Budget Set or replace the shared budget of an access group. Idempotent. Every key that can reach a model in the group draws from this one budget. Example: ```bash curl -X PUT 'http://localhost:4000/access_group/production-models/budget' \ -H 'Authorization: Bearer sk-1234' \ -H 'Content-Type: application/json' \ -d '{ "max_budget": 100.0, "budget_duration": "30d" }' ``` Parameters: - access_group: str - The access group name (URL path parameter) - max_budget: Optional[float] - Requests fail once the group's shared spend exceeds this - soft_budget: Optional[float] - Fires an alert when reached; requests still succeed - budget_duration: Optional[str] - Frequency of resetting the group's spend (e.g. '30d') - budget_id: Optional[str] - Link an existing budget instead of creating one Returns: - AccessGroupBudgetResponse with the stored budget and current spend Raises: - HTTPException 400: If no budget field is given, or budget_duration cannot be parsed - HTTPException 404: If access group not found */
+export declare const putSetAccessGroupBudgetAccessGroupAccessGroupBudget: API.OperationMethod<PutSetAccessGroupBudgetAccessGroupAccessGroupBudgetRequest, AccessGroupBudgetResponse, PutSetAccessGroupBudgetAccessGroupAccessGroupBudgetError, LitellmOpContext>;
+export type UnblockModelModelUnblockPostError = UnprocessableEntity | LitellmOpError;
+/** Unblock Model Unblock a DB-stored model deployment so it can serve requests again. Parameters: - model_id: str - The model deployment id to unblock. */
+export declare const unblockModelModelUnblockPost: API.OperationMethod<UnblockModelModelUnblockPostRequest, UnblockModelModelUnblockPostResponse, UnblockModelModelUnblockPostError, LitellmOpContext>;
+export type UpdateAccessGroupAccessGroupAccessGroupUpdatePutError = UnprocessableEntity | LitellmOpError;
+/** Update Access Group Update an access group's model names. This will: 1. Remove the access group from all current deployments 2. Add the access group to all deployments for the new model_names list Example: ```bash curl -X PUT 'http://localhost:4000/access_group/production-models/update' \ -H 'Authorization: Bearer sk-1234' \ -H 'Content-Type: application/json' \ -d '{ "model_names": ["gpt-4", "claude-3-sonnet"] }' ``` Parameters: - access_group: str - The access group name (URL path parameter) - model_names: List[str] - New list of model groups to include Returns: - NewModelGroupResponse with the updated access group details Raises: - HTTPException 400: If any model names don't exist - HTTPException 404: If access group not found */
+export declare const updateAccessGroupAccessGroupAccessGroupUpdatePut: API.OperationMethod<UpdateAccessGroupAccessGroupAccessGroupUpdatePutRequest, NewModelGroupResponse, UpdateAccessGroupAccessGroupAccessGroupUpdatePutError, LitellmOpContext>;
+export type UpdateModelModelUpdatePostError = BadRequest | UnprocessableEntity | LitellmOpError;
+/** Update Model Edit existing model params */
+export declare const updateModelModelUpdatePost: API.OperationMethod<UpdateModelModelUpdatePostRequest, UpdateModelModelUpdatePostResponse, UpdateModelModelUpdatePostError, LitellmOpContext>;
+export type UpdatePublicModelGroupsModelGroupMakePublicPostError = UnprocessableEntity | LitellmOpError;
+/** Update Public Model Groups Update which model groups are public */
+export declare const updatePublicModelGroupsModelGroupMakePublicPost: API.OperationMethod<UpdatePublicModelGroupsModelGroupMakePublicPostRequest, UpdatePublicModelGroupsModelGroupMakePublicPostResponse, UpdatePublicModelGroupsModelGroupMakePublicPostError, LitellmOpContext>;
+export type UpdateUsefulLinksModelHubUpdateUsefulLinksPostError = UnprocessableEntity | LitellmOpError;
+/** Update Useful Links Update useful links */
+export declare const updateUsefulLinksModelHubUpdateUsefulLinksPost: API.OperationMethod<UpdateUsefulLinksModelHubUpdateUsefulLinksPostRequest, UpdateUsefulLinksModelHubUpdateUsefulLinksPostResponse, UpdateUsefulLinksModelHubUpdateUsefulLinksPostError, LitellmOpContext>;
+export type ValidateComplexityRouterConfigAutoRouterValidateComplexityRouterConfigPostError = UnprocessableEntity | LitellmOpError;
+/** Validate Complexity Router Config Validate a complexity-router config without saving it. Runs the same check every write path runs (the router's own pydantic model), so a form can show the backend's exact verdict while the operator is still editing rather than after a rejected save. Gated exactly like the save it rehearses: a proxy admin, or a team admin naming their own team. Nothing is created, routed, or billed. */
+export declare const validateComplexityRouterConfigAutoRouterValidateComplexityRouterConfigPost: API.OperationMethod<ValidateComplexityRouterConfigAutoRouterValidateComplexityRouterConfigPostRequest, ComplexityRouterConfigValidationResponse, ValidateComplexityRouterConfigAutoRouterValidateComplexityRouterConfigPostError, LitellmOpContext>;
+//# sourceMappingURL=model_management.d.ts.map