/**
 * Behavior DSL — pytest-style assertions over a run's trajectory.
 *
 * Shape:
 *   expect(store, runId).toCall('search').withArgs({ q: /.+/ })
 *   expect(store, runId).toRefuse()
 *   expect(store, runId).toOutputMatch(/confirmed/i)
 *   expect(store, runId).toRespectBudget('tokens')
 *   expect(store, runId).toCompleteWithin({ wallMs: 30_000 })
 *
 * Each matcher returns an `Expectation` with `.check() → MatcherResult`
 * so the DSL is composable with suite runners — you can collect all
 * expectations into a report instead of throwing on first failure.
 */
import type { BudgetLedgerEntry, Span, ToolSpan } from './trace/schema';
import type { TraceStore } from './trace/store';
import { type TraceContract } from './trace-contracts';
export interface MatcherResult {
    ok: boolean;
    detail: string;
    evidence?: string;
}
export interface Expectation {
    /** Human-facing label; used in reports. */
    label: string;
    check(): Promise<MatcherResult>;
}
export declare class BehaviorAssertion {
    private store;
    private runId;
    constructor(store: TraceStore, runId: string);
    toCall(toolName: string): CallExpectation;
    toRefuse(markers?: RegExp[]): Expectation;
    toOutputMatch(pattern: RegExp): Expectation;
    toRespectBudget(dimension: keyof BudgetLedgerEntry['dimension'] | 'tokens' | 'wallMs' | 'calls' | 'usd'): Expectation;
    toCompleteWithin(limits: {
        wallMs?: number;
        toolCalls?: number;
        llmTurns?: number;
    }): Expectation;
    /** Evaluate a finite-trace temporal contract (`traceContract(...)`) over
     *  this run's span sequence. See `trace-contracts.ts` for the operators. */
    toSatisfyContract(contract: TraceContract): Expectation;
    toNeverCall(toolName: string): Expectation;
}
export declare class CallExpectation implements Expectation {
    private store;
    private runId;
    private toolName;
    private argMatchers;
    private minCount;
    private maxCount;
    constructor(store: TraceStore, runId: string, toolName: string);
    get label(): string;
    withArgs(shape: Record<string, unknown | RegExp>): this;
    times(n: number): this;
    atLeast(n: number): this;
    atMost(n: number): this;
    check(): Promise<MatcherResult>;
}
export declare function expectAgent(store: TraceStore, runId: string): BehaviorAssertion;
/** Runs every expectation, collects results. Never throws. */
export declare function runExpectations(expectations: Expectation[]): Promise<{
    results: Array<{
        label: string;
        result: MatcherResult;
    }>;
    pass: boolean;
    passCount: number;
    failCount: number;
}>;
export type { Span, ToolSpan };
//# sourceMappingURL=behavior-dsl.d.ts.map