@homeflare/distilled-litellm 0.2.0

package/dist/services/config_yaml.d.ts

@@ -0,0 +1,647 @@
+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 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 interface DeleteCallbackConfigCallbackDeletePostRequest {
+    callback_name: string;
+}
+export declare const DeleteCallbackConfigCallbackDeletePostRequest: S.Schema<DeleteCallbackConfigCallbackDeletePostRequest>;
+export interface DeleteCallbackConfigCallbackDeletePostResponse {
+    body: unknown;
+}
+export declare const DeleteCallbackConfigCallbackDeletePostResponse: S.Schema<DeleteCallbackConfigCallbackDeletePostResponse>;
+export interface DeleteConfigGeneralSettingsConfigFieldDeletePostRequest {
+    config_type: string;
+    field_name: string;
+}
+export declare const DeleteConfigGeneralSettingsConfigFieldDeletePostRequest: S.Schema<DeleteConfigGeneralSettingsConfigFieldDeletePostRequest>;
+export interface DeleteConfigGeneralSettingsConfigFieldDeletePostResponse {
+    body: unknown;
+}
+export declare const DeleteConfigGeneralSettingsConfigFieldDeletePostResponse: S.Schema<DeleteConfigGeneralSettingsConfigFieldDeletePostResponse>;
+export interface GetConfigGeneralSettingsConfigFieldInfoGetRequest {
+    field_name: string;
+}
+export declare const GetConfigGeneralSettingsConfigFieldInfoGetRequest: S.Schema<GetConfigGeneralSettingsConfigFieldInfoGetRequest>;
+export interface ConfigFieldInfo {
+    field_name: string;
+    field_value: unknown;
+}
+export declare const ConfigFieldInfo: S.Schema<ConfigFieldInfo>;
+export interface GetConfigGetConfigCallbacksGetRequest {
+}
+export declare const GetConfigGetConfigCallbacksGetRequest: S.Schema<GetConfigGetConfigCallbacksGetRequest>;
+export interface GetConfigGetConfigCallbacksGetResponse {
+    body: unknown;
+}
+export declare const GetConfigGetConfigCallbacksGetResponse: S.Schema<GetConfigGetConfigCallbacksGetResponse>;
+export interface GetConfigListConfigListGetRequest {
+    config_type: string;
+}
+export declare const GetConfigListConfigListGetRequest: S.Schema<GetConfigListConfigListGetRequest>;
+export type ConfigListFieldOptionsList = Array<string>;
+export declare const ConfigListFieldOptionsList: S.Schema<ConfigListFieldOptionsList>;
+export interface FieldDetail {
+    field_default_value?: unknown;
+    field_description: string;
+    field_name: string;
+    field_type: string;
+    stored_in_db: boolean | null;
+}
+export declare const FieldDetail: S.Schema<FieldDetail>;
+export type ConfigListNestedFieldsList = Array<FieldDetail>;
+export declare const ConfigListNestedFieldsList: S.Schema<ConfigListNestedFieldsList>;
+export interface ConfigList {
+    field_default_value: unknown;
+    field_description: string;
+    field_name: string;
+    field_options?: ConfigListFieldOptionsList | null;
+    field_tab?: string | null;
+    field_type: string;
+    field_value: unknown;
+    nested_fields?: ConfigListNestedFieldsList | null;
+    premium_field?: boolean;
+    stored_in_db: boolean | null;
+}
+export declare const ConfigList: S.Schema<ConfigList>;
+export type GetConfigListConfigListGetResponseBodyList = Array<ConfigList>;
+export declare const GetConfigListConfigListGetResponseBodyList: S.Schema<GetConfigListConfigListGetResponseBodyList>;
+export interface GetConfigListConfigListGetResponse {
+    body: GetConfigListConfigListGetResponseBodyList;
+}
+export declare const GetConfigListConfigListGetResponse: S.Schema<GetConfigListConfigListGetResponse>;
+export type GetConfigYamlEndpointConfigYamlRequestEnvironmentVariablesMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const GetConfigYamlEndpointConfigYamlRequestEnvironmentVariablesMap: S.Schema<GetConfigYamlEndpointConfigYamlRequestEnvironmentVariablesMap>;
+export type ConfigGeneralSettingsAlertToWebhookUrlMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const ConfigGeneralSettingsAlertToWebhookUrlMap: S.Schema<ConfigGeneralSettingsAlertToWebhookUrlMap>;
+/** Enum for alert types and management event types */
+export type AlertType = "llm_exceptions" | "llm_too_slow" | "llm_requests_hanging" | "budget_alerts" | "spend_reports" | "failed_tracking_spend" | "db_exceptions" | "daily_reports" | "cooldown_deployment" | "new_model_added" | "model_deprecation_warnings" | "outage_alerts" | "region_outage_alerts" | "fallback_reports" | "new_virtual_key_created" | "virtual_key_updated" | "virtual_key_deleted" | "new_team_created" | "team_updated" | "team_deleted" | "new_internal_user_created" | "internal_user_updated" | "internal_user_deleted";
+export declare const AlertType: any;
+export type ConfigGeneralSettingsAlertTypesList = Array<AlertType | (string & {})>;
+export declare const ConfigGeneralSettingsAlertTypesList: S.Schema<ConfigGeneralSettingsAlertTypesList>;
+export type ConfigGeneralSettingsAlertingList = Array<unknown>;
+export declare const ConfigGeneralSettingsAlertingList: S.Schema<ConfigGeneralSettingsAlertingList>;
+export type ConfigGeneralSettingsAlertingArgsMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const ConfigGeneralSettingsAlertingArgsMap: S.Schema<ConfigGeneralSettingsAlertingArgsMap>;
+export type ConfigGeneralSettingsAllowedRoutesList = Array<unknown>;
+export declare const ConfigGeneralSettingsAllowedRoutesList: S.Schema<ConfigGeneralSettingsAllowedRoutesList>;
+export type ConfigGeneralSettingsBackgroundHealthCheckModelGroupsList = Array<string>;
+export declare const ConfigGeneralSettingsBackgroundHealthCheckModelGroupsList: S.Schema<ConfigGeneralSettingsBackgroundHealthCheckModelGroupsList>;
+export type CoordinationRedisParamsSentinelNodesItemItem = string | number;
+export declare const CoordinationRedisParamsSentinelNodesItemItem: S.Schema<CoordinationRedisParamsSentinelNodesItemItem>;
+export type CoordinationRedisParamsSentinelNodesItemList = Array<CoordinationRedisParamsSentinelNodesItemItem>;
+export declare const CoordinationRedisParamsSentinelNodesItemList: S.Schema<CoordinationRedisParamsSentinelNodesItemList>;
+export type CoordinationRedisParamsSentinelNodesList = Array<CoordinationRedisParamsSentinelNodesItemList>;
+export declare const CoordinationRedisParamsSentinelNodesList: S.Schema<CoordinationRedisParamsSentinelNodesList>;
+/** A single startup node of a cluster-mode Redis used for proxy coordination. */
+export interface CoordinationRedisNode {
+    /** hostname of the cluster node */
+    host: string;
+    /** port of the cluster node */
+    port: number;
+}
+export declare const CoordinationRedisNode: S.Schema<CoordinationRedisNode>;
+export type CoordinationRedisParamsStartupNodesList = Array<CoordinationRedisNode>;
+export declare const CoordinationRedisParamsStartupNodesList: S.Schema<CoordinationRedisParamsStartupNodesList>;
+/** Connection params for the proxy's coordination Redis (cross-pod tpm/rpm rate limits, spend tracking, pod lock manager, shared health checks), configured independently of the response-cache backend in `litellm_settings.cache_params`. */
+export interface CoordinationRedisParams {
+    /** Redis hostname */
+    host?: string | null;
+    /** Redis password */
+    password?: string | null;
+    /** Redis port */
+    port?: number | null;
+    /** sentinel [host, port] pairs; when set a sentinel-managed client is used */
+    sentinel_nodes?: CoordinationRedisParamsSentinelNodesList | null;
+    /** password for the sentinel nodes */
+    sentinel_password?: string | null;
+    /** sentinel service name */
+    service_name?: string | null;
+    /** connect over TLS */
+    ssl?: boolean | null;
+    /** cluster-mode startup nodes; when set a cluster client is used */
+    startup_nodes?: CoordinationRedisParamsStartupNodesList | null;
+    /** full Redis connection url, e.g. redis://:pass@host:6379 */
+    url?: string | null;
+    /** Redis username */
+    username?: string | null;
+}
+export declare const CoordinationRedisParams: S.Schema<CoordinationRedisParams>;
+export type DynamoDBArgsAwsPolicyArnsList = Array<string>;
+export declare const DynamoDBArgsAwsPolicyArnsList: S.Schema<DynamoDBArgsAwsPolicyArnsList>;
+export type DynamoDBArgsBillingMode = "PROVISIONED_THROUGHPUT" | "PAY_PER_REQUEST";
+export declare const DynamoDBArgsBillingMode: any;
+export interface DynamoDBArgs {
+    assume_role_aws_role_name?: string | null;
+    assume_role_aws_session_name?: string | null;
+    aws_duration_seconds?: number | null;
+    aws_policy?: string | null;
+    aws_policy_arns?: DynamoDBArgsAwsPolicyArnsList | null;
+    aws_provider_id?: string | null;
+    aws_role_name?: string | null;
+    aws_session_name?: string | null;
+    aws_web_identity_token?: string | null;
+    billing_mode: DynamoDBArgsBillingMode | (string & {});
+    config_table_name?: string;
+    key_table_name?: string;
+    read_capacity_units?: number | null;
+    region_name: string;
+    spend_table_name?: string;
+    ssl_verify?: boolean | null;
+    user_table_name?: string;
+    write_capacity_units?: number | null;
+}
+export declare const DynamoDBArgs: S.Schema<DynamoDBArgs>;
+export type ConfigGeneralSettingsDatabaseExtraConnectionParamsMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const ConfigGeneralSettingsDatabaseExtraConnectionParamsMap: S.Schema<ConfigGeneralSettingsDatabaseExtraConnectionParamsMap>;
+export type KeyManagementSystem = "google_kms" | "azure_key_vault" | "aws_secret_manager" | "google_secret_manager" | "hashicorp_vault" | "cyberark" | "local" | "aws_kms" | "custom";
+export declare const KeyManagementSystem: any;
+export type ConfigGeneralSettingsMcpInternalIpRangesList = Array<string>;
+export declare const ConfigGeneralSettingsMcpInternalIpRangesList: S.Schema<ConfigGeneralSettingsMcpInternalIpRangesList>;
+export type ConfigGeneralSettingsMcpRequiredFieldsList = Array<string>;
+export declare const ConfigGeneralSettingsMcpRequiredFieldsList: S.Schema<ConfigGeneralSettingsMcpRequiredFieldsList>;
+export type ConfigGeneralSettingsMcpTrustedProxyRangesList = Array<string>;
+export declare const ConfigGeneralSettingsMcpTrustedProxyRangesList: S.Schema<ConfigGeneralSettingsMcpTrustedProxyRangesList>;
+/** Key-value pairs of default query parameters to be sent with every request to this endpoint. These can be overridden by client-provided query parameters. For example: {'key': 'default_value', 'api_version': '2023-01'} */
+export type PassThroughGenericEndpointDefaultQueryParamsMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const PassThroughGenericEndpointDefaultQueryParamsMap: S.Schema<PassThroughGenericEndpointDefaultQueryParamsMap>;
+export type PassThroughGuardrailSettingsRequestFieldsList = Array<string>;
+export declare const PassThroughGuardrailSettingsRequestFieldsList: S.Schema<PassThroughGuardrailSettingsRequestFieldsList>;
+export type PassThroughGuardrailSettingsResponseFieldsList = Array<string>;
+export declare const PassThroughGuardrailSettingsResponseFieldsList: S.Schema<PassThroughGuardrailSettingsResponseFieldsList>;
+/** Settings for a specific guardrail on a passthrough endpoint. Allows field-level targeting for guardrail execution. */
+export interface PassThroughGuardrailSettings {
+    /** JSONPath expressions for input field targeting (pre_call). Examples: 'query', 'documents[*].text', 'messages[*].content'. If not specified, guardrail runs on entire request payload. */
+    request_fields?: PassThroughGuardrailSettingsRequestFieldsList | null;
+    /** JSONPath expressions for output field targeting (post_call). Examples: 'results[*].text', 'output'. If not specified, guardrail runs on entire response payload. */
+    response_fields?: PassThroughGuardrailSettingsResponseFieldsList | null;
+}
+export declare const PassThroughGuardrailSettings: S.Schema<PassThroughGuardrailSettings>;
+export type PassThroughGenericEndpointGuardrailsMap = {
+    [key: string]: PassThroughGuardrailSettings | null | undefined;
+};
+export declare const PassThroughGenericEndpointGuardrailsMap: S.Schema<PassThroughGenericEndpointGuardrailsMap>;
+/** Key-value pairs of headers to be forwarded with the request. You can set any key value pair here and it will be forwarded to your target endpoint */
+export type PassThroughGenericEndpointHeadersMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const PassThroughGenericEndpointHeadersMap: S.Schema<PassThroughGenericEndpointHeadersMap>;
+export type PassThroughGenericEndpointMethodsList = Array<string>;
+export declare const PassThroughGenericEndpointMethodsList: S.Schema<PassThroughGenericEndpointMethodsList>;
+export interface PassThroughGenericEndpoint {
+    /** Whether authentication is required for the pass-through endpoint. Defaults to True so a pass-through silently created without an explicit value still requires a valid LiteLLM API key — set to False only if the endpoint is meant to be a public forwarder (e.g. an unauthenticated webhook target). */
+    auth?: boolean;
+    /** The USD cost per request to the target endpoint. This is used to calculate the cost of the request to the target endpoint. */
+    cost_per_request?: number;
+    /** Key-value pairs of default query parameters to be sent with every request to this endpoint. These can be overridden by client-provided query parameters. For example: {'key': 'default_value', 'api_version': '2023-01'} */
+    default_query_params?: PassThroughGenericEndpointDefaultQueryParamsMap;
+    /** Guardrails configuration for this passthrough endpoint. Dict keys are guardrail names, values are optional settings for field targeting. When set, all org/team/key level guardrails will also execute. Defaults to None (no guardrails execute). */
+    guardrails?: PassThroughGenericEndpointGuardrailsMap | null;
+    /** Key-value pairs of headers to be forwarded with the request. You can set any key value pair here and it will be forwarded to your target endpoint */
+    headers?: PassThroughGenericEndpointHeadersMap;
+    /** Optional unique identifier for the pass-through endpoint. If not provided, endpoints will be identified by path for backwards compatibility. */
+    id?: string | null;
+    /** If True, requests to subpaths of the path will be forwarded to the target endpoint. For example, if the path is /bria and include_subpath is True, requests to /bria/v1/text-to-image/base/2.3 will be forwarded to the target endpoint. */
+    include_subpath?: boolean;
+    /** True if this endpoint is defined in the config file, False if from DB. Config-defined endpoints cannot be edited via the UI. */
+    is_from_config?: boolean;
+    /** List of HTTP methods this endpoint handles (e.g., ['GET', 'POST']). If None or empty, all methods (GET, POST, PUT, DELETE, PATCH) are supported for backward compatibility. This allows the same path to have different targets for different HTTP methods. */
+    methods?: PassThroughGenericEndpointMethodsList | null;
+    /** The route to be added to the LiteLLM Proxy Server. */
+    path: string;
+    /** The URL to which requests for this path should be forwarded. */
+    target: string;
+    /** Upstream request timeout in seconds for this pass-through endpoint. If unset, uses general_settings.pass_through_request_timeout (default 600). */
+    timeout?: number | null;
+}
+export declare const PassThroughGenericEndpoint: S.Schema<PassThroughGenericEndpoint>;
+export type ConfigGeneralSettingsPassThroughEndpointsList = Array<PassThroughGenericEndpoint>;
+export declare const ConfigGeneralSettingsPassThroughEndpointsList: S.Schema<ConfigGeneralSettingsPassThroughEndpointsList>;
+/** A single external service registered as an embeddable UI plugin. */
+export interface PluginConfig {
+    /** human-readable label shown in the UI view switcher */
+    display_name?: string | null;
+    /** unique plugin identifier (kebab-case) */
+    name: string;
+    /** plugin's own credential, injected as Bearer auth only on /plugin-proxy/<name>/* reverse-proxy calls */
+    plugin_key?: string | null;
+    /** base URL of the plugin service */
+    url: string;
+}
+export declare const PluginConfig: S.Schema<PluginConfig>;
+export type ConfigGeneralSettingsPluginsList = Array<PluginConfig>;
+export declare const ConfigGeneralSettingsPluginsList: S.Schema<ConfigGeneralSettingsPluginsList>;
+export type ConfigGeneralSettingsProviderUrlDestinationAllowedHostsList = Array<string>;
+export declare const ConfigGeneralSettingsProviderUrlDestinationAllowedHostsList: S.Schema<ConfigGeneralSettingsProviderUrlDestinationAllowedHostsList>;
+/** explicit offset in seconds per scheduler job id, overriding the derived value. 0 pins a job to its unshifted schedule */
+export type ScheduledJobStaggerSettingsOffsetsMap = {
+    [key: string]: number | undefined;
+};
+export declare const ScheduledJobStaggerSettingsOffsetsMap: S.Schema<ScheduledJobStaggerSettingsOffsetsMap>;
+/** Spreads the proxy's scheduled background jobs across a window instead of firing them all on one instant, on every replica, forever. */
+export interface ScheduledJobStaggerSettings {
+    /** apply deterministic phase offsets to scheduled background jobs */
+    enabled?: boolean;
+    /** replaces the POD_NAME/HOSTNAME-derived component of the offset hash. Set this when replicas share a hostname and would otherwise land on the same offset */
+    identity?: string | null;
+    /** explicit offset in seconds per scheduler job id, overriding the derived value. 0 pins a job to its unshifted schedule */
+    offsets?: ScheduledJobStaggerSettingsOffsetsMap;
+    /** width of the window jobs are spread over. An interval job is never offset by more than one of its own periods, so it is not delayed past the wait it already has */
+    window_seconds?: number;
+}
+export declare const ScheduledJobStaggerSettings: S.Schema<ScheduledJobStaggerSettings>;
+/** Supported database object types for fine-grained DB storage control. Use in general_settings.supported_db_objects to specify which objects to load from DB. */
+export type SupportedDBObjectType = "models" | "mcp" | "guardrails" | "policies" | "vector_stores" | "pass_through_endpoints" | "prompts" | "model_cost_map" | "tools" | "config_overrides";
+export declare const SupportedDBObjectType: any;
+export type ConfigGeneralSettingsSupportedDbObjectsList = Array<SupportedDBObjectType | (string & {})>;
+export declare const ConfigGeneralSettingsSupportedDbObjectsList: S.Schema<ConfigGeneralSettingsSupportedDbObjectsList>;
+export type ConfigGeneralSettingsTrustedProxyRangesList = Array<string>;
+export declare const ConfigGeneralSettingsTrustedProxyRangesList: S.Schema<ConfigGeneralSettingsTrustedProxyRangesList>;
+export type ConfigGeneralSettingsUiAccessMode = "admin_only" | "all";
+export declare const ConfigGeneralSettingsUiAccessMode: any;
+export type UserHeaderMappingLitellmUserRole = "internal_user" | "customer";
+export declare const UserHeaderMappingLitellmUserRole: any;
+/** Map an incoming HTTP header to a LiteLLM user role. */
+export interface UserHeaderMapping {
+    header_name: string;
+    litellm_user_role: UserHeaderMappingLitellmUserRole | (string & {});
+}
+export declare const UserHeaderMapping: S.Schema<UserHeaderMapping>;
+export type ConfigGeneralSettingsUserHeaderMappingsList = Array<UserHeaderMapping>;
+export declare const ConfigGeneralSettingsUserHeaderMappingsList: S.Schema<ConfigGeneralSettingsUserHeaderMappingsList>;
+export type ConfigGeneralSettingsUserMcpManagementMode = "restricted" | "view_all";
+export declare const ConfigGeneralSettingsUserMcpManagementMode: any;
+export type ConfigGeneralSettingsUserUrlAllowedHostsList = Array<string>;
+export declare const ConfigGeneralSettingsUserUrlAllowedHostsList: S.Schema<ConfigGeneralSettingsUserUrlAllowedHostsList>;
+/** Documents all the fields supported by `general_settings` in config.yaml */
+export interface ConfigGeneralSettings {
+    /** Mapping of alert type to webhook url. e.g. `alert_to_webhook_url: {'budget_alerts': 'https://nothooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX'}` */
+    alert_to_webhook_url?: ConfigGeneralSettingsAlertToWebhookUrlMap | null;
+    /** List of alerting types. By default it is all alerts */
+    alert_types?: ConfigGeneralSettingsAlertTypesList | null;
+    /** List of alerting integrations. Today, just slack - `alerting: ['slack']` */
+    alerting?: ConfigGeneralSettingsAlertingList | null;
+    /** Controllable params for slack alerting - e.g. ttl in cache. */
+    alerting_args?: ConfigGeneralSettingsAlertingArgsMap | null;
+    /** sends alerts if requests hang for 5min+ */
+    alerting_threshold?: number | null;
+    /** opt-in to RFC 8628 verification_uri_complete for the CLI SSO device flow, pre-filling the user_code in the browser. Off by default; intended for same-host clients where the device that starts the flow and the browser run on the same machine */
+    allow_cli_sso_verification_uri_complete?: boolean | null;
+    /** Proxy API Endpoints you want users to be able to access */
+    allowed_routes?: ConfigGeneralSettingsAllowedRoutesList | null;
+    /** If True, a user's personal max_budget is enforced on every request they make, including requests made with a team-scoped key. Defaults to False, where a team-scoped key is governed only by the team and team-member budgets and the key owner's personal max_budget does not apply (see GitHub issue #12905). */
+    apply_user_budget_to_team_keys?: boolean | null;
+    /** Opt-in allowlist of model group names for background health checks and health-check routing. When set, the background loop probes only deployments whose model_name is listed, and enable_health_check_routing filters unhealthy deployments only within the listed groups; every other group, including newly added deployments, is skipped and keeps its configured routing strategy. When unset, all deployments participate (opt out per deployment via model_info.disable_background_health_check). */
+    background_health_check_model_groups?: ConfigGeneralSettingsBackgroundHealthCheckModelGroupsList | null;
+    /** run health checks in background */
+    background_health_checks?: boolean | null;
+    /** cancel the in-flight upstream LLM request (non-streaming) when the client disconnects, freeing backend capacity (e.g. a vLLM GPU slot); the request is logged as a 499 failure */
+    cancel_on_disconnect?: boolean | null;
+    /** proxy level default model for all chat completion calls */
+    completion_model?: string | null;
+    /** Global Control Plane: URL of the control plane whose admin UI manages this instance. Enables /v3/login and /v3/login/exchange on this instance so that UI can authenticate against it cross-origin, and restricts the SSO return_to origin to that URL. No state is shared with the control plane */
+    control_plane_url?: string | null;
+    /** standalone Redis for cross-pod coordination (tpm/rpm rate limits, spend tracking, pod lock manager, shared health checks), configured independently of the response-cache backend; takes precedence over borrowing the `cache_params` Redis and over the REDIS_* env fallback */
+    coordination_redis?: CoordinationRedisParams | null;
+    /** override user_api_key_auth with your own auth script - https://docs.litellm.ai/docs/proxy/virtual_keys#custom-auth */
+    custom_auth?: string | null;
+    /** custom args for instantiating dynamodb client - e.g. billing provision */
+    database_args?: DynamoDBArgs | null;
+    /** Prisma `connect_timeout` URL param (seconds). Bounds how long the engine waits to establish a new connection before failing. Defaults to Prisma's built-in value when unset. */
+    database_connect_timeout?: number | null;
+    /** default connection pool for prisma client connecting to postgres db */
+    database_connection_pool_limit?: number | null;
+    /** default timeout for a connection to the database */
+    database_connection_timeout?: number | null;
+    /** Disable server-side prepared statements by setting Prisma's `pgbouncer=true` URL param. Use this for pgbouncer transaction-pooling deployments, or to prevent the 'cached plan must not change result type' error that pooled connections hit during rolling schema migrations. An explicit `pgbouncer` in `database_extra_connection_params` takes precedence. */
+    database_disable_prepared_statements?: boolean | null;
+    /** Escape hatch: extra key/value pairs appended verbatim to the Prisma DATABASE_URL / DIRECT_URL query string (e.g. `sslmode`, `pgbouncer`, `statement_cache_size`). Keys here override any default LiteLLM sets. */
+    database_extra_connection_params?: ConfigGeneralSettingsDatabaseExtraConnectionParamsMap | null;
+    /** Prisma `socket_timeout` URL param (seconds). When set, an idle/slow connection that has not produced data within this window is closed. This is the main knob for capping idle DB connections from LiteLLM. */
+    database_socket_timeout?: number | null;
+    /** to use dynamodb instead of postgres db */
+    database_type?: string | null;
+    /** connect to a postgres db - needed for generating temporary keys + tracking spend / key */
+    database_url?: string | null;
+    /** By default, the user calling /team/new is automatically added to the new team as a team admin. If True, proxy admins are no longer auto-added; members explicitly listed in members_with_roles are unaffected. Default is False. */
+    disable_auto_add_proxy_admin_to_teams?: boolean | null;
+    /** If True, disables the optimistic per-request budget reservation introduced in v1.84.0. WARNING: This weakens hard budget enforcement. Without the reservation, a burst of concurrent requests from a single key can each pass the read-time spend check before any of them is charged, allowing a configured budget to be exceeded under high concurrency. Budgets are still evaluated on every request at read time, so an already-exhausted budget is still rejected. Enable only if your deployment is experiencing phantom BudgetExceededError responses caused by leaked reservations (see GitHub issue #27639). A proxy-level WARNING is logged on every request while this flag is active as a reminder that hard enforcement is relaxed. */
+    disable_budget_reservation?: boolean | null;
+    /** Public model hub for users to see what models they have access to, supported openai params, etc. */
+    enable_public_model_hub?: boolean;
+    /** If True, router fallbacks configured in router_settings are only attempted when the calling key (and its team and project) is allowed to call the fallback model; unauthorized fallback targets are skipped and the primary model's error is returned. Default is False. */
+    enforce_fallback_model_access?: boolean | null;
+    /** If True, forwards client headers (e.g. Authorization) to the LLM API. Required for Claude Code with Max subscription. */
+    forward_client_headers_to_llm_api?: boolean | null;
+    /** global max parallel requests to allow for a proxy instance. */
+    global_max_parallel_requests?: number | null;
+    /** limit concurrent health checks per cycle; when unset, health checks run without a concurrency cap */
+    health_check_concurrency?: number | null;
+    /** background health check interval in seconds */
+    health_check_interval?: number;
+    /** When true, deployments with model_info.disable_background_health_check are skipped for on-demand GET /health as well as the background health loop. */
+    health_check_skip_disabled_background_models?: boolean;
+    /** for `/models` endpoint, infers available model based on environment keys (e.g. OPENAI_API_KEY) */
+    infer_model_from_keys?: boolean | null;
+    /** key manager to load keys from / decrypt keys with */
+    key_management_system?: KeyManagementSystem | (string & {}) | null;
+    /** require a key for all calls to proxy */
+    master_key?: string | null;
+    /** max batch input file size in MB for /v1/files uploads with purpose=batch, if a file is larger than this size it will be rejected before being forwarded to the provider */
+    max_batch_file_size_mb?: number | null;
+    /** maximum parallel requests for each api key */
+    max_parallel_requests?: number | null;
+    /** max request size in MB, if a request is larger than this size it will be rejected */
+    max_request_size_mb?: number | null;
+    /** max response size in MB, if a response is larger than this size it will be rejected */
+    max_response_size_mb?: number | null;
+    /** Maximum retention period for auto-router benchmark session rollup rows (e.g., '365d'). Rows whose last turn is older than this are deleted by the spend log cleanup job, on that job's schedule. Unset means rollup rows are never deleted. */
+    maximum_autorouter_session_retention_period?: string | null;
+    /** Maximum retention period for health-check rows (e.g., '30d'). Rows whose checked_at is older than this are deleted by the spend log cleanup job, on that job's schedule. Unset means rows are never deleted. Set this well above health_check_interval because /health and the UI read the latest row per model. */
+    maximum_health_check_retention_period?: string | null;
+    /** Rows deleted per DELETE statement by the spend log cleanup job. Defaults to 1000. */
+    maximum_spend_logs_cleanup_batch_size?: number | null;
+    /** Postgres statement_timeout and lock_timeout applied to each spend log cleanup delete batch (e.g. '30s'), so cleanup cannot hold row locks or a connection indefinitely. Defaults to '30s'. */
+    maximum_spend_logs_cleanup_batch_timeout?: string | null;
+    /** Maximum DELETE statements the spend log cleanup job issues per table per run. Defaults to 500. */
+    maximum_spend_logs_cleanup_max_batches?: number | null;
+    /** Wall-clock budget for one spend log cleanup run (e.g. '5m'), shared across every table it prunes. A run that hits the budget stops and the next run resumes from where it left off. Defaults to '5m'. */
+    maximum_spend_logs_cleanup_run_budget?: string | null;
+    /** Maximum retention period for spend logs (e.g., '7d' for 7 days). Logs older than this will be deleted. */
+    maximum_spend_logs_retention_period?: string | null;
+    /** Custom CIDR ranges that define internal/private networks for MCP access control. When set, only these ranges are treated as internal. Defaults to RFC 1918 private ranges (10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16, 127.0.0.0/8). */
+    mcp_internal_ip_ranges?: ConfigGeneralSettingsMcpInternalIpRangesList | null;
+    /** List of MCP server fields that must be filled in for a submission to pass standards checks (e.g. ['description', 'source_url', 'alias']). */
+    mcp_required_fields?: ConfigGeneralSettingsMcpRequiredFieldsList | null;
+    /** CIDR ranges of trusted reverse proxies. When set, X-Forwarded-For and X-Forwarded-* origin headers are only trusted from these IPs. */
+    mcp_trusted_proxy_ranges?: ConfigGeneralSettingsMcpTrustedProxyRangesList | null;
+    /** Number of trusted reverse proxies/load balancers in front of the gateway that append to X-Forwarded-For. When set (and mcp_trusted_proxy_ranges validates the direct peer), the client IP for MCP access control is read this many entries from the right of the chain instead of the spoofable leftmost value, defeating append-style X-Forwarded-For forgery. */
+    mcp_xff_num_trusted_hops?: number | null;
+    /** When true, `/models`, `/v1/models/{id}` and `/model/info` hide models whose backing deployments are all unhealthy, for every caller, without needing `healthy_only=true` per request. Requires `background_health_checks: true`, and keeps deployment health state cached without turning on `enable_health_check_routing`, so routing is unaffected. With no health state nothing is hidden. Hiding is presentation-only, a hidden model can still be called. */
+    model_list_healthy_only?: boolean | null;
+    /** [BETA] OpenTelemetry support - this might change, use with caution. */
+    otel?: boolean | null;
+    /** Set-up pass-through endpoints for provider-specific endpoints. Docs - https://docs.litellm.ai/docs/proxy/pass_through */
+    pass_through_endpoints?: ConfigGeneralSettingsPassThroughEndpointsList | null;
+    /** Default upstream request timeout in seconds for native and custom pass-through endpoints that use pass_through_request. Defaults to 600 when unset. */
+    pass_through_request_timeout?: number | null;
+    /** external services registered as embeddable UI plugins */
+    plugins?: ConfigGeneralSettingsPluginsList | null;
+    /** Allowlist of hosts a request may redirect a provider call's destination URL to. */
+    provider_url_destination_allowed_hosts?: ConfigGeneralSettingsProviderUrlDestinationAllowedHostsList | null;
+    /** how often (in seconds) each pod reloads config-in-DB objects (models, credentials, guardrails, etc.) when store_model_in_db is enabled; lower values speed up multi-pod convergence at the cost of more DB load. Applied on proxy startup */
+    proxy_config_reload_interval_seconds?: number;
+    /** When set to True, rejects requests that contain client-side 'metadata.tags' to prevent users from influencing budgets by sending different tags. Tags can only be inherited from the API key metadata. */
+    reject_clientside_metadata_tags?: boolean | null;
+    /** Spreads the proxy's scheduled background jobs (spend flushes, budget resets, config reloads, exports) across a window instead of firing them together on every replica. On by default; set to tune the window, pin a job, or turn it off. */
+    scheduled_job_stagger?: ScheduledJobStaggerSettings | null;
+    /** If True, models and config are stored in and loaded from the database. Default is False. */
+    store_model_in_db?: boolean | null;
+    /** If True, stores request messages and responses in spend logs. Default is False. */
+    store_prompts_in_spend_logs?: boolean | null;
+    /** Fine-grained control over which object types to load from the database when store_model_in_db is True. Available types: 'models', 'mcp', 'guardrails', 'vector_stores', 'pass_through_endpoints', 'prompts', 'model_cost_map', 'tools', 'config_overrides'. If not set, all objects are loaded (default behavior). */
+    supported_db_objects?: ConfigGeneralSettingsSupportedDbObjectsList | null;
+    /** CIDR ranges of trusted reverse proxies allowed to provide identity headers for header-based auth paths such as enable_oauth2_proxy_auth and custom_ui_sso_sign_in_handler. */
+    trusted_proxy_ranges?: ConfigGeneralSettingsTrustedProxyRangesList | null;
+    /** Control access to the Proxy UI */
+    ui_access_mode?: ConfigGeneralSettingsUiAccessMode | (string & {}) | null;
+    /** load keys from azure key vault */
+    use_azure_key_vault?: boolean | null;
+    /** decrypt keys with google kms */
+    use_google_kms?: boolean | null;
+    /** If True and LiteLLM_SpendLogs has been converted to a range-partitioned table (db_scripts/partition_spend_logs.sql), retention cleanup drops expired partitions instead of deleting rows, and pre-creates upcoming partitions. Default is False. */
+    use_spend_logs_partitioning?: boolean | null;
+    user_header_mappings?: ConfigGeneralSettingsUserHeaderMappingsList | null;
+    /** [DEPRECATED] Use 'user_header_mappings' instead. When set, the header value is treated as the end user id unless overridden by user_header_mappings. */
+    user_header_name?: string | null;
+    /** Controls how non-admin users interact with MCP servers in the dashboard. 'restricted' shows only accessible servers, 'view_all' lists every server in read-only mode. */
+    user_mcp_management_mode?: ConfigGeneralSettingsUserMcpManagementMode | (string & {}) | null;
+    /** SSRF allowlist for user-supplied URLs. Entries are `hostname` or `hostname:port` (bracketed for IPv6, e.g. `[::1]:8080`). Allowlisted hosts skip the blocked-network check in validate_url() but still resolve DNS. Use this to permit legitimate internal targets, e.g. an internal OpenAPI/MCP server. */
+    user_url_allowed_hosts?: ConfigGeneralSettingsUserUrlAllowedHostsList | null;
+    /** Master switch for the SSRF guard applied to user-supplied URLs (image_url, file_url, MCP/OpenAPI spec URLs, etc). Defaults to True. Set to False to disable DNS/IP validation entirely (not recommended). */
+    user_url_validation?: boolean | null;
+}
+export declare const ConfigGeneralSettings: S.Schema<ConfigGeneralSettings>;
+export type GetConfigYamlEndpointConfigYamlRequestLitellmSettingsMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const GetConfigYamlEndpointConfigYamlRequestLitellmSettingsMap: S.Schema<GetConfigYamlEndpointConfigYamlRequestLitellmSettingsMap>;
+export type ModelParamsLitellmParamsMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const ModelParamsLitellmParamsMap: S.Schema<ModelParamsLitellmParamsMap>;
+export type LitellmProxyTypesModelInfoBaseModel = "gpt-4-1106-preview" | "gpt-4-32k" | "gpt-4" | "gpt-3.5-turbo-16k" | "gpt-3.5-turbo" | "text-embedding-ada-002";
+export declare const LitellmProxyTypesModelInfoBaseModel: any;
+export type LitellmProxyTypesModelInfoMode = "embedding" | "chat" | "completion";
+export declare const LitellmProxyTypesModelInfoMode: any;
+export interface LitellmProxyTypesModelInfo {
+    base_model: LitellmProxyTypesModelInfoBaseModel | (string & {}) | null;
+    id: string | null;
+    input_cost_per_token?: number | null;
+    max_tokens?: number | null;
+    mode: LitellmProxyTypesModelInfoMode | (string & {}) | null;
+    output_cost_per_token?: number | null;
+}
+export declare const LitellmProxyTypesModelInfo: S.Schema<LitellmProxyTypesModelInfo>;
+export interface ModelParams {
+    litellm_params: ModelParamsLitellmParamsMap;
+    model_info: LitellmProxyTypesModelInfo;
+    model_name: string;
+}
+export declare const ModelParams: S.Schema<ModelParams>;
+export type GetConfigYamlEndpointConfigYamlRequestModelListList = Array<ModelParams>;
+export declare const GetConfigYamlEndpointConfigYamlRequestModelListList: S.Schema<GetConfigYamlEndpointConfigYamlRequestModelListList>;
+export type UpdateRouterConfigContextWindowFallbacksItemMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const UpdateRouterConfigContextWindowFallbacksItemMap: S.Schema<UpdateRouterConfigContextWindowFallbacksItemMap>;
+export type UpdateRouterConfigContextWindowFallbacksList = Array<UpdateRouterConfigContextWindowFallbacksItemMap>;
+export declare const UpdateRouterConfigContextWindowFallbacksList: S.Schema<UpdateRouterConfigContextWindowFallbacksList>;
+export type UpdateRouterConfigFallbacksItemMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const UpdateRouterConfigFallbacksItemMap: S.Schema<UpdateRouterConfigFallbacksItemMap>;
+export type UpdateRouterConfigFallbacksList = Array<UpdateRouterConfigFallbacksItemMap>;
+export declare const UpdateRouterConfigFallbacksList: S.Schema<UpdateRouterConfigFallbacksList>;
+export type UpdateRouterConfigModelGroupAffinityConfigValueList = Array<string>;
+export declare const UpdateRouterConfigModelGroupAffinityConfigValueList: S.Schema<UpdateRouterConfigModelGroupAffinityConfigValueList>;
+export type UpdateRouterConfigModelGroupAffinityConfigMap = {
+    [key: string]: UpdateRouterConfigModelGroupAffinityConfigValueList | undefined;
+};
+export declare const UpdateRouterConfigModelGroupAffinityConfigMap: S.Schema<UpdateRouterConfigModelGroupAffinityConfigMap>;
+export type UpdateRouterConfigModelGroupAliasValueCase1Map = {
+    [key: string]: unknown | undefined;
+};
+export declare const UpdateRouterConfigModelGroupAliasValueCase1Map: S.Schema<UpdateRouterConfigModelGroupAliasValueCase1Map>;
+export type UpdateRouterConfigModelGroupAliasValue = string | UpdateRouterConfigModelGroupAliasValueCase1Map;
+export declare const UpdateRouterConfigModelGroupAliasValue: S.Schema<UpdateRouterConfigModelGroupAliasValue>;
+export type UpdateRouterConfigModelGroupAliasMap = {
+    [key: string]: UpdateRouterConfigModelGroupAliasValue | undefined;
+};
+export declare const UpdateRouterConfigModelGroupAliasMap: S.Schema<UpdateRouterConfigModelGroupAliasMap>;
+/** Use this to set a custom number of retries per exception type If RateLimitErrorRetries = 3, then 3 retries will be made for RateLimitError Mapping of Exception type to number of retries https://docs.litellm.ai/docs/exception_mapping */
+export interface RetryPolicy {
+    AuthenticationErrorRetries?: number | null;
+    BadRequestErrorRetries?: number | null;
+    ContentPolicyViolationErrorRetries?: number | null;
+    InternalServerErrorRetries?: number | null;
+    RateLimitErrorRetries?: number | null;
+    TimeoutErrorRetries?: number | null;
+}
+export declare const RetryPolicy: S.Schema<RetryPolicy>;
+export type UpdateRouterConfigModelGroupRetryPolicyMap = {
+    [key: string]: RetryPolicy | undefined;
+};
+export declare const UpdateRouterConfigModelGroupRetryPolicyMap: S.Schema<UpdateRouterConfigModelGroupRetryPolicyMap>;
+export type RoutingGroupModelsList = Array<string>;
+export declare const RoutingGroupModelsList: S.Schema<RoutingGroupModelsList>;
+export type RoutingGroupRoutingStrategyArgsMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const RoutingGroupRoutingStrategyArgsMap: S.Schema<RoutingGroupRoutingStrategyArgsMap>;
+/** A group of models that share a routing strategy. */
+export interface RoutingGroup {
+    group_name: string;
+    models: RoutingGroupModelsList;
+    routing_strategy: string;
+    routing_strategy_args?: RoutingGroupRoutingStrategyArgsMap | null;
+}
+export declare const RoutingGroup: S.Schema<RoutingGroup>;
+export type UpdateRouterConfigRoutingGroupsList = Array<RoutingGroup>;
+export declare const UpdateRouterConfigRoutingGroupsList: S.Schema<UpdateRouterConfigRoutingGroupsList>;
+export type UpdateRouterConfigRoutingStrategyArgsMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const UpdateRouterConfigRoutingStrategyArgsMap: S.Schema<UpdateRouterConfigRoutingStrategyArgsMap>;
+/** Set of params that you can modify via `router.update_settings()`. */
+export interface UpdateRouterConfig {
+    allowed_fails?: number | null;
+    context_window_fallbacks?: UpdateRouterConfigContextWindowFallbacksList | null;
+    cooldown_time?: number | null;
+    enable_tag_filtering?: boolean | null;
+    fallbacks?: UpdateRouterConfigFallbacksList | null;
+    max_retries?: number | null;
+    model_group_affinity_config?: UpdateRouterConfigModelGroupAffinityConfigMap | null;
+    model_group_alias?: UpdateRouterConfigModelGroupAliasMap | null;
+    model_group_retry_policy?: UpdateRouterConfigModelGroupRetryPolicyMap | null;
+    num_retries?: number | null;
+    retry_after?: number | null;
+    retry_policy?: RetryPolicy | null;
+    routing_groups?: UpdateRouterConfigRoutingGroupsList | null;
+    routing_strategy?: string | null;
+    routing_strategy_args?: UpdateRouterConfigRoutingStrategyArgsMap | null;
+    tag_routing_prefix?: string | null;
+    timeout?: number | null;
+}
+export declare const UpdateRouterConfig: S.Schema<UpdateRouterConfig>;
+export interface WorkerRegistryEntry {
+    name: string;
+    url: string;
+    worker_id: string;
+}
+export declare const WorkerRegistryEntry: S.Schema<WorkerRegistryEntry>;
+export type GetConfigYamlEndpointConfigYamlRequestWorkerRegistryList = Array<WorkerRegistryEntry>;
+export declare const GetConfigYamlEndpointConfigYamlRequestWorkerRegistryList: S.Schema<GetConfigYamlEndpointConfigYamlRequestWorkerRegistryList>;
+export interface GetConfigYamlEndpointConfigYamlRequest {
+    /** Object to pass in additional environment variables via POST request */
+    environment_variables?: GetConfigYamlEndpointConfigYamlRequestEnvironmentVariablesMap | null;
+    general_settings?: ConfigGeneralSettings | null;
+    /** litellm Module settings. See __init__.py for all, example litellm.drop_params=True, litellm.set_verbose=True, litellm.api_base, litellm.cache */
+    litellm_settings?: GetConfigYamlEndpointConfigYamlRequestLitellmSettingsMap | null;
+    /** List of supported models on the server, with model-specific configs */
+    model_list?: GetConfigYamlEndpointConfigYamlRequestModelListList | null;
+    /** litellm router object settings. See router.py __init__ for all, example router.num_retries=5, router.timeout=5, router.max_retries=5, router.retry_after=5 */
+    router_settings?: UpdateRouterConfig | null;
+    /** Global Control Plane: the independent proxy instances this instance's admin UI manages. Setting it makes this a control plane, which serves the UI and does not route LLM requests. Enterprise-only */
+    worker_registry?: GetConfigYamlEndpointConfigYamlRequestWorkerRegistryList | null;
+}
+export declare const GetConfigYamlEndpointConfigYamlRequest: S.Schema<GetConfigYamlEndpointConfigYamlRequest>;
+export interface GetConfigYamlEndpointConfigYamlResponse {
+    body: unknown;
+}
+export declare const GetConfigYamlEndpointConfigYamlResponse: S.Schema<GetConfigYamlEndpointConfigYamlResponse>;
+export type UpdateConfigConfigUpdatePostRequestEnvironmentVariablesMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const UpdateConfigConfigUpdatePostRequestEnvironmentVariablesMap: S.Schema<UpdateConfigConfigUpdatePostRequestEnvironmentVariablesMap>;
+export type UpdateConfigConfigUpdatePostRequestLitellmSettingsMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const UpdateConfigConfigUpdatePostRequestLitellmSettingsMap: S.Schema<UpdateConfigConfigUpdatePostRequestLitellmSettingsMap>;
+export type UpdateConfigConfigUpdatePostRequestModelListList = Array<ModelParams>;
+export declare const UpdateConfigConfigUpdatePostRequestModelListList: S.Schema<UpdateConfigConfigUpdatePostRequestModelListList>;
+export type UpdateConfigConfigUpdatePostRequestWorkerRegistryList = Array<WorkerRegistryEntry>;
+export declare const UpdateConfigConfigUpdatePostRequestWorkerRegistryList: S.Schema<UpdateConfigConfigUpdatePostRequestWorkerRegistryList>;
+export interface UpdateConfigConfigUpdatePostRequest {
+    /** Object to pass in additional environment variables via POST request */
+    environment_variables?: UpdateConfigConfigUpdatePostRequestEnvironmentVariablesMap | null;
+    general_settings?: ConfigGeneralSettings | null;
+    /** litellm Module settings. See __init__.py for all, example litellm.drop_params=True, litellm.set_verbose=True, litellm.api_base, litellm.cache */
+    litellm_settings?: UpdateConfigConfigUpdatePostRequestLitellmSettingsMap | null;
+    /** List of supported models on the server, with model-specific configs */
+    model_list?: UpdateConfigConfigUpdatePostRequestModelListList | null;
+    /** litellm router object settings. See router.py __init__ for all, example router.num_retries=5, router.timeout=5, router.max_retries=5, router.retry_after=5 */
+    router_settings?: UpdateRouterConfig | null;
+    /** Global Control Plane: the independent proxy instances this instance's admin UI manages. Setting it makes this a control plane, which serves the UI and does not route LLM requests. Enterprise-only */
+    worker_registry?: UpdateConfigConfigUpdatePostRequestWorkerRegistryList | null;
+}
+export declare const UpdateConfigConfigUpdatePostRequest: S.Schema<UpdateConfigConfigUpdatePostRequest>;
+export interface UpdateConfigConfigUpdatePostResponse {
+    body: unknown;
+}
+export declare const UpdateConfigConfigUpdatePostResponse: S.Schema<UpdateConfigConfigUpdatePostResponse>;
+export interface UpdateConfigGeneralSettingsConfigFieldUpdatePostRequest {
+    config_type: string;
+    field_name: string;
+    field_value: unknown;
+}
+export declare const UpdateConfigGeneralSettingsConfigFieldUpdatePostRequest: S.Schema<UpdateConfigGeneralSettingsConfigFieldUpdatePostRequest>;
+export interface UpdateConfigGeneralSettingsConfigFieldUpdatePostResponse {
+    body: unknown;
+}
+export declare const UpdateConfigGeneralSettingsConfigFieldUpdatePostResponse: S.Schema<UpdateConfigGeneralSettingsConfigFieldUpdatePostResponse>;
+export type DeleteCallbackConfigCallbackDeletePostError = UnprocessableEntity | LitellmOpError;
+/** Delete Callback Delete specific logging callback from configuration. */
+export declare const deleteCallbackConfigCallbackDeletePost: API.OperationMethod<DeleteCallbackConfigCallbackDeletePostRequest, DeleteCallbackConfigCallbackDeletePostResponse, DeleteCallbackConfigCallbackDeletePostError, LitellmOpContext>;
+export type DeleteConfigGeneralSettingsConfigFieldDeletePostError = UnprocessableEntity | LitellmOpError;
+/** Delete Config General Settings Delete the db value of this field in litellm general settings. Resets it to it's initial default value on litellm. */
+export declare const deleteConfigGeneralSettingsConfigFieldDeletePost: API.OperationMethod<DeleteConfigGeneralSettingsConfigFieldDeletePostRequest, DeleteConfigGeneralSettingsConfigFieldDeletePostResponse, DeleteConfigGeneralSettingsConfigFieldDeletePostError, LitellmOpContext>;
+export type GetConfigGeneralSettingsConfigFieldInfoGetError = UnprocessableEntity | LitellmOpError;
+/** Get Config General Settings */
+export declare const getConfigGeneralSettingsConfigFieldInfoGet: API.OperationMethod<GetConfigGeneralSettingsConfigFieldInfoGetRequest, ConfigFieldInfo, GetConfigGeneralSettingsConfigFieldInfoGetError, LitellmOpContext>;
+export type GetConfigGetConfigCallbacksGetError = LitellmOpError;
+/** Get Config For Admin UI - allows admin to view config via UI # return the callbacks and the env variables for the callback */
+export declare const getConfigGetConfigCallbacksGet: API.OperationMethod<GetConfigGetConfigCallbacksGetRequest, GetConfigGetConfigCallbacksGetResponse, GetConfigGetConfigCallbacksGetError, LitellmOpContext>;
+export type GetConfigListConfigListGetError = UnprocessableEntity | LitellmOpError;
+/** Get Config List List the available fields + current values for a given type of setting (currently just 'general_settings'user_api_key_dict: UserAPIKeyAuth = Depends(user_api_key_auth),) */
+export declare const getConfigListConfigListGet: API.OperationMethod<GetConfigListConfigListGetRequest, GetConfigListConfigListGetResponse, GetConfigListConfigListGetError, LitellmOpContext>;
+export type GetConfigYamlEndpointConfigYamlError = UnprocessableEntity | LitellmOpError;
+/** Config Yaml Endpoint This is a mock endpoint, to show what you can set in config.yaml details in the Swagger UI. Parameters: The config.yaml object has the following attributes: - **model_list**: *Optional[List[ModelParams]]* - A list of supported models on the server, along with model-specific configurations. ModelParams includes "model_name" (name of the model), "litellm_params" (litellm-specific parameters for the model), and "model_info" (additional info about the model such as id, mode, cost per token, etc). - **litellm_settings**: *Optional[dict]*: Settings for the litellm module. You can specify multiple properties like "drop_params", "set_verbose", "api_base", "cache". - **general_settings**: *Optional[ConfigGeneralSettings]*: General settings for the server like "completion_model" (default model for chat completion calls), "use_azure_key_vault" (option to load keys from azure key vault), "master_key" (key required for all calls to proxy), and others. Please, refer to each class's description for a better understanding of the specific attributes within them. Note: This is a mock endpoint primarily meant for demonstration purposes, and does not actually provide or change any configurations. */
+export declare const getConfigYamlEndpointConfigYaml: API.OperationMethod<GetConfigYamlEndpointConfigYamlRequest, GetConfigYamlEndpointConfigYamlResponse, GetConfigYamlEndpointConfigYamlError, LitellmOpContext>;
+export type UpdateConfigConfigUpdatePostError = UnprocessableEntity | LitellmOpError;
+/** Update Config For Admin UI - allows admin to update config via UI. Writes only the sections present in the request body to LiteLLM_Config rows (one row per top-level section). Sections the caller did not send are left untouched — this endpoint never persists pre-existing YAML values to DB as a side effect of an unrelated update. */
+export declare const updateConfigConfigUpdatePost: API.OperationMethod<UpdateConfigConfigUpdatePostRequest, UpdateConfigConfigUpdatePostResponse, UpdateConfigConfigUpdatePostError, LitellmOpContext>;
+export type UpdateConfigGeneralSettingsConfigFieldUpdatePostError = UnprocessableEntity | LitellmOpError;
+/** Update Config General Settings Update a specific field in litellm general settings */
+export declare const updateConfigGeneralSettingsConfigFieldUpdatePost: API.OperationMethod<UpdateConfigGeneralSettingsConfigFieldUpdatePostRequest, UpdateConfigGeneralSettingsConfigFieldUpdatePostResponse, UpdateConfigGeneralSettingsConfigFieldUpdatePostError, LitellmOpContext>;
+//# sourceMappingURL=config_yaml.d.ts.map