import type { TestCase, TestCaseVersion, AgentContextItem, AgentToolDefinition } from '../../types/index.js';
export interface CreateTestCaseInput {
    /** Optional ID - if provided, will be used instead of generating a new one (useful for migration) */
    id?: string;
    name: string;
    description?: string;
    labels?: string[];
    /** @deprecated Use labels instead */
    category?: string;
    /** @deprecated Use labels instead */
    subcategory?: string;
    /** @deprecated Use labels instead */
    difficulty?: 'Easy' | 'Medium' | 'Hard';
    initialPrompt: string;
    context: AgentContextItem[];
    tools?: AgentToolDefinition[];
    expectedPPL?: string;
    expectedOutcomes?: string[];
    expectedTrajectory?: {
        step: number;
        description: string;
        requiredTools: string[];
    }[];
    followUpQuestions?: {
        trigger: 'results_available' | 'error' | 'always';
        question: string;
        businessValue: string;
    }[];
    tags?: string[];
    author?: string;
    isPromoted?: boolean;
}
export interface UpdateTestCaseInput {
    name?: string;
    description?: string;
    labels?: string[];
    /** @deprecated Use labels instead */
    category?: string;
    /** @deprecated Use labels instead */
    subcategory?: string;
    /** @deprecated Use labels instead */
    difficulty?: 'Easy' | 'Medium' | 'Hard';
    initialPrompt?: string;
    context?: AgentContextItem[];
    tools?: AgentToolDefinition[];
    expectedPPL?: string;
    expectedOutcomes?: string[];
    expectedTrajectory?: {
        step: number;
        description: string;
        requiredTools: string[];
    }[];
    followUpQuestions?: {
        trigger: 'results_available' | 'error' | 'always';
        question: string;
        businessValue: string;
    }[];
    tags?: string[];
    isPromoted?: boolean;
}
/** Paginated response from getAll with summary/pagination options */
export interface TestCasePage {
    testCases: TestCase[];
    total: number;
    after?: string | null;
    hasMore?: boolean;
}
declare class AsyncTestCaseStorage {
    /**
     * Get all test cases (latest versions), sorted by updatedAt descending
     * @param options.summary - true to fetch lightweight summary (no context/expectedOutcomes)
     * @param options.size - page size for pagination
     * @param options.after - cursor token for next page
     * @param options.includeSample - whether to include sample/demo data
     */
    getAll(options: {
        summary?: boolean;
        size: number;
        after?: string;
        includeSample?: boolean;
    }): Promise<TestCasePage>;
    getAll(options?: {
        summary?: boolean;
        size?: number;
        after?: string;
        includeSample?: boolean;
    }): Promise<TestCase[]>;
    /**
     * Get only promoted test cases (for Experiments)
     */
    getPromoted(): Promise<TestCase[]>;
    /**
     * Get test cases by specific IDs (for efficient filtered fetching)
     * Used when you only need test cases for a specific benchmark, or for a
     * name/labels/category lookup scoped to a known id set — e.g. the
     * comparison page's category-matrix breakdown, which used to call the
     * unpaginated {@link getAll} for this (every test case in the whole
     * storage backend, full body included) and could take many seconds or
     * fail outright on a real deployment. Chunked the same way
     * asyncRunStorage.getReportsByIds is — never one unbounded `?ids=<all>`
     * request, never an unbounded burst of parallel ones either — so a
     * lookup over many runs' worth of test cases stays bounded regardless of
     * how large the id list is.
     * @param options.summary - request the lightweight list-view payload
     *   (strips sourceCode/context/expectedOutcomes) instead of full records.
     */
    getByIds(ids: string[], options?: {
        summary?: boolean;
    }): Promise<TestCase[]>;
    /**
     * Get a test case by ID (latest version)
     */
    getById(id: string): Promise<TestCase | null>;
    /**
     * Create a new test case
     */
    create(input: CreateTestCaseInput): Promise<TestCase>;
    /**
     * Update a test case (creates new version automatically in OpenSearch)
     */
    update(id: string, updates: UpdateTestCaseInput): Promise<TestCase | null>;
    /**
     * Delete a test case (all versions)
     */
    delete(id: string): Promise<boolean>;
    /**
     * Set promoted status for a test case
     */
    setPromoted(id: string, isPromoted: boolean): Promise<boolean>;
    /**
     * Get all versions of a test case
     */
    getVersions(testCaseId: string): Promise<TestCaseVersion[]>;
    /**
     * Get a specific version of a test case
     */
    getVersion(testCaseId: string, version: number): Promise<TestCaseVersion | null>;
    /**
     * Generate a unique ID
     */
    generateId(): string;
    /**
     * Get unique categories from all test cases
     * @deprecated Use getLabels() instead
     */
    getCategories(): Promise<string[]>;
    /**
     * Get all unique labels from all test cases
     */
    getLabels(): Promise<string[]>;
    /**
     * Get test cases count
     */
    getCount(): Promise<number>;
    /**
     * Get promoted count
     */
    getPromotedCount(): Promise<number>;
    /**
     * Bulk create test cases (for migration)
     */
    bulkCreate(testCases: CreateTestCaseInput[]): Promise<{
        created: number;
        errors: number;
        testCases: TestCase[];
    }>;
}
export declare const asyncTestCaseStorage: AsyncTestCaseStorage;
export {};
//# sourceMappingURL=asyncTestCaseStorage.d.ts.map