@homeflare/distilled-litellm 0.2.0 → 0.4.0

package/src/services/llm_passthrough.ts

@@ -0,0 +1,4542 @@
+// AUTO-GENERATED by scripts/generate.ts from .generated-specs (pinned litellm-openapi @ 1.103.0 — see README). Do not edit.
+import * as S from "@distilled.cloud/core/schema";
+import * as API from "@distilled.cloud/core/api";
+import * as C from "@distilled.cloud/core/category";
+import * as T from "../traits.ts";
+import {
+  LitellmProtocol,
+  type LitellmOpError,
+  type LitellmOpContext,
+} from "../protocol.ts";
+import * as Retry from "../retry.ts";
+
+export type { LitellmOpError, LitellmOpContext };
+
+export class UnprocessableEntity
+  extends /*@__PURE__*/ T.applyErrorMatchers(
+    /*@__PURE__*/ S.TaggedError<UnprocessableEntity>()("UnprocessableEntity", {
+      code: S.Number,
+      message: S.String,
+    }).pipe(C.withBadRequestError),
+    [{ status: 422 }],
+  ) {}
+
+export interface CreateRealtimeClientSecretOpenaiV1RealtimeClientSecretsPostRequest {}
+export const CreateRealtimeClientSecretOpenaiV1RealtimeClientSecretsPostRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({}).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/openai/v1/realtime/client_secrets",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier:
+      "CreateRealtimeClientSecretOpenaiV1RealtimeClientSecretsPostRequest",
+  }) as any as S.Schema<CreateRealtimeClientSecretOpenaiV1RealtimeClientSecretsPostRequest>;
+
+export type RealtimeClientSecretResponseSessionMap = {
+  [key: string]: unknown | undefined;
+};
+export const RealtimeClientSecretResponseSessionMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.Unknown,
+) as any as 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 const RealtimeClientSecretResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    expires_at: S.optional(S.NullOr(S.Number)),
+    session: S.optional(S.NullOr(RealtimeClientSecretResponseSessionMap)),
+    value: S.String,
+  }),
+).annotate({
+  identifier: "RealtimeClientSecretResponse",
+}) as any as S.Schema<RealtimeClientSecretResponse>;
+
+export interface CreateRealtimeTranscriptionSessionOpenaiV1RealtimeTranscriptionSessionsPostRequest {}
+export const CreateRealtimeTranscriptionSessionOpenaiV1RealtimeTranscriptionSessionsPostRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({}).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/openai/v1/realtime/transcription_sessions",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier:
+      "CreateRealtimeTranscriptionSessionOpenaiV1RealtimeTranscriptionSessionsPostRequest",
+  }) as any as S.Schema<CreateRealtimeTranscriptionSessionOpenaiV1RealtimeTranscriptionSessionsPostRequest>;
+
+export type RealtimeTranscriptionSessionResponseClientSecretMap = {
+  [key: string]: unknown | undefined;
+};
+export const RealtimeTranscriptionSessionResponseClientSecretMap =
+  /*@__PURE__*/ S.Record(
+    S.String,
+    S.Unknown,
+  ) as any as 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 const RealtimeTranscriptionSessionResponse = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      client_secret: S.optional(
+        S.NullOr(RealtimeTranscriptionSessionResponseClientSecretMap),
+      ),
+    }),
+).annotate({
+  identifier: "RealtimeTranscriptionSessionResponse",
+}) as any as S.Schema<RealtimeTranscriptionSessionResponse>;
+
+export interface DeleteAnthropicProxyRouteAnthropicEndpointRequest {
+  endpoint: string;
+}
+export const DeleteAnthropicProxyRouteAnthropicEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({ method: "DELETE", uri: "/anthropic/{endpoint}", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "DeleteAnthropicProxyRouteAnthropicEndpointRequest",
+  }) as any as S.Schema<DeleteAnthropicProxyRouteAnthropicEndpointRequest>;
+
+export interface DeleteAnthropicProxyRouteAnthropicEndpointResponse {
+  body: unknown;
+}
+export const DeleteAnthropicProxyRouteAnthropicEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "DeleteAnthropicProxyRouteAnthropicEndpointResponse",
+  }) as any as S.Schema<DeleteAnthropicProxyRouteAnthropicEndpointResponse>;
+
+export interface DeleteAssemblyaiProxyRouteAssemblyaiEndpointRequest {
+  endpoint: string;
+}
+export const DeleteAssemblyaiProxyRouteAssemblyaiEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({ method: "DELETE", uri: "/assemblyai/{endpoint}", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "DeleteAssemblyaiProxyRouteAssemblyaiEndpointRequest",
+  }) as any as S.Schema<DeleteAssemblyaiProxyRouteAssemblyaiEndpointRequest>;
+
+export interface DeleteAssemblyaiProxyRouteAssemblyaiEndpointResponse {
+  body: unknown;
+}
+export const DeleteAssemblyaiProxyRouteAssemblyaiEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "DeleteAssemblyaiProxyRouteAssemblyaiEndpointResponse",
+  }) as any as S.Schema<DeleteAssemblyaiProxyRouteAssemblyaiEndpointResponse>;
+
+export interface DeleteAssemblyaiProxyRouteEuAssemblyaiEndpointRequest {
+  endpoint: string;
+}
+export const DeleteAssemblyaiProxyRouteEuAssemblyaiEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({ method: "DELETE", uri: "/eu.assemblyai/{endpoint}", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "DeleteAssemblyaiProxyRouteEuAssemblyaiEndpointRequest",
+  }) as any as S.Schema<DeleteAssemblyaiProxyRouteEuAssemblyaiEndpointRequest>;
+
+export interface DeleteAssemblyaiProxyRouteEuAssemblyaiEndpointResponse {
+  body: unknown;
+}
+export const DeleteAssemblyaiProxyRouteEuAssemblyaiEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "DeleteAssemblyaiProxyRouteEuAssemblyaiEndpointResponse",
+  }) as any as S.Schema<DeleteAssemblyaiProxyRouteEuAssemblyaiEndpointResponse>;
+
+export interface DeleteAzureProxyRouteAzureAiEndpointRequest {
+  endpoint: string;
+}
+export const DeleteAzureProxyRouteAzureAiEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({ method: "DELETE", uri: "/azure_ai/{endpoint}", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "DeleteAzureProxyRouteAzureAiEndpointRequest",
+  }) as any as S.Schema<DeleteAzureProxyRouteAzureAiEndpointRequest>;
+
+export interface DeleteAzureProxyRouteAzureAiEndpointResponse {
+  body: unknown;
+}
+export const DeleteAzureProxyRouteAzureAiEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "DeleteAzureProxyRouteAzureAiEndpointResponse",
+  }) as any as S.Schema<DeleteAzureProxyRouteAzureAiEndpointResponse>;
+
+export interface DeleteAzureProxyRouteAzureEndpointRequest {
+  endpoint: string;
+}
+export const DeleteAzureProxyRouteAzureEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "DELETE", uri: "/azure/{endpoint}", code: 200 })),
+  ).annotate({
+    identifier: "DeleteAzureProxyRouteAzureEndpointRequest",
+  }) as any as S.Schema<DeleteAzureProxyRouteAzureEndpointRequest>;
+
+export interface DeleteAzureProxyRouteAzureEndpointResponse {
+  body: unknown;
+}
+export const DeleteAzureProxyRouteAzureEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "DeleteAzureProxyRouteAzureEndpointResponse",
+  }) as any as S.Schema<DeleteAzureProxyRouteAzureEndpointResponse>;
+
+export interface DeleteAzureSpeechProxyRouteAzureSpeechEndpointRequest {
+  endpoint: string;
+}
+export const DeleteAzureSpeechProxyRouteAzureSpeechEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({ method: "DELETE", uri: "/azure_speech/{endpoint}", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "DeleteAzureSpeechProxyRouteAzureSpeechEndpointRequest",
+  }) as any as S.Schema<DeleteAzureSpeechProxyRouteAzureSpeechEndpointRequest>;
+
+export interface DeleteAzureSpeechProxyRouteAzureSpeechEndpointResponse {
+  body: unknown;
+}
+export const DeleteAzureSpeechProxyRouteAzureSpeechEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "DeleteAzureSpeechProxyRouteAzureSpeechEndpointResponse",
+  }) as any as S.Schema<DeleteAzureSpeechProxyRouteAzureSpeechEndpointResponse>;
+
+export interface DeleteBedrockProxyRouteBedrockEndpointRequest {
+  endpoint: string;
+}
+export const DeleteBedrockProxyRouteBedrockEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({ method: "DELETE", uri: "/bedrock/{endpoint}", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "DeleteBedrockProxyRouteBedrockEndpointRequest",
+  }) as any as S.Schema<DeleteBedrockProxyRouteBedrockEndpointRequest>;
+
+export interface DeleteBedrockProxyRouteBedrockEndpointResponse {
+  body: unknown;
+}
+export const DeleteBedrockProxyRouteBedrockEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "DeleteBedrockProxyRouteBedrockEndpointResponse",
+  }) as any as S.Schema<DeleteBedrockProxyRouteBedrockEndpointResponse>;
+
+export interface DeleteCohereProxyRouteCohereEndpointRequest {
+  endpoint: string;
+}
+export const DeleteCohereProxyRouteCohereEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "DELETE", uri: "/cohere/{endpoint}", code: 200 })),
+  ).annotate({
+    identifier: "DeleteCohereProxyRouteCohereEndpointRequest",
+  }) as any as S.Schema<DeleteCohereProxyRouteCohereEndpointRequest>;
+
+export interface DeleteCohereProxyRouteCohereEndpointResponse {
+  body: unknown;
+}
+export const DeleteCohereProxyRouteCohereEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "DeleteCohereProxyRouteCohereEndpointResponse",
+  }) as any as S.Schema<DeleteCohereProxyRouteCohereEndpointResponse>;
+
+export interface DeleteCursorProxyRouteCursorEndpointRequest {
+  endpoint: string;
+}
+export const DeleteCursorProxyRouteCursorEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "DELETE", uri: "/cursor/{endpoint}", code: 200 })),
+  ).annotate({
+    identifier: "DeleteCursorProxyRouteCursorEndpointRequest",
+  }) as any as S.Schema<DeleteCursorProxyRouteCursorEndpointRequest>;
+
+export interface DeleteCursorProxyRouteCursorEndpointResponse {
+  body: unknown;
+}
+export const DeleteCursorProxyRouteCursorEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "DeleteCursorProxyRouteCursorEndpointResponse",
+  }) as any as S.Schema<DeleteCursorProxyRouteCursorEndpointResponse>;
+
+export interface DeleteGeminiProxyRouteGeminiEndpointRequest {
+  endpoint: string;
+}
+export const DeleteGeminiProxyRouteGeminiEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "DELETE", uri: "/gemini/{endpoint}", code: 200 })),
+  ).annotate({
+    identifier: "DeleteGeminiProxyRouteGeminiEndpointRequest",
+  }) as any as S.Schema<DeleteGeminiProxyRouteGeminiEndpointRequest>;
+
+export interface DeleteGeminiProxyRouteGeminiEndpointResponse {
+  body: unknown;
+}
+export const DeleteGeminiProxyRouteGeminiEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "DeleteGeminiProxyRouteGeminiEndpointResponse",
+  }) as any as S.Schema<DeleteGeminiProxyRouteGeminiEndpointResponse>;
+
+export interface DeleteGigachatProxyRouteGigachatEndpointRequest {
+  endpoint: string;
+}
+export const DeleteGigachatProxyRouteGigachatEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({ method: "DELETE", uri: "/gigachat/{endpoint}", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "DeleteGigachatProxyRouteGigachatEndpointRequest",
+  }) as any as S.Schema<DeleteGigachatProxyRouteGigachatEndpointRequest>;
+
+export interface DeleteGigachatProxyRouteGigachatEndpointResponse {
+  body: unknown;
+}
+export const DeleteGigachatProxyRouteGigachatEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "DeleteGigachatProxyRouteGigachatEndpointResponse",
+  }) as any as S.Schema<DeleteGigachatProxyRouteGigachatEndpointResponse>;
+
+export interface DeleteMilvusProxyRouteMilvusEndpointRequest {
+  endpoint: string;
+}
+export const DeleteMilvusProxyRouteMilvusEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "DELETE", uri: "/milvus/{endpoint}", code: 200 })),
+  ).annotate({
+    identifier: "DeleteMilvusProxyRouteMilvusEndpointRequest",
+  }) as any as S.Schema<DeleteMilvusProxyRouteMilvusEndpointRequest>;
+
+export interface DeleteMilvusProxyRouteMilvusEndpointResponse {
+  body: unknown;
+}
+export const DeleteMilvusProxyRouteMilvusEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "DeleteMilvusProxyRouteMilvusEndpointResponse",
+  }) as any as S.Schema<DeleteMilvusProxyRouteMilvusEndpointResponse>;
+
+export interface DeleteMistralProxyRouteMistralEndpointRequest {
+  endpoint: string;
+}
+export const DeleteMistralProxyRouteMistralEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({ method: "DELETE", uri: "/mistral/{endpoint}", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "DeleteMistralProxyRouteMistralEndpointRequest",
+  }) as any as S.Schema<DeleteMistralProxyRouteMistralEndpointRequest>;
+
+export interface DeleteMistralProxyRouteMistralEndpointResponse {
+  body: unknown;
+}
+export const DeleteMistralProxyRouteMistralEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "DeleteMistralProxyRouteMistralEndpointResponse",
+  }) as any as S.Schema<DeleteMistralProxyRouteMistralEndpointResponse>;
+
+export interface DeleteNvidiaNimProxyRouteNvidiaNimEndpointRequest {
+  endpoint: string;
+}
+export const DeleteNvidiaNimProxyRouteNvidiaNimEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({ method: "DELETE", uri: "/nvidia_nim/{endpoint}", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "DeleteNvidiaNimProxyRouteNvidiaNimEndpointRequest",
+  }) as any as S.Schema<DeleteNvidiaNimProxyRouteNvidiaNimEndpointRequest>;
+
+export interface DeleteNvidiaNimProxyRouteNvidiaNimEndpointResponse {
+  body: unknown;
+}
+export const DeleteNvidiaNimProxyRouteNvidiaNimEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "DeleteNvidiaNimProxyRouteNvidiaNimEndpointResponse",
+  }) as any as S.Schema<DeleteNvidiaNimProxyRouteNvidiaNimEndpointResponse>;
+
+export interface DeleteOpenaiProxyRouteOpenaiEndpointRequest {
+  endpoint: string;
+}
+export const DeleteOpenaiProxyRouteOpenaiEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "DELETE", uri: "/openai/{endpoint}", code: 200 })),
+  ).annotate({
+    identifier: "DeleteOpenaiProxyRouteOpenaiEndpointRequest",
+  }) as any as S.Schema<DeleteOpenaiProxyRouteOpenaiEndpointRequest>;
+
+export interface DeleteOpenaiProxyRouteOpenaiEndpointResponse {
+  body: unknown;
+}
+export const DeleteOpenaiProxyRouteOpenaiEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "DeleteOpenaiProxyRouteOpenaiEndpointResponse",
+  }) as any as S.Schema<DeleteOpenaiProxyRouteOpenaiEndpointResponse>;
+
+export interface DeleteTypesafeProxyRouteTypesafeEndpointRequest {
+  endpoint: string;
+}
+export const DeleteTypesafeProxyRouteTypesafeEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({ method: "DELETE", uri: "/typesafe/{endpoint}", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "DeleteTypesafeProxyRouteTypesafeEndpointRequest",
+  }) as any as S.Schema<DeleteTypesafeProxyRouteTypesafeEndpointRequest>;
+
+export interface DeleteTypesafeProxyRouteTypesafeEndpointResponse {
+  body: unknown;
+}
+export const DeleteTypesafeProxyRouteTypesafeEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "DeleteTypesafeProxyRouteTypesafeEndpointResponse",
+  }) as any as S.Schema<DeleteTypesafeProxyRouteTypesafeEndpointResponse>;
+
+export interface DeleteVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointRequest {
+  endpoint: string;
+}
+export const DeleteVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "DELETE",
+        uri: "/vertex_ai/discovery/{endpoint}",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier:
+      "DeleteVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointRequest",
+  }) as any as S.Schema<DeleteVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointRequest>;
+
+export interface DeleteVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointResponse {
+  body: unknown;
+}
+export const DeleteVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier:
+      "DeleteVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointResponse",
+  }) as any as S.Schema<DeleteVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointResponse>;
+
+export interface DeleteVertexProxyRouteVertexAiEndpointRequest {
+  endpoint: string;
+}
+export const DeleteVertexProxyRouteVertexAiEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({ method: "DELETE", uri: "/vertex_ai/{endpoint}", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "DeleteVertexProxyRouteVertexAiEndpointRequest",
+  }) as any as S.Schema<DeleteVertexProxyRouteVertexAiEndpointRequest>;
+
+export interface DeleteVertexProxyRouteVertexAiEndpointResponse {
+  body: unknown;
+}
+export const DeleteVertexProxyRouteVertexAiEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "DeleteVertexProxyRouteVertexAiEndpointResponse",
+  }) as any as S.Schema<DeleteVertexProxyRouteVertexAiEndpointResponse>;
+
+export interface DeleteVllmProxyRouteVllmEndpointRequest {
+  endpoint: string;
+}
+export const DeleteVllmProxyRouteVllmEndpointRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "DELETE", uri: "/vllm/{endpoint}", code: 200 })),
+).annotate({
+  identifier: "DeleteVllmProxyRouteVllmEndpointRequest",
+}) as any as S.Schema<DeleteVllmProxyRouteVllmEndpointRequest>;
+
+export interface DeleteVllmProxyRouteVllmEndpointResponse {
+  body: unknown;
+}
+export const DeleteVllmProxyRouteVllmEndpointResponse = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+).annotate({
+  identifier: "DeleteVllmProxyRouteVllmEndpointResponse",
+}) as any as S.Schema<DeleteVllmProxyRouteVllmEndpointResponse>;
+
+export interface DeleteWatsonxProxyRouteWatsonxEndpointRequest {
+  endpoint: string;
+}
+export const DeleteWatsonxProxyRouteWatsonxEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({ method: "DELETE", uri: "/watsonx/{endpoint}", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "DeleteWatsonxProxyRouteWatsonxEndpointRequest",
+  }) as any as S.Schema<DeleteWatsonxProxyRouteWatsonxEndpointRequest>;
+
+export interface DeleteWatsonxProxyRouteWatsonxEndpointResponse {
+  body: unknown;
+}
+export const DeleteWatsonxProxyRouteWatsonxEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "DeleteWatsonxProxyRouteWatsonxEndpointResponse",
+  }) as any as S.Schema<DeleteWatsonxProxyRouteWatsonxEndpointResponse>;
+
+export interface GetAnthropicProxyRouteAnthropicEndpointRequest {
+  endpoint: string;
+}
+export const GetAnthropicProxyRouteAnthropicEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "GET", uri: "/anthropic/{endpoint}", code: 200 })),
+  ).annotate({
+    identifier: "GetAnthropicProxyRouteAnthropicEndpointRequest",
+  }) as any as S.Schema<GetAnthropicProxyRouteAnthropicEndpointRequest>;
+
+export interface GetAnthropicProxyRouteAnthropicEndpointResponse {
+  body: unknown;
+}
+export const GetAnthropicProxyRouteAnthropicEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "GetAnthropicProxyRouteAnthropicEndpointResponse",
+  }) as any as S.Schema<GetAnthropicProxyRouteAnthropicEndpointResponse>;
+
+export interface GetAssemblyaiProxyRouteAssemblyaiEndpointRequest {
+  endpoint: string;
+}
+export const GetAssemblyaiProxyRouteAssemblyaiEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({ method: "GET", uri: "/assemblyai/{endpoint}", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "GetAssemblyaiProxyRouteAssemblyaiEndpointRequest",
+  }) as any as S.Schema<GetAssemblyaiProxyRouteAssemblyaiEndpointRequest>;
+
+export interface GetAssemblyaiProxyRouteAssemblyaiEndpointResponse {
+  body: unknown;
+}
+export const GetAssemblyaiProxyRouteAssemblyaiEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "GetAssemblyaiProxyRouteAssemblyaiEndpointResponse",
+  }) as any as S.Schema<GetAssemblyaiProxyRouteAssemblyaiEndpointResponse>;
+
+export interface GetAssemblyaiProxyRouteEuAssemblyaiEndpointRequest {
+  endpoint: string;
+}
+export const GetAssemblyaiProxyRouteEuAssemblyaiEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({ method: "GET", uri: "/eu.assemblyai/{endpoint}", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "GetAssemblyaiProxyRouteEuAssemblyaiEndpointRequest",
+  }) as any as S.Schema<GetAssemblyaiProxyRouteEuAssemblyaiEndpointRequest>;
+
+export interface GetAssemblyaiProxyRouteEuAssemblyaiEndpointResponse {
+  body: unknown;
+}
+export const GetAssemblyaiProxyRouteEuAssemblyaiEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "GetAssemblyaiProxyRouteEuAssemblyaiEndpointResponse",
+  }) as any as S.Schema<GetAssemblyaiProxyRouteEuAssemblyaiEndpointResponse>;
+
+export interface GetAzureProxyRouteAzureAiEndpointRequest {
+  endpoint: string;
+}
+export const GetAzureProxyRouteAzureAiEndpointRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "GET", uri: "/azure_ai/{endpoint}", code: 200 })),
+).annotate({
+  identifier: "GetAzureProxyRouteAzureAiEndpointRequest",
+}) as any as S.Schema<GetAzureProxyRouteAzureAiEndpointRequest>;
+
+export interface GetAzureProxyRouteAzureAiEndpointResponse {
+  body: unknown;
+}
+export const GetAzureProxyRouteAzureAiEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "GetAzureProxyRouteAzureAiEndpointResponse",
+  }) as any as S.Schema<GetAzureProxyRouteAzureAiEndpointResponse>;
+
+export interface GetAzureProxyRouteAzureEndpointRequest {
+  endpoint: string;
+}
+export const GetAzureProxyRouteAzureEndpointRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "GET", uri: "/azure/{endpoint}", code: 200 })),
+).annotate({
+  identifier: "GetAzureProxyRouteAzureEndpointRequest",
+}) as any as S.Schema<GetAzureProxyRouteAzureEndpointRequest>;
+
+export interface GetAzureProxyRouteAzureEndpointResponse {
+  body: unknown;
+}
+export const GetAzureProxyRouteAzureEndpointResponse = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+).annotate({
+  identifier: "GetAzureProxyRouteAzureEndpointResponse",
+}) as any as S.Schema<GetAzureProxyRouteAzureEndpointResponse>;
+
+export interface GetAzureSpeechProxyRouteAzureSpeechEndpointRequest {
+  endpoint: string;
+}
+export const GetAzureSpeechProxyRouteAzureSpeechEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({ method: "GET", uri: "/azure_speech/{endpoint}", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "GetAzureSpeechProxyRouteAzureSpeechEndpointRequest",
+  }) as any as S.Schema<GetAzureSpeechProxyRouteAzureSpeechEndpointRequest>;
+
+export interface GetAzureSpeechProxyRouteAzureSpeechEndpointResponse {
+  body: unknown;
+}
+export const GetAzureSpeechProxyRouteAzureSpeechEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "GetAzureSpeechProxyRouteAzureSpeechEndpointResponse",
+  }) as any as S.Schema<GetAzureSpeechProxyRouteAzureSpeechEndpointResponse>;
+
+export interface GetBedrockProxyRouteBedrockEndpointRequest {
+  endpoint: string;
+}
+export const GetBedrockProxyRouteBedrockEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "GET", uri: "/bedrock/{endpoint}", code: 200 })),
+  ).annotate({
+    identifier: "GetBedrockProxyRouteBedrockEndpointRequest",
+  }) as any as S.Schema<GetBedrockProxyRouteBedrockEndpointRequest>;
+
+export interface GetBedrockProxyRouteBedrockEndpointResponse {
+  body: unknown;
+}
+export const GetBedrockProxyRouteBedrockEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "GetBedrockProxyRouteBedrockEndpointResponse",
+  }) as any as S.Schema<GetBedrockProxyRouteBedrockEndpointResponse>;
+
+export interface GetCohereProxyRouteCohereEndpointRequest {
+  endpoint: string;
+}
+export const GetCohereProxyRouteCohereEndpointRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "GET", uri: "/cohere/{endpoint}", code: 200 })),
+).annotate({
+  identifier: "GetCohereProxyRouteCohereEndpointRequest",
+}) as any as S.Schema<GetCohereProxyRouteCohereEndpointRequest>;
+
+export interface GetCohereProxyRouteCohereEndpointResponse {
+  body: unknown;
+}
+export const GetCohereProxyRouteCohereEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "GetCohereProxyRouteCohereEndpointResponse",
+  }) as any as S.Schema<GetCohereProxyRouteCohereEndpointResponse>;
+
+export interface GetCursorProxyRouteCursorEndpointRequest {
+  endpoint: string;
+}
+export const GetCursorProxyRouteCursorEndpointRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "GET", uri: "/cursor/{endpoint}", code: 200 })),
+).annotate({
+  identifier: "GetCursorProxyRouteCursorEndpointRequest",
+}) as any as S.Schema<GetCursorProxyRouteCursorEndpointRequest>;
+
+export interface GetCursorProxyRouteCursorEndpointResponse {
+  body: unknown;
+}
+export const GetCursorProxyRouteCursorEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "GetCursorProxyRouteCursorEndpointResponse",
+  }) as any as S.Schema<GetCursorProxyRouteCursorEndpointResponse>;
+
+export interface GetGeminiProxyRouteGeminiEndpointRequest {
+  endpoint: string;
+}
+export const GetGeminiProxyRouteGeminiEndpointRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "GET", uri: "/gemini/{endpoint}", code: 200 })),
+).annotate({
+  identifier: "GetGeminiProxyRouteGeminiEndpointRequest",
+}) as any as S.Schema<GetGeminiProxyRouteGeminiEndpointRequest>;
+
+export interface GetGeminiProxyRouteGeminiEndpointResponse {
+  body: unknown;
+}
+export const GetGeminiProxyRouteGeminiEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "GetGeminiProxyRouteGeminiEndpointResponse",
+  }) as any as S.Schema<GetGeminiProxyRouteGeminiEndpointResponse>;
+
+export interface GetGigachatProxyRouteGigachatEndpointRequest {
+  endpoint: string;
+}
+export const GetGigachatProxyRouteGigachatEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "GET", uri: "/gigachat/{endpoint}", code: 200 })),
+  ).annotate({
+    identifier: "GetGigachatProxyRouteGigachatEndpointRequest",
+  }) as any as S.Schema<GetGigachatProxyRouteGigachatEndpointRequest>;
+
+export interface GetGigachatProxyRouteGigachatEndpointResponse {
+  body: unknown;
+}
+export const GetGigachatProxyRouteGigachatEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "GetGigachatProxyRouteGigachatEndpointResponse",
+  }) as any as S.Schema<GetGigachatProxyRouteGigachatEndpointResponse>;
+
+export interface GetMilvusProxyRouteMilvusEndpointRequest {
+  endpoint: string;
+}
+export const GetMilvusProxyRouteMilvusEndpointRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "GET", uri: "/milvus/{endpoint}", code: 200 })),
+).annotate({
+  identifier: "GetMilvusProxyRouteMilvusEndpointRequest",
+}) as any as S.Schema<GetMilvusProxyRouteMilvusEndpointRequest>;
+
+export interface GetMilvusProxyRouteMilvusEndpointResponse {
+  body: unknown;
+}
+export const GetMilvusProxyRouteMilvusEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "GetMilvusProxyRouteMilvusEndpointResponse",
+  }) as any as S.Schema<GetMilvusProxyRouteMilvusEndpointResponse>;
+
+export interface GetMistralProxyRouteMistralEndpointRequest {
+  endpoint: string;
+}
+export const GetMistralProxyRouteMistralEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "GET", uri: "/mistral/{endpoint}", code: 200 })),
+  ).annotate({
+    identifier: "GetMistralProxyRouteMistralEndpointRequest",
+  }) as any as S.Schema<GetMistralProxyRouteMistralEndpointRequest>;
+
+export interface GetMistralProxyRouteMistralEndpointResponse {
+  body: unknown;
+}
+export const GetMistralProxyRouteMistralEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "GetMistralProxyRouteMistralEndpointResponse",
+  }) as any as S.Schema<GetMistralProxyRouteMistralEndpointResponse>;
+
+export interface GetNvidiaNimProxyRouteNvidiaNimEndpointRequest {
+  endpoint: string;
+}
+export const GetNvidiaNimProxyRouteNvidiaNimEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({ method: "GET", uri: "/nvidia_nim/{endpoint}", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "GetNvidiaNimProxyRouteNvidiaNimEndpointRequest",
+  }) as any as S.Schema<GetNvidiaNimProxyRouteNvidiaNimEndpointRequest>;
+
+export interface GetNvidiaNimProxyRouteNvidiaNimEndpointResponse {
+  body: unknown;
+}
+export const GetNvidiaNimProxyRouteNvidiaNimEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "GetNvidiaNimProxyRouteNvidiaNimEndpointResponse",
+  }) as any as S.Schema<GetNvidiaNimProxyRouteNvidiaNimEndpointResponse>;
+
+export interface GetOpenaiProxyRouteOpenaiEndpointRequest {
+  endpoint: string;
+}
+export const GetOpenaiProxyRouteOpenaiEndpointRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "GET", uri: "/openai/{endpoint}", code: 200 })),
+).annotate({
+  identifier: "GetOpenaiProxyRouteOpenaiEndpointRequest",
+}) as any as S.Schema<GetOpenaiProxyRouteOpenaiEndpointRequest>;
+
+export interface GetOpenaiProxyRouteOpenaiEndpointResponse {
+  body: unknown;
+}
+export const GetOpenaiProxyRouteOpenaiEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "GetOpenaiProxyRouteOpenaiEndpointResponse",
+  }) as any as S.Schema<GetOpenaiProxyRouteOpenaiEndpointResponse>;
+
+export interface GetTypesafeProxyRouteTypesafeEndpointRequest {
+  endpoint: string;
+}
+export const GetTypesafeProxyRouteTypesafeEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "GET", uri: "/typesafe/{endpoint}", code: 200 })),
+  ).annotate({
+    identifier: "GetTypesafeProxyRouteTypesafeEndpointRequest",
+  }) as any as S.Schema<GetTypesafeProxyRouteTypesafeEndpointRequest>;
+
+export interface GetTypesafeProxyRouteTypesafeEndpointResponse {
+  body: unknown;
+}
+export const GetTypesafeProxyRouteTypesafeEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "GetTypesafeProxyRouteTypesafeEndpointResponse",
+  }) as any as S.Schema<GetTypesafeProxyRouteTypesafeEndpointResponse>;
+
+export interface GetVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointRequest {
+  endpoint: string;
+}
+export const GetVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/vertex_ai/discovery/{endpoint}",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "GetVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointRequest",
+  }) as any as S.Schema<GetVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointRequest>;
+
+export interface GetVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointResponse {
+  body: unknown;
+}
+export const GetVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "GetVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointResponse",
+  }) as any as S.Schema<GetVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointResponse>;
+
+export interface GetVertexProxyRouteVertexAiEndpointRequest {
+  endpoint: string;
+}
+export const GetVertexProxyRouteVertexAiEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "GET", uri: "/vertex_ai/{endpoint}", code: 200 })),
+  ).annotate({
+    identifier: "GetVertexProxyRouteVertexAiEndpointRequest",
+  }) as any as S.Schema<GetVertexProxyRouteVertexAiEndpointRequest>;
+
+export interface GetVertexProxyRouteVertexAiEndpointResponse {
+  body: unknown;
+}
+export const GetVertexProxyRouteVertexAiEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "GetVertexProxyRouteVertexAiEndpointResponse",
+  }) as any as S.Schema<GetVertexProxyRouteVertexAiEndpointResponse>;
+
+export interface GetVllmProxyRouteVllmEndpointRequest {
+  endpoint: string;
+}
+export const GetVllmProxyRouteVllmEndpointRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "GET", uri: "/vllm/{endpoint}", code: 200 })),
+).annotate({
+  identifier: "GetVllmProxyRouteVllmEndpointRequest",
+}) as any as S.Schema<GetVllmProxyRouteVllmEndpointRequest>;
+
+export interface GetVllmProxyRouteVllmEndpointResponse {
+  body: unknown;
+}
+export const GetVllmProxyRouteVllmEndpointResponse = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+).annotate({
+  identifier: "GetVllmProxyRouteVllmEndpointResponse",
+}) as any as S.Schema<GetVllmProxyRouteVllmEndpointResponse>;
+
+export interface GetWatsonxProxyRouteWatsonxEndpointRequest {
+  endpoint: string;
+}
+export const GetWatsonxProxyRouteWatsonxEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "GET", uri: "/watsonx/{endpoint}", code: 200 })),
+  ).annotate({
+    identifier: "GetWatsonxProxyRouteWatsonxEndpointRequest",
+  }) as any as S.Schema<GetWatsonxProxyRouteWatsonxEndpointRequest>;
+
+export interface GetWatsonxProxyRouteWatsonxEndpointResponse {
+  body: unknown;
+}
+export const GetWatsonxProxyRouteWatsonxEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "GetWatsonxProxyRouteWatsonxEndpointResponse",
+  }) as any as S.Schema<GetWatsonxProxyRouteWatsonxEndpointResponse>;
+
+export interface PatchAnthropicProxyRouteAnthropicEndpointRequest {
+  endpoint: string;
+}
+export const PatchAnthropicProxyRouteAnthropicEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({ method: "PATCH", uri: "/anthropic/{endpoint}", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "PatchAnthropicProxyRouteAnthropicEndpointRequest",
+  }) as any as S.Schema<PatchAnthropicProxyRouteAnthropicEndpointRequest>;
+
+export interface PatchAnthropicProxyRouteAnthropicEndpointResponse {
+  body: unknown;
+}
+export const PatchAnthropicProxyRouteAnthropicEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PatchAnthropicProxyRouteAnthropicEndpointResponse",
+  }) as any as S.Schema<PatchAnthropicProxyRouteAnthropicEndpointResponse>;
+
+export interface PatchAssemblyaiProxyRouteAssemblyaiEndpointRequest {
+  endpoint: string;
+}
+export const PatchAssemblyaiProxyRouteAssemblyaiEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({ method: "PATCH", uri: "/assemblyai/{endpoint}", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "PatchAssemblyaiProxyRouteAssemblyaiEndpointRequest",
+  }) as any as S.Schema<PatchAssemblyaiProxyRouteAssemblyaiEndpointRequest>;
+
+export interface PatchAssemblyaiProxyRouteAssemblyaiEndpointResponse {
+  body: unknown;
+}
+export const PatchAssemblyaiProxyRouteAssemblyaiEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PatchAssemblyaiProxyRouteAssemblyaiEndpointResponse",
+  }) as any as S.Schema<PatchAssemblyaiProxyRouteAssemblyaiEndpointResponse>;
+
+export interface PatchAssemblyaiProxyRouteEuAssemblyaiEndpointRequest {
+  endpoint: string;
+}
+export const PatchAssemblyaiProxyRouteEuAssemblyaiEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({ method: "PATCH", uri: "/eu.assemblyai/{endpoint}", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "PatchAssemblyaiProxyRouteEuAssemblyaiEndpointRequest",
+  }) as any as S.Schema<PatchAssemblyaiProxyRouteEuAssemblyaiEndpointRequest>;
+
+export interface PatchAssemblyaiProxyRouteEuAssemblyaiEndpointResponse {
+  body: unknown;
+}
+export const PatchAssemblyaiProxyRouteEuAssemblyaiEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PatchAssemblyaiProxyRouteEuAssemblyaiEndpointResponse",
+  }) as any as S.Schema<PatchAssemblyaiProxyRouteEuAssemblyaiEndpointResponse>;
+
+export interface PatchAzureProxyRouteAzureAiEndpointRequest {
+  endpoint: string;
+}
+export const PatchAzureProxyRouteAzureAiEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({ method: "PATCH", uri: "/azure_ai/{endpoint}", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "PatchAzureProxyRouteAzureAiEndpointRequest",
+  }) as any as S.Schema<PatchAzureProxyRouteAzureAiEndpointRequest>;
+
+export interface PatchAzureProxyRouteAzureAiEndpointResponse {
+  body: unknown;
+}
+export const PatchAzureProxyRouteAzureAiEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PatchAzureProxyRouteAzureAiEndpointResponse",
+  }) as any as S.Schema<PatchAzureProxyRouteAzureAiEndpointResponse>;
+
+export interface PatchAzureProxyRouteAzureEndpointRequest {
+  endpoint: string;
+}
+export const PatchAzureProxyRouteAzureEndpointRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "PATCH", uri: "/azure/{endpoint}", code: 200 })),
+).annotate({
+  identifier: "PatchAzureProxyRouteAzureEndpointRequest",
+}) as any as S.Schema<PatchAzureProxyRouteAzureEndpointRequest>;
+
+export interface PatchAzureProxyRouteAzureEndpointResponse {
+  body: unknown;
+}
+export const PatchAzureProxyRouteAzureEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PatchAzureProxyRouteAzureEndpointResponse",
+  }) as any as S.Schema<PatchAzureProxyRouteAzureEndpointResponse>;
+
+export interface PatchAzureSpeechProxyRouteAzureSpeechEndpointRequest {
+  endpoint: string;
+}
+export const PatchAzureSpeechProxyRouteAzureSpeechEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({ method: "PATCH", uri: "/azure_speech/{endpoint}", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "PatchAzureSpeechProxyRouteAzureSpeechEndpointRequest",
+  }) as any as S.Schema<PatchAzureSpeechProxyRouteAzureSpeechEndpointRequest>;
+
+export interface PatchAzureSpeechProxyRouteAzureSpeechEndpointResponse {
+  body: unknown;
+}
+export const PatchAzureSpeechProxyRouteAzureSpeechEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PatchAzureSpeechProxyRouteAzureSpeechEndpointResponse",
+  }) as any as S.Schema<PatchAzureSpeechProxyRouteAzureSpeechEndpointResponse>;
+
+export interface PatchBedrockProxyRouteBedrockEndpointRequest {
+  endpoint: string;
+}
+export const PatchBedrockProxyRouteBedrockEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "PATCH", uri: "/bedrock/{endpoint}", code: 200 })),
+  ).annotate({
+    identifier: "PatchBedrockProxyRouteBedrockEndpointRequest",
+  }) as any as S.Schema<PatchBedrockProxyRouteBedrockEndpointRequest>;
+
+export interface PatchBedrockProxyRouteBedrockEndpointResponse {
+  body: unknown;
+}
+export const PatchBedrockProxyRouteBedrockEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PatchBedrockProxyRouteBedrockEndpointResponse",
+  }) as any as S.Schema<PatchBedrockProxyRouteBedrockEndpointResponse>;
+
+export interface PatchCohereProxyRouteCohereEndpointRequest {
+  endpoint: string;
+}
+export const PatchCohereProxyRouteCohereEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "PATCH", uri: "/cohere/{endpoint}", code: 200 })),
+  ).annotate({
+    identifier: "PatchCohereProxyRouteCohereEndpointRequest",
+  }) as any as S.Schema<PatchCohereProxyRouteCohereEndpointRequest>;
+
+export interface PatchCohereProxyRouteCohereEndpointResponse {
+  body: unknown;
+}
+export const PatchCohereProxyRouteCohereEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PatchCohereProxyRouteCohereEndpointResponse",
+  }) as any as S.Schema<PatchCohereProxyRouteCohereEndpointResponse>;
+
+export interface PatchCursorProxyRouteCursorEndpointRequest {
+  endpoint: string;
+}
+export const PatchCursorProxyRouteCursorEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "PATCH", uri: "/cursor/{endpoint}", code: 200 })),
+  ).annotate({
+    identifier: "PatchCursorProxyRouteCursorEndpointRequest",
+  }) as any as S.Schema<PatchCursorProxyRouteCursorEndpointRequest>;
+
+export interface PatchCursorProxyRouteCursorEndpointResponse {
+  body: unknown;
+}
+export const PatchCursorProxyRouteCursorEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PatchCursorProxyRouteCursorEndpointResponse",
+  }) as any as S.Schema<PatchCursorProxyRouteCursorEndpointResponse>;
+
+export interface PatchGeminiProxyRouteGeminiEndpointRequest {
+  endpoint: string;
+}
+export const PatchGeminiProxyRouteGeminiEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "PATCH", uri: "/gemini/{endpoint}", code: 200 })),
+  ).annotate({
+    identifier: "PatchGeminiProxyRouteGeminiEndpointRequest",
+  }) as any as S.Schema<PatchGeminiProxyRouteGeminiEndpointRequest>;
+
+export interface PatchGeminiProxyRouteGeminiEndpointResponse {
+  body: unknown;
+}
+export const PatchGeminiProxyRouteGeminiEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PatchGeminiProxyRouteGeminiEndpointResponse",
+  }) as any as S.Schema<PatchGeminiProxyRouteGeminiEndpointResponse>;
+
+export interface PatchGigachatProxyRouteGigachatEndpointRequest {
+  endpoint: string;
+}
+export const PatchGigachatProxyRouteGigachatEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({ method: "PATCH", uri: "/gigachat/{endpoint}", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "PatchGigachatProxyRouteGigachatEndpointRequest",
+  }) as any as S.Schema<PatchGigachatProxyRouteGigachatEndpointRequest>;
+
+export interface PatchGigachatProxyRouteGigachatEndpointResponse {
+  body: unknown;
+}
+export const PatchGigachatProxyRouteGigachatEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PatchGigachatProxyRouteGigachatEndpointResponse",
+  }) as any as S.Schema<PatchGigachatProxyRouteGigachatEndpointResponse>;
+
+export interface PatchMilvusProxyRouteMilvusEndpointRequest {
+  endpoint: string;
+}
+export const PatchMilvusProxyRouteMilvusEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "PATCH", uri: "/milvus/{endpoint}", code: 200 })),
+  ).annotate({
+    identifier: "PatchMilvusProxyRouteMilvusEndpointRequest",
+  }) as any as S.Schema<PatchMilvusProxyRouteMilvusEndpointRequest>;
+
+export interface PatchMilvusProxyRouteMilvusEndpointResponse {
+  body: unknown;
+}
+export const PatchMilvusProxyRouteMilvusEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PatchMilvusProxyRouteMilvusEndpointResponse",
+  }) as any as S.Schema<PatchMilvusProxyRouteMilvusEndpointResponse>;
+
+export interface PatchMistralProxyRouteMistralEndpointRequest {
+  endpoint: string;
+}
+export const PatchMistralProxyRouteMistralEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "PATCH", uri: "/mistral/{endpoint}", code: 200 })),
+  ).annotate({
+    identifier: "PatchMistralProxyRouteMistralEndpointRequest",
+  }) as any as S.Schema<PatchMistralProxyRouteMistralEndpointRequest>;
+
+export interface PatchMistralProxyRouteMistralEndpointResponse {
+  body: unknown;
+}
+export const PatchMistralProxyRouteMistralEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PatchMistralProxyRouteMistralEndpointResponse",
+  }) as any as S.Schema<PatchMistralProxyRouteMistralEndpointResponse>;
+
+export interface PatchNvidiaNimProxyRouteNvidiaNimEndpointRequest {
+  endpoint: string;
+}
+export const PatchNvidiaNimProxyRouteNvidiaNimEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({ method: "PATCH", uri: "/nvidia_nim/{endpoint}", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "PatchNvidiaNimProxyRouteNvidiaNimEndpointRequest",
+  }) as any as S.Schema<PatchNvidiaNimProxyRouteNvidiaNimEndpointRequest>;
+
+export interface PatchNvidiaNimProxyRouteNvidiaNimEndpointResponse {
+  body: unknown;
+}
+export const PatchNvidiaNimProxyRouteNvidiaNimEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PatchNvidiaNimProxyRouteNvidiaNimEndpointResponse",
+  }) as any as S.Schema<PatchNvidiaNimProxyRouteNvidiaNimEndpointResponse>;
+
+export interface PatchOpenaiProxyRouteOpenaiEndpointRequest {
+  endpoint: string;
+}
+export const PatchOpenaiProxyRouteOpenaiEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "PATCH", uri: "/openai/{endpoint}", code: 200 })),
+  ).annotate({
+    identifier: "PatchOpenaiProxyRouteOpenaiEndpointRequest",
+  }) as any as S.Schema<PatchOpenaiProxyRouteOpenaiEndpointRequest>;
+
+export interface PatchOpenaiProxyRouteOpenaiEndpointResponse {
+  body: unknown;
+}
+export const PatchOpenaiProxyRouteOpenaiEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PatchOpenaiProxyRouteOpenaiEndpointResponse",
+  }) as any as S.Schema<PatchOpenaiProxyRouteOpenaiEndpointResponse>;
+
+export interface PatchTypesafeProxyRouteTypesafeEndpointRequest {
+  endpoint: string;
+}
+export const PatchTypesafeProxyRouteTypesafeEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({ method: "PATCH", uri: "/typesafe/{endpoint}", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "PatchTypesafeProxyRouteTypesafeEndpointRequest",
+  }) as any as S.Schema<PatchTypesafeProxyRouteTypesafeEndpointRequest>;
+
+export interface PatchTypesafeProxyRouteTypesafeEndpointResponse {
+  body: unknown;
+}
+export const PatchTypesafeProxyRouteTypesafeEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PatchTypesafeProxyRouteTypesafeEndpointResponse",
+  }) as any as S.Schema<PatchTypesafeProxyRouteTypesafeEndpointResponse>;
+
+export interface PatchVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointRequest {
+  endpoint: string;
+}
+export const PatchVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "PATCH",
+        uri: "/vertex_ai/discovery/{endpoint}",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier:
+      "PatchVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointRequest",
+  }) as any as S.Schema<PatchVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointRequest>;
+
+export interface PatchVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointResponse {
+  body: unknown;
+}
+export const PatchVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier:
+      "PatchVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointResponse",
+  }) as any as S.Schema<PatchVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointResponse>;
+
+export interface PatchVertexProxyRouteVertexAiEndpointRequest {
+  endpoint: string;
+}
+export const PatchVertexProxyRouteVertexAiEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({ method: "PATCH", uri: "/vertex_ai/{endpoint}", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "PatchVertexProxyRouteVertexAiEndpointRequest",
+  }) as any as S.Schema<PatchVertexProxyRouteVertexAiEndpointRequest>;
+
+export interface PatchVertexProxyRouteVertexAiEndpointResponse {
+  body: unknown;
+}
+export const PatchVertexProxyRouteVertexAiEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PatchVertexProxyRouteVertexAiEndpointResponse",
+  }) as any as S.Schema<PatchVertexProxyRouteVertexAiEndpointResponse>;
+
+export interface PatchVllmProxyRouteVllmEndpointRequest {
+  endpoint: string;
+}
+export const PatchVllmProxyRouteVllmEndpointRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "PATCH", uri: "/vllm/{endpoint}", code: 200 })),
+).annotate({
+  identifier: "PatchVllmProxyRouteVllmEndpointRequest",
+}) as any as S.Schema<PatchVllmProxyRouteVllmEndpointRequest>;
+
+export interface PatchVllmProxyRouteVllmEndpointResponse {
+  body: unknown;
+}
+export const PatchVllmProxyRouteVllmEndpointResponse = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+).annotate({
+  identifier: "PatchVllmProxyRouteVllmEndpointResponse",
+}) as any as S.Schema<PatchVllmProxyRouteVllmEndpointResponse>;
+
+export interface PatchWatsonxProxyRouteWatsonxEndpointRequest {
+  endpoint: string;
+}
+export const PatchWatsonxProxyRouteWatsonxEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "PATCH", uri: "/watsonx/{endpoint}", code: 200 })),
+  ).annotate({
+    identifier: "PatchWatsonxProxyRouteWatsonxEndpointRequest",
+  }) as any as S.Schema<PatchWatsonxProxyRouteWatsonxEndpointRequest>;
+
+export interface PatchWatsonxProxyRouteWatsonxEndpointResponse {
+  body: unknown;
+}
+export const PatchWatsonxProxyRouteWatsonxEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PatchWatsonxProxyRouteWatsonxEndpointResponse",
+  }) as any as S.Schema<PatchWatsonxProxyRouteWatsonxEndpointResponse>;
+
+export interface PostAnthropicProxyRouteAnthropicEndpointRequest {
+  endpoint: string;
+}
+export const PostAnthropicProxyRouteAnthropicEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({ method: "POST", uri: "/anthropic/{endpoint}", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "PostAnthropicProxyRouteAnthropicEndpointRequest",
+  }) as any as S.Schema<PostAnthropicProxyRouteAnthropicEndpointRequest>;
+
+export interface PostAnthropicProxyRouteAnthropicEndpointResponse {
+  body: unknown;
+}
+export const PostAnthropicProxyRouteAnthropicEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PostAnthropicProxyRouteAnthropicEndpointResponse",
+  }) as any as S.Schema<PostAnthropicProxyRouteAnthropicEndpointResponse>;
+
+export interface PostAssemblyaiProxyRouteAssemblyaiEndpointRequest {
+  endpoint: string;
+}
+export const PostAssemblyaiProxyRouteAssemblyaiEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({ method: "POST", uri: "/assemblyai/{endpoint}", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "PostAssemblyaiProxyRouteAssemblyaiEndpointRequest",
+  }) as any as S.Schema<PostAssemblyaiProxyRouteAssemblyaiEndpointRequest>;
+
+export interface PostAssemblyaiProxyRouteAssemblyaiEndpointResponse {
+  body: unknown;
+}
+export const PostAssemblyaiProxyRouteAssemblyaiEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PostAssemblyaiProxyRouteAssemblyaiEndpointResponse",
+  }) as any as S.Schema<PostAssemblyaiProxyRouteAssemblyaiEndpointResponse>;
+
+export interface PostAssemblyaiProxyRouteEuAssemblyaiEndpointRequest {
+  endpoint: string;
+}
+export const PostAssemblyaiProxyRouteEuAssemblyaiEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({ method: "POST", uri: "/eu.assemblyai/{endpoint}", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "PostAssemblyaiProxyRouteEuAssemblyaiEndpointRequest",
+  }) as any as S.Schema<PostAssemblyaiProxyRouteEuAssemblyaiEndpointRequest>;
+
+export interface PostAssemblyaiProxyRouteEuAssemblyaiEndpointResponse {
+  body: unknown;
+}
+export const PostAssemblyaiProxyRouteEuAssemblyaiEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PostAssemblyaiProxyRouteEuAssemblyaiEndpointResponse",
+  }) as any as S.Schema<PostAssemblyaiProxyRouteEuAssemblyaiEndpointResponse>;
+
+export interface PostAzureProxyRouteAzureAiEndpointRequest {
+  endpoint: string;
+}
+export const PostAzureProxyRouteAzureAiEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "POST", uri: "/azure_ai/{endpoint}", code: 200 })),
+  ).annotate({
+    identifier: "PostAzureProxyRouteAzureAiEndpointRequest",
+  }) as any as S.Schema<PostAzureProxyRouteAzureAiEndpointRequest>;
+
+export interface PostAzureProxyRouteAzureAiEndpointResponse {
+  body: unknown;
+}
+export const PostAzureProxyRouteAzureAiEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PostAzureProxyRouteAzureAiEndpointResponse",
+  }) as any as S.Schema<PostAzureProxyRouteAzureAiEndpointResponse>;
+
+export interface PostAzureProxyRouteAzureEndpointRequest {
+  endpoint: string;
+}
+export const PostAzureProxyRouteAzureEndpointRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "POST", uri: "/azure/{endpoint}", code: 200 })),
+).annotate({
+  identifier: "PostAzureProxyRouteAzureEndpointRequest",
+}) as any as S.Schema<PostAzureProxyRouteAzureEndpointRequest>;
+
+export interface PostAzureProxyRouteAzureEndpointResponse {
+  body: unknown;
+}
+export const PostAzureProxyRouteAzureEndpointResponse = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+).annotate({
+  identifier: "PostAzureProxyRouteAzureEndpointResponse",
+}) as any as S.Schema<PostAzureProxyRouteAzureEndpointResponse>;
+
+export interface PostAzureSpeechProxyRouteAzureSpeechEndpointRequest {
+  endpoint: string;
+}
+export const PostAzureSpeechProxyRouteAzureSpeechEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({ method: "POST", uri: "/azure_speech/{endpoint}", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "PostAzureSpeechProxyRouteAzureSpeechEndpointRequest",
+  }) as any as S.Schema<PostAzureSpeechProxyRouteAzureSpeechEndpointRequest>;
+
+export interface PostAzureSpeechProxyRouteAzureSpeechEndpointResponse {
+  body: unknown;
+}
+export const PostAzureSpeechProxyRouteAzureSpeechEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PostAzureSpeechProxyRouteAzureSpeechEndpointResponse",
+  }) as any as S.Schema<PostAzureSpeechProxyRouteAzureSpeechEndpointResponse>;
+
+export interface PostBedrockProxyRouteBedrockEndpointRequest {
+  endpoint: string;
+}
+export const PostBedrockProxyRouteBedrockEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "POST", uri: "/bedrock/{endpoint}", code: 200 })),
+  ).annotate({
+    identifier: "PostBedrockProxyRouteBedrockEndpointRequest",
+  }) as any as S.Schema<PostBedrockProxyRouteBedrockEndpointRequest>;
+
+export interface PostBedrockProxyRouteBedrockEndpointResponse {
+  body: unknown;
+}
+export const PostBedrockProxyRouteBedrockEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PostBedrockProxyRouteBedrockEndpointResponse",
+  }) as any as S.Schema<PostBedrockProxyRouteBedrockEndpointResponse>;
+
+export interface PostCohereProxyRouteCohereEndpointRequest {
+  endpoint: string;
+}
+export const PostCohereProxyRouteCohereEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "POST", uri: "/cohere/{endpoint}", code: 200 })),
+  ).annotate({
+    identifier: "PostCohereProxyRouteCohereEndpointRequest",
+  }) as any as S.Schema<PostCohereProxyRouteCohereEndpointRequest>;
+
+export interface PostCohereProxyRouteCohereEndpointResponse {
+  body: unknown;
+}
+export const PostCohereProxyRouteCohereEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PostCohereProxyRouteCohereEndpointResponse",
+  }) as any as S.Schema<PostCohereProxyRouteCohereEndpointResponse>;
+
+export interface PostComprehendMedicalProxyRouteComprehendmedicalOperationRequest {
+  operation: string;
+}
+export const PostComprehendMedicalProxyRouteComprehendmedicalOperationRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      operation: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/comprehendmedical/{operation}",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier:
+      "PostComprehendMedicalProxyRouteComprehendmedicalOperationRequest",
+  }) as any as S.Schema<PostComprehendMedicalProxyRouteComprehendmedicalOperationRequest>;
+
+export interface PostComprehendMedicalProxyRouteComprehendmedicalOperationResponse {
+  body: unknown;
+}
+export const PostComprehendMedicalProxyRouteComprehendmedicalOperationResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier:
+      "PostComprehendMedicalProxyRouteComprehendmedicalOperationResponse",
+  }) as any as S.Schema<PostComprehendMedicalProxyRouteComprehendmedicalOperationResponse>;
+
+export interface PostComprehendMedicalSdkProxyRouteComprehendmedicalRequest {}
+export const PostComprehendMedicalSdkProxyRouteComprehendmedicalRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({}).pipe(
+      T.Http({ method: "POST", uri: "/comprehendmedical", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "PostComprehendMedicalSdkProxyRouteComprehendmedicalRequest",
+  }) as any as S.Schema<PostComprehendMedicalSdkProxyRouteComprehendmedicalRequest>;
+
+export interface PostComprehendMedicalSdkProxyRouteComprehendmedicalResponse {
+  body: unknown;
+}
+export const PostComprehendMedicalSdkProxyRouteComprehendmedicalResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PostComprehendMedicalSdkProxyRouteComprehendmedicalResponse",
+  }) as any as S.Schema<PostComprehendMedicalSdkProxyRouteComprehendmedicalResponse>;
+
+export interface PostCursorProxyRouteCursorEndpointRequest {
+  endpoint: string;
+}
+export const PostCursorProxyRouteCursorEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "POST", uri: "/cursor/{endpoint}", code: 200 })),
+  ).annotate({
+    identifier: "PostCursorProxyRouteCursorEndpointRequest",
+  }) as any as S.Schema<PostCursorProxyRouteCursorEndpointRequest>;
+
+export interface PostCursorProxyRouteCursorEndpointResponse {
+  body: unknown;
+}
+export const PostCursorProxyRouteCursorEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PostCursorProxyRouteCursorEndpointResponse",
+  }) as any as S.Schema<PostCursorProxyRouteCursorEndpointResponse>;
+
+export interface PostGeminiProxyRouteGeminiEndpointRequest {
+  endpoint: string;
+}
+export const PostGeminiProxyRouteGeminiEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "POST", uri: "/gemini/{endpoint}", code: 200 })),
+  ).annotate({
+    identifier: "PostGeminiProxyRouteGeminiEndpointRequest",
+  }) as any as S.Schema<PostGeminiProxyRouteGeminiEndpointRequest>;
+
+export interface PostGeminiProxyRouteGeminiEndpointResponse {
+  body: unknown;
+}
+export const PostGeminiProxyRouteGeminiEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PostGeminiProxyRouteGeminiEndpointResponse",
+  }) as any as S.Schema<PostGeminiProxyRouteGeminiEndpointResponse>;
+
+export interface PostGigachatProxyRouteGigachatEndpointRequest {
+  endpoint: string;
+}
+export const PostGigachatProxyRouteGigachatEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "POST", uri: "/gigachat/{endpoint}", code: 200 })),
+  ).annotate({
+    identifier: "PostGigachatProxyRouteGigachatEndpointRequest",
+  }) as any as S.Schema<PostGigachatProxyRouteGigachatEndpointRequest>;
+
+export interface PostGigachatProxyRouteGigachatEndpointResponse {
+  body: unknown;
+}
+export const PostGigachatProxyRouteGigachatEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PostGigachatProxyRouteGigachatEndpointResponse",
+  }) as any as S.Schema<PostGigachatProxyRouteGigachatEndpointResponse>;
+
+export interface PostMilvusProxyRouteMilvusEndpointRequest {
+  endpoint: string;
+}
+export const PostMilvusProxyRouteMilvusEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "POST", uri: "/milvus/{endpoint}", code: 200 })),
+  ).annotate({
+    identifier: "PostMilvusProxyRouteMilvusEndpointRequest",
+  }) as any as S.Schema<PostMilvusProxyRouteMilvusEndpointRequest>;
+
+export interface PostMilvusProxyRouteMilvusEndpointResponse {
+  body: unknown;
+}
+export const PostMilvusProxyRouteMilvusEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PostMilvusProxyRouteMilvusEndpointResponse",
+  }) as any as S.Schema<PostMilvusProxyRouteMilvusEndpointResponse>;
+
+export interface PostMistralProxyRouteMistralEndpointRequest {
+  endpoint: string;
+}
+export const PostMistralProxyRouteMistralEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "POST", uri: "/mistral/{endpoint}", code: 200 })),
+  ).annotate({
+    identifier: "PostMistralProxyRouteMistralEndpointRequest",
+  }) as any as S.Schema<PostMistralProxyRouteMistralEndpointRequest>;
+
+export interface PostMistralProxyRouteMistralEndpointResponse {
+  body: unknown;
+}
+export const PostMistralProxyRouteMistralEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PostMistralProxyRouteMistralEndpointResponse",
+  }) as any as S.Schema<PostMistralProxyRouteMistralEndpointResponse>;
+
+export interface PostNvidiaNimProxyRouteNvidiaNimEndpointRequest {
+  endpoint: string;
+}
+export const PostNvidiaNimProxyRouteNvidiaNimEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({ method: "POST", uri: "/nvidia_nim/{endpoint}", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "PostNvidiaNimProxyRouteNvidiaNimEndpointRequest",
+  }) as any as S.Schema<PostNvidiaNimProxyRouteNvidiaNimEndpointRequest>;
+
+export interface PostNvidiaNimProxyRouteNvidiaNimEndpointResponse {
+  body: unknown;
+}
+export const PostNvidiaNimProxyRouteNvidiaNimEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PostNvidiaNimProxyRouteNvidiaNimEndpointResponse",
+  }) as any as S.Schema<PostNvidiaNimProxyRouteNvidiaNimEndpointResponse>;
+
+export interface PostOpenaiProxyRouteOpenaiEndpointRequest {
+  endpoint: string;
+}
+export const PostOpenaiProxyRouteOpenaiEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "POST", uri: "/openai/{endpoint}", code: 200 })),
+  ).annotate({
+    identifier: "PostOpenaiProxyRouteOpenaiEndpointRequest",
+  }) as any as S.Schema<PostOpenaiProxyRouteOpenaiEndpointRequest>;
+
+export interface PostOpenaiProxyRouteOpenaiEndpointResponse {
+  body: unknown;
+}
+export const PostOpenaiProxyRouteOpenaiEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PostOpenaiProxyRouteOpenaiEndpointResponse",
+  }) as any as S.Schema<PostOpenaiProxyRouteOpenaiEndpointResponse>;
+
+export interface PostProxyRealtimeCallsOpenaiV1RealtimeCallRequest {}
+export const PostProxyRealtimeCallsOpenaiV1RealtimeCallRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({}).pipe(
+      T.Http({ method: "POST", uri: "/openai/v1/realtime/calls", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "PostProxyRealtimeCallsOpenaiV1RealtimeCallRequest",
+  }) as any as S.Schema<PostProxyRealtimeCallsOpenaiV1RealtimeCallRequest>;
+
+export interface PostProxyRealtimeCallsOpenaiV1RealtimeCallResponse {
+  body: unknown;
+}
+export const PostProxyRealtimeCallsOpenaiV1RealtimeCallResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PostProxyRealtimeCallsOpenaiV1RealtimeCallResponse",
+  }) as any as S.Schema<PostProxyRealtimeCallsOpenaiV1RealtimeCallResponse>;
+
+export interface PostTranscribeProxyRouteTranscribeOperationRequest {
+  operation: string;
+}
+export const PostTranscribeProxyRouteTranscribeOperationRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      operation: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({ method: "POST", uri: "/transcribe/{operation}", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "PostTranscribeProxyRouteTranscribeOperationRequest",
+  }) as any as S.Schema<PostTranscribeProxyRouteTranscribeOperationRequest>;
+
+export interface PostTranscribeProxyRouteTranscribeOperationResponse {
+  body: unknown;
+}
+export const PostTranscribeProxyRouteTranscribeOperationResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PostTranscribeProxyRouteTranscribeOperationResponse",
+  }) as any as S.Schema<PostTranscribeProxyRouteTranscribeOperationResponse>;
+
+export interface PostTranscribeSdkProxyRouteTranscribeRequest {}
+export const PostTranscribeSdkProxyRouteTranscribeRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({}).pipe(
+      T.Http({ method: "POST", uri: "/transcribe", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "PostTranscribeSdkProxyRouteTranscribeRequest",
+  }) as any as S.Schema<PostTranscribeSdkProxyRouteTranscribeRequest>;
+
+export interface PostTranscribeSdkProxyRouteTranscribeResponse {
+  body: unknown;
+}
+export const PostTranscribeSdkProxyRouteTranscribeResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PostTranscribeSdkProxyRouteTranscribeResponse",
+  }) as any as S.Schema<PostTranscribeSdkProxyRouteTranscribeResponse>;
+
+export interface PostTypesafeProxyRouteTypesafeEndpointRequest {
+  endpoint: string;
+}
+export const PostTypesafeProxyRouteTypesafeEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "POST", uri: "/typesafe/{endpoint}", code: 200 })),
+  ).annotate({
+    identifier: "PostTypesafeProxyRouteTypesafeEndpointRequest",
+  }) as any as S.Schema<PostTypesafeProxyRouteTypesafeEndpointRequest>;
+
+export interface PostTypesafeProxyRouteTypesafeEndpointResponse {
+  body: unknown;
+}
+export const PostTypesafeProxyRouteTypesafeEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PostTypesafeProxyRouteTypesafeEndpointResponse",
+  }) as any as S.Schema<PostTypesafeProxyRouteTypesafeEndpointResponse>;
+
+export interface PostVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointRequest {
+  endpoint: string;
+}
+export const PostVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/vertex_ai/discovery/{endpoint}",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "PostVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointRequest",
+  }) as any as S.Schema<PostVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointRequest>;
+
+export interface PostVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointResponse {
+  body: unknown;
+}
+export const PostVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier:
+      "PostVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointResponse",
+  }) as any as S.Schema<PostVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointResponse>;
+
+export interface PostVertexProxyRouteVertexAiEndpointRequest {
+  endpoint: string;
+}
+export const PostVertexProxyRouteVertexAiEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({ method: "POST", uri: "/vertex_ai/{endpoint}", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "PostVertexProxyRouteVertexAiEndpointRequest",
+  }) as any as S.Schema<PostVertexProxyRouteVertexAiEndpointRequest>;
+
+export interface PostVertexProxyRouteVertexAiEndpointResponse {
+  body: unknown;
+}
+export const PostVertexProxyRouteVertexAiEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PostVertexProxyRouteVertexAiEndpointResponse",
+  }) as any as S.Schema<PostVertexProxyRouteVertexAiEndpointResponse>;
+
+export interface PostVllmProxyRouteVllmEndpointRequest {
+  endpoint: string;
+}
+export const PostVllmProxyRouteVllmEndpointRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "POST", uri: "/vllm/{endpoint}", code: 200 })),
+).annotate({
+  identifier: "PostVllmProxyRouteVllmEndpointRequest",
+}) as any as S.Schema<PostVllmProxyRouteVllmEndpointRequest>;
+
+export interface PostVllmProxyRouteVllmEndpointResponse {
+  body: unknown;
+}
+export const PostVllmProxyRouteVllmEndpointResponse = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+).annotate({
+  identifier: "PostVllmProxyRouteVllmEndpointResponse",
+}) as any as S.Schema<PostVllmProxyRouteVllmEndpointResponse>;
+
+export interface PostWatsonxProxyRouteWatsonxEndpointRequest {
+  endpoint: string;
+}
+export const PostWatsonxProxyRouteWatsonxEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "POST", uri: "/watsonx/{endpoint}", code: 200 })),
+  ).annotate({
+    identifier: "PostWatsonxProxyRouteWatsonxEndpointRequest",
+  }) as any as S.Schema<PostWatsonxProxyRouteWatsonxEndpointRequest>;
+
+export interface PostWatsonxProxyRouteWatsonxEndpointResponse {
+  body: unknown;
+}
+export const PostWatsonxProxyRouteWatsonxEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PostWatsonxProxyRouteWatsonxEndpointResponse",
+  }) as any as S.Schema<PostWatsonxProxyRouteWatsonxEndpointResponse>;
+
+export interface PutAnthropicProxyRouteAnthropicEndpointRequest {
+  endpoint: string;
+}
+export const PutAnthropicProxyRouteAnthropicEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "PUT", uri: "/anthropic/{endpoint}", code: 200 })),
+  ).annotate({
+    identifier: "PutAnthropicProxyRouteAnthropicEndpointRequest",
+  }) as any as S.Schema<PutAnthropicProxyRouteAnthropicEndpointRequest>;
+
+export interface PutAnthropicProxyRouteAnthropicEndpointResponse {
+  body: unknown;
+}
+export const PutAnthropicProxyRouteAnthropicEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PutAnthropicProxyRouteAnthropicEndpointResponse",
+  }) as any as S.Schema<PutAnthropicProxyRouteAnthropicEndpointResponse>;
+
+export interface PutAssemblyaiProxyRouteAssemblyaiEndpointRequest {
+  endpoint: string;
+}
+export const PutAssemblyaiProxyRouteAssemblyaiEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({ method: "PUT", uri: "/assemblyai/{endpoint}", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "PutAssemblyaiProxyRouteAssemblyaiEndpointRequest",
+  }) as any as S.Schema<PutAssemblyaiProxyRouteAssemblyaiEndpointRequest>;
+
+export interface PutAssemblyaiProxyRouteAssemblyaiEndpointResponse {
+  body: unknown;
+}
+export const PutAssemblyaiProxyRouteAssemblyaiEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PutAssemblyaiProxyRouteAssemblyaiEndpointResponse",
+  }) as any as S.Schema<PutAssemblyaiProxyRouteAssemblyaiEndpointResponse>;
+
+export interface PutAssemblyaiProxyRouteEuAssemblyaiEndpointRequest {
+  endpoint: string;
+}
+export const PutAssemblyaiProxyRouteEuAssemblyaiEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({ method: "PUT", uri: "/eu.assemblyai/{endpoint}", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "PutAssemblyaiProxyRouteEuAssemblyaiEndpointRequest",
+  }) as any as S.Schema<PutAssemblyaiProxyRouteEuAssemblyaiEndpointRequest>;
+
+export interface PutAssemblyaiProxyRouteEuAssemblyaiEndpointResponse {
+  body: unknown;
+}
+export const PutAssemblyaiProxyRouteEuAssemblyaiEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PutAssemblyaiProxyRouteEuAssemblyaiEndpointResponse",
+  }) as any as S.Schema<PutAssemblyaiProxyRouteEuAssemblyaiEndpointResponse>;
+
+export interface PutAzureProxyRouteAzureAiEndpointRequest {
+  endpoint: string;
+}
+export const PutAzureProxyRouteAzureAiEndpointRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "PUT", uri: "/azure_ai/{endpoint}", code: 200 })),
+).annotate({
+  identifier: "PutAzureProxyRouteAzureAiEndpointRequest",
+}) as any as S.Schema<PutAzureProxyRouteAzureAiEndpointRequest>;
+
+export interface PutAzureProxyRouteAzureAiEndpointResponse {
+  body: unknown;
+}
+export const PutAzureProxyRouteAzureAiEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PutAzureProxyRouteAzureAiEndpointResponse",
+  }) as any as S.Schema<PutAzureProxyRouteAzureAiEndpointResponse>;
+
+export interface PutAzureProxyRouteAzureEndpointRequest {
+  endpoint: string;
+}
+export const PutAzureProxyRouteAzureEndpointRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "PUT", uri: "/azure/{endpoint}", code: 200 })),
+).annotate({
+  identifier: "PutAzureProxyRouteAzureEndpointRequest",
+}) as any as S.Schema<PutAzureProxyRouteAzureEndpointRequest>;
+
+export interface PutAzureProxyRouteAzureEndpointResponse {
+  body: unknown;
+}
+export const PutAzureProxyRouteAzureEndpointResponse = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+).annotate({
+  identifier: "PutAzureProxyRouteAzureEndpointResponse",
+}) as any as S.Schema<PutAzureProxyRouteAzureEndpointResponse>;
+
+export interface PutAzureSpeechProxyRouteAzureSpeechEndpointRequest {
+  endpoint: string;
+}
+export const PutAzureSpeechProxyRouteAzureSpeechEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({ method: "PUT", uri: "/azure_speech/{endpoint}", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "PutAzureSpeechProxyRouteAzureSpeechEndpointRequest",
+  }) as any as S.Schema<PutAzureSpeechProxyRouteAzureSpeechEndpointRequest>;
+
+export interface PutAzureSpeechProxyRouteAzureSpeechEndpointResponse {
+  body: unknown;
+}
+export const PutAzureSpeechProxyRouteAzureSpeechEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PutAzureSpeechProxyRouteAzureSpeechEndpointResponse",
+  }) as any as S.Schema<PutAzureSpeechProxyRouteAzureSpeechEndpointResponse>;
+
+export interface PutBedrockProxyRouteBedrockEndpointRequest {
+  endpoint: string;
+}
+export const PutBedrockProxyRouteBedrockEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "PUT", uri: "/bedrock/{endpoint}", code: 200 })),
+  ).annotate({
+    identifier: "PutBedrockProxyRouteBedrockEndpointRequest",
+  }) as any as S.Schema<PutBedrockProxyRouteBedrockEndpointRequest>;
+
+export interface PutBedrockProxyRouteBedrockEndpointResponse {
+  body: unknown;
+}
+export const PutBedrockProxyRouteBedrockEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PutBedrockProxyRouteBedrockEndpointResponse",
+  }) as any as S.Schema<PutBedrockProxyRouteBedrockEndpointResponse>;
+
+export interface PutCohereProxyRouteCohereEndpointRequest {
+  endpoint: string;
+}
+export const PutCohereProxyRouteCohereEndpointRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "PUT", uri: "/cohere/{endpoint}", code: 200 })),
+).annotate({
+  identifier: "PutCohereProxyRouteCohereEndpointRequest",
+}) as any as S.Schema<PutCohereProxyRouteCohereEndpointRequest>;
+
+export interface PutCohereProxyRouteCohereEndpointResponse {
+  body: unknown;
+}
+export const PutCohereProxyRouteCohereEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PutCohereProxyRouteCohereEndpointResponse",
+  }) as any as S.Schema<PutCohereProxyRouteCohereEndpointResponse>;
+
+export interface PutCursorProxyRouteCursorEndpointRequest {
+  endpoint: string;
+}
+export const PutCursorProxyRouteCursorEndpointRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "PUT", uri: "/cursor/{endpoint}", code: 200 })),
+).annotate({
+  identifier: "PutCursorProxyRouteCursorEndpointRequest",
+}) as any as S.Schema<PutCursorProxyRouteCursorEndpointRequest>;
+
+export interface PutCursorProxyRouteCursorEndpointResponse {
+  body: unknown;
+}
+export const PutCursorProxyRouteCursorEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PutCursorProxyRouteCursorEndpointResponse",
+  }) as any as S.Schema<PutCursorProxyRouteCursorEndpointResponse>;
+
+export interface PutGeminiProxyRouteGeminiEndpointRequest {
+  endpoint: string;
+}
+export const PutGeminiProxyRouteGeminiEndpointRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "PUT", uri: "/gemini/{endpoint}", code: 200 })),
+).annotate({
+  identifier: "PutGeminiProxyRouteGeminiEndpointRequest",
+}) as any as S.Schema<PutGeminiProxyRouteGeminiEndpointRequest>;
+
+export interface PutGeminiProxyRouteGeminiEndpointResponse {
+  body: unknown;
+}
+export const PutGeminiProxyRouteGeminiEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PutGeminiProxyRouteGeminiEndpointResponse",
+  }) as any as S.Schema<PutGeminiProxyRouteGeminiEndpointResponse>;
+
+export interface PutGigachatProxyRouteGigachatEndpointRequest {
+  endpoint: string;
+}
+export const PutGigachatProxyRouteGigachatEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "PUT", uri: "/gigachat/{endpoint}", code: 200 })),
+  ).annotate({
+    identifier: "PutGigachatProxyRouteGigachatEndpointRequest",
+  }) as any as S.Schema<PutGigachatProxyRouteGigachatEndpointRequest>;
+
+export interface PutGigachatProxyRouteGigachatEndpointResponse {
+  body: unknown;
+}
+export const PutGigachatProxyRouteGigachatEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PutGigachatProxyRouteGigachatEndpointResponse",
+  }) as any as S.Schema<PutGigachatProxyRouteGigachatEndpointResponse>;
+
+export interface PutMilvusProxyRouteMilvusEndpointRequest {
+  endpoint: string;
+}
+export const PutMilvusProxyRouteMilvusEndpointRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "PUT", uri: "/milvus/{endpoint}", code: 200 })),
+).annotate({
+  identifier: "PutMilvusProxyRouteMilvusEndpointRequest",
+}) as any as S.Schema<PutMilvusProxyRouteMilvusEndpointRequest>;
+
+export interface PutMilvusProxyRouteMilvusEndpointResponse {
+  body: unknown;
+}
+export const PutMilvusProxyRouteMilvusEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PutMilvusProxyRouteMilvusEndpointResponse",
+  }) as any as S.Schema<PutMilvusProxyRouteMilvusEndpointResponse>;
+
+export interface PutMistralProxyRouteMistralEndpointRequest {
+  endpoint: string;
+}
+export const PutMistralProxyRouteMistralEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "PUT", uri: "/mistral/{endpoint}", code: 200 })),
+  ).annotate({
+    identifier: "PutMistralProxyRouteMistralEndpointRequest",
+  }) as any as S.Schema<PutMistralProxyRouteMistralEndpointRequest>;
+
+export interface PutMistralProxyRouteMistralEndpointResponse {
+  body: unknown;
+}
+export const PutMistralProxyRouteMistralEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PutMistralProxyRouteMistralEndpointResponse",
+  }) as any as S.Schema<PutMistralProxyRouteMistralEndpointResponse>;
+
+export interface PutNvidiaNimProxyRouteNvidiaNimEndpointRequest {
+  endpoint: string;
+}
+export const PutNvidiaNimProxyRouteNvidiaNimEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({ method: "PUT", uri: "/nvidia_nim/{endpoint}", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "PutNvidiaNimProxyRouteNvidiaNimEndpointRequest",
+  }) as any as S.Schema<PutNvidiaNimProxyRouteNvidiaNimEndpointRequest>;
+
+export interface PutNvidiaNimProxyRouteNvidiaNimEndpointResponse {
+  body: unknown;
+}
+export const PutNvidiaNimProxyRouteNvidiaNimEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PutNvidiaNimProxyRouteNvidiaNimEndpointResponse",
+  }) as any as S.Schema<PutNvidiaNimProxyRouteNvidiaNimEndpointResponse>;
+
+export interface PutOpenaiProxyRouteOpenaiEndpointRequest {
+  endpoint: string;
+}
+export const PutOpenaiProxyRouteOpenaiEndpointRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "PUT", uri: "/openai/{endpoint}", code: 200 })),
+).annotate({
+  identifier: "PutOpenaiProxyRouteOpenaiEndpointRequest",
+}) as any as S.Schema<PutOpenaiProxyRouteOpenaiEndpointRequest>;
+
+export interface PutOpenaiProxyRouteOpenaiEndpointResponse {
+  body: unknown;
+}
+export const PutOpenaiProxyRouteOpenaiEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PutOpenaiProxyRouteOpenaiEndpointResponse",
+  }) as any as S.Schema<PutOpenaiProxyRouteOpenaiEndpointResponse>;
+
+export interface PutTypesafeProxyRouteTypesafeEndpointRequest {
+  endpoint: string;
+}
+export const PutTypesafeProxyRouteTypesafeEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "PUT", uri: "/typesafe/{endpoint}", code: 200 })),
+  ).annotate({
+    identifier: "PutTypesafeProxyRouteTypesafeEndpointRequest",
+  }) as any as S.Schema<PutTypesafeProxyRouteTypesafeEndpointRequest>;
+
+export interface PutTypesafeProxyRouteTypesafeEndpointResponse {
+  body: unknown;
+}
+export const PutTypesafeProxyRouteTypesafeEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PutTypesafeProxyRouteTypesafeEndpointResponse",
+  }) as any as S.Schema<PutTypesafeProxyRouteTypesafeEndpointResponse>;
+
+export interface PutVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointRequest {
+  endpoint: string;
+}
+export const PutVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "PUT",
+        uri: "/vertex_ai/discovery/{endpoint}",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "PutVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointRequest",
+  }) as any as S.Schema<PutVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointRequest>;
+
+export interface PutVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointResponse {
+  body: unknown;
+}
+export const PutVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PutVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointResponse",
+  }) as any as S.Schema<PutVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointResponse>;
+
+export interface PutVertexProxyRouteVertexAiEndpointRequest {
+  endpoint: string;
+}
+export const PutVertexProxyRouteVertexAiEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "PUT", uri: "/vertex_ai/{endpoint}", code: 200 })),
+  ).annotate({
+    identifier: "PutVertexProxyRouteVertexAiEndpointRequest",
+  }) as any as S.Schema<PutVertexProxyRouteVertexAiEndpointRequest>;
+
+export interface PutVertexProxyRouteVertexAiEndpointResponse {
+  body: unknown;
+}
+export const PutVertexProxyRouteVertexAiEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PutVertexProxyRouteVertexAiEndpointResponse",
+  }) as any as S.Schema<PutVertexProxyRouteVertexAiEndpointResponse>;
+
+export interface PutVllmProxyRouteVllmEndpointRequest {
+  endpoint: string;
+}
+export const PutVllmProxyRouteVllmEndpointRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "PUT", uri: "/vllm/{endpoint}", code: 200 })),
+).annotate({
+  identifier: "PutVllmProxyRouteVllmEndpointRequest",
+}) as any as S.Schema<PutVllmProxyRouteVllmEndpointRequest>;
+
+export interface PutVllmProxyRouteVllmEndpointResponse {
+  body: unknown;
+}
+export const PutVllmProxyRouteVllmEndpointResponse = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+).annotate({
+  identifier: "PutVllmProxyRouteVllmEndpointResponse",
+}) as any as S.Schema<PutVllmProxyRouteVllmEndpointResponse>;
+
+export interface PutWatsonxProxyRouteWatsonxEndpointRequest {
+  endpoint: string;
+}
+export const PutWatsonxProxyRouteWatsonxEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "PUT", uri: "/watsonx/{endpoint}", code: 200 })),
+  ).annotate({
+    identifier: "PutWatsonxProxyRouteWatsonxEndpointRequest",
+  }) as any as S.Schema<PutWatsonxProxyRouteWatsonxEndpointRequest>;
+
+export interface PutWatsonxProxyRouteWatsonxEndpointResponse {
+  body: unknown;
+}
+export const PutWatsonxProxyRouteWatsonxEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PutWatsonxProxyRouteWatsonxEndpointResponse",
+  }) as any as S.Schema<PutWatsonxProxyRouteWatsonxEndpointResponse>;
+
+export type CreateRealtimeClientSecretOpenaiV1RealtimeClientSecretsPostError =
+  LitellmOpError;
+/** Create Realtime Client Secret */
+export const createRealtimeClientSecretOpenaiV1RealtimeClientSecretsPost: API.OperationMethod<
+  CreateRealtimeClientSecretOpenaiV1RealtimeClientSecretsPostRequest,
+  RealtimeClientSecretResponse,
+  CreateRealtimeClientSecretOpenaiV1RealtimeClientSecretsPostError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateRealtimeClientSecretOpenaiV1RealtimeClientSecretsPostRequest,
+  output: RealtimeClientSecretResponse,
+  errors: [],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const createRealtimeTranscriptionSessionOpenaiV1RealtimeTranscriptionSessionsPost: API.OperationMethod<
+  CreateRealtimeTranscriptionSessionOpenaiV1RealtimeTranscriptionSessionsPostRequest,
+  RealtimeTranscriptionSessionResponse,
+  CreateRealtimeTranscriptionSessionOpenaiV1RealtimeTranscriptionSessionsPostError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input:
+    CreateRealtimeTranscriptionSessionOpenaiV1RealtimeTranscriptionSessionsPostRequest,
+  output: RealtimeTranscriptionSessionResponse,
+  errors: [],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteAnthropicProxyRouteAnthropicEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Anthropic Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/anthropic_completion) */
+export const deleteAnthropicProxyRouteAnthropicEndpoint: API.OperationMethod<
+  DeleteAnthropicProxyRouteAnthropicEndpointRequest,
+  DeleteAnthropicProxyRouteAnthropicEndpointResponse,
+  DeleteAnthropicProxyRouteAnthropicEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteAnthropicProxyRouteAnthropicEndpointRequest,
+  output: DeleteAnthropicProxyRouteAnthropicEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteAssemblyaiProxyRouteAssemblyaiEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Assemblyai Proxy Route */
+export const deleteAssemblyaiProxyRouteAssemblyaiEndpoint: API.OperationMethod<
+  DeleteAssemblyaiProxyRouteAssemblyaiEndpointRequest,
+  DeleteAssemblyaiProxyRouteAssemblyaiEndpointResponse,
+  DeleteAssemblyaiProxyRouteAssemblyaiEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteAssemblyaiProxyRouteAssemblyaiEndpointRequest,
+  output: DeleteAssemblyaiProxyRouteAssemblyaiEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteAssemblyaiProxyRouteEuAssemblyaiEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Assemblyai Proxy Route */
+export const deleteAssemblyaiProxyRouteEuAssemblyaiEndpoint: API.OperationMethod<
+  DeleteAssemblyaiProxyRouteEuAssemblyaiEndpointRequest,
+  DeleteAssemblyaiProxyRouteEuAssemblyaiEndpointResponse,
+  DeleteAssemblyaiProxyRouteEuAssemblyaiEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteAssemblyaiProxyRouteEuAssemblyaiEndpointRequest,
+  output: DeleteAssemblyaiProxyRouteEuAssemblyaiEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const deleteAzureProxyRouteAzureAiEndpoint: API.OperationMethod<
+  DeleteAzureProxyRouteAzureAiEndpointRequest,
+  DeleteAzureProxyRouteAzureAiEndpointResponse,
+  DeleteAzureProxyRouteAzureAiEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteAzureProxyRouteAzureAiEndpointRequest,
+  output: DeleteAzureProxyRouteAzureAiEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const deleteAzureProxyRouteAzureEndpoint: API.OperationMethod<
+  DeleteAzureProxyRouteAzureEndpointRequest,
+  DeleteAzureProxyRouteAzureEndpointResponse,
+  DeleteAzureProxyRouteAzureEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteAzureProxyRouteAzureEndpointRequest,
+  output: DeleteAzureProxyRouteAzureEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const deleteAzureSpeechProxyRouteAzureSpeechEndpoint: API.OperationMethod<
+  DeleteAzureSpeechProxyRouteAzureSpeechEndpointRequest,
+  DeleteAzureSpeechProxyRouteAzureSpeechEndpointResponse,
+  DeleteAzureSpeechProxyRouteAzureSpeechEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteAzureSpeechProxyRouteAzureSpeechEndpointRequest,
+  output: DeleteAzureSpeechProxyRouteAzureSpeechEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const deleteBedrockProxyRouteBedrockEndpoint: API.OperationMethod<
+  DeleteBedrockProxyRouteBedrockEndpointRequest,
+  DeleteBedrockProxyRouteBedrockEndpointResponse,
+  DeleteBedrockProxyRouteBedrockEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteBedrockProxyRouteBedrockEndpointRequest,
+  output: DeleteBedrockProxyRouteBedrockEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteCohereProxyRouteCohereEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Cohere Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/cohere) */
+export const deleteCohereProxyRouteCohereEndpoint: API.OperationMethod<
+  DeleteCohereProxyRouteCohereEndpointRequest,
+  DeleteCohereProxyRouteCohereEndpointResponse,
+  DeleteCohereProxyRouteCohereEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteCohereProxyRouteCohereEndpointRequest,
+  output: DeleteCohereProxyRouteCohereEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const deleteCursorProxyRouteCursorEndpoint: API.OperationMethod<
+  DeleteCursorProxyRouteCursorEndpointRequest,
+  DeleteCursorProxyRouteCursorEndpointResponse,
+  DeleteCursorProxyRouteCursorEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteCursorProxyRouteCursorEndpointRequest,
+  output: DeleteCursorProxyRouteCursorEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteGeminiProxyRouteGeminiEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Gemini Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/google_ai_studio) */
+export const deleteGeminiProxyRouteGeminiEndpoint: API.OperationMethod<
+  DeleteGeminiProxyRouteGeminiEndpointRequest,
+  DeleteGeminiProxyRouteGeminiEndpointResponse,
+  DeleteGeminiProxyRouteGeminiEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteGeminiProxyRouteGeminiEndpointRequest,
+  output: DeleteGeminiProxyRouteGeminiEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteGigachatProxyRouteGigachatEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Gigachat Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/gigachat) */
+export const deleteGigachatProxyRouteGigachatEndpoint: API.OperationMethod<
+  DeleteGigachatProxyRouteGigachatEndpointRequest,
+  DeleteGigachatProxyRouteGigachatEndpointResponse,
+  DeleteGigachatProxyRouteGigachatEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteGigachatProxyRouteGigachatEndpointRequest,
+  output: DeleteGigachatProxyRouteGigachatEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteMilvusProxyRouteMilvusEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Milvus Proxy Route Enable using Milvus `/vectors` endpoint as a pass-through endpoint. */
+export const deleteMilvusProxyRouteMilvusEndpoint: API.OperationMethod<
+  DeleteMilvusProxyRouteMilvusEndpointRequest,
+  DeleteMilvusProxyRouteMilvusEndpointResponse,
+  DeleteMilvusProxyRouteMilvusEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteMilvusProxyRouteMilvusEndpointRequest,
+  output: DeleteMilvusProxyRouteMilvusEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteMistralProxyRouteMistralEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Mistral Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/mistral) */
+export const deleteMistralProxyRouteMistralEndpoint: API.OperationMethod<
+  DeleteMistralProxyRouteMistralEndpointRequest,
+  DeleteMistralProxyRouteMistralEndpointResponse,
+  DeleteMistralProxyRouteMistralEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteMistralProxyRouteMistralEndpointRequest,
+  output: DeleteMistralProxyRouteMistralEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const deleteNvidiaNimProxyRouteNvidiaNimEndpoint: API.OperationMethod<
+  DeleteNvidiaNimProxyRouteNvidiaNimEndpointRequest,
+  DeleteNvidiaNimProxyRouteNvidiaNimEndpointResponse,
+  DeleteNvidiaNimProxyRouteNvidiaNimEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteNvidiaNimProxyRouteNvidiaNimEndpointRequest,
+  output: DeleteNvidiaNimProxyRouteNvidiaNimEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const deleteOpenaiProxyRouteOpenaiEndpoint: API.OperationMethod<
+  DeleteOpenaiProxyRouteOpenaiEndpointRequest,
+  DeleteOpenaiProxyRouteOpenaiEndpointResponse,
+  DeleteOpenaiProxyRouteOpenaiEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteOpenaiProxyRouteOpenaiEndpointRequest,
+  output: DeleteOpenaiProxyRouteOpenaiEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteTypesafeProxyRouteTypesafeEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Typesafe Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/typesafe) */
+export const deleteTypesafeProxyRouteTypesafeEndpoint: API.OperationMethod<
+  DeleteTypesafeProxyRouteTypesafeEndpointRequest,
+  DeleteTypesafeProxyRouteTypesafeEndpointResponse,
+  DeleteTypesafeProxyRouteTypesafeEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteTypesafeProxyRouteTypesafeEndpointRequest,
+  output: DeleteTypesafeProxyRouteTypesafeEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const deleteVertexDiscoveryProxyRouteVertexAiDiscoveryEndpoint: API.OperationMethod<
+  DeleteVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointRequest,
+  DeleteVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointResponse,
+  DeleteVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointRequest,
+  output: DeleteVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const deleteVertexProxyRouteVertexAiEndpoint: API.OperationMethod<
+  DeleteVertexProxyRouteVertexAiEndpointRequest,
+  DeleteVertexProxyRouteVertexAiEndpointResponse,
+  DeleteVertexProxyRouteVertexAiEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteVertexProxyRouteVertexAiEndpointRequest,
+  output: DeleteVertexProxyRouteVertexAiEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteVllmProxyRouteVllmEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Vllm Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/vllm) */
+export const deleteVllmProxyRouteVllmEndpoint: API.OperationMethod<
+  DeleteVllmProxyRouteVllmEndpointRequest,
+  DeleteVllmProxyRouteVllmEndpointResponse,
+  DeleteVllmProxyRouteVllmEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteVllmProxyRouteVllmEndpointRequest,
+  output: DeleteVllmProxyRouteVllmEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const deleteWatsonxProxyRouteWatsonxEndpoint: API.OperationMethod<
+  DeleteWatsonxProxyRouteWatsonxEndpointRequest,
+  DeleteWatsonxProxyRouteWatsonxEndpointResponse,
+  DeleteWatsonxProxyRouteWatsonxEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteWatsonxProxyRouteWatsonxEndpointRequest,
+  output: DeleteWatsonxProxyRouteWatsonxEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetAnthropicProxyRouteAnthropicEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Anthropic Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/anthropic_completion) */
+export const getAnthropicProxyRouteAnthropicEndpoint: API.OperationMethod<
+  GetAnthropicProxyRouteAnthropicEndpointRequest,
+  GetAnthropicProxyRouteAnthropicEndpointResponse,
+  GetAnthropicProxyRouteAnthropicEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetAnthropicProxyRouteAnthropicEndpointRequest,
+  output: GetAnthropicProxyRouteAnthropicEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetAssemblyaiProxyRouteAssemblyaiEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Assemblyai Proxy Route */
+export const getAssemblyaiProxyRouteAssemblyaiEndpoint: API.OperationMethod<
+  GetAssemblyaiProxyRouteAssemblyaiEndpointRequest,
+  GetAssemblyaiProxyRouteAssemblyaiEndpointResponse,
+  GetAssemblyaiProxyRouteAssemblyaiEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetAssemblyaiProxyRouteAssemblyaiEndpointRequest,
+  output: GetAssemblyaiProxyRouteAssemblyaiEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetAssemblyaiProxyRouteEuAssemblyaiEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Assemblyai Proxy Route */
+export const getAssemblyaiProxyRouteEuAssemblyaiEndpoint: API.OperationMethod<
+  GetAssemblyaiProxyRouteEuAssemblyaiEndpointRequest,
+  GetAssemblyaiProxyRouteEuAssemblyaiEndpointResponse,
+  GetAssemblyaiProxyRouteEuAssemblyaiEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetAssemblyaiProxyRouteEuAssemblyaiEndpointRequest,
+  output: GetAssemblyaiProxyRouteEuAssemblyaiEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const getAzureProxyRouteAzureAiEndpoint: API.OperationMethod<
+  GetAzureProxyRouteAzureAiEndpointRequest,
+  GetAzureProxyRouteAzureAiEndpointResponse,
+  GetAzureProxyRouteAzureAiEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetAzureProxyRouteAzureAiEndpointRequest,
+  output: GetAzureProxyRouteAzureAiEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const getAzureProxyRouteAzureEndpoint: API.OperationMethod<
+  GetAzureProxyRouteAzureEndpointRequest,
+  GetAzureProxyRouteAzureEndpointResponse,
+  GetAzureProxyRouteAzureEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetAzureProxyRouteAzureEndpointRequest,
+  output: GetAzureProxyRouteAzureEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const getAzureSpeechProxyRouteAzureSpeechEndpoint: API.OperationMethod<
+  GetAzureSpeechProxyRouteAzureSpeechEndpointRequest,
+  GetAzureSpeechProxyRouteAzureSpeechEndpointResponse,
+  GetAzureSpeechProxyRouteAzureSpeechEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetAzureSpeechProxyRouteAzureSpeechEndpointRequest,
+  output: GetAzureSpeechProxyRouteAzureSpeechEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const getBedrockProxyRouteBedrockEndpoint: API.OperationMethod<
+  GetBedrockProxyRouteBedrockEndpointRequest,
+  GetBedrockProxyRouteBedrockEndpointResponse,
+  GetBedrockProxyRouteBedrockEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetBedrockProxyRouteBedrockEndpointRequest,
+  output: GetBedrockProxyRouteBedrockEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetCohereProxyRouteCohereEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Cohere Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/cohere) */
+export const getCohereProxyRouteCohereEndpoint: API.OperationMethod<
+  GetCohereProxyRouteCohereEndpointRequest,
+  GetCohereProxyRouteCohereEndpointResponse,
+  GetCohereProxyRouteCohereEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetCohereProxyRouteCohereEndpointRequest,
+  output: GetCohereProxyRouteCohereEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const getCursorProxyRouteCursorEndpoint: API.OperationMethod<
+  GetCursorProxyRouteCursorEndpointRequest,
+  GetCursorProxyRouteCursorEndpointResponse,
+  GetCursorProxyRouteCursorEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetCursorProxyRouteCursorEndpointRequest,
+  output: GetCursorProxyRouteCursorEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetGeminiProxyRouteGeminiEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Gemini Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/google_ai_studio) */
+export const getGeminiProxyRouteGeminiEndpoint: API.OperationMethod<
+  GetGeminiProxyRouteGeminiEndpointRequest,
+  GetGeminiProxyRouteGeminiEndpointResponse,
+  GetGeminiProxyRouteGeminiEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetGeminiProxyRouteGeminiEndpointRequest,
+  output: GetGeminiProxyRouteGeminiEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetGigachatProxyRouteGigachatEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Gigachat Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/gigachat) */
+export const getGigachatProxyRouteGigachatEndpoint: API.OperationMethod<
+  GetGigachatProxyRouteGigachatEndpointRequest,
+  GetGigachatProxyRouteGigachatEndpointResponse,
+  GetGigachatProxyRouteGigachatEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetGigachatProxyRouteGigachatEndpointRequest,
+  output: GetGigachatProxyRouteGigachatEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetMilvusProxyRouteMilvusEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Milvus Proxy Route Enable using Milvus `/vectors` endpoint as a pass-through endpoint. */
+export const getMilvusProxyRouteMilvusEndpoint: API.OperationMethod<
+  GetMilvusProxyRouteMilvusEndpointRequest,
+  GetMilvusProxyRouteMilvusEndpointResponse,
+  GetMilvusProxyRouteMilvusEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetMilvusProxyRouteMilvusEndpointRequest,
+  output: GetMilvusProxyRouteMilvusEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetMistralProxyRouteMistralEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Mistral Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/mistral) */
+export const getMistralProxyRouteMistralEndpoint: API.OperationMethod<
+  GetMistralProxyRouteMistralEndpointRequest,
+  GetMistralProxyRouteMistralEndpointResponse,
+  GetMistralProxyRouteMistralEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetMistralProxyRouteMistralEndpointRequest,
+  output: GetMistralProxyRouteMistralEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const getNvidiaNimProxyRouteNvidiaNimEndpoint: API.OperationMethod<
+  GetNvidiaNimProxyRouteNvidiaNimEndpointRequest,
+  GetNvidiaNimProxyRouteNvidiaNimEndpointResponse,
+  GetNvidiaNimProxyRouteNvidiaNimEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetNvidiaNimProxyRouteNvidiaNimEndpointRequest,
+  output: GetNvidiaNimProxyRouteNvidiaNimEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const getOpenaiProxyRouteOpenaiEndpoint: API.OperationMethod<
+  GetOpenaiProxyRouteOpenaiEndpointRequest,
+  GetOpenaiProxyRouteOpenaiEndpointResponse,
+  GetOpenaiProxyRouteOpenaiEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetOpenaiProxyRouteOpenaiEndpointRequest,
+  output: GetOpenaiProxyRouteOpenaiEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetTypesafeProxyRouteTypesafeEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Typesafe Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/typesafe) */
+export const getTypesafeProxyRouteTypesafeEndpoint: API.OperationMethod<
+  GetTypesafeProxyRouteTypesafeEndpointRequest,
+  GetTypesafeProxyRouteTypesafeEndpointResponse,
+  GetTypesafeProxyRouteTypesafeEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetTypesafeProxyRouteTypesafeEndpointRequest,
+  output: GetTypesafeProxyRouteTypesafeEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const getVertexDiscoveryProxyRouteVertexAiDiscoveryEndpoint: API.OperationMethod<
+  GetVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointRequest,
+  GetVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointResponse,
+  GetVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointRequest,
+  output: GetVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const getVertexProxyRouteVertexAiEndpoint: API.OperationMethod<
+  GetVertexProxyRouteVertexAiEndpointRequest,
+  GetVertexProxyRouteVertexAiEndpointResponse,
+  GetVertexProxyRouteVertexAiEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetVertexProxyRouteVertexAiEndpointRequest,
+  output: GetVertexProxyRouteVertexAiEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetVllmProxyRouteVllmEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Vllm Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/vllm) */
+export const getVllmProxyRouteVllmEndpoint: API.OperationMethod<
+  GetVllmProxyRouteVllmEndpointRequest,
+  GetVllmProxyRouteVllmEndpointResponse,
+  GetVllmProxyRouteVllmEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetVllmProxyRouteVllmEndpointRequest,
+  output: GetVllmProxyRouteVllmEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const getWatsonxProxyRouteWatsonxEndpoint: API.OperationMethod<
+  GetWatsonxProxyRouteWatsonxEndpointRequest,
+  GetWatsonxProxyRouteWatsonxEndpointResponse,
+  GetWatsonxProxyRouteWatsonxEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetWatsonxProxyRouteWatsonxEndpointRequest,
+  output: GetWatsonxProxyRouteWatsonxEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PatchAnthropicProxyRouteAnthropicEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Anthropic Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/anthropic_completion) */
+export const patchAnthropicProxyRouteAnthropicEndpoint: API.OperationMethod<
+  PatchAnthropicProxyRouteAnthropicEndpointRequest,
+  PatchAnthropicProxyRouteAnthropicEndpointResponse,
+  PatchAnthropicProxyRouteAnthropicEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PatchAnthropicProxyRouteAnthropicEndpointRequest,
+  output: PatchAnthropicProxyRouteAnthropicEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PatchAssemblyaiProxyRouteAssemblyaiEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Assemblyai Proxy Route */
+export const patchAssemblyaiProxyRouteAssemblyaiEndpoint: API.OperationMethod<
+  PatchAssemblyaiProxyRouteAssemblyaiEndpointRequest,
+  PatchAssemblyaiProxyRouteAssemblyaiEndpointResponse,
+  PatchAssemblyaiProxyRouteAssemblyaiEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PatchAssemblyaiProxyRouteAssemblyaiEndpointRequest,
+  output: PatchAssemblyaiProxyRouteAssemblyaiEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PatchAssemblyaiProxyRouteEuAssemblyaiEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Assemblyai Proxy Route */
+export const patchAssemblyaiProxyRouteEuAssemblyaiEndpoint: API.OperationMethod<
+  PatchAssemblyaiProxyRouteEuAssemblyaiEndpointRequest,
+  PatchAssemblyaiProxyRouteEuAssemblyaiEndpointResponse,
+  PatchAssemblyaiProxyRouteEuAssemblyaiEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PatchAssemblyaiProxyRouteEuAssemblyaiEndpointRequest,
+  output: PatchAssemblyaiProxyRouteEuAssemblyaiEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const patchAzureProxyRouteAzureAiEndpoint: API.OperationMethod<
+  PatchAzureProxyRouteAzureAiEndpointRequest,
+  PatchAzureProxyRouteAzureAiEndpointResponse,
+  PatchAzureProxyRouteAzureAiEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PatchAzureProxyRouteAzureAiEndpointRequest,
+  output: PatchAzureProxyRouteAzureAiEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const patchAzureProxyRouteAzureEndpoint: API.OperationMethod<
+  PatchAzureProxyRouteAzureEndpointRequest,
+  PatchAzureProxyRouteAzureEndpointResponse,
+  PatchAzureProxyRouteAzureEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PatchAzureProxyRouteAzureEndpointRequest,
+  output: PatchAzureProxyRouteAzureEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const patchAzureSpeechProxyRouteAzureSpeechEndpoint: API.OperationMethod<
+  PatchAzureSpeechProxyRouteAzureSpeechEndpointRequest,
+  PatchAzureSpeechProxyRouteAzureSpeechEndpointResponse,
+  PatchAzureSpeechProxyRouteAzureSpeechEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PatchAzureSpeechProxyRouteAzureSpeechEndpointRequest,
+  output: PatchAzureSpeechProxyRouteAzureSpeechEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const patchBedrockProxyRouteBedrockEndpoint: API.OperationMethod<
+  PatchBedrockProxyRouteBedrockEndpointRequest,
+  PatchBedrockProxyRouteBedrockEndpointResponse,
+  PatchBedrockProxyRouteBedrockEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PatchBedrockProxyRouteBedrockEndpointRequest,
+  output: PatchBedrockProxyRouteBedrockEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PatchCohereProxyRouteCohereEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Cohere Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/cohere) */
+export const patchCohereProxyRouteCohereEndpoint: API.OperationMethod<
+  PatchCohereProxyRouteCohereEndpointRequest,
+  PatchCohereProxyRouteCohereEndpointResponse,
+  PatchCohereProxyRouteCohereEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PatchCohereProxyRouteCohereEndpointRequest,
+  output: PatchCohereProxyRouteCohereEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const patchCursorProxyRouteCursorEndpoint: API.OperationMethod<
+  PatchCursorProxyRouteCursorEndpointRequest,
+  PatchCursorProxyRouteCursorEndpointResponse,
+  PatchCursorProxyRouteCursorEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PatchCursorProxyRouteCursorEndpointRequest,
+  output: PatchCursorProxyRouteCursorEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PatchGeminiProxyRouteGeminiEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Gemini Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/google_ai_studio) */
+export const patchGeminiProxyRouteGeminiEndpoint: API.OperationMethod<
+  PatchGeminiProxyRouteGeminiEndpointRequest,
+  PatchGeminiProxyRouteGeminiEndpointResponse,
+  PatchGeminiProxyRouteGeminiEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PatchGeminiProxyRouteGeminiEndpointRequest,
+  output: PatchGeminiProxyRouteGeminiEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PatchGigachatProxyRouteGigachatEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Gigachat Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/gigachat) */
+export const patchGigachatProxyRouteGigachatEndpoint: API.OperationMethod<
+  PatchGigachatProxyRouteGigachatEndpointRequest,
+  PatchGigachatProxyRouteGigachatEndpointResponse,
+  PatchGigachatProxyRouteGigachatEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PatchGigachatProxyRouteGigachatEndpointRequest,
+  output: PatchGigachatProxyRouteGigachatEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PatchMilvusProxyRouteMilvusEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Milvus Proxy Route Enable using Milvus `/vectors` endpoint as a pass-through endpoint. */
+export const patchMilvusProxyRouteMilvusEndpoint: API.OperationMethod<
+  PatchMilvusProxyRouteMilvusEndpointRequest,
+  PatchMilvusProxyRouteMilvusEndpointResponse,
+  PatchMilvusProxyRouteMilvusEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PatchMilvusProxyRouteMilvusEndpointRequest,
+  output: PatchMilvusProxyRouteMilvusEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PatchMistralProxyRouteMistralEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Mistral Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/mistral) */
+export const patchMistralProxyRouteMistralEndpoint: API.OperationMethod<
+  PatchMistralProxyRouteMistralEndpointRequest,
+  PatchMistralProxyRouteMistralEndpointResponse,
+  PatchMistralProxyRouteMistralEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PatchMistralProxyRouteMistralEndpointRequest,
+  output: PatchMistralProxyRouteMistralEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const patchNvidiaNimProxyRouteNvidiaNimEndpoint: API.OperationMethod<
+  PatchNvidiaNimProxyRouteNvidiaNimEndpointRequest,
+  PatchNvidiaNimProxyRouteNvidiaNimEndpointResponse,
+  PatchNvidiaNimProxyRouteNvidiaNimEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PatchNvidiaNimProxyRouteNvidiaNimEndpointRequest,
+  output: PatchNvidiaNimProxyRouteNvidiaNimEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const patchOpenaiProxyRouteOpenaiEndpoint: API.OperationMethod<
+  PatchOpenaiProxyRouteOpenaiEndpointRequest,
+  PatchOpenaiProxyRouteOpenaiEndpointResponse,
+  PatchOpenaiProxyRouteOpenaiEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PatchOpenaiProxyRouteOpenaiEndpointRequest,
+  output: PatchOpenaiProxyRouteOpenaiEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PatchTypesafeProxyRouteTypesafeEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Typesafe Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/typesafe) */
+export const patchTypesafeProxyRouteTypesafeEndpoint: API.OperationMethod<
+  PatchTypesafeProxyRouteTypesafeEndpointRequest,
+  PatchTypesafeProxyRouteTypesafeEndpointResponse,
+  PatchTypesafeProxyRouteTypesafeEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PatchTypesafeProxyRouteTypesafeEndpointRequest,
+  output: PatchTypesafeProxyRouteTypesafeEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const patchVertexDiscoveryProxyRouteVertexAiDiscoveryEndpoint: API.OperationMethod<
+  PatchVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointRequest,
+  PatchVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointResponse,
+  PatchVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PatchVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointRequest,
+  output: PatchVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const patchVertexProxyRouteVertexAiEndpoint: API.OperationMethod<
+  PatchVertexProxyRouteVertexAiEndpointRequest,
+  PatchVertexProxyRouteVertexAiEndpointResponse,
+  PatchVertexProxyRouteVertexAiEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PatchVertexProxyRouteVertexAiEndpointRequest,
+  output: PatchVertexProxyRouteVertexAiEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PatchVllmProxyRouteVllmEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Vllm Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/vllm) */
+export const patchVllmProxyRouteVllmEndpoint: API.OperationMethod<
+  PatchVllmProxyRouteVllmEndpointRequest,
+  PatchVllmProxyRouteVllmEndpointResponse,
+  PatchVllmProxyRouteVllmEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PatchVllmProxyRouteVllmEndpointRequest,
+  output: PatchVllmProxyRouteVllmEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const patchWatsonxProxyRouteWatsonxEndpoint: API.OperationMethod<
+  PatchWatsonxProxyRouteWatsonxEndpointRequest,
+  PatchWatsonxProxyRouteWatsonxEndpointResponse,
+  PatchWatsonxProxyRouteWatsonxEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PatchWatsonxProxyRouteWatsonxEndpointRequest,
+  output: PatchWatsonxProxyRouteWatsonxEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PostAnthropicProxyRouteAnthropicEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Anthropic Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/anthropic_completion) */
+export const postAnthropicProxyRouteAnthropicEndpoint: API.OperationMethod<
+  PostAnthropicProxyRouteAnthropicEndpointRequest,
+  PostAnthropicProxyRouteAnthropicEndpointResponse,
+  PostAnthropicProxyRouteAnthropicEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PostAnthropicProxyRouteAnthropicEndpointRequest,
+  output: PostAnthropicProxyRouteAnthropicEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PostAssemblyaiProxyRouteAssemblyaiEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Assemblyai Proxy Route */
+export const postAssemblyaiProxyRouteAssemblyaiEndpoint: API.OperationMethod<
+  PostAssemblyaiProxyRouteAssemblyaiEndpointRequest,
+  PostAssemblyaiProxyRouteAssemblyaiEndpointResponse,
+  PostAssemblyaiProxyRouteAssemblyaiEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PostAssemblyaiProxyRouteAssemblyaiEndpointRequest,
+  output: PostAssemblyaiProxyRouteAssemblyaiEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PostAssemblyaiProxyRouteEuAssemblyaiEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Assemblyai Proxy Route */
+export const postAssemblyaiProxyRouteEuAssemblyaiEndpoint: API.OperationMethod<
+  PostAssemblyaiProxyRouteEuAssemblyaiEndpointRequest,
+  PostAssemblyaiProxyRouteEuAssemblyaiEndpointResponse,
+  PostAssemblyaiProxyRouteEuAssemblyaiEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PostAssemblyaiProxyRouteEuAssemblyaiEndpointRequest,
+  output: PostAssemblyaiProxyRouteEuAssemblyaiEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const postAzureProxyRouteAzureAiEndpoint: API.OperationMethod<
+  PostAzureProxyRouteAzureAiEndpointRequest,
+  PostAzureProxyRouteAzureAiEndpointResponse,
+  PostAzureProxyRouteAzureAiEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PostAzureProxyRouteAzureAiEndpointRequest,
+  output: PostAzureProxyRouteAzureAiEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const postAzureProxyRouteAzureEndpoint: API.OperationMethod<
+  PostAzureProxyRouteAzureEndpointRequest,
+  PostAzureProxyRouteAzureEndpointResponse,
+  PostAzureProxyRouteAzureEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PostAzureProxyRouteAzureEndpointRequest,
+  output: PostAzureProxyRouteAzureEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const postAzureSpeechProxyRouteAzureSpeechEndpoint: API.OperationMethod<
+  PostAzureSpeechProxyRouteAzureSpeechEndpointRequest,
+  PostAzureSpeechProxyRouteAzureSpeechEndpointResponse,
+  PostAzureSpeechProxyRouteAzureSpeechEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PostAzureSpeechProxyRouteAzureSpeechEndpointRequest,
+  output: PostAzureSpeechProxyRouteAzureSpeechEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const postBedrockProxyRouteBedrockEndpoint: API.OperationMethod<
+  PostBedrockProxyRouteBedrockEndpointRequest,
+  PostBedrockProxyRouteBedrockEndpointResponse,
+  PostBedrockProxyRouteBedrockEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PostBedrockProxyRouteBedrockEndpointRequest,
+  output: PostBedrockProxyRouteBedrockEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PostCohereProxyRouteCohereEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Cohere Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/cohere) */
+export const postCohereProxyRouteCohereEndpoint: API.OperationMethod<
+  PostCohereProxyRouteCohereEndpointRequest,
+  PostCohereProxyRouteCohereEndpointResponse,
+  PostCohereProxyRouteCohereEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PostCohereProxyRouteCohereEndpointRequest,
+  output: PostCohereProxyRouteCohereEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const postComprehendMedicalProxyRouteComprehendmedicalOperation: API.OperationMethod<
+  PostComprehendMedicalProxyRouteComprehendmedicalOperationRequest,
+  PostComprehendMedicalProxyRouteComprehendmedicalOperationResponse,
+  PostComprehendMedicalProxyRouteComprehendmedicalOperationError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PostComprehendMedicalProxyRouteComprehendmedicalOperationRequest,
+  output: PostComprehendMedicalProxyRouteComprehendmedicalOperationResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const postComprehendMedicalSdkProxyRouteComprehendmedical: API.OperationMethod<
+  PostComprehendMedicalSdkProxyRouteComprehendmedicalRequest,
+  PostComprehendMedicalSdkProxyRouteComprehendmedicalResponse,
+  PostComprehendMedicalSdkProxyRouteComprehendmedicalError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PostComprehendMedicalSdkProxyRouteComprehendmedicalRequest,
+  output: PostComprehendMedicalSdkProxyRouteComprehendmedicalResponse,
+  errors: [],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const postCursorProxyRouteCursorEndpoint: API.OperationMethod<
+  PostCursorProxyRouteCursorEndpointRequest,
+  PostCursorProxyRouteCursorEndpointResponse,
+  PostCursorProxyRouteCursorEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PostCursorProxyRouteCursorEndpointRequest,
+  output: PostCursorProxyRouteCursorEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PostGeminiProxyRouteGeminiEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Gemini Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/google_ai_studio) */
+export const postGeminiProxyRouteGeminiEndpoint: API.OperationMethod<
+  PostGeminiProxyRouteGeminiEndpointRequest,
+  PostGeminiProxyRouteGeminiEndpointResponse,
+  PostGeminiProxyRouteGeminiEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PostGeminiProxyRouteGeminiEndpointRequest,
+  output: PostGeminiProxyRouteGeminiEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PostGigachatProxyRouteGigachatEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Gigachat Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/gigachat) */
+export const postGigachatProxyRouteGigachatEndpoint: API.OperationMethod<
+  PostGigachatProxyRouteGigachatEndpointRequest,
+  PostGigachatProxyRouteGigachatEndpointResponse,
+  PostGigachatProxyRouteGigachatEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PostGigachatProxyRouteGigachatEndpointRequest,
+  output: PostGigachatProxyRouteGigachatEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PostMilvusProxyRouteMilvusEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Milvus Proxy Route Enable using Milvus `/vectors` endpoint as a pass-through endpoint. */
+export const postMilvusProxyRouteMilvusEndpoint: API.OperationMethod<
+  PostMilvusProxyRouteMilvusEndpointRequest,
+  PostMilvusProxyRouteMilvusEndpointResponse,
+  PostMilvusProxyRouteMilvusEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PostMilvusProxyRouteMilvusEndpointRequest,
+  output: PostMilvusProxyRouteMilvusEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PostMistralProxyRouteMistralEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Mistral Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/mistral) */
+export const postMistralProxyRouteMistralEndpoint: API.OperationMethod<
+  PostMistralProxyRouteMistralEndpointRequest,
+  PostMistralProxyRouteMistralEndpointResponse,
+  PostMistralProxyRouteMistralEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PostMistralProxyRouteMistralEndpointRequest,
+  output: PostMistralProxyRouteMistralEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const postNvidiaNimProxyRouteNvidiaNimEndpoint: API.OperationMethod<
+  PostNvidiaNimProxyRouteNvidiaNimEndpointRequest,
+  PostNvidiaNimProxyRouteNvidiaNimEndpointResponse,
+  PostNvidiaNimProxyRouteNvidiaNimEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PostNvidiaNimProxyRouteNvidiaNimEndpointRequest,
+  output: PostNvidiaNimProxyRouteNvidiaNimEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const postOpenaiProxyRouteOpenaiEndpoint: API.OperationMethod<
+  PostOpenaiProxyRouteOpenaiEndpointRequest,
+  PostOpenaiProxyRouteOpenaiEndpointResponse,
+  PostOpenaiProxyRouteOpenaiEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PostOpenaiProxyRouteOpenaiEndpointRequest,
+  output: PostOpenaiProxyRouteOpenaiEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PostProxyRealtimeCallsOpenaiV1RealtimeCallError = LitellmOpError;
+/** Proxy Realtime Calls */
+export const postProxyRealtimeCallsOpenaiV1RealtimeCall: API.OperationMethod<
+  PostProxyRealtimeCallsOpenaiV1RealtimeCallRequest,
+  PostProxyRealtimeCallsOpenaiV1RealtimeCallResponse,
+  PostProxyRealtimeCallsOpenaiV1RealtimeCallError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PostProxyRealtimeCallsOpenaiV1RealtimeCallRequest,
+  output: PostProxyRealtimeCallsOpenaiV1RealtimeCallResponse,
+  errors: [],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const postTranscribeProxyRouteTranscribeOperation: API.OperationMethod<
+  PostTranscribeProxyRouteTranscribeOperationRequest,
+  PostTranscribeProxyRouteTranscribeOperationResponse,
+  PostTranscribeProxyRouteTranscribeOperationError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PostTranscribeProxyRouteTranscribeOperationRequest,
+  output: PostTranscribeProxyRouteTranscribeOperationResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const postTranscribeSdkProxyRouteTranscribe: API.OperationMethod<
+  PostTranscribeSdkProxyRouteTranscribeRequest,
+  PostTranscribeSdkProxyRouteTranscribeResponse,
+  PostTranscribeSdkProxyRouteTranscribeError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PostTranscribeSdkProxyRouteTranscribeRequest,
+  output: PostTranscribeSdkProxyRouteTranscribeResponse,
+  errors: [],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PostTypesafeProxyRouteTypesafeEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Typesafe Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/typesafe) */
+export const postTypesafeProxyRouteTypesafeEndpoint: API.OperationMethod<
+  PostTypesafeProxyRouteTypesafeEndpointRequest,
+  PostTypesafeProxyRouteTypesafeEndpointResponse,
+  PostTypesafeProxyRouteTypesafeEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PostTypesafeProxyRouteTypesafeEndpointRequest,
+  output: PostTypesafeProxyRouteTypesafeEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const postVertexDiscoveryProxyRouteVertexAiDiscoveryEndpoint: API.OperationMethod<
+  PostVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointRequest,
+  PostVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointResponse,
+  PostVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PostVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointRequest,
+  output: PostVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const postVertexProxyRouteVertexAiEndpoint: API.OperationMethod<
+  PostVertexProxyRouteVertexAiEndpointRequest,
+  PostVertexProxyRouteVertexAiEndpointResponse,
+  PostVertexProxyRouteVertexAiEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PostVertexProxyRouteVertexAiEndpointRequest,
+  output: PostVertexProxyRouteVertexAiEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PostVllmProxyRouteVllmEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Vllm Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/vllm) */
+export const postVllmProxyRouteVllmEndpoint: API.OperationMethod<
+  PostVllmProxyRouteVllmEndpointRequest,
+  PostVllmProxyRouteVllmEndpointResponse,
+  PostVllmProxyRouteVllmEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PostVllmProxyRouteVllmEndpointRequest,
+  output: PostVllmProxyRouteVllmEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const postWatsonxProxyRouteWatsonxEndpoint: API.OperationMethod<
+  PostWatsonxProxyRouteWatsonxEndpointRequest,
+  PostWatsonxProxyRouteWatsonxEndpointResponse,
+  PostWatsonxProxyRouteWatsonxEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PostWatsonxProxyRouteWatsonxEndpointRequest,
+  output: PostWatsonxProxyRouteWatsonxEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutAnthropicProxyRouteAnthropicEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Anthropic Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/anthropic_completion) */
+export const putAnthropicProxyRouteAnthropicEndpoint: API.OperationMethod<
+  PutAnthropicProxyRouteAnthropicEndpointRequest,
+  PutAnthropicProxyRouteAnthropicEndpointResponse,
+  PutAnthropicProxyRouteAnthropicEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutAnthropicProxyRouteAnthropicEndpointRequest,
+  output: PutAnthropicProxyRouteAnthropicEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutAssemblyaiProxyRouteAssemblyaiEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Assemblyai Proxy Route */
+export const putAssemblyaiProxyRouteAssemblyaiEndpoint: API.OperationMethod<
+  PutAssemblyaiProxyRouteAssemblyaiEndpointRequest,
+  PutAssemblyaiProxyRouteAssemblyaiEndpointResponse,
+  PutAssemblyaiProxyRouteAssemblyaiEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutAssemblyaiProxyRouteAssemblyaiEndpointRequest,
+  output: PutAssemblyaiProxyRouteAssemblyaiEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutAssemblyaiProxyRouteEuAssemblyaiEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Assemblyai Proxy Route */
+export const putAssemblyaiProxyRouteEuAssemblyaiEndpoint: API.OperationMethod<
+  PutAssemblyaiProxyRouteEuAssemblyaiEndpointRequest,
+  PutAssemblyaiProxyRouteEuAssemblyaiEndpointResponse,
+  PutAssemblyaiProxyRouteEuAssemblyaiEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutAssemblyaiProxyRouteEuAssemblyaiEndpointRequest,
+  output: PutAssemblyaiProxyRouteEuAssemblyaiEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const putAzureProxyRouteAzureAiEndpoint: API.OperationMethod<
+  PutAzureProxyRouteAzureAiEndpointRequest,
+  PutAzureProxyRouteAzureAiEndpointResponse,
+  PutAzureProxyRouteAzureAiEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutAzureProxyRouteAzureAiEndpointRequest,
+  output: PutAzureProxyRouteAzureAiEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const putAzureProxyRouteAzureEndpoint: API.OperationMethod<
+  PutAzureProxyRouteAzureEndpointRequest,
+  PutAzureProxyRouteAzureEndpointResponse,
+  PutAzureProxyRouteAzureEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutAzureProxyRouteAzureEndpointRequest,
+  output: PutAzureProxyRouteAzureEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const putAzureSpeechProxyRouteAzureSpeechEndpoint: API.OperationMethod<
+  PutAzureSpeechProxyRouteAzureSpeechEndpointRequest,
+  PutAzureSpeechProxyRouteAzureSpeechEndpointResponse,
+  PutAzureSpeechProxyRouteAzureSpeechEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutAzureSpeechProxyRouteAzureSpeechEndpointRequest,
+  output: PutAzureSpeechProxyRouteAzureSpeechEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const putBedrockProxyRouteBedrockEndpoint: API.OperationMethod<
+  PutBedrockProxyRouteBedrockEndpointRequest,
+  PutBedrockProxyRouteBedrockEndpointResponse,
+  PutBedrockProxyRouteBedrockEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutBedrockProxyRouteBedrockEndpointRequest,
+  output: PutBedrockProxyRouteBedrockEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutCohereProxyRouteCohereEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Cohere Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/cohere) */
+export const putCohereProxyRouteCohereEndpoint: API.OperationMethod<
+  PutCohereProxyRouteCohereEndpointRequest,
+  PutCohereProxyRouteCohereEndpointResponse,
+  PutCohereProxyRouteCohereEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutCohereProxyRouteCohereEndpointRequest,
+  output: PutCohereProxyRouteCohereEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const putCursorProxyRouteCursorEndpoint: API.OperationMethod<
+  PutCursorProxyRouteCursorEndpointRequest,
+  PutCursorProxyRouteCursorEndpointResponse,
+  PutCursorProxyRouteCursorEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutCursorProxyRouteCursorEndpointRequest,
+  output: PutCursorProxyRouteCursorEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutGeminiProxyRouteGeminiEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Gemini Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/google_ai_studio) */
+export const putGeminiProxyRouteGeminiEndpoint: API.OperationMethod<
+  PutGeminiProxyRouteGeminiEndpointRequest,
+  PutGeminiProxyRouteGeminiEndpointResponse,
+  PutGeminiProxyRouteGeminiEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutGeminiProxyRouteGeminiEndpointRequest,
+  output: PutGeminiProxyRouteGeminiEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutGigachatProxyRouteGigachatEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Gigachat Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/gigachat) */
+export const putGigachatProxyRouteGigachatEndpoint: API.OperationMethod<
+  PutGigachatProxyRouteGigachatEndpointRequest,
+  PutGigachatProxyRouteGigachatEndpointResponse,
+  PutGigachatProxyRouteGigachatEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutGigachatProxyRouteGigachatEndpointRequest,
+  output: PutGigachatProxyRouteGigachatEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutMilvusProxyRouteMilvusEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Milvus Proxy Route Enable using Milvus `/vectors` endpoint as a pass-through endpoint. */
+export const putMilvusProxyRouteMilvusEndpoint: API.OperationMethod<
+  PutMilvusProxyRouteMilvusEndpointRequest,
+  PutMilvusProxyRouteMilvusEndpointResponse,
+  PutMilvusProxyRouteMilvusEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutMilvusProxyRouteMilvusEndpointRequest,
+  output: PutMilvusProxyRouteMilvusEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutMistralProxyRouteMistralEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Mistral Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/mistral) */
+export const putMistralProxyRouteMistralEndpoint: API.OperationMethod<
+  PutMistralProxyRouteMistralEndpointRequest,
+  PutMistralProxyRouteMistralEndpointResponse,
+  PutMistralProxyRouteMistralEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutMistralProxyRouteMistralEndpointRequest,
+  output: PutMistralProxyRouteMistralEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const putNvidiaNimProxyRouteNvidiaNimEndpoint: API.OperationMethod<
+  PutNvidiaNimProxyRouteNvidiaNimEndpointRequest,
+  PutNvidiaNimProxyRouteNvidiaNimEndpointResponse,
+  PutNvidiaNimProxyRouteNvidiaNimEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutNvidiaNimProxyRouteNvidiaNimEndpointRequest,
+  output: PutNvidiaNimProxyRouteNvidiaNimEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const putOpenaiProxyRouteOpenaiEndpoint: API.OperationMethod<
+  PutOpenaiProxyRouteOpenaiEndpointRequest,
+  PutOpenaiProxyRouteOpenaiEndpointResponse,
+  PutOpenaiProxyRouteOpenaiEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutOpenaiProxyRouteOpenaiEndpointRequest,
+  output: PutOpenaiProxyRouteOpenaiEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutTypesafeProxyRouteTypesafeEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Typesafe Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/typesafe) */
+export const putTypesafeProxyRouteTypesafeEndpoint: API.OperationMethod<
+  PutTypesafeProxyRouteTypesafeEndpointRequest,
+  PutTypesafeProxyRouteTypesafeEndpointResponse,
+  PutTypesafeProxyRouteTypesafeEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutTypesafeProxyRouteTypesafeEndpointRequest,
+  output: PutTypesafeProxyRouteTypesafeEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const putVertexDiscoveryProxyRouteVertexAiDiscoveryEndpoint: API.OperationMethod<
+  PutVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointRequest,
+  PutVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointResponse,
+  PutVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointRequest,
+  output: PutVertexDiscoveryProxyRouteVertexAiDiscoveryEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const putVertexProxyRouteVertexAiEndpoint: API.OperationMethod<
+  PutVertexProxyRouteVertexAiEndpointRequest,
+  PutVertexProxyRouteVertexAiEndpointResponse,
+  PutVertexProxyRouteVertexAiEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutVertexProxyRouteVertexAiEndpointRequest,
+  output: PutVertexProxyRouteVertexAiEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutVllmProxyRouteVllmEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Vllm Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/vllm) */
+export const putVllmProxyRouteVllmEndpoint: API.OperationMethod<
+  PutVllmProxyRouteVllmEndpointRequest,
+  PutVllmProxyRouteVllmEndpointResponse,
+  PutVllmProxyRouteVllmEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutVllmProxyRouteVllmEndpointRequest,
+  output: PutVllmProxyRouteVllmEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const putWatsonxProxyRouteWatsonxEndpoint: API.OperationMethod<
+  PutWatsonxProxyRouteWatsonxEndpointRequest,
+  PutWatsonxProxyRouteWatsonxEndpointResponse,
+  PutWatsonxProxyRouteWatsonxEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutWatsonxProxyRouteWatsonxEndpointRequest,
+  output: PutWatsonxProxyRouteWatsonxEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));