@homeflare/distilled-litellm 0.2.0 → 0.3.0

package/dist/services/llm_passthrough.d.ts

@@ -0,0 +1,1199 @@
+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 CreateRealtimeClientSecretOpenaiV1RealtimeClientSecretsPostRequest {
+}
+export declare const CreateRealtimeClientSecretOpenaiV1RealtimeClientSecretsPostRequest: S.Schema<CreateRealtimeClientSecretOpenaiV1RealtimeClientSecretsPostRequest>;
+export type RealtimeClientSecretResponseSessionMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const RealtimeClientSecretResponseSessionMap: S.Schema<RealtimeClientSecretResponseSessionMap>;
+/** Response from POST /v1/realtime/client_secrets. Both the top-level `value` and `session.client_secret.value` will contain the encrypted token instead of the raw ephemeral key. The `session` field is kept as a raw dict so unknown fields pass through. */
+export interface RealtimeClientSecretResponse {
+    expires_at?: number | null;
+    session?: RealtimeClientSecretResponseSessionMap | null;
+    value: string;
+}
+export declare const RealtimeClientSecretResponse: S.Schema<RealtimeClientSecretResponse>;
+export interface CreateRealtimeTranscriptionSessionOpenaiV1RealtimeTranscriptionSessionsPostRequest {
+}
+export declare const CreateRealtimeTranscriptionSessionOpenaiV1RealtimeTranscriptionSessionsPostRequest: S.Schema<CreateRealtimeTranscriptionSessionOpenaiV1RealtimeTranscriptionSessionsPostRequest>;
+export type RealtimeTranscriptionSessionResponseClientSecretMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const RealtimeTranscriptionSessionResponseClientSecretMap: S.Schema<RealtimeTranscriptionSessionResponseClientSecretMap>;
+/** Response from POST /v1/realtime/transcription_sessions. `client_secret.value` contains the encrypted token instead of the raw ephemeral key. Unknown fields pass through unchanged. */
+export interface RealtimeTranscriptionSessionResponse {
+    client_secret?: RealtimeTranscriptionSessionResponseClientSecretMap | null;
+}
+export declare const RealtimeTranscriptionSessionResponse: S.Schema<RealtimeTranscriptionSessionResponse>;
+export interface DeleteAnthropicProxyRouteAnthropicEndpointRequest {
+    endpoint: string;
+}
+export declare const DeleteAnthropicProxyRouteAnthropicEndpointRequest: S.Schema<DeleteAnthropicProxyRouteAnthropicEndpointRequest>;
+export interface DeleteAnthropicProxyRouteAnthropicEndpointResponse {
+    body: unknown;
+}
+export declare const DeleteAnthropicProxyRouteAnthropicEndpointResponse: S.Schema<DeleteAnthropicProxyRouteAnthropicEndpointResponse>;
+export interface DeleteAssemblyaiProxyRouteAssemblyaiEndpointRequest {
+    endpoint: string;
+}
+export declare const DeleteAssemblyaiProxyRouteAssemblyaiEndpointRequest: S.Schema<DeleteAssemblyaiProxyRouteAssemblyaiEndpointRequest>;
+export interface DeleteAssemblyaiProxyRouteAssemblyaiEndpointResponse {
+    body: unknown;
+}
+export declare const DeleteAssemblyaiProxyRouteAssemblyaiEndpointResponse: S.Schema<DeleteAssemblyaiProxyRouteAssemblyaiEndpointResponse>;
+export interface DeleteAssemblyaiProxyRouteEuAssemblyaiEndpointRequest {
+    endpoint: string;
+}
+export declare const DeleteAssemblyaiProxyRouteEuAssemblyaiEndpointRequest: S.Schema<DeleteAssemblyaiProxyRouteEuAssemblyaiEndpointRequest>;
+export interface DeleteAssemblyaiProxyRouteEuAssemblyaiEndpointResponse {
+    body: unknown;
+}
+export declare const DeleteAssemblyaiProxyRouteEuAssemblyaiEndpointResponse: S.Schema<DeleteAssemblyaiProxyRouteEuAssemblyaiEndpointResponse>;
+export interface DeleteAzureProxyRouteAzureAiEndpointRequest {
+    endpoint: string;
+}
+export declare const DeleteAzureProxyRouteAzureAiEndpointRequest: S.Schema<DeleteAzureProxyRouteAzureAiEndpointRequest>;
+export interface DeleteAzureProxyRouteAzureAiEndpointResponse {
+    body: unknown;
+}
+export declare const DeleteAzureProxyRouteAzureAiEndpointResponse: S.Schema<DeleteAzureProxyRouteAzureAiEndpointResponse>;
+export interface DeleteAzureProxyRouteAzureEndpointRequest {
+    endpoint: string;
+}
+export declare const DeleteAzureProxyRouteAzureEndpointRequest: S.Schema<DeleteAzureProxyRouteAzureEndpointRequest>;
+export interface DeleteAzureProxyRouteAzureEndpointResponse {
+    body: unknown;
+}
+export declare const DeleteAzureProxyRouteAzureEndpointResponse: S.Schema<DeleteAzureProxyRouteAzureEndpointResponse>;
+export interface DeleteAzureSpeechProxyRouteAzureSpeechEndpointRequest {
+    endpoint: string;
+}
+export declare const DeleteAzureSpeechProxyRouteAzureSpeechEndpointRequest: S.Schema<DeleteAzureSpeechProxyRouteAzureSpeechEndpointRequest>;
+export interface DeleteAzureSpeechProxyRouteAzureSpeechEndpointResponse {
+    body: unknown;
+}
+export declare const DeleteAzureSpeechProxyRouteAzureSpeechEndpointResponse: S.Schema<DeleteAzureSpeechProxyRouteAzureSpeechEndpointResponse>;
+export interface DeleteBedrockProxyRouteBedrockEndpointRequest {
+    endpoint: string;
+}
+export declare const DeleteBedrockProxyRouteBedrockEndpointRequest: S.Schema<DeleteBedrockProxyRouteBedrockEndpointRequest>;
+export interface DeleteBedrockProxyRouteBedrockEndpointResponse {
+    body: unknown;
+}
+export declare const DeleteBedrockProxyRouteBedrockEndpointResponse: S.Schema<DeleteBedrockProxyRouteBedrockEndpointResponse>;
+export interface DeleteCohereProxyRouteCohereEndpointRequest {
+    endpoint: string;
+}
+export declare const DeleteCohereProxyRouteCohereEndpointRequest: S.Schema<DeleteCohereProxyRouteCohereEndpointRequest>;
+export interface DeleteCohereProxyRouteCohereEndpointResponse {
+    body: unknown;
+}
+export declare const DeleteCohereProxyRouteCohereEndpointResponse: S.Schema<DeleteCohereProxyRouteCohereEndpointResponse>;
+export interface DeleteCursorProxyRouteCursorEndpointRequest {
+    endpoint: string;
+}
+export declare const DeleteCursorProxyRouteCursorEndpointRequest: S.Schema<DeleteCursorProxyRouteCursorEndpointRequest>;
+export interface DeleteCursorProxyRouteCursorEndpointResponse {
+    body: unknown;
+}
+export declare const DeleteCursorProxyRouteCursorEndpointResponse: S.Schema<DeleteCursorProxyRouteCursorEndpointResponse>;
+export interface DeleteGeminiProxyRouteGeminiEndpointRequest {
+    endpoint: string;
+}
+export declare const DeleteGeminiProxyRouteGeminiEndpointRequest: S.Schema<DeleteGeminiProxyRouteGeminiEndpointRequest>;
+export interface DeleteGeminiProxyRouteGeminiEndpointResponse {
+    body: unknown;
+}
+export declare const DeleteGeminiProxyRouteGeminiEndpointResponse: S.Schema<DeleteGeminiProxyRouteGeminiEndpointResponse>;
+export interface DeleteGigachatProxyRouteGigachatEndpointRequest {
+    endpoint: string;
+}
+export declare const DeleteGigachatProxyRouteGigachatEndpointRequest: S.Schema<DeleteGigachatProxyRouteGigachatEndpointRequest>;
+export interface DeleteGigachatProxyRouteGigachatEndpointResponse {
+    body: unknown;
+}
+export declare const DeleteGigachatProxyRouteGigachatEndpointResponse: S.Schema<DeleteGigachatProxyRouteGigachatEndpointResponse>;
+export interface DeleteMilvusProxyRouteMilvusEndpointRequest {
+    endpoint: string;
+}
+export declare const DeleteMilvusProxyRouteMilvusEndpointRequest: S.Schema<DeleteMilvusProxyRouteMilvusEndpointRequest>;
+export interface DeleteMilvusProxyRouteMilvusEndpointResponse {
+    body: unknown;
+}
+export declare const DeleteMilvusProxyRouteMilvusEndpointResponse: S.Schema<DeleteMilvusProxyRouteMilvusEndpointResponse>;
+export interface DeleteMistralProxyRouteMistralEndpointRequest {
+    endpoint: string;
+}
+export declare const DeleteMistralProxyRouteMistralEndpointRequest: S.Schema<DeleteMistralProxyRouteMistralEndpointRequest>;
+export interface DeleteMistralProxyRouteMistralEndpointResponse {
+    body: unknown;
+}
+export declare const DeleteMistralProxyRouteMistralEndpointResponse: S.Schema<DeleteMistralProxyRouteMistralEndpointResponse>;
+export interface DeleteNvidiaNimProxyRouteNvidiaNimEndpointRequest {
+    endpoint: string;
+}
+export declare const DeleteNvidiaNimProxyRouteNvidiaNimEndpointRequest: S.Schema<DeleteNvidiaNimProxyRouteNvidiaNimEndpointRequest>;
+export interface DeleteNvidiaNimProxyRouteNvidiaNimEndpointResponse {
+    body: unknown;
+}
+export declare const DeleteNvidiaNimProxyRouteNvidiaNimEndpointResponse: S.Schema<DeleteNvidiaNimProxyRouteNvidiaNimEndpointResponse>;
+export interface DeleteOpenaiProxyRouteOpenaiEndpointRequest {
+    endpoint: string;
+}
+export declare const DeleteOpenaiProxyRouteOpenaiEndpointRequest: S.Schema<DeleteOpenaiProxyRouteOpenaiEndpointRequest>;
+export interface DeleteOpenaiProxyRouteOpenaiEndpointResponse {
+    body: unknown;
+}
+export declare const DeleteOpenaiProxyRouteOpenaiEndpointResponse: S.Schema<DeleteOpenaiProxyRouteOpenaiEndpointResponse>;
+export interface DeleteTypesafeProxyRouteTypesafeEndpointRequest {
+    endpoint: string;
+}
+export declare const DeleteTypesafeProxyRouteTypesafeEndpointRequest: S.Schema<DeleteTypesafeProxyRouteTypesafeEndpointRequest>;
+export interface DeleteTypesafeProxyRouteTypesafeEndpointResponse {
+    body: unknown;
+}
+export declare const DeleteTypesafeProxyRouteTypesafeEndpointResponse: S.Schema<DeleteTypesafeProxyRouteTypesafeEndpointResponse>;
+export interface DeleteVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointRequest {
+    endpoint: string;
+}
+export declare const DeleteVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointRequest: S.Schema<DeleteVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointRequest>;
+export interface DeleteVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointResponse {
+    body: unknown;
+}
+export declare const DeleteVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointResponse: S.Schema<DeleteVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointResponse>;
+export interface DeleteVertexProxyRouteVertexAiEndpointRequest {
+    endpoint: string;
+}
+export declare const DeleteVertexProxyRouteVertexAiEndpointRequest: S.Schema<DeleteVertexProxyRouteVertexAiEndpointRequest>;
+export interface DeleteVertexProxyRouteVertexAiEndpointResponse {
+    body: unknown;
+}
+export declare const DeleteVertexProxyRouteVertexAiEndpointResponse: S.Schema<DeleteVertexProxyRouteVertexAiEndpointResponse>;
+export interface DeleteVllmProxyRouteVllmEndpointRequest {
+    endpoint: string;
+}
+export declare const DeleteVllmProxyRouteVllmEndpointRequest: S.Schema<DeleteVllmProxyRouteVllmEndpointRequest>;
+export interface DeleteVllmProxyRouteVllmEndpointResponse {
+    body: unknown;
+}
+export declare const DeleteVllmProxyRouteVllmEndpointResponse: S.Schema<DeleteVllmProxyRouteVllmEndpointResponse>;
+export interface DeleteWatsonxProxyRouteWatsonxEndpointRequest {
+    endpoint: string;
+}
+export declare const DeleteWatsonxProxyRouteWatsonxEndpointRequest: S.Schema<DeleteWatsonxProxyRouteWatsonxEndpointRequest>;
+export interface DeleteWatsonxProxyRouteWatsonxEndpointResponse {
+    body: unknown;
+}
+export declare const DeleteWatsonxProxyRouteWatsonxEndpointResponse: S.Schema<DeleteWatsonxProxyRouteWatsonxEndpointResponse>;
+export interface GetAnthropicProxyRouteAnthropicEndpointRequest {
+    endpoint: string;
+}
+export declare const GetAnthropicProxyRouteAnthropicEndpointRequest: S.Schema<GetAnthropicProxyRouteAnthropicEndpointRequest>;
+export interface GetAnthropicProxyRouteAnthropicEndpointResponse {
+    body: unknown;
+}
+export declare const GetAnthropicProxyRouteAnthropicEndpointResponse: S.Schema<GetAnthropicProxyRouteAnthropicEndpointResponse>;
+export interface GetAssemblyaiProxyRouteAssemblyaiEndpointRequest {
+    endpoint: string;
+}
+export declare const GetAssemblyaiProxyRouteAssemblyaiEndpointRequest: S.Schema<GetAssemblyaiProxyRouteAssemblyaiEndpointRequest>;
+export interface GetAssemblyaiProxyRouteAssemblyaiEndpointResponse {
+    body: unknown;
+}
+export declare const GetAssemblyaiProxyRouteAssemblyaiEndpointResponse: S.Schema<GetAssemblyaiProxyRouteAssemblyaiEndpointResponse>;
+export interface GetAssemblyaiProxyRouteEuAssemblyaiEndpointRequest {
+    endpoint: string;
+}
+export declare const GetAssemblyaiProxyRouteEuAssemblyaiEndpointRequest: S.Schema<GetAssemblyaiProxyRouteEuAssemblyaiEndpointRequest>;
+export interface GetAssemblyaiProxyRouteEuAssemblyaiEndpointResponse {
+    body: unknown;
+}
+export declare const GetAssemblyaiProxyRouteEuAssemblyaiEndpointResponse: S.Schema<GetAssemblyaiProxyRouteEuAssemblyaiEndpointResponse>;
+export interface GetAzureProxyRouteAzureAiEndpointRequest {
+    endpoint: string;
+}
+export declare const GetAzureProxyRouteAzureAiEndpointRequest: S.Schema<GetAzureProxyRouteAzureAiEndpointRequest>;
+export interface GetAzureProxyRouteAzureAiEndpointResponse {
+    body: unknown;
+}
+export declare const GetAzureProxyRouteAzureAiEndpointResponse: S.Schema<GetAzureProxyRouteAzureAiEndpointResponse>;
+export interface GetAzureProxyRouteAzureEndpointRequest {
+    endpoint: string;
+}
+export declare const GetAzureProxyRouteAzureEndpointRequest: S.Schema<GetAzureProxyRouteAzureEndpointRequest>;
+export interface GetAzureProxyRouteAzureEndpointResponse {
+    body: unknown;
+}
+export declare const GetAzureProxyRouteAzureEndpointResponse: S.Schema<GetAzureProxyRouteAzureEndpointResponse>;
+export interface GetAzureSpeechProxyRouteAzureSpeechEndpointRequest {
+    endpoint: string;
+}
+export declare const GetAzureSpeechProxyRouteAzureSpeechEndpointRequest: S.Schema<GetAzureSpeechProxyRouteAzureSpeechEndpointRequest>;
+export interface GetAzureSpeechProxyRouteAzureSpeechEndpointResponse {
+    body: unknown;
+}
+export declare const GetAzureSpeechProxyRouteAzureSpeechEndpointResponse: S.Schema<GetAzureSpeechProxyRouteAzureSpeechEndpointResponse>;
+export interface GetBedrockProxyRouteBedrockEndpointRequest {
+    endpoint: string;
+}
+export declare const GetBedrockProxyRouteBedrockEndpointRequest: S.Schema<GetBedrockProxyRouteBedrockEndpointRequest>;
+export interface GetBedrockProxyRouteBedrockEndpointResponse {
+    body: unknown;
+}
+export declare const GetBedrockProxyRouteBedrockEndpointResponse: S.Schema<GetBedrockProxyRouteBedrockEndpointResponse>;
+export interface GetCohereProxyRouteCohereEndpointRequest {
+    endpoint: string;
+}
+export declare const GetCohereProxyRouteCohereEndpointRequest: S.Schema<GetCohereProxyRouteCohereEndpointRequest>;
+export interface GetCohereProxyRouteCohereEndpointResponse {
+    body: unknown;
+}
+export declare const GetCohereProxyRouteCohereEndpointResponse: S.Schema<GetCohereProxyRouteCohereEndpointResponse>;
+export interface GetCursorProxyRouteCursorEndpointRequest {
+    endpoint: string;
+}
+export declare const GetCursorProxyRouteCursorEndpointRequest: S.Schema<GetCursorProxyRouteCursorEndpointRequest>;
+export interface GetCursorProxyRouteCursorEndpointResponse {
+    body: unknown;
+}
+export declare const GetCursorProxyRouteCursorEndpointResponse: S.Schema<GetCursorProxyRouteCursorEndpointResponse>;
+export interface GetGeminiProxyRouteGeminiEndpointRequest {
+    endpoint: string;
+}
+export declare const GetGeminiProxyRouteGeminiEndpointRequest: S.Schema<GetGeminiProxyRouteGeminiEndpointRequest>;
+export interface GetGeminiProxyRouteGeminiEndpointResponse {
+    body: unknown;
+}
+export declare const GetGeminiProxyRouteGeminiEndpointResponse: S.Schema<GetGeminiProxyRouteGeminiEndpointResponse>;
+export interface GetGigachatProxyRouteGigachatEndpointRequest {
+    endpoint: string;
+}
+export declare const GetGigachatProxyRouteGigachatEndpointRequest: S.Schema<GetGigachatProxyRouteGigachatEndpointRequest>;
+export interface GetGigachatProxyRouteGigachatEndpointResponse {
+    body: unknown;
+}
+export declare const GetGigachatProxyRouteGigachatEndpointResponse: S.Schema<GetGigachatProxyRouteGigachatEndpointResponse>;
+export interface GetMilvusProxyRouteMilvusEndpointRequest {
+    endpoint: string;
+}
+export declare const GetMilvusProxyRouteMilvusEndpointRequest: S.Schema<GetMilvusProxyRouteMilvusEndpointRequest>;
+export interface GetMilvusProxyRouteMilvusEndpointResponse {
+    body: unknown;
+}
+export declare const GetMilvusProxyRouteMilvusEndpointResponse: S.Schema<GetMilvusProxyRouteMilvusEndpointResponse>;
+export interface GetMistralProxyRouteMistralEndpointRequest {
+    endpoint: string;
+}
+export declare const GetMistralProxyRouteMistralEndpointRequest: S.Schema<GetMistralProxyRouteMistralEndpointRequest>;
+export interface GetMistralProxyRouteMistralEndpointResponse {
+    body: unknown;
+}
+export declare const GetMistralProxyRouteMistralEndpointResponse: S.Schema<GetMistralProxyRouteMistralEndpointResponse>;
+export interface GetNvidiaNimProxyRouteNvidiaNimEndpointRequest {
+    endpoint: string;
+}
+export declare const GetNvidiaNimProxyRouteNvidiaNimEndpointRequest: S.Schema<GetNvidiaNimProxyRouteNvidiaNimEndpointRequest>;
+export interface GetNvidiaNimProxyRouteNvidiaNimEndpointResponse {
+    body: unknown;
+}
+export declare const GetNvidiaNimProxyRouteNvidiaNimEndpointResponse: S.Schema<GetNvidiaNimProxyRouteNvidiaNimEndpointResponse>;
+export interface GetOpenaiProxyRouteOpenaiEndpointRequest {
+    endpoint: string;
+}
+export declare const GetOpenaiProxyRouteOpenaiEndpointRequest: S.Schema<GetOpenaiProxyRouteOpenaiEndpointRequest>;
+export interface GetOpenaiProxyRouteOpenaiEndpointResponse {
+    body: unknown;
+}
+export declare const GetOpenaiProxyRouteOpenaiEndpointResponse: S.Schema<GetOpenaiProxyRouteOpenaiEndpointResponse>;
+export interface GetTypesafeProxyRouteTypesafeEndpointRequest {
+    endpoint: string;
+}
+export declare const GetTypesafeProxyRouteTypesafeEndpointRequest: S.Schema<GetTypesafeProxyRouteTypesafeEndpointRequest>;
+export interface GetTypesafeProxyRouteTypesafeEndpointResponse {
+    body: unknown;
+}
+export declare const GetTypesafeProxyRouteTypesafeEndpointResponse: S.Schema<GetTypesafeProxyRouteTypesafeEndpointResponse>;
+export interface GetVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointRequest {
+    endpoint: string;
+}
+export declare const GetVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointRequest: S.Schema<GetVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointRequest>;
+export interface GetVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointResponse {
+    body: unknown;
+}
+export declare const GetVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointResponse: S.Schema<GetVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointResponse>;
+export interface GetVertexProxyRouteVertexAiEndpointRequest {
+    endpoint: string;
+}
+export declare const GetVertexProxyRouteVertexAiEndpointRequest: S.Schema<GetVertexProxyRouteVertexAiEndpointRequest>;
+export interface GetVertexProxyRouteVertexAiEndpointResponse {
+    body: unknown;
+}
+export declare const GetVertexProxyRouteVertexAiEndpointResponse: S.Schema<GetVertexProxyRouteVertexAiEndpointResponse>;
+export interface GetVllmProxyRouteVllmEndpointRequest {
+    endpoint: string;
+}
+export declare const GetVllmProxyRouteVllmEndpointRequest: S.Schema<GetVllmProxyRouteVllmEndpointRequest>;
+export interface GetVllmProxyRouteVllmEndpointResponse {
+    body: unknown;
+}
+export declare const GetVllmProxyRouteVllmEndpointResponse: S.Schema<GetVllmProxyRouteVllmEndpointResponse>;
+export interface GetWatsonxProxyRouteWatsonxEndpointRequest {
+    endpoint: string;
+}
+export declare const GetWatsonxProxyRouteWatsonxEndpointRequest: S.Schema<GetWatsonxProxyRouteWatsonxEndpointRequest>;
+export interface GetWatsonxProxyRouteWatsonxEndpointResponse {
+    body: unknown;
+}
+export declare const GetWatsonxProxyRouteWatsonxEndpointResponse: S.Schema<GetWatsonxProxyRouteWatsonxEndpointResponse>;
+export interface PatchAnthropicProxyRouteAnthropicEndpointRequest {
+    endpoint: string;
+}
+export declare const PatchAnthropicProxyRouteAnthropicEndpointRequest: S.Schema<PatchAnthropicProxyRouteAnthropicEndpointRequest>;
+export interface PatchAnthropicProxyRouteAnthropicEndpointResponse {
+    body: unknown;
+}
+export declare const PatchAnthropicProxyRouteAnthropicEndpointResponse: S.Schema<PatchAnthropicProxyRouteAnthropicEndpointResponse>;
+export interface PatchAssemblyaiProxyRouteAssemblyaiEndpointRequest {
+    endpoint: string;
+}
+export declare const PatchAssemblyaiProxyRouteAssemblyaiEndpointRequest: S.Schema<PatchAssemblyaiProxyRouteAssemblyaiEndpointRequest>;
+export interface PatchAssemblyaiProxyRouteAssemblyaiEndpointResponse {
+    body: unknown;
+}
+export declare const PatchAssemblyaiProxyRouteAssemblyaiEndpointResponse: S.Schema<PatchAssemblyaiProxyRouteAssemblyaiEndpointResponse>;
+export interface PatchAssemblyaiProxyRouteEuAssemblyaiEndpointRequest {
+    endpoint: string;
+}
+export declare const PatchAssemblyaiProxyRouteEuAssemblyaiEndpointRequest: S.Schema<PatchAssemblyaiProxyRouteEuAssemblyaiEndpointRequest>;
+export interface PatchAssemblyaiProxyRouteEuAssemblyaiEndpointResponse {
+    body: unknown;
+}
+export declare const PatchAssemblyaiProxyRouteEuAssemblyaiEndpointResponse: S.Schema<PatchAssemblyaiProxyRouteEuAssemblyaiEndpointResponse>;
+export interface PatchAzureProxyRouteAzureAiEndpointRequest {
+    endpoint: string;
+}
+export declare const PatchAzureProxyRouteAzureAiEndpointRequest: S.Schema<PatchAzureProxyRouteAzureAiEndpointRequest>;
+export interface PatchAzureProxyRouteAzureAiEndpointResponse {
+    body: unknown;
+}
+export declare const PatchAzureProxyRouteAzureAiEndpointResponse: S.Schema<PatchAzureProxyRouteAzureAiEndpointResponse>;
+export interface PatchAzureProxyRouteAzureEndpointRequest {
+    endpoint: string;
+}
+export declare const PatchAzureProxyRouteAzureEndpointRequest: S.Schema<PatchAzureProxyRouteAzureEndpointRequest>;
+export interface PatchAzureProxyRouteAzureEndpointResponse {
+    body: unknown;
+}
+export declare const PatchAzureProxyRouteAzureEndpointResponse: S.Schema<PatchAzureProxyRouteAzureEndpointResponse>;
+export interface PatchAzureSpeechProxyRouteAzureSpeechEndpointRequest {
+    endpoint: string;
+}
+export declare const PatchAzureSpeechProxyRouteAzureSpeechEndpointRequest: S.Schema<PatchAzureSpeechProxyRouteAzureSpeechEndpointRequest>;
+export interface PatchAzureSpeechProxyRouteAzureSpeechEndpointResponse {
+    body: unknown;
+}
+export declare const PatchAzureSpeechProxyRouteAzureSpeechEndpointResponse: S.Schema<PatchAzureSpeechProxyRouteAzureSpeechEndpointResponse>;
+export interface PatchBedrockProxyRouteBedrockEndpointRequest {
+    endpoint: string;
+}
+export declare const PatchBedrockProxyRouteBedrockEndpointRequest: S.Schema<PatchBedrockProxyRouteBedrockEndpointRequest>;
+export interface PatchBedrockProxyRouteBedrockEndpointResponse {
+    body: unknown;
+}
+export declare const PatchBedrockProxyRouteBedrockEndpointResponse: S.Schema<PatchBedrockProxyRouteBedrockEndpointResponse>;
+export interface PatchCohereProxyRouteCohereEndpointRequest {
+    endpoint: string;
+}
+export declare const PatchCohereProxyRouteCohereEndpointRequest: S.Schema<PatchCohereProxyRouteCohereEndpointRequest>;
+export interface PatchCohereProxyRouteCohereEndpointResponse {
+    body: unknown;
+}
+export declare const PatchCohereProxyRouteCohereEndpointResponse: S.Schema<PatchCohereProxyRouteCohereEndpointResponse>;
+export interface PatchCursorProxyRouteCursorEndpointRequest {
+    endpoint: string;
+}
+export declare const PatchCursorProxyRouteCursorEndpointRequest: S.Schema<PatchCursorProxyRouteCursorEndpointRequest>;
+export interface PatchCursorProxyRouteCursorEndpointResponse {
+    body: unknown;
+}
+export declare const PatchCursorProxyRouteCursorEndpointResponse: S.Schema<PatchCursorProxyRouteCursorEndpointResponse>;
+export interface PatchGeminiProxyRouteGeminiEndpointRequest {
+    endpoint: string;
+}
+export declare const PatchGeminiProxyRouteGeminiEndpointRequest: S.Schema<PatchGeminiProxyRouteGeminiEndpointRequest>;
+export interface PatchGeminiProxyRouteGeminiEndpointResponse {
+    body: unknown;
+}
+export declare const PatchGeminiProxyRouteGeminiEndpointResponse: S.Schema<PatchGeminiProxyRouteGeminiEndpointResponse>;
+export interface PatchGigachatProxyRouteGigachatEndpointRequest {
+    endpoint: string;
+}
+export declare const PatchGigachatProxyRouteGigachatEndpointRequest: S.Schema<PatchGigachatProxyRouteGigachatEndpointRequest>;
+export interface PatchGigachatProxyRouteGigachatEndpointResponse {
+    body: unknown;
+}
+export declare const PatchGigachatProxyRouteGigachatEndpointResponse: S.Schema<PatchGigachatProxyRouteGigachatEndpointResponse>;
+export interface PatchMilvusProxyRouteMilvusEndpointRequest {
+    endpoint: string;
+}
+export declare const PatchMilvusProxyRouteMilvusEndpointRequest: S.Schema<PatchMilvusProxyRouteMilvusEndpointRequest>;
+export interface PatchMilvusProxyRouteMilvusEndpointResponse {
+    body: unknown;
+}
+export declare const PatchMilvusProxyRouteMilvusEndpointResponse: S.Schema<PatchMilvusProxyRouteMilvusEndpointResponse>;
+export interface PatchMistralProxyRouteMistralEndpointRequest {
+    endpoint: string;
+}
+export declare const PatchMistralProxyRouteMistralEndpointRequest: S.Schema<PatchMistralProxyRouteMistralEndpointRequest>;
+export interface PatchMistralProxyRouteMistralEndpointResponse {
+    body: unknown;
+}
+export declare const PatchMistralProxyRouteMistralEndpointResponse: S.Schema<PatchMistralProxyRouteMistralEndpointResponse>;
+export interface PatchNvidiaNimProxyRouteNvidiaNimEndpointRequest {
+    endpoint: string;
+}
+export declare const PatchNvidiaNimProxyRouteNvidiaNimEndpointRequest: S.Schema<PatchNvidiaNimProxyRouteNvidiaNimEndpointRequest>;
+export interface PatchNvidiaNimProxyRouteNvidiaNimEndpointResponse {
+    body: unknown;
+}
+export declare const PatchNvidiaNimProxyRouteNvidiaNimEndpointResponse: S.Schema<PatchNvidiaNimProxyRouteNvidiaNimEndpointResponse>;
+export interface PatchOpenaiProxyRouteOpenaiEndpointRequest {
+    endpoint: string;
+}
+export declare const PatchOpenaiProxyRouteOpenaiEndpointRequest: S.Schema<PatchOpenaiProxyRouteOpenaiEndpointRequest>;
+export interface PatchOpenaiProxyRouteOpenaiEndpointResponse {
+    body: unknown;
+}
+export declare const PatchOpenaiProxyRouteOpenaiEndpointResponse: S.Schema<PatchOpenaiProxyRouteOpenaiEndpointResponse>;
+export interface PatchTypesafeProxyRouteTypesafeEndpointRequest {
+    endpoint: string;
+}
+export declare const PatchTypesafeProxyRouteTypesafeEndpointRequest: S.Schema<PatchTypesafeProxyRouteTypesafeEndpointRequest>;
+export interface PatchTypesafeProxyRouteTypesafeEndpointResponse {
+    body: unknown;
+}
+export declare const PatchTypesafeProxyRouteTypesafeEndpointResponse: S.Schema<PatchTypesafeProxyRouteTypesafeEndpointResponse>;
+export interface PatchVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointRequest {
+    endpoint: string;
+}
+export declare const PatchVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointRequest: S.Schema<PatchVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointRequest>;
+export interface PatchVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointResponse {
+    body: unknown;
+}
+export declare const PatchVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointResponse: S.Schema<PatchVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointResponse>;
+export interface PatchVertexProxyRouteVertexAiEndpointRequest {
+    endpoint: string;
+}
+export declare const PatchVertexProxyRouteVertexAiEndpointRequest: S.Schema<PatchVertexProxyRouteVertexAiEndpointRequest>;
+export interface PatchVertexProxyRouteVertexAiEndpointResponse {
+    body: unknown;
+}
+export declare const PatchVertexProxyRouteVertexAiEndpointResponse: S.Schema<PatchVertexProxyRouteVertexAiEndpointResponse>;
+export interface PatchVllmProxyRouteVllmEndpointRequest {
+    endpoint: string;
+}
+export declare const PatchVllmProxyRouteVllmEndpointRequest: S.Schema<PatchVllmProxyRouteVllmEndpointRequest>;
+export interface PatchVllmProxyRouteVllmEndpointResponse {
+    body: unknown;
+}
+export declare const PatchVllmProxyRouteVllmEndpointResponse: S.Schema<PatchVllmProxyRouteVllmEndpointResponse>;
+export interface PatchWatsonxProxyRouteWatsonxEndpointRequest {
+    endpoint: string;
+}
+export declare const PatchWatsonxProxyRouteWatsonxEndpointRequest: S.Schema<PatchWatsonxProxyRouteWatsonxEndpointRequest>;
+export interface PatchWatsonxProxyRouteWatsonxEndpointResponse {
+    body: unknown;
+}
+export declare const PatchWatsonxProxyRouteWatsonxEndpointResponse: S.Schema<PatchWatsonxProxyRouteWatsonxEndpointResponse>;
+export interface PostAnthropicProxyRouteAnthropicEndpointRequest {
+    endpoint: string;
+}
+export declare const PostAnthropicProxyRouteAnthropicEndpointRequest: S.Schema<PostAnthropicProxyRouteAnthropicEndpointRequest>;
+export interface PostAnthropicProxyRouteAnthropicEndpointResponse {
+    body: unknown;
+}
+export declare const PostAnthropicProxyRouteAnthropicEndpointResponse: S.Schema<PostAnthropicProxyRouteAnthropicEndpointResponse>;
+export interface PostAssemblyaiProxyRouteAssemblyaiEndpointRequest {
+    endpoint: string;
+}
+export declare const PostAssemblyaiProxyRouteAssemblyaiEndpointRequest: S.Schema<PostAssemblyaiProxyRouteAssemblyaiEndpointRequest>;
+export interface PostAssemblyaiProxyRouteAssemblyaiEndpointResponse {
+    body: unknown;
+}
+export declare const PostAssemblyaiProxyRouteAssemblyaiEndpointResponse: S.Schema<PostAssemblyaiProxyRouteAssemblyaiEndpointResponse>;
+export interface PostAssemblyaiProxyRouteEuAssemblyaiEndpointRequest {
+    endpoint: string;
+}
+export declare const PostAssemblyaiProxyRouteEuAssemblyaiEndpointRequest: S.Schema<PostAssemblyaiProxyRouteEuAssemblyaiEndpointRequest>;
+export interface PostAssemblyaiProxyRouteEuAssemblyaiEndpointResponse {
+    body: unknown;
+}
+export declare const PostAssemblyaiProxyRouteEuAssemblyaiEndpointResponse: S.Schema<PostAssemblyaiProxyRouteEuAssemblyaiEndpointResponse>;
+export interface PostAzureProxyRouteAzureAiEndpointRequest {
+    endpoint: string;
+}
+export declare const PostAzureProxyRouteAzureAiEndpointRequest: S.Schema<PostAzureProxyRouteAzureAiEndpointRequest>;
+export interface PostAzureProxyRouteAzureAiEndpointResponse {
+    body: unknown;
+}
+export declare const PostAzureProxyRouteAzureAiEndpointResponse: S.Schema<PostAzureProxyRouteAzureAiEndpointResponse>;
+export interface PostAzureProxyRouteAzureEndpointRequest {
+    endpoint: string;
+}
+export declare const PostAzureProxyRouteAzureEndpointRequest: S.Schema<PostAzureProxyRouteAzureEndpointRequest>;
+export interface PostAzureProxyRouteAzureEndpointResponse {
+    body: unknown;
+}
+export declare const PostAzureProxyRouteAzureEndpointResponse: S.Schema<PostAzureProxyRouteAzureEndpointResponse>;
+export interface PostAzureSpeechProxyRouteAzureSpeechEndpointRequest {
+    endpoint: string;
+}
+export declare const PostAzureSpeechProxyRouteAzureSpeechEndpointRequest: S.Schema<PostAzureSpeechProxyRouteAzureSpeechEndpointRequest>;
+export interface PostAzureSpeechProxyRouteAzureSpeechEndpointResponse {
+    body: unknown;
+}
+export declare const PostAzureSpeechProxyRouteAzureSpeechEndpointResponse: S.Schema<PostAzureSpeechProxyRouteAzureSpeechEndpointResponse>;
+export interface PostBedrockProxyRouteBedrockEndpointRequest {
+    endpoint: string;
+}
+export declare const PostBedrockProxyRouteBedrockEndpointRequest: S.Schema<PostBedrockProxyRouteBedrockEndpointRequest>;
+export interface PostBedrockProxyRouteBedrockEndpointResponse {
+    body: unknown;
+}
+export declare const PostBedrockProxyRouteBedrockEndpointResponse: S.Schema<PostBedrockProxyRouteBedrockEndpointResponse>;
+export interface PostCohereProxyRouteCohereEndpointRequest {
+    endpoint: string;
+}
+export declare const PostCohereProxyRouteCohereEndpointRequest: S.Schema<PostCohereProxyRouteCohereEndpointRequest>;
+export interface PostCohereProxyRouteCohereEndpointResponse {
+    body: unknown;
+}
+export declare const PostCohereProxyRouteCohereEndpointResponse: S.Schema<PostCohereProxyRouteCohereEndpointResponse>;
+export interface PostComprehendMedicalProxyRouteComprehendmedicalOperationRequest {
+    operation: string;
+}
+export declare const PostComprehendMedicalProxyRouteComprehendmedicalOperationRequest: S.Schema<PostComprehendMedicalProxyRouteComprehendmedicalOperationRequest>;
+export interface PostComprehendMedicalProxyRouteComprehendmedicalOperationResponse {
+    body: unknown;
+}
+export declare const PostComprehendMedicalProxyRouteComprehendmedicalOperationResponse: S.Schema<PostComprehendMedicalProxyRouteComprehendmedicalOperationResponse>;
+export interface PostComprehendMedicalSdkProxyRouteComprehendmedicalRequest {
+}
+export declare const PostComprehendMedicalSdkProxyRouteComprehendmedicalRequest: S.Schema<PostComprehendMedicalSdkProxyRouteComprehendmedicalRequest>;
+export interface PostComprehendMedicalSdkProxyRouteComprehendmedicalResponse {
+    body: unknown;
+}
+export declare const PostComprehendMedicalSdkProxyRouteComprehendmedicalResponse: S.Schema<PostComprehendMedicalSdkProxyRouteComprehendmedicalResponse>;
+export interface PostCursorProxyRouteCursorEndpointRequest {
+    endpoint: string;
+}
+export declare const PostCursorProxyRouteCursorEndpointRequest: S.Schema<PostCursorProxyRouteCursorEndpointRequest>;
+export interface PostCursorProxyRouteCursorEndpointResponse {
+    body: unknown;
+}
+export declare const PostCursorProxyRouteCursorEndpointResponse: S.Schema<PostCursorProxyRouteCursorEndpointResponse>;
+export interface PostGeminiProxyRouteGeminiEndpointRequest {
+    endpoint: string;
+}
+export declare const PostGeminiProxyRouteGeminiEndpointRequest: S.Schema<PostGeminiProxyRouteGeminiEndpointRequest>;
+export interface PostGeminiProxyRouteGeminiEndpointResponse {
+    body: unknown;
+}
+export declare const PostGeminiProxyRouteGeminiEndpointResponse: S.Schema<PostGeminiProxyRouteGeminiEndpointResponse>;
+export interface PostGigachatProxyRouteGigachatEndpointRequest {
+    endpoint: string;
+}
+export declare const PostGigachatProxyRouteGigachatEndpointRequest: S.Schema<PostGigachatProxyRouteGigachatEndpointRequest>;
+export interface PostGigachatProxyRouteGigachatEndpointResponse {
+    body: unknown;
+}
+export declare const PostGigachatProxyRouteGigachatEndpointResponse: S.Schema<PostGigachatProxyRouteGigachatEndpointResponse>;
+export interface PostMilvusProxyRouteMilvusEndpointRequest {
+    endpoint: string;
+}
+export declare const PostMilvusProxyRouteMilvusEndpointRequest: S.Schema<PostMilvusProxyRouteMilvusEndpointRequest>;
+export interface PostMilvusProxyRouteMilvusEndpointResponse {
+    body: unknown;
+}
+export declare const PostMilvusProxyRouteMilvusEndpointResponse: S.Schema<PostMilvusProxyRouteMilvusEndpointResponse>;
+export interface PostMistralProxyRouteMistralEndpointRequest {
+    endpoint: string;
+}
+export declare const PostMistralProxyRouteMistralEndpointRequest: S.Schema<PostMistralProxyRouteMistralEndpointRequest>;
+export interface PostMistralProxyRouteMistralEndpointResponse {
+    body: unknown;
+}
+export declare const PostMistralProxyRouteMistralEndpointResponse: S.Schema<PostMistralProxyRouteMistralEndpointResponse>;
+export interface PostNvidiaNimProxyRouteNvidiaNimEndpointRequest {
+    endpoint: string;
+}
+export declare const PostNvidiaNimProxyRouteNvidiaNimEndpointRequest: S.Schema<PostNvidiaNimProxyRouteNvidiaNimEndpointRequest>;
+export interface PostNvidiaNimProxyRouteNvidiaNimEndpointResponse {
+    body: unknown;
+}
+export declare const PostNvidiaNimProxyRouteNvidiaNimEndpointResponse: S.Schema<PostNvidiaNimProxyRouteNvidiaNimEndpointResponse>;
+export interface PostOpenaiProxyRouteOpenaiEndpointRequest {
+    endpoint: string;
+}
+export declare const PostOpenaiProxyRouteOpenaiEndpointRequest: S.Schema<PostOpenaiProxyRouteOpenaiEndpointRequest>;
+export interface PostOpenaiProxyRouteOpenaiEndpointResponse {
+    body: unknown;
+}
+export declare const PostOpenaiProxyRouteOpenaiEndpointResponse: S.Schema<PostOpenaiProxyRouteOpenaiEndpointResponse>;
+export interface PostProxyRealtimeCallsOpenaiV1RealtimeCallRequest {
+}
+export declare const PostProxyRealtimeCallsOpenaiV1RealtimeCallRequest: S.Schema<PostProxyRealtimeCallsOpenaiV1RealtimeCallRequest>;
+export interface PostProxyRealtimeCallsOpenaiV1RealtimeCallResponse {
+    body: unknown;
+}
+export declare const PostProxyRealtimeCallsOpenaiV1RealtimeCallResponse: S.Schema<PostProxyRealtimeCallsOpenaiV1RealtimeCallResponse>;
+export interface PostTranscribeProxyRouteTranscribeOperationRequest {
+    operation: string;
+}
+export declare const PostTranscribeProxyRouteTranscribeOperationRequest: S.Schema<PostTranscribeProxyRouteTranscribeOperationRequest>;
+export interface PostTranscribeProxyRouteTranscribeOperationResponse {
+    body: unknown;
+}
+export declare const PostTranscribeProxyRouteTranscribeOperationResponse: S.Schema<PostTranscribeProxyRouteTranscribeOperationResponse>;
+export interface PostTranscribeSdkProxyRouteTranscribeRequest {
+}
+export declare const PostTranscribeSdkProxyRouteTranscribeRequest: S.Schema<PostTranscribeSdkProxyRouteTranscribeRequest>;
+export interface PostTranscribeSdkProxyRouteTranscribeResponse {
+    body: unknown;
+}
+export declare const PostTranscribeSdkProxyRouteTranscribeResponse: S.Schema<PostTranscribeSdkProxyRouteTranscribeResponse>;
+export interface PostTypesafeProxyRouteTypesafeEndpointRequest {
+    endpoint: string;
+}
+export declare const PostTypesafeProxyRouteTypesafeEndpointRequest: S.Schema<PostTypesafeProxyRouteTypesafeEndpointRequest>;
+export interface PostTypesafeProxyRouteTypesafeEndpointResponse {
+    body: unknown;
+}
+export declare const PostTypesafeProxyRouteTypesafeEndpointResponse: S.Schema<PostTypesafeProxyRouteTypesafeEndpointResponse>;
+export interface PostVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointRequest {
+    endpoint: string;
+}
+export declare const PostVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointRequest: S.Schema<PostVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointRequest>;
+export interface PostVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointResponse {
+    body: unknown;
+}
+export declare const PostVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointResponse: S.Schema<PostVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointResponse>;
+export interface PostVertexProxyRouteVertexAiEndpointRequest {
+    endpoint: string;
+}
+export declare const PostVertexProxyRouteVertexAiEndpointRequest: S.Schema<PostVertexProxyRouteVertexAiEndpointRequest>;
+export interface PostVertexProxyRouteVertexAiEndpointResponse {
+    body: unknown;
+}
+export declare const PostVertexProxyRouteVertexAiEndpointResponse: S.Schema<PostVertexProxyRouteVertexAiEndpointResponse>;
+export interface PostVllmProxyRouteVllmEndpointRequest {
+    endpoint: string;
+}
+export declare const PostVllmProxyRouteVllmEndpointRequest: S.Schema<PostVllmProxyRouteVllmEndpointRequest>;
+export interface PostVllmProxyRouteVllmEndpointResponse {
+    body: unknown;
+}
+export declare const PostVllmProxyRouteVllmEndpointResponse: S.Schema<PostVllmProxyRouteVllmEndpointResponse>;
+export interface PostWatsonxProxyRouteWatsonxEndpointRequest {
+    endpoint: string;
+}
+export declare const PostWatsonxProxyRouteWatsonxEndpointRequest: S.Schema<PostWatsonxProxyRouteWatsonxEndpointRequest>;
+export interface PostWatsonxProxyRouteWatsonxEndpointResponse {
+    body: unknown;
+}
+export declare const PostWatsonxProxyRouteWatsonxEndpointResponse: S.Schema<PostWatsonxProxyRouteWatsonxEndpointResponse>;
+export interface PutAnthropicProxyRouteAnthropicEndpointRequest {
+    endpoint: string;
+}
+export declare const PutAnthropicProxyRouteAnthropicEndpointRequest: S.Schema<PutAnthropicProxyRouteAnthropicEndpointRequest>;
+export interface PutAnthropicProxyRouteAnthropicEndpointResponse {
+    body: unknown;
+}
+export declare const PutAnthropicProxyRouteAnthropicEndpointResponse: S.Schema<PutAnthropicProxyRouteAnthropicEndpointResponse>;
+export interface PutAssemblyaiProxyRouteAssemblyaiEndpointRequest {
+    endpoint: string;
+}
+export declare const PutAssemblyaiProxyRouteAssemblyaiEndpointRequest: S.Schema<PutAssemblyaiProxyRouteAssemblyaiEndpointRequest>;
+export interface PutAssemblyaiProxyRouteAssemblyaiEndpointResponse {
+    body: unknown;
+}
+export declare const PutAssemblyaiProxyRouteAssemblyaiEndpointResponse: S.Schema<PutAssemblyaiProxyRouteAssemblyaiEndpointResponse>;
+export interface PutAssemblyaiProxyRouteEuAssemblyaiEndpointRequest {
+    endpoint: string;
+}
+export declare const PutAssemblyaiProxyRouteEuAssemblyaiEndpointRequest: S.Schema<PutAssemblyaiProxyRouteEuAssemblyaiEndpointRequest>;
+export interface PutAssemblyaiProxyRouteEuAssemblyaiEndpointResponse {
+    body: unknown;
+}
+export declare const PutAssemblyaiProxyRouteEuAssemblyaiEndpointResponse: S.Schema<PutAssemblyaiProxyRouteEuAssemblyaiEndpointResponse>;
+export interface PutAzureProxyRouteAzureAiEndpointRequest {
+    endpoint: string;
+}
+export declare const PutAzureProxyRouteAzureAiEndpointRequest: S.Schema<PutAzureProxyRouteAzureAiEndpointRequest>;
+export interface PutAzureProxyRouteAzureAiEndpointResponse {
+    body: unknown;
+}
+export declare const PutAzureProxyRouteAzureAiEndpointResponse: S.Schema<PutAzureProxyRouteAzureAiEndpointResponse>;
+export interface PutAzureProxyRouteAzureEndpointRequest {
+    endpoint: string;
+}
+export declare const PutAzureProxyRouteAzureEndpointRequest: S.Schema<PutAzureProxyRouteAzureEndpointRequest>;
+export interface PutAzureProxyRouteAzureEndpointResponse {
+    body: unknown;
+}
+export declare const PutAzureProxyRouteAzureEndpointResponse: S.Schema<PutAzureProxyRouteAzureEndpointResponse>;
+export interface PutAzureSpeechProxyRouteAzureSpeechEndpointRequest {
+    endpoint: string;
+}
+export declare const PutAzureSpeechProxyRouteAzureSpeechEndpointRequest: S.Schema<PutAzureSpeechProxyRouteAzureSpeechEndpointRequest>;
+export interface PutAzureSpeechProxyRouteAzureSpeechEndpointResponse {
+    body: unknown;
+}
+export declare const PutAzureSpeechProxyRouteAzureSpeechEndpointResponse: S.Schema<PutAzureSpeechProxyRouteAzureSpeechEndpointResponse>;
+export interface PutBedrockProxyRouteBedrockEndpointRequest {
+    endpoint: string;
+}
+export declare const PutBedrockProxyRouteBedrockEndpointRequest: S.Schema<PutBedrockProxyRouteBedrockEndpointRequest>;
+export interface PutBedrockProxyRouteBedrockEndpointResponse {
+    body: unknown;
+}
+export declare const PutBedrockProxyRouteBedrockEndpointResponse: S.Schema<PutBedrockProxyRouteBedrockEndpointResponse>;
+export interface PutCohereProxyRouteCohereEndpointRequest {
+    endpoint: string;
+}
+export declare const PutCohereProxyRouteCohereEndpointRequest: S.Schema<PutCohereProxyRouteCohereEndpointRequest>;
+export interface PutCohereProxyRouteCohereEndpointResponse {
+    body: unknown;
+}
+export declare const PutCohereProxyRouteCohereEndpointResponse: S.Schema<PutCohereProxyRouteCohereEndpointResponse>;
+export interface PutCursorProxyRouteCursorEndpointRequest {
+    endpoint: string;
+}
+export declare const PutCursorProxyRouteCursorEndpointRequest: S.Schema<PutCursorProxyRouteCursorEndpointRequest>;
+export interface PutCursorProxyRouteCursorEndpointResponse {
+    body: unknown;
+}
+export declare const PutCursorProxyRouteCursorEndpointResponse: S.Schema<PutCursorProxyRouteCursorEndpointResponse>;
+export interface PutGeminiProxyRouteGeminiEndpointRequest {
+    endpoint: string;
+}
+export declare const PutGeminiProxyRouteGeminiEndpointRequest: S.Schema<PutGeminiProxyRouteGeminiEndpointRequest>;
+export interface PutGeminiProxyRouteGeminiEndpointResponse {
+    body: unknown;
+}
+export declare const PutGeminiProxyRouteGeminiEndpointResponse: S.Schema<PutGeminiProxyRouteGeminiEndpointResponse>;
+export interface PutGigachatProxyRouteGigachatEndpointRequest {
+    endpoint: string;
+}
+export declare const PutGigachatProxyRouteGigachatEndpointRequest: S.Schema<PutGigachatProxyRouteGigachatEndpointRequest>;
+export interface PutGigachatProxyRouteGigachatEndpointResponse {
+    body: unknown;
+}
+export declare const PutGigachatProxyRouteGigachatEndpointResponse: S.Schema<PutGigachatProxyRouteGigachatEndpointResponse>;
+export interface PutMilvusProxyRouteMilvusEndpointRequest {
+    endpoint: string;
+}
+export declare const PutMilvusProxyRouteMilvusEndpointRequest: S.Schema<PutMilvusProxyRouteMilvusEndpointRequest>;
+export interface PutMilvusProxyRouteMilvusEndpointResponse {
+    body: unknown;
+}
+export declare const PutMilvusProxyRouteMilvusEndpointResponse: S.Schema<PutMilvusProxyRouteMilvusEndpointResponse>;
+export interface PutMistralProxyRouteMistralEndpointRequest {
+    endpoint: string;
+}
+export declare const PutMistralProxyRouteMistralEndpointRequest: S.Schema<PutMistralProxyRouteMistralEndpointRequest>;
+export interface PutMistralProxyRouteMistralEndpointResponse {
+    body: unknown;
+}
+export declare const PutMistralProxyRouteMistralEndpointResponse: S.Schema<PutMistralProxyRouteMistralEndpointResponse>;
+export interface PutNvidiaNimProxyRouteNvidiaNimEndpointRequest {
+    endpoint: string;
+}
+export declare const PutNvidiaNimProxyRouteNvidiaNimEndpointRequest: S.Schema<PutNvidiaNimProxyRouteNvidiaNimEndpointRequest>;
+export interface PutNvidiaNimProxyRouteNvidiaNimEndpointResponse {
+    body: unknown;
+}
+export declare const PutNvidiaNimProxyRouteNvidiaNimEndpointResponse: S.Schema<PutNvidiaNimProxyRouteNvidiaNimEndpointResponse>;
+export interface PutOpenaiProxyRouteOpenaiEndpointRequest {
+    endpoint: string;
+}
+export declare const PutOpenaiProxyRouteOpenaiEndpointRequest: S.Schema<PutOpenaiProxyRouteOpenaiEndpointRequest>;
+export interface PutOpenaiProxyRouteOpenaiEndpointResponse {
+    body: unknown;
+}
+export declare const PutOpenaiProxyRouteOpenaiEndpointResponse: S.Schema<PutOpenaiProxyRouteOpenaiEndpointResponse>;
+export interface PutTypesafeProxyRouteTypesafeEndpointRequest {
+    endpoint: string;
+}
+export declare const PutTypesafeProxyRouteTypesafeEndpointRequest: S.Schema<PutTypesafeProxyRouteTypesafeEndpointRequest>;
+export interface PutTypesafeProxyRouteTypesafeEndpointResponse {
+    body: unknown;
+}
+export declare const PutTypesafeProxyRouteTypesafeEndpointResponse: S.Schema<PutTypesafeProxyRouteTypesafeEndpointResponse>;
+export interface PutVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointRequest {
+    endpoint: string;
+}
+export declare const PutVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointRequest: S.Schema<PutVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointRequest>;
+export interface PutVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointResponse {
+    body: unknown;
+}
+export declare const PutVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointResponse: S.Schema<PutVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointResponse>;
+export interface PutVertexProxyRouteVertexAiEndpointRequest {
+    endpoint: string;
+}
+export declare const PutVertexProxyRouteVertexAiEndpointRequest: S.Schema<PutVertexProxyRouteVertexAiEndpointRequest>;
+export interface PutVertexProxyRouteVertexAiEndpointResponse {
+    body: unknown;
+}
+export declare const PutVertexProxyRouteVertexAiEndpointResponse: S.Schema<PutVertexProxyRouteVertexAiEndpointResponse>;
+export interface PutVllmProxyRouteVllmEndpointRequest {
+    endpoint: string;
+}
+export declare const PutVllmProxyRouteVllmEndpointRequest: S.Schema<PutVllmProxyRouteVllmEndpointRequest>;
+export interface PutVllmProxyRouteVllmEndpointResponse {
+    body: unknown;
+}
+export declare const PutVllmProxyRouteVllmEndpointResponse: S.Schema<PutVllmProxyRouteVllmEndpointResponse>;
+export interface PutWatsonxProxyRouteWatsonxEndpointRequest {
+    endpoint: string;
+}
+export declare const PutWatsonxProxyRouteWatsonxEndpointRequest: S.Schema<PutWatsonxProxyRouteWatsonxEndpointRequest>;
+export interface PutWatsonxProxyRouteWatsonxEndpointResponse {
+    body: unknown;
+}
+export declare const PutWatsonxProxyRouteWatsonxEndpointResponse: S.Schema<PutWatsonxProxyRouteWatsonxEndpointResponse>;
+export type CreateRealtimeClientSecretOpenaiV1RealtimeClientSecretsPostError = LitellmOpError;
+/** Create Realtime Client Secret */
+export declare const createRealtimeClientSecretOpenaiV1RealtimeClientSecretsPost: API.OperationMethod<CreateRealtimeClientSecretOpenaiV1RealtimeClientSecretsPostRequest, RealtimeClientSecretResponse, CreateRealtimeClientSecretOpenaiV1RealtimeClientSecretsPostError, LitellmOpContext>;
+export type CreateRealtimeTranscriptionSessionOpenaiV1RealtimeTranscriptionSessionsPostError = LitellmOpError;
+/** Create Realtime Transcription Session Create an ephemeral Realtime transcription session (POST /v1/realtime/transcription_sessions) for the WebRTC/WebSocket flow. Mirrors the client_secrets route but targets the transcription_sessions endpoint and encrypts the ephemeral key returned under `client_secret.value`. */
+export declare const createRealtimeTranscriptionSessionOpenaiV1RealtimeTranscriptionSessionsPost: API.OperationMethod<CreateRealtimeTranscriptionSessionOpenaiV1RealtimeTranscriptionSessionsPostRequest, RealtimeTranscriptionSessionResponse, CreateRealtimeTranscriptionSessionOpenaiV1RealtimeTranscriptionSessionsPostError, LitellmOpContext>;
+export type DeleteAnthropicProxyRouteAnthropicEndpointError = UnprocessableEntity | LitellmOpError;
+/** Anthropic Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/anthropic_completion) */
+export declare const deleteAnthropicProxyRouteAnthropicEndpoint: API.OperationMethod<DeleteAnthropicProxyRouteAnthropicEndpointRequest, DeleteAnthropicProxyRouteAnthropicEndpointResponse, DeleteAnthropicProxyRouteAnthropicEndpointError, LitellmOpContext>;
+export type DeleteAssemblyaiProxyRouteAssemblyaiEndpointError = UnprocessableEntity | LitellmOpError;
+/** Assemblyai Proxy Route */
+export declare const deleteAssemblyaiProxyRouteAssemblyaiEndpoint: API.OperationMethod<DeleteAssemblyaiProxyRouteAssemblyaiEndpointRequest, DeleteAssemblyaiProxyRouteAssemblyaiEndpointResponse, DeleteAssemblyaiProxyRouteAssemblyaiEndpointError, LitellmOpContext>;
+export type DeleteAssemblyaiProxyRouteEuAssemblyaiEndpointError = UnprocessableEntity | LitellmOpError;
+/** Assemblyai Proxy Route */
+export declare const deleteAssemblyaiProxyRouteEuAssemblyaiEndpoint: API.OperationMethod<DeleteAssemblyaiProxyRouteEuAssemblyaiEndpointRequest, DeleteAssemblyaiProxyRouteEuAssemblyaiEndpointResponse, DeleteAssemblyaiProxyRouteEuAssemblyaiEndpointError, LitellmOpContext>;
+export type DeleteAzureProxyRouteAzureAiEndpointError = UnprocessableEntity | LitellmOpError;
+/** Azure Proxy Route Call any azure endpoint using the proxy. Just use `{PROXY_BASE_URL}/azure/{endpoint:path}` Checks if the deployment id in the url is a litellm model name. If so, it will route using the llm_router.allm_passthrough_route. */
+export declare const deleteAzureProxyRouteAzureAiEndpoint: API.OperationMethod<DeleteAzureProxyRouteAzureAiEndpointRequest, DeleteAzureProxyRouteAzureAiEndpointResponse, DeleteAzureProxyRouteAzureAiEndpointError, LitellmOpContext>;
+export type DeleteAzureProxyRouteAzureEndpointError = UnprocessableEntity | LitellmOpError;
+/** Azure Proxy Route Call any azure endpoint using the proxy. Just use `{PROXY_BASE_URL}/azure/{endpoint:path}` Checks if the deployment id in the url is a litellm model name. If so, it will route using the llm_router.allm_passthrough_route. */
+export declare const deleteAzureProxyRouteAzureEndpoint: API.OperationMethod<DeleteAzureProxyRouteAzureEndpointRequest, DeleteAzureProxyRouteAzureEndpointResponse, DeleteAzureProxyRouteAzureEndpointError, LitellmOpContext>;
+export type DeleteAzureSpeechProxyRouteAzureSpeechEndpointError = UnprocessableEntity | LitellmOpError;
+/** Azure Speech Proxy Route Pass-through for the Azure AI Speech REST APIs (speech to text), e.g. `POST /azure_speech/speech/recognition/conversation/cognitiveservices/v1?language=en-US` with the raw audio as the body, or `POST /azure_speech/speechtotext/v3.2/transcriptions`. The body is forwarded byte for byte and the proxy injects its own `Ocp-Apim-Subscription-Key`; the caller's `Authorization` header is the LiteLLM key and is never forwarded. [Docs](https://docs.litellm.ai/docs/pass_through/azure_speech) */
+export declare const deleteAzureSpeechProxyRouteAzureSpeechEndpoint: API.OperationMethod<DeleteAzureSpeechProxyRouteAzureSpeechEndpointRequest, DeleteAzureSpeechProxyRouteAzureSpeechEndpointResponse, DeleteAzureSpeechProxyRouteAzureSpeechEndpointError, LitellmOpContext>;
+export type DeleteBedrockProxyRouteBedrockEndpointError = UnprocessableEntity | LitellmOpError;
+/** Bedrock Proxy Route This is the v1 passthrough for Bedrock. V2 is handled by the `/bedrock/v2` endpoint. [Docs](https://docs.litellm.ai/docs/pass_through/bedrock) */
+export declare const deleteBedrockProxyRouteBedrockEndpoint: API.OperationMethod<DeleteBedrockProxyRouteBedrockEndpointRequest, DeleteBedrockProxyRouteBedrockEndpointResponse, DeleteBedrockProxyRouteBedrockEndpointError, LitellmOpContext>;
+export type DeleteCohereProxyRouteCohereEndpointError = UnprocessableEntity | LitellmOpError;
+/** Cohere Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/cohere) */
+export declare const deleteCohereProxyRouteCohereEndpoint: API.OperationMethod<DeleteCohereProxyRouteCohereEndpointRequest, DeleteCohereProxyRouteCohereEndpointResponse, DeleteCohereProxyRouteCohereEndpointError, LitellmOpContext>;
+export type DeleteCursorProxyRouteCursorEndpointError = UnprocessableEntity | LitellmOpError;
+/** Cursor Proxy Route Pass-through endpoint for the Cursor Cloud Agents API. Supports all Cursor Cloud Agents endpoints: - GET /v0/agents — List agents - POST /v0/agents — Launch an agent - GET /v0/agents/{id} — Agent status - GET /v0/agents/{id}/conversation — Agent conversation - POST /v0/agents/{id}/followup — Add follow-up - POST /v0/agents/{id}/stop — Stop an agent - DELETE /v0/agents/{id} — Delete an agent - GET /v0/me — API key info - GET /v0/models — List models - GET /v0/repositories — List GitHub repositories Uses Basic Authentication (base64-encoded `API_KEY:`). Credential lookup order: 1. passthrough_endpoint_router (config.yaml deployments with use_in_pass_through) 2. litellm.credential_list (credentials added via UI) 3. CURSOR_API_KEY environment variable */
+export declare const deleteCursorProxyRouteCursorEndpoint: API.OperationMethod<DeleteCursorProxyRouteCursorEndpointRequest, DeleteCursorProxyRouteCursorEndpointResponse, DeleteCursorProxyRouteCursorEndpointError, LitellmOpContext>;
+export type DeleteGeminiProxyRouteGeminiEndpointError = UnprocessableEntity | LitellmOpError;
+/** Gemini Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/google_ai_studio) */
+export declare const deleteGeminiProxyRouteGeminiEndpoint: API.OperationMethod<DeleteGeminiProxyRouteGeminiEndpointRequest, DeleteGeminiProxyRouteGeminiEndpointResponse, DeleteGeminiProxyRouteGeminiEndpointError, LitellmOpContext>;
+export type DeleteGigachatProxyRouteGigachatEndpointError = UnprocessableEntity | LitellmOpError;
+/** Gigachat Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/gigachat) */
+export declare const deleteGigachatProxyRouteGigachatEndpoint: API.OperationMethod<DeleteGigachatProxyRouteGigachatEndpointRequest, DeleteGigachatProxyRouteGigachatEndpointResponse, DeleteGigachatProxyRouteGigachatEndpointError, LitellmOpContext>;
+export type DeleteMilvusProxyRouteMilvusEndpointError = UnprocessableEntity | LitellmOpError;
+/** Milvus Proxy Route Enable using Milvus `/vectors` endpoint as a pass-through endpoint. */
+export declare const deleteMilvusProxyRouteMilvusEndpoint: API.OperationMethod<DeleteMilvusProxyRouteMilvusEndpointRequest, DeleteMilvusProxyRouteMilvusEndpointResponse, DeleteMilvusProxyRouteMilvusEndpointError, LitellmOpContext>;
+export type DeleteMistralProxyRouteMistralEndpointError = UnprocessableEntity | LitellmOpError;
+/** Mistral Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/mistral) */
+export declare const deleteMistralProxyRouteMistralEndpoint: API.OperationMethod<DeleteMistralProxyRouteMistralEndpointRequest, DeleteMistralProxyRouteMistralEndpointResponse, DeleteMistralProxyRouteMistralEndpointError, LitellmOpContext>;
+export type DeleteNvidiaNimProxyRouteNvidiaNimEndpointError = UnprocessableEntity | LitellmOpError;
+/** Nvidia Nim Proxy Route Relay a native NVIDIA NIM request through a LiteLLM model group. `{PROXY_BASE_URL}/nvidia_nim/{model_group}/v1/infer` forwards the body unchanged to the deployment's `api_base`, so object detection and OCR NIMs whose payload carries no `model` field still go through virtual key auth, model access checks, and spend logging. */
+export declare const deleteNvidiaNimProxyRouteNvidiaNimEndpoint: API.OperationMethod<DeleteNvidiaNimProxyRouteNvidiaNimEndpointRequest, DeleteNvidiaNimProxyRouteNvidiaNimEndpointResponse, DeleteNvidiaNimProxyRouteNvidiaNimEndpointError, LitellmOpContext>;
+export type DeleteOpenaiProxyRouteOpenaiEndpointError = UnprocessableEntity | LitellmOpError;
+/** Openai Proxy Route Pass-through endpoint for OpenAI API calls. Available on both routes: - /openai/{endpoint:path} - Standard OpenAI passthrough route - /openai_passthrough/{endpoint:path} - Dedicated passthrough route (recommended for Responses API) Use /openai_passthrough/* when you need guaranteed passthrough to OpenAI without conflicts with LiteLLM's native implementations (e.g., for the Responses API at /v1/responses). Examples: Standard route: - /openai/v1/chat/completions - /openai/v1/assistants - /openai/v1/threads Dedicated passthrough (for Responses API): - /openai_passthrough/v1/responses - /openai_passthrough/v1/responses/{response_id} - /openai_passthrough/v1/responses/{response_id}/input_items [Docs](https://docs.litellm.ai/docs/pass_through/openai_passthrough) */
+export declare const deleteOpenaiProxyRouteOpenaiEndpoint: API.OperationMethod<DeleteOpenaiProxyRouteOpenaiEndpointRequest, DeleteOpenaiProxyRouteOpenaiEndpointResponse, DeleteOpenaiProxyRouteOpenaiEndpointError, LitellmOpContext>;
+export type DeleteTypesafeProxyRouteTypesafeEndpointError = UnprocessableEntity | LitellmOpError;
+/** Typesafe Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/typesafe) */
+export declare const deleteTypesafeProxyRouteTypesafeEndpoint: API.OperationMethod<DeleteTypesafeProxyRouteTypesafeEndpointRequest, DeleteTypesafeProxyRouteTypesafeEndpointResponse, DeleteTypesafeProxyRouteTypesafeEndpointError, LitellmOpContext>;
+export type DeleteVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointError = UnprocessableEntity | LitellmOpError;
+/** Vertex Discovery Proxy Route Call any vertex discovery endpoint using the proxy. Just use `{PROXY_BASE_URL}/vertex_ai/discovery/{endpoint:path}` Target url: `https://discoveryengine.googleapis.com` */
+export declare const deleteVertexDiscoveryProxyRouteVertexAiDiscoveryEndpoint: API.OperationMethod<DeleteVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointRequest, DeleteVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointResponse, DeleteVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointError, LitellmOpContext>;
+export type DeleteVertexProxyRouteVertexAiEndpointError = UnprocessableEntity | LitellmOpError;
+/** Vertex Proxy Route Call LiteLLM proxy via Vertex AI SDK. [Docs](https://docs.litellm.ai/docs/pass_through/vertex_ai) */
+export declare const deleteVertexProxyRouteVertexAiEndpoint: API.OperationMethod<DeleteVertexProxyRouteVertexAiEndpointRequest, DeleteVertexProxyRouteVertexAiEndpointResponse, DeleteVertexProxyRouteVertexAiEndpointError, LitellmOpContext>;
+export type DeleteVllmProxyRouteVllmEndpointError = UnprocessableEntity | LitellmOpError;
+/** Vllm Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/vllm) */
+export declare const deleteVllmProxyRouteVllmEndpoint: API.OperationMethod<DeleteVllmProxyRouteVllmEndpointRequest, DeleteVllmProxyRouteVllmEndpointResponse, DeleteVllmProxyRouteVllmEndpointError, LitellmOpContext>;
+export type DeleteWatsonxProxyRouteWatsonxEndpointError = UnprocessableEntity | LitellmOpError;
+/** Watsonx Proxy Route Watsonx pass-through endpoint. Allows using Watsonx APIs with automatic IAM token management and version parameter injection. Example: POST /watsonx/ml/v1/text/tokenization POST /watsonx/ml/v1/text/generation */
+export declare const deleteWatsonxProxyRouteWatsonxEndpoint: API.OperationMethod<DeleteWatsonxProxyRouteWatsonxEndpointRequest, DeleteWatsonxProxyRouteWatsonxEndpointResponse, DeleteWatsonxProxyRouteWatsonxEndpointError, LitellmOpContext>;
+export type GetAnthropicProxyRouteAnthropicEndpointError = UnprocessableEntity | LitellmOpError;
+/** Anthropic Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/anthropic_completion) */
+export declare const getAnthropicProxyRouteAnthropicEndpoint: API.OperationMethod<GetAnthropicProxyRouteAnthropicEndpointRequest, GetAnthropicProxyRouteAnthropicEndpointResponse, GetAnthropicProxyRouteAnthropicEndpointError, LitellmOpContext>;
+export type GetAssemblyaiProxyRouteAssemblyaiEndpointError = UnprocessableEntity | LitellmOpError;
+/** Assemblyai Proxy Route */
+export declare const getAssemblyaiProxyRouteAssemblyaiEndpoint: API.OperationMethod<GetAssemblyaiProxyRouteAssemblyaiEndpointRequest, GetAssemblyaiProxyRouteAssemblyaiEndpointResponse, GetAssemblyaiProxyRouteAssemblyaiEndpointError, LitellmOpContext>;
+export type GetAssemblyaiProxyRouteEuAssemblyaiEndpointError = UnprocessableEntity | LitellmOpError;
+/** Assemblyai Proxy Route */
+export declare const getAssemblyaiProxyRouteEuAssemblyaiEndpoint: API.OperationMethod<GetAssemblyaiProxyRouteEuAssemblyaiEndpointRequest, GetAssemblyaiProxyRouteEuAssemblyaiEndpointResponse, GetAssemblyaiProxyRouteEuAssemblyaiEndpointError, LitellmOpContext>;
+export type GetAzureProxyRouteAzureAiEndpointError = UnprocessableEntity | LitellmOpError;
+/** Azure Proxy Route Call any azure endpoint using the proxy. Just use `{PROXY_BASE_URL}/azure/{endpoint:path}` Checks if the deployment id in the url is a litellm model name. If so, it will route using the llm_router.allm_passthrough_route. */
+export declare const getAzureProxyRouteAzureAiEndpoint: API.OperationMethod<GetAzureProxyRouteAzureAiEndpointRequest, GetAzureProxyRouteAzureAiEndpointResponse, GetAzureProxyRouteAzureAiEndpointError, LitellmOpContext>;
+export type GetAzureProxyRouteAzureEndpointError = UnprocessableEntity | LitellmOpError;
+/** Azure Proxy Route Call any azure endpoint using the proxy. Just use `{PROXY_BASE_URL}/azure/{endpoint:path}` Checks if the deployment id in the url is a litellm model name. If so, it will route using the llm_router.allm_passthrough_route. */
+export declare const getAzureProxyRouteAzureEndpoint: API.OperationMethod<GetAzureProxyRouteAzureEndpointRequest, GetAzureProxyRouteAzureEndpointResponse, GetAzureProxyRouteAzureEndpointError, LitellmOpContext>;
+export type GetAzureSpeechProxyRouteAzureSpeechEndpointError = UnprocessableEntity | LitellmOpError;
+/** Azure Speech Proxy Route Pass-through for the Azure AI Speech REST APIs (speech to text), e.g. `POST /azure_speech/speech/recognition/conversation/cognitiveservices/v1?language=en-US` with the raw audio as the body, or `POST /azure_speech/speechtotext/v3.2/transcriptions`. The body is forwarded byte for byte and the proxy injects its own `Ocp-Apim-Subscription-Key`; the caller's `Authorization` header is the LiteLLM key and is never forwarded. [Docs](https://docs.litellm.ai/docs/pass_through/azure_speech) */
+export declare const getAzureSpeechProxyRouteAzureSpeechEndpoint: API.OperationMethod<GetAzureSpeechProxyRouteAzureSpeechEndpointRequest, GetAzureSpeechProxyRouteAzureSpeechEndpointResponse, GetAzureSpeechProxyRouteAzureSpeechEndpointError, LitellmOpContext>;
+export type GetBedrockProxyRouteBedrockEndpointError = UnprocessableEntity | LitellmOpError;
+/** Bedrock Proxy Route This is the v1 passthrough for Bedrock. V2 is handled by the `/bedrock/v2` endpoint. [Docs](https://docs.litellm.ai/docs/pass_through/bedrock) */
+export declare const getBedrockProxyRouteBedrockEndpoint: API.OperationMethod<GetBedrockProxyRouteBedrockEndpointRequest, GetBedrockProxyRouteBedrockEndpointResponse, GetBedrockProxyRouteBedrockEndpointError, LitellmOpContext>;
+export type GetCohereProxyRouteCohereEndpointError = UnprocessableEntity | LitellmOpError;
+/** Cohere Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/cohere) */
+export declare const getCohereProxyRouteCohereEndpoint: API.OperationMethod<GetCohereProxyRouteCohereEndpointRequest, GetCohereProxyRouteCohereEndpointResponse, GetCohereProxyRouteCohereEndpointError, LitellmOpContext>;
+export type GetCursorProxyRouteCursorEndpointError = UnprocessableEntity | LitellmOpError;
+/** Cursor Proxy Route Pass-through endpoint for the Cursor Cloud Agents API. Supports all Cursor Cloud Agents endpoints: - GET /v0/agents — List agents - POST /v0/agents — Launch an agent - GET /v0/agents/{id} — Agent status - GET /v0/agents/{id}/conversation — Agent conversation - POST /v0/agents/{id}/followup — Add follow-up - POST /v0/agents/{id}/stop — Stop an agent - DELETE /v0/agents/{id} — Delete an agent - GET /v0/me — API key info - GET /v0/models — List models - GET /v0/repositories — List GitHub repositories Uses Basic Authentication (base64-encoded `API_KEY:`). Credential lookup order: 1. passthrough_endpoint_router (config.yaml deployments with use_in_pass_through) 2. litellm.credential_list (credentials added via UI) 3. CURSOR_API_KEY environment variable */
+export declare const getCursorProxyRouteCursorEndpoint: API.OperationMethod<GetCursorProxyRouteCursorEndpointRequest, GetCursorProxyRouteCursorEndpointResponse, GetCursorProxyRouteCursorEndpointError, LitellmOpContext>;
+export type GetGeminiProxyRouteGeminiEndpointError = UnprocessableEntity | LitellmOpError;
+/** Gemini Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/google_ai_studio) */
+export declare const getGeminiProxyRouteGeminiEndpoint: API.OperationMethod<GetGeminiProxyRouteGeminiEndpointRequest, GetGeminiProxyRouteGeminiEndpointResponse, GetGeminiProxyRouteGeminiEndpointError, LitellmOpContext>;
+export type GetGigachatProxyRouteGigachatEndpointError = UnprocessableEntity | LitellmOpError;
+/** Gigachat Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/gigachat) */
+export declare const getGigachatProxyRouteGigachatEndpoint: API.OperationMethod<GetGigachatProxyRouteGigachatEndpointRequest, GetGigachatProxyRouteGigachatEndpointResponse, GetGigachatProxyRouteGigachatEndpointError, LitellmOpContext>;
+export type GetMilvusProxyRouteMilvusEndpointError = UnprocessableEntity | LitellmOpError;
+/** Milvus Proxy Route Enable using Milvus `/vectors` endpoint as a pass-through endpoint. */
+export declare const getMilvusProxyRouteMilvusEndpoint: API.OperationMethod<GetMilvusProxyRouteMilvusEndpointRequest, GetMilvusProxyRouteMilvusEndpointResponse, GetMilvusProxyRouteMilvusEndpointError, LitellmOpContext>;
+export type GetMistralProxyRouteMistralEndpointError = UnprocessableEntity | LitellmOpError;
+/** Mistral Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/mistral) */
+export declare const getMistralProxyRouteMistralEndpoint: API.OperationMethod<GetMistralProxyRouteMistralEndpointRequest, GetMistralProxyRouteMistralEndpointResponse, GetMistralProxyRouteMistralEndpointError, LitellmOpContext>;
+export type GetNvidiaNimProxyRouteNvidiaNimEndpointError = UnprocessableEntity | LitellmOpError;
+/** Nvidia Nim Proxy Route Relay a native NVIDIA NIM request through a LiteLLM model group. `{PROXY_BASE_URL}/nvidia_nim/{model_group}/v1/infer` forwards the body unchanged to the deployment's `api_base`, so object detection and OCR NIMs whose payload carries no `model` field still go through virtual key auth, model access checks, and spend logging. */
+export declare const getNvidiaNimProxyRouteNvidiaNimEndpoint: API.OperationMethod<GetNvidiaNimProxyRouteNvidiaNimEndpointRequest, GetNvidiaNimProxyRouteNvidiaNimEndpointResponse, GetNvidiaNimProxyRouteNvidiaNimEndpointError, LitellmOpContext>;
+export type GetOpenaiProxyRouteOpenaiEndpointError = UnprocessableEntity | LitellmOpError;
+/** Openai Proxy Route Pass-through endpoint for OpenAI API calls. Available on both routes: - /openai/{endpoint:path} - Standard OpenAI passthrough route - /openai_passthrough/{endpoint:path} - Dedicated passthrough route (recommended for Responses API) Use /openai_passthrough/* when you need guaranteed passthrough to OpenAI without conflicts with LiteLLM's native implementations (e.g., for the Responses API at /v1/responses). Examples: Standard route: - /openai/v1/chat/completions - /openai/v1/assistants - /openai/v1/threads Dedicated passthrough (for Responses API): - /openai_passthrough/v1/responses - /openai_passthrough/v1/responses/{response_id} - /openai_passthrough/v1/responses/{response_id}/input_items [Docs](https://docs.litellm.ai/docs/pass_through/openai_passthrough) */
+export declare const getOpenaiProxyRouteOpenaiEndpoint: API.OperationMethod<GetOpenaiProxyRouteOpenaiEndpointRequest, GetOpenaiProxyRouteOpenaiEndpointResponse, GetOpenaiProxyRouteOpenaiEndpointError, LitellmOpContext>;
+export type GetTypesafeProxyRouteTypesafeEndpointError = UnprocessableEntity | LitellmOpError;
+/** Typesafe Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/typesafe) */
+export declare const getTypesafeProxyRouteTypesafeEndpoint: API.OperationMethod<GetTypesafeProxyRouteTypesafeEndpointRequest, GetTypesafeProxyRouteTypesafeEndpointResponse, GetTypesafeProxyRouteTypesafeEndpointError, LitellmOpContext>;
+export type GetVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointError = UnprocessableEntity | LitellmOpError;
+/** Vertex Discovery Proxy Route Call any vertex discovery endpoint using the proxy. Just use `{PROXY_BASE_URL}/vertex_ai/discovery/{endpoint:path}` Target url: `https://discoveryengine.googleapis.com` */
+export declare const getVertexDiscoveryProxyRouteVertexAiDiscoveryEndpoint: API.OperationMethod<GetVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointRequest, GetVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointResponse, GetVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointError, LitellmOpContext>;
+export type GetVertexProxyRouteVertexAiEndpointError = UnprocessableEntity | LitellmOpError;
+/** Vertex Proxy Route Call LiteLLM proxy via Vertex AI SDK. [Docs](https://docs.litellm.ai/docs/pass_through/vertex_ai) */
+export declare const getVertexProxyRouteVertexAiEndpoint: API.OperationMethod<GetVertexProxyRouteVertexAiEndpointRequest, GetVertexProxyRouteVertexAiEndpointResponse, GetVertexProxyRouteVertexAiEndpointError, LitellmOpContext>;
+export type GetVllmProxyRouteVllmEndpointError = UnprocessableEntity | LitellmOpError;
+/** Vllm Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/vllm) */
+export declare const getVllmProxyRouteVllmEndpoint: API.OperationMethod<GetVllmProxyRouteVllmEndpointRequest, GetVllmProxyRouteVllmEndpointResponse, GetVllmProxyRouteVllmEndpointError, LitellmOpContext>;
+export type GetWatsonxProxyRouteWatsonxEndpointError = UnprocessableEntity | LitellmOpError;
+/** Watsonx Proxy Route Watsonx pass-through endpoint. Allows using Watsonx APIs with automatic IAM token management and version parameter injection. Example: POST /watsonx/ml/v1/text/tokenization POST /watsonx/ml/v1/text/generation */
+export declare const getWatsonxProxyRouteWatsonxEndpoint: API.OperationMethod<GetWatsonxProxyRouteWatsonxEndpointRequest, GetWatsonxProxyRouteWatsonxEndpointResponse, GetWatsonxProxyRouteWatsonxEndpointError, LitellmOpContext>;
+export type PatchAnthropicProxyRouteAnthropicEndpointError = UnprocessableEntity | LitellmOpError;
+/** Anthropic Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/anthropic_completion) */
+export declare const patchAnthropicProxyRouteAnthropicEndpoint: API.OperationMethod<PatchAnthropicProxyRouteAnthropicEndpointRequest, PatchAnthropicProxyRouteAnthropicEndpointResponse, PatchAnthropicProxyRouteAnthropicEndpointError, LitellmOpContext>;
+export type PatchAssemblyaiProxyRouteAssemblyaiEndpointError = UnprocessableEntity | LitellmOpError;
+/** Assemblyai Proxy Route */
+export declare const patchAssemblyaiProxyRouteAssemblyaiEndpoint: API.OperationMethod<PatchAssemblyaiProxyRouteAssemblyaiEndpointRequest, PatchAssemblyaiProxyRouteAssemblyaiEndpointResponse, PatchAssemblyaiProxyRouteAssemblyaiEndpointError, LitellmOpContext>;
+export type PatchAssemblyaiProxyRouteEuAssemblyaiEndpointError = UnprocessableEntity | LitellmOpError;
+/** Assemblyai Proxy Route */
+export declare const patchAssemblyaiProxyRouteEuAssemblyaiEndpoint: API.OperationMethod<PatchAssemblyaiProxyRouteEuAssemblyaiEndpointRequest, PatchAssemblyaiProxyRouteEuAssemblyaiEndpointResponse, PatchAssemblyaiProxyRouteEuAssemblyaiEndpointError, LitellmOpContext>;
+export type PatchAzureProxyRouteAzureAiEndpointError = UnprocessableEntity | LitellmOpError;
+/** Azure Proxy Route Call any azure endpoint using the proxy. Just use `{PROXY_BASE_URL}/azure/{endpoint:path}` Checks if the deployment id in the url is a litellm model name. If so, it will route using the llm_router.allm_passthrough_route. */
+export declare const patchAzureProxyRouteAzureAiEndpoint: API.OperationMethod<PatchAzureProxyRouteAzureAiEndpointRequest, PatchAzureProxyRouteAzureAiEndpointResponse, PatchAzureProxyRouteAzureAiEndpointError, LitellmOpContext>;
+export type PatchAzureProxyRouteAzureEndpointError = UnprocessableEntity | LitellmOpError;
+/** Azure Proxy Route Call any azure endpoint using the proxy. Just use `{PROXY_BASE_URL}/azure/{endpoint:path}` Checks if the deployment id in the url is a litellm model name. If so, it will route using the llm_router.allm_passthrough_route. */
+export declare const patchAzureProxyRouteAzureEndpoint: API.OperationMethod<PatchAzureProxyRouteAzureEndpointRequest, PatchAzureProxyRouteAzureEndpointResponse, PatchAzureProxyRouteAzureEndpointError, LitellmOpContext>;
+export type PatchAzureSpeechProxyRouteAzureSpeechEndpointError = UnprocessableEntity | LitellmOpError;
+/** Azure Speech Proxy Route Pass-through for the Azure AI Speech REST APIs (speech to text), e.g. `POST /azure_speech/speech/recognition/conversation/cognitiveservices/v1?language=en-US` with the raw audio as the body, or `POST /azure_speech/speechtotext/v3.2/transcriptions`. The body is forwarded byte for byte and the proxy injects its own `Ocp-Apim-Subscription-Key`; the caller's `Authorization` header is the LiteLLM key and is never forwarded. [Docs](https://docs.litellm.ai/docs/pass_through/azure_speech) */
+export declare const patchAzureSpeechProxyRouteAzureSpeechEndpoint: API.OperationMethod<PatchAzureSpeechProxyRouteAzureSpeechEndpointRequest, PatchAzureSpeechProxyRouteAzureSpeechEndpointResponse, PatchAzureSpeechProxyRouteAzureSpeechEndpointError, LitellmOpContext>;
+export type PatchBedrockProxyRouteBedrockEndpointError = UnprocessableEntity | LitellmOpError;
+/** Bedrock Proxy Route This is the v1 passthrough for Bedrock. V2 is handled by the `/bedrock/v2` endpoint. [Docs](https://docs.litellm.ai/docs/pass_through/bedrock) */
+export declare const patchBedrockProxyRouteBedrockEndpoint: API.OperationMethod<PatchBedrockProxyRouteBedrockEndpointRequest, PatchBedrockProxyRouteBedrockEndpointResponse, PatchBedrockProxyRouteBedrockEndpointError, LitellmOpContext>;
+export type PatchCohereProxyRouteCohereEndpointError = UnprocessableEntity | LitellmOpError;
+/** Cohere Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/cohere) */
+export declare const patchCohereProxyRouteCohereEndpoint: API.OperationMethod<PatchCohereProxyRouteCohereEndpointRequest, PatchCohereProxyRouteCohereEndpointResponse, PatchCohereProxyRouteCohereEndpointError, LitellmOpContext>;
+export type PatchCursorProxyRouteCursorEndpointError = UnprocessableEntity | LitellmOpError;
+/** Cursor Proxy Route Pass-through endpoint for the Cursor Cloud Agents API. Supports all Cursor Cloud Agents endpoints: - GET /v0/agents — List agents - POST /v0/agents — Launch an agent - GET /v0/agents/{id} — Agent status - GET /v0/agents/{id}/conversation — Agent conversation - POST /v0/agents/{id}/followup — Add follow-up - POST /v0/agents/{id}/stop — Stop an agent - DELETE /v0/agents/{id} — Delete an agent - GET /v0/me — API key info - GET /v0/models — List models - GET /v0/repositories — List GitHub repositories Uses Basic Authentication (base64-encoded `API_KEY:`). Credential lookup order: 1. passthrough_endpoint_router (config.yaml deployments with use_in_pass_through) 2. litellm.credential_list (credentials added via UI) 3. CURSOR_API_KEY environment variable */
+export declare const patchCursorProxyRouteCursorEndpoint: API.OperationMethod<PatchCursorProxyRouteCursorEndpointRequest, PatchCursorProxyRouteCursorEndpointResponse, PatchCursorProxyRouteCursorEndpointError, LitellmOpContext>;
+export type PatchGeminiProxyRouteGeminiEndpointError = UnprocessableEntity | LitellmOpError;
+/** Gemini Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/google_ai_studio) */
+export declare const patchGeminiProxyRouteGeminiEndpoint: API.OperationMethod<PatchGeminiProxyRouteGeminiEndpointRequest, PatchGeminiProxyRouteGeminiEndpointResponse, PatchGeminiProxyRouteGeminiEndpointError, LitellmOpContext>;
+export type PatchGigachatProxyRouteGigachatEndpointError = UnprocessableEntity | LitellmOpError;
+/** Gigachat Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/gigachat) */
+export declare const patchGigachatProxyRouteGigachatEndpoint: API.OperationMethod<PatchGigachatProxyRouteGigachatEndpointRequest, PatchGigachatProxyRouteGigachatEndpointResponse, PatchGigachatProxyRouteGigachatEndpointError, LitellmOpContext>;
+export type PatchMilvusProxyRouteMilvusEndpointError = UnprocessableEntity | LitellmOpError;
+/** Milvus Proxy Route Enable using Milvus `/vectors` endpoint as a pass-through endpoint. */
+export declare const patchMilvusProxyRouteMilvusEndpoint: API.OperationMethod<PatchMilvusProxyRouteMilvusEndpointRequest, PatchMilvusProxyRouteMilvusEndpointResponse, PatchMilvusProxyRouteMilvusEndpointError, LitellmOpContext>;
+export type PatchMistralProxyRouteMistralEndpointError = UnprocessableEntity | LitellmOpError;
+/** Mistral Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/mistral) */
+export declare const patchMistralProxyRouteMistralEndpoint: API.OperationMethod<PatchMistralProxyRouteMistralEndpointRequest, PatchMistralProxyRouteMistralEndpointResponse, PatchMistralProxyRouteMistralEndpointError, LitellmOpContext>;
+export type PatchNvidiaNimProxyRouteNvidiaNimEndpointError = UnprocessableEntity | LitellmOpError;
+/** Nvidia Nim Proxy Route Relay a native NVIDIA NIM request through a LiteLLM model group. `{PROXY_BASE_URL}/nvidia_nim/{model_group}/v1/infer` forwards the body unchanged to the deployment's `api_base`, so object detection and OCR NIMs whose payload carries no `model` field still go through virtual key auth, model access checks, and spend logging. */
+export declare const patchNvidiaNimProxyRouteNvidiaNimEndpoint: API.OperationMethod<PatchNvidiaNimProxyRouteNvidiaNimEndpointRequest, PatchNvidiaNimProxyRouteNvidiaNimEndpointResponse, PatchNvidiaNimProxyRouteNvidiaNimEndpointError, LitellmOpContext>;
+export type PatchOpenaiProxyRouteOpenaiEndpointError = UnprocessableEntity | LitellmOpError;
+/** Openai Proxy Route Pass-through endpoint for OpenAI API calls. Available on both routes: - /openai/{endpoint:path} - Standard OpenAI passthrough route - /openai_passthrough/{endpoint:path} - Dedicated passthrough route (recommended for Responses API) Use /openai_passthrough/* when you need guaranteed passthrough to OpenAI without conflicts with LiteLLM's native implementations (e.g., for the Responses API at /v1/responses). Examples: Standard route: - /openai/v1/chat/completions - /openai/v1/assistants - /openai/v1/threads Dedicated passthrough (for Responses API): - /openai_passthrough/v1/responses - /openai_passthrough/v1/responses/{response_id} - /openai_passthrough/v1/responses/{response_id}/input_items [Docs](https://docs.litellm.ai/docs/pass_through/openai_passthrough) */
+export declare const patchOpenaiProxyRouteOpenaiEndpoint: API.OperationMethod<PatchOpenaiProxyRouteOpenaiEndpointRequest, PatchOpenaiProxyRouteOpenaiEndpointResponse, PatchOpenaiProxyRouteOpenaiEndpointError, LitellmOpContext>;
+export type PatchTypesafeProxyRouteTypesafeEndpointError = UnprocessableEntity | LitellmOpError;
+/** Typesafe Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/typesafe) */
+export declare const patchTypesafeProxyRouteTypesafeEndpoint: API.OperationMethod<PatchTypesafeProxyRouteTypesafeEndpointRequest, PatchTypesafeProxyRouteTypesafeEndpointResponse, PatchTypesafeProxyRouteTypesafeEndpointError, LitellmOpContext>;
+export type PatchVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointError = UnprocessableEntity | LitellmOpError;
+/** Vertex Discovery Proxy Route Call any vertex discovery endpoint using the proxy. Just use `{PROXY_BASE_URL}/vertex_ai/discovery/{endpoint:path}` Target url: `https://discoveryengine.googleapis.com` */
+export declare const patchVertexDiscoveryProxyRouteVertexAiDiscoveryEndpoint: API.OperationMethod<PatchVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointRequest, PatchVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointResponse, PatchVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointError, LitellmOpContext>;
+export type PatchVertexProxyRouteVertexAiEndpointError = UnprocessableEntity | LitellmOpError;
+/** Vertex Proxy Route Call LiteLLM proxy via Vertex AI SDK. [Docs](https://docs.litellm.ai/docs/pass_through/vertex_ai) */
+export declare const patchVertexProxyRouteVertexAiEndpoint: API.OperationMethod<PatchVertexProxyRouteVertexAiEndpointRequest, PatchVertexProxyRouteVertexAiEndpointResponse, PatchVertexProxyRouteVertexAiEndpointError, LitellmOpContext>;
+export type PatchVllmProxyRouteVllmEndpointError = UnprocessableEntity | LitellmOpError;
+/** Vllm Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/vllm) */
+export declare const patchVllmProxyRouteVllmEndpoint: API.OperationMethod<PatchVllmProxyRouteVllmEndpointRequest, PatchVllmProxyRouteVllmEndpointResponse, PatchVllmProxyRouteVllmEndpointError, LitellmOpContext>;
+export type PatchWatsonxProxyRouteWatsonxEndpointError = UnprocessableEntity | LitellmOpError;
+/** Watsonx Proxy Route Watsonx pass-through endpoint. Allows using Watsonx APIs with automatic IAM token management and version parameter injection. Example: POST /watsonx/ml/v1/text/tokenization POST /watsonx/ml/v1/text/generation */
+export declare const patchWatsonxProxyRouteWatsonxEndpoint: API.OperationMethod<PatchWatsonxProxyRouteWatsonxEndpointRequest, PatchWatsonxProxyRouteWatsonxEndpointResponse, PatchWatsonxProxyRouteWatsonxEndpointError, LitellmOpContext>;
+export type PostAnthropicProxyRouteAnthropicEndpointError = UnprocessableEntity | LitellmOpError;
+/** Anthropic Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/anthropic_completion) */
+export declare const postAnthropicProxyRouteAnthropicEndpoint: API.OperationMethod<PostAnthropicProxyRouteAnthropicEndpointRequest, PostAnthropicProxyRouteAnthropicEndpointResponse, PostAnthropicProxyRouteAnthropicEndpointError, LitellmOpContext>;
+export type PostAssemblyaiProxyRouteAssemblyaiEndpointError = UnprocessableEntity | LitellmOpError;
+/** Assemblyai Proxy Route */
+export declare const postAssemblyaiProxyRouteAssemblyaiEndpoint: API.OperationMethod<PostAssemblyaiProxyRouteAssemblyaiEndpointRequest, PostAssemblyaiProxyRouteAssemblyaiEndpointResponse, PostAssemblyaiProxyRouteAssemblyaiEndpointError, LitellmOpContext>;
+export type PostAssemblyaiProxyRouteEuAssemblyaiEndpointError = UnprocessableEntity | LitellmOpError;
+/** Assemblyai Proxy Route */
+export declare const postAssemblyaiProxyRouteEuAssemblyaiEndpoint: API.OperationMethod<PostAssemblyaiProxyRouteEuAssemblyaiEndpointRequest, PostAssemblyaiProxyRouteEuAssemblyaiEndpointResponse, PostAssemblyaiProxyRouteEuAssemblyaiEndpointError, LitellmOpContext>;
+export type PostAzureProxyRouteAzureAiEndpointError = UnprocessableEntity | LitellmOpError;
+/** Azure Proxy Route Call any azure endpoint using the proxy. Just use `{PROXY_BASE_URL}/azure/{endpoint:path}` Checks if the deployment id in the url is a litellm model name. If so, it will route using the llm_router.allm_passthrough_route. */
+export declare const postAzureProxyRouteAzureAiEndpoint: API.OperationMethod<PostAzureProxyRouteAzureAiEndpointRequest, PostAzureProxyRouteAzureAiEndpointResponse, PostAzureProxyRouteAzureAiEndpointError, LitellmOpContext>;
+export type PostAzureProxyRouteAzureEndpointError = UnprocessableEntity | LitellmOpError;
+/** Azure Proxy Route Call any azure endpoint using the proxy. Just use `{PROXY_BASE_URL}/azure/{endpoint:path}` Checks if the deployment id in the url is a litellm model name. If so, it will route using the llm_router.allm_passthrough_route. */
+export declare const postAzureProxyRouteAzureEndpoint: API.OperationMethod<PostAzureProxyRouteAzureEndpointRequest, PostAzureProxyRouteAzureEndpointResponse, PostAzureProxyRouteAzureEndpointError, LitellmOpContext>;
+export type PostAzureSpeechProxyRouteAzureSpeechEndpointError = UnprocessableEntity | LitellmOpError;
+/** Azure Speech Proxy Route Pass-through for the Azure AI Speech REST APIs (speech to text), e.g. `POST /azure_speech/speech/recognition/conversation/cognitiveservices/v1?language=en-US` with the raw audio as the body, or `POST /azure_speech/speechtotext/v3.2/transcriptions`. The body is forwarded byte for byte and the proxy injects its own `Ocp-Apim-Subscription-Key`; the caller's `Authorization` header is the LiteLLM key and is never forwarded. [Docs](https://docs.litellm.ai/docs/pass_through/azure_speech) */
+export declare const postAzureSpeechProxyRouteAzureSpeechEndpoint: API.OperationMethod<PostAzureSpeechProxyRouteAzureSpeechEndpointRequest, PostAzureSpeechProxyRouteAzureSpeechEndpointResponse, PostAzureSpeechProxyRouteAzureSpeechEndpointError, LitellmOpContext>;
+export type PostBedrockProxyRouteBedrockEndpointError = UnprocessableEntity | LitellmOpError;
+/** Bedrock Proxy Route This is the v1 passthrough for Bedrock. V2 is handled by the `/bedrock/v2` endpoint. [Docs](https://docs.litellm.ai/docs/pass_through/bedrock) */
+export declare const postBedrockProxyRouteBedrockEndpoint: API.OperationMethod<PostBedrockProxyRouteBedrockEndpointRequest, PostBedrockProxyRouteBedrockEndpointResponse, PostBedrockProxyRouteBedrockEndpointError, LitellmOpContext>;
+export type PostCohereProxyRouteCohereEndpointError = UnprocessableEntity | LitellmOpError;
+/** Cohere Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/cohere) */
+export declare const postCohereProxyRouteCohereEndpoint: API.OperationMethod<PostCohereProxyRouteCohereEndpointRequest, PostCohereProxyRouteCohereEndpointResponse, PostCohereProxyRouteCohereEndpointError, LitellmOpContext>;
+export type PostComprehendMedicalProxyRouteComprehendmedicalOperationError = UnprocessableEntity | LitellmOpError;
+/** Comprehend Medical Proxy Route Pass-through for Amazon Comprehend Medical, e.g. `POST /comprehendmedical/DetectEntitiesV2`. The request body is forwarded as-is to the AWS JSON 1.1 API and signed with SigV4 using the proxy's AWS credentials. [Docs](https://docs.litellm.ai/docs/pass_through/comprehend_medical) */
+export declare const postComprehendMedicalProxyRouteComprehendmedicalOperation: API.OperationMethod<PostComprehendMedicalProxyRouteComprehendmedicalOperationRequest, PostComprehendMedicalProxyRouteComprehendmedicalOperationResponse, PostComprehendMedicalProxyRouteComprehendmedicalOperationError, LitellmOpContext>;
+export type PostComprehendMedicalSdkProxyRouteComprehendmedicalError = LitellmOpError;
+/** Comprehend Medical Sdk Proxy Route AWS-SDK-shaped pass-through for Amazon Comprehend Medical: point the SDK's `endpoint_url` at `/comprehendmedical` and the operation is read from the `X-Amz-Target` header, per the AWS JSON 1.1 protocol. [Docs](https://docs.litellm.ai/docs/pass_through/comprehend_medical) */
+export declare const postComprehendMedicalSdkProxyRouteComprehendmedical: API.OperationMethod<PostComprehendMedicalSdkProxyRouteComprehendmedicalRequest, PostComprehendMedicalSdkProxyRouteComprehendmedicalResponse, PostComprehendMedicalSdkProxyRouteComprehendmedicalError, LitellmOpContext>;
+export type PostCursorProxyRouteCursorEndpointError = UnprocessableEntity | LitellmOpError;
+/** Cursor Proxy Route Pass-through endpoint for the Cursor Cloud Agents API. Supports all Cursor Cloud Agents endpoints: - GET /v0/agents — List agents - POST /v0/agents — Launch an agent - GET /v0/agents/{id} — Agent status - GET /v0/agents/{id}/conversation — Agent conversation - POST /v0/agents/{id}/followup — Add follow-up - POST /v0/agents/{id}/stop — Stop an agent - DELETE /v0/agents/{id} — Delete an agent - GET /v0/me — API key info - GET /v0/models — List models - GET /v0/repositories — List GitHub repositories Uses Basic Authentication (base64-encoded `API_KEY:`). Credential lookup order: 1. passthrough_endpoint_router (config.yaml deployments with use_in_pass_through) 2. litellm.credential_list (credentials added via UI) 3. CURSOR_API_KEY environment variable */
+export declare const postCursorProxyRouteCursorEndpoint: API.OperationMethod<PostCursorProxyRouteCursorEndpointRequest, PostCursorProxyRouteCursorEndpointResponse, PostCursorProxyRouteCursorEndpointError, LitellmOpContext>;
+export type PostGeminiProxyRouteGeminiEndpointError = UnprocessableEntity | LitellmOpError;
+/** Gemini Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/google_ai_studio) */
+export declare const postGeminiProxyRouteGeminiEndpoint: API.OperationMethod<PostGeminiProxyRouteGeminiEndpointRequest, PostGeminiProxyRouteGeminiEndpointResponse, PostGeminiProxyRouteGeminiEndpointError, LitellmOpContext>;
+export type PostGigachatProxyRouteGigachatEndpointError = UnprocessableEntity | LitellmOpError;
+/** Gigachat Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/gigachat) */
+export declare const postGigachatProxyRouteGigachatEndpoint: API.OperationMethod<PostGigachatProxyRouteGigachatEndpointRequest, PostGigachatProxyRouteGigachatEndpointResponse, PostGigachatProxyRouteGigachatEndpointError, LitellmOpContext>;
+export type PostMilvusProxyRouteMilvusEndpointError = UnprocessableEntity | LitellmOpError;
+/** Milvus Proxy Route Enable using Milvus `/vectors` endpoint as a pass-through endpoint. */
+export declare const postMilvusProxyRouteMilvusEndpoint: API.OperationMethod<PostMilvusProxyRouteMilvusEndpointRequest, PostMilvusProxyRouteMilvusEndpointResponse, PostMilvusProxyRouteMilvusEndpointError, LitellmOpContext>;
+export type PostMistralProxyRouteMistralEndpointError = UnprocessableEntity | LitellmOpError;
+/** Mistral Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/mistral) */
+export declare const postMistralProxyRouteMistralEndpoint: API.OperationMethod<PostMistralProxyRouteMistralEndpointRequest, PostMistralProxyRouteMistralEndpointResponse, PostMistralProxyRouteMistralEndpointError, LitellmOpContext>;
+export type PostNvidiaNimProxyRouteNvidiaNimEndpointError = UnprocessableEntity | LitellmOpError;
+/** Nvidia Nim Proxy Route Relay a native NVIDIA NIM request through a LiteLLM model group. `{PROXY_BASE_URL}/nvidia_nim/{model_group}/v1/infer` forwards the body unchanged to the deployment's `api_base`, so object detection and OCR NIMs whose payload carries no `model` field still go through virtual key auth, model access checks, and spend logging. */
+export declare const postNvidiaNimProxyRouteNvidiaNimEndpoint: API.OperationMethod<PostNvidiaNimProxyRouteNvidiaNimEndpointRequest, PostNvidiaNimProxyRouteNvidiaNimEndpointResponse, PostNvidiaNimProxyRouteNvidiaNimEndpointError, LitellmOpContext>;
+export type PostOpenaiProxyRouteOpenaiEndpointError = UnprocessableEntity | LitellmOpError;
+/** Openai Proxy Route Pass-through endpoint for OpenAI API calls. Available on both routes: - /openai/{endpoint:path} - Standard OpenAI passthrough route - /openai_passthrough/{endpoint:path} - Dedicated passthrough route (recommended for Responses API) Use /openai_passthrough/* when you need guaranteed passthrough to OpenAI without conflicts with LiteLLM's native implementations (e.g., for the Responses API at /v1/responses). Examples: Standard route: - /openai/v1/chat/completions - /openai/v1/assistants - /openai/v1/threads Dedicated passthrough (for Responses API): - /openai_passthrough/v1/responses - /openai_passthrough/v1/responses/{response_id} - /openai_passthrough/v1/responses/{response_id}/input_items [Docs](https://docs.litellm.ai/docs/pass_through/openai_passthrough) */
+export declare const postOpenaiProxyRouteOpenaiEndpoint: API.OperationMethod<PostOpenaiProxyRouteOpenaiEndpointRequest, PostOpenaiProxyRouteOpenaiEndpointResponse, PostOpenaiProxyRouteOpenaiEndpointError, LitellmOpContext>;
+export type PostProxyRealtimeCallsOpenaiV1RealtimeCallError = LitellmOpError;
+/** Proxy Realtime Calls */
+export declare const postProxyRealtimeCallsOpenaiV1RealtimeCall: API.OperationMethod<PostProxyRealtimeCallsOpenaiV1RealtimeCallRequest, PostProxyRealtimeCallsOpenaiV1RealtimeCallResponse, PostProxyRealtimeCallsOpenaiV1RealtimeCallError, LitellmOpContext>;
+export type PostTranscribeProxyRouteTranscribeOperationError = UnprocessableEntity | LitellmOpError;
+/** Transcribe Proxy Route Pass-through for the Amazon Transcribe API, e.g. `POST /transcribe/StartTranscriptionJob`. The request body is forwarded to the AWS JSON 1.1 API and signed with SigV4 using the proxy's AWS credentials. Standard jobs are tagged with the calling key's owner so that only that owner (or a proxy admin) can read or delete them, and keys other than proxy admins may only read media from and write transcripts to the S3 buckets listed in `general_settings.transcribe_media_buckets`; account-wide operations such as ListTranscriptionJobs are limited to proxy admins. Streaming transcription (`transcribestreaming`) uses a separate HTTP/2 event-stream protocol and is not served by this route. [Docs](https://docs.litellm.ai/docs/pass_through/transcribe) */
+export declare const postTranscribeProxyRouteTranscribeOperation: API.OperationMethod<PostTranscribeProxyRouteTranscribeOperationRequest, PostTranscribeProxyRouteTranscribeOperationResponse, PostTranscribeProxyRouteTranscribeOperationError, LitellmOpContext>;
+export type PostTranscribeSdkProxyRouteTranscribeError = LitellmOpError;
+/** Transcribe Sdk Proxy Route AWS-SDK-shaped pass-through for Amazon Transcribe: point the SDK's `endpoint_url` at `/transcribe` and the operation is read from the `X-Amz-Target` header, per the AWS JSON 1.1 protocol. [Docs](https://docs.litellm.ai/docs/pass_through/transcribe) */
+export declare const postTranscribeSdkProxyRouteTranscribe: API.OperationMethod<PostTranscribeSdkProxyRouteTranscribeRequest, PostTranscribeSdkProxyRouteTranscribeResponse, PostTranscribeSdkProxyRouteTranscribeError, LitellmOpContext>;
+export type PostTypesafeProxyRouteTypesafeEndpointError = UnprocessableEntity | LitellmOpError;
+/** Typesafe Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/typesafe) */
+export declare const postTypesafeProxyRouteTypesafeEndpoint: API.OperationMethod<PostTypesafeProxyRouteTypesafeEndpointRequest, PostTypesafeProxyRouteTypesafeEndpointResponse, PostTypesafeProxyRouteTypesafeEndpointError, LitellmOpContext>;
+export type PostVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointError = UnprocessableEntity | LitellmOpError;
+/** Vertex Discovery Proxy Route Call any vertex discovery endpoint using the proxy. Just use `{PROXY_BASE_URL}/vertex_ai/discovery/{endpoint:path}` Target url: `https://discoveryengine.googleapis.com` */
+export declare const postVertexDiscoveryProxyRouteVertexAiDiscoveryEndpoint: API.OperationMethod<PostVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointRequest, PostVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointResponse, PostVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointError, LitellmOpContext>;
+export type PostVertexProxyRouteVertexAiEndpointError = UnprocessableEntity | LitellmOpError;
+/** Vertex Proxy Route Call LiteLLM proxy via Vertex AI SDK. [Docs](https://docs.litellm.ai/docs/pass_through/vertex_ai) */
+export declare const postVertexProxyRouteVertexAiEndpoint: API.OperationMethod<PostVertexProxyRouteVertexAiEndpointRequest, PostVertexProxyRouteVertexAiEndpointResponse, PostVertexProxyRouteVertexAiEndpointError, LitellmOpContext>;
+export type PostVllmProxyRouteVllmEndpointError = UnprocessableEntity | LitellmOpError;
+/** Vllm Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/vllm) */
+export declare const postVllmProxyRouteVllmEndpoint: API.OperationMethod<PostVllmProxyRouteVllmEndpointRequest, PostVllmProxyRouteVllmEndpointResponse, PostVllmProxyRouteVllmEndpointError, LitellmOpContext>;
+export type PostWatsonxProxyRouteWatsonxEndpointError = UnprocessableEntity | LitellmOpError;
+/** Watsonx Proxy Route Watsonx pass-through endpoint. Allows using Watsonx APIs with automatic IAM token management and version parameter injection. Example: POST /watsonx/ml/v1/text/tokenization POST /watsonx/ml/v1/text/generation */
+export declare const postWatsonxProxyRouteWatsonxEndpoint: API.OperationMethod<PostWatsonxProxyRouteWatsonxEndpointRequest, PostWatsonxProxyRouteWatsonxEndpointResponse, PostWatsonxProxyRouteWatsonxEndpointError, LitellmOpContext>;
+export type PutAnthropicProxyRouteAnthropicEndpointError = UnprocessableEntity | LitellmOpError;
+/** Anthropic Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/anthropic_completion) */
+export declare const putAnthropicProxyRouteAnthropicEndpoint: API.OperationMethod<PutAnthropicProxyRouteAnthropicEndpointRequest, PutAnthropicProxyRouteAnthropicEndpointResponse, PutAnthropicProxyRouteAnthropicEndpointError, LitellmOpContext>;
+export type PutAssemblyaiProxyRouteAssemblyaiEndpointError = UnprocessableEntity | LitellmOpError;
+/** Assemblyai Proxy Route */
+export declare const putAssemblyaiProxyRouteAssemblyaiEndpoint: API.OperationMethod<PutAssemblyaiProxyRouteAssemblyaiEndpointRequest, PutAssemblyaiProxyRouteAssemblyaiEndpointResponse, PutAssemblyaiProxyRouteAssemblyaiEndpointError, LitellmOpContext>;
+export type PutAssemblyaiProxyRouteEuAssemblyaiEndpointError = UnprocessableEntity | LitellmOpError;
+/** Assemblyai Proxy Route */
+export declare const putAssemblyaiProxyRouteEuAssemblyaiEndpoint: API.OperationMethod<PutAssemblyaiProxyRouteEuAssemblyaiEndpointRequest, PutAssemblyaiProxyRouteEuAssemblyaiEndpointResponse, PutAssemblyaiProxyRouteEuAssemblyaiEndpointError, LitellmOpContext>;
+export type PutAzureProxyRouteAzureAiEndpointError = UnprocessableEntity | LitellmOpError;
+/** Azure Proxy Route Call any azure endpoint using the proxy. Just use `{PROXY_BASE_URL}/azure/{endpoint:path}` Checks if the deployment id in the url is a litellm model name. If so, it will route using the llm_router.allm_passthrough_route. */
+export declare const putAzureProxyRouteAzureAiEndpoint: API.OperationMethod<PutAzureProxyRouteAzureAiEndpointRequest, PutAzureProxyRouteAzureAiEndpointResponse, PutAzureProxyRouteAzureAiEndpointError, LitellmOpContext>;
+export type PutAzureProxyRouteAzureEndpointError = UnprocessableEntity | LitellmOpError;
+/** Azure Proxy Route Call any azure endpoint using the proxy. Just use `{PROXY_BASE_URL}/azure/{endpoint:path}` Checks if the deployment id in the url is a litellm model name. If so, it will route using the llm_router.allm_passthrough_route. */
+export declare const putAzureProxyRouteAzureEndpoint: API.OperationMethod<PutAzureProxyRouteAzureEndpointRequest, PutAzureProxyRouteAzureEndpointResponse, PutAzureProxyRouteAzureEndpointError, LitellmOpContext>;
+export type PutAzureSpeechProxyRouteAzureSpeechEndpointError = UnprocessableEntity | LitellmOpError;
+/** Azure Speech Proxy Route Pass-through for the Azure AI Speech REST APIs (speech to text), e.g. `POST /azure_speech/speech/recognition/conversation/cognitiveservices/v1?language=en-US` with the raw audio as the body, or `POST /azure_speech/speechtotext/v3.2/transcriptions`. The body is forwarded byte for byte and the proxy injects its own `Ocp-Apim-Subscription-Key`; the caller's `Authorization` header is the LiteLLM key and is never forwarded. [Docs](https://docs.litellm.ai/docs/pass_through/azure_speech) */
+export declare const putAzureSpeechProxyRouteAzureSpeechEndpoint: API.OperationMethod<PutAzureSpeechProxyRouteAzureSpeechEndpointRequest, PutAzureSpeechProxyRouteAzureSpeechEndpointResponse, PutAzureSpeechProxyRouteAzureSpeechEndpointError, LitellmOpContext>;
+export type PutBedrockProxyRouteBedrockEndpointError = UnprocessableEntity | LitellmOpError;
+/** Bedrock Proxy Route This is the v1 passthrough for Bedrock. V2 is handled by the `/bedrock/v2` endpoint. [Docs](https://docs.litellm.ai/docs/pass_through/bedrock) */
+export declare const putBedrockProxyRouteBedrockEndpoint: API.OperationMethod<PutBedrockProxyRouteBedrockEndpointRequest, PutBedrockProxyRouteBedrockEndpointResponse, PutBedrockProxyRouteBedrockEndpointError, LitellmOpContext>;
+export type PutCohereProxyRouteCohereEndpointError = UnprocessableEntity | LitellmOpError;
+/** Cohere Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/cohere) */
+export declare const putCohereProxyRouteCohereEndpoint: API.OperationMethod<PutCohereProxyRouteCohereEndpointRequest, PutCohereProxyRouteCohereEndpointResponse, PutCohereProxyRouteCohereEndpointError, LitellmOpContext>;
+export type PutCursorProxyRouteCursorEndpointError = UnprocessableEntity | LitellmOpError;
+/** Cursor Proxy Route Pass-through endpoint for the Cursor Cloud Agents API. Supports all Cursor Cloud Agents endpoints: - GET /v0/agents — List agents - POST /v0/agents — Launch an agent - GET /v0/agents/{id} — Agent status - GET /v0/agents/{id}/conversation — Agent conversation - POST /v0/agents/{id}/followup — Add follow-up - POST /v0/agents/{id}/stop — Stop an agent - DELETE /v0/agents/{id} — Delete an agent - GET /v0/me — API key info - GET /v0/models — List models - GET /v0/repositories — List GitHub repositories Uses Basic Authentication (base64-encoded `API_KEY:`). Credential lookup order: 1. passthrough_endpoint_router (config.yaml deployments with use_in_pass_through) 2. litellm.credential_list (credentials added via UI) 3. CURSOR_API_KEY environment variable */
+export declare const putCursorProxyRouteCursorEndpoint: API.OperationMethod<PutCursorProxyRouteCursorEndpointRequest, PutCursorProxyRouteCursorEndpointResponse, PutCursorProxyRouteCursorEndpointError, LitellmOpContext>;
+export type PutGeminiProxyRouteGeminiEndpointError = UnprocessableEntity | LitellmOpError;
+/** Gemini Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/google_ai_studio) */
+export declare const putGeminiProxyRouteGeminiEndpoint: API.OperationMethod<PutGeminiProxyRouteGeminiEndpointRequest, PutGeminiProxyRouteGeminiEndpointResponse, PutGeminiProxyRouteGeminiEndpointError, LitellmOpContext>;
+export type PutGigachatProxyRouteGigachatEndpointError = UnprocessableEntity | LitellmOpError;
+/** Gigachat Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/gigachat) */
+export declare const putGigachatProxyRouteGigachatEndpoint: API.OperationMethod<PutGigachatProxyRouteGigachatEndpointRequest, PutGigachatProxyRouteGigachatEndpointResponse, PutGigachatProxyRouteGigachatEndpointError, LitellmOpContext>;
+export type PutMilvusProxyRouteMilvusEndpointError = UnprocessableEntity | LitellmOpError;
+/** Milvus Proxy Route Enable using Milvus `/vectors` endpoint as a pass-through endpoint. */
+export declare const putMilvusProxyRouteMilvusEndpoint: API.OperationMethod<PutMilvusProxyRouteMilvusEndpointRequest, PutMilvusProxyRouteMilvusEndpointResponse, PutMilvusProxyRouteMilvusEndpointError, LitellmOpContext>;
+export type PutMistralProxyRouteMistralEndpointError = UnprocessableEntity | LitellmOpError;
+/** Mistral Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/mistral) */
+export declare const putMistralProxyRouteMistralEndpoint: API.OperationMethod<PutMistralProxyRouteMistralEndpointRequest, PutMistralProxyRouteMistralEndpointResponse, PutMistralProxyRouteMistralEndpointError, LitellmOpContext>;
+export type PutNvidiaNimProxyRouteNvidiaNimEndpointError = UnprocessableEntity | LitellmOpError;
+/** Nvidia Nim Proxy Route Relay a native NVIDIA NIM request through a LiteLLM model group. `{PROXY_BASE_URL}/nvidia_nim/{model_group}/v1/infer` forwards the body unchanged to the deployment's `api_base`, so object detection and OCR NIMs whose payload carries no `model` field still go through virtual key auth, model access checks, and spend logging. */
+export declare const putNvidiaNimProxyRouteNvidiaNimEndpoint: API.OperationMethod<PutNvidiaNimProxyRouteNvidiaNimEndpointRequest, PutNvidiaNimProxyRouteNvidiaNimEndpointResponse, PutNvidiaNimProxyRouteNvidiaNimEndpointError, LitellmOpContext>;
+export type PutOpenaiProxyRouteOpenaiEndpointError = UnprocessableEntity | LitellmOpError;
+/** Openai Proxy Route Pass-through endpoint for OpenAI API calls. Available on both routes: - /openai/{endpoint:path} - Standard OpenAI passthrough route - /openai_passthrough/{endpoint:path} - Dedicated passthrough route (recommended for Responses API) Use /openai_passthrough/* when you need guaranteed passthrough to OpenAI without conflicts with LiteLLM's native implementations (e.g., for the Responses API at /v1/responses). Examples: Standard route: - /openai/v1/chat/completions - /openai/v1/assistants - /openai/v1/threads Dedicated passthrough (for Responses API): - /openai_passthrough/v1/responses - /openai_passthrough/v1/responses/{response_id} - /openai_passthrough/v1/responses/{response_id}/input_items [Docs](https://docs.litellm.ai/docs/pass_through/openai_passthrough) */
+export declare const putOpenaiProxyRouteOpenaiEndpoint: API.OperationMethod<PutOpenaiProxyRouteOpenaiEndpointRequest, PutOpenaiProxyRouteOpenaiEndpointResponse, PutOpenaiProxyRouteOpenaiEndpointError, LitellmOpContext>;
+export type PutTypesafeProxyRouteTypesafeEndpointError = UnprocessableEntity | LitellmOpError;
+/** Typesafe Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/typesafe) */
+export declare const putTypesafeProxyRouteTypesafeEndpoint: API.OperationMethod<PutTypesafeProxyRouteTypesafeEndpointRequest, PutTypesafeProxyRouteTypesafeEndpointResponse, PutTypesafeProxyRouteTypesafeEndpointError, LitellmOpContext>;
+export type PutVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointError = UnprocessableEntity | LitellmOpError;
+/** Vertex Discovery Proxy Route Call any vertex discovery endpoint using the proxy. Just use `{PROXY_BASE_URL}/vertex_ai/discovery/{endpoint:path}` Target url: `https://discoveryengine.googleapis.com` */
+export declare const putVertexDiscoveryProxyRouteVertexAiDiscoveryEndpoint: API.OperationMethod<PutVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointRequest, PutVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointResponse, PutVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointError, LitellmOpContext>;
+export type PutVertexProxyRouteVertexAiEndpointError = UnprocessableEntity | LitellmOpError;
+/** Vertex Proxy Route Call LiteLLM proxy via Vertex AI SDK. [Docs](https://docs.litellm.ai/docs/pass_through/vertex_ai) */
+export declare const putVertexProxyRouteVertexAiEndpoint: API.OperationMethod<PutVertexProxyRouteVertexAiEndpointRequest, PutVertexProxyRouteVertexAiEndpointResponse, PutVertexProxyRouteVertexAiEndpointError, LitellmOpContext>;
+export type PutVllmProxyRouteVllmEndpointError = UnprocessableEntity | LitellmOpError;
+/** Vllm Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/vllm) */
+export declare const putVllmProxyRouteVllmEndpoint: API.OperationMethod<PutVllmProxyRouteVllmEndpointRequest, PutVllmProxyRouteVllmEndpointResponse, PutVllmProxyRouteVllmEndpointError, LitellmOpContext>;
+export type PutWatsonxProxyRouteWatsonxEndpointError = UnprocessableEntity | LitellmOpError;
+/** Watsonx Proxy Route Watsonx pass-through endpoint. Allows using Watsonx APIs with automatic IAM token management and version parameter injection. Example: POST /watsonx/ml/v1/text/tokenization POST /watsonx/ml/v1/text/generation */
+export declare const putWatsonxProxyRouteWatsonxEndpoint: API.OperationMethod<PutWatsonxProxyRouteWatsonxEndpointRequest, PutWatsonxProxyRouteWatsonxEndpointResponse, PutWatsonxProxyRouteWatsonxEndpointError, LitellmOpContext>;
+//# sourceMappingURL=llm_passthrough.d.ts.map