import { APIResource } from "../core/resource.js";
import * as Shared from "./shared.js";
import * as CompletionsAPI from "./chat/completions.js";
import * as EvaluationsAPI from "./evaluations/evaluations.js";
import { APIPromise } from "../core/api-promise.js";
import { CursorPage, type CursorPageParams, PagePromise } from "../core/pagination.js";
import { RequestOptions } from "../internal/request-options.js";
export declare class EvaluationItems extends APIResource {
    /**
     * Retrieve a single evaluation item by its ID within the caller's account.
     *
     * By default only non-archived items are returned; pass `include_archived=true` to
     * also retrieve an item that has been archived. The response merges the item's
     * cached task results into its `data` field and exposes a `task_errors` map keyed
     * by task alias, so a task that failed on this item surfaces as an entry there
     * rather than as a request error. Use this to inspect one item's input data and
     * per-task results; to page through many items, use the list endpoint instead. The
     * request fails if no item with the given ID exists in the caller's account.
     */
    retrieve(evaluationItemID: string, query?: EvaluationItemRetrieveParams | null | undefined, options?: RequestOptions): APIPromise<EvaluationItem>;
    /**
     * Return a paginated list of evaluation items belonging to the caller's account.
     *
     * Pass `evaluation_id` to restrict the results to a single evaluation's items. The
     * `completion_status` filter selects items by whether any of their tasks errored:
     * `failed` returns only items that have task errors, `passed` returns only items
     * with no task errors, and `all` (or omitting the parameter) returns every item.
     * Archived items are excluded unless `include_archived=true`. Each returned item
     * has its cached task results merged into `data` and its errors exposed in
     * `task_errors`, identically to the single-item endpoint.
     */
    list(query?: EvaluationItemListParams | null | undefined, options?: RequestOptions): PagePromise<EvaluationItemsCursorPage, EvaluationItem>;
    /**
     * Export all evaluation items for a single evaluation as a downloadable file.
     *
     * The evaluation is specified by `evaluation_id` in the request body.
     * `export_format` selects CSV, JSON, or JSONL; for CSV the per-item `data` and
     * `files` fields are flattened into individual columns and metric-like result
     * columns are expanded. `export_method` controls delivery: `direct` returns the
     * file contents inline in the response, while `signed_url` uploads the file to
     * object storage and returns a pre-signed download URL. Requesting `signed_url` in
     * an environment where object storage is not configured fails with a 501, so use
     * `direct` there instead. Set `include_archived=true` to include archived items in
     * the export. This endpoint reads items only and does not modify the evaluation.
     */
    export(body: EvaluationItemExportParams, options?: RequestOptions): APIPromise<EvaluationItemExport>;
}
export type EvaluationItemsCursorPage = CursorPage<EvaluationItem>;
export interface Component {
    /**
     * A pointer to the data in each evaluation item to be displayed within the
     * component
     */
    data: EvaluationsAPI.ItemLocator;
    label?: string;
}
export interface Container {
    /**
     * The children to be displayed within the container
     */
    children: Array<Container | Component>;
    /**
     * The axis that children are placed in the container. Based on CSS
     * `flex-direction` (see:
     * https://developer.mozilla.org/en-US/docs/Web/CSS/flex-direction)
     */
    direction?: 'row' | 'column';
}
export interface EvaluationItem {
    /**
     * The unique identifier of the entity.
     */
    id: string;
    /**
     * The date and time when the entity was created in ISO format.
     */
    created_at: string;
    /**
     * The identity that created the entity.
     */
    created_by: Shared.Identity;
    data: {
        [key: string]: unknown;
    };
    evaluation_id: string;
    /**
     * The date and time when the entity was archived in ISO format.
     */
    archived_at?: string;
    dataset_item_id?: string;
    dataset_item_version_num?: number;
    files?: {
        [key: string]: string;
    };
    object?: 'evaluation.item';
    /**
     * Map of task alias to error info.
     */
    task_errors?: {
        [key: string]: TaskError;
    };
    /**
     * Per-alias task-result lifecycle status derived from `task_result_cache`. Present
     * when at least one alias has a recorded status; `null` for legacy rows with an
     * empty cache. Renderers use this to distinguish `prefilled` from `completed` on
     * the wire (values themselves are already merged into `data` by
     * `merge_task_result_cache_into_data`).
     */
    task_result_statuses?: {
        [key: string]: 'completed' | 'skipped' | 'errored' | 'pending' | 'prefilled';
    };
}
/**
 * Response model for exporting evaluation items. This class represents the
 * response when users export evaluation items. It contains either a signed URL to
 * download the exported data from object storage, or the actual content bytes when
 * direct download is used (in environments where object storage is not
 * configured).
 */
export interface EvaluationItemExport {
    /**
     * The name of the exported file
     */
    filename: string;
    /**
     * The raw file content as bytes, used when direct download is enabled
     */
    content?: string;
    /**
     * Pre-signed URL to download the file from object storage, if applicable
     */
    signed_url?: string;
}
export type ExportFormat = 'json' | 'jsonl' | 'csv';
export type ExportMethod = 'signed_url' | 'direct';
export interface TaskError {
    /**
     * Error message
     */
    message: string;
    /**
     * Error type/category
     */
    type: string;
}
export interface EvaluationItemRetrieveParams {
    include_archived?: boolean;
}
export interface EvaluationItemListParams extends CursorPageParams {
    /**
     * Filter items by completion status. Pass 'failed' to return only items with
     * errors, 'passed' for items without errors. Pass 'all' or omit to return all
     * items.
     */
    completion_status?: 'failed' | 'passed' | 'all';
    evaluation_id?: string;
    include_archived?: boolean;
    sort_by?: string;
    sort_order?: CompletionsAPI.SortOrder;
}
export interface EvaluationItemExportParams {
    /**
     * The ID of the evaluation to export items from.
     */
    evaluation_id: string;
    /**
     * The format of the exported evaluation items. `json` returns a single JSON array,
     * while `jsonl` returns one JSON object per line.
     */
    export_format?: ExportFormat;
    /**
     * The method for exporting evaluation items. `signed_url` returns a pre-signed
     * URL, while `direct` returns the raw content.
     */
    export_method?: ExportMethod;
    /**
     * If true, include archived evaluation items in the export.
     */
    include_archived?: boolean;
}
export declare namespace EvaluationItems {
    export { type Component as Component, type Container as Container, type EvaluationItem as EvaluationItem, type EvaluationItemExport as EvaluationItemExport, type ExportFormat as ExportFormat, type ExportMethod as ExportMethod, type TaskError as TaskError, type EvaluationItemsCursorPage as EvaluationItemsCursorPage, type EvaluationItemRetrieveParams as EvaluationItemRetrieveParams, type EvaluationItemListParams as EvaluationItemListParams, type EvaluationItemExportParams as EvaluationItemExportParams, };
}
//# sourceMappingURL=evaluation-items.d.ts.map