import { EventEmitter } from "eventemitter3";
import type { ReqFilter, TaggedNostrEvent } from ".";
import { NoteCollection } from "./note-collection";
import type { RequestBuilder } from "./request-builder";
export declare enum QueryTraceState {
    NEW = "NEW",// New state, not used trace
    QUEUED = "QUEUED",// When first created
    WAITING = "WAITING",// Waiting for relay response (sent REQ to relay, will close on EOSE)
    WAITING_STREAM = "WAITING_STREAM",// Streaming (sent REQ to relay, will stay open after EOSE)
    SYNC_WAITING = "SYNC_WAITING",// Waiting for SYNC response (sent NEG-OPEN)
    SYNC_FALLBACK = "SYNC_FALLBACK",// SYNC not supported, falling back to REQ
    EOSE = "EOSE",// Server told us there are no more results
    LOCAL_CLOSE = "LOCAL_CLOSE",// We sent close to server
    REMOTE_CLOSE = "REMOTE_CLOSE",// Server closed the request
    DROP = "DROP",// Dropped due to disconnect
    TIMEOUT = "TIMEOUT"
}
export interface QueryTraceEvent {
    id: string;
    relay: string;
    connId: string;
    state: QueryTraceState;
    timestamp: number;
    filters: Array<ReqFilter>;
}
interface QueryTraceEvents {
    stateChange: (event: QueryTraceEvent) => void;
}
/**
 * Tracing for relay query status - pure state machine
 */
export declare class QueryTrace extends EventEmitter<QueryTraceEvents> {
    #private;
    readonly relay: string;
    readonly connId: string;
    readonly leaveOpen: boolean;
    readonly id: string;
    readonly createdAt: number;
    filters: Array<ReqFilter>;
    constructor(relay: string, filters: Array<ReqFilter>, connId: string, leaveOpen: boolean);
    get currentState(): QueryTraceState;
    queued(): void;
    sent(): void;
    sentSync(): void;
    syncFallback(): void;
    eose(): void;
    remoteClosed(): void;
    close(): void;
    drop(): void;
    timeout(): void;
    /**
     * If tracing is finished
     */
    get finished(): boolean;
}
export interface QueryEvents {
    trace: (event: QueryTraceEvent) => void;
    request: (subId: string, req: Array<ReqFilter>) => void;
    event: (evs: Array<TaggedNostrEvent>) => void;
    /**
     * Emitted when the query will be removed
     */
    end: () => void;
    /**
     * Emitted when the query has either been EOSE / CLOSED / TIMEOUT
     */
    eose: () => void;
}
/**
 * Active query - collects events and tracks traces
 */
export declare class Query extends EventEmitter<QueryEvents> {
    #private;
    id: string;
    /**
     * RequestBuilder instance
     */
    requests: Array<ReqFilter>;
    /**
     * Skip cache layer
     */
    skipCache: boolean;
    /**
     * Use sync module for this query
     */
    useSyncModule: boolean;
    constructor(req: RequestBuilder);
    /**
     * Adds another request to this one
     */
    addRequest(req: RequestBuilder): boolean | undefined;
    isOpen(): boolean;
    canRemove(): boolean;
    /**
     * Recompute the complete set of compressed filters from all query traces
     */
    get filters(): ReqFilter[];
    get feed(): NoteCollection;
    get snapshot(): import("./note-collection").NoteStoreSnapshotData;
    get traces(): QueryTrace[];
    get leaveOpen(): boolean;
    /**
     * Flush any buffered data
     */
    flush(): void;
    /**
     * Add a trace to this query
     */
    addTrace(trace: QueryTrace): void;
    /**
     * Remove a trace from this query
     */
    removeTrace(traceId: string): void;
    /**
     * Add event to feed if it matches any trace filter
     */
    addEvent(sub: string, e: TaggedNostrEvent): void;
    /**
     * This function should be called when this Query object and FeedStore is no longer needed
     */
    cancel(): void;
    uncancel(): void;
    cleanup(): void;
    closeQuery(): void;
    /**
     * Get the progress to EOSE, can be used to determine when we should load more content
     */
    get progress(): number;
    /**
     * Wait for all traces to reach a finished state.
     * Returns a promise that resolves when all traces are finished.
     */
    waitFinished(): Promise<void>;
    /**
     * Start filter emit
     */
    start(): void;
}
export {};
//# sourceMappingURL=query.d.ts.map