@homeflare/distilled-litellm 0.2.0

package/dist/services/misc.d.ts

@@ -0,0 +1,676 @@
+import * as S from "@distilled.cloud/core/schema";
+import * as Redacted from "effect/Redacted";
+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 NotFound_base: S.Class<NotFound, S.TaggedStruct<"NotFound", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
+export declare class NotFound extends /*@__PURE__*/ NotFound_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 {
+}
+/** 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 CreatePassThroughEndpointsConfigPassThroughEndpointPostRequestDefaultQueryParamsMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const CreatePassThroughEndpointsConfigPassThroughEndpointPostRequestDefaultQueryParamsMap: S.Schema<CreatePassThroughEndpointsConfigPassThroughEndpointPostRequestDefaultQueryParamsMap>;
+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 CreatePassThroughEndpointsConfigPassThroughEndpointPostRequestGuardrailsMap = {
+    [key: string]: PassThroughGuardrailSettings | null | undefined;
+};
+export declare const CreatePassThroughEndpointsConfigPassThroughEndpointPostRequestGuardrailsMap: S.Schema<CreatePassThroughEndpointsConfigPassThroughEndpointPostRequestGuardrailsMap>;
+/** 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 CreatePassThroughEndpointsConfigPassThroughEndpointPostRequestHeadersMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const CreatePassThroughEndpointsConfigPassThroughEndpointPostRequestHeadersMap: S.Schema<CreatePassThroughEndpointsConfigPassThroughEndpointPostRequestHeadersMap>;
+export type CreatePassThroughEndpointsConfigPassThroughEndpointPostRequestMethodsList = Array<string>;
+export declare const CreatePassThroughEndpointsConfigPassThroughEndpointPostRequestMethodsList: S.Schema<CreatePassThroughEndpointsConfigPassThroughEndpointPostRequestMethodsList>;
+export interface CreatePassThroughEndpointsConfigPassThroughEndpointPostRequest {
+    /** 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?: CreatePassThroughEndpointsConfigPassThroughEndpointPostRequestDefaultQueryParamsMap;
+    /** 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?: CreatePassThroughEndpointsConfigPassThroughEndpointPostRequestGuardrailsMap | 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?: CreatePassThroughEndpointsConfigPassThroughEndpointPostRequestHeadersMap;
+    /** 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?: CreatePassThroughEndpointsConfigPassThroughEndpointPostRequestMethodsList | 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 CreatePassThroughEndpointsConfigPassThroughEndpointPostRequest: S.Schema<CreatePassThroughEndpointsConfigPassThroughEndpointPostRequest>;
+export interface CreatePassThroughEndpointsConfigPassThroughEndpointPostResponse {
+    body: unknown;
+}
+export declare const CreatePassThroughEndpointsConfigPassThroughEndpointPostResponse: S.Schema<CreatePassThroughEndpointsConfigPassThroughEndpointPostResponse>;
+export interface DeleteAggregateMcpRouteMcpRequest {
+}
+export declare const DeleteAggregateMcpRouteMcpRequest: S.Schema<DeleteAggregateMcpRouteMcpRequest>;
+export interface DeleteAggregateMcpRouteMcpResponse {
+    body: unknown;
+}
+export declare const DeleteAggregateMcpRouteMcpResponse: S.Schema<DeleteAggregateMcpRouteMcpResponse>;
+export interface DeleteDynamicMcpRouteMcpServerNameMcpRequest {
+    mcp_server_name: string;
+}
+export declare const DeleteDynamicMcpRouteMcpServerNameMcpRequest: S.Schema<DeleteDynamicMcpRouteMcpServerNameMcpRequest>;
+export interface DeleteDynamicMcpRouteMcpServerNameMcpResponse {
+    body: unknown;
+}
+export declare const DeleteDynamicMcpRouteMcpServerNameMcpResponse: S.Schema<DeleteDynamicMcpRouteMcpServerNameMcpResponse>;
+export interface DeletePassThroughEndpointsConfigPassThroughEndpointDeleteRequest {
+    endpoint_id: string;
+}
+export declare const DeletePassThroughEndpointsConfigPassThroughEndpointDeleteRequest: S.Schema<DeletePassThroughEndpointsConfigPassThroughEndpointDeleteRequest>;
+/** 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 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 PassThroughEndpointResponseEndpointsList = Array<PassThroughGenericEndpoint>;
+export declare const PassThroughEndpointResponseEndpointsList: S.Schema<PassThroughEndpointResponseEndpointsList>;
+export interface PassThroughEndpointResponse {
+    endpoints: PassThroughEndpointResponseEndpointsList;
+}
+export declare const PassThroughEndpointResponse: S.Schema<PassThroughEndpointResponse>;
+export interface DeleteToolsetMcpRouteToolsetToolsetNameMcpRequest {
+    toolset_name: string;
+}
+export declare const DeleteToolsetMcpRouteToolsetToolsetNameMcpRequest: S.Schema<DeleteToolsetMcpRouteToolsetToolsetNameMcpRequest>;
+export interface DeleteToolsetMcpRouteToolsetToolsetNameMcpResponse {
+    body: unknown;
+}
+export declare const DeleteToolsetMcpRouteToolsetToolsetNameMcpResponse: S.Schema<DeleteToolsetMcpRouteToolsetToolsetNameMcpResponse>;
+export interface GetActiveTasksStatsDebugAsyncioTasksGetRequest {
+}
+export declare const GetActiveTasksStatsDebugAsyncioTasksGetRequest: S.Schema<GetActiveTasksStatsDebugAsyncioTasksGetRequest>;
+export interface GetActiveTasksStatsDebugAsyncioTasksGetResponse {
+    body: unknown;
+}
+export declare const GetActiveTasksStatsDebugAsyncioTasksGetResponse: S.Schema<GetActiveTasksStatsDebugAsyncioTasksGetResponse>;
+export interface GetAggregateMcpRouteMcpRequest {
+}
+export declare const GetAggregateMcpRouteMcpRequest: S.Schema<GetAggregateMcpRouteMcpRequest>;
+export interface GetAggregateMcpRouteMcpResponse {
+    body: unknown;
+}
+export declare const GetAggregateMcpRouteMcpResponse: S.Schema<GetAggregateMcpRouteMcpResponse>;
+export interface GetDynamicMcpRouteMcpServerNameMcpRequest {
+    mcp_server_name: string;
+}
+export declare const GetDynamicMcpRouteMcpServerNameMcpRequest: S.Schema<GetDynamicMcpRouteMcpServerNameMcpRequest>;
+export interface GetDynamicMcpRouteMcpServerNameMcpResponse {
+    body: unknown;
+}
+export declare const GetDynamicMcpRouteMcpServerNameMcpResponse: S.Schema<GetDynamicMcpRouteMcpServerNameMcpResponse>;
+export interface GetFaviconGetFaviconGetRequest {
+}
+export declare const GetFaviconGetFaviconGetRequest: S.Schema<GetFaviconGetFaviconGetRequest>;
+export interface GetFaviconGetFaviconGetResponse {
+    body: unknown;
+}
+export declare const GetFaviconGetFaviconGetResponse: S.Schema<GetFaviconGetFaviconGetResponse>;
+export interface GetHomeRequest {
+}
+export declare const GetHomeRequest: S.Schema<GetHomeRequest>;
+export interface GetHomeResponse {
+    body: unknown;
+}
+export declare const GetHomeResponse: S.Schema<GetHomeResponse>;
+export type GetImageGetImageGetRequestTheme = "light" | "dark";
+export declare const GetImageGetImageGetRequestTheme: any;
+export interface GetImageGetImageGetRequest {
+    theme?: GetImageGetImageGetRequestTheme | (string & {});
+}
+export declare const GetImageGetImageGetRequest: S.Schema<GetImageGetImageGetRequest>;
+export interface GetImageGetImageGetResponse {
+    body: unknown;
+}
+export declare const GetImageGetImageGetResponse: S.Schema<GetImageGetImageGetResponse>;
+export interface GetLogoUrlGetLogoUrlGetRequest {
+}
+export declare const GetLogoUrlGetLogoUrlGetRequest: S.Schema<GetLogoUrlGetLogoUrlGetRequest>;
+export interface GetLogoUrlGetLogoUrlGetResponse {
+    body: unknown;
+}
+export declare const GetLogoUrlGetLogoUrlGetResponse: S.Schema<GetLogoUrlGetLogoUrlGetResponse>;
+export interface GetMemoryDetailsDebugMemoryDetailsGetRequest {
+    /** Number of top object types to return */
+    top_n?: number;
+    /** Include process memory info */
+    include_process_info?: boolean;
+}
+export declare const GetMemoryDetailsDebugMemoryDetailsGetRequest: S.Schema<GetMemoryDetailsDebugMemoryDetailsGetRequest>;
+export type GetMemoryDetailsDebugMemoryDetailsGetResponseBodyMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const GetMemoryDetailsDebugMemoryDetailsGetResponseBodyMap: S.Schema<GetMemoryDetailsDebugMemoryDetailsGetResponseBodyMap>;
+export interface GetMemoryDetailsDebugMemoryDetailsGetResponse {
+    body: GetMemoryDetailsDebugMemoryDetailsGetResponseBodyMap;
+}
+export declare const GetMemoryDetailsDebugMemoryDetailsGetResponse: S.Schema<GetMemoryDetailsDebugMemoryDetailsGetResponse>;
+export interface GetMemorySummaryDebugMemorySummaryGetRequest {
+}
+export declare const GetMemorySummaryDebugMemorySummaryGetRequest: S.Schema<GetMemorySummaryDebugMemorySummaryGetRequest>;
+export type GetMemorySummaryDebugMemorySummaryGetResponseBodyMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const GetMemorySummaryDebugMemorySummaryGetResponseBodyMap: S.Schema<GetMemorySummaryDebugMemorySummaryGetResponseBodyMap>;
+export interface GetMemorySummaryDebugMemorySummaryGetResponse {
+    body: GetMemorySummaryDebugMemorySummaryGetResponseBodyMap;
+}
+export declare const GetMemorySummaryDebugMemorySummaryGetResponse: S.Schema<GetMemorySummaryDebugMemorySummaryGetResponse>;
+export interface GetMemoryUsageInMemCacheItemsMemoryUsageInMemCacheItemRequest {
+}
+export declare const GetMemoryUsageInMemCacheItemsMemoryUsageInMemCacheItemRequest: S.Schema<GetMemoryUsageInMemCacheItemsMemoryUsageInMemCacheItemRequest>;
+export interface GetMemoryUsageInMemCacheItemsMemoryUsageInMemCacheItemResponse {
+    body: unknown;
+}
+export declare const GetMemoryUsageInMemCacheItemsMemoryUsageInMemCacheItemResponse: S.Schema<GetMemoryUsageInMemCacheItemsMemoryUsageInMemCacheItemResponse>;
+export interface GetMemoryUsageInMemCacheMemoryUsageInMemCacheRequest {
+}
+export declare const GetMemoryUsageInMemCacheMemoryUsageInMemCacheRequest: S.Schema<GetMemoryUsageInMemCacheMemoryUsageInMemCacheRequest>;
+export interface GetMemoryUsageInMemCacheMemoryUsageInMemCacheResponse {
+    body: unknown;
+}
+export declare const GetMemoryUsageInMemCacheMemoryUsageInMemCacheResponse: S.Schema<GetMemoryUsageInMemCacheMemoryUsageInMemCacheResponse>;
+export interface GetOtelSpansOtelSpansGetRequest {
+}
+export declare const GetOtelSpansOtelSpansGetRequest: S.Schema<GetOtelSpansOtelSpansGetRequest>;
+export interface GetOtelSpansOtelSpansGetResponse {
+    body: unknown;
+}
+export declare const GetOtelSpansOtelSpansGetResponse: S.Schema<GetOtelSpansOtelSpansGetResponse>;
+export interface GetPassThroughEndpointsConfigPassThroughEndpointGetRequest {
+    endpoint_id?: string;
+    team_id?: string;
+}
+export declare const GetPassThroughEndpointsConfigPassThroughEndpointGetRequest: S.Schema<GetPassThroughEndpointsConfigPassThroughEndpointGetRequest>;
+export interface GetPassThroughEndpointsConfigPassThroughEndpointTeamTeamIdGetRequest {
+    team_id: string;
+    endpoint_id?: string;
+}
+export declare const GetPassThroughEndpointsConfigPassThroughEndpointTeamTeamIdGetRequest: S.Schema<GetPassThroughEndpointsConfigPassThroughEndpointTeamTeamIdGetRequest>;
+export interface GetProviderBudgetsProviderBudgetRequest {
+}
+export declare const GetProviderBudgetsProviderBudgetRequest: S.Schema<GetProviderBudgetsProviderBudgetRequest>;
+/** Configuration for a single provider's budget settings */
+export interface ProviderBudgetResponseObject {
+    budget_limit: number | null;
+    budget_reset_at?: string | null;
+    spend?: number | null;
+    time_period: string | null;
+}
+export declare const ProviderBudgetResponseObject: S.Schema<ProviderBudgetResponseObject>;
+export type ProviderBudgetResponseProvidersMap = {
+    [key: string]: ProviderBudgetResponseObject | undefined;
+};
+export declare const ProviderBudgetResponseProvidersMap: S.Schema<ProviderBudgetResponseProvidersMap>;
+/** Complete provider budget configuration and status. Maps provider names to their budget configs. */
+export interface ProviderBudgetResponse {
+    providers?: ProviderBudgetResponseProvidersMap;
+}
+export declare const ProviderBudgetResponse: S.Schema<ProviderBudgetResponse>;
+export interface GetRobotsRobotsTxtGetRequest {
+}
+export declare const GetRobotsRobotsTxtGetRequest: S.Schema<GetRobotsRobotsTxtGetRequest>;
+export interface GetRobotsRobotsTxtGetResponse {
+    body: unknown;
+}
+export declare const GetRobotsRobotsTxtGetResponse: S.Schema<GetRobotsRobotsTxtGetResponse>;
+export interface GetRoutesRoutesGetRequest {
+}
+export declare const GetRoutesRoutesGetRequest: S.Schema<GetRoutesRoutesGetRequest>;
+export interface GetRoutesRoutesGetResponse {
+    body: unknown;
+}
+export declare const GetRoutesRoutesGetResponse: S.Schema<GetRoutesRoutesGetResponse>;
+export interface GetToolsetMcpRouteToolsetToolsetNameMcpRequest {
+    toolset_name: string;
+}
+export declare const GetToolsetMcpRouteToolsetToolsetNameMcpRequest: S.Schema<GetToolsetMcpRouteToolsetToolsetNameMcpRequest>;
+export interface GetToolsetMcpRouteToolsetToolsetNameMcpResponse {
+    body: unknown;
+}
+export declare const GetToolsetMcpRouteToolsetToolsetNameMcpResponse: S.Schema<GetToolsetMcpRouteToolsetToolsetNameMcpResponse>;
+export interface GetUiConfigLitellmWellKnownLitellmUiConfigGetRequest {
+}
+export declare const GetUiConfigLitellmWellKnownLitellmUiConfigGetRequest: S.Schema<GetUiConfigLitellmWellKnownLitellmUiConfigGetRequest>;
+export interface WorkerRegistryEntry {
+    name: string;
+    url: string;
+    worker_id: string;
+}
+export declare const WorkerRegistryEntry: S.Schema<WorkerRegistryEntry>;
+export type UiDiscoveryEndpointsWorkersList = Array<WorkerRegistryEntry>;
+export declare const UiDiscoveryEndpointsWorkersList: S.Schema<UiDiscoveryEndpointsWorkersList>;
+export interface UiDiscoveryEndpoints {
+    admin_ui_disabled: boolean;
+    auto_redirect_to_sso: boolean;
+    hide_default_credentials_hint?: boolean;
+    is_control_plane?: boolean;
+    proxy_base_url: string | null;
+    server_root_path: string;
+    sso_configured: boolean;
+    workers?: UiDiscoveryEndpointsWorkersList;
+}
+export declare const UiDiscoveryEndpoints: S.Schema<UiDiscoveryEndpoints>;
+export interface GetUiConfigWellKnownLitellmUiConfigGetRequest {
+}
+export declare const GetUiConfigWellKnownLitellmUiConfigGetRequest: S.Schema<GetUiConfigWellKnownLitellmUiConfigGetRequest>;
+export interface ListAvailableTeamsTeamAvailableGetRequest {
+    response_model?: unknown;
+}
+export declare const ListAvailableTeamsTeamAvailableGetRequest: S.Schema<ListAvailableTeamsTeamAvailableGetRequest>;
+export interface ListAvailableTeamsTeamAvailableGetResponse {
+    body: unknown;
+}
+export declare const ListAvailableTeamsTeamAvailableGetResponse: S.Schema<ListAvailableTeamsTeamAvailableGetResponse>;
+export interface OnboardingOnboardingGetTokenGetRequest {
+    invite_link: string;
+}
+export declare const OnboardingOnboardingGetTokenGetRequest: S.Schema<OnboardingOnboardingGetTokenGetRequest>;
+export interface OnboardingOnboardingGetTokenGetResponse {
+    body: unknown;
+}
+export declare const OnboardingOnboardingGetTokenGetResponse: S.Schema<OnboardingOnboardingGetTokenGetResponse>;
+export interface PatchAggregateMcpRouteMcpRequest {
+}
+export declare const PatchAggregateMcpRouteMcpRequest: S.Schema<PatchAggregateMcpRouteMcpRequest>;
+export interface PatchAggregateMcpRouteMcpResponse {
+    body: unknown;
+}
+export declare const PatchAggregateMcpRouteMcpResponse: S.Schema<PatchAggregateMcpRouteMcpResponse>;
+export interface PatchDynamicMcpRouteMcpServerNameMcpRequest {
+    mcp_server_name: string;
+}
+export declare const PatchDynamicMcpRouteMcpServerNameMcpRequest: S.Schema<PatchDynamicMcpRouteMcpServerNameMcpRequest>;
+export interface PatchDynamicMcpRouteMcpServerNameMcpResponse {
+    body: unknown;
+}
+export declare const PatchDynamicMcpRouteMcpServerNameMcpResponse: S.Schema<PatchDynamicMcpRouteMcpServerNameMcpResponse>;
+export interface PatchToolsetMcpRouteToolsetToolsetNameMcpRequest {
+    toolset_name: string;
+}
+export declare const PatchToolsetMcpRouteToolsetToolsetNameMcpRequest: S.Schema<PatchToolsetMcpRouteToolsetToolsetNameMcpRequest>;
+export interface PatchToolsetMcpRouteToolsetToolsetNameMcpResponse {
+    body: unknown;
+}
+export declare const PatchToolsetMcpRouteToolsetToolsetNameMcpResponse: S.Schema<PatchToolsetMcpRouteToolsetToolsetNameMcpResponse>;
+export interface PostAggregateMcpRouteMcpRequest {
+}
+export declare const PostAggregateMcpRouteMcpRequest: S.Schema<PostAggregateMcpRouteMcpRequest>;
+export interface PostAggregateMcpRouteMcpResponse {
+    body: unknown;
+}
+export declare const PostAggregateMcpRouteMcpResponse: S.Schema<PostAggregateMcpRouteMcpResponse>;
+export interface PostClaimOnboardingLinkOnboardingClaimTokenRequest {
+    invitation_link: string;
+    password: string | Redacted.Redacted<string>;
+    user_id: string;
+}
+export declare const PostClaimOnboardingLinkOnboardingClaimTokenRequest: S.Schema<PostClaimOnboardingLinkOnboardingClaimTokenRequest>;
+export interface PostClaimOnboardingLinkOnboardingClaimTokenResponse {
+    body: unknown;
+}
+export declare const PostClaimOnboardingLinkOnboardingClaimTokenResponse: S.Schema<PostClaimOnboardingLinkOnboardingClaimTokenResponse>;
+export interface PostConfigureGcThresholdsEndpointDebugMemoryGcConfigureRequest {
+    /** Generation 0 threshold (default: 700) */
+    generation_0?: number;
+    /** Generation 1 threshold (default: 10) */
+    generation_1?: number;
+    /** Generation 2 threshold (default: 10) */
+    generation_2?: number;
+}
+export declare const PostConfigureGcThresholdsEndpointDebugMemoryGcConfigureRequest: S.Schema<PostConfigureGcThresholdsEndpointDebugMemoryGcConfigureRequest>;
+export type PostConfigureGcThresholdsEndpointDebugMemoryGcConfigureResponseBodyMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const PostConfigureGcThresholdsEndpointDebugMemoryGcConfigureResponseBodyMap: S.Schema<PostConfigureGcThresholdsEndpointDebugMemoryGcConfigureResponseBodyMap>;
+export interface PostConfigureGcThresholdsEndpointDebugMemoryGcConfigureResponse {
+    body: PostConfigureGcThresholdsEndpointDebugMemoryGcConfigureResponseBodyMap;
+}
+export declare const PostConfigureGcThresholdsEndpointDebugMemoryGcConfigureResponse: S.Schema<PostConfigureGcThresholdsEndpointDebugMemoryGcConfigureResponse>;
+export interface PostDynamicMcpRouteMcpServerNameMcpRequest {
+    mcp_server_name: string;
+}
+export declare const PostDynamicMcpRouteMcpServerNameMcpRequest: S.Schema<PostDynamicMcpRouteMcpServerNameMcpRequest>;
+export interface PostDynamicMcpRouteMcpServerNameMcpResponse {
+    body: unknown;
+}
+export declare const PostDynamicMcpRouteMcpServerNameMcpResponse: S.Schema<PostDynamicMcpRouteMcpServerNameMcpResponse>;
+export interface PostLoginLoginRequest {
+}
+export declare const PostLoginLoginRequest: S.Schema<PostLoginLoginRequest>;
+export interface PostLoginLoginResponse {
+    body: unknown;
+}
+export declare const PostLoginLoginResponse: S.Schema<PostLoginLoginResponse>;
+export interface PostLoginV2V2LoginRequest {
+}
+export declare const PostLoginV2V2LoginRequest: S.Schema<PostLoginV2V2LoginRequest>;
+export interface PostLoginV2V2LoginResponse {
+    body: unknown;
+}
+export declare const PostLoginV2V2LoginResponse: S.Schema<PostLoginV2V2LoginResponse>;
+export interface PostLoginV3ExchangeV3LoginExchangeRequest {
+}
+export declare const PostLoginV3ExchangeV3LoginExchangeRequest: S.Schema<PostLoginV3ExchangeV3LoginExchangeRequest>;
+export interface PostLoginV3ExchangeV3LoginExchangeResponse {
+    body: unknown;
+}
+export declare const PostLoginV3ExchangeV3LoginExchangeResponse: S.Schema<PostLoginV3ExchangeV3LoginExchangeResponse>;
+export interface PostLoginV3V3LoginRequest {
+}
+export declare const PostLoginV3V3LoginRequest: S.Schema<PostLoginV3V3LoginRequest>;
+export interface PostLoginV3V3LoginResponse {
+    body: unknown;
+}
+export declare const PostLoginV3V3LoginResponse: S.Schema<PostLoginV3V3LoginResponse>;
+export interface PostToolsetMcpRouteToolsetToolsetNameMcpRequest {
+    toolset_name: string;
+}
+export declare const PostToolsetMcpRouteToolsetToolsetNameMcpRequest: S.Schema<PostToolsetMcpRouteToolsetToolsetNameMcpRequest>;
+export interface PostToolsetMcpRouteToolsetToolsetNameMcpResponse {
+    body: unknown;
+}
+export declare const PostToolsetMcpRouteToolsetToolsetNameMcpResponse: S.Schema<PostToolsetMcpRouteToolsetToolsetNameMcpResponse>;
+export interface PostWarmLazyWarmNameRequest {
+    name: string;
+}
+export declare const PostWarmLazyWarmNameRequest: S.Schema<PostWarmLazyWarmNameRequest>;
+export interface PostWarmLazyWarmNameResponse {
+    body: unknown;
+}
+export declare const PostWarmLazyWarmNameResponse: S.Schema<PostWarmLazyWarmNameResponse>;
+export interface PutAggregateMcpRouteMcpRequest {
+}
+export declare const PutAggregateMcpRouteMcpRequest: S.Schema<PutAggregateMcpRouteMcpRequest>;
+export interface PutAggregateMcpRouteMcpResponse {
+    body: unknown;
+}
+export declare const PutAggregateMcpRouteMcpResponse: S.Schema<PutAggregateMcpRouteMcpResponse>;
+export interface PutDynamicMcpRouteMcpServerNameMcpRequest {
+    mcp_server_name: string;
+}
+export declare const PutDynamicMcpRouteMcpServerNameMcpRequest: S.Schema<PutDynamicMcpRouteMcpServerNameMcpRequest>;
+export interface PutDynamicMcpRouteMcpServerNameMcpResponse {
+    body: unknown;
+}
+export declare const PutDynamicMcpRouteMcpServerNameMcpResponse: S.Schema<PutDynamicMcpRouteMcpServerNameMcpResponse>;
+export interface PutToolsetMcpRouteToolsetToolsetNameMcpRequest {
+    toolset_name: string;
+}
+export declare const PutToolsetMcpRouteToolsetToolsetNameMcpRequest: S.Schema<PutToolsetMcpRouteToolsetToolsetNameMcpRequest>;
+export interface PutToolsetMcpRouteToolsetToolsetNameMcpResponse {
+    body: unknown;
+}
+export declare const PutToolsetMcpRouteToolsetToolsetNameMcpResponse: S.Schema<PutToolsetMcpRouteToolsetToolsetNameMcpResponse>;
+/** 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 UpdatePassThroughEndpointsConfigPassThroughEndpointEndpointIdPostRequestDefaultQueryParamsMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const UpdatePassThroughEndpointsConfigPassThroughEndpointEndpointIdPostRequestDefaultQueryParamsMap: S.Schema<UpdatePassThroughEndpointsConfigPassThroughEndpointEndpointIdPostRequestDefaultQueryParamsMap>;
+export type UpdatePassThroughEndpointsConfigPassThroughEndpointEndpointIdPostRequestGuardrailsMap = {
+    [key: string]: PassThroughGuardrailSettings | null | undefined;
+};
+export declare const UpdatePassThroughEndpointsConfigPassThroughEndpointEndpointIdPostRequestGuardrailsMap: S.Schema<UpdatePassThroughEndpointsConfigPassThroughEndpointEndpointIdPostRequestGuardrailsMap>;
+/** 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 UpdatePassThroughEndpointsConfigPassThroughEndpointEndpointIdPostRequestHeadersMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const UpdatePassThroughEndpointsConfigPassThroughEndpointEndpointIdPostRequestHeadersMap: S.Schema<UpdatePassThroughEndpointsConfigPassThroughEndpointEndpointIdPostRequestHeadersMap>;
+export type UpdatePassThroughEndpointsConfigPassThroughEndpointEndpointIdPostRequestMethodsList = Array<string>;
+export declare const UpdatePassThroughEndpointsConfigPassThroughEndpointEndpointIdPostRequestMethodsList: S.Schema<UpdatePassThroughEndpointsConfigPassThroughEndpointEndpointIdPostRequestMethodsList>;
+export interface UpdatePassThroughEndpointsConfigPassThroughEndpointEndpointIdPostRequest {
+    endpoint_id: string;
+    /** 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?: UpdatePassThroughEndpointsConfigPassThroughEndpointEndpointIdPostRequestDefaultQueryParamsMap;
+    /** 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?: UpdatePassThroughEndpointsConfigPassThroughEndpointEndpointIdPostRequestGuardrailsMap | 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?: UpdatePassThroughEndpointsConfigPassThroughEndpointEndpointIdPostRequestHeadersMap;
+    /** 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?: UpdatePassThroughEndpointsConfigPassThroughEndpointEndpointIdPostRequestMethodsList | 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 UpdatePassThroughEndpointsConfigPassThroughEndpointEndpointIdPostRequest: S.Schema<UpdatePassThroughEndpointsConfigPassThroughEndpointEndpointIdPostRequest>;
+export interface UpdatePassThroughEndpointsConfigPassThroughEndpointEndpointIdPostResponse {
+    body: unknown;
+}
+export declare const UpdatePassThroughEndpointsConfigPassThroughEndpointEndpointIdPostResponse: S.Schema<UpdatePassThroughEndpointsConfigPassThroughEndpointEndpointIdPostResponse>;
+export type CreatePassThroughEndpointsConfigPassThroughEndpointPostError = BadRequest | UnprocessableEntity | LitellmOpError;
+/** Create Pass Through Endpoints Create new pass-through endpoint */
+export declare const createPassThroughEndpointsConfigPassThroughEndpointPost: API.OperationMethod<CreatePassThroughEndpointsConfigPassThroughEndpointPostRequest, CreatePassThroughEndpointsConfigPassThroughEndpointPostResponse, CreatePassThroughEndpointsConfigPassThroughEndpointPostError, LitellmOpContext>;
+export type DeleteAggregateMcpRouteMcpError = LitellmOpError;
+/** Aggregate Mcp Route Serve the aggregate MCP endpoint on the bare ``/mcp`` spelling: the ``/mcp`` mount cannot match its bare prefix, and the resulting 307 breaks MCP clients behind TLS-terminating proxies. */
+export declare const deleteAggregateMcpRouteMcp: API.OperationMethod<DeleteAggregateMcpRouteMcpRequest, DeleteAggregateMcpRouteMcpResponse, DeleteAggregateMcpRouteMcpError, LitellmOpContext>;
+export type DeleteDynamicMcpRouteMcpServerNameMcpError = UnprocessableEntity | LitellmOpError;
+/** Dynamic Mcp Route Handle /{name}/mcp for MCP server aliases, toolsets, MCP access group tags, and comma-separated lists. Resolution order: 1. Registered MCP server alias / name 2. Comma-separated list (short-circuits before any DB call) 3. Toolset name (DB lookup, cached) 4. MCP access group tag (DB lookup, cached) */
+export declare const deleteDynamicMcpRouteMcpServerNameMcp: API.OperationMethod<DeleteDynamicMcpRouteMcpServerNameMcpRequest, DeleteDynamicMcpRouteMcpServerNameMcpResponse, DeleteDynamicMcpRouteMcpServerNameMcpError, LitellmOpContext>;
+export type DeletePassThroughEndpointsConfigPassThroughEndpointDeleteError = BadRequest | UnprocessableEntity | LitellmOpError;
+/** Delete Pass Through Endpoints Delete a pass-through endpoint by ID. Returns - the deleted endpoint */
+export declare const deletePassThroughEndpointsConfigPassThroughEndpointDelete: API.OperationMethod<DeletePassThroughEndpointsConfigPassThroughEndpointDeleteRequest, PassThroughEndpointResponse, DeletePassThroughEndpointsConfigPassThroughEndpointDeleteError, LitellmOpContext>;
+export type DeleteToolsetMcpRouteToolsetToolsetNameMcpError = UnprocessableEntity | LitellmOpError;
+/** Toolset Mcp Route Namespace a toolset as its own MCP endpoint. Connecting to /toolset/<name>/mcp exposes exactly the tools defined in the toolset. Access is enforced: non-admin API keys must have the toolset listed in their object_permission.mcp_toolsets grant list, or the request will be rejected with a 403. */
+export declare const deleteToolsetMcpRouteToolsetToolsetNameMcp: API.OperationMethod<DeleteToolsetMcpRouteToolsetToolsetNameMcpRequest, DeleteToolsetMcpRouteToolsetToolsetNameMcpResponse, DeleteToolsetMcpRouteToolsetToolsetNameMcpError, LitellmOpContext>;
+export type GetActiveTasksStatsDebugAsyncioTasksGetError = LitellmOpError;
+/** Get Active Tasks Stats Returns: total_active_tasks: int by_name: { coroutine_name: count } */
+export declare const getActiveTasksStatsDebugAsyncioTasksGet: API.OperationMethod<GetActiveTasksStatsDebugAsyncioTasksGetRequest, GetActiveTasksStatsDebugAsyncioTasksGetResponse, GetActiveTasksStatsDebugAsyncioTasksGetError, LitellmOpContext>;
+export type GetAggregateMcpRouteMcpError = LitellmOpError;
+/** Aggregate Mcp Route Serve the aggregate MCP endpoint on the bare ``/mcp`` spelling: the ``/mcp`` mount cannot match its bare prefix, and the resulting 307 breaks MCP clients behind TLS-terminating proxies. */
+export declare const getAggregateMcpRouteMcp: API.OperationMethod<GetAggregateMcpRouteMcpRequest, GetAggregateMcpRouteMcpResponse, GetAggregateMcpRouteMcpError, LitellmOpContext>;
+export type GetDynamicMcpRouteMcpServerNameMcpError = UnprocessableEntity | LitellmOpError;
+/** Dynamic Mcp Route Handle /{name}/mcp for MCP server aliases, toolsets, MCP access group tags, and comma-separated lists. Resolution order: 1. Registered MCP server alias / name 2. Comma-separated list (short-circuits before any DB call) 3. Toolset name (DB lookup, cached) 4. MCP access group tag (DB lookup, cached) */
+export declare const getDynamicMcpRouteMcpServerNameMcp: API.OperationMethod<GetDynamicMcpRouteMcpServerNameMcpRequest, GetDynamicMcpRouteMcpServerNameMcpResponse, GetDynamicMcpRouteMcpServerNameMcpError, LitellmOpContext>;
+export type GetFaviconGetFaviconGetError = LitellmOpError;
+/** Get Favicon Get custom favicon for the admin UI. */
+export declare const getFaviconGetFaviconGet: API.OperationMethod<GetFaviconGetFaviconGetRequest, GetFaviconGetFaviconGetResponse, GetFaviconGetFaviconGetError, LitellmOpContext>;
+export type GetHomeError = LitellmOpError;
+/** Home */
+export declare const getHome: API.OperationMethod<GetHomeRequest, GetHomeResponse, GetHomeError, LitellmOpContext>;
+export type GetImageGetImageGetError = UnprocessableEntity | LitellmOpError;
+/** Get Image Get logo to show on admin UI */
+export declare const getImageGetImageGet: API.OperationMethod<GetImageGetImageGetRequest, GetImageGetImageGetResponse, GetImageGetImageGetError, LitellmOpContext>;
+export type GetLogoUrlGetLogoUrlGetError = LitellmOpError;
+/** Get Logo Url Get the current logo URL from environment. Only HTTP(S) URLs are returned — those are intended to be loaded directly by the browser from a public/internal CDN. Local file paths set via ``UI_LOGO_PATH`` are NOT returned: they are admin- only filesystem details, the dashboard falls back to ``/get_image`` which serves the file only when it is a supported image. Without this filter, the unauthenticated endpoint would disclose internal hostnames or filesystem paths to any caller. */
+export declare const getLogoUrlGetLogoUrlGet: API.OperationMethod<GetLogoUrlGetLogoUrlGetRequest, GetLogoUrlGetLogoUrlGetResponse, GetLogoUrlGetLogoUrlGetError, LitellmOpContext>;
+export type GetMemoryDetailsDebugMemoryDetailsGetError = UnprocessableEntity | LitellmOpError;
+/** Get Memory Details Get detailed memory diagnostics for deep debugging. Returns: - worker_pid: Process ID - process_memory: RAM usage, virtual memory, file handles, threads - garbage_collector: GC thresholds, counts, collection history - objects: Total tracked objects and top object types - uncollectable: Objects that can't be garbage collected (potential leaks) - cache_memory: Memory usage of user_api_key, router, and logging caches - router_memory: Memory usage of router components (model_list, deployment_names, etc.) Query Parameters: - top_n: Number of top object types to return (default: 20) - include_process_info: Include process-level memory info using psutil (default: true) Example usage: curl "http://localhost:4000/debug/memory/details?top_n=30" -H "Authorization: Bearer sk-1234" All memory sizes are reported in both bytes and MB. */
+export declare const getMemoryDetailsDebugMemoryDetailsGet: API.OperationMethod<GetMemoryDetailsDebugMemoryDetailsGetRequest, GetMemoryDetailsDebugMemoryDetailsGetResponse, GetMemoryDetailsDebugMemoryDetailsGetError, LitellmOpContext>;
+export type GetMemorySummaryDebugMemorySummaryGetError = LitellmOpError;
+/** Get Memory Summary Get simplified memory usage summary for the proxy. Returns: - worker_pid: Process ID - status: Overall health based on memory usage - memory: Process memory usage and RAM info - caches: Cache item counts and descriptions - garbage_collector: GC status and pending object counts Example usage: curl http://localhost:4000/debug/memory/summary -H "Authorization: Bearer sk-1234" For detailed analysis, call GET /debug/memory/details For cache management, use the cache management endpoints */
+export declare const getMemorySummaryDebugMemorySummaryGet: API.OperationMethod<GetMemorySummaryDebugMemorySummaryGetRequest, GetMemorySummaryDebugMemorySummaryGetResponse, GetMemorySummaryDebugMemorySummaryGetError, LitellmOpContext>;
+export type GetMemoryUsageInMemCacheItemsMemoryUsageInMemCacheItemError = LitellmOpError;
+/** Memory Usage In Mem Cache Items 1. user_api_key_cache 2. router_cache 3. proxy_logging_cache 4. internal_usage_cache */
+export declare const getMemoryUsageInMemCacheItemsMemoryUsageInMemCacheItem: API.OperationMethod<GetMemoryUsageInMemCacheItemsMemoryUsageInMemCacheItemRequest, GetMemoryUsageInMemCacheItemsMemoryUsageInMemCacheItemResponse, GetMemoryUsageInMemCacheItemsMemoryUsageInMemCacheItemError, LitellmOpContext>;
+export type GetMemoryUsageInMemCacheMemoryUsageInMemCacheError = LitellmOpError;
+/** Memory Usage In Mem Cache 1. user_api_key_cache 2. router_cache 3. proxy_logging_cache 4. internal_usage_cache */
+export declare const getMemoryUsageInMemCacheMemoryUsageInMemCache: API.OperationMethod<GetMemoryUsageInMemCacheMemoryUsageInMemCacheRequest, GetMemoryUsageInMemCacheMemoryUsageInMemCacheResponse, GetMemoryUsageInMemCacheMemoryUsageInMemCacheError, LitellmOpContext>;
+export type GetOtelSpansOtelSpansGetError = LitellmOpError;
+/** Get Otel Spans */
+export declare const getOtelSpansOtelSpansGet: API.OperationMethod<GetOtelSpansOtelSpansGetRequest, GetOtelSpansOtelSpansGetResponse, GetOtelSpansOtelSpansGetError, LitellmOpContext>;
+export type GetPassThroughEndpointsConfigPassThroughEndpointGetError = UnprocessableEntity | LitellmOpError;
+/** Get Pass Through Endpoints GET configured pass through endpoint. If no endpoint_id given, return all configured endpoints. */
+export declare const getPassThroughEndpointsConfigPassThroughEndpointGet: API.OperationMethod<GetPassThroughEndpointsConfigPassThroughEndpointGetRequest, PassThroughEndpointResponse, GetPassThroughEndpointsConfigPassThroughEndpointGetError, LitellmOpContext>;
+export type GetPassThroughEndpointsConfigPassThroughEndpointTeamTeamIdGetError = UnprocessableEntity | LitellmOpError;
+/** Get Pass Through Endpoints GET configured pass through endpoint. If no endpoint_id given, return all configured endpoints. */
+export declare const getPassThroughEndpointsConfigPassThroughEndpointTeamTeamIdGet: API.OperationMethod<GetPassThroughEndpointsConfigPassThroughEndpointTeamTeamIdGetRequest, PassThroughEndpointResponse, GetPassThroughEndpointsConfigPassThroughEndpointTeamTeamIdGetError, LitellmOpContext>;
+export type GetProviderBudgetsProviderBudgetError = LitellmOpError;
+/** Provider Budgets Provider Budget Routing - Get Budget, Spend Details https://docs.litellm.ai/docs/proxy/provider_budget_routing Use this endpoint to check current budget, spend and budget reset time for a provider Example Request ```bash curl -X GET http://localhost:4000/provider/budgets -H "Content-Type: application/json" -H "Authorization: Bearer sk-1234" ``` Example Response ```json { "providers": { "openai": { "budget_limit": 1e-12, "time_period": "1d", "spend": 0.0, "budget_reset_at": null }, "azure": { "budget_limit": 100.0, "time_period": "1d", "spend": 0.0, "budget_reset_at": null }, "anthropic": { "budget_limit": 100.0, "time_period": "10d", "spend": 0.0, "budget_reset_at": null }, "vertex_ai": { "budget_limit": 100.0, "time_period": "12d", "spend": 0.0, "budget_reset_at": null } } } ``` */
+export declare const getProviderBudgetsProviderBudget: API.OperationMethod<GetProviderBudgetsProviderBudgetRequest, ProviderBudgetResponse, GetProviderBudgetsProviderBudgetError, LitellmOpContext>;
+export type GetRobotsRobotsTxtGetError = LitellmOpError;
+/** Get Robots Block all web crawlers from indexing the proxy server endpoints This is useful for ensuring that the API endpoints aren't indexed by search engines */
+export declare const getRobotsRobotsTxtGet: API.OperationMethod<GetRobotsRobotsTxtGetRequest, GetRobotsRobotsTxtGetResponse, GetRobotsRobotsTxtGetError, LitellmOpContext>;
+export type GetRoutesRoutesGetError = LitellmOpError;
+/** Get Routes Get a list of available routes in the FastAPI application. */
+export declare const getRoutesRoutesGet: API.OperationMethod<GetRoutesRoutesGetRequest, GetRoutesRoutesGetResponse, GetRoutesRoutesGetError, LitellmOpContext>;
+export type GetToolsetMcpRouteToolsetToolsetNameMcpError = UnprocessableEntity | LitellmOpError;
+/** Toolset Mcp Route Namespace a toolset as its own MCP endpoint. Connecting to /toolset/<name>/mcp exposes exactly the tools defined in the toolset. Access is enforced: non-admin API keys must have the toolset listed in their object_permission.mcp_toolsets grant list, or the request will be rejected with a 403. */
+export declare const getToolsetMcpRouteToolsetToolsetNameMcp: API.OperationMethod<GetToolsetMcpRouteToolsetToolsetNameMcpRequest, GetToolsetMcpRouteToolsetToolsetNameMcpResponse, GetToolsetMcpRouteToolsetToolsetNameMcpError, LitellmOpContext>;
+export type GetUiConfigLitellmWellKnownLitellmUiConfigGetError = LitellmOpError;
+/** Get Ui Config */
+export declare const getUiConfigLitellmWellKnownLitellmUiConfigGet: API.OperationMethod<GetUiConfigLitellmWellKnownLitellmUiConfigGetRequest, UiDiscoveryEndpoints, GetUiConfigLitellmWellKnownLitellmUiConfigGetError, LitellmOpContext>;
+export type GetUiConfigWellKnownLitellmUiConfigGetError = LitellmOpError;
+/** Get Ui Config */
+export declare const getUiConfigWellKnownLitellmUiConfigGet: API.OperationMethod<GetUiConfigWellKnownLitellmUiConfigGetRequest, UiDiscoveryEndpoints, GetUiConfigWellKnownLitellmUiConfigGetError, LitellmOpContext>;
+export type ListAvailableTeamsTeamAvailableGetError = UnprocessableEntity | LitellmOpError;
+/** List Available Teams */
+export declare const listAvailableTeamsTeamAvailableGet: API.OperationMethod<ListAvailableTeamsTeamAvailableGetRequest, ListAvailableTeamsTeamAvailableGetResponse, ListAvailableTeamsTeamAvailableGetError, LitellmOpContext>;
+export type OnboardingOnboardingGetTokenGetError = UnprocessableEntity | LitellmOpError;
+/** Onboarding - Get the invite link - Validate it's still 'valid' - Return a short-lived onboarding token - Get user from db - Pass in user_email if set */
+export declare const onboardingOnboardingGetTokenGet: API.OperationMethod<OnboardingOnboardingGetTokenGetRequest, OnboardingOnboardingGetTokenGetResponse, OnboardingOnboardingGetTokenGetError, LitellmOpContext>;
+export type PatchAggregateMcpRouteMcpError = LitellmOpError;
+/** Aggregate Mcp Route Serve the aggregate MCP endpoint on the bare ``/mcp`` spelling: the ``/mcp`` mount cannot match its bare prefix, and the resulting 307 breaks MCP clients behind TLS-terminating proxies. */
+export declare const patchAggregateMcpRouteMcp: API.OperationMethod<PatchAggregateMcpRouteMcpRequest, PatchAggregateMcpRouteMcpResponse, PatchAggregateMcpRouteMcpError, LitellmOpContext>;
+export type PatchDynamicMcpRouteMcpServerNameMcpError = UnprocessableEntity | LitellmOpError;
+/** Dynamic Mcp Route Handle /{name}/mcp for MCP server aliases, toolsets, MCP access group tags, and comma-separated lists. Resolution order: 1. Registered MCP server alias / name 2. Comma-separated list (short-circuits before any DB call) 3. Toolset name (DB lookup, cached) 4. MCP access group tag (DB lookup, cached) */
+export declare const patchDynamicMcpRouteMcpServerNameMcp: API.OperationMethod<PatchDynamicMcpRouteMcpServerNameMcpRequest, PatchDynamicMcpRouteMcpServerNameMcpResponse, PatchDynamicMcpRouteMcpServerNameMcpError, LitellmOpContext>;
+export type PatchToolsetMcpRouteToolsetToolsetNameMcpError = UnprocessableEntity | LitellmOpError;
+/** Toolset Mcp Route Namespace a toolset as its own MCP endpoint. Connecting to /toolset/<name>/mcp exposes exactly the tools defined in the toolset. Access is enforced: non-admin API keys must have the toolset listed in their object_permission.mcp_toolsets grant list, or the request will be rejected with a 403. */
+export declare const patchToolsetMcpRouteToolsetToolsetNameMcp: API.OperationMethod<PatchToolsetMcpRouteToolsetToolsetNameMcpRequest, PatchToolsetMcpRouteToolsetToolsetNameMcpResponse, PatchToolsetMcpRouteToolsetToolsetNameMcpError, LitellmOpContext>;
+export type PostAggregateMcpRouteMcpError = LitellmOpError;
+/** Aggregate Mcp Route Serve the aggregate MCP endpoint on the bare ``/mcp`` spelling: the ``/mcp`` mount cannot match its bare prefix, and the resulting 307 breaks MCP clients behind TLS-terminating proxies. */
+export declare const postAggregateMcpRouteMcp: API.OperationMethod<PostAggregateMcpRouteMcpRequest, PostAggregateMcpRouteMcpResponse, PostAggregateMcpRouteMcpError, LitellmOpContext>;
+export type PostClaimOnboardingLinkOnboardingClaimTokenError = UnprocessableEntity | LitellmOpError;
+/** Claim Onboarding Link Special route. Allows UI link share user to update their password. - Get the invite link - Validate it's still 'valid' - Check if user within initial session (prevents abuse) - Get user from db - Update user password This route can only update user password. */
+export declare const postClaimOnboardingLinkOnboardingClaimToken: API.OperationMethod<PostClaimOnboardingLinkOnboardingClaimTokenRequest, PostClaimOnboardingLinkOnboardingClaimTokenResponse, PostClaimOnboardingLinkOnboardingClaimTokenError, LitellmOpContext>;
+export type PostConfigureGcThresholdsEndpointDebugMemoryGcConfigureError = UnprocessableEntity | LitellmOpError;
+/** Configure Gc Thresholds Endpoint Configure Python garbage collection thresholds. Lower thresholds mean more frequent GC cycles (less memory, more CPU overhead). Higher thresholds mean less frequent GC cycles (more memory, less CPU overhead). Returns: - message: Confirmation message - previous_thresholds: Old threshold values - new_thresholds: New threshold values - objects_awaiting_collection: Current object count in gen-0 - tip: Hint about when next collection will occur Query Parameters: - generation_0: Number of allocations before gen-0 collection (default: 700) - generation_1: Number of gen-0 collections before gen-1 collection (default: 10) - generation_2: Number of gen-1 collections before gen-2 collection (default: 10) Example for more aggressive collection: curl -X POST "http://localhost:4000/debug/memory/gc/configure?generation_0=500" -H "Authorization: Bearer sk-1234" Example for less aggressive collection: curl -X POST "http://localhost:4000/debug/memory/gc/configure?generation_0=1000" -H "Authorization: Bearer sk-1234" Monitor memory usage with GET /debug/memory/summary after changes. */
+export declare const postConfigureGcThresholdsEndpointDebugMemoryGcConfigure: API.OperationMethod<PostConfigureGcThresholdsEndpointDebugMemoryGcConfigureRequest, PostConfigureGcThresholdsEndpointDebugMemoryGcConfigureResponse, PostConfigureGcThresholdsEndpointDebugMemoryGcConfigureError, LitellmOpContext>;
+export type PostDynamicMcpRouteMcpServerNameMcpError = UnprocessableEntity | LitellmOpError;
+/** Dynamic Mcp Route Handle /{name}/mcp for MCP server aliases, toolsets, MCP access group tags, and comma-separated lists. Resolution order: 1. Registered MCP server alias / name 2. Comma-separated list (short-circuits before any DB call) 3. Toolset name (DB lookup, cached) 4. MCP access group tag (DB lookup, cached) */
+export declare const postDynamicMcpRouteMcpServerNameMcp: API.OperationMethod<PostDynamicMcpRouteMcpServerNameMcpRequest, PostDynamicMcpRouteMcpServerNameMcpResponse, PostDynamicMcpRouteMcpServerNameMcpError, LitellmOpContext>;
+export type PostLoginLoginError = LitellmOpError;
+/** Login */
+export declare const postLoginLogin: API.OperationMethod<PostLoginLoginRequest, PostLoginLoginResponse, PostLoginLoginError, LitellmOpContext>;
+export type PostLoginV2V2LoginError = LitellmOpError;
+/** Login V2 */
+export declare const postLoginV2V2Login: API.OperationMethod<PostLoginV2V2LoginRequest, PostLoginV2V2LoginResponse, PostLoginV2V2LoginError, LitellmOpContext>;
+export type PostLoginV3ExchangeV3LoginExchangeError = LitellmOpError;
+/** Login V3 Exchange */
+export declare const postLoginV3ExchangeV3LoginExchange: API.OperationMethod<PostLoginV3ExchangeV3LoginExchangeRequest, PostLoginV3ExchangeV3LoginExchangeResponse, PostLoginV3ExchangeV3LoginExchangeError, LitellmOpContext>;
+export type PostLoginV3V3LoginError = LitellmOpError;
+/** Login V3 */
+export declare const postLoginV3V3Login: API.OperationMethod<PostLoginV3V3LoginRequest, PostLoginV3V3LoginResponse, PostLoginV3V3LoginError, LitellmOpContext>;
+export type PostToolsetMcpRouteToolsetToolsetNameMcpError = UnprocessableEntity | LitellmOpError;
+/** Toolset Mcp Route Namespace a toolset as its own MCP endpoint. Connecting to /toolset/<name>/mcp exposes exactly the tools defined in the toolset. Access is enforced: non-admin API keys must have the toolset listed in their object_permission.mcp_toolsets grant list, or the request will be rejected with a 403. */
+export declare const postToolsetMcpRouteToolsetToolsetNameMcp: API.OperationMethod<PostToolsetMcpRouteToolsetToolsetNameMcpRequest, PostToolsetMcpRouteToolsetToolsetNameMcpResponse, PostToolsetMcpRouteToolsetToolsetNameMcpError, LitellmOpContext>;
+export type PostWarmLazyWarmNameError = UnprocessableEntity | LitellmOpError;
+/** Warm */
+export declare const postWarmLazyWarmName: API.OperationMethod<PostWarmLazyWarmNameRequest, PostWarmLazyWarmNameResponse, PostWarmLazyWarmNameError, LitellmOpContext>;
+export type PutAggregateMcpRouteMcpError = LitellmOpError;
+/** Aggregate Mcp Route Serve the aggregate MCP endpoint on the bare ``/mcp`` spelling: the ``/mcp`` mount cannot match its bare prefix, and the resulting 307 breaks MCP clients behind TLS-terminating proxies. */
+export declare const putAggregateMcpRouteMcp: API.OperationMethod<PutAggregateMcpRouteMcpRequest, PutAggregateMcpRouteMcpResponse, PutAggregateMcpRouteMcpError, LitellmOpContext>;
+export type PutDynamicMcpRouteMcpServerNameMcpError = UnprocessableEntity | LitellmOpError;
+/** Dynamic Mcp Route Handle /{name}/mcp for MCP server aliases, toolsets, MCP access group tags, and comma-separated lists. Resolution order: 1. Registered MCP server alias / name 2. Comma-separated list (short-circuits before any DB call) 3. Toolset name (DB lookup, cached) 4. MCP access group tag (DB lookup, cached) */
+export declare const putDynamicMcpRouteMcpServerNameMcp: API.OperationMethod<PutDynamicMcpRouteMcpServerNameMcpRequest, PutDynamicMcpRouteMcpServerNameMcpResponse, PutDynamicMcpRouteMcpServerNameMcpError, LitellmOpContext>;
+export type PutToolsetMcpRouteToolsetToolsetNameMcpError = UnprocessableEntity | LitellmOpError;
+/** Toolset Mcp Route Namespace a toolset as its own MCP endpoint. Connecting to /toolset/<name>/mcp exposes exactly the tools defined in the toolset. Access is enforced: non-admin API keys must have the toolset listed in their object_permission.mcp_toolsets grant list, or the request will be rejected with a 403. */
+export declare const putToolsetMcpRouteToolsetToolsetNameMcp: API.OperationMethod<PutToolsetMcpRouteToolsetToolsetNameMcpRequest, PutToolsetMcpRouteToolsetToolsetNameMcpResponse, PutToolsetMcpRouteToolsetToolsetNameMcpError, LitellmOpContext>;
+export type UpdatePassThroughEndpointsConfigPassThroughEndpointEndpointIdPostError = BadRequest | NotFound | UnprocessableEntity | LitellmOpError;
+/** Update Pass Through Endpoints Update a pass-through endpoint by ID. */
+export declare const updatePassThroughEndpointsConfigPassThroughEndpointEndpointIdPost: API.OperationMethod<UpdatePassThroughEndpointsConfigPassThroughEndpointEndpointIdPostRequest, UpdatePassThroughEndpointsConfigPassThroughEndpointEndpointIdPostResponse, UpdatePassThroughEndpointsConfigPassThroughEndpointEndpointIdPostError, LitellmOpContext>;
+//# sourceMappingURL=misc.d.ts.map