import type { ChronicleEvent, ChronicleOutcome, ChronicleResourceRef } from './types.js';
export interface ChronicleQuery {
    eventId?: string;
    eventTypes?: string[];
    outcomes?: ChronicleOutcome[];
    from?: string;
    to?: string;
    projectId?: string;
    sessionId?: string;
    agentId?: string;
    taskId?: string;
    providerId?: string;
    modelId?: string;
    traceId?: string;
    logicalRequestId?: string;
    attemptId?: string;
    toolCallId?: string;
    resourceKind?: ChronicleResourceRef['kind'];
    resourceId?: string;
    path?: string;
    line?: number;
    tags?: Record<string, string>;
    attributes?: Record<string, unknown>;
    text?: string;
    order?: 'asc' | 'desc';
    limit?: number;
    cursor?: string;
}
export interface ChronicleQueryResult {
    events: ChronicleEvent[];
    total: number;
    nextCursor?: string;
    scannedEvents: number;
    sourceFiles: number;
    invalidLines: number;
    summary: ChronicleSummary;
}
/** Derived once from all matching events; never from the paginated UI sample. */
export interface ChronicleSummary {
    logicalRequests: number;
    modelAttempts: number;
    completedAttempts: number;
    failedAttempts: number;
    scheduledRetries: number;
    fallbacks: number;
    providers: number;
    models: number;
    inputTokens: number;
    outputTokens: number;
    cacheReadTokens: number;
    cacheWriteTokens: number;
    estimatedCostUsd: number;
    providerAvgDurationMs: number;
    providerP95DurationMs: number;
    toolCalls: number;
    completedTools: number;
    failedTools: number;
    toolAvgDurationMs: number;
    processes: number;
    failedProcesses: number;
    fileEvents: number;
    uniqueFiles: number;
    agentEvents: number;
    uniqueAgents: number;
    decisions: number;
    escalations: number;
    failures: number;
    cancellations: number;
    families: Record<ChronicleSignalFamily, number>;
    failuresByFamily: Record<ChronicleSignalFamily, number>;
}
export type ChronicleSignalFamily = 'llm' | 'agent' | 'tool' | 'file' | 'memory' | 'task' | 'decision' | 'runtime';
export type ChronicleFacet = 'eventType' | 'outcome' | 'projectId' | 'sessionId' | 'agentId' | 'taskId' | 'providerId' | 'modelId' | 'resourceKind' | 'resourcePath' | 'toolCallId';
export interface ChronicleFacetValue {
    value: string;
    count: number;
}
export type ChronicleFacetResults = Partial<Record<ChronicleFacet, ChronicleFacetValue[]>>;
/**
 * The complete set of valid {@link ChronicleFacet} values. Shared by both
 * the CLI-embedded and standalone WebUI message routers so they can validate
 * `chronicle.facet` / `chronicle.facets` payloads against a single source of
 * truth — if `ChronicleFacet` grows a member, this set is the only place
 * that needs updating.
 */
export declare const CHRONICLE_FACET_FIELDS: ReadonlySet<ChronicleFacet>;
export type ChronicleRelationKind = 'parent_span' | 'trace' | 'tool_call' | 'logical_request' | 'attempt' | 'decision' | 'network_request' | 'prompt_manifest' | 'resource_lineage';
export interface ChronicleGraphEdge {
    from: string;
    to: string;
    kind: ChronicleRelationKind;
    confidence: 'explicit' | 'correlated' | 'inferred';
}
export interface ChronicleGraphResult {
    nodes: ChronicleEvent[];
    edges: ChronicleGraphEdge[];
    truncated: boolean;
}
/** Queryable projection over immutable Chronicle JSONL partitions.
 *  Events are streamed on demand — no full-file load into memory. */
export declare class ChronicleQueryEngine {
    readonly diagnostics: {
        sourceFiles: number;
        invalidLines: number;
    };
    private readonly partitionFiles;
    private constructor();
    static fromDirectory(directory: string): Promise<ChronicleQueryEngine>;
    static fromFiles(files: string[]): Promise<ChronicleQueryEngine>;
    /** Stream all partitions, filter, and return the requested page + summary. */
    query(query?: ChronicleQuery): Promise<ChronicleQueryResult>;
    /** Stream all partitions once and compute value counts for every requested facet. */
    facets(fields: readonly ChronicleFacet[], query?: ChronicleQuery, limit?: number): Promise<ChronicleFacetResults>;
    /** Stream all partitions and compute one facet's value counts. */
    facet(field: ChronicleFacet, query?: ChronicleQuery, limit?: number): Promise<ChronicleFacetValue[]>;
    /** Expand explicit and typed correlation edges; temporal proximity alone never creates causality. */
    graph(seed?: ChronicleQuery, hops?: number, maxNodes?: number): Promise<ChronicleGraphResult>;
}
/** Recursively locate journal partition files under a Chronicle directory,
 *  ordered family-first then rotation index. Shared with the metrics store. */
export declare function findChroniclePartitions(root: string): Promise<string[]>;
//# sourceMappingURL=query.d.ts.map