// This file is auto-generated by @hey-api/openapi-ts

export type ActivateSuiteResponse = {
    /**
     * ID of the created suite
     */
    suite_id: number;
    /**
     * Version number of the suite
     */
    suite_version: number;
    /**
     * Whether the suite is active
     */
    is_active: boolean;
    /**
     * Number of agent versions requeued for evaluation
     */
    requeued_versions?: number;
};

export type AdminAgentCodeResponse = {
    /**
     * Presigned S3 download URL
     */
    download_url: string;
    /**
     * Agent version the code belongs to
     */
    agent_version_id: string;
    /**
     * Name of the agent
     */
    agent_name: string;
};

export type AdminAgentVersionEntry = {
    /**
     * Agent version ID
     */
    agent_version_id: string;
    /**
     * Parent agent ID
     */
    agent_id: string;
    /**
     * Agent name
     */
    agent_name: string;
    /**
     * Owner's hotkey
     */
    miner_hotkey: string;
    /**
     * Version number within the agent
     */
    version_number: number;
    /**
     * When this version was created
     */
    created_at: string;
    /**
     * Whether this version is eligible for scoring
     */
    is_eligible?: (boolean | null);
    /**
     * Whether this version has been discarded
     */
    is_discarded?: (boolean | null);
    /**
     * Final qualifying score
     */
    final_score?: (number | null);
    /**
     * Whether the work item is closed
     */
    work_item_is_closed?: (boolean | null);
    /**
     * Whether the work item is cancelled
     */
    work_item_is_cancelled?: (boolean | null);
    /**
     * Number of active evaluation runs
     */
    active_run_count?: (number | null);
    /**
     * Whether this is the current top agent
     */
    is_current_top?: boolean;
    /**
     * When the agent was eliminated from future races, if any
     */
    eliminated_at?: (string | null);
    /**
     * Race number that eliminated this agent, if any
     */
    eliminated_in_race_number?: (number | null);
    /**
     * Number of included successful runs in work item
     */
    work_item_included_success_count?: (number | null);
};

export type AdminAgentVersionsResponse = {
    /**
     * Total entries matching filter
     */
    total: number;
    /**
     * Page size
     */
    limit: number;
    /**
     * Page offset
     */
    offset: number;
    /**
     * Agent version entries
     */
    agent_versions: Array<AdminAgentVersionEntry>;
};

export type AdminEvaluationRunEntry = {
    /**
     * Evaluation run ID
     */
    run_id: string;
    /**
     * Agent version being evaluated
     */
    agent_version_id: string;
    /**
     * Validator performing the evaluation
     */
    validator_hotkey: string;
    /**
     * Problem suite ID
     */
    suite_id: number;
    /**
     * Current run status
     */
    status: string;
    /**
     * When the run was claimed
     */
    claimed_at?: (string | null);
    /**
     * When the run completed
     */
    completed_at?: (string | null);
    /**
     * Last heartbeat from the validator
     */
    last_heartbeat_at?: (string | null);
    /**
     * When the lease expires
     */
    lease_expires_at?: (string | null);
    /**
     * Whether this run is included in scoring
     */
    is_included: boolean;
    /**
     * Run score
     */
    score?: (number | null);
    /**
     * When the run was invalidated
     */
    invalidated_at?: (string | null);
    /**
     * Reason the run was invalidated
     */
    invalidation_reason?: (string | null);
    /**
     * Reason the run failed
     */
    failure_reason?: (string | null);
    /**
     * When the run was created
     */
    created_at: string;
    /**
     * Work item this run was created for
     */
    eval_work_item_id?: (string | null);
    /**
     * Evaluation phase (QUALIFYING or RACE) from the work item
     */
    phase?: (string | null);
    /**
     * Race ID for RACE-phase runs
     */
    race_id?: (string | null);
    /**
     * Race number for RACE-phase runs
     */
    race_number?: (number | null);
    /**
     * Inference provider used for this run (e.g. chutes, openrouter)
     */
    inference_provider?: (string | null);
};

export type AdminEvaluationRunsResponse = {
    /**
     * Total entries matching filter
     */
    total: number;
    /**
     * Page size
     */
    limit: number;
    /**
     * Page offset
     */
    offset: number;
    /**
     * Evaluation run entries
     */
    evaluation_runs: Array<AdminEvaluationRunEntry>;
};

export type AdminMinerEntry = {
    /**
     * Miner's SS58 hotkey
     */
    miner_hotkey: string;
    /**
     * Whether the miner is banned
     */
    is_banned: boolean;
    /**
     * Reason for the ban
     */
    ban_reason?: (string | null);
    /**
     * When the miner was banned
     */
    banned_at?: (string | null);
    /**
     * Number of agents submitted by this miner
     */
    agent_count: number;
    /**
     * When the miner last submitted an agent
     */
    last_submitted_at?: (string | null);
    /**
     * When the miner registered on-chain
     */
    registered_at?: (string | null);
    /**
     * Remaining submission cooldown in seconds, or null if no cooldown is active. Sourced from Redis (`cooldown:miner:{hotkey}` TTL).
     */
    cooldown_remaining_seconds?: (number | null);
};

export type AdminMinersResponse = {
    /**
     * Total entries matching filter
     */
    total: number;
    /**
     * Page size
     */
    limit: number;
    /**
     * Page offset
     */
    offset: number;
    /**
     * Miner entries
     */
    miners: Array<AdminMinerEntry>;
};

export type AdminValidatorEntry = {
    /**
     * Validator's SS58 address
     */
    hotkey: string;
    /**
     * On-chain identity name, if set
     */
    name?: (string | null);
    /**
     * Current validator status
     */
    status: ValidatorStatus;
    /**
     * When validator was registered
     */
    registered_at: string;
    /**
     * Last work claim time
     */
    last_claim_at?: (string | null);
    /**
     * Last time validator was seen
     */
    last_seen_at?: (string | null);
    /**
     * Agent currently being evaluated, if any
     */
    current_agent?: (ValidatorCurrentAgent | null);
    /**
     * Docker image digests for validator stack services
     */
    service_versions?: ({
    [key: string]: (string);
} | null);
    /**
     * On-chain identity URL
     */
    identity_url?: (string | null);
    /**
     * On-chain identity image URL
     */
    identity_image?: (string | null);
    /**
     * On-chain identity description
     */
    identity_description?: (string | null);
    /**
     * Latest reported host CPU utilisation percentage (0-100)
     */
    cpu_pct?: (number | null);
    /**
     * Latest reported host RAM utilisation percentage (0-100)
     */
    ram_pct?: (number | null);
    /**
     * Latest reported host disk utilisation percentage on the sandbox volume (0-100)
     */
    disk_pct?: (number | null);
    /**
     * Latest reported running Docker container count on the host
     */
    docker_container_count?: (number | null);
    /**
     * UTC timestamp of the last resource-metrics report
     */
    metrics_reported_at?: (string | null);
    /**
     * Whether the validator is banned
     */
    is_banned: boolean;
    /**
     * Reason for the ban
     */
    ban_reason?: (string | null);
    /**
     * When the validator was banned
     */
    banned_at?: (string | null);
    /**
     * Maximum concurrent evaluation runs for this hotkey
     */
    max_concurrent_runs: number;
};

export type AdminValidatorsResponse = {
    /**
     * Total entries matching filter
     */
    total: number;
    /**
     * Page size
     */
    limit: number;
    /**
     * Page offset
     */
    offset: number;
    /**
     * Validator entries
     */
    validators: Array<AdminValidatorEntry>;
};

export type AdmissionReason = 'COOLDOWN' | 'INVALID_FILE' | 'NOT_REGISTERED_ONCHAIN' | 'BANNED' | 'NO_ACTIVE_SUITE';

export type AdmissionStatus = 'ACCEPTED' | 'REJECTED';

export type AgentLatestVersion = {
    /**
     * When the agent was eliminated from future races, if any
     */
    eliminated_at?: (string | null);
    /**
     * Race number that eliminated this agent, if any
     */
    eliminated_in_race_number?: (number | null);
    /**
     * Version ID
     */
    agent_version_id: string;
    /**
     * Version number (v1, v2, etc.)
     */
    version_number: number;
    /**
     * Submission timestamp
     */
    submitted_at: string;
    /**
     * Current state
     */
    state: AgentVersionState;
    /**
     * Final score if eligible
     */
    final_score?: (number | null);
    /**
     * True when this version is the miner's pinned race candidate
     */
    is_selected_for_race?: boolean;
    /**
     * Set on the pinned version only when the pin can't take effect.
     */
    selection_fallback_reason?: ('eliminated' | 'discarded' | 'below_threshold' | 'not_eligible' | null);
    /**
     * True when this version can be pinned as the next race candidate. Mirrors the admission rules used by the PUT /v1/miner/race-selection endpoint.
     */
    is_pinnable?: boolean;
    /**
     * When `is_pinnable` is false, the specific precondition that fails. Same enum as `selection_fallback_reason`.
     */
    pin_disabled_reason?: ('eliminated' | 'discarded' | 'below_threshold' | 'not_eligible' | null);
};

export type AgentNotFoundError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "AGENT_NOT_FOUND";
};

export type AgentPublic = {
    /**
     * Unique identifier for the agent
     */
    agent_id: string;
    /**
     * Owner's hotkey
     */
    miner_hotkey: string;
    /**
     * Human-readable name for the agent
     */
    agent_name: string;
    /**
     * When the agent was created
     */
    created_at: string;
    /**
     * Latest version with state and score
     */
    latest_version?: (AgentLatestVersion | null);
};

export type AgentVersionHistoryEntry = {
    /**
     * When the agent was eliminated from future races, if any
     */
    eliminated_at?: (string | null);
    /**
     * Race number that eliminated this agent, if any
     */
    eliminated_in_race_number?: (number | null);
    /**
     * Version ID
     */
    agent_version_id: string;
    /**
     * Version number (v1, v2, etc.)
     */
    version_number: number;
    /**
     * Submission timestamp
     */
    submitted_at: string;
    /**
     * Current state
     */
    state: AgentVersionState;
    /**
     * Final score if eligible
     */
    final_score?: (number | null);
    /**
     * True when this version is the miner's pinned race candidate
     */
    is_selected_for_race?: boolean;
    /**
     * Set on the pinned version only when the pin can't take effect.
     */
    selection_fallback_reason?: ('eliminated' | 'discarded' | 'below_threshold' | 'not_eligible' | null);
    /**
     * True when this version can be pinned as the next race candidate. Mirrors the admission rules used by the PUT /v1/miner/race-selection endpoint.
     */
    is_pinnable?: boolean;
    /**
     * When `is_pinnable` is false, the specific precondition that fails. Same enum as `selection_fallback_reason`.
     */
    pin_disabled_reason?: ('eliminated' | 'discarded' | 'below_threshold' | 'not_eligible' | null);
};

export type AgentVersionNotFoundError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "AGENT_VERSION_NOT_FOUND";
};

export type AgentVersionProblemsResponse = {
    /**
     * Agent version ID
     */
    agent_version_id: string;
    /**
     * Suite ID
     */
    suite_id?: (number | null);
    /**
     * Problem progress list
     */
    problems: Array<ProblemProgressEntry>;
};

export type AgentVersionPublic = {
    /**
     * Unique identifier for this version
     */
    agent_version_id: string;
    /**
     * Parent agent ID
     */
    agent_id: string;
    /**
     * Agent name
     */
    agent_name: string;
    /**
     * Owner's hotkey
     */
    miner_hotkey: string;
    /**
     * Version number within this agent (v1, v2, etc.)
     */
    version_number: number;
    /**
     * Suite this version was submitted for
     */
    suite_id?: (number | null);
    /**
     * When this version was submitted
     */
    submitted_at: string;
    /**
     * UTC timestamp at which this version's code became / becomes public
     */
    released_at: string;
    /**
     * UTC timestamp at which the code artifact becomes downloadable. Alias for released_at kept as a distinct field for Frontend compatibility. ORO-1504.
     */
    code_available_at: string;
    /**
     * Final score if eligible
     */
    latest_final_score?: (number | null);
};

export type AgentVersionScoreEntry = {
    /**
     * Validator's SS58 hotkey
     */
    validator_hotkey: string;
    /**
     * Score assigned by this validator
     */
    score: number;
    /**
     * Evaluation run ID
     */
    run_id: string;
};

/**
 * State of an agent version evaluation.
 */
export type AgentVersionState = 'RECEIVED' | 'QUEUED' | 'RUNNING' | 'ELIGIBLE' | 'DISCARDED' | 'CANCELLED';

export type AgentVersionStatus = {
    /**
     * When the agent was eliminated from future races, if any
     */
    eliminated_at?: (string | null);
    /**
     * Race number that eliminated this agent, if any
     */
    eliminated_in_race_number?: (number | null);
    /**
     * Unique identifier for this version
     */
    agent_version_id: string;
    /**
     * Agent name
     */
    agent_name: string;
    /**
     * Owner's hotkey
     */
    miner_hotkey: string;
    /**
     * Version number within this agent (v1, v2, etc.)
     */
    version_number: number;
    /**
     * Suite ID
     */
    suite_id?: (number | null);
    /**
     * Submission timestamp
     */
    submitted_at: string;
    /**
     * Current state of the version
     */
    state: AgentVersionState;
    /**
     * Required successful evaluations
     */
    required_successes?: number;
    /**
     * Number of successful evaluations
     */
    success_count?: number;
    /**
     * Number of active evaluations
     */
    active_count?: number;
    /**
     * Whether evaluation is closed
     */
    is_closed?: boolean;
    /**
     * Qualifying score if eligible
     */
    final_score?: (number | null);
    /**
     * Race score
     */
    race_score?: (number | null);
    /**
     * Average reasoning coefficient from included successful runs
     */
    reasoning_coefficient?: (number | null);
    /**
     * Whether artifacts are released
     */
    release_state?: ArtifactReleaseState;
    /**
     * When agent code becomes available for download (= AgentVersion.released_at)
     */
    code_available_at?: (string | null);
    /**
     * Per-validator scores on success
     */
    per_validator_success_scores?: ({
    [key: string]: (number);
} | null);
    /**
     * True when this version is the active qualifier on its hotkey for the open race (covers both the incumbent and the scored qualifier).
     */
    is_active_qualifier?: boolean;
    /**
     * Set when this version's score qualifies but a higher-scoring sibling on the same hotkey is the active qualifier instead.
     */
    outranked_by_agent_version_id?: (string | null);
    /**
     * 3-race pooled ('weighted') score across the current window.
     */
    weighted_score?: (number | null);
    /**
     * Per-race build-up of the pooled window (seed entries flag races the agent did not run; count the non-seed entries for races contributing).
     */
    window?: (Array<PooledWindowRace> | null);
};

export type AgentVersionVariance = {
    /**
     * Agent version ID
     */
    agent_version_id: string;
    /**
     * Agent name
     */
    agent_name: string;
    /**
     * Owner's hotkey
     */
    miner_hotkey: string;
    /**
     * Work item this variance row is computed for
     */
    eval_work_item_id?: (string | null);
    /**
     * Evaluation phase (QUALIFYING or RACE)
     */
    phase?: (string | null);
    /**
     * Race number for RACE-phase work items
     */
    race_number?: (number | null);
    /**
     * Number of validators that scored this version
     */
    validator_count: number;
    /**
     * Average score across validators
     */
    avg_score: number;
    /**
     * Minimum validator score
     */
    min_score: number;
    /**
     * Maximum validator score
     */
    max_score: number;
    /**
     * Spread between min and max scores
     */
    spread: number;
    /**
     * Whether the variance exceeds the threshold
     */
    is_high_variance: boolean;
    /**
     * Per-validator score breakdown
     */
    per_validator?: Array<AgentVersionScoreEntry>;
};

export type AgentVersionVarianceResponse = {
    /**
     * Per-version variance entries
     */
    agent_versions: Array<AgentVersionVariance>;
    /**
     * Threshold used to flag high-variance versions
     */
    variance_threshold: number;
};

export type AlreadyInvalidatedError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "ALREADY_INVALIDATED";
};

export type ArtifactDownloadRequest = {
    /**
     * Type of artifact to download
     */
    artifact_type: ArtifactType;
    /**
     * Agent version ID
     */
    agent_version_id: string;
    /**
     * Run ID for run-scoped artifacts
     */
    eval_run_id?: (string | null);
    /**
     * Problem ID for per-problem artifact downloads
     */
    problem_id?: (string | null);
};

export type ArtifactDownloadResponse = {
    /**
     * Presigned download URL
     */
    download_url: string;
    /**
     * URL expiration time
     */
    expires_at: string;
};

export type ArtifactNotFoundError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "ARTIFACT_NOT_FOUND";
};

export type ArtifactNotReleasedError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "ARTIFACT_NOT_RELEASED";
};

/**
 * Release state of agent version artifacts.
 */
export type ArtifactReleaseState = 'HIDDEN' | 'RELEASED';

export type ArtifactType = 'AGENT_CODE' | 'EVAL_LOGS_BUNDLE' | 'EVAL_PROBLEM_LOGS' | 'REASONING_DETAILS';

export type AtCapacityError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "AT_CAPACITY";
};

export type AuditEventEntry = {
    /**
     * Unique event identifier
     */
    event_id: string;
    /**
     * Action that was performed
     */
    action: string;
    /**
     * Type of entity targeted
     */
    target_type: string;
    /**
     * Identifier of the targeted entity
     */
    target_id: string;
    /**
     * Hotkey of the admin who performed the action
     */
    actor_hotkey: string;
    /**
     * Reason for the action
     */
    reason?: (string | null);
    /**
     * Additional event details
     */
    details?: ({
    [key: string]: unknown;
} | null);
    /**
     * When the event occurred
     */
    created_at: string;
};

export type AuditEventsResponse = {
    /**
     * Total entries matching filter
     */
    total: number;
    /**
     * Page size
     */
    limit: number;
    /**
     * Page offset
     */
    offset: number;
    /**
     * Audit event entries
     */
    events: Array<AuditEventEntry>;
};

export type BanRequest = {
    /**
     * Reason for the ban
     */
    reason: string;
};

export type BanResponse = {
    /**
     * Hotkey of the banned/unbanned entity
     */
    hotkey: string;
    /**
     * Current ban status after the operation
     */
    is_banned: boolean;
};

export type Body_submit_agent = {
    /**
     * Name for this agent (unique per miner)
     */
    agent_name: string;
    /**
     * Python agent file (max 1MB)
     */
    file: (Blob | File);
};

export type CancelRequest = {
    /**
     * Reason for cancellation
     */
    reason: string;
};

export type CancelResponse = {
    /**
     * Agent version whose runs were cancelled
     */
    agent_version_id: string;
    /**
     * Number of runs cancelled
     */
    cancelled_runs: number;
};

export type ChallengeRequest = {
    /**
     * SS58 hotkey address
     */
    hotkey: string;
};

export type ChallengeResponse = {
    /**
     * Challenge string to sign
     */
    challenge: string;
    /**
     * Unix timestamp when challenge expires
     */
    expires_at: number;
};

export type ChutesAuthStatusResponse = {
    /**
     * Whether the miner has a valid Chutes token stored
     */
    connected: boolean;
    /**
     * When the Chutes token was last updated
     */
    updated_at?: (string | null);
};

export type ClaimWorkResponse = {
    /**
     * Evaluation run ID assigned to this claim
     */
    eval_run_id: string;
    /**
     * Agent version to evaluate
     */
    agent_version_id: string;
    /**
     * Problem suite ID for this evaluation
     */
    suite_id: number;
    /**
     * When the lease expires if not renewed
     */
    lease_expires_at: string;
    /**
     * Presigned URL to download agent code
     */
    code_download_url: string;
    /**
     * ExecutionContract this work item is frozen to (ORO-1928). Stamped at work-item creation, immutable after — contract rotations/retirements after creation do NOT change what pack this claim is bound to. Null for legacy pre-1928 work items that fall back to the static-suite path.
     */
    execution_contract_id?: (string | null);
    /**
     * Content-hash of the sealed environment pack this work item is bound to (ORO-1928). Derived from the frozen execution_contract_id — validators load and run against this sha regardless of any contract activity after the work item was created. Null for legacy work items with no binding.
     */
    env_pack_sha256?: (string | null);
    /**
     * Per-run scoped inference credential. Null when the miner has no inference auth connected. ORO-1509: when the mint call itself fails with a transient upstream error (5xx / 429 / network), the backend marks the eval run terminal server-side with a distinct failure_reason before returning; the validator's later completion call will get 409 (already complete), which existing clients already handle.
     */
    inference_token?: (InferenceTokenGrant | null);
};

export type ClearCooldownResponse = {
    /**
     * Whether the cooldown was cleared
     */
    cleared: boolean;
    /**
     * Hotkey whose cooldown was cleared
     */
    hotkey?: (string | null);
    /**
     * Seconds remaining on the cooldown before clearing
     */
    seconds_remaining_was?: (number | null);
    /**
     * Human-readable status message
     */
    message?: (string | null);
};

export type CloseQualifyingResponse = {
    /**
     * Race ID
     */
    race_id: string;
    /**
     * Original qualifying close time
     */
    previous_closes_at: string;
    /**
     * New qualifying close time
     */
    new_closes_at: string;
    /**
     * Race status after closing qualifying
     */
    status: string;
};

/**
 * 422 - Static analysis found issues in submitted code.
 */
export type CodeAnalysisError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "CODE_ANALYSIS_ERROR";
    /**
     * List of violations found (rule, severity, message, line)
     */
    violations?: Array<{
        [key: string]: unknown;
    }>;
    /**
     * Seconds remaining on cooldown (if cooldown was consumed by this submission)
     */
    remaining_seconds?: (number | null);
};

/**
 * Sent by the validator when an evaluation run finishes.
 */
export type CompleteRunRequest = {
    /**
     * Final status of the evaluation run
     */
    terminal_status: TerminalStatus;
    /**
     * Aggregate score computed by the validator
     */
    validator_score?: (number | null);
    /**
     * Detailed score component breakdown
     */
    score_components?: ({
    [key: string]: unknown;
} | null);
    /**
     * S3 key for the uploaded results bundle
     */
    results_s3_key?: (string | null);
    /**
     * Human-readable failure reason
     */
    failure_reason?: (string | null);
    /**
     * Metadata about the sandbox environment used
     */
    sandbox_metadata?: ({
    [key: string]: unknown;
} | null);
};

export type CompleteRunResponse = {
    /**
     * Evaluation run that was completed
     */
    eval_run_id: string;
    /**
     * Recorded terminal status
     */
    status: string;
    /**
     * Current work-item completion counters
     */
    work_item: WorkItemStatus;
    /**
     * Whether this run caused the agent version to become eligible
     */
    agent_version_became_eligible: boolean;
    /**
     * Final qualifying score if the version became eligible
     */
    final_score?: (number | null);
};

/**
 * 429 - Cooldown period is active.
 */
export type CooldownActiveError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "COOLDOWN_ACTIVE";
    /**
     * Seconds remaining until cooldown expires
     */
    remaining_seconds: number;
};

export type CreateSuiteRequest = {
    /**
     * URI of the problem suite to import
     */
    problem_suite_uri: string;
    /**
     * Whether the suite is publicly visible
     */
    is_public?: boolean;
    /**
     * Existing suite versions to also add the new problems to (via problem_suite_membership). Use to extend a race-bank with a freshly-generated batch while keeping the batch's own origin.
     */
    also_member_of?: Array<(number)>;
};

export type CreateSuiteResponse = {
    /**
     * ID of the created suite
     */
    suite_id: number;
    /**
     * Version number of the suite
     */
    suite_version: number;
    /**
     * Whether the suite is active
     */
    is_active: boolean;
};

export type CurrentRacesResponse = {
    /**
     * Active races
     */
    races: Array<RaceSummary>;
};

export type DiscardRequest = {
    /**
     * Reason for discarding the version
     */
    reason: string;
    /**
     * Specific suite to discard from
     */
    suite_id?: (number | null);
};

export type DiscardResponse = {
    /**
     * Discarded agent version ID
     */
    agent_version_id: string;
    /**
     * Suite the version was discarded from
     */
    suite_id: number;
    /**
     * Current discard status
     */
    is_discarded: boolean;
};

export type EliminateRequest = {
    /**
     * Specific suite to eliminate the version in
     */
    suite_id?: (number | null);
    /**
     * Reason for eliminating the version
     */
    reason: string;
};

export type EliminateResponse = {
    /**
     * Agent version that was eliminated
     */
    agent_version_id: string;
    /**
     * Suite the version was eliminated in
     */
    suite_id: number;
    /**
     * Timestamp of elimination
     */
    eliminated_at: string;
};

/**
 * Base weight standings pinned to one epoch (ORO-1704).
 *
 * Served so every honest validator in the same epoch builds the identical
 * base vector regardless of when in the epoch its weight-setter ticks —
 * closing the race→epoch-boundary desync that would otherwise fracture the
 * honest consensus (and, once the watermark is live, its >50% majority).
 *
 * Snapshotted once per epoch (frozen at the epoch's first request), so a race
 * completing mid-epoch is not reflected until the next boundary — the old
 * winner keeps its share during the adoption lag (ORO-1704 decision D2).
 */
export type EpochStandings = {
    /**
     * Admin-designated top miner hotkey as of this epoch; None burns the top share
     */
    top_hotkey: (string | null);
    /**
     * Burn share for the base vector this epoch
     */
    t_burn: number;
    /**
     * Most-recent-completed-race finishers as of this epoch (dereg-protection tail)
     */
    finishers?: Array<PinnedFinisher>;
};

export type EvalRunNotFoundError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "EVAL_RUN_NOT_FOUND";
};

/**
 * Which phase of the qualifying+race cycle an evaluation belongs to.
 */
export type EvaluationPhase = 'QUALIFYING' | 'RACE';

export type EvaluationRunDetail = {
    /**
     * Unique identifier for this run
     */
    eval_run_id: string;
    /**
     * Agent version being evaluated
     */
    agent_version_id: string;
    /**
     * Name of the agent
     */
    agent_name: string;
    /**
     * Validator performing evaluation
     */
    validator_hotkey: string;
    /**
     * Current run status
     */
    status: EvaluationRunStatus;
    /**
     * Score if completed successfully
     */
    score?: (number | null);
    /**
     * Version number within this agent (v1, v2, etc.)
     */
    version_number: number;
    /**
     * When the run was claimed
     */
    claimed_at: string;
    /**
     * When the run completed
     */
    completed_at?: (string | null);
    /**
     * Validator-reported failure reason
     */
    failure_reason?: (string | null);
    /**
     * Whether run is included in aggregate scoring
     */
    is_included?: boolean;
    /**
     * When run was invalidated
     */
    invalidated_at?: (string | null);
    /**
     * Reason for invalidation
     */
    invalidation_reason?: (string | null);
    /**
     * Sandbox execution details
     */
    sandbox_metadata?: ({
    [key: string]: unknown;
} | null);
    /**
     * Score breakdown including reasoning details
     */
    score_components_summary?: ({
    [key: string]: unknown;
} | null);
};

export type EvaluationRunPublic = {
    /**
     * Unique identifier for this run
     */
    eval_run_id: string;
    /**
     * Agent version being evaluated
     */
    agent_version_id: string;
    /**
     * Suite ID
     */
    suite_id: number;
    /**
     * Validator performing evaluation
     */
    validator_hotkey: string;
    /**
     * Run status
     */
    status: EvaluationRunStatus;
    /**
     * When the run was claimed
     */
    claimed_at: string;
    /**
     * Lease expiration
     */
    lease_expires_at: string;
    /**
     * Last heartbeat
     */
    last_heartbeat_at?: (string | null);
    /**
     * Completion timestamp
     */
    completed_at?: (string | null);
    /**
     * Whether run is included in aggregate
     */
    is_included: boolean;
    /**
     * When run was invalidated
     */
    invalidated_at?: (string | null);
    /**
     * Who invalidated the run
     */
    invalidated_by?: (string | null);
    /**
     * Reason for invalidation
     */
    invalidation_reason?: (string | null);
    /**
     * Validator-reported failure reason
     */
    failure_reason?: (string | null);
    /**
     * Score on success
     */
    validator_score?: (number | null);
    /**
     * Average reasoning quality from LLM judge (0-1)
     */
    reasoning_quality?: (number | null);
    /**
     * Reasoning coefficient applied to outcome score (0.3-1.0)
     */
    reasoning_coefficient?: (number | null);
    /**
     * Score breakdown on success
     */
    score_components_summary?: ({
    [key: string]: unknown;
} | null);
    /**
     * Snapshot of validator service versions at claim time
     */
    service_versions?: ({
    [key: string]: (string);
} | null);
    /**
     * Sandbox execution details
     */
    sandbox_metadata?: ({
    [key: string]: unknown;
} | null);
    /**
     * Evaluation phase (QUALIFYING or RACE)
     */
    phase?: (string | null);
    /**
     * Race ID if this is a race-phase evaluation
     */
    race_id?: (string | null);
    /**
     * Race number if this is a race-phase evaluation
     */
    race_number?: (number | null);
};

/**
 * Status of an evaluation run through its lifecycle.
 */
export type EvaluationRunStatus = 'CLAIMED' | 'RUNNING' | 'SUCCESS' | 'FAILED' | 'TIMED_OUT' | 'STALE' | 'CANCELLED';

export type EvaluationRunStatusPublic = {
    /**
     * Evaluation run ID
     */
    eval_run_id: string;
    /**
     * Agent version being evaluated
     */
    agent_version_id: string;
    /**
     * Problem suite ID
     */
    suite_id: number;
    /**
     * Validator performing the evaluation
     */
    validator_hotkey: string;
    /**
     * Current run status
     */
    status: EvaluationRunStatus;
    /**
     * When the run was claimed
     */
    claimed_at: string;
    /**
     * When the lease expires
     */
    lease_expires_at: string;
    /**
     * Whether this run is included in scoring
     */
    is_included: boolean;
    /**
     * Last heartbeat from the validator
     */
    last_heartbeat_at?: (string | null);
    /**
     * When the run completed
     */
    completed_at?: (string | null);
    /**
     * When the run was invalidated
     */
    invalidated_at?: (string | null);
    /**
     * Hotkey of the admin who invalidated the run
     */
    invalidated_by?: (string | null);
    /**
     * Reason the run was invalidated
     */
    invalidation_reason?: (string | null);
    /**
     * Score assigned by the validator
     */
    validator_score?: (number | null);
    /**
     * Summary of score components
     */
    score_components_summary?: ({
    [key: string]: unknown;
} | null);
};

/**
 * Request body for ``POST /v1/miner/chutes/exchange-code``.
 *
 * SDK sends this after capturing the auth code from Chutes' redirect. Backend
 * completes the OAuth token exchange server-side (where the ``client_secret``
 * lives) and persists the resulting refresh_token encrypted under the miner's
 * hotkey.
 */
export type ExchangeChutesCodeRequest = {
    /**
     * Authorization code from Chutes /idp/authorize redirect.
     */
    code: string;
    /**
     * PKCE code_verifier the SDK generated before /idp/authorize. Per RFC 7636: 43–128 characters from the unreserved set [A-Za-z0-9-._~].
     */
    code_verifier: string;
    /**
     * Must exactly match the redirect_uri the SDK sent to /idp/authorize (per RFC 6749 §4.1.3). Backend validates against an allowlist.
     */
    redirect_uri: string;
};

/**
 * Response body for ``POST /v1/miner/chutes/exchange-code``.
 */
export type ExchangeChutesCodeResponse = {
    /**
     * True on successful exchange + persistence.
     */
    ok: boolean;
    /**
     * Miner's default inference provider after persistence. Set to 'chutes' if this was the miner's first provider connection.
     */
    default_provider?: (string | null);
};

export type FileTooLargeError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "FILE_TOO_LARGE";
};

export type HeartbeatRequest = {
    /**
     * Docker image digests for validator stack services
     */
    service_versions?: ({
    [key: string]: (string);
} | null);
    /**
     * Validator host CPU utilisation percentage (0-100)
     */
    cpu_pct?: (number | null);
    /**
     * Validator host RAM utilisation percentage (0-100)
     */
    ram_pct?: (number | null);
    /**
     * Validator host disk utilisation percentage on the sandbox volume (0-100)
     */
    disk_pct?: (number | null);
    /**
     * Validator host running Docker container count
     */
    docker_container_count?: (number | null);
};

export type HeartbeatResponse = {
    /**
     * New lease expiry after heartbeat
     */
    lease_expires_at: string;
};

export type HTTPValidationError = {
    detail?: Array<ValidationError>;
};

/**
 * Response body for ``GET /v1/miner/inference-auth``.
 */
export type InferenceAuthListResponse = {
    providers: Array<InferenceAuthStatusResponse>;
    /**
     * Which provider claim_work mints a token from. Null = single-provider auto-pick.
     */
    default_provider?: (string | null);
};

/**
 * Response body for ``GET /v1/miner/inference-auth/{provider}``.
 */
export type InferenceAuthStatusResponse = {
    connected: boolean;
    provider: string;
    /**
     * When the credential for this provider was last updated.
     */
    updated_at?: (string | null);
};

/**
 * List of models available to ORO agents via the inference proxy.
 */
export type InferenceModelsResponse = {
    /**
     * Allowed model identifiers
     */
    models: Array<(string)>;
};

/**
 * Per-run scoped inference credential issued at claim_work.
 */
export type InferenceTokenGrant = {
    /**
     * Provider that minted the token.
     */
    provider: 'chutes' | 'openrouter';
    /**
     * Bearer credential the validator presents at base_url.
     */
    access_token: string;
    /**
     * Inference API base URL (OpenAI-compatible chat/completions).
     */
    base_url: string;
    /**
     * UTC timestamp when this token stops being usable.
     */
    expires_at: string;
};

/**
 * Provider that minted the token.
 */
export type provider = 'chutes' | 'openrouter';

export type InvalidAgentNameError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "INVALID_AGENT_NAME";
};

export type InvalidArtifactTypeError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "INVALID_ARTIFACT_TYPE";
};

export type InvalidateRunRequest = {
    /**
     * Reason for invalidating the run
     */
    reason: string;
};

export type InvalidFileError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "INVALID_FILE";
};

export type InvalidProblemIdError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "INVALID_PROBLEM_ID";
};

export type LeaderboardEntry = {
    /**
     * Leaderboard rank
     */
    rank: number;
    /**
     * Agent version ID
     */
    agent_version_id: string;
    /**
     * Agent name
     */
    agent_name: string;
    /**
     * Miner hotkey
     */
    miner_hotkey: string;
    /**
     * Version number within this agent (v1, v2, etc.)
     */
    version_number: number;
    /**
     * Final score
     */
    final_score: number;
    /**
     * Competitive evaluation score
     */
    race_score?: (number | null);
    /**
     * When eligibility was reached
     */
    eligible_at?: (string | null);
    /**
     * Whether discarded by admin
     */
    is_discarded?: boolean;
    /**
     * Whether miner is banned
     */
    is_miner_banned?: boolean;
    /**
     * Current top agent for emissions
     */
    is_current_top?: boolean;
    /**
     * Previously held top agent status
     */
    was_top?: boolean;
    /**
     * When this agent became top
     */
    top_at?: (string | null);
    /**
     * True when this version is the active qualifier on its hotkey for the open race (covers both the incumbent and the scored qualifier).
     */
    is_active_qualifier?: boolean;
    /**
     * Set when this version's score qualifies but a higher-scoring sibling on the same hotkey is the active qualifier instead.
     */
    outranked_by_agent_version_id?: (string | null);
    /**
     * UTC timestamp when this agent was eliminated from future races.
     */
    eliminated_at?: (string | null);
    /**
     * 3-race pooled ('weighted') score across the current window.
     */
    weighted_score?: (number | null);
    /**
     * Per-race build-up of the pooled window (seed entries flag races the agent did not run; count the non-seed entries for races contributing).
     */
    window?: (Array<PooledWindowRace> | null);
};

export type LeaderboardResponse = {
    /**
     * Total entries matching filter
     */
    total: number;
    /**
     * Page size
     */
    limit: number;
    /**
     * Page offset
     */
    offset: number;
    /**
     * Suite information
     */
    suite: SuitePublic;
    /**
     * Leaderboard entries
     */
    entries: Array<LeaderboardEntry>;
    /**
     * Distinct miner hotkeys on leaderboard
     */
    unique_miners: number;
    /**
     * Count of agent versions submitted in the last 24 hours (across all suites)
     */
    agents_submitted_24h?: number;
    /**
     * Score required to dethrone current top
     */
    challenge_threshold?: (number | null);
};

export type LeaseExpiredError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "LEASE_EXPIRED";
};

export type LogoutResponse = {
    /**
     * Whether logout was successful
     */
    success: boolean;
};

export type MinerAgentsResponse = {
    /**
     * List of agents owned by the miner
     */
    agents: Array<AgentPublic>;
    /**
     * Whether the miner is currently allowed to submit a new agent
     */
    can_submit: boolean;
    /**
     * Earliest time the miner may submit again, if on cooldown
     */
    next_allowed_at?: (string | null);
    /**
     * The agent_version_id this miner would race with right now: the explicitly pinned version when valid, otherwise the picker's auto-pick (highest-scoring eligible version on this hotkey >= the qualifying threshold). None when nothing on this hotkey qualifies.
     */
    racing_agent_version_id?: (string | null);
    /**
     * The agent_id that owns racing_agent_version_id. Surfaced alongside the version id so the dashboard can highlight the right row even when the racing version isn't that agent's latest. None when racing_agent_version_id is None.
     */
    racing_agent_id?: (string | null);
};

export type MinerNotFoundError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "MINER_NOT_FOUND";
};

export type MinerRaceSelectionRequest = {
    /**
     * Agent version to pin as the race candidate
     */
    agent_version_id: string;
};

export type MissingParameterError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "MISSING_PARAMETER";
};

export type MissingScoreError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "MISSING_SCORE";
};

export type NoActiveSuiteError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "NO_ACTIVE_SUITE";
};

export type NoSelectionError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "NO_SELECTION";
};

export type NotRunOwnerError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "NOT_RUN_OWNER";
};

export type NotVersionOwnerError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "NOT_VERSION_OWNER";
};

export type PendingEvaluation = {
    /**
     * Unique work item identifier
     */
    work_item_id: string;
    /**
     * Agent version being evaluated
     */
    agent_version_id: string;
    /**
     * Name of the agent
     */
    agent_name: string;
    /**
     * Version number within this agent
     */
    version_number: number;
    /**
     * Miner who owns the agent
     */
    miner_hotkey: string;
    /**
     * Problem suite ID
     */
    suite_id: number;
    /**
     * Total successful evaluations needed
     */
    required_successes: number;
    /**
     * Successful evaluations completed so far
     */
    completed_successes: number;
    /**
     * Currently CLAIMED or RUNNING evaluations
     */
    active_runs: number;
    /**
     * Additional validator claims still needed
     */
    remaining: number;
    /**
     * When this work item was created
     */
    queued_at: string;
    /**
     * Evaluation phase (QUALIFYING or RACE)
     */
    phase?: (string | null);
    /**
     * Race ID when phase is RACE
     */
    race_id?: (string | null);
};

export type PendingEvaluationsResponse = {
    /**
     * Aggregate queue statistics
     */
    summary: PendingEvaluationSummary;
    /**
     * Individual pending work items
     */
    items: Array<PendingEvaluation>;
};

export type PendingEvaluationSummary = {
    /**
     * Number of open work items
     */
    total_pending: number;
    /**
     * Sum of remaining runs across all items
     */
    total_runs_needed: number;
    /**
     * Sum of active runs across all items
     */
    total_runs_active: number;
    /**
     * Projected UTC timestamp when the queue will fully drain. Null when the queue is empty, no validators are currently active, or there is insufficient evaluation history to project.
     */
    projected_completion_at?: (string | null);
};

/**
 * One race finisher in the epoch-pinned base standings (ORO-1704).
 *
 * Exactly the fields the validator maps to its ``RankedFinisher`` — which the
 * weight builder re-sorts by ``race_score`` desc, tie-break ``agent_version_id``
 * asc. Both are required so the pinned vector is byte-identical to the live one;
 * the serve order is irrelevant (the validator re-sorts).
 */
export type PinnedFinisher = {
    /**
     * Finisher's miner hotkey (ss58)
     */
    miner_hotkey: string;
    /**
     * Finisher's agent version id (rank tie-break)
     */
    agent_version_id: string;
    /**
     * Finisher's race score (ranking key)
     */
    race_score: number;
};

export type PooledWindowRace = {
    race_id: string;
    race_number: number;
    raw_score: (number | null);
    rank: (number | null);
    anchor: number;
    delta: number;
    is_seed: boolean;
};

export type PresignUploadRequest = {
    /**
     * MIME type of the upload
     */
    content_type?: string;
    /**
     * Size in bytes of the upload payload
     */
    content_length: number;
    /**
     * Evaluation run these results belong to
     */
    eval_run_id: string;
    /**
     * Problem these results belong to
     */
    problem_id: string;
};

export type PresignUploadResponse = {
    /**
     * Presigned URL to upload to
     */
    upload_url: string;
    /**
     * HTTP method to use for upload
     */
    method?: string;
    /**
     * S3 key where the results will be stored
     */
    results_s3_key: string;
    /**
     * When the presigned URL expires
     */
    expires_at: string;
};

export type ProblemNotFoundError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "PROBLEM_NOT_FOUND";
};

export type ProblemProgressEntry = {
    /**
     * Problem ID
     */
    problem_id: string;
    /**
     * Problem category
     */
    category?: (string | null);
    /**
     * Evaluation phase: QUALIFYING or RACE
     */
    phase?: (string | null);
    /**
     * Race ID when phase is RACE
     */
    race_id?: (string | null);
    /**
     * Results from each validator that evaluated this problem
     */
    validator_results?: Array<ValidatorProblemResult>;
};

export type ProblemProgressUpdate = {
    /**
     * Problem being reported on
     */
    problem_id: string;
    /**
     * Current status of this problem
     */
    status: ProblemStatus;
    /**
     * Normalised score for this problem
     */
    score?: (number | null);
    /**
     * Breakdown of score components
     */
    score_components_summary?: ({
    [key: string]: unknown;
} | null);
    /**
     * S3 key for problem-level logs
     */
    logs_s3_key?: (string | null);
    /**
     * Reasoning quality score
     */
    reasoning_score?: (number | null);
    /**
     * Number of failed inference calls
     */
    inference_failure_count?: (number | null);
    /**
     * Total number of inference calls
     */
    inference_total?: (number | null);
    /**
     * Sandbox execution time for this problem in seconds
     */
    execution_time?: (number | null);
};

export type ProblemPublic = {
    /**
     * Unique identifier for the problem
     */
    problem_id: string;
    /**
     * Parent suite ID
     */
    suite_id: number;
    /**
     * Full problem metadata
     */
    metadata?: {
        [key: string]: unknown;
    };
};

export type ProblemStatus = 'PENDING' | 'RUNNING' | 'SUCCESS' | 'FAILED' | 'SKIPPED' | 'TIMED_OUT';

export type ProgressUpdateRequest = {
    /**
     * Per-problem progress updates
     */
    problems: Array<ProblemProgressUpdate>;
};

export type ProgressUpdateResponse = {
    /**
     * Whether the update was accepted
     */
    accepted?: boolean;
};

export type RaceCurrentResponse = {
    /**
     * Current race, if any
     */
    race?: (RacePublic | null);
    /**
     * Race qualifiers
     */
    qualifiers?: Array<RaceQualifierPublic>;
};

export type RaceDetailResponse = {
    /**
     * Race details
     */
    race: RacePublic;
    /**
     * Race qualifiers
     */
    qualifiers?: Array<RaceQualifierPublic>;
};

export type RaceDiagnosticsResponse = {
    /**
     * Race ID
     */
    race_id: string;
    /**
     * Problem suite ID
     */
    suite_id: number;
    race_number?: (number | null);
    /**
     * Current race status
     */
    status: string;
    qualifying_closes_at?: (string | null);
    race_started_at?: (string | null);
    race_completed_at?: (string | null);
    winner_agent_version_id?: (string | null);
    winner_score?: (number | null);
    /**
     * Score threshold for qualifying
     */
    qualifying_threshold?: (number | null);
    /**
     * Current incumbent agent version ID
     */
    incumbent_agent_version_id?: (string | null);
    /**
     * Seed used for problem selection
     */
    problem_seed?: (string | null);
    /**
     * Number of problems in the race
     */
    problem_count?: number;
    /**
     * Qualified agent versions
     */
    qualifiers?: Array<RaceQualifierEntry>;
    /**
     * Race work items
     */
    work_items?: Array<RaceWorkItemEntry>;
};

export type RaceHistoryResponse = {
    /**
     * Total entries matching filter
     */
    total: number;
    /**
     * Page size
     */
    limit: number;
    /**
     * Page offset
     */
    offset: number;
    /**
     * Historical races
     */
    races: Array<RacePublic>;
};

export type RaceInFlightError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "RACE_IN_FLIGHT";
};

export type RaceLockedError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "RACE_LOCKED";
};

export type RaceNotFoundError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "RACE_NOT_FOUND";
};

export type RacePublic = {
    /**
     * Race ID
     */
    race_id: string;
    /**
     * Problem suite ID
     */
    suite_id: number;
    race_number?: (number | null);
    /**
     * Current race status
     */
    status: string;
    qualifying_closes_at?: (string | null);
    race_started_at?: (string | null);
    race_completed_at?: (string | null);
    winner_agent_version_id?: (string | null);
    winner_score?: (number | null);
    /**
     * Score threshold for qualifying
     */
    qualifying_threshold?: (number | null);
    /**
     * Name of the winning agent
     */
    winner_agent_name?: (string | null);
    /**
     * Number of qualifiers in this race
     */
    qualifier_count?: number;
    /**
     * Number of qualifiers that have a completed race evaluation so far — an evaluation-progress signal (scored_count / qualifier_count). Unlike the per-agent scores (which are embargoed while a race runs, ORO-1811), this aggregate count reveals only how far along the race is, not who is winning, so it stays visible throughout. Null when not computed.
     */
    scored_count?: (number | null);
    /**
     * Arithmetic mean of race_score across the top half (by race_score desc) of qualifiers with non-null race_score. Null when the race has no scored qualifiers. Pre-computed so Frontend doesn't have to fan out per-race detail fetches for the Challenge History chart's tooltip distribution stats.
     */
    top50_mean?: (number | null);
    /**
     * Population standard deviation of race_score across the same top-half slice as top50_mean. Null when the race has no scored qualifiers; 0.0 when the top half contains a single row.
     */
    top50_std?: (number | null);
    /**
     * When the race was created
     */
    created_at?: (string | null);
    /**
     * Projected UTC timestamp when the race will complete. Set only on RACE_RUNNING races; null otherwise or when there is insufficient evaluation history or no active validators.
     */
    projected_completion_at?: (string | null);
};

export type RaceQualifierEntry = {
    /**
     * Agent version ID
     */
    agent_version_id: string;
    /**
     * Agent name
     */
    agent_name?: (string | null);
    /**
     * Miner hotkey
     */
    miner_hotkey?: (string | null);
    /**
     * Version number within this agent
     */
    version_number?: number;
    /**
     * How agent qualified (INCUMBENT or SCORED)
     */
    qualification_type: string;
    /**
     * Score from qualifying
     */
    qualifying_score?: (number | null);
    /**
     * Score from race phase
     */
    race_score?: (number | null);
    /**
     * UTC timestamp when this agent was eliminated from future races, if any. Sourced from the agent version aggregate, not the qualifier row.
     */
    eliminated_at?: (string | null);
};

export type RaceQualifierPublic = {
    /**
     * Agent version ID
     */
    agent_version_id: string;
    /**
     * Agent name
     */
    agent_name?: (string | null);
    /**
     * Miner hotkey
     */
    miner_hotkey?: (string | null);
    /**
     * Version number within this agent
     */
    version_number?: number;
    /**
     * How agent qualified (INCUMBENT or SCORED)
     */
    qualification_type: string;
    /**
     * Score from qualifying
     */
    qualifying_score?: (number | null);
    /**
     * Score from race phase
     */
    race_score?: (number | null);
    /**
     * UTC timestamp when this agent was eliminated from future races, if any. Sourced from the agent version aggregate, not the qualifier row.
     */
    eliminated_at?: (string | null);
    /**
     * Rank within the race
     */
    race_rank?: (number | null);
    /**
     * True when the agent's aggregate is marked discarded (admin- or auto-discarded). Sourced from AgentVersionAggregate for this version + suite; defaults to False if no aggregate row exists.
     */
    is_discarded?: boolean;
    /**
     * 3-race pooled ('weighted') score across the current window.
     */
    weighted_score?: (number | null);
    /**
     * Per-race build-up of the pooled window for this qualifier (seed entries flag races this version did not run; respects the launch floor).
     */
    window?: (Array<PooledWindowRace> | null);
};

export type RaceSummary = {
    /**
     * Race ID
     */
    race_id: string;
    /**
     * Problem suite ID
     */
    suite_id: number;
    race_number?: (number | null);
    /**
     * Current race status
     */
    status: string;
    qualifying_closes_at?: (string | null);
    race_started_at?: (string | null);
    race_completed_at?: (string | null);
    winner_agent_version_id?: (string | null);
    winner_score?: (number | null);
    /**
     * Number of qualifiers in this race
     */
    qualifier_count?: number;
    /**
     * Number of work items in this race
     */
    work_item_count?: number;
};

/**
 * Per-validator variance stats for a race.
 *
 * See ``GET /v1/public/races/{race_id}/validator-variance`` description
 * for the input filter (included SUCCESS runs, RACE-phase, ≥2 validators).
 */
export type RaceValidatorVarianceResponse = {
    race_id: string;
    race_number?: (number | null);
    /**
     * Agent-race pairs where ≥2 validators produced included SUCCESS runs
     */
    n_pairs: number;
    /**
     * Mean (top validator score − bottom validator score) across pairs. Null when n_pairs == 0.
     */
    mean_spread?: (number | null);
    median_spread?: (number | null);
    max_spread?: (number | null);
    /**
     * Fraction of pairs at or above given spread thresholds
     */
    spread_buckets?: Array<SpreadBucket>;
    /**
     * Per-validator bias statistics (sorted by validator_name)
     */
    validators?: Array<ValidatorVarianceEntry>;
};

export type RaceWorkItemEntry = {
    /**
     * Agent version ID
     */
    agent_version_id: string;
    /**
     * Agent name
     */
    agent_name?: (string | null);
    /**
     * Race phase (qualifying or race)
     */
    phase: string;
    /**
     * Whether the work item is closed
     */
    is_closed: boolean;
    /**
     * Whether the work item is cancelled
     */
    is_cancelled: boolean;
    /**
     * Number of included successful runs
     */
    included_success_count: number;
    /**
     * Number of active runs
     */
    active_count: number;
    /**
     * Required number of successful runs
     */
    required_successes: number;
};

/**
 * One row in a ranked inference-models response.
 *
 * ``rank_metric`` is provider-specific: Chutes returns rate-limit ratio +
 * utilization + instance counts; OpenRouter returns uptime + latency +
 * status.
 */
export type RankedInferenceModel = {
    id: string;
    rank_metric?: {
        [key: string]: unknown;
    };
    healthy?: boolean;
};

/**
 * Models in ranked order — earlier entries are preferred.
 */
export type RankedInferenceModelsResponse = {
    models: Array<RankedInferenceModel>;
    /**
     * Sort applied; null on cold start (static fallback order).
     */
    ranked_by?: (string | null);
    as_of?: (string | null);
};

export type RateLimitExceededError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "RATE_LIMIT_EXCEEDED";
};

export type ReaperStatsResponse = {
    /**
     * Whether the reaper is enabled
     */
    enabled: boolean;
    /**
     * Whether the reaper is currently running
     */
    is_running: boolean;
    /**
     * When the reaper last ran
     */
    last_run_at?: (string | null);
    /**
     * Total number of runs reaped since startup
     */
    runs_reaped_total: number;
    /**
     * Number of runs reaped in the last cycle
     */
    runs_reaped_last_cycle: number;
    /**
     * Duration of the last reaper cycle in milliseconds
     */
    last_cycle_duration_ms: number;
    /**
     * Total number of reaper errors
     */
    error_count: number;
    /**
     * Total number of Redis-related reaper errors
     */
    redis_error_count: number;
    /**
     * Reaper cycle interval in seconds
     */
    interval_seconds: number;
};

export type ReevaluateRequest = {
    /**
     * Reason for re-evaluation
     */
    reason: string;
    /**
     * Specific suite to re-evaluate against
     */
    suite_id?: (number | null);
    /**
     * Override for number of required successful evaluations
     */
    required_successes?: (number | null);
};

export type ReevaluateResponse = {
    /**
     * Agent version queued for re-evaluation
     */
    agent_version_id: string;
};

export type ReinstateEliminationRequest = {
    /**
     * Specific suite to reinstate elimination for
     */
    suite_id?: (number | null);
    /**
     * Optional reason captured in the audit trail
     */
    reason?: (string | null);
};

export type ReinstateEliminationResponse = {
    /**
     * Agent version whose elimination was cleared
     */
    agent_version_id: string;
    /**
     * Suite the elimination was cleared for
     */
    suite_id: number;
};

export type ReinstateRequest = {
    /**
     * Specific suite to reinstate for
     */
    suite_id?: (number | null);
    /**
     * Optional reason captured in the audit trail
     */
    reason?: (string | null);
};

export type RunAlreadyCompleteError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "RUN_ALREADY_COMPLETE";
};

export type RunningEvaluation = {
    /**
     * Unique identifier for this run
     */
    eval_run_id: string;
    /**
     * Agent version being evaluated
     */
    agent_version_id: string;
    /**
     * Name of the agent
     */
    agent_name: string;
    /**
     * Version number within this agent (v1, v2, etc.)
     */
    version_number: number;
    /**
     * Miner who owns the agent
     */
    miner_hotkey: string;
    /**
     * Validator performing evaluation
     */
    validator_hotkey: string;
    /**
     * Current run status
     */
    status: EvaluationRunStatus;
    /**
     * When evaluation started
     */
    started_at: string;
    /**
     * Percentage of problems completed (0-100)
     */
    progress_percent?: number;
    /**
     * Evaluation phase (QUALIFYING or RACE)
     */
    phase?: (string | null);
    /**
     * Race ID when phase is RACE
     */
    race_id?: (string | null);
};

export type RunProblemsResponse = {
    /**
     * Problems to evaluate
     */
    problems: Array<ProblemPublic>;
};

/**
 * 400 - Candidate score does not exceed the challenge threshold.
 */
export type ScoreBelowThresholdError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "SCORE_BELOW_THRESHOLD";
    /**
     * Score of the candidate agent
     */
    candidate_score: number;
    /**
     * Minimum score required to dethrone the current top
     */
    required_score: number;
    /**
     * Score of the current top agent
     */
    current_top_score: number;
    /**
     * Current challenge margin fraction
     */
    margin: number;
};

export type SessionRequest = {
    /**
     * SS58 hotkey address
     */
    hotkey: string;
    /**
     * Challenge that was signed
     */
    challenge: string;
    /**
     * Hex-encoded signature
     */
    signature: string;
};

export type SessionResponse = {
    /**
     * Session token for authenticated requests
     */
    session_token: string;
    /**
     * Unix timestamp when session expires
     */
    expires_at: number;
    /**
     * User role (miner, validator, admin)
     */
    role: string;
};

/**
 * Request body for ``PATCH /v1/miner/inference-auth/default``.
 */
export type SetDefaultProviderRequest = {
    provider: string;
};

export type SetTopRequest = {
    /**
     * Specific suite to set top agent for
     */
    suite_id?: (number | null);
    /**
     * Force set even if version has lower score
     */
    force?: boolean;
};

export type SetTopResponse = {
    /**
     * Agent version set as top
     */
    agent_version_id: string;
    /**
     * Suite the top agent was set for
     */
    suite_id: number;
    /**
     * Previous top agent version ID, if any
     */
    previous_top_agent_version_id?: (string | null);
    /**
     * Timestamp when the top agent was set
     */
    top_at: string;
};

export type SimilarityCheckUnavailableError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "SIMILARITY_CHECK_UNAVAILABLE";
};

export type SpreadBucket = {
    /**
     * Spread threshold in percentage points
     */
    threshold_pp: number;
    /**
     * Pairs at or above the threshold
     */
    count: number;
    /**
     * Share of pairs at or above the threshold
     */
    pct: number;
};

export type StoreChutesTokenRequest = {
    /**
     * Chutes OAuth refresh token to store
     */
    refresh_token: string;
};

/**
 * Request body for ``POST /v1/miner/inference-auth/{provider}``.
 */
export type StoreInferenceCredentialRequest = {
    /**
     * Provider-specific credential (refresh token, API key, etc.)
     */
    credential: string;
};

export type SubmitAgentResponse = {
    /**
     * Unique identifier for the created agent
     */
    agent_id?: (string | null);
    /**
     * Unique identifier for the created agent version
     */
    agent_version_id?: (string | null);
    /**
     * Whether the submission was accepted or rejected
     */
    admission_status: AdmissionStatus;
    /**
     * Reason for rejection, if the submission was rejected
     */
    admission_reason?: (AdmissionReason | null);
    /**
     * Earliest time the miner may submit again after cooldown
     */
    next_allowed_at?: (string | null);
    /**
     * Hotkey of the miner who submitted the agent
     */
    hotkey: string;
    /**
     * Human-readable status message
     */
    message?: string;
};

export type SuiteNotFoundError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "SUITE_NOT_FOUND";
};

export type SuitePublic = {
    /**
     * Problem suite version/ID
     */
    suite_id: number;
    /**
     * Version number of the problem suite
     */
    suite_version: number;
    /**
     * Whether this suite is currently active
     */
    is_active: boolean;
};

export type SuiteWithProblemsResponse = {
    /**
     * Suite information
     */
    suite: SuitePublic;
    /**
     * Problems in this suite
     */
    problems: Array<ProblemPublic>;
};

export type TerminalStatus = 'SUCCESS' | 'FAILED' | 'TIMED_OUT';

export type TopAgentResponse = {
    /**
     * Active suite ID
     */
    suite_id: number;
    /**
     * When this was computed
     */
    computed_at: string;
    /**
     * Top agent version ID
     */
    top_agent_version_id?: (string | null);
    /**
     * Top miner's hotkey
     */
    top_miner_hotkey?: (string | null);
    /**
     * Top score
     */
    top_score?: (number | null);
    /**
     * Challenge-threshold + burn-rate params
     */
    policy?: ({
    [key: string]: unknown;
} | null);
    /**
     * Score required to dethrone
     */
    challenge_threshold?: (number | null);
    /**
     * Current challenge margin fraction
     */
    margin?: (number | null);
};

export type TopHistoryEntry = {
    /**
     * Agent version ID
     */
    agent_version_id: string;
    /**
     * Agent name
     */
    agent_name: string;
    /**
     * Miner hotkey
     */
    miner_hotkey: string;
    /**
     * Version number
     */
    version_number: number;
    /**
     * Final score
     */
    final_score: number;
    /**
     * When this agent became top
     */
    top_at: string;
    /**
     * Currently the top agent
     */
    is_current_top: boolean;
    /**
     * Previously held top agent status
     */
    was_top: boolean;
    /**
     * Suite this top status was earned on
     */
    suite_id: number;
};

export type TopHistoryResponse = {
    /**
     * Suite ID
     */
    suite_id: number;
    /**
     * Top agent history entries
     */
    entries: Array<TopHistoryEntry>;
};

export type TopMinerPayoutResponse = {
    /**
     * Top miner's hotkey
     */
    miner_hotkey?: (string | null);
    /**
     * Top miner's agent name
     */
    agent_name?: (string | null);
    /**
     * Estimated TAO emitted per day
     */
    tao_per_day?: (number | null);
    /**
     * Estimated USD equivalent per day
     */
    usd_per_day?: (number | null);
    /**
     * TAO/USD price used for USD estimate
     */
    tao_price_usd?: (number | null);
    /**
     * When this payout estimate was computed
     */
    as_of: string;
};

export type UpdateValidatorRequest = {
    /**
     * Maximum concurrent evaluation runs (must be >= 1)
     */
    max_concurrent_runs: number;
};

export type ValidationError = {
    loc: Array<(string | number)>;
    msg: string;
    type: string;
    input?: unknown;
    ctx?: {
        [key: string]: unknown;
    };
};

export type ValidationErrorError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "VALIDATION_ERROR";
};

export type ValidatorCurrentAgent = {
    /**
     * Name of the agent being evaluated
     */
    agent_name: string;
    /**
     * Agent version ID
     */
    version_id: string;
    /**
     * Version number within this agent (v1, v2, etc.)
     */
    version_number: number;
    /**
     * When evaluation started
     */
    started_at: string;
};

/**
 * A single FAILED/TIMED_OUT evaluation run from a validator.
 */
export type ValidatorFailureEntry = {
    /**
     * Evaluation run identifier
     */
    eval_run_id: string;
    /**
     * Agent version that was being evaluated
     */
    agent_version_id: string;
    /**
     * Reason the run failed (free-form string)
     */
    failure_reason?: (string | null);
    /**
     * When the run completed (UTC)
     */
    completed_at?: (string | null);
    /**
     * Terminal status — FAILED or TIMED_OUT
     */
    status: string;
};

/**
 * Recent failures for a single validator, ordered by completed_at DESC.
 */
export type ValidatorFailuresResponse = {
    /**
     * Validator whose failures these are
     */
    validator_hotkey: string;
    /**
     * Recent failure entries
     */
    failures: Array<ValidatorFailureEntry>;
    /**
     * Number of entries returned
     */
    total: number;
};

export type ValidatorNotFoundError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "VALIDATOR_NOT_FOUND";
};

export type ValidatorPauseRequest = {
    /**
     * Reason for pulling the andon cord
     */
    reason: string;
    /**
     * UTC timestamp at which the pause auto-clears. Safety net so a pause can't be left on by accident.
     */
    auto_release_at?: (string | null);
};

export type ValidatorPauseStatus = {
    /**
     * True when validator claims are paused
     */
    active: boolean;
    /**
     * Reason from the most recent pause
     */
    reason?: (string | null);
    /**
     * Admin hotkey that pulled the cord
     */
    paused_by?: (string | null);
    /**
     * When the cord was pulled
     */
    paused_at?: (string | null);
    /**
     * When the pause will auto-clear, if scheduled
     */
    auto_release_at?: (string | null);
};

export type ValidatorProblemResult = {
    /**
     * Evaluation run ID this result belongs to
     */
    eval_run_id: string;
    /**
     * Validator hotkey
     */
    validator_hotkey: string;
    /**
     * Problem status from this validator
     */
    status: ProblemStatus;
    /**
     * Problem score from this validator
     */
    score?: (number | null);
    /**
     * Score breakdown from this validator
     */
    score_components?: ({
    [key: string]: unknown;
} | null);
    /**
     * Reasoning quality score from LLM judge
     */
    reasoning_score?: (number | null);
    /**
     * Last update from this validator
     */
    updated_at?: (string | null);
    /**
     * Number of failed inference calls for this problem
     */
    inference_failure_count?: (number | null);
    /**
     * Total number of inference calls for this problem
     */
    inference_total?: (number | null);
    /**
     * Sandbox execution time for this problem in seconds
     */
    execution_time?: (number | null);
};

export type ValidatorPublic = {
    /**
     * Validator's SS58 address
     */
    hotkey: string;
    /**
     * On-chain identity name, if set
     */
    name?: (string | null);
    /**
     * Current validator status
     */
    status: ValidatorStatus;
    /**
     * When validator was registered
     */
    registered_at: string;
    /**
     * Last work claim time
     */
    last_claim_at?: (string | null);
    /**
     * Last time validator was seen
     */
    last_seen_at?: (string | null);
    /**
     * Agent currently being evaluated, if any
     */
    current_agent?: (ValidatorCurrentAgent | null);
    /**
     * Docker image digests for validator stack services
     */
    service_versions?: ({
    [key: string]: (string);
} | null);
    /**
     * On-chain identity URL
     */
    identity_url?: (string | null);
    /**
     * On-chain identity image URL
     */
    identity_image?: (string | null);
    /**
     * On-chain identity description
     */
    identity_description?: (string | null);
    /**
     * Latest reported host CPU utilisation percentage (0-100)
     */
    cpu_pct?: (number | null);
    /**
     * Latest reported host RAM utilisation percentage (0-100)
     */
    ram_pct?: (number | null);
    /**
     * Latest reported host disk utilisation percentage on the sandbox volume (0-100)
     */
    disk_pct?: (number | null);
    /**
     * Latest reported running Docker container count on the host
     */
    docker_container_count?: (number | null);
    /**
     * UTC timestamp of the last resource-metrics report
     */
    metrics_reported_at?: (string | null);
};

export type ValidatorResourceSampleEntry = {
    validator_hotkey: string;
    recorded_at: string;
    cpu_pct?: (number | null);
    ram_pct?: (number | null);
    disk_pct?: (number | null);
    docker_container_count?: (number | null);
};

export type ValidatorResourceSamplesResponse = {
    samples: Array<ValidatorResourceSampleEntry>;
    count: number;
};

export type ValidatorResumeRequest = {
    /**
     * Optional reason for releasing the cord
     */
    reason?: (string | null);
};

/**
 * Aggregated validator scoring analysis.
 */
export type ValidatorScoresResponse = {
    /**
     * Per-validator score summaries
     */
    validators: Array<ValidatorScoreSummary>;
    /**
     * Global average score across all validators
     */
    global_avg_score: number;
    /**
     * Global standard deviation of scores
     */
    global_stddev: number;
    /**
     * Global average execution time in seconds
     */
    global_avg_execution_seconds?: number;
};

export type ValidatorScoreSummary = {
    /**
     * Validator's SS58 hotkey
     */
    validator_hotkey: string;
    /**
     * Total number of completed runs
     */
    total_runs: number;
    /**
     * Average score across runs
     */
    avg_score: number;
    /**
     * Median score across runs
     */
    median_score: number;
    /**
     * Standard deviation of scores
     */
    stddev_score: number;
    /**
     * Minimum score
     */
    min_score: number;
    /**
     * Maximum score
     */
    max_score: number;
    /**
     * Deviation of this validator's average from the global average
     */
    deviation_from_global: number;
    /**
     * Whether this validator is a scoring outlier
     */
    is_outlier: boolean;
    /**
     * Average execution time in seconds
     */
    avg_execution_seconds?: number;
    /**
     * Median execution time in seconds
     */
    median_execution_seconds?: number;
    /**
     * Minimum execution time in seconds
     */
    min_execution_seconds?: number;
    /**
     * Maximum execution time in seconds
     */
    max_execution_seconds?: number;
    /**
     * Percentage deviation of execution time from global average
     */
    execution_deviation_pct?: number;
    /**
     * Whether this validator is a slow execution outlier
     */
    is_slow_outlier?: boolean;
    /**
     * Number of successful runs
     */
    success_count?: number;
    /**
     * Number of failed runs
     */
    failed_count?: number;
    /**
     * Number of timed-out runs
     */
    timed_out_count?: number;
    /**
     * Success rate as a fraction
     */
    success_rate?: number;
    /**
     * Reason for the most recent failure
     */
    last_failure_reason?: (string | null);
    /**
     * When the most recent failure occurred
     */
    last_failure_at?: (string | null);
};

export type ValidatorStatus = 'evaluating' | 'available';

/**
 * Per-validator variance statistics for a single race.
 *
 * Computed over agent-race pairs where at least two validators produced
 * included SUCCESS runs. `mean_delta_vs_peers` is the mean of
 * (this validator's score on an agent − mean score across the other
 * validators on that same agent) across all such pairs the validator
 * participated in. A systematically hot or cold validator would show a
 * persistently non-zero delta; noise sits within ±0.003.
 */
export type ValidatorVarianceEntry = {
    /**
     * Validator hotkey (ss58)
     */
    validator_hotkey: string;
    /**
     * On-chain identity name, if available
     */
    validator_name?: (string | null);
    /**
     * Number of agent-race pairs this validator participated in
     */
    pairs_evaluated: number;
    /**
     * Mean of (this validator score − peers mean) across pairs
     */
    mean_delta_vs_peers: number;
    /**
     * Standard deviation of the per-pair delta
     */
    std_dev: number;
    /**
     * Mean score this validator produced across the pairs
     */
    mean_score: number;
};

export type WaitlistSignupRequest = {
    /**
     * Email address to add to the waitlist
     */
    email: string;
    /**
     * Signup source
     */
    source?: string;
};

export type WaitlistSignupResponse = {
    /**
     * Whether signup was recorded
     */
    success: boolean;
};

/**
 * Per-epoch base standings for the weight setter (ORO-1704).
 *
 * ``epoch_standings`` is the epoch-pinned base vector input: the validator
 * builds its base vector from it so all honest validators in the epoch stay
 * byte-identical. **None** means it couldn't be resolved this tick (e.g. chain
 * unreadable); the validator retains its last-good weights.
 *
 * ``active`` / ``eligible`` / ``weight_overlay`` are **deprecated** — the
 * ORO-1649 watermark decoy-overlay was removed. They are retained (empty /
 * False) only for response-shape compatibility with older clients and will be
 * dropped in a coordinated SDK + validator release.
 */
export type WeightSaltResponse = {
    /**
     * Deprecated (watermark removed)
     */
    active?: boolean;
    /**
     * Deprecated (watermark removed)
     */
    eligible?: boolean;
    /**
     * Epoch index the standings are keyed to (stable within it)
     */
    epoch_index: number;
    /**
     * Deprecated (watermark removed); always empty
     */
    weight_overlay?: {
        [key: string]: (number);
    };
    /**
     * Epoch-pinned base standings (ORO-1704); None if unresolved this tick
     */
    epoch_standings?: (EpochStandings | null);
};

export type WorkItemStatus = {
    /**
     * Number of successful runs included so far
     */
    included_success_count: number;
    /**
     * Number of successful runs required to close the work item
     */
    required_successes: number;
    /**
     * Whether the work item is closed
     */
    is_closed: boolean;
};

export type HealthCheckResponse = ({
    [key: string]: unknown;
});

export type HealthCheckError = unknown;

export type DeepHealthCheckResponse = (unknown);

export type DeepHealthCheckError = unknown;

export type ListSuitesResponse = (Array<SuitePublic>);

export type ListSuitesError = unknown;

export type GetCurrentSuiteResponse = (SuitePublic);

export type GetCurrentSuiteError = (SuiteNotFoundError);

export type GetSuiteProblemsData = {
    path: {
        /**
         * Suite ID/version
         */
        suite_id: number;
    };
    query?: {
        /**
         * Include precomputed reward_title_embeddings in metadata. Off by default to keep responses small (~50 KB vs ~1.5 MB).
         */
        include_embeddings?: boolean;
    };
};

export type GetSuiteProblemsResponse = (SuiteWithProblemsResponse);

export type GetSuiteProblemsError = (SuiteNotFoundError | HTTPValidationError);

export type GetLeaderboardData = {
    query?: {
        /**
         * Maximum entries to return
         */
        limit?: number;
        /**
         * Offset for pagination
         */
        offset?: number;
        /**
         * Filter by agent name (case-insensitive substring) or miner hotkey (case-insensitive prefix). Empty/whitespace is ignored.
         */
        q?: (string | null);
        /**
         * Which score to rank by
         */
        score_type?: string;
        /**
         * Suite ID (defaults to current)
         */
        suite_id?: (number | null);
    };
};

export type GetLeaderboardResponse = (LeaderboardResponse);

export type GetLeaderboardError = (HTTPValidationError);

export type GetTopAgentResponse = (TopAgentResponse);

export type GetTopAgentError = unknown;

export type GetTopMinerPayoutResponse = (TopMinerPayoutResponse);

export type GetTopMinerPayoutError = unknown;

export type GetTopHistoryData = {
    query?: {
        /**
         * Suite ID (omit for all suites)
         */
        suite_id?: (number | null);
    };
};

export type GetTopHistoryResponse = (TopHistoryResponse);

export type GetTopHistoryError = (HTTPValidationError);

export type GetAgentVersionStatusData = {
    path: {
        /**
         * Agent version ID
         */
        agent_version_id: string;
    };
};

export type GetAgentVersionStatusResponse = (AgentVersionStatus);

export type GetAgentVersionStatusError = (AgentVersionNotFoundError | HTTPValidationError);

export type GetAgentVersionRunsData = {
    path: {
        /**
         * Agent version ID
         */
        agent_version_id: string;
    };
};

export type GetAgentVersionRunsResponse = (Array<EvaluationRunPublic>);

export type GetAgentVersionRunsError = (AgentVersionNotFoundError | HTTPValidationError);

export type GetAgentVersionProblemsData = {
    path: {
        /**
         * Agent version ID
         */
        agent_version_id: string;
    };
    query?: {
        /**
         * Filter by evaluation phase (QUALIFYING or RACE)
         */
        phase?: (string | null);
        /**
         * Filter to a specific race (implies phase=RACE)
         */
        race_id?: (string | null);
    };
};

export type GetAgentVersionProblemsResponse = (AgentVersionProblemsResponse);

export type GetAgentVersionProblemsError = (AgentVersionNotFoundError | HTTPValidationError);

export type GetAgentVersionData = {
    path: {
        /**
         * Agent version ID
         */
        agent_version_id: string;
    };
};

export type GetAgentVersionResponse = (AgentVersionPublic);

export type GetAgentVersionError = ((AgentVersionNotFoundError | SuiteNotFoundError | ArtifactNotReleasedError) | HTTPValidationError);

export type GetArtifactDownloadUrlData = {
    body: ArtifactDownloadRequest;
};

export type GetArtifactDownloadUrlResponse = (ArtifactDownloadResponse);

export type GetArtifactDownloadUrlError = ((MissingParameterError | InvalidArtifactTypeError) | RaceInFlightError | (AgentVersionNotFoundError | SuiteNotFoundError | ArtifactNotReleasedError | ArtifactNotFoundError | EvalRunNotFoundError) | HTTPValidationError);

export type GetEvaluationRunData = {
    path: {
        /**
         * Evaluation run ID
         */
        eval_run_id: string;
    };
};

export type GetEvaluationRunResponse = (EvaluationRunDetail);

export type GetEvaluationRunError = (EvalRunNotFoundError | HTTPValidationError);

export type GetValidatorsResponse = (Array<ValidatorPublic>);

export type GetValidatorsError = unknown;

export type GetRunningEvaluationsResponse = (Array<RunningEvaluation>);

export type GetRunningEvaluationsError = unknown;

export type GetPendingEvaluationsData = {
    query?: {
        /**
         * Maximum items to return
         */
        limit?: number;
        /**
         * Number of items to skip
         */
        offset?: number;
        /**
         * Filter by problem suite ID
         */
        suite_id?: (number | null);
    };
};

export type GetPendingEvaluationsResponse = (PendingEvaluationsResponse);

export type GetPendingEvaluationsError = (HTTPValidationError);

export type GetCurrentRaceResponse = (RaceCurrentResponse);

export type GetCurrentRaceError = unknown;

export type GetRaceHistoryData = {
    query?: {
        /**
         * Page size
         */
        limit?: number;
        /**
         * Page offset
         */
        offset?: number;
        /**
         * Filter by suite ID
         */
        suite_id?: (number | null);
    };
};

export type GetRaceHistoryResponse = (RaceHistoryResponse);

export type GetRaceHistoryError = (HTTPValidationError);

export type GetRaceDetailData = {
    path: {
        /**
         * Race ID
         */
        race_id: string;
    };
};

export type GetRaceDetailResponse = (RaceDetailResponse);

export type GetRaceDetailError = (RaceNotFoundError | HTTPValidationError);

export type GetRaceValidatorVarianceData = {
    path: {
        /**
         * Race ID
         */
        race_id: string;
    };
};

export type GetRaceValidatorVarianceResponse = (RaceValidatorVarianceResponse);

export type GetRaceValidatorVarianceError = (RaceNotFoundError | HTTPValidationError);

export type JoinWaitlistData = {
    body: WaitlistSignupRequest;
};

export type JoinWaitlistResponse = (WaitlistSignupResponse);

export type JoinWaitlistError = (HTTPValidationError);

export type GetInferenceModelsData = {
    query?: {
        provider?: string;
        ranked?: boolean;
    };
};

export type GetInferenceModelsResponse = ((InferenceModelsResponse | RankedInferenceModelsResponse));

export type GetInferenceModelsError = (HTTPValidationError);

export type RequestChallengeData = {
    body: ChallengeRequest;
};

export type RequestChallengeResponse = (ChallengeResponse);

export type RequestChallengeError = (HTTPValidationError);

export type CreateSessionEndpointData = {
    body: SessionRequest;
};

export type CreateSessionEndpointResponse = (SessionResponse);

export type CreateSessionEndpointError = (HTTPValidationError);

export type LogoutData = {
    headers?: {
        authorization?: (string | null);
    };
};

export type LogoutResponse2 = (LogoutResponse);

export type LogoutError = (HTTPValidationError);

export type SubmitAgentData = {
    body: Body_submit_agent;
};

export type SubmitAgentResponse2 = (SubmitAgentResponse);

export type SubmitAgentError = ((InvalidAgentNameError | InvalidFileError) | FileTooLargeError | CodeAnalysisError | (CooldownActiveError | RateLimitExceededError) | (NoActiveSuiteError | SimilarityCheckUnavailableError));

export type StoreInferenceCredentialData = {
    body: StoreInferenceCredentialRequest;
    path: {
        provider: string;
    };
};

export type StoreInferenceCredentialResponse = ({
    [key: string]: (boolean);
});

export type StoreInferenceCredentialError = (HTTPValidationError);

export type GetInferenceAuthStatusOneData = {
    path: {
        provider: string;
    };
};

export type GetInferenceAuthStatusOneResponse = (InferenceAuthStatusResponse);

export type GetInferenceAuthStatusOneError = (HTTPValidationError);

export type DeleteInferenceCredentialData = {
    path: {
        provider: string;
    };
};

export type DeleteInferenceCredentialResponse = ({
    [key: string]: (string | null);
});

export type DeleteInferenceCredentialError = (HTTPValidationError);

export type ListInferenceAuthResponse = (InferenceAuthListResponse);

export type ListInferenceAuthError = unknown;

export type SetDefaultInferenceProviderData = {
    body: SetDefaultProviderRequest;
};

export type SetDefaultInferenceProviderResponse = ({
    [key: string]: (string | null);
});

export type SetDefaultInferenceProviderError = (HTTPValidationError);

export type StoreChutesTokenData = {
    body: StoreChutesTokenRequest;
};

export type StoreChutesTokenResponse = ({
    [key: string]: (boolean);
});

export type StoreChutesTokenError = (HTTPValidationError);

export type GetChutesAuthStatusResponse = (ChutesAuthStatusResponse);

export type GetChutesAuthStatusError = unknown;

export type ExchangeChutesCodeData = {
    body: ExchangeChutesCodeRequest;
};

export type ExchangeChutesCodeResponse2 = (ExchangeChutesCodeResponse);

export type ExchangeChutesCodeError = (HTTPValidationError);

export type ListMinerAgentsResponse = (MinerAgentsResponse);

export type ListMinerAgentsError = unknown;

export type ListAgentVersionsData = {
    path: {
        /**
         * Agent ID
         */
        agent_id: string;
    };
};

export type ListAgentVersionsResponse = (Array<AgentVersionHistoryEntry>);

export type ListAgentVersionsError = (AgentNotFoundError | HTTPValidationError);

export type GetOwnedAgentVersionStatusData = {
    path: {
        /**
         * Agent version ID
         */
        agent_version_id: string;
    };
};

export type GetOwnedAgentVersionStatusResponse = (AgentVersionStatus);

export type GetOwnedAgentVersionStatusError = (AgentVersionNotFoundError | HTTPValidationError);

export type SetRaceSelectionData = {
    body: MinerRaceSelectionRequest;
};

export type SetRaceSelectionResponse = (void);

export type SetRaceSelectionError = (unknown | NotVersionOwnerError | RaceLockedError | HTTPValidationError);

export type ClearRaceSelectionResponse = (void);

export type ClearRaceSelectionError = (NoSelectionError | RaceLockedError);

export type ClaimWorkData = {
    body?: (HeartbeatRequest | null);
};

export type ClaimWorkResponse2 = (ClaimWorkResponse | void);

export type ClaimWorkError = (AtCapacityError | HTTPValidationError);

export type HeartbeatData = {
    body?: (HeartbeatRequest | null);
    path: {
        /**
         * Evaluation run ID
         */
        eval_run_id: string;
    };
};

export type HeartbeatResponse2 = (HeartbeatResponse);

export type HeartbeatError = (EvalRunNotFoundError | (LeaseExpiredError | NotRunOwnerError | RunAlreadyCompleteError) | HTTPValidationError);

export type UpdateProgressData = {
    body: ProgressUpdateRequest;
    path: {
        /**
         * Evaluation run ID
         */
        eval_run_id: string;
    };
};

export type UpdateProgressResponse = (ProgressUpdateResponse);

export type UpdateProgressError = (InvalidProblemIdError | EvalRunNotFoundError | (NotRunOwnerError | RunAlreadyCompleteError) | HTTPValidationError);

export type PresignUploadData = {
    body: PresignUploadRequest;
};

export type PresignUploadResponse2 = (PresignUploadResponse);

export type PresignUploadError = ((FileTooLargeError | ValidationErrorError) | (EvalRunNotFoundError | ProblemNotFoundError) | NotRunOwnerError | HTTPValidationError);

export type CompleteRunData = {
    body: CompleteRunRequest;
    path: {
        /**
         * Evaluation run ID
         */
        eval_run_id: string;
    };
};

export type CompleteRunResponse2 = (CompleteRunResponse);

export type CompleteRunError = ((MissingScoreError | ValidationErrorError) | EvalRunNotFoundError | (NotRunOwnerError | RunAlreadyCompleteError) | HTTPValidationError);

export type GetRunProblemsData = {
    path: {
        /**
         * Evaluation run ID
         */
        eval_run_id: string;
    };
};

export type GetRunProblemsResponse = (RunProblemsResponse);

export type GetRunProblemsError = (EvalRunNotFoundError | HTTPValidationError);

export type GetWeightSaltResponse = (WeightSaltResponse);

export type GetWeightSaltError = unknown;

export type BanMinerData = {
    body: BanRequest;
    path: {
        /**
         * Miner hotkey to ban
         */
        miner_hotkey: string;
    };
};

export type BanMinerResponse = (BanResponse);

export type BanMinerError = (MinerNotFoundError | HTTPValidationError);

export type UnbanMinerData = {
    path: {
        /**
         * Miner hotkey to unban
         */
        miner_hotkey: string;
    };
};

export type UnbanMinerResponse = (BanResponse);

export type UnbanMinerError = (MinerNotFoundError | HTTPValidationError);

export type BanValidatorData = {
    body: BanRequest;
    path: {
        /**
         * Validator hotkey to ban
         */
        validator_hotkey: string;
    };
};

export type BanValidatorResponse = (BanResponse);

export type BanValidatorError = (ValidatorNotFoundError | HTTPValidationError);

export type UnbanValidatorData = {
    path: {
        /**
         * Validator hotkey to unban
         */
        validator_hotkey: string;
    };
};

export type UnbanValidatorResponse = (BanResponse);

export type UnbanValidatorError = (ValidatorNotFoundError | HTTPValidationError);

export type UpdateValidatorData = {
    body: UpdateValidatorRequest;
    path: {
        /**
         * Validator hotkey to update
         */
        validator_hotkey: string;
    };
};

export type UpdateValidatorResponse = (AdminValidatorEntry);

export type UpdateValidatorError = (ValidatorNotFoundError | HTTPValidationError);

export type DiscardAgentVersionData = {
    body: DiscardRequest;
    path: {
        /**
         * Agent version ID
         */
        agent_version_id: string;
    };
};

export type DiscardAgentVersionResponse = (DiscardResponse);

export type DiscardAgentVersionError = (AgentVersionNotFoundError | HTTPValidationError | NoActiveSuiteError);

export type ReinstateAgentVersionData = {
    body: ReinstateRequest;
    path: {
        /**
         * Agent version ID
         */
        agent_version_id: string;
    };
};

export type ReinstateAgentVersionResponse = (DiscardResponse);

export type ReinstateAgentVersionError = (AgentVersionNotFoundError | HTTPValidationError | NoActiveSuiteError);

export type EliminateAgentVersionData = {
    body: EliminateRequest;
    path: {
        /**
         * Agent version ID
         */
        agent_version_id: string;
    };
};

export type EliminateAgentVersionResponse = (EliminateResponse);

export type EliminateAgentVersionError = (AgentVersionNotFoundError | HTTPValidationError | NoActiveSuiteError);

export type ReinstateEliminationData = {
    body: ReinstateEliminationRequest;
    path: {
        /**
         * Agent version ID
         */
        agent_version_id: string;
    };
};

export type ReinstateEliminationResponse2 = (ReinstateEliminationResponse);

export type ReinstateEliminationError = (AgentVersionNotFoundError | HTTPValidationError | NoActiveSuiteError);

export type SetTopAgentData = {
    body: SetTopRequest;
    path: {
        /**
         * Agent version ID to set as top
         */
        agent_version_id: string;
    };
};

export type SetTopAgentResponse = (SetTopResponse);

export type SetTopAgentError = (ScoreBelowThresholdError | AgentVersionNotFoundError | HTTPValidationError | NoActiveSuiteError);

export type InvalidateEvaluationRunData = {
    body: InvalidateRunRequest;
    path: {
        /**
         * Evaluation run ID
         */
        eval_run_id: string;
    };
};

export type InvalidateEvaluationRunResponse = (EvaluationRunStatusPublic);

export type InvalidateEvaluationRunError = (EvalRunNotFoundError | AlreadyInvalidatedError | HTTPValidationError);

export type ReevaluateAgentVersionData = {
    body: ReevaluateRequest;
    path: {
        /**
         * Agent version ID
         */
        agent_version_id: string;
    };
};

export type ReevaluateAgentVersionResponse = (ReevaluateResponse);

export type ReevaluateAgentVersionError = (AgentVersionNotFoundError | HTTPValidationError | NoActiveSuiteError);

export type CancelAgentVersionData = {
    body: CancelRequest;
    path: {
        /**
         * Agent version ID
         */
        agent_version_id: string;
    };
};

export type CancelAgentVersionResponse = (CancelResponse);

export type CancelAgentVersionError = (HTTPValidationError);

export type CreateSuiteData = {
    body: CreateSuiteRequest;
};

export type CreateSuiteResponse2 = (CreateSuiteResponse);

export type CreateSuiteError = (HTTPValidationError);

export type ActivateSuiteData = {
    path: {
        /**
         * Suite version to activate
         */
        suite_id: number;
    };
    query?: {
        /**
         * Number of top agent versions to requeue from the previous suite (0 to skip)
         */
        requeue_top_n?: number;
    };
};

export type ActivateSuiteResponse2 = (ActivateSuiteResponse);

export type ActivateSuiteError = (SuiteNotFoundError | HTTPValidationError);

export type GetAuditEventsData = {
    query?: {
        /**
         * Filter by action type (e.g., BAN_MINER)
         */
        action?: (string | null);
        /**
         * Filter by actor hotkey
         */
        actor_hotkey?: (string | null);
        /**
         * Number of events to return
         */
        limit?: number;
        /**
         * Offset for pagination
         */
        offset?: number;
        /**
         * Filter: at or after (ISO 8601)
         */
        since?: (string | null);
        /**
         * Filter by target ID
         */
        target_id?: (string | null);
        /**
         * Filter by target type
         */
        target_type?: (string | null);
        /**
         * Filter: at or before (ISO 8601)
         */
        until?: (string | null);
    };
};

export type GetAuditEventsResponse = (AuditEventsResponse);

export type GetAuditEventsError = (HTTPValidationError);

export type GetReaperStatsResponse = (ReaperStatsResponse);

export type GetReaperStatsError = unknown;

export type ClearMinerCooldownData = {
    path: {
        /**
         * Miner hotkey
         */
        hotkey: string;
    };
};

export type ClearMinerCooldownResponse = (ClearCooldownResponse);

export type ClearMinerCooldownError = (HTTPValidationError);

export type ListMinersData = {
    query?: {
        /**
         * Filter by ban status
         */
        is_banned?: (boolean | null);
        /**
         * Number of miners to return
         */
        limit?: number;
        /**
         * Offset for pagination
         */
        offset?: number;
        /**
         * Last submitted at or after
         */
        since?: (string | null);
        /**
         * Last submitted at or before
         */
        until?: (string | null);
    };
};

export type ListMinersResponse = (AdminMinersResponse);

export type ListMinersError = (HTTPValidationError);

export type ListValidatorsData = {
    query?: {
        /**
         * Filter by ban status
         */
        is_banned?: (boolean | null);
        /**
         * Page size
         */
        limit?: number;
        /**
         * Offset
         */
        offset?: number;
    };
};

export type ListValidatorsResponse = (AdminValidatorsResponse);

export type ListValidatorsError = (HTTPValidationError);

export type ListAgentVersions1Data = {
    query?: {
        /**
         * Filter by discard status
         */
        is_discarded?: (boolean | null);
        /**
         * Filter by eligibility
         */
        is_eligible?: (boolean | null);
        /**
         * Number of versions to return
         */
        limit?: number;
        /**
         * Filter by miner hotkey
         */
        miner_hotkey?: (string | null);
        /**
         * Offset for pagination
         */
        offset?: number;
        /**
         * Filter: created at or after (ISO 8601)
         */
        since?: (string | null);
        /**
         * Suite ID (defaults to active suite)
         */
        suite_id?: (number | null);
        /**
         * Filter: created at or before (ISO 8601)
         */
        until?: (string | null);
    };
};

export type ListAgentVersions1Response = (AdminAgentVersionsResponse);

export type ListAgentVersions1Error = (HTTPValidationError);

export type ListEvaluationRunsData = {
    query?: {
        /**
         * Filter by agent version ID
         */
        agent_version_id?: (string | null);
        /**
         * Filter to runs for a specific work item
         */
        eval_work_item_id?: (string | null);
        /**
         * Filter by inference provider (e.g. chutes, openrouter). Pass 'none' to filter to runs with no provider recorded.
         */
        inference_provider?: (string | null);
        /**
         * Number of runs to return
         */
        limit?: number;
        /**
         * Offset for pagination
         */
        offset?: number;
        /**
         * Filter by evaluation phase (QUALIFYING or RACE)
         */
        phase?: (EvaluationPhase | null);
        /**
         * Filter by race ID (RACE-phase runs only)
         */
        race_id?: (string | null);
        /**
         * Filter: created at or after (ISO 8601)
         */
        since?: (string | null);
        /**
         * Filter by run status (e.g., RUNNING, SUCCESS)
         */
        status?: (EvaluationRunStatus | null);
        /**
         * Filter: created at or before (ISO 8601)
         */
        until?: (string | null);
        /**
         * Filter by validator hotkey
         */
        validator_hotkey?: (string | null);
    };
};

export type ListEvaluationRunsResponse = (AdminEvaluationRunsResponse);

export type ListEvaluationRunsError = (HTTPValidationError);

export type GetValidatorScoresData = {
    query?: {
        /**
         * Restrict aggregation to runs from this phase
         */
        phase?: (EvaluationPhase | null);
        /**
         * Only runs after this time
         */
        since?: (string | null);
        /**
         * Suite ID (defaults to active suite)
         */
        suite_id?: (number | null);
        /**
         * Only runs before this time
         */
        until?: (string | null);
    };
};

export type GetValidatorScoresResponse = (ValidatorScoresResponse);

export type GetValidatorScoresError = (HTTPValidationError);

export type GetAgentVersionVarianceData = {
    query?: {
        /**
         * Number of agent versions
         */
        limit?: number;
        /**
         * Restrict aggregation to runs from this phase
         */
        phase?: (EvaluationPhase | null);
        /**
         * Only versions after this time
         */
        since?: (string | null);
        /**
         * Suite ID (defaults to active suite)
         */
        suite_id?: (number | null);
        /**
         * Only versions before this time
         */
        until?: (string | null);
        /**
         * Spread threshold for flagging
         */
        variance_threshold?: number;
    };
};

export type GetAgentVersionVarianceResponse = (AgentVersionVarianceResponse);

export type GetAgentVersionVarianceError = (HTTPValidationError);

export type GetAgentVersionCodeData = {
    path: {
        /**
         * Agent version ID
         */
        agent_version_id: string;
    };
};

export type GetAgentVersionCodeResponse = (AdminAgentCodeResponse);

export type GetAgentVersionCodeError = (AgentVersionNotFoundError | HTTPValidationError);

export type GetCurrentRacesResponse = (CurrentRacesResponse);

export type GetCurrentRacesError = unknown;

export type GetRaceDiagnosticsData = {
    path: {
        /**
         * Race ID
         */
        race_id: string;
    };
};

export type GetRaceDiagnosticsResponse = (RaceDiagnosticsResponse);

export type GetRaceDiagnosticsError = (HTTPValidationError);

export type CloseQualifyingResponse2 = (CloseQualifyingResponse);

export type CloseQualifyingError = unknown;

export type GetValidatorResourceSamplesData = {
    query: {
        /**
         * Inclusive upper bound (ISO 8601 UTC)
         */
        end: string;
        limit?: number;
        /**
         * Inclusive lower bound (ISO 8601 UTC)
         */
        start: string;
        validator_hotkey?: (string | null);
    };
};

export type GetValidatorResourceSamplesResponse = (ValidatorResourceSamplesResponse);

export type GetValidatorResourceSamplesError = (HTTPValidationError);

export type GetValidatorFailuresData = {
    path: {
        /**
         * Validator SS58 hotkey
         */
        validator_hotkey: string;
    };
    query?: {
        /**
         * Maximum number of failures to return
         */
        limit?: number;
    };
};

export type GetValidatorFailuresResponse = (ValidatorFailuresResponse);

export type GetValidatorFailuresError = (HTTPValidationError);

export type GetValidatorPauseResponse = (ValidatorPauseStatus);

export type GetValidatorPauseError = unknown;

export type PostValidatorPauseData = {
    body: ValidatorPauseRequest;
};

export type PostValidatorPauseResponse = (ValidatorPauseStatus);

export type PostValidatorPauseError = (HTTPValidationError);

export type PostValidatorResumeData = {
    body: ValidatorResumeRequest;
};

export type PostValidatorResumeResponse = (ValidatorPauseStatus);

export type PostValidatorResumeError = (HTTPValidationError);

export type ApiProblemsData = {
    headers?: {
        'X-Demo-Auth'?: (string | null);
    };
};

export type ApiProblemsResponse = (Array<{
    [key: string]: unknown;
}>);

export type ApiProblemsError = (HTTPValidationError);

export type ApiRunData = {
    headers?: {
        'X-Demo-Auth'?: (string | null);
        'X-OpenRouter-Key'?: (string | null);
    };
    query: {
        /**
         * comma-separated model ids
         */
        models: string;
        problem_id?: (string | null);
        query?: (string | null);
    };
};

export type ApiRunResponse = (unknown);

export type ApiRunError = (HTTPValidationError);