import * as _hey_api_client_fetch from '@hey-api/client-fetch';
import { OptionsLegacyParser } from '@hey-api/client-fetch';

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;
};
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;
};
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);
};
type AdminAgentVersionsResponse = {
    /**
     * Total entries matching filter
     */
    total: number;
    /**
     * Page size
     */
    limit: number;
    /**
     * Page offset
     */
    offset: number;
    /**
     * Agent version entries
     */
    agent_versions: Array<AdminAgentVersionEntry>;
};
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);
};
type AdminEvaluationRunsResponse = {
    /**
     * Total entries matching filter
     */
    total: number;
    /**
     * Page size
     */
    limit: number;
    /**
     * Page offset
     */
    offset: number;
    /**
     * Evaluation run entries
     */
    evaluation_runs: Array<AdminEvaluationRunEntry>;
};
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);
};
type AdminMinersResponse = {
    /**
     * Total entries matching filter
     */
    total: number;
    /**
     * Page size
     */
    limit: number;
    /**
     * Page offset
     */
    offset: number;
    /**
     * Miner entries
     */
    miners: Array<AdminMinerEntry>;
};
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;
};
type AdminValidatorsResponse = {
    /**
     * Total entries matching filter
     */
    total: number;
    /**
     * Page size
     */
    limit: number;
    /**
     * Page offset
     */
    offset: number;
    /**
     * Validator entries
     */
    validators: Array<AdminValidatorEntry>;
};
type AdmissionReason = 'COOLDOWN' | 'INVALID_FILE' | 'NOT_REGISTERED_ONCHAIN' | 'BANNED' | 'NO_ACTIVE_SUITE';
type AdmissionStatus = 'ACCEPTED' | 'REJECTED';
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);
};
type AgentNotFoundError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "AGENT_NOT_FOUND";
};
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);
};
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);
};
type AgentVersionNotFoundError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "AGENT_VERSION_NOT_FOUND";
};
type AgentVersionProblemsResponse = {
    /**
     * Agent version ID
     */
    agent_version_id: string;
    /**
     * Suite ID
     */
    suite_id?: (number | null);
    /**
     * Problem progress list
     */
    problems: Array<ProblemProgressEntry>;
};
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);
};
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.
 */
type AgentVersionState = 'RECEIVED' | 'QUEUED' | 'RUNNING' | 'ELIGIBLE' | 'DISCARDED' | 'CANCELLED';
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);
};
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>;
};
type AgentVersionVarianceResponse = {
    /**
     * Per-version variance entries
     */
    agent_versions: Array<AgentVersionVariance>;
    /**
     * Threshold used to flag high-variance versions
     */
    variance_threshold: number;
};
type AlreadyInvalidatedError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "ALREADY_INVALIDATED";
};
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);
};
type ArtifactDownloadResponse = {
    /**
     * Presigned download URL
     */
    download_url: string;
    /**
     * URL expiration time
     */
    expires_at: string;
};
type ArtifactNotFoundError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "ARTIFACT_NOT_FOUND";
};
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.
 */
type ArtifactReleaseState = 'HIDDEN' | 'RELEASED';
type ArtifactType = 'AGENT_CODE' | 'EVAL_LOGS_BUNDLE' | 'EVAL_PROBLEM_LOGS' | 'REASONING_DETAILS';
type AtCapacityError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "AT_CAPACITY";
};
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;
};
type AuditEventsResponse = {
    /**
     * Total entries matching filter
     */
    total: number;
    /**
     * Page size
     */
    limit: number;
    /**
     * Page offset
     */
    offset: number;
    /**
     * Audit event entries
     */
    events: Array<AuditEventEntry>;
};
type BanRequest = {
    /**
     * Reason for the ban
     */
    reason: string;
};
type BanResponse = {
    /**
     * Hotkey of the banned/unbanned entity
     */
    hotkey: string;
    /**
     * Current ban status after the operation
     */
    is_banned: boolean;
};
type Body_submit_agent = {
    /**
     * Name for this agent (unique per miner)
     */
    agent_name: string;
    /**
     * Python agent file (max 1MB)
     */
    file: (Blob | File);
};
type CancelRequest = {
    /**
     * Reason for cancellation
     */
    reason: string;
};
type CancelResponse = {
    /**
     * Agent version whose runs were cancelled
     */
    agent_version_id: string;
    /**
     * Number of runs cancelled
     */
    cancelled_runs: number;
};
type ChallengeRequest = {
    /**
     * SS58 hotkey address
     */
    hotkey: string;
};
type ChallengeResponse = {
    /**
     * Challenge string to sign
     */
    challenge: string;
    /**
     * Unix timestamp when challenge expires
     */
    expires_at: number;
};
type ChutesAuthStatusResponse = {
    /**
     * Whether the miner has a valid Chutes token stored
     */
    connected: boolean;
    /**
     * When the Chutes token was last updated
     */
    updated_at?: (string | null);
};
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);
};
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);
};
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.
 */
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.
 */
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);
};
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.
 */
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;
};
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)>;
};
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;
};
type CurrentRacesResponse = {
    /**
     * Active races
     */
    races: Array<RaceSummary>;
};
type DiscardRequest = {
    /**
     * Reason for discarding the version
     */
    reason: string;
    /**
     * Specific suite to discard from
     */
    suite_id?: (number | null);
};
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;
};
type EliminateRequest = {
    /**
     * Specific suite to eliminate the version in
     */
    suite_id?: (number | null);
    /**
     * Reason for eliminating the version
     */
    reason: string;
};
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).
 */
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>;
};
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.
 */
type EvaluationPhase = 'QUALIFYING' | 'RACE';
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);
};
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.
 */
type EvaluationRunStatus = 'CLAIMED' | 'RUNNING' | 'SUCCESS' | 'FAILED' | 'TIMED_OUT' | 'STALE' | 'CANCELLED';
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.
 */
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``.
 */
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);
};
type FileTooLargeError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "FILE_TOO_LARGE";
};
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);
};
type HeartbeatResponse = {
    /**
     * New lease expiry after heartbeat
     */
    lease_expires_at: string;
};
type HTTPValidationError = {
    detail?: Array<ValidationError>;
};
/**
 * Response body for ``GET /v1/miner/inference-auth``.
 */
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}``.
 */
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.
 */
type InferenceModelsResponse = {
    /**
     * Allowed model identifiers
     */
    models: Array<(string)>;
};
/**
 * Per-run scoped inference credential issued at claim_work.
 */
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.
 */
type provider = 'chutes' | 'openrouter';
type InvalidAgentNameError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "INVALID_AGENT_NAME";
};
type InvalidArtifactTypeError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "INVALID_ARTIFACT_TYPE";
};
type InvalidateRunRequest = {
    /**
     * Reason for invalidating the run
     */
    reason: string;
};
type InvalidFileError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "INVALID_FILE";
};
type InvalidProblemIdError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "INVALID_PROBLEM_ID";
};
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);
};
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);
};
type LeaseExpiredError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "LEASE_EXPIRED";
};
type LogoutResponse = {
    /**
     * Whether logout was successful
     */
    success: boolean;
};
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);
};
type MinerNotFoundError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "MINER_NOT_FOUND";
};
type MinerRaceSelectionRequest = {
    /**
     * Agent version to pin as the race candidate
     */
    agent_version_id: string;
};
type MissingParameterError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "MISSING_PARAMETER";
};
type MissingScoreError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "MISSING_SCORE";
};
type NoActiveSuiteError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "NO_ACTIVE_SUITE";
};
type NoSelectionError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "NO_SELECTION";
};
type NotRunOwnerError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "NOT_RUN_OWNER";
};
type NotVersionOwnerError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "NOT_VERSION_OWNER";
};
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);
};
type PendingEvaluationsResponse = {
    /**
     * Aggregate queue statistics
     */
    summary: PendingEvaluationSummary;
    /**
     * Individual pending work items
     */
    items: Array<PendingEvaluation>;
};
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).
 */
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;
};
type PooledWindowRace = {
    race_id: string;
    race_number: number;
    raw_score: (number | null);
    rank: (number | null);
    anchor: number;
    delta: number;
    is_seed: boolean;
};
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;
};
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;
};
type ProblemNotFoundError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "PROBLEM_NOT_FOUND";
};
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>;
};
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);
};
type ProblemPublic = {
    /**
     * Unique identifier for the problem
     */
    problem_id: string;
    /**
     * Parent suite ID
     */
    suite_id: number;
    /**
     * Full problem metadata
     */
    metadata?: {
        [key: string]: unknown;
    };
};
type ProblemStatus = 'PENDING' | 'RUNNING' | 'SUCCESS' | 'FAILED' | 'SKIPPED' | 'TIMED_OUT';
type ProgressUpdateRequest = {
    /**
     * Per-problem progress updates
     */
    problems: Array<ProblemProgressUpdate>;
};
type ProgressUpdateResponse = {
    /**
     * Whether the update was accepted
     */
    accepted?: boolean;
};
type RaceCurrentResponse = {
    /**
     * Current race, if any
     */
    race?: (RacePublic | null);
    /**
     * Race qualifiers
     */
    qualifiers?: Array<RaceQualifierPublic>;
};
type RaceDetailResponse = {
    /**
     * Race details
     */
    race: RacePublic;
    /**
     * Race qualifiers
     */
    qualifiers?: Array<RaceQualifierPublic>;
};
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>;
};
type RaceHistoryResponse = {
    /**
     * Total entries matching filter
     */
    total: number;
    /**
     * Page size
     */
    limit: number;
    /**
     * Page offset
     */
    offset: number;
    /**
     * Historical races
     */
    races: Array<RacePublic>;
};
type RaceInFlightError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "RACE_IN_FLIGHT";
};
type RaceLockedError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "RACE_LOCKED";
};
type RaceNotFoundError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "RACE_NOT_FOUND";
};
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);
};
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);
};
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);
};
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).
 */
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>;
};
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.
 */
type RankedInferenceModel = {
    id: string;
    rank_metric?: {
        [key: string]: unknown;
    };
    healthy?: boolean;
};
/**
 * Models in ranked order — earlier entries are preferred.
 */
type RankedInferenceModelsResponse = {
    models: Array<RankedInferenceModel>;
    /**
     * Sort applied; null on cold start (static fallback order).
     */
    ranked_by?: (string | null);
    as_of?: (string | null);
};
type RateLimitExceededError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "RATE_LIMIT_EXCEEDED";
};
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;
};
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);
};
type ReevaluateResponse = {
    /**
     * Agent version queued for re-evaluation
     */
    agent_version_id: string;
};
type ReinstateEliminationRequest = {
    /**
     * Specific suite to reinstate elimination for
     */
    suite_id?: (number | null);
    /**
     * Optional reason captured in the audit trail
     */
    reason?: (string | null);
};
type ReinstateEliminationResponse = {
    /**
     * Agent version whose elimination was cleared
     */
    agent_version_id: string;
    /**
     * Suite the elimination was cleared for
     */
    suite_id: number;
};
type ReinstateRequest = {
    /**
     * Specific suite to reinstate for
     */
    suite_id?: (number | null);
    /**
     * Optional reason captured in the audit trail
     */
    reason?: (string | null);
};
type RunAlreadyCompleteError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "RUN_ALREADY_COMPLETE";
};
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);
};
type RunProblemsResponse = {
    /**
     * Problems to evaluate
     */
    problems: Array<ProblemPublic>;
};
/**
 * 400 - Candidate score does not exceed the challenge threshold.
 */
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;
};
type SessionRequest = {
    /**
     * SS58 hotkey address
     */
    hotkey: string;
    /**
     * Challenge that was signed
     */
    challenge: string;
    /**
     * Hex-encoded signature
     */
    signature: string;
};
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``.
 */
type SetDefaultProviderRequest = {
    provider: string;
};
type SetTopRequest = {
    /**
     * Specific suite to set top agent for
     */
    suite_id?: (number | null);
    /**
     * Force set even if version has lower score
     */
    force?: boolean;
};
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;
};
type SimilarityCheckUnavailableError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "SIMILARITY_CHECK_UNAVAILABLE";
};
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;
};
type StoreChutesTokenRequest = {
    /**
     * Chutes OAuth refresh token to store
     */
    refresh_token: string;
};
/**
 * Request body for ``POST /v1/miner/inference-auth/{provider}``.
 */
type StoreInferenceCredentialRequest = {
    /**
     * Provider-specific credential (refresh token, API key, etc.)
     */
    credential: string;
};
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;
};
type SuiteNotFoundError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "SUITE_NOT_FOUND";
};
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;
};
type SuiteWithProblemsResponse = {
    /**
     * Suite information
     */
    suite: SuitePublic;
    /**
     * Problems in this suite
     */
    problems: Array<ProblemPublic>;
};
type TerminalStatus = 'SUCCESS' | 'FAILED' | 'TIMED_OUT';
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);
};
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;
};
type TopHistoryResponse = {
    /**
     * Suite ID
     */
    suite_id: number;
    /**
     * Top agent history entries
     */
    entries: Array<TopHistoryEntry>;
};
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;
};
type UpdateValidatorRequest = {
    /**
     * Maximum concurrent evaluation runs (must be >= 1)
     */
    max_concurrent_runs: number;
};
type ValidationError = {
    loc: Array<(string | number)>;
    msg: string;
    type: string;
    input?: unknown;
    ctx?: {
        [key: string]: unknown;
    };
};
type ValidationErrorError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "VALIDATION_ERROR";
};
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.
 */
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.
 */
type ValidatorFailuresResponse = {
    /**
     * Validator whose failures these are
     */
    validator_hotkey: string;
    /**
     * Recent failure entries
     */
    failures: Array<ValidatorFailureEntry>;
    /**
     * Number of entries returned
     */
    total: number;
};
type ValidatorNotFoundError = {
    /**
     * Error message describing what went wrong
     */
    detail: string;
    /**
     * Error code for programmatic handling
     */
    error_code?: "VALIDATOR_NOT_FOUND";
};
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);
};
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);
};
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);
};
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);
};
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);
};
type ValidatorResourceSamplesResponse = {
    samples: Array<ValidatorResourceSampleEntry>;
    count: number;
};
type ValidatorResumeRequest = {
    /**
     * Optional reason for releasing the cord
     */
    reason?: (string | null);
};
/**
 * Aggregated validator scoring analysis.
 */
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;
};
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);
};
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.
 */
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;
};
type WaitlistSignupRequest = {
    /**
     * Email address to add to the waitlist
     */
    email: string;
    /**
     * Signup source
     */
    source?: string;
};
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.
 */
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);
};
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;
};
type HealthCheckResponse = ({
    [key: string]: unknown;
});
type HealthCheckError = unknown;
type DeepHealthCheckResponse = (unknown);
type DeepHealthCheckError = unknown;
type ListSuitesResponse = (Array<SuitePublic>);
type ListSuitesError = unknown;
type GetCurrentSuiteResponse = (SuitePublic);
type GetCurrentSuiteError = (SuiteNotFoundError);
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;
    };
};
type GetSuiteProblemsResponse = (SuiteWithProblemsResponse);
type GetSuiteProblemsError = (SuiteNotFoundError | HTTPValidationError);
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);
    };
};
type GetLeaderboardResponse = (LeaderboardResponse);
type GetLeaderboardError = (HTTPValidationError);
type GetTopAgentResponse = (TopAgentResponse);
type GetTopAgentError = unknown;
type GetTopMinerPayoutResponse = (TopMinerPayoutResponse);
type GetTopMinerPayoutError = unknown;
type GetTopHistoryData = {
    query?: {
        /**
         * Suite ID (omit for all suites)
         */
        suite_id?: (number | null);
    };
};
type GetTopHistoryResponse = (TopHistoryResponse);
type GetTopHistoryError = (HTTPValidationError);
type GetAgentVersionStatusData = {
    path: {
        /**
         * Agent version ID
         */
        agent_version_id: string;
    };
};
type GetAgentVersionStatusResponse = (AgentVersionStatus);
type GetAgentVersionStatusError = (AgentVersionNotFoundError | HTTPValidationError);
type GetAgentVersionRunsData = {
    path: {
        /**
         * Agent version ID
         */
        agent_version_id: string;
    };
};
type GetAgentVersionRunsResponse = (Array<EvaluationRunPublic>);
type GetAgentVersionRunsError = (AgentVersionNotFoundError | HTTPValidationError);
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);
    };
};
type GetAgentVersionProblemsResponse = (AgentVersionProblemsResponse);
type GetAgentVersionProblemsError = (AgentVersionNotFoundError | HTTPValidationError);
type GetAgentVersionData = {
    path: {
        /**
         * Agent version ID
         */
        agent_version_id: string;
    };
};
type GetAgentVersionResponse = (AgentVersionPublic);
type GetAgentVersionError = ((AgentVersionNotFoundError | SuiteNotFoundError | ArtifactNotReleasedError) | HTTPValidationError);
type GetArtifactDownloadUrlData = {
    body: ArtifactDownloadRequest;
};
type GetArtifactDownloadUrlResponse = (ArtifactDownloadResponse);
type GetArtifactDownloadUrlError = ((MissingParameterError | InvalidArtifactTypeError) | RaceInFlightError | (AgentVersionNotFoundError | SuiteNotFoundError | ArtifactNotReleasedError | ArtifactNotFoundError | EvalRunNotFoundError) | HTTPValidationError);
type GetEvaluationRunData = {
    path: {
        /**
         * Evaluation run ID
         */
        eval_run_id: string;
    };
};
type GetEvaluationRunResponse = (EvaluationRunDetail);
type GetEvaluationRunError = (EvalRunNotFoundError | HTTPValidationError);
type GetValidatorsResponse = (Array<ValidatorPublic>);
type GetValidatorsError = unknown;
type GetRunningEvaluationsResponse = (Array<RunningEvaluation>);
type GetRunningEvaluationsError = unknown;
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);
    };
};
type GetPendingEvaluationsResponse = (PendingEvaluationsResponse);
type GetPendingEvaluationsError = (HTTPValidationError);
type GetCurrentRaceResponse = (RaceCurrentResponse);
type GetCurrentRaceError = unknown;
type GetRaceHistoryData = {
    query?: {
        /**
         * Page size
         */
        limit?: number;
        /**
         * Page offset
         */
        offset?: number;
        /**
         * Filter by suite ID
         */
        suite_id?: (number | null);
    };
};
type GetRaceHistoryResponse = (RaceHistoryResponse);
type GetRaceHistoryError = (HTTPValidationError);
type GetRaceDetailData = {
    path: {
        /**
         * Race ID
         */
        race_id: string;
    };
};
type GetRaceDetailResponse = (RaceDetailResponse);
type GetRaceDetailError = (RaceNotFoundError | HTTPValidationError);
type GetRaceValidatorVarianceData = {
    path: {
        /**
         * Race ID
         */
        race_id: string;
    };
};
type GetRaceValidatorVarianceResponse = (RaceValidatorVarianceResponse);
type GetRaceValidatorVarianceError = (RaceNotFoundError | HTTPValidationError);
type JoinWaitlistData = {
    body: WaitlistSignupRequest;
};
type JoinWaitlistResponse = (WaitlistSignupResponse);
type JoinWaitlistError = (HTTPValidationError);
type GetInferenceModelsData = {
    query?: {
        provider?: string;
        ranked?: boolean;
    };
};
type GetInferenceModelsResponse = ((InferenceModelsResponse | RankedInferenceModelsResponse));
type GetInferenceModelsError = (HTTPValidationError);
type RequestChallengeData = {
    body: ChallengeRequest;
};
type RequestChallengeResponse = (ChallengeResponse);
type RequestChallengeError = (HTTPValidationError);
type CreateSessionEndpointData = {
    body: SessionRequest;
};
type CreateSessionEndpointResponse = (SessionResponse);
type CreateSessionEndpointError = (HTTPValidationError);
type LogoutData = {
    headers?: {
        authorization?: (string | null);
    };
};
type LogoutResponse2 = (LogoutResponse);
type LogoutError = (HTTPValidationError);
type SubmitAgentData = {
    body: Body_submit_agent;
};
type SubmitAgentResponse2 = (SubmitAgentResponse);
type SubmitAgentError = ((InvalidAgentNameError | InvalidFileError) | FileTooLargeError | CodeAnalysisError | (CooldownActiveError | RateLimitExceededError) | (NoActiveSuiteError | SimilarityCheckUnavailableError));
type StoreInferenceCredentialData = {
    body: StoreInferenceCredentialRequest;
    path: {
        provider: string;
    };
};
type StoreInferenceCredentialResponse = ({
    [key: string]: (boolean);
});
type StoreInferenceCredentialError = (HTTPValidationError);
type GetInferenceAuthStatusOneData = {
    path: {
        provider: string;
    };
};
type GetInferenceAuthStatusOneResponse = (InferenceAuthStatusResponse);
type GetInferenceAuthStatusOneError = (HTTPValidationError);
type DeleteInferenceCredentialData = {
    path: {
        provider: string;
    };
};
type DeleteInferenceCredentialResponse = ({
    [key: string]: (string | null);
});
type DeleteInferenceCredentialError = (HTTPValidationError);
type ListInferenceAuthResponse = (InferenceAuthListResponse);
type ListInferenceAuthError = unknown;
type SetDefaultInferenceProviderData = {
    body: SetDefaultProviderRequest;
};
type SetDefaultInferenceProviderResponse = ({
    [key: string]: (string | null);
});
type SetDefaultInferenceProviderError = (HTTPValidationError);
type StoreChutesTokenData = {
    body: StoreChutesTokenRequest;
};
type StoreChutesTokenResponse = ({
    [key: string]: (boolean);
});
type StoreChutesTokenError = (HTTPValidationError);
type GetChutesAuthStatusResponse = (ChutesAuthStatusResponse);
type GetChutesAuthStatusError = unknown;
type ExchangeChutesCodeData = {
    body: ExchangeChutesCodeRequest;
};
type ExchangeChutesCodeResponse2 = (ExchangeChutesCodeResponse);
type ExchangeChutesCodeError = (HTTPValidationError);
type ListMinerAgentsResponse = (MinerAgentsResponse);
type ListMinerAgentsError = unknown;
type ListAgentVersionsData = {
    path: {
        /**
         * Agent ID
         */
        agent_id: string;
    };
};
type ListAgentVersionsResponse = (Array<AgentVersionHistoryEntry>);
type ListAgentVersionsError = (AgentNotFoundError | HTTPValidationError);
type GetOwnedAgentVersionStatusData = {
    path: {
        /**
         * Agent version ID
         */
        agent_version_id: string;
    };
};
type GetOwnedAgentVersionStatusResponse = (AgentVersionStatus);
type GetOwnedAgentVersionStatusError = (AgentVersionNotFoundError | HTTPValidationError);
type SetRaceSelectionData = {
    body: MinerRaceSelectionRequest;
};
type SetRaceSelectionResponse = (void);
type SetRaceSelectionError = (unknown | NotVersionOwnerError | RaceLockedError | HTTPValidationError);
type ClearRaceSelectionResponse = (void);
type ClearRaceSelectionError = (NoSelectionError | RaceLockedError);
type ClaimWorkData = {
    body?: (HeartbeatRequest | null);
};
type ClaimWorkResponse2 = (ClaimWorkResponse | void);
type ClaimWorkError = (AtCapacityError | HTTPValidationError);
type HeartbeatData = {
    body?: (HeartbeatRequest | null);
    path: {
        /**
         * Evaluation run ID
         */
        eval_run_id: string;
    };
};
type HeartbeatResponse2 = (HeartbeatResponse);
type HeartbeatError = (EvalRunNotFoundError | (LeaseExpiredError | NotRunOwnerError | RunAlreadyCompleteError) | HTTPValidationError);
type UpdateProgressData = {
    body: ProgressUpdateRequest;
    path: {
        /**
         * Evaluation run ID
         */
        eval_run_id: string;
    };
};
type UpdateProgressResponse = (ProgressUpdateResponse);
type UpdateProgressError = (InvalidProblemIdError | EvalRunNotFoundError | (NotRunOwnerError | RunAlreadyCompleteError) | HTTPValidationError);
type PresignUploadData = {
    body: PresignUploadRequest;
};
type PresignUploadResponse2 = (PresignUploadResponse);
type PresignUploadError = ((FileTooLargeError | ValidationErrorError) | (EvalRunNotFoundError | ProblemNotFoundError) | NotRunOwnerError | HTTPValidationError);
type CompleteRunData = {
    body: CompleteRunRequest;
    path: {
        /**
         * Evaluation run ID
         */
        eval_run_id: string;
    };
};
type CompleteRunResponse2 = (CompleteRunResponse);
type CompleteRunError = ((MissingScoreError | ValidationErrorError) | EvalRunNotFoundError | (NotRunOwnerError | RunAlreadyCompleteError) | HTTPValidationError);
type GetRunProblemsData = {
    path: {
        /**
         * Evaluation run ID
         */
        eval_run_id: string;
    };
};
type GetRunProblemsResponse = (RunProblemsResponse);
type GetRunProblemsError = (EvalRunNotFoundError | HTTPValidationError);
type GetWeightSaltResponse = (WeightSaltResponse);
type GetWeightSaltError = unknown;
type BanMinerData = {
    body: BanRequest;
    path: {
        /**
         * Miner hotkey to ban
         */
        miner_hotkey: string;
    };
};
type BanMinerResponse = (BanResponse);
type BanMinerError = (MinerNotFoundError | HTTPValidationError);
type UnbanMinerData = {
    path: {
        /**
         * Miner hotkey to unban
         */
        miner_hotkey: string;
    };
};
type UnbanMinerResponse = (BanResponse);
type UnbanMinerError = (MinerNotFoundError | HTTPValidationError);
type BanValidatorData = {
    body: BanRequest;
    path: {
        /**
         * Validator hotkey to ban
         */
        validator_hotkey: string;
    };
};
type BanValidatorResponse = (BanResponse);
type BanValidatorError = (ValidatorNotFoundError | HTTPValidationError);
type UnbanValidatorData = {
    path: {
        /**
         * Validator hotkey to unban
         */
        validator_hotkey: string;
    };
};
type UnbanValidatorResponse = (BanResponse);
type UnbanValidatorError = (ValidatorNotFoundError | HTTPValidationError);
type UpdateValidatorData = {
    body: UpdateValidatorRequest;
    path: {
        /**
         * Validator hotkey to update
         */
        validator_hotkey: string;
    };
};
type UpdateValidatorResponse = (AdminValidatorEntry);
type UpdateValidatorError = (ValidatorNotFoundError | HTTPValidationError);
type DiscardAgentVersionData = {
    body: DiscardRequest;
    path: {
        /**
         * Agent version ID
         */
        agent_version_id: string;
    };
};
type DiscardAgentVersionResponse = (DiscardResponse);
type DiscardAgentVersionError = (AgentVersionNotFoundError | HTTPValidationError | NoActiveSuiteError);
type ReinstateAgentVersionData = {
    body: ReinstateRequest;
    path: {
        /**
         * Agent version ID
         */
        agent_version_id: string;
    };
};
type ReinstateAgentVersionResponse = (DiscardResponse);
type ReinstateAgentVersionError = (AgentVersionNotFoundError | HTTPValidationError | NoActiveSuiteError);
type EliminateAgentVersionData = {
    body: EliminateRequest;
    path: {
        /**
         * Agent version ID
         */
        agent_version_id: string;
    };
};
type EliminateAgentVersionResponse = (EliminateResponse);
type EliminateAgentVersionError = (AgentVersionNotFoundError | HTTPValidationError | NoActiveSuiteError);
type ReinstateEliminationData = {
    body: ReinstateEliminationRequest;
    path: {
        /**
         * Agent version ID
         */
        agent_version_id: string;
    };
};
type ReinstateEliminationResponse2 = (ReinstateEliminationResponse);
type ReinstateEliminationError = (AgentVersionNotFoundError | HTTPValidationError | NoActiveSuiteError);
type SetTopAgentData = {
    body: SetTopRequest;
    path: {
        /**
         * Agent version ID to set as top
         */
        agent_version_id: string;
    };
};
type SetTopAgentResponse = (SetTopResponse);
type SetTopAgentError = (ScoreBelowThresholdError | AgentVersionNotFoundError | HTTPValidationError | NoActiveSuiteError);
type InvalidateEvaluationRunData = {
    body: InvalidateRunRequest;
    path: {
        /**
         * Evaluation run ID
         */
        eval_run_id: string;
    };
};
type InvalidateEvaluationRunResponse = (EvaluationRunStatusPublic);
type InvalidateEvaluationRunError = (EvalRunNotFoundError | AlreadyInvalidatedError | HTTPValidationError);
type ReevaluateAgentVersionData = {
    body: ReevaluateRequest;
    path: {
        /**
         * Agent version ID
         */
        agent_version_id: string;
    };
};
type ReevaluateAgentVersionResponse = (ReevaluateResponse);
type ReevaluateAgentVersionError = (AgentVersionNotFoundError | HTTPValidationError | NoActiveSuiteError);
type CancelAgentVersionData = {
    body: CancelRequest;
    path: {
        /**
         * Agent version ID
         */
        agent_version_id: string;
    };
};
type CancelAgentVersionResponse = (CancelResponse);
type CancelAgentVersionError = (HTTPValidationError);
type CreateSuiteData = {
    body: CreateSuiteRequest;
};
type CreateSuiteResponse2 = (CreateSuiteResponse);
type CreateSuiteError = (HTTPValidationError);
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;
    };
};
type ActivateSuiteResponse2 = (ActivateSuiteResponse);
type ActivateSuiteError = (SuiteNotFoundError | HTTPValidationError);
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);
    };
};
type GetAuditEventsResponse = (AuditEventsResponse);
type GetAuditEventsError = (HTTPValidationError);
type GetReaperStatsResponse = (ReaperStatsResponse);
type GetReaperStatsError = unknown;
type ClearMinerCooldownData = {
    path: {
        /**
         * Miner hotkey
         */
        hotkey: string;
    };
};
type ClearMinerCooldownResponse = (ClearCooldownResponse);
type ClearMinerCooldownError = (HTTPValidationError);
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);
    };
};
type ListMinersResponse = (AdminMinersResponse);
type ListMinersError = (HTTPValidationError);
type ListValidatorsData = {
    query?: {
        /**
         * Filter by ban status
         */
        is_banned?: (boolean | null);
        /**
         * Page size
         */
        limit?: number;
        /**
         * Offset
         */
        offset?: number;
    };
};
type ListValidatorsResponse = (AdminValidatorsResponse);
type ListValidatorsError = (HTTPValidationError);
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);
    };
};
type ListAgentVersions1Response = (AdminAgentVersionsResponse);
type ListAgentVersions1Error = (HTTPValidationError);
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);
    };
};
type ListEvaluationRunsResponse = (AdminEvaluationRunsResponse);
type ListEvaluationRunsError = (HTTPValidationError);
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);
    };
};
type GetValidatorScoresResponse = (ValidatorScoresResponse);
type GetValidatorScoresError = (HTTPValidationError);
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;
    };
};
type GetAgentVersionVarianceResponse = (AgentVersionVarianceResponse);
type GetAgentVersionVarianceError = (HTTPValidationError);
type GetAgentVersionCodeData = {
    path: {
        /**
         * Agent version ID
         */
        agent_version_id: string;
    };
};
type GetAgentVersionCodeResponse = (AdminAgentCodeResponse);
type GetAgentVersionCodeError = (AgentVersionNotFoundError | HTTPValidationError);
type GetCurrentRacesResponse = (CurrentRacesResponse);
type GetCurrentRacesError = unknown;
type GetRaceDiagnosticsData = {
    path: {
        /**
         * Race ID
         */
        race_id: string;
    };
};
type GetRaceDiagnosticsResponse = (RaceDiagnosticsResponse);
type GetRaceDiagnosticsError = (HTTPValidationError);
type CloseQualifyingResponse2 = (CloseQualifyingResponse);
type CloseQualifyingError = unknown;
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);
    };
};
type GetValidatorResourceSamplesResponse = (ValidatorResourceSamplesResponse);
type GetValidatorResourceSamplesError = (HTTPValidationError);
type GetValidatorFailuresData = {
    path: {
        /**
         * Validator SS58 hotkey
         */
        validator_hotkey: string;
    };
    query?: {
        /**
         * Maximum number of failures to return
         */
        limit?: number;
    };
};
type GetValidatorFailuresResponse = (ValidatorFailuresResponse);
type GetValidatorFailuresError = (HTTPValidationError);
type GetValidatorPauseResponse = (ValidatorPauseStatus);
type GetValidatorPauseError = unknown;
type PostValidatorPauseData = {
    body: ValidatorPauseRequest;
};
type PostValidatorPauseResponse = (ValidatorPauseStatus);
type PostValidatorPauseError = (HTTPValidationError);
type PostValidatorResumeData = {
    body: ValidatorResumeRequest;
};
type PostValidatorResumeResponse = (ValidatorPauseStatus);
type PostValidatorResumeError = (HTTPValidationError);
type ApiProblemsData = {
    headers?: {
        'X-Demo-Auth'?: (string | null);
    };
};
type ApiProblemsResponse = (Array<{
    [key: string]: unknown;
}>);
type ApiProblemsError = (HTTPValidationError);
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);
    };
};
type ApiRunResponse = (unknown);
type ApiRunError = (HTTPValidationError);

declare const client: _hey_api_client_fetch.Client<Request, Response, unknown, _hey_api_client_fetch.RequestOptions<boolean, string>>;
/**
 * Health Check
 * Shallow liveness check. Confirms the process is up; does not
 * exercise the DB pool. Kept available as a release valve in case
 * we need to flip the ALB target group back during an RDS incident.
 */
declare const healthCheck: <ThrowOnError extends boolean = false>(options?: OptionsLegacyParser<unknown, ThrowOnError>) => _hey_api_client_fetch.RequestResult<HealthCheckResponse, unknown, ThrowOnError>;
/**
 * Deep Health Check
 * Deep readiness check that exercises the SQLAlchemy pool (ORO-1121).
 *
 * Acquires a session and runs SELECT 1 with a hard timeout, retrying
 * once on failure to ride out transient pool stalls or one-shot
 * network blips (ORO-1168). If the pool is wedged (phantom-checked-out
 * slots) or RDS is unreachable across both attempts, the check fails
 * and the ALB pulls the task out of rotation after its own
 * unhealthy_threshold_count consecutive failures.
 *
 * On final failure we return 503 directly via `JSONResponse` instead
 * of raising `HTTPException`. The status to the ALB is identical, but
 * the Sentry FastAPI integration only captures *exceptions* — so this
 * path no longer triggers the "new unhandled error" PD rule on a
 * transient blip. Sustained DB-unreachable is correctly surfaced by
 * the ALB target-health alarm, not the Sentry new-issue rule.
 */
declare const deepHealthCheck: <ThrowOnError extends boolean = false>(options?: OptionsLegacyParser<unknown, ThrowOnError>) => _hey_api_client_fetch.RequestResult<unknown, unknown, ThrowOnError>;
/**
 * List all suites
 * Get all problem suites, ordered by version descending (newest first).
 */
declare const listSuites: <ThrowOnError extends boolean = false>(options?: OptionsLegacyParser<unknown, ThrowOnError>) => _hey_api_client_fetch.RequestResult<ListSuitesResponse, unknown, ThrowOnError>;
/**
 * Get current active suite
 * Fetch the currently active problem suite.
 */
declare const getCurrentSuite: <ThrowOnError extends boolean = false>(options?: OptionsLegacyParser<unknown, ThrowOnError>) => _hey_api_client_fetch.RequestResult<SuitePublic, SuiteNotFoundError, ThrowOnError>;
/**
 * Get suite problems
 * Get the list of problems for a specific suite.
 */
declare const getSuiteProblems: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<GetSuiteProblemsData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<SuiteWithProblemsResponse, GetSuiteProblemsError, ThrowOnError>;
/**
 * Get leaderboard
 * Get the eligible agent leaderboard for a suite.
 */
declare const getLeaderboard: <ThrowOnError extends boolean = false>(options?: OptionsLegacyParser<GetLeaderboardData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<LeaderboardResponse, HTTPValidationError, ThrowOnError>;
/**
 * Get top agent for emissions
 * Get the canonical top miner for emissions calculation.
 */
declare const getTopAgent: <ThrowOnError extends boolean = false>(options?: OptionsLegacyParser<unknown, ThrowOnError>) => _hey_api_client_fetch.RequestResult<TopAgentResponse, unknown, ThrowOnError>;
/**
 * Get top miner payout rate
 * Get the current top miner's estimated emission payout rate in TAO/day and USD/day. Uses the cached metagraph and a periodically refreshed TAO/USD price.
 */
declare const getTopMinerPayout: <ThrowOnError extends boolean = false>(options?: OptionsLegacyParser<unknown, ThrowOnError>) => _hey_api_client_fetch.RequestResult<TopMinerPayoutResponse, unknown, ThrowOnError>;
/**
 * Get top agent history
 * Get all agents that have held top agent status for a suite.
 */
declare const getTopHistory: <ThrowOnError extends boolean = false>(options?: OptionsLegacyParser<GetTopHistoryData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<TopHistoryResponse, HTTPValidationError, ThrowOnError>;
/**
 * Get agent version status
 * Get live status and counters for an agent version.
 */
declare const getAgentVersionStatus: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<GetAgentVersionStatusData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<AgentVersionStatus, GetAgentVersionStatusError, ThrowOnError>;
/**
 * Get agent version runs
 * Get evaluation runs for an agent version.
 */
declare const getAgentVersionRuns: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<GetAgentVersionRunsData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<GetAgentVersionRunsResponse, GetAgentVersionRunsError, ThrowOnError>;
/**
 * Get agent version problem progress
 * Get per-problem progress matrix across validators.
 */
declare const getAgentVersionProblems: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<GetAgentVersionProblemsData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<AgentVersionProblemsResponse, GetAgentVersionProblemsError, ThrowOnError>;
/**
 * Get agent version details
 * Get released public details for an agent version.
 */
declare const getAgentVersion: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<GetAgentVersionData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<AgentVersionPublic, GetAgentVersionError, ThrowOnError>;
/**
 * Get artifact download URL
 * Get a presigned URL to download artifacts. Agent code requires the version to be released. Qualifying-phase trajectories and logs are available immediately; race-phase artifacts are gated until the race completes (403 RACE_IN_FLIGHT).
 */
declare const getArtifactDownloadUrl: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<GetArtifactDownloadUrlData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<ArtifactDownloadResponse, GetArtifactDownloadUrlError, ThrowOnError>;
/**
 * Get evaluation run details
 * Get detailed information about a specific evaluation run.
 */
declare const getEvaluationRun: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<GetEvaluationRunData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<EvaluationRunDetail, GetEvaluationRunError, ThrowOnError>;
/**
 * Get list of validators
 * Get all non-banned validators with their current status.
 */
declare const getValidators: <ThrowOnError extends boolean = false>(options?: OptionsLegacyParser<unknown, ThrowOnError>) => _hey_api_client_fetch.RequestResult<GetValidatorsResponse, unknown, ThrowOnError>;
/**
 * Get running evaluations
 * Get all currently running or claimed evaluations.
 */
declare const getRunningEvaluations: <ThrowOnError extends boolean = false>(options?: OptionsLegacyParser<unknown, ThrowOnError>) => _hey_api_client_fetch.RequestResult<GetRunningEvaluationsResponse, unknown, ThrowOnError>;
/**
 * Get pending evaluations
 * Get all open work items awaiting validator evaluations, with queue summary.
 */
declare const getPendingEvaluations: <ThrowOnError extends boolean = false>(options?: OptionsLegacyParser<GetPendingEvaluationsData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<PendingEvaluationsResponse, HTTPValidationError, ThrowOnError>;
/**
 * Get current race
 * Get the active race for the current suite, if any.
 */
declare const getCurrentRace: <ThrowOnError extends boolean = false>(options?: OptionsLegacyParser<unknown, ThrowOnError>) => _hey_api_client_fetch.RequestResult<RaceCurrentResponse, unknown, ThrowOnError>;
/**
 * Get race history
 * Get completed and cancelled races, most recent first.
 */
declare const getRaceHistory: <ThrowOnError extends boolean = false>(options?: OptionsLegacyParser<GetRaceHistoryData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<RaceHistoryResponse, HTTPValidationError, ThrowOnError>;
/**
 * Get race details
 * Get details for a specific race including qualifiers and results.
 */
declare const getRaceDetail: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<GetRaceDetailData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<RaceDetailResponse, GetRaceDetailError, ThrowOnError>;
/**
 * Per-validator variance for a race
 * Per-validator variance statistics for a race, computed over included SUCCESS evaluation runs (`is_included = true`, `invalidated_at IS NULL`) joined via `eval_work_items` on `phase = 'RACE'`. Only agent-race pairs where at least two validators produced a run are counted.
 *
 * Available live during a running race. This endpoint aggregates data that `/agent-versions/{av_id}/runs` already exposes per-run — see `_assert_artifact_not_race_gated` for the artifacts that stay hidden until race completion (ORO-1467).
 *
 * Announced 2026-07-17 as part of the validator-variance visibility commitment. See the miner announcement thread for background.
 */
declare const getRaceValidatorVariance: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<GetRaceValidatorVarianceData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<RaceValidatorVarianceResponse, GetRaceValidatorVarianceError, ThrowOnError>;
/**
 * Join waitlist
 * Submit an email to join the ORO waitlist.
 */
declare const joinWaitlist: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<JoinWaitlistData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<WaitlistSignupResponse, HTTPValidationError, ThrowOnError>;
/**
 * List allowed inference models
 * Returns the models available to ORO agents via the inference proxy. Defaults to a flat array of model IDs (provider's static allowlist). Set ``?ranked=true`` to receive models in load-/health-sorted order with per-model stats from the most recent provider poll.
 *
 * **Chutes-deprecated models (still in the Chutes allowlist for miner compatibility, but Chutes no longer serves them — route via OpenRouter):**
 * - `deepseek-ai/DeepSeek-V3.1-TEE`
 * - `deepseek-ai/DeepSeek-V3-0324-TEE`
 * - `deepseek-ai/DeepSeek-R1-0528-TEE`
 * - `XiaomiMiMo/MiMo-V2-Flash-TEE`
 */
declare const getInferenceModels: <ThrowOnError extends boolean = false>(options?: OptionsLegacyParser<GetInferenceModelsData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<GetInferenceModelsResponse, HTTPValidationError, ThrowOnError>;
/**
 * Request Challenge
 * Request a challenge for wallet authentication.
 *
 * The challenge must be signed by the wallet and submitted to /session
 * within 60 seconds.
 *
 * Rate limited to 10 requests per minute per IP to prevent abuse.
 */
declare const requestChallenge: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<RequestChallengeData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<ChallengeResponse, HTTPValidationError, ThrowOnError>;
/**
 * Create Session Endpoint
 * Create a session by verifying a signed challenge.
 *
 * The challenge must have been requested within the last 60 seconds
 * and the signature must be valid for the challenge message.
 *
 * Rate limited to 5 requests per minute per IP to prevent brute force.
 */
declare const createSessionEndpoint: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<CreateSessionEndpointData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<SessionResponse, HTTPValidationError, ThrowOnError>;
/**
 * Logout
 * Logout and invalidate the current session.
 */
declare const logout: <ThrowOnError extends boolean = false>(options?: OptionsLegacyParser<LogoutData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<LogoutResponse, HTTPValidationError, ThrowOnError>;
/**
 * Submit agent
 * Submit an agent file for evaluation. Creates new agent if needed.
 */
declare const submitAgent: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<SubmitAgentData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<SubmitAgentResponse, SubmitAgentError, ThrowOnError>;
/**
 * Store an inference-provider credential
 * Store (or overwrite) the miner's credential for the given provider.
 *
 * Validates the credential before persisting so bad input fails here rather
 * than at first claim_work. The first stored provider becomes the miner's
 * default; switching default afterward goes through the dedicated PATCH
 * endpoint.
 */
declare const storeInferenceCredential: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<StoreInferenceCredentialData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<StoreInferenceCredentialResponse, HTTPValidationError, ThrowOnError>;
/**
 * Check inference auth status for a single provider
 * Check whether the miner has a stored credential for the given provider.
 */
declare const getInferenceAuthStatusOne: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<GetInferenceAuthStatusOneData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<InferenceAuthStatusResponse, HTTPValidationError, ThrowOnError>;
/**
 * Disconnect an inference-provider credential
 * Delete the miner's stored credential for the given provider.
 *
 * If the deleted provider was the miner's default, the default falls back
 * to whichever other provider is still connected, or clears to NULL when
 * none remain. Returns the new default so the client can update without a
 * follow-up GET.
 */
declare const deleteInferenceCredential: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<DeleteInferenceCredentialData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<DeleteInferenceCredentialResponse, HTTPValidationError, ThrowOnError>;
/**
 * List all inference-auth providers the miner has connected
 * List every provider the authenticated miner currently has a credential for.
 */
declare const listInferenceAuth: <ThrowOnError extends boolean = false>(options?: OptionsLegacyParser<unknown, ThrowOnError>) => _hey_api_client_fetch.RequestResult<InferenceAuthListResponse, unknown, ThrowOnError>;
/**
 * Set the miner's default inference provider
 * Set which provider claim_work should mint a token from for this miner.
 */
declare const setDefaultInferenceProvider: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<SetDefaultInferenceProviderData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<SetDefaultInferenceProviderResponse, HTTPValidationError, ThrowOnError>;
/**
 * @deprecated
 * Store Chutes OAuth refresh token (legacy — use /inference-auth/chutes)
 * Back-compat shim. Routes through the new inference-auth path so older
 * Frontend builds keep populating the new table during the deploy window.
 */
declare const storeChutesToken: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<StoreChutesTokenData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<StoreChutesTokenResponse, HTTPValidationError, ThrowOnError>;
/**
 * @deprecated
 * Check Chutes auth status (legacy — use /inference-auth/chutes)
 * Back-compat shim. Reads from the new MinerInferenceAuth table.
 */
declare const getChutesAuthStatus: <ThrowOnError extends boolean = false>(options?: OptionsLegacyParser<unknown, ThrowOnError>) => _hey_api_client_fetch.RequestResult<ChutesAuthStatusResponse, unknown, ThrowOnError>;
/**
 * Exchange Chutes PKCE auth code for a refresh token (server-side)
 * Complete the Chutes OAuth code exchange on behalf of the SDK CLI.
 *
 * Chutes' OAuth app is registered as a Confidential client (requires
 * ``client_secret`` at /idp/token). The SDK, distributed via PyPI, can't
 * safely hold a secret. So the SDK runs the browser PKCE leg locally
 * (preserves auth-code interception protection) and then hands the
 * resulting authorization code + ``code_verifier`` here. Backend holds
 * the ``client_secret`` and completes the exchange (ORO-1463).
 */
declare const exchangeChutesCode: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<ExchangeChutesCodeData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<ExchangeChutesCodeResponse, HTTPValidationError, ThrowOnError>;
/**
 * List miner's agents
 * List all agents owned by the authenticated miner, with cooldown status.
 *
 * Includes the latest version per agent with its state and score so the
 * frontend doesn't need to make N additional requests.
 */
declare const listMinerAgents: <ThrowOnError extends boolean = false>(options?: OptionsLegacyParser<unknown, ThrowOnError>) => _hey_api_client_fetch.RequestResult<MinerAgentsResponse, unknown, ThrowOnError>;
/**
 * List agent versions
 * List all versions of a specific agent owned by the miner.
 */
declare const listAgentVersions: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<ListAgentVersionsData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<ListAgentVersionsResponse, ListAgentVersionsError, ThrowOnError>;
/**
 * Get agent version status
 * Get detailed status of a specific agent version owned by the miner.
 */
declare const getOwnedAgentVersionStatus: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<GetOwnedAgentVersionStatusData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<AgentVersionStatus, GetOwnedAgentVersionStatusError, ThrowOnError>;
/**
 * Pin agent version as race candidate
 * Pin the given agent version as this miner's race candidate.
 */
declare const setRaceSelection: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<SetRaceSelectionData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<void, unknown, ThrowOnError>;
/**
 * Clear pinned race candidate
 * Clear the miner's pinned race candidate so the auto-pick is used.
 */
declare const clearRaceSelection: <ThrowOnError extends boolean = false>(options?: OptionsLegacyParser<unknown, ThrowOnError>) => _hey_api_client_fetch.RequestResult<void, ClearRaceSelectionError, ThrowOnError>;
/**
 * Claim evaluation work
 * FIFO claim of next available evaluation work item.
 */
declare const claimWork: <ThrowOnError extends boolean = false>(options?: OptionsLegacyParser<ClaimWorkData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<ClaimWorkResponse2, ClaimWorkError, ThrowOnError>;
/**
 * Extend lease
 * Heartbeat to extend lease and mark run as RUNNING.
 */
declare const heartbeat: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<HeartbeatData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<HeartbeatResponse, HeartbeatError, ThrowOnError>;
/**
 * Update progress
 * Report per-problem progress during evaluation.
 */
declare const updateProgress: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<UpdateProgressData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<ProgressUpdateResponse, UpdateProgressError, ThrowOnError>;
/**
 * Get upload URL
 * Get a presigned URL for uploading per-problem evaluation logs.
 */
declare const presignUpload: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<PresignUploadData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<PresignUploadResponse, PresignUploadError, ThrowOnError>;
/**
 * Complete evaluation run
 * Finalize an evaluation run with terminal status and score.
 */
declare const completeRun: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<CompleteRunData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<CompleteRunResponse, CompleteRunError, ThrowOnError>;
/**
 * Get problems for an evaluation run
 * Returns the problems that should be evaluated for a given run.
 */
declare const getRunProblems: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<GetRunProblemsData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<RunProblemsResponse, GetRunProblemsError, ThrowOnError>;
/**
 * Get Weight Salt
 * Per-epoch base standings for the weight setter (ORO-1704).
 *
 * Serves the epoch-pinned base standings (top designation + finisher tail)
 * snapshotted once per epoch, so every honest validator in the epoch builds the
 * identical base vector regardless of tick phase. (The ORO-1649 watermark
 * decoy-overlay was removed — we rely on the chain's anti-copy features.)
 */
declare const getWeightSalt: <ThrowOnError extends boolean = false>(options?: OptionsLegacyParser<unknown, ThrowOnError>) => _hey_api_client_fetch.RequestResult<WeightSaltResponse, unknown, ThrowOnError>;
/**
 * Ban a miner
 * Ban a miner from submitting agents.
 */
declare const banMiner: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<BanMinerData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<BanResponse, BanMinerError, ThrowOnError>;
/**
 * Unban a miner
 * Unban a miner, allowing them to submit agents again.
 */
declare const unbanMiner: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<UnbanMinerData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<BanResponse, UnbanMinerError, ThrowOnError>;
/**
 * Ban a validator
 * Ban a validator from claiming work. Revokes any active inference tokens.
 */
declare const banValidator: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<BanValidatorData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<BanResponse, BanValidatorError, ThrowOnError>;
/**
 * Unban a validator
 * Unban a validator, allowing them to claim work again.
 */
declare const unbanValidator: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<UnbanValidatorData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<BanResponse, UnbanValidatorError, ThrowOnError>;
/**
 * Update validator configuration
 * Update validator configuration. Currently supports `max_concurrent_runs`.
 */
declare const updateValidator: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<UpdateValidatorData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<AdminValidatorEntry, UpdateValidatorError, ThrowOnError>;
/**
 * Discard an agent version from leaderboard
 * Discard an agent version from the leaderboard (reversible tombstone).
 *
 * Also cancels any active evaluation runs and closes the work item
 * to prevent the validator from claiming new work for this version.
 */
declare const discardAgentVersion: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<DiscardAgentVersionData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<DiscardResponse, DiscardAgentVersionError, ThrowOnError>;
/**
 * Reinstate a discarded agent version
 * Reinstate a previously discarded agent version.
 *
 * Also reopens the work item so validators can claim work again.
 */
declare const reinstateAgentVersion: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<ReinstateAgentVersionData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<DiscardResponse, ReinstateAgentVersionError, ThrowOnError>;
/**
 * Eliminate an agent version (admin override)
 * Stamp `eliminated_at` on the aggregate so the version is removed from
 * future qualifying.
 *
 * Counterpart to `reinstate-elimination`. Used to test the admission
 * cascade end-to-end and to manually retire an agent that should no
 * longer race (e.g. confirmed cheating before a natural race-loss).
 *
 * Idempotent on `eliminated_at`: re-running stamps the same row with a
 * fresh timestamp.
 */
declare const eliminateAgentVersion: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<EliminateAgentVersionData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<EliminateResponse, EliminateAgentVersionError, ThrowOnError>;
/**
 * Reinstate an agent version that was eliminated after a race
 * Clear `eliminated_at` and `eliminated_in_race_id` on the aggregate.
 *
 * Use when an agent was eliminated due to a mis-evaluation, scoring bug, or
 * operational incident rather than genuine poor performance. The agent will
 * re-appear in `_find_scored_qualifiers` on the next qualifying evaluation.
 *
 * Idempotent: succeeds even if the aggregate is not currently eliminated.
 */
declare const reinstateElimination: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<ReinstateEliminationData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<ReinstateEliminationResponse, ReinstateEliminationError, ThrowOnError>;
/**
 * Set an agent version as the top agent for emissions
 * Designate an agent version as the top agent for emissions.
 *
 * The top agent is the one that receives emissions. Setting a new top agent
 * automatically marks the previous top agent as was_top=True.
 *
 * Requirements:
 * - Agent version must exist and have an aggregate for the suite
 * - Only one agent can be is_current_top=True per suite (enforced by DB index)
 */
declare const setTopAgent: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<SetTopAgentData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<SetTopResponse, SetTopAgentError, ThrowOnError>;
/**
 * Invalidate an evaluation run
 * Invalidate an evaluation run (irreversible).
 *
 * Marks the run as excluded from scoring and adjusts the work item's
 * included_success_count. Reopens the work item to allow validators
 * to claim replacement work.
 */
declare const invalidateEvaluationRun: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<InvalidateEvaluationRunData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<EvaluationRunStatusPublic, InvalidateEvaluationRunError, ThrowOnError>;
/**
 * Re-evaluate an agent version
 * Create a new work item for an agent version to be re-evaluated.
 */
declare const reevaluateAgentVersion: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<ReevaluateAgentVersionData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<ReevaluateResponse, ReevaluateAgentVersionError, ThrowOnError>;
/**
 * Cancel evaluation of an agent version
 * Cancel active evaluation runs for an agent version.
 */
declare const cancelAgentVersion: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<CancelAgentVersionData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<CancelResponse, HTTPValidationError, ThrowOnError>;
/**
 * Create a new problem suite
 * Create a new problem suite version.
 *
 * Downloads and parses the problem suite JSON from S3, then creates
 * Problem records for each problem in the suite.
 */
declare const createSuite: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<CreateSuiteData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<CreateSuiteResponse, HTTPValidationError, ThrowOnError>;
/**
 * Activate a problem suite
 * Activate a suite, making it the current active suite (deactivates others).
 *
 * Automatically requeues the top N agent versions from the previous suite
 * so validators have work immediately and the leaderboard populates quickly.
 */
declare const activateSuite: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<ActivateSuiteData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<ActivateSuiteResponse, ActivateSuiteError, ThrowOnError>;
/**
 * Get audit events
 * Retrieve audit events with optional filtering and pagination.
 */
declare const getAuditEvents: <ThrowOnError extends boolean = false>(options?: OptionsLegacyParser<GetAuditEventsData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<AuditEventsResponse, HTTPValidationError, ThrowOnError>;
/**
 * Get reaper service statistics
 * Get statistics about the background reaper service.
 *
 * The reaper service runs periodically to clean up orphaned evaluation runs
 * where validators have stopped reporting (crashed or disconnected).
 *
 * Stats are read from Redis (persisted by the active reaper instance) to ensure
 * consistent visibility across all replicas.
 */
declare const getReaperStats: <ThrowOnError extends boolean = false>(options?: OptionsLegacyParser<unknown, ThrowOnError>) => _hey_api_client_fetch.RequestResult<ReaperStatsResponse, unknown, ThrowOnError>;
/**
 * Clear miner cooldown
 * Clear the submission cooldown for a miner.
 */
declare const clearMinerCooldown: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<ClearMinerCooldownData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<ClearCooldownResponse, HTTPValidationError, ThrowOnError>;
/**
 * List miners with ban status and agent count
 * List all miners with their ban status, agent count, and last submission time.
 */
declare const listMiners: <ThrowOnError extends boolean = false>(options?: OptionsLegacyParser<ListMinersData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<AdminMinersResponse, HTTPValidationError, ThrowOnError>;
/**
 * List validators including banned
 * List all validators including banned ones.
 */
declare const listValidators: <ThrowOnError extends boolean = false>(options?: OptionsLegacyParser<ListValidatorsData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<AdminValidatorsResponse, HTTPValidationError, ThrowOnError>;
/**
 * List agent versions with work item state
 * List agent versions with aggregate and work item state for a specific suite.
 */
declare const listAgentVersions1: <ThrowOnError extends boolean = false>(options?: OptionsLegacyParser<ListAgentVersions1Data, ThrowOnError>) => _hey_api_client_fetch.RequestResult<AdminAgentVersionsResponse, HTTPValidationError, ThrowOnError>;
/**
 * List evaluation runs with full details
 * List evaluation runs with optional filtering and pagination.
 */
declare const listEvaluationRuns: <ThrowOnError extends boolean = false>(options?: OptionsLegacyParser<ListEvaluationRunsData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<AdminEvaluationRunsResponse, HTTPValidationError, ThrowOnError>;
/**
 * Aggregated scoring statistics per validator
 * Compute per-validator scoring and performance statistics.
 */
declare const getValidatorScores: <ThrowOnError extends boolean = false>(options?: OptionsLegacyParser<GetValidatorScoresData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<ValidatorScoresResponse, HTTPValidationError, ThrowOnError>;
/**
 * Score variance across validators for recent agent versions
 * Find agent versions with high score variance across validators.
 */
declare const getAgentVersionVariance: <ThrowOnError extends boolean = false>(options?: OptionsLegacyParser<GetAgentVersionVarianceData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<AgentVersionVarianceResponse, HTTPValidationError, ThrowOnError>;
/**
 * Download agent code
 * Get a presigned S3 URL to download agent source code for any version, regardless of release state.
 */
declare const getAgentVersionCode: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<GetAgentVersionCodeData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<AdminAgentCodeResponse, GetAgentVersionCodeError, ThrowOnError>;
/**
 * Get current race state
 * Get all active (non-complete, non-cancelled) races with summary info.
 */
declare const getCurrentRaces: <ThrowOnError extends boolean = false>(options?: OptionsLegacyParser<unknown, ThrowOnError>) => _hey_api_client_fetch.RequestResult<CurrentRacesResponse, unknown, ThrowOnError>;
/**
 * Get race diagnostics
 * Get detailed diagnostics for a specific race.
 */
declare const getRaceDiagnostics: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<GetRaceDiagnosticsData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<RaceDiagnosticsResponse, HTTPValidationError, ThrowOnError>;
/**
 * Close qualifying and start race
 * Close the current qualifying window immediately.
 *
 * Sets qualifying_closes_at to now so the orchestrator picks it up
 * on its next cycle and transitions to RACE_RUNNING (or CANCELLED
 * if no qualifiers meet the threshold).
 */
declare const closeQualifying: <ThrowOnError extends boolean = false>(options?: OptionsLegacyParser<unknown, ThrowOnError>) => _hey_api_client_fetch.RequestResult<CloseQualifyingResponse, unknown, ThrowOnError>;
/**
 * Validator host resource samples
 */
declare const getValidatorResourceSamples: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<GetValidatorResourceSamplesData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<ValidatorResourceSamplesResponse, HTTPValidationError, ThrowOnError>;
/**
 * Recent failed/timed-out runs for a single validator
 * Returns the most recent FAILED and TIMED_OUT evaluation runs for the given validator, ordered by completed_at DESC. Powers the expandable failure-history view on the admin analytics dashboard (ORO-676).
 */
declare const getValidatorFailures: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<GetValidatorFailuresData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<ValidatorFailuresResponse, HTTPValidationError, ThrowOnError>;
/**
 * Get validator-pause (andon-cord) state
 * Returns whether new validator claims are currently paused, plus metadata on who pulled the cord and when it auto-releases.
 */
declare const getValidatorPause: <ThrowOnError extends boolean = false>(options?: OptionsLegacyParser<unknown, ThrowOnError>) => _hey_api_client_fetch.RequestResult<ValidatorPauseStatus, unknown, ThrowOnError>;
/**
 * Pause validator claims (pull the andon cord)
 * Block all validators from claiming new evaluations. In-flight runs continue and report normally. Idempotent — calling twice overwrites the prior pause metadata.
 */
declare const postValidatorPause: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<PostValidatorPauseData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<ValidatorPauseStatus, HTTPValidationError, ThrowOnError>;
/**
 * Resume validator claims (release the andon cord)
 */
declare const postValidatorResume: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<PostValidatorResumeData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<ValidatorPauseStatus, HTTPValidationError, ThrowOnError>;
/**
 * Api Problems
 */
declare const apiProblems: <ThrowOnError extends boolean = false>(options?: OptionsLegacyParser<ApiProblemsData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<ApiProblemsResponse, HTTPValidationError, ThrowOnError>;
/**
 * Api Run
 */
declare const apiRun: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<ApiRunData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<unknown, HTTPValidationError, ThrowOnError>;

/**
 * Auto-generated error code type.
 *
 * DO NOT EDIT — regenerate with: python3 scripts/extract-errors.py
 */
type OroErrorCode = 'AGENT_NOT_FOUND' | 'AGENT_VERSION_NOT_FOUND' | 'ALREADY_INVALIDATED' | 'ARTIFACT_NOT_FOUND' | 'ARTIFACT_NOT_RELEASED' | 'AT_CAPACITY' | 'CODE_ANALYSIS_ERROR' | 'COOLDOWN_ACTIVE' | 'EVAL_RUN_NOT_FOUND' | 'FILE_TOO_LARGE' | 'INVALID_AGENT_NAME' | 'INVALID_ARTIFACT_TYPE' | 'INVALID_FILE' | 'INVALID_PROBLEM_ID' | 'LEASE_EXPIRED' | 'MINER_NOT_FOUND' | 'MISSING_PARAMETER' | 'MISSING_SCORE' | 'NO_ACTIVE_SUITE' | 'NO_SELECTION' | 'NOT_RUN_OWNER' | 'NOT_VERSION_OWNER' | 'PROBLEM_NOT_FOUND' | 'RACE_IN_FLIGHT' | 'RACE_LOCKED' | 'RACE_NOT_FOUND' | 'RATE_LIMIT_EXCEEDED' | 'RUN_ALREADY_COMPLETE' | 'SCORE_BELOW_THRESHOLD' | 'SIMILARITY_CHECK_UNAVAILABLE' | 'SUITE_NOT_FOUND' | 'VALIDATION_ERROR' | 'VALIDATOR_NOT_FOUND';

/**
 * Error classification utilities for the ORO SDK.
 *
 * Provides helpers to classify HTTP responses, check transient errors,
 * and extract structured error details from API responses.
 */

/**
 * High-level error category derived from HTTP status codes.
 */
type ErrorCategory = 'NETWORK' | 'AUTH' | 'NOT_FOUND' | 'VALIDATION' | 'CONFLICT' | 'RATE_LIMITED' | 'SERVER' | 'UNKNOWN';
/**
 * Classify an HTTP status code into an {@link ErrorCategory}.
 */
declare function classifyStatus(status: number | undefined): ErrorCategory;
/**
 * Classify a `Response` object (or null for network failures) into an {@link ErrorCategory}.
 */
declare function classifyError(response: Response | null): ErrorCategory;
/**
 * Returns `true` if the HTTP status code represents a transient (retryable) error.
 *
 * Transient statuses: 429 (rate limited), 5xx (server errors), 0/undefined (network failures).
 */
declare function isTransient(status: number | undefined): boolean;
/**
 * Returns `true` if the response represents a transient (retryable) error.
 */
declare function isTransientError(response: Response | null): boolean;
/**
 * Extract the `detail` string from a parsed error body.
 *
 * Returns `undefined` if `detail` is missing, not a string (e.g. Pydantic validation arrays),
 * or the error body is null/undefined.
 */
declare function getErrorDetail(error: unknown): string | undefined;
/**
 * Extract the `error_code` from a parsed error body.
 *
 * Returns `undefined` if the field is missing or not a string.
 */
declare function getErrorCode(error: unknown): OroErrorCode | undefined;
/**
 * Type guard that narrows `error` to an object with a matching `error_code`.
 */
declare function hasErrorCode<C extends OroErrorCode>(error: unknown, code: C): error is {
    error_code: C;
};
/**
 * Type guard that narrows `error` to `{ detail: string }`.
 */
declare function hasDetail(error: unknown): error is {
    detail: string;
};

/**
 * Retry middleware for the ORO SDK.
 *
 * Provides opt-in retry logic with exponential backoff for transient errors
 * (429, 502, 503, 504) and network failures.
 */
/**
 * Configuration for retry behavior.
 */
interface RetryConfig {
    /** Maximum number of retries. Set to 0 to disable. Defaults to 3. */
    maxRetries?: number;
    /** HTTP status codes that should trigger a retry. Defaults to [429, 502, 503, 504]. */
    retryableStatuses?: number[];
    /** Base delay in milliseconds for exponential backoff. Defaults to 1000. */
    baseDelayMs?: number;
    /** Maximum delay in milliseconds. Defaults to 30000. */
    maxDelayMs?: number;
    /** Whether to add random jitter to the delay. Defaults to true. */
    jitter?: boolean;
    /** Optional callback invoked before each retry attempt. */
    onRetry?: (context: RetryContext) => void;
}
/**
 * Context passed to the onRetry callback.
 */
interface RetryContext {
    /** The current retry attempt number (1-based). */
    attempt: number;
    /** The delay in milliseconds before this retry. */
    delayMs: number;
    /** The HTTP status code that triggered the retry, or undefined for network errors. */
    status?: number;
    /** The Retry-After value from the response header, in milliseconds. */
    retryAfter?: number;
}
/**
 * Parse the Retry-After header value into milliseconds.
 *
 * Supports both integer seconds (`120`) and HTTP-date format
 * (`Wed, 21 Oct 2015 07:28:00 GMT`).
 *
 * @param response - The Response object to parse the header from
 * @returns Retry-After value in milliseconds, or undefined if not present/parseable
 */
declare function parseRetryAfter(response: Response): number | undefined;
/**
 * Compute the delay before the next retry attempt using exponential backoff.
 *
 * Formula: `min(base * 2^attempt, max)`, optionally jittered, with
 * Retry-After taking precedence when present.
 *
 * @param attempt - The current attempt number (0-based)
 * @param baseDelayMs - Base delay in milliseconds
 * @param maxDelayMs - Maximum delay in milliseconds
 * @param jitter - Whether to add random jitter
 * @param retryAfter - Optional Retry-After value in milliseconds
 * @returns The computed delay in milliseconds
 */
declare function computeDelay(attempt: number, baseDelayMs: number, maxDelayMs: number, jitter: boolean, retryAfter?: number): number;
/**
 * Create a fetch wrapper that retries transient failures with exponential backoff.
 *
 * The returned function has the same signature as `globalThis.fetch` and can be
 * passed to `client.setConfig({ fetch: ... })`.
 *
 * @param config - Retry configuration (all fields optional with sensible defaults)
 * @returns A fetch-compatible function with retry logic
 *
 * @example
 * ```typescript
 * import { createRetryFetch } from '@oro-ai/sdk';
 *
 * // Use defaults (3 retries, 1s base delay)
 * const retryFetch = createRetryFetch({});
 *
 * // Custom config
 * const retryFetch = createRetryFetch({ maxRetries: 5, baseDelayMs: 500 });
 *
 * // Disable retries
 * const noRetryFetch = createRetryFetch({ maxRetries: 0 });
 * ```
 */
declare function createRetryFetch(config: RetryConfig): typeof globalThis.fetch;

/**
 * Bittensor wallet authentication helper for ORO SDK.
 *
 * This module provides utilities to authenticate API requests using
 * Bittensor wallet signatures (SR25519).
 */

/**
 * Configuration for Bittensor authentication.
 */
interface BittensorAuthConfig {
    /**
     * The hotkey SS58 address.
     */
    hotkey: string;
    /**
     * Function to sign a message with the hotkey.
     * Should return the signature as a hex string.
     *
     * @param message - The message to sign (`{hotkey}:{timestamp}:{nonce}`)
     * @returns Signature as hex string (with or without 0x prefix)
     */
    sign: (message: string) => string | Promise<string>;
}
/**
 * Generate authentication headers for a Bittensor wallet.
 *
 * Message format is `{hotkey}:{timestamp}:{nonce}` (matches the ORO Backend's
 * expected signature format).
 *
 * @param config - Bittensor auth configuration
 * @param nonce - Optional nonce (defaults to crypto.randomUUID())
 * @returns Object with X-Hotkey, X-Signature, X-Nonce, X-Timestamp headers
 */
declare function generateAuthHeaders(config: BittensorAuthConfig, nonce?: string): Promise<Record<string, string>>;
/**
 * Configure the SDK client with Bittensor authentication.
 *
 * This adds a request interceptor that automatically signs each request
 * with fresh authentication headers.
 *
 * @param baseUrl - API base URL
 * @param authConfig - Bittensor auth configuration
 * @returns The configured client
 *
 * @example
 * ```typescript
 * import { configureBittensorAuth, claimWork } from '@oro-ai/sdk';
 *
 * // With a signing function (you provide the implementation)
 * configureBittensorAuth('https://api.oro.ai', {
 *   hotkey: '5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY',
 *   sign: (message) => wallet.sign(message),
 * });
 *
 * // Now all requests are automatically authenticated
 * const { data: work } = await claimWork();
 * ```
 */
declare function configureBittensorAuth(baseUrl: string, authConfig: BittensorAuthConfig, retryConfig?: RetryConfig): typeof client;
/**
 * Configure the SDK client for public (unauthenticated) access only.
 *
 * @param baseUrl - API base URL
 * @returns The configured client
 *
 * @example
 * ```typescript
 * import { configurePublicClient, getLeaderboard } from '@oro-ai/sdk';
 *
 * configurePublicClient('https://api.oro.ai');
 * const { data } = await getLeaderboard();
 * ```
 */
declare function configurePublicClient(baseUrl: string, retryConfig?: RetryConfig): typeof client;

/**
 * Session-based authentication manager for ORO SDK.
 *
 * This module provides a convenient session lifecycle manager that handles
 * challenge/response login, token storage, auto-refresh, header injection,
 * and logout — matching the convenience of the Python SDK's BittensorAuthClient.
 */

/**
 * A serializable snapshot of a session, suitable for caching
 * in sessionStorage or similar.
 */
interface CachedSession {
    token: string;
    expiresAt: number;
    role: string;
}
/**
 * Configuration for session-based authentication.
 */
interface SessionAuthConfig {
    /** The hotkey SS58 address. */
    hotkey: string;
    /**
     * Function to sign a challenge string with the hotkey.
     * Should return the signature as a hex string.
     */
    sign: (message: string) => string | Promise<string>;
    /** Seconds before expiry to trigger auto-refresh. Default: 300 (5 minutes). */
    refreshBufferSeconds?: number;
    /** Called when the session has expired and cannot be refreshed. */
    onSessionExpired?: () => void;
    /**
     * Previously cached session to restore without re-authenticating.
     * If provided and the token hasn't expired, the manager starts
     * in an authenticated state — no login() call needed.
     */
    cachedSession?: CachedSession;
}
/**
 * Information about the current session.
 */
interface SessionInfo {
    hotkey: string;
    role: string;
    expiresAt: number;
}
/**
 * Manages the full session authentication lifecycle: login, logout,
 * token refresh, and automatic header injection.
 */
declare class SessionAuthManager {
    private token;
    private expiresAt;
    private role;
    private refreshPromise;
    private readonly hotkey;
    private readonly sign;
    private readonly refreshBufferSeconds;
    private readonly onSessionExpired?;
    constructor(config: SessionAuthConfig);
    /**
     * Perform challenge/response login flow.
     *
     * 1. Requests a challenge from the server
     * 2. Signs the challenge with the configured sign function
     * 3. Creates a session with the signed challenge
     * 4. Stores the session token internally
     */
    login(): Promise<SessionResponse>;
    /**
     * Logout and invalidate the current session.
     * Silently catches errors (session may already be expired).
     */
    logout(): Promise<void>;
    /**
     * Refresh the session by performing a new login flow.
     */
    refreshSession(): Promise<SessionResponse>;
    /** Returns true if a session token exists and hasn't expired. */
    hasActiveSession(): boolean;
    /** Returns true if the session is within the refresh buffer of expiry. */
    sessionNeedsRefresh(): boolean;
    /** Returns current session info, or null if no active session. */
    getSessionInfo(): SessionInfo | null;
    /**
     * Returns a serializable snapshot of the current session for caching.
     * Returns null if no active session.
     *
     * Store the result in sessionStorage and pass it back as
     * `cachedSession` in the constructor to restore without re-authenticating.
     */
    getSessionToken(): CachedSession | null;
    /**
     * Returns authorization headers. Auto-refreshes if the session is
     * within the refresh buffer. Throws if not authenticated or session expired.
     */
    getAuthHeaders(): Promise<Record<string, string>>;
    private clearSession;
}
/**
 * Configure the SDK client with session-based authentication.
 *
 * Sets up the base URL, creates a {@link SessionAuthManager}, and installs
 * a request interceptor that injects Bearer tokens automatically.
 *
 * @param baseUrl - API base URL
 * @param config - Session auth configuration
 * @returns A {@link SessionAuthManager} instance for controlling the session lifecycle
 *
 * @example
 * ```typescript
 * import { configureSessionAuth, listMinerAgents } from '@oro-ai/sdk';
 *
 * const session = configureSessionAuth('https://api.oro.ai', {
 *   hotkey: '5GrwvaEF...',
 *   sign: (challenge) => wallet.sign(challenge),
 *   onSessionExpired: () => router.push('/login'),
 * });
 *
 * await session.login();
 *
 * // All subsequent requests include Bearer token automatically
 * const { data: agents } = await listMinerAgents();
 * ```
 */
declare function configureSessionAuth(baseUrl: string, config: SessionAuthConfig): SessionAuthManager;

export { type ActivateSuiteData, type ActivateSuiteError, type ActivateSuiteResponse, type ActivateSuiteResponse2, type AdminAgentCodeResponse, type AdminAgentVersionEntry, type AdminAgentVersionsResponse, type AdminEvaluationRunEntry, type AdminEvaluationRunsResponse, type AdminMinerEntry, type AdminMinersResponse, type AdminValidatorEntry, type AdminValidatorsResponse, type AdmissionReason, type AdmissionStatus, type AgentLatestVersion, type AgentNotFoundError, type AgentPublic, type AgentVersionHistoryEntry, type AgentVersionNotFoundError, type AgentVersionProblemsResponse, type AgentVersionPublic, type AgentVersionScoreEntry, type AgentVersionState, type AgentVersionStatus, type AgentVersionVariance, type AgentVersionVarianceResponse, type AlreadyInvalidatedError, type ApiProblemsData, type ApiProblemsError, type ApiProblemsResponse, type ApiRunData, type ApiRunError, type ApiRunResponse, type ArtifactDownloadRequest, type ArtifactDownloadResponse, type ArtifactNotFoundError, type ArtifactNotReleasedError, type ArtifactReleaseState, type ArtifactType, type AtCapacityError, type AuditEventEntry, type AuditEventsResponse, type BanMinerData, type BanMinerError, type BanMinerResponse, type BanRequest, type BanResponse, type BanValidatorData, type BanValidatorError, type BanValidatorResponse, type BittensorAuthConfig, type Body_submit_agent, type CachedSession, type CancelAgentVersionData, type CancelAgentVersionError, type CancelAgentVersionResponse, type CancelRequest, type CancelResponse, type ChallengeRequest, type ChallengeResponse, type ChutesAuthStatusResponse, type ClaimWorkData, type ClaimWorkError, type ClaimWorkResponse, type ClaimWorkResponse2, type ClearCooldownResponse, type ClearMinerCooldownData, type ClearMinerCooldownError, type ClearMinerCooldownResponse, type ClearRaceSelectionError, type ClearRaceSelectionResponse, type CloseQualifyingError, type CloseQualifyingResponse, type CloseQualifyingResponse2, type CodeAnalysisError, type CompleteRunData, type CompleteRunError, type CompleteRunRequest, type CompleteRunResponse, type CompleteRunResponse2, type CooldownActiveError, type CreateSessionEndpointData, type CreateSessionEndpointError, type CreateSessionEndpointResponse, type CreateSuiteData, type CreateSuiteError, type CreateSuiteRequest, type CreateSuiteResponse, type CreateSuiteResponse2, type CurrentRacesResponse, type DeepHealthCheckError, type DeepHealthCheckResponse, type DeleteInferenceCredentialData, type DeleteInferenceCredentialError, type DeleteInferenceCredentialResponse, type DiscardAgentVersionData, type DiscardAgentVersionError, type DiscardAgentVersionResponse, type DiscardRequest, type DiscardResponse, type EliminateAgentVersionData, type EliminateAgentVersionError, type EliminateAgentVersionResponse, type EliminateRequest, type EliminateResponse, type EpochStandings, type ErrorCategory, type EvalRunNotFoundError, type EvaluationPhase, type EvaluationRunDetail, type EvaluationRunPublic, type EvaluationRunStatus, type EvaluationRunStatusPublic, type ExchangeChutesCodeData, type ExchangeChutesCodeError, type ExchangeChutesCodeRequest, type ExchangeChutesCodeResponse, type ExchangeChutesCodeResponse2, type FileTooLargeError, type GetAgentVersionCodeData, type GetAgentVersionCodeError, type GetAgentVersionCodeResponse, type GetAgentVersionData, type GetAgentVersionError, type GetAgentVersionProblemsData, type GetAgentVersionProblemsError, type GetAgentVersionProblemsResponse, type GetAgentVersionResponse, type GetAgentVersionRunsData, type GetAgentVersionRunsError, type GetAgentVersionRunsResponse, type GetAgentVersionStatusData, type GetAgentVersionStatusError, type GetAgentVersionStatusResponse, type GetAgentVersionVarianceData, type GetAgentVersionVarianceError, type GetAgentVersionVarianceResponse, type GetArtifactDownloadUrlData, type GetArtifactDownloadUrlError, type GetArtifactDownloadUrlResponse, type GetAuditEventsData, type GetAuditEventsError, type GetAuditEventsResponse, type GetChutesAuthStatusError, type GetChutesAuthStatusResponse, type GetCurrentRaceError, type GetCurrentRaceResponse, type GetCurrentRacesError, type GetCurrentRacesResponse, type GetCurrentSuiteError, type GetCurrentSuiteResponse, type GetEvaluationRunData, type GetEvaluationRunError, type GetEvaluationRunResponse, type GetInferenceAuthStatusOneData, type GetInferenceAuthStatusOneError, type GetInferenceAuthStatusOneResponse, type GetInferenceModelsData, type GetInferenceModelsError, type GetInferenceModelsResponse, type GetLeaderboardData, type GetLeaderboardError, type GetLeaderboardResponse, type GetOwnedAgentVersionStatusData, type GetOwnedAgentVersionStatusError, type GetOwnedAgentVersionStatusResponse, type GetPendingEvaluationsData, type GetPendingEvaluationsError, type GetPendingEvaluationsResponse, type GetRaceDetailData, type GetRaceDetailError, type GetRaceDetailResponse, type GetRaceDiagnosticsData, type GetRaceDiagnosticsError, type GetRaceDiagnosticsResponse, type GetRaceHistoryData, type GetRaceHistoryError, type GetRaceHistoryResponse, type GetRaceValidatorVarianceData, type GetRaceValidatorVarianceError, type GetRaceValidatorVarianceResponse, type GetReaperStatsError, type GetReaperStatsResponse, type GetRunProblemsData, type GetRunProblemsError, type GetRunProblemsResponse, type GetRunningEvaluationsError, type GetRunningEvaluationsResponse, type GetSuiteProblemsData, type GetSuiteProblemsError, type GetSuiteProblemsResponse, type GetTopAgentError, type GetTopAgentResponse, type GetTopHistoryData, type GetTopHistoryError, type GetTopHistoryResponse, type GetTopMinerPayoutError, type GetTopMinerPayoutResponse, type GetValidatorFailuresData, type GetValidatorFailuresError, type GetValidatorFailuresResponse, type GetValidatorPauseError, type GetValidatorPauseResponse, type GetValidatorResourceSamplesData, type GetValidatorResourceSamplesError, type GetValidatorResourceSamplesResponse, type GetValidatorScoresData, type GetValidatorScoresError, type GetValidatorScoresResponse, type GetValidatorsError, type GetValidatorsResponse, type GetWeightSaltError, type GetWeightSaltResponse, type HTTPValidationError, type HealthCheckError, type HealthCheckResponse, type HeartbeatData, type HeartbeatError, type HeartbeatRequest, type HeartbeatResponse, type HeartbeatResponse2, type InferenceAuthListResponse, type InferenceAuthStatusResponse, type InferenceModelsResponse, type InferenceTokenGrant, type InvalidAgentNameError, type InvalidArtifactTypeError, type InvalidFileError, type InvalidProblemIdError, type InvalidateEvaluationRunData, type InvalidateEvaluationRunError, type InvalidateEvaluationRunResponse, type InvalidateRunRequest, type JoinWaitlistData, type JoinWaitlistError, type JoinWaitlistResponse, type LeaderboardEntry, type LeaderboardResponse, type LeaseExpiredError, type ListAgentVersions1Data, type ListAgentVersions1Error, type ListAgentVersions1Response, type ListAgentVersionsData, type ListAgentVersionsError, type ListAgentVersionsResponse, type ListEvaluationRunsData, type ListEvaluationRunsError, type ListEvaluationRunsResponse, type ListInferenceAuthError, type ListInferenceAuthResponse, type ListMinerAgentsError, type ListMinerAgentsResponse, type ListMinersData, type ListMinersError, type ListMinersResponse, type ListSuitesError, type ListSuitesResponse, type ListValidatorsData, type ListValidatorsError, type ListValidatorsResponse, type LogoutData, type LogoutError, type LogoutResponse, type LogoutResponse2, type MinerAgentsResponse, type MinerNotFoundError, type MinerRaceSelectionRequest, type MissingParameterError, type MissingScoreError, type NoActiveSuiteError, type NoSelectionError, type NotRunOwnerError, type NotVersionOwnerError, type OroErrorCode, type PendingEvaluation, type PendingEvaluationSummary, type PendingEvaluationsResponse, type PinnedFinisher, type PooledWindowRace, type PostValidatorPauseData, type PostValidatorPauseError, type PostValidatorPauseResponse, type PostValidatorResumeData, type PostValidatorResumeError, type PostValidatorResumeResponse, type PresignUploadData, type PresignUploadError, type PresignUploadRequest, type PresignUploadResponse, type PresignUploadResponse2, type ProblemNotFoundError, type ProblemProgressEntry, type ProblemProgressUpdate, type ProblemPublic, type ProblemStatus, type ProgressUpdateRequest, type ProgressUpdateResponse, type RaceCurrentResponse, type RaceDetailResponse, type RaceDiagnosticsResponse, type RaceHistoryResponse, type RaceInFlightError, type RaceLockedError, type RaceNotFoundError, type RacePublic, type RaceQualifierEntry, type RaceQualifierPublic, type RaceSummary, type RaceValidatorVarianceResponse, type RaceWorkItemEntry, type RankedInferenceModel, type RankedInferenceModelsResponse, type RateLimitExceededError, type ReaperStatsResponse, type ReevaluateAgentVersionData, type ReevaluateAgentVersionError, type ReevaluateAgentVersionResponse, type ReevaluateRequest, type ReevaluateResponse, type ReinstateAgentVersionData, type ReinstateAgentVersionError, type ReinstateAgentVersionResponse, type ReinstateEliminationData, type ReinstateEliminationError, type ReinstateEliminationRequest, type ReinstateEliminationResponse, type ReinstateEliminationResponse2, type ReinstateRequest, type RequestChallengeData, type RequestChallengeError, type RequestChallengeResponse, type RetryConfig, type RetryContext, type RunAlreadyCompleteError, type RunProblemsResponse, type RunningEvaluation, type ScoreBelowThresholdError, type SessionAuthConfig, SessionAuthManager, type SessionInfo, type SessionRequest, type SessionResponse, type SetDefaultInferenceProviderData, type SetDefaultInferenceProviderError, type SetDefaultInferenceProviderResponse, type SetDefaultProviderRequest, type SetRaceSelectionData, type SetRaceSelectionError, type SetRaceSelectionResponse, type SetTopAgentData, type SetTopAgentError, type SetTopAgentResponse, type SetTopRequest, type SetTopResponse, type SimilarityCheckUnavailableError, type SpreadBucket, type StoreChutesTokenData, type StoreChutesTokenError, type StoreChutesTokenRequest, type StoreChutesTokenResponse, type StoreInferenceCredentialData, type StoreInferenceCredentialError, type StoreInferenceCredentialRequest, type StoreInferenceCredentialResponse, type SubmitAgentData, type SubmitAgentError, type SubmitAgentResponse, type SubmitAgentResponse2, type SuiteNotFoundError, type SuitePublic, type SuiteWithProblemsResponse, type TerminalStatus, type TopAgentResponse, type TopHistoryEntry, type TopHistoryResponse, type TopMinerPayoutResponse, type UnbanMinerData, type UnbanMinerError, type UnbanMinerResponse, type UnbanValidatorData, type UnbanValidatorError, type UnbanValidatorResponse, type UpdateProgressData, type UpdateProgressError, type UpdateProgressResponse, type UpdateValidatorData, type UpdateValidatorError, type UpdateValidatorRequest, type UpdateValidatorResponse, type ValidationError, type ValidationErrorError, type ValidatorCurrentAgent, type ValidatorFailureEntry, type ValidatorFailuresResponse, type ValidatorNotFoundError, type ValidatorPauseRequest, type ValidatorPauseStatus, type ValidatorProblemResult, type ValidatorPublic, type ValidatorResourceSampleEntry, type ValidatorResourceSamplesResponse, type ValidatorResumeRequest, type ValidatorScoreSummary, type ValidatorScoresResponse, type ValidatorStatus, type ValidatorVarianceEntry, type WaitlistSignupRequest, type WaitlistSignupResponse, type WeightSaltResponse, type WorkItemStatus, activateSuite, apiProblems, apiRun, banMiner, banValidator, cancelAgentVersion, claimWork, classifyError, classifyStatus, clearMinerCooldown, clearRaceSelection, client, closeQualifying, completeRun, computeDelay, configureBittensorAuth, configurePublicClient, configureSessionAuth, createRetryFetch, createSessionEndpoint, createSuite, deepHealthCheck, deleteInferenceCredential, discardAgentVersion, eliminateAgentVersion, exchangeChutesCode, generateAuthHeaders, getAgentVersion, getAgentVersionCode, getAgentVersionProblems, getAgentVersionRuns, getAgentVersionStatus, getAgentVersionVariance, getArtifactDownloadUrl, getAuditEvents, getChutesAuthStatus, getCurrentRace, getCurrentRaces, getCurrentSuite, getErrorCode, getErrorDetail, getEvaluationRun, getInferenceAuthStatusOne, getInferenceModels, getLeaderboard, getOwnedAgentVersionStatus, getPendingEvaluations, getRaceDetail, getRaceDiagnostics, getRaceHistory, getRaceValidatorVariance, getReaperStats, getRunProblems, getRunningEvaluations, getSuiteProblems, getTopAgent, getTopHistory, getTopMinerPayout, getValidatorFailures, getValidatorPause, getValidatorResourceSamples, getValidatorScores, getValidators, getWeightSalt, hasDetail, hasErrorCode, healthCheck, heartbeat, invalidateEvaluationRun, isTransient, isTransientError, joinWaitlist, listAgentVersions, listAgentVersions1, listEvaluationRuns, listInferenceAuth, listMinerAgents, listMiners, listSuites, listValidators, logout, parseRetryAfter, postValidatorPause, postValidatorResume, presignUpload, type provider, reevaluateAgentVersion, reinstateAgentVersion, reinstateElimination, requestChallenge, setDefaultInferenceProvider, setRaceSelection, setTopAgent, storeChutesToken, storeInferenceCredential, submitAgent, unbanMiner, unbanValidator, updateProgress, updateValidator };