"""
Generated types for Maniac SDK.

DO NOT EDIT - This file is generated by scripts/generate.py --types
"""

from __future__ import annotations

from typing import Any, Literal

from pydantic import BaseModel

try:
    from typing import TypedDict
except ImportError:
    from typing_extensions import TypedDict


# =============================================================================
# RESPONSE MODELS (Pydantic BaseModel)
# =============================================================================


class ToolChoiceFunctionName(BaseModel):
    """Specifies a function name to force-call."""

    name: str


class ToolChoiceFunction(BaseModel):
    """Force the model to call a specific function."""

    type: Literal["function"] = "function"
    function: ToolChoiceFunctionName


class ResponseFormatJsonObject(BaseModel):
    """JSON object response format (legacy JSON mode)."""

    type: Literal["json_object"] = "json_object"


class FunctionDefinition(BaseModel):
    """Function definition inside a tool."""

    name: str
    description: str | None = None
    parameters: dict[str, Any] | None = None
    strict: bool | None = None


class ToolDefinition(BaseModel):
    """A tool the model may call."""

    type: Literal["function"] = "function"
    function: FunctionDefinition


class ReasoningConfig(BaseModel):
    """Reasoning configuration for reasoning models."""

    effort: Literal["none", "minimal", "low", "medium", "high", "xhigh"] | None = None
    summary: Literal["auto", "concise", "detailed"] | None = None


class JsonSchemaConfig(BaseModel):
    """Configuration for json_schema response format."""

    name: str
    description: str | None = None
    schema: dict[str, Any] | None = None
    strict: bool | None = None


class ResponseFormatJsonSchema(BaseModel):
    """Structured JSON output via a supplied schema."""

    type: Literal["json_schema"] = "json_schema"
    json_schema: JsonSchemaConfig


class ResponseFormatText(BaseModel):
    """Plain text response format (default)."""

    type: Literal["text"] = "text"


class InferenceParamsInput(BaseModel):
    """Inference-only parameters (no messages, model, stream, etc.)."""

    provider: dict[str, Any] | None = None
    plugins: list[Any] | None = None
    route: str | None = None
    session_id: str | None = None
    frequency_penalty: float | None = None
    logit_bias: dict[str, Any] | None = None
    logprobs: bool | None = None
    top_logprobs: float | None = None
    max_completion_tokens: float | None = None
    max_tokens: float | None = None
    presence_penalty: float | None = None
    reasoning: ReasoningConfig | None = None
    response_format: ResponseFormatText | None = None
    seed: int | None = None
    stop: str | None = None
    temperature: float | None = None
    tool_choice: Literal["none", "auto", "required"] | None = None
    tools: list[ToolDefinition] | None = None
    top_p: float | None = None
    image_config: dict[str, Any] | None = None
    modalities: list[str] | None = None


class InferenceParams(BaseModel):
    """Inference-only parameters (no messages, model, stream, etc.)."""

    provider: dict[str, Any] | None = None
    plugins: list[Any] | None = None
    route: str | None = None
    session_id: str | None = None
    frequency_penalty: float | None = None
    logit_bias: dict[str, Any] | None = None
    logprobs: bool | None = None
    top_logprobs: float | None = None
    max_completion_tokens: float | None = None
    max_tokens: float | None = None
    presence_penalty: float | None = None
    reasoning: ReasoningConfig | None = None
    response_format: ResponseFormatText | None = None
    seed: int | None = None
    stop: str | None = None
    temperature: float | None = None
    tool_choice: Literal["none", "auto", "required"] | None = None
    tools: list[ToolDefinition] | None = None
    top_p: float | None = None
    image_config: dict[str, Any] | None = None
    modalities: list[str] | None = None


class ModelAddResponse(BaseModel):
    """AddModelToContainerRes"""

    object: Literal["model"] = "model"
    id: str
    container_id: str
    slug: str
    container: str
    default_parameters: InferenceParams | None = None
    default_system_prompt: str | None = None


class ChatResponseUsage(BaseModel):
    """Token usage in a chat completion response."""

    prompt_tokens: float
    completion_tokens: float
    total_tokens: float
    completion_tokens_details: dict[str, Any] | None = None
    prompt_tokens_details: dict[str, Any] | None = None


class RegisterOutputMessage(BaseModel):
    """RegisterOutputMessage"""

    role: str
    content: str | None = None


class RegisterOutputChoice(BaseModel):
    """RegisterOutputChoice"""

    index: int | None = None
    message: RegisterOutputMessage
    finish_reason: str | None = None


class ChatCompletionRelaxed(BaseModel):
    """ChatResRelaxed"""

    id: str | None = None
    choices: list[RegisterOutputChoice]
    created: Any | None = None
    model: str | None = None
    object: Literal["chat.completion"] = "chat.completion"
    usage: ChatResponseUsage | None = None
    provider: str | None = None
    container: str | None = None
    model_id: str | None = None
    spend: float | None = None
    tags: list[str] | None = None
    metadata: dict[str, Any] | None = None


class ChatCompletionList(BaseModel):
    """OpenAI-style list response for chat completions."""

    object: Literal["list"] = "list"
    data: list[ChatCompletionRelaxed]
    total: int


class TextContentPart(BaseModel):
    """Text content part in a message."""

    type: Literal["text"] = "text"
    text: str


class FunctionCall(BaseModel):
    """Function call payload inside a tool call."""

    name: str
    arguments: str


class StreamOptions(BaseModel):
    """Options for streaming responses."""

    include_usage: bool | None = None


class ToolCall(BaseModel):
    """A tool call emitted by the model."""

    id: str
    type: Literal["function"] = "function"
    function: FunctionCall


class ImageContentPart(BaseModel):
    """Image content part in a message."""

    type: Literal["image_url"] = "image_url"
    image_url: dict[str, Any]


class Message(BaseModel):
    """OpenAI-style chat message."""

    role: Literal["system", "user", "assistant", "developer", "tool"]
    content: str | None = None
    name: str | None = None
    tool_calls: list[ToolCall] | None = None
    tool_call_id: str | None = None


class ChatResponseMessage(BaseModel):
    """Assistant message in a choice."""

    role: str
    content: Any | None = None
    name: str | None = None
    tool_calls: list[ToolCall] | None = None


class ChatCompletionChoice(BaseModel):
    """Single choice in a chat completion response."""

    index: float
    message: ChatResponseMessage
    finish_reason: (
        Literal["stop", "length", "tool_calls", "content_filter", "error"] | None
    ) = None
    logprobs: Any | None = None


class ChatCompletion(BaseModel):
    """ChatRes"""

    id: str
    choices: list[ChatCompletionChoice]
    created: float
    model: str
    object: Literal["chat.completion"] = "chat.completion"
    usage: ChatResponseUsage | None = None
    provider: str | None = None
    container: str | None = None


class ChatResRelaxedInput(BaseModel):
    """ChatResRelaxed"""

    id: str | None = None
    choices: list[RegisterOutputChoice]
    created: Any | None = None
    model: str | None = None
    object: Literal["chat.completion"] = "chat.completion"
    usage: ChatResponseUsage | None = None
    provider: str | None = None
    container: str | None = None
    model_id: str | None = None
    spend: float | None = None
    tags: list[str] | None = None
    metadata: dict[str, Any] | None = None


class ChatResponseMessageInput(BaseModel):
    """Assistant message in a choice."""

    role: str
    content: Any | None = None
    name: str | None = None
    tool_calls: list[ToolCall] | None = None


class ChatCompletionChoiceInput(BaseModel):
    """Single choice in a chat completion response."""

    index: float
    message: ChatResponseMessageInput
    finish_reason: (
        Literal["stop", "length", "tool_calls", "content_filter", "error"] | None
    ) = None
    logprobs: Any | None = None


class CodeEvaluator(BaseModel):
    """CodeEvaluator"""

    object: Literal["evaluator.code"] = "evaluator.code"
    project_id: str
    container_id: str | None = None
    id: str
    name: str
    description: str | None = None
    created_at: str
    metadata: dict[str, Any] | None = None
    pass_threshold: float | None = None
    api: str | None = None
    container: str | None = None
    source: str
    requirements: list[str] | None = None


class ContainerInput(BaseModel):
    """Container"""

    id: str
    object: Literal["container"] = "container"
    project_id: str
    org_id: str | None = None
    user_id: str | None = None
    created_at: str | None = None
    label: str
    api: Literal[
        "chat.completions",
        "completions",
        "responses",
        "embeddings",
        "rerank",
        "containers",
        "models",
        "datasets",
        "evaluation",
        "optimization",
        "project.keys",
    ] = "chat.completions"
    best_model_id: str | None = None
    default_system_prompt: str | None = None
    default_parameters: InferenceParamsInput | None = None
    optimized_system_prompt: str | None = None
    optimized_parameters: InferenceParamsInput | None = None
    initial_model: str | None = None
    deleted_at: bool = False


class Container(BaseModel):
    """Container"""

    id: str
    object: Literal["container"] = "container"
    project_id: str
    org_id: str | None = None
    user_id: str | None = None
    created_at: str | None = None
    label: str
    api: Literal[
        "chat.completions",
        "completions",
        "responses",
        "embeddings",
        "rerank",
        "containers",
        "models",
        "datasets",
        "evaluation",
        "optimization",
        "project.keys",
    ] = "chat.completions"
    best_model_id: str | None = None
    default_system_prompt: str | None = None
    default_parameters: InferenceParams | None = None
    optimized_system_prompt: str | None = None
    optimized_parameters: InferenceParams | None = None
    initial_model: str | None = None
    deleted_at: bool = False


class ContainerDataSource(BaseModel):
    """ContainerDataSource"""

    range: str | None = "0:100"
    type: Literal["container"] = "container"
    container: str


class ContainerList(BaseModel):
    """ContainerListResponse"""

    object: Literal["list"] = "list"
    data: list[Container]
    total: int


class ContainerCreateResponse(BaseModel):
    """CreateContainerRes"""

    id: str
    object: Literal["container"] = "container"
    org_id: str | None = None
    created_at: str | None = None
    label: str
    api: Literal[
        "chat.completions",
        "completions",
        "responses",
        "embeddings",
        "rerank",
        "containers",
        "models",
        "datasets",
        "evaluation",
        "optimization",
        "project.keys",
    ] = "chat.completions"
    default_system_prompt: str | None = None
    default_parameters: InferenceParams | None = None
    optimized_system_prompt: str | None = None
    optimized_parameters: InferenceParams | None = None
    initial_model: str | None = None
    deleted_at: bool = False


class DatasetFilter(BaseModel):
    """DatasetFilter"""

    key: str
    operator: DatasetFilterOperator
    value: Any | None = None


class DatasetCreateResponse(BaseModel):
    """CreateDatasetRes"""

    id: str
    message: str


class SFTHyperparameters(BaseModel):
    """SFTHyperparameters"""

    max_steps: int
    lora_targets: list[str]
    lora_dim: list[int] | int
    lora_alpha: list[int] | int
    per_device_train_batch_size: list[int] | int
    gradient_accumulation_steps: list[int] | int
    warmup_ratio: list[float] | float
    optim: list[str] | str
    weight_decay: list[float] | float
    lr_scheduler_type: list[str] | str
    learning_rate: list[float] | float
    seed: list[int] | int
    mode: (
        list[Literal["autoregression", "classification", "regression"]]
        | Literal["autoregression", "classification", "regression"]
    )
    num_eval_checkpoints: int = 7
    train_range: str = "500:20000"
    eval_range: str = "0:500"
    top_c: int = 10
    filter: str | None = None
    max_seq_len: int = 2048
    max_gen_tokens: int | None = None
    target_key: str = "relevance"
    classification_labels: list[str] | None = None


class SFTMethod(BaseModel):
    """SFTMethod"""

    type: Literal["sft"] = "sft"
    hyperparameters: SFTHyperparameters


class GRPOHyperparameters(BaseModel):
    """GRPOHyperparameters"""

    lora_alpha: list[float]
    lora_targets: list[str]
    learning_rate: float
    batch_size: int
    max_steps: int
    seed: int
    num_eval_checkpoints: int = 5


class FileDataSource(BaseModel):
    """FileDataSource"""

    range: str | None = "0:100"
    type: Literal["file"] = "file"
    file: str


class GRPOMethod(BaseModel):
    """GRPOMethod"""

    type: Literal["grpo"] = "grpo"
    hyperparameters: GRPOHyperparameters


class DatasetDataSource(BaseModel):
    """DatasetDataSource"""

    range: str | None = "0:100"
    type: Literal["dataset"] = "dataset"
    dataset: str


class OptimizationRunCreateResponse(BaseModel):
    """CreateOptimizationRunRes"""

    created_at: str
    finished_at: str | None = None
    error_at: str | None = None
    status: str
    error: Any | None = None
    object: Literal["optimization.run"] = "optimization.run"
    id: str
    container_id: str
    base_models: list[str]
    methods: list[SFTMethod | GRPOMethod]
    dataset: str | None = None
    evaluators: list[str]
    metadata: dict[str, Any] | None = None
    metrics: dict[str, Any] | None = None
    spend: float | None = None
    best_checkpoint: str | None = None


class Dataset(BaseModel):
    """Dataset"""

    id: str
    object: Literal["dataset"] = "dataset"
    name: str
    description: str | None = None
    user_id: str | None = None
    project_id: str | None = None
    org_id: str | None = None
    container_id: str | None = None
    requested_size: int | None = None
    size: int | None = None
    filters: list[DatasetFilter] | None = None
    created_at: str | None = None
    tags: list[str] | None = None
    metadata: dict[str, Any] | None = None


class ContainerDeleteResponse(BaseModel):
    """DeleteContainerRes"""

    object: Literal["container"] = "container"
    label: str
    deleted: Literal[True] = True


class EvaluatorDeleteResponse(BaseModel):
    """DeleteEvaluatorRes"""

    object: Literal["evaluator"] = "evaluator"
    id: str
    deleted: Literal[True] = True


class ManiacError(BaseModel):
    """Standard Maniac API error envelope.

    This matches the shape already used by v2 auth (`detail={"error": {...}}`)."""

    code: str
    message: str
    details: dict[str, Any] | None = None


class ErrorResponse(BaseModel):
    """Response body for errors."""

    error: ManiacError


class EvaluationRunOverallResults(BaseModel):
    """Aggregated scores across all models and evaluators."""

    avg_score: float | None = None
    avg_accuracy: float | None = None


class GenerateDataSource(BaseModel):
    """Data source that generates completions via one or more models."""

    range: str | None = "0:100"
    type: Literal["generate"] = "generate"
    models: list[str]


class EvaluationRunPerModelResults(BaseModel):
    """Results for a single model within an evaluation run."""

    model: dict[str, Any] | None = None
    per_eval: dict[str, Any] | None = None
    avg_score: float | None = None
    avg_accuracy: float | None = None
    launch_index: int | None = None
    launch_call_id: str | None = None


class EvaluationRunResults(BaseModel):
    """Typed representation of the evaluation run results payload."""

    overall: EvaluationRunOverallResults | None = None
    metadata: dict[str, Any] | None = None
    per_model: list[EvaluationRunPerModelResults] | None = None
    launch_count: int | None = None


class EvaluationRun(BaseModel):
    """Response model for an evaluation run."""

    created_at: str
    finished_at: str | None = None
    error_at: str | None = None
    status: str
    error: Any | None = None
    object: Literal["evaluation.run"] = "evaluation.run"
    id: str
    process_id: str | None = None
    evaluators: list[str] | None = None
    container: str | None = None
    dataset_id: str | None = None
    sample: DatasetDataSource | ContainerDataSource | GenerateDataSource | None = None
    ground_truth: (
        DatasetDataSource | ContainerDataSource | GenerateDataSource | None
    ) = None
    results: EvaluationRunResults | None = None
    metrics: dict[str, Any] | None = None
    config: dict[str, Any] | None = None
    spend: float | None = None
    metadata: dict[str, Any] | None = None


class EvaluationRunList(BaseModel):
    """EvaluationRunListResponse"""

    object: Literal["list"] = "list"
    data: list[EvaluationRun]
    total: int


class EvaluationRunPerEvalResults(BaseModel):
    """Per-evaluator breakdown within a single model run."""

    accuracy: float | None = None
    avg_score: float | None = None
    num_total: int | None = None
    num_errors: int | None = None
    num_failed: int | None = None
    num_passed: int | None = None
    num_scored: int | None = None
    num_missing: int | None = None
    avg_accuracy: float | None = None
    break_reason: str | None = None
    expected_count: int | None = None


class EvaluationRunResultsInput(BaseModel):
    """Typed representation of the evaluation run results payload."""

    overall: EvaluationRunOverallResults | None = None
    metadata: dict[str, Any] | None = None
    per_model: list[EvaluationRunPerModelResults] | None = None
    launch_count: int | None = None


class JudgeEvaluator(BaseModel):
    """JudgeEvaluator"""

    object: Literal["evaluator.judge"] = "evaluator.judge"
    project_id: str
    container_id: str | None = None
    id: str
    name: str
    description: str | None = None
    created_at: str
    metadata: dict[str, Any] | None = None
    pass_threshold: float | None = None
    api: str | None = None
    container: str | None = None
    model: str
    prompt: str
    inference_parameters: dict[str, Any] | None = None


class EvaluatorList(BaseModel):
    """EvaluatorListResponse"""

    object: Literal["list"] = "list"
    data: list[JudgeEvaluator | CodeEvaluator]
    total: int


class FileDeleteResponse(BaseModel):
    """OpenAI-compatible delete response."""

    id: str
    object: Literal["file"] = "file"
    deleted: bool = True


class FileObject(BaseModel):
    """OpenAI-compatible file object (subset).

    We keep `id` as the DB UUID string, and expose the OpenAI-ish envelope."""

    id: str
    object: Literal["file"] = "file"
    bytes: int
    created_at: int
    filename: str
    purpose: str
    status: str
    status_details: str | None = None


class FileList(BaseModel):
    """OpenAI-compatible list response for files."""

    object: Literal["list"] = "list"
    data: list[FileObject]
    total: int


class Item(BaseModel):
    """Item"""

    input: ChatCompletionCreateParams
    output: ChatResRelaxedInput | None = None
    tags: list[str] | None = None
    metadata: dict[str, Any] | None = None


class DatasetList(BaseModel):
    """ListResponse[Dataset]"""

    object: Literal["list"] = "list"
    data: list[Dataset]
    total: int


class Pricing(BaseModel):
    """Pricing"""

    prompt: str
    completion: str
    image: str | None = None
    request: str | None = None
    discount: str | None = None
    web_search: str | None = None
    image_output: str | None = None
    input_cache_read: str | None = None
    internal_reasoning: str | None = None


class ModelListItem(BaseModel):
    """ModelListItem"""

    object: Literal["model"] = "model"
    id: str
    slug: str
    pricing: Pricing
    supported_parameters: list[str]
    supported_apis: list[
        Literal[
            "chat.completions",
            "completions",
            "responses",
            "embeddings",
            "rerank",
            "containers",
            "models",
            "datasets",
            "evaluation",
            "optimization",
            "project.keys",
        ]
    ]
    provider: str | None = None


class ModelList(BaseModel):
    """ModelListResponse"""

    object: Literal["list"] = "list"
    data: list[ModelListItem]
    total: int


class RegisterResponse(BaseModel):
    """RegisterChatCompletionsResponse"""

    ok: bool
    container: str
    summary: dict[str, Any]
    errors: list[dict[str, Any]]


# =============================================================================
# TYPE ALIASES (unions, enums)
# =============================================================================

DatasetFilterOperator = Literal[
    "equals",
    "not_equals",
    "contains",
    "not_contains",
    "greater_than",
    "less_than",
    "greater_than_or_equal",
    "less_than_or_equal",
    "in",
    "not_in",
    "exists",
    "not_exists",
    "between",
]


# =============================================================================
# REQUEST PARAMS (TypedDict)
# =============================================================================


class _ModelAddParamsRequired(TypedDict):
    model: str
    container: str
    slug: str


class ModelAddParams(_ModelAddParamsRequired, total=False):
    default_parameters: dict[str, Any] | None
    default_system_prompt: str | None


class _ChatCompletionCreateParamsRequired(TypedDict):
    messages: list[dict[str, Any]]


class ChatCompletionCreateParams(_ChatCompletionCreateParamsRequired, total=False):
    model: str | None
    models: list[str] | None
    frequency_penalty: float | None
    logit_bias: dict[str, Any] | None
    logprobs: bool | None
    top_logprobs: float | None
    max_completion_tokens: float | None
    max_tokens: float | None
    metadata: dict[str, Any] | None
    presence_penalty: float | None
    reasoning: dict[str, Any] | None
    response_format: dict[str, Any] | None
    seed: int | None
    stop: str | None
    stream: bool | None
    stream_options: dict[str, Any] | None
    temperature: float | None
    tool_choice: Literal["none", "auto", "required"] | None
    tools: list[dict[str, Any]] | None
    top_p: float | None
    tags: list[str]
    store: bool | None


class _ContainerCreateParamsRequired(TypedDict):
    label: str
    initial_model: str


class ContainerCreateParams(_ContainerCreateParamsRequired, total=False):
    api: Literal[
        "chat.completions",
        "completions",
        "responses",
        "embeddings",
        "rerank",
        "containers",
        "models",
        "datasets",
        "evaluation",
        "optimization",
        "project.keys",
    ]
    default_parameters: dict[str, Any] | None
    default_system_prompt: str | None


class _DatasetCreateParamsRequired(TypedDict):
    name: str
    container: str
    size: int


class DatasetCreateParams(_DatasetCreateParamsRequired, total=False):
    description: str | None
    filters: list[dict[str, Any]]
    tags: list[str] | None
    metadata: dict[str, Any]


class _OptimizationRunCreateParamsRequired(TypedDict):
    container: str
    base_models: list[str]
    evals: list[str]
    methods: list[dict[str, Any] | dict[str, Any]]


class OptimizationRunCreateParams(_OptimizationRunCreateParamsRequired, total=False):
    data_source: dict[str, Any] | None
    metadata: dict[str, Any] | None
    environment: str | None


class _EvaluationRunCreateParamsRequired(TypedDict):
    container: str
    evaluators: list[str]


class EvaluationRunCreateParams(_EvaluationRunCreateParamsRequired, total=False):
    sample: dict[str, Any] | None
    ground_truth: dict[str, Any] | None
    metadata: dict[str, Any] | None
    environment: str | None


class _EvaluatorCreateParamsRequired(TypedDict):
    type: Literal["judge", "code"]


class EvaluatorCreateParams(_EvaluatorCreateParamsRequired, total=False):
    container: str | None
    model: str | None
    prompt: str | None
    source: str | None
    requirements: list[str] | None
    pass_threshold: float | None
    metadata: dict[str, Any] | None
    name: str | None
    description: str | None
    api: str | None
    inference_parameters: dict[str, Any] | None


class RegisterParams(TypedDict):
    items: list[dict[str, Any]]
    container: str


class EvaluatorUpdateParams(TypedDict, total=False):
    container: str | None
    model: str | None
    prompt: str | None
    source: str | None
    requirements: list[str] | None
    pass_threshold: float | None
    metadata: dict[str, Any] | None
    name: str | None
    description: str | None
    api: str | None
    inference_parameters: dict[str, Any] | None


__all__ = [
    "ChatCompletion",
    "ChatCompletionChoice",
    "ChatCompletionChoiceInput",
    "ChatCompletionCreateParams",
    "ChatCompletionList",
    "ChatCompletionRelaxed",
    "ChatResRelaxedInput",
    "ChatResponseMessage",
    "ChatResponseMessageInput",
    "ChatResponseUsage",
    "CodeEvaluator",
    "Container",
    "ContainerCreateParams",
    "ContainerCreateResponse",
    "ContainerDataSource",
    "ContainerDeleteResponse",
    "ContainerInput",
    "ContainerList",
    "Dataset",
    "DatasetCreateParams",
    "DatasetCreateResponse",
    "DatasetDataSource",
    "DatasetFilter",
    "DatasetFilterOperator",
    "DatasetList",
    "ErrorResponse",
    "EvaluationRun",
    "EvaluationRunCreateParams",
    "EvaluationRunList",
    "EvaluationRunOverallResults",
    "EvaluationRunPerEvalResults",
    "EvaluationRunPerModelResults",
    "EvaluationRunResults",
    "EvaluationRunResultsInput",
    "EvaluatorCreateParams",
    "EvaluatorDeleteResponse",
    "EvaluatorList",
    "EvaluatorUpdateParams",
    "FileDataSource",
    "FileDeleteResponse",
    "FileList",
    "FileObject",
    "FunctionCall",
    "FunctionDefinition",
    "GRPOHyperparameters",
    "GRPOMethod",
    "GenerateDataSource",
    "ImageContentPart",
    "InferenceParams",
    "InferenceParamsInput",
    "Item",
    "JsonSchemaConfig",
    "JudgeEvaluator",
    "ManiacError",
    "Message",
    "ModelAddParams",
    "ModelAddResponse",
    "ModelList",
    "ModelListItem",
    "OptimizationRunCreateParams",
    "OptimizationRunCreateResponse",
    "Pricing",
    "ReasoningConfig",
    "RegisterOutputChoice",
    "RegisterOutputMessage",
    "RegisterParams",
    "RegisterResponse",
    "ResponseFormatJsonObject",
    "ResponseFormatJsonSchema",
    "ResponseFormatText",
    "SFTHyperparameters",
    "SFTMethod",
    "StreamOptions",
    "TextContentPart",
    "ToolCall",
    "ToolChoiceFunction",
    "ToolChoiceFunctionName",
    "ToolDefinition",
]
