@homeflare/distilled-litellm 0.2.0

package/src/services/health.ts

@@ -0,0 +1,713 @@
+// AUTO-GENERATED by scripts/generate.ts from .generated-specs (pinned litellm-openapi @ 1.100.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 GetActiveCallbacksActiveCallbackRequest {}
+export const GetActiveCallbacksActiveCallbackRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({}).pipe(
+      T.Http({ method: "GET", uri: "/active/callbacks", code: 200 }),
+    ),
+).annotate({
+  identifier: "GetActiveCallbacksActiveCallbackRequest",
+}) as any as S.Schema<GetActiveCallbacksActiveCallbackRequest>;
+
+export interface GetActiveCallbacksActiveCallbackResponse {
+  body: unknown;
+}
+export const GetActiveCallbacksActiveCallbackResponse = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+).annotate({
+  identifier: "GetActiveCallbacksActiveCallbackResponse",
+}) as any as S.Schema<GetActiveCallbacksActiveCallbackResponse>;
+
+export interface GetActiveCallbacksSettingsRequest {}
+export const GetActiveCallbacksSettingsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(T.Http({ method: "GET", uri: "/settings", code: 200 })),
+).annotate({
+  identifier: "GetActiveCallbacksSettingsRequest",
+}) as any as S.Schema<GetActiveCallbacksSettingsRequest>;
+
+export interface GetActiveCallbacksSettingsResponse {
+  body: unknown;
+}
+export const GetActiveCallbacksSettingsResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    body: S.Unknown,
+  }),
+).annotate({
+  identifier: "GetActiveCallbacksSettingsResponse",
+}) as any as S.Schema<GetActiveCallbacksSettingsResponse>;
+
+export interface GetHealthBacklogHealthBacklogRequest {}
+export const GetHealthBacklogHealthBacklogRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({}).pipe(
+      T.Http({ method: "GET", uri: "/health/backlog", code: 200 }),
+    ),
+).annotate({
+  identifier: "GetHealthBacklogHealthBacklogRequest",
+}) as any as S.Schema<GetHealthBacklogHealthBacklogRequest>;
+
+export interface GetHealthBacklogHealthBacklogResponse {
+  body: unknown;
+}
+export const GetHealthBacklogHealthBacklogResponse = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+).annotate({
+  identifier: "GetHealthBacklogHealthBacklogResponse",
+}) as any as S.Schema<GetHealthBacklogHealthBacklogResponse>;
+
+export interface GetHealthCheckHistoryEndpointHealthHistoryRequest {
+  /** Filter by specific model name */
+  model?: string;
+  /** Filter by status (healthy/unhealthy) */
+  status_filter?: string;
+  /** Number of records to return */
+  limit?: number;
+  /** Number of records to skip */
+  offset?: number;
+}
+export const GetHealthCheckHistoryEndpointHealthHistoryRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      model: S.optional(S.String.pipe(T.Query())),
+      status_filter: S.optional(S.String.pipe(T.Query())),
+      limit: S.optional(S.Number.pipe(T.Query())),
+      offset: S.optional(S.Number.pipe(T.Query())),
+    }).pipe(T.Http({ method: "GET", uri: "/health/history", code: 200 })),
+  ).annotate({
+    identifier: "GetHealthCheckHistoryEndpointHealthHistoryRequest",
+  }) as any as S.Schema<GetHealthCheckHistoryEndpointHealthHistoryRequest>;
+
+export interface GetHealthCheckHistoryEndpointHealthHistoryResponse {
+  body: unknown;
+}
+export const GetHealthCheckHistoryEndpointHealthHistoryResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "GetHealthCheckHistoryEndpointHealthHistoryResponse",
+  }) as any as S.Schema<GetHealthCheckHistoryEndpointHealthHistoryResponse>;
+
+export interface GetHealthDrainHealthDrainRequest {}
+export const GetHealthDrainHealthDrainRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(T.Http({ method: "GET", uri: "/health/drain", code: 200 })),
+).annotate({
+  identifier: "GetHealthDrainHealthDrainRequest",
+}) as any as S.Schema<GetHealthDrainHealthDrainRequest>;
+
+export interface GetHealthDrainHealthDrainResponse {
+  body: unknown;
+}
+export const GetHealthDrainHealthDrainResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    body: S.Unknown,
+  }),
+).annotate({
+  identifier: "GetHealthDrainHealthDrainResponse",
+}) as any as S.Schema<GetHealthDrainHealthDrainResponse>;
+
+export interface GetHealthEndpointHealthRequest {
+  /** Specify the model name (optional) */
+  model?: string;
+  /** Specify the model ID (optional) */
+  model_id?: string;
+}
+export const GetHealthEndpointHealthRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    model: S.optional(S.String.pipe(T.Query())),
+    model_id: S.optional(S.String.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/health", code: 200 })),
+).annotate({
+  identifier: "GetHealthEndpointHealthRequest",
+}) as any as S.Schema<GetHealthEndpointHealthRequest>;
+
+export interface GetHealthEndpointHealthResponse {
+  body: unknown;
+}
+export const GetHealthEndpointHealthResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    body: S.Unknown,
+  }),
+).annotate({
+  identifier: "GetHealthEndpointHealthResponse",
+}) as any as S.Schema<GetHealthEndpointHealthResponse>;
+
+export interface GetHealthLicenseEndpointHealthLicenseRequest {}
+export const GetHealthLicenseEndpointHealthLicenseRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({}).pipe(
+      T.Http({ method: "GET", uri: "/health/license", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "GetHealthLicenseEndpointHealthLicenseRequest",
+  }) as any as S.Schema<GetHealthLicenseEndpointHealthLicenseRequest>;
+
+export interface GetHealthLicenseEndpointHealthLicenseResponse {
+  body: unknown;
+}
+export const GetHealthLicenseEndpointHealthLicenseResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "GetHealthLicenseEndpointHealthLicenseResponse",
+  }) as any as S.Schema<GetHealthLicenseEndpointHealthLicenseResponse>;
+
+export interface GetHealthLivelinessHealthLivelinessRequest {}
+export const GetHealthLivelinessHealthLivelinessRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({}).pipe(
+      T.Http({ method: "GET", uri: "/health/liveliness", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "GetHealthLivelinessHealthLivelinessRequest",
+  }) as any as S.Schema<GetHealthLivelinessHealthLivelinessRequest>;
+
+export interface GetHealthLivelinessHealthLivelinessResponse {
+  body: unknown;
+}
+export const GetHealthLivelinessHealthLivelinessResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "GetHealthLivelinessHealthLivelinessResponse",
+  }) as any as S.Schema<GetHealthLivelinessHealthLivelinessResponse>;
+
+export interface GetHealthLivelinessHealthLivenessRequest {}
+export const GetHealthLivelinessHealthLivenessRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({}).pipe(
+      T.Http({ method: "GET", uri: "/health/liveness", code: 200 }),
+    ),
+).annotate({
+  identifier: "GetHealthLivelinessHealthLivenessRequest",
+}) as any as S.Schema<GetHealthLivelinessHealthLivenessRequest>;
+
+export interface GetHealthLivelinessHealthLivenessResponse {
+  body: unknown;
+}
+export const GetHealthLivelinessHealthLivenessResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "GetHealthLivelinessHealthLivenessResponse",
+  }) as any as S.Schema<GetHealthLivelinessHealthLivenessResponse>;
+
+export interface GetHealthReadinessDetailsHealthReadinessDetailRequest {}
+export const GetHealthReadinessDetailsHealthReadinessDetailRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({}).pipe(
+      T.Http({ method: "GET", uri: "/health/readiness/details", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "GetHealthReadinessDetailsHealthReadinessDetailRequest",
+  }) as any as S.Schema<GetHealthReadinessDetailsHealthReadinessDetailRequest>;
+
+export interface GetHealthReadinessDetailsHealthReadinessDetailResponse {
+  body: unknown;
+}
+export const GetHealthReadinessDetailsHealthReadinessDetailResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "GetHealthReadinessDetailsHealthReadinessDetailResponse",
+  }) as any as S.Schema<GetHealthReadinessDetailsHealthReadinessDetailResponse>;
+
+export interface GetHealthReadinessHealthReadinessRequest {}
+export const GetHealthReadinessHealthReadinessRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({}).pipe(
+      T.Http({ method: "GET", uri: "/health/readiness", code: 200 }),
+    ),
+).annotate({
+  identifier: "GetHealthReadinessHealthReadinessRequest",
+}) as any as S.Schema<GetHealthReadinessHealthReadinessRequest>;
+
+export interface GetHealthReadinessHealthReadinessResponse {
+  body: unknown;
+}
+export const GetHealthReadinessHealthReadinessResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "GetHealthReadinessHealthReadinessResponse",
+  }) as any as S.Schema<GetHealthReadinessHealthReadinessResponse>;
+
+export type GetHealthServicesEndpointHealthServiceRequestServiceCase0 =
+  | "slack_budget_alerts"
+  | "langfuse"
+  | "langfuse_otel"
+  | "slack"
+  | "ms_teams"
+  | "openmeter"
+  | "webhook"
+  | "email"
+  | "braintrust"
+  | "datadog"
+  | "datadog_llm_observability"
+  | "generic_api"
+  | "arize"
+  | "galileo"
+  | "newrelic"
+  | "sqs";
+export const GetHealthServicesEndpointHealthServiceRequestServiceCase0 =
+  S.String;
+
+/** Specify the service being hit. */
+export type GetHealthServicesEndpointHealthServiceRequestService =
+  | GetHealthServicesEndpointHealthServiceRequestServiceCase0
+  | string;
+export const GetHealthServicesEndpointHealthServiceRequestService =
+  S.Unknown as any as S.Schema<GetHealthServicesEndpointHealthServiceRequestService>;
+
+export interface GetHealthServicesEndpointHealthServiceRequest {
+  /** Specify the service being hit. */
+  service: GetHealthServicesEndpointHealthServiceRequestService;
+}
+export const GetHealthServicesEndpointHealthServiceRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      service: GetHealthServicesEndpointHealthServiceRequestService.pipe(
+        T.Query(),
+      ),
+    }).pipe(T.Http({ method: "GET", uri: "/health/services", code: 200 })),
+  ).annotate({
+    identifier: "GetHealthServicesEndpointHealthServiceRequest",
+  }) as any as S.Schema<GetHealthServicesEndpointHealthServiceRequest>;
+
+export interface GetHealthServicesEndpointHealthServiceResponse {
+  body: unknown;
+}
+export const GetHealthServicesEndpointHealthServiceResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "GetHealthServicesEndpointHealthServiceResponse",
+  }) as any as S.Schema<GetHealthServicesEndpointHealthServiceResponse>;
+
+export interface GetLatestHealthChecksEndpointHealthLatestRequest {}
+export const GetLatestHealthChecksEndpointHealthLatestRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({}).pipe(
+      T.Http({ method: "GET", uri: "/health/latest", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "GetLatestHealthChecksEndpointHealthLatestRequest",
+  }) as any as S.Schema<GetLatestHealthChecksEndpointHealthLatestRequest>;
+
+export interface GetLatestHealthChecksEndpointHealthLatestResponse {
+  body: unknown;
+}
+export const GetLatestHealthChecksEndpointHealthLatestResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "GetLatestHealthChecksEndpointHealthLatestResponse",
+  }) as any as S.Schema<GetLatestHealthChecksEndpointHealthLatestResponse>;
+
+export interface GetSharedHealthCheckStatusEndpointHealthSharedStatusRequest {}
+export const GetSharedHealthCheckStatusEndpointHealthSharedStatusRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({}).pipe(
+      T.Http({ method: "GET", uri: "/health/shared-status", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "GetSharedHealthCheckStatusEndpointHealthSharedStatusRequest",
+  }) as any as S.Schema<GetSharedHealthCheckStatusEndpointHealthSharedStatusRequest>;
+
+export interface GetSharedHealthCheckStatusEndpointHealthSharedStatusResponse {
+  body: unknown;
+}
+export const GetSharedHealthCheckStatusEndpointHealthSharedStatusResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "GetSharedHealthCheckStatusEndpointHealthSharedStatusResponse",
+  }) as any as S.Schema<GetSharedHealthCheckStatusEndpointHealthSharedStatusResponse>;
+
+export interface GetTestEndpointTestRequest {}
+export const GetTestEndpointTestRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(T.Http({ method: "GET", uri: "/test", code: 200 })),
+).annotate({
+  identifier: "GetTestEndpointTestRequest",
+}) as any as S.Schema<GetTestEndpointTestRequest>;
+
+export interface GetTestEndpointTestResponse {
+  body: unknown;
+}
+export const GetTestEndpointTestResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    body: S.Unknown,
+  }),
+).annotate({
+  identifier: "GetTestEndpointTestResponse",
+}) as any as S.Schema<GetTestEndpointTestResponse>;
+
+/** Parameters for litellm.completion, litellm.embedding for the health check */
+export type PostTestModelConnectionHealthTestConnectionRequestLitellmParamsMap =
+  { [key: string]: unknown | undefined };
+export const PostTestModelConnectionHealthTestConnectionRequestLitellmParamsMap =
+  /*@__PURE__*/ S.Record(
+    S.String,
+    S.Unknown,
+  ) as any as S.Schema<PostTestModelConnectionHealthTestConnectionRequestLitellmParamsMap>;
+
+export type PostTestModelConnectionHealthTestConnectionRequestMode =
+  | "chat"
+  | "completion"
+  | "embedding"
+  | "audio_speech"
+  | "audio_transcription"
+  | "image_generation"
+  | "image_edit"
+  | "video_generation"
+  | "batch"
+  | "rerank"
+  | "realtime"
+  | "responses"
+  | "ocr";
+export const PostTestModelConnectionHealthTestConnectionRequestMode = S.String;
+
+/** Model info for the health check */
+export type PostTestModelConnectionHealthTestConnectionRequestModelInfoMap = {
+  [key: string]: unknown | undefined;
+};
+export const PostTestModelConnectionHealthTestConnectionRequestModelInfoMap =
+  /*@__PURE__*/ S.Record(
+    S.String,
+    S.Unknown,
+  ) as any as S.Schema<PostTestModelConnectionHealthTestConnectionRequestModelInfoMap>;
+
+export interface PostTestModelConnectionHealthTestConnectionRequest {
+  /** Parameters for litellm.completion, litellm.embedding for the health check */
+  litellm_params?: PostTestModelConnectionHealthTestConnectionRequestLitellmParamsMap;
+  /** The mode to test the model with. If not provided, auto-detected from model capabilities. */
+  mode?:
+    | PostTestModelConnectionHealthTestConnectionRequestMode
+    | (string & {})
+    | null;
+  /** Model info for the health check */
+  model_info?: PostTestModelConnectionHealthTestConnectionRequestModelInfoMap;
+}
+export const PostTestModelConnectionHealthTestConnectionRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      litellm_params: S.optional(
+        PostTestModelConnectionHealthTestConnectionRequestLitellmParamsMap,
+      ),
+      mode: S.optional(
+        S.NullOr(PostTestModelConnectionHealthTestConnectionRequestMode),
+      ),
+      model_info: S.optional(
+        PostTestModelConnectionHealthTestConnectionRequestModelInfoMap,
+      ),
+    }).pipe(
+      T.Http({ method: "POST", uri: "/health/test_connection", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "PostTestModelConnectionHealthTestConnectionRequest",
+  }) as any as S.Schema<PostTestModelConnectionHealthTestConnectionRequest>;
+
+export interface PostTestModelConnectionHealthTestConnectionResponse {
+  body: unknown;
+}
+export const PostTestModelConnectionHealthTestConnectionResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PostTestModelConnectionHealthTestConnectionResponse",
+  }) as any as S.Schema<PostTestModelConnectionHealthTestConnectionResponse>;
+
+export type GetActiveCallbacksActiveCallbackError = LitellmOpError;
+/** Active Callbacks Returns a list of litellm level settings This is useful for debugging and ensuring the proxy server is configured correctly. Response schema: ``` { "alerting": _alerting, "litellm.callbacks": litellm_callbacks, "litellm.input_callback": litellm_input_callbacks, "litellm.failure_callback": litellm_failure_callbacks, "litellm.success_callback": litellm_success_callbacks, "litellm._async_success_callback": litellm_async_success_callbacks, "litellm._async_failure_callback": litellm_async_failure_callbacks, "litellm._async_input_callback": litellm_async_input_callbacks, "all_litellm_callbacks": all_litellm_callbacks, "num_callbacks": len(all_litellm_callbacks), "num_alerting": _num_alerting, "litellm.request_timeout": litellm.request_timeout, } ``` */
+export const getActiveCallbacksActiveCallback: API.OperationMethod<
+  GetActiveCallbacksActiveCallbackRequest,
+  GetActiveCallbacksActiveCallbackResponse,
+  GetActiveCallbacksActiveCallbackError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetActiveCallbacksActiveCallbackRequest,
+  output: GetActiveCallbacksActiveCallbackResponse,
+  errors: [],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetActiveCallbacksSettingsError = LitellmOpError;
+/** Active Callbacks Returns a list of litellm level settings This is useful for debugging and ensuring the proxy server is configured correctly. Response schema: ``` { "alerting": _alerting, "litellm.callbacks": litellm_callbacks, "litellm.input_callback": litellm_input_callbacks, "litellm.failure_callback": litellm_failure_callbacks, "litellm.success_callback": litellm_success_callbacks, "litellm._async_success_callback": litellm_async_success_callbacks, "litellm._async_failure_callback": litellm_async_failure_callbacks, "litellm._async_input_callback": litellm_async_input_callbacks, "all_litellm_callbacks": all_litellm_callbacks, "num_callbacks": len(all_litellm_callbacks), "num_alerting": _num_alerting, "litellm.request_timeout": litellm.request_timeout, } ``` */
+export const getActiveCallbacksSettings: API.OperationMethod<
+  GetActiveCallbacksSettingsRequest,
+  GetActiveCallbacksSettingsResponse,
+  GetActiveCallbacksSettingsError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetActiveCallbacksSettingsRequest,
+  output: GetActiveCallbacksSettingsResponse,
+  errors: [],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetHealthBacklogHealthBacklogError = LitellmOpError;
+/** Health Backlog Returns the number of HTTP requests currently in-flight on this uvicorn worker. Use this to measure per-pod queue depth. A high value means the worker is processing many concurrent requests — requests arriving now will have to wait for the event loop to get to them, adding latency before LiteLLM even starts its own timer. */
+export const getHealthBacklogHealthBacklog: API.OperationMethod<
+  GetHealthBacklogHealthBacklogRequest,
+  GetHealthBacklogHealthBacklogResponse,
+  GetHealthBacklogHealthBacklogError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetHealthBacklogHealthBacklogRequest,
+  output: GetHealthBacklogHealthBacklogResponse,
+  errors: [],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetHealthCheckHistoryEndpointHealthHistoryError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Health Check History Endpoint Get health check history for models Returns historical health check data with optional filtering. */
+export const getHealthCheckHistoryEndpointHealthHistory: API.OperationMethod<
+  GetHealthCheckHistoryEndpointHealthHistoryRequest,
+  GetHealthCheckHistoryEndpointHealthHistoryResponse,
+  GetHealthCheckHistoryEndpointHealthHistoryError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetHealthCheckHistoryEndpointHealthHistoryRequest,
+  output: GetHealthCheckHistoryEndpointHealthHistoryResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetHealthDrainHealthDrainError = LitellmOpError;
+/** Health Drain Graceful-drain probe for Kubernetes ``preStop`` hooks. Disabled by default and returns 404 unless ``general_settings`` sets ``enable_drain_endpoint: true``. Calling it flips a process-wide shutting-down flag, so a successful call permanently takes the worker out of rotation until the pod restarts. Because the kubelet calls preStop hooks without proxy credentials, the endpoint does not require ``user_api_key_auth``. To prevent any pod-reachable caller from triggering shutdown, set ``general_settings.drain_endpoint_token`` (or the ``DRAIN_ENDPOINT_TOKEN`` env var) and supply the same value on the ``X-Drain-Token`` header from the preStop hook. Calls without the header (or with a wrong value) get a 401 and have no side effect. When enabled, it marks the worker as shutting down (so /health/readiness and /health/liveliness immediately start returning 503, removing the pod from service) and blocks until the in-flight request counter drains to zero or ``GRACEFUL_SHUTDOWN_TIMEOUT`` elapses. Unlike a fixed ``sleep``, this returns as soon as real in-flight work is done. Wire it up as: ```yaml lifecycle: preStop: httpGet: path: /health/drain port: 4000 httpHeaders: - name: X-Drain-Token value: <same value as drain_endpoint_token> ``` */
+export const getHealthDrainHealthDrain: API.OperationMethod<
+  GetHealthDrainHealthDrainRequest,
+  GetHealthDrainHealthDrainResponse,
+  GetHealthDrainHealthDrainError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetHealthDrainHealthDrainRequest,
+  output: GetHealthDrainHealthDrainResponse,
+  errors: [],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetHealthEndpointHealthError = UnprocessableEntity | LitellmOpError;
+/** Health Endpoint 🚨 USE `/health/liveliness` to health check the proxy 🚨 See more 👉 https://docs.litellm.ai/docs/proxy/health Check the health of all the endpoints in config.yaml To run health checks in the background, add this to config.yaml: ``` general_settings: # ... other settings background_health_checks: True ``` else, the health checks will be run on models when /health is called. To skip deployments that set ``model_info.disable_background_health_check: true`` on ``GET /health`` as well as in the background loop, set ``general_settings.health_check_skip_disabled_background_models: true``. */
+export const getHealthEndpointHealth: API.OperationMethod<
+  GetHealthEndpointHealthRequest,
+  GetHealthEndpointHealthResponse,
+  GetHealthEndpointHealthError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetHealthEndpointHealthRequest,
+  output: GetHealthEndpointHealthResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetHealthLicenseEndpointHealthLicenseError = LitellmOpError;
+/** Health License Endpoint Return metadata about the configured LiteLLM license without exposing the key. */
+export const getHealthLicenseEndpointHealthLicense: API.OperationMethod<
+  GetHealthLicenseEndpointHealthLicenseRequest,
+  GetHealthLicenseEndpointHealthLicenseResponse,
+  GetHealthLicenseEndpointHealthLicenseError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetHealthLicenseEndpointHealthLicenseRequest,
+  output: GetHealthLicenseEndpointHealthLicenseResponse,
+  errors: [],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetHealthLivelinessHealthLivelinessError = LitellmOpError;
+/** Health Liveliness Unprotected endpoint for checking if worker is alive. Returns 503 once graceful shutdown has begun so Kubernetes stops counting the draining pod as live and terminates it on schedule. */
+export const getHealthLivelinessHealthLiveliness: API.OperationMethod<
+  GetHealthLivelinessHealthLivelinessRequest,
+  GetHealthLivelinessHealthLivelinessResponse,
+  GetHealthLivelinessHealthLivelinessError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetHealthLivelinessHealthLivelinessRequest,
+  output: GetHealthLivelinessHealthLivelinessResponse,
+  errors: [],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetHealthLivelinessHealthLivenessError = LitellmOpError;
+/** Health Liveliness Unprotected endpoint for checking if worker is alive. Returns 503 once graceful shutdown has begun so Kubernetes stops counting the draining pod as live and terminates it on schedule. */
+export const getHealthLivelinessHealthLiveness: API.OperationMethod<
+  GetHealthLivelinessHealthLivenessRequest,
+  GetHealthLivelinessHealthLivenessResponse,
+  GetHealthLivelinessHealthLivenessError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetHealthLivelinessHealthLivenessRequest,
+  output: GetHealthLivelinessHealthLivenessResponse,
+  errors: [],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetHealthReadinessDetailsHealthReadinessDetailError =
+  LitellmOpError;
+/** Health Readiness Details Authenticated readiness diagnostics with DB/cache/callback metadata. */
+export const getHealthReadinessDetailsHealthReadinessDetail: API.OperationMethod<
+  GetHealthReadinessDetailsHealthReadinessDetailRequest,
+  GetHealthReadinessDetailsHealthReadinessDetailResponse,
+  GetHealthReadinessDetailsHealthReadinessDetailError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetHealthReadinessDetailsHealthReadinessDetailRequest,
+  output: GetHealthReadinessDetailsHealthReadinessDetailResponse,
+  errors: [],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetHealthReadinessHealthReadinessError = LitellmOpError;
+/** Health Readiness Public readiness probe. Returns a low-detail payload safe to expose to unauthenticated load balancers — `status` plus `db` so orchestrators and external probes can distinguish "healthy" from "DB unreachable" without a credential. Admins can opt into the legacy detailed payload with general_settings.allow_public_health_readiness_details. */
+export const getHealthReadinessHealthReadiness: API.OperationMethod<
+  GetHealthReadinessHealthReadinessRequest,
+  GetHealthReadinessHealthReadinessResponse,
+  GetHealthReadinessHealthReadinessError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetHealthReadinessHealthReadinessRequest,
+  output: GetHealthReadinessHealthReadinessResponse,
+  errors: [],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetHealthServicesEndpointHealthServiceError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Health Services Endpoint Use this admin-only endpoint to check if the service is healthy. Example: ``` curl -L -X GET 'http://0.0.0.0:4000/health/services?service=datadog' -H 'Authorization: Bearer sk-1234' ``` */
+export const getHealthServicesEndpointHealthService: API.OperationMethod<
+  GetHealthServicesEndpointHealthServiceRequest,
+  GetHealthServicesEndpointHealthServiceResponse,
+  GetHealthServicesEndpointHealthServiceError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetHealthServicesEndpointHealthServiceRequest,
+  output: GetHealthServicesEndpointHealthServiceResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetLatestHealthChecksEndpointHealthLatestError = LitellmOpError;
+/** Latest Health Checks Endpoint Get the latest health check status for all models Returns the most recent health check result for each model. */
+export const getLatestHealthChecksEndpointHealthLatest: API.OperationMethod<
+  GetLatestHealthChecksEndpointHealthLatestRequest,
+  GetLatestHealthChecksEndpointHealthLatestResponse,
+  GetLatestHealthChecksEndpointHealthLatestError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetLatestHealthChecksEndpointHealthLatestRequest,
+  output: GetLatestHealthChecksEndpointHealthLatestResponse,
+  errors: [],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetSharedHealthCheckStatusEndpointHealthSharedStatusError =
+  LitellmOpError;
+/** Shared Health Check Status Endpoint Get the status of shared health check coordination across pods. Returns information about Redis connectivity, lock status, and cache status. */
+export const getSharedHealthCheckStatusEndpointHealthSharedStatus: API.OperationMethod<
+  GetSharedHealthCheckStatusEndpointHealthSharedStatusRequest,
+  GetSharedHealthCheckStatusEndpointHealthSharedStatusResponse,
+  GetSharedHealthCheckStatusEndpointHealthSharedStatusError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetSharedHealthCheckStatusEndpointHealthSharedStatusRequest,
+  output: GetSharedHealthCheckStatusEndpointHealthSharedStatusResponse,
+  errors: [],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetTestEndpointTestError = LitellmOpError;
+/** Test Endpoint [DEPRECATED] use `/health/liveliness` instead. A test endpoint that pings the proxy server to check if it's healthy. Parameters: request (Request): The incoming request. Returns: dict: A dictionary containing the route of the request URL. */
+export const getTestEndpointTest: API.OperationMethod<
+  GetTestEndpointTestRequest,
+  GetTestEndpointTestResponse,
+  GetTestEndpointTestError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetTestEndpointTestRequest,
+  output: GetTestEndpointTestResponse,
+  errors: [],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PostTestModelConnectionHealthTestConnectionError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Test Model Connection Test a direct connection to a specific model. This endpoint allows you to verify if your proxy can successfully connect to a specific model. It's useful for troubleshooting model connectivity issues without going through the full proxy routing. Example: ```bash # If model is configured in proxy_config.yaml, you only need to specify the model name: curl -X POST 'http://localhost:4000/health/test_connection' \ -H 'Authorization: Bearer sk-1234' \ -H 'Content-Type: application/json' \ -d '{ "litellm_params": { "model": "gpt-4o" }, "mode": "chat" }' # The endpoint will automatically use api_key, api_base, etc. from proxy_config.yaml # You can also override specific params or test with custom credentials: curl -X POST 'http://localhost:4000/health/test_connection' \ -H 'Authorization: Bearer sk-1234' \ -H 'Content-Type: application/json' \ -d '{ "litellm_params": { "model": "azure/gpt-4o", "api_key": "os.environ/AZURE_OPENAI_API_KEY", "api_base": "os.environ/AZURE_OPENAI_ENDPOINT", "api_version": "2024-10-21" }, "mode": "chat" }' ``` Note: - If the model is configured in proxy_config.yaml, credentials (api_key, api_base, etc.) will be automatically loaded from the config (with resolved environment variables). - You can override specific params by including them in the request. - You can use `os.environ/VARIABLE_NAME` syntax to reference environment variables, which will be resolved automatically (same as in proxy_config.yaml). Returns: dict: A dictionary containing the health check result with either success information or error details. */
+export const postTestModelConnectionHealthTestConnection: API.OperationMethod<
+  PostTestModelConnectionHealthTestConnectionRequest,
+  PostTestModelConnectionHealthTestConnectionResponse,
+  PostTestModelConnectionHealthTestConnectionError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PostTestModelConnectionHealthTestConnectionRequest,
+  output: PostTestModelConnectionHealthTestConnectionResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));