import type { CodeTestCase, TestOptions, EvalResult, HookFn, RegisteredHook } from './types.js';
/** @internal */
export declare function _resetExperimentalWarning(): void;
export declare function setActiveFile(filePath: string): void;
/**
 * Register a code-based test case.
 *
 * Two valid signatures (Playwright-style):
 * - `test(name, body)` — no options at all
 * - `test(name, options, body)` — with options
 *
 * Only `name` is required. All TestOptions fields are optional. When
 * `options.prompt` is absent, the runner skips agent invocation and the
 * body receives an empty EvalResult.
 *
 * Throws if a test with the same name is already registered in the same
 * source file. Cross-file duplicates are allowed (storage identity is
 * `name + sourceFile`).
 *
 * @experimental The SDK shape (signature, options, body fixtures) may change
 * in a minor release without a deprecation cycle. See `lib/index.ts`.
 */
export declare function test(name: string, body: (result: EvalResult) => Promise<void> | void): void;
export declare function test(name: string, options: TestOptions, body: (result: EvalResult) => Promise<void> | void): void;
/**
 * Group tests under a benchmark name. Equivalent to Playwright's
 * `describe()` — the wrapped `test()` calls inherit the describe's name as
 * their benchmark group. Nested describes flatten with ' > '.
 *
 * @example
 *   describe('RCA Suite', () => {
 *     test('payment-service is the root cause', { prompt: ... }, async ({ result, judge }) => {
 *       expect(result.trajectory).to.haveCalledTool('search_logs');
 *       await judge(result, 'identifies the failing dependency');
 *     });
 *   });
 *
 * The describe body MUST be synchronous (no `await`/dynamic content), like
 * Playwright. The function is invoked once at registration time.
 */
export declare function describe(name: string, fn: () => void): void;
export declare function getRegisteredTests(filePath?: string): CodeTestCase[];
/**
 * Return all hooks registered for the given file (or every file when no
 * argument is given). Returns a snapshot — mutating the result has no
 * effect on the registry.
 */
export declare function getRegisteredHooks(filePath?: string): RegisteredHook[];
export declare function clearRegistry(filePath?: string): void;
/**
 * Register a hook that runs **once** before the first test in its scope.
 *
 * Scope is the surrounding `describe(...)` block, or the whole file when
 * called at the top level. With parallel test execution (the runner
 * dispatches up to `concurrency` tests at once), the orchestrator uses a
 * once-latch so all parallel arrivals await the same `beforeAll` promise.
 *
 * @example
 *   beforeAll(async () => {
 *     await fs.mkdir('/tmp/agent-health-fixtures', { recursive: true });
 *   });
 */
export declare function beforeAll(fn: HookFn): void;
/**
 * Register a hook that runs **once** after the last test in its scope.
 *
 * Always runs, even when every test in the scope failed. The orchestrator
 * uses a remaining-test counter (decremented on each test completion,
 * regardless of pass/fail) and triggers `afterAll` when it hits zero.
 *
 * @example
 *   afterAll(async () => {
 *     await fs.rm('/tmp/agent-health-fixtures', { recursive: true });
 *   });
 */
export declare function afterAll(fn: HookFn): void;
/**
 * Register a hook that runs **before each test** in its scope.
 *
 * Receives the same fixtures object the body will see, plus a
 * `provide(key, value)` function for stashing values that the test body
 * (and `afterEach`) can read via `fixtures.provisioned[key]`. Each test
 * gets its own provisioned bag, so concurrent tests are isolated.
 *
 * @example
 *   beforeEach(async ({ provide, testInfo }) => {
 *     const dir = await fs.mkdtemp(`/tmp/${testInfo.name}-`);
 *     provide('workspaceDir', dir);
 *   });
 */
export declare function beforeEach(fn: HookFn): void;
/**
 * Register a hook that runs **after each test** in its scope.
 *
 * Always runs, even when the test body or a `beforeEach` threw. Reads
 * provisioned values via `fixtures.provisioned[key]` for cleanup. Errors
 * thrown from `afterEach` are captured as MatcherResult entries on the
 * test — they don't crash the runner.
 *
 * @example
 *   afterEach(async ({ provisioned }) => {
 *     if (provisioned.workspaceDir) {
 *       await fs.rm(provisioned.workspaceDir as string, { recursive: true, force: true });
 *     }
 *   });
 */
export declare function afterEach(fn: HookFn): void;
export declare namespace test {
    const beforeAll: (fn: HookFn) => void;
    const afterAll: (fn: HookFn) => void;
    const beforeEach: (fn: HookFn) => void;
    const afterEach: (fn: HookFn) => void;
}
//# sourceMappingURL=define.d.ts.map