import { type AbstractType } from "@dao-xyz/borsh";
import type { PeerId, TypedEventTarget } from "@libp2p/interface";
import type { Multiaddr } from "@multiformats/multiaddr";
import { type MaybePromise, PublicSignKey } from "@peerbit/crypto";
import * as types from "@peerbit/document-interface";
import { type QueryCacheOptions } from "@peerbit/indexer-cache";
import * as indexerTypes from "@peerbit/indexer-interface";
import { type Encoding, Entry } from "@peerbit/log";
import { Program } from "@peerbit/program";
import { RPC, type RPCRequestAllOptions } from "@peerbit/rpc";
import { type CoverRange, type ReplicationDomain, SharedLog } from "@peerbit/shared-log";
import { type PeerRefs } from "@peerbit/stream-interface";
import type { DocumentEvents, DocumentsChange } from "./events.js";
import type { QueryPredictor } from "./most-common-query-predictor.js";
import { type Operation } from "./operation.js";
import { Prefetch } from "./prefetch.js";
import type { ExtractArgs } from "./program.js";
export type UpdateMergeStrategy<T, I, Resolve extends boolean | undefined, _RT = ValueTypeFromRequest<Resolve, T, I>> = boolean | {
    filter?: (evt: DocumentsChange<T, I>) => MaybePromise<DocumentsChange<T, I> | void>;
};
export type UpdateReason = "initial" | "manual" | "join" | "change" | "push";
export type UpdateCallbacks<T, I, Resolve extends boolean | undefined, RT = ValueTypeFromRequest<Resolve, T, I>> = {
    /**
     * Fires whenever the iterator detects new work (e.g. push, join, change).
     * Ideal for reactive consumers that need to call `next()` or trigger UI work.
     */
    notify?: (reason: UpdateReason) => void | Promise<void>;
    /**
     * Fires whenever the iterator yields a batch to the consumer.
     * Good for external sync (e.g. React state).
     */
    onBatch?: (batch: RT[], meta: {
        reason: UpdateReason;
    }) => void | Promise<void>;
};
/**
 * Unified update options for iterate()/search()/get() and hooks.
 * If you pass `true`, defaults to `{ merge: "sorted" }`.
 */
export type UpdateModeShortcut = "local" | "remote" | "all";
export type UpdateOptions<T, I, Resolve extends boolean | undefined> = boolean | UpdateModeShortcut | ({
    /** Live update behavior. Only sorted merging is supported; optional filter can mutate/ignore events. */
    merge?: UpdateMergeStrategy<T, I, Resolve>;
    /** Request push-style notifications backed by the prefetch channel. */
    push?: boolean | types.PushUpdatesMode;
} & UpdateCallbacks<T, I, Resolve>);
export type JoiningTargets = {
    /** Specific peers you care about */
    peers?: Array<PublicSignKey | PeerId | string>;
    /** Multiaddrs you care about */
    multiaddrs?: (string | Multiaddr)[];
    /**
     * From the previous cover set (what you "knew" about earlier).
     * - "any": wait until at least 1 of the known peers is ready
     * - "all": wait until all known peers are ready
     * - number: wait until N known peers are ready
     */
    known?: "any" | "all" | number;
};
export type JoiningTimeoutPolicy = "proceed" | "error";
export type JoiningOnMissedResults = (evt: {
    /** How many items should have preceded the current frontier. */
    amount: number;
    /** The peer whose arrival triggered the gap calculation. */
    peer: PublicSignKey;
}) => void | Promise<void>;
export type OutOfOrderMode = "drop" | "queue";
export type LateResultsItem = {
    indexed: WithContext<any>;
    context: types.Context;
    from: PublicSignKey;
    value?: any;
};
export type LateResultsEvent<M extends OutOfOrderMode = "drop", Item = LateResultsItem> = {
    /** Count of items that should have appeared earlier than the current frontier */
    amount: number;
    /** If attributable, the peer that produced the late items */
    peer?: PublicSignKey;
} & (M extends "queue" ? {
    items: Item[];
} : {
    items?: undefined;
});
export type LateResultsHelpers<M extends OutOfOrderMode = "drop", Item = LateResultsItem> = {
    /** Collect concrete late items if available for the chosen mode */
    collect: () => Promise<M extends "queue" ? Item[] : Item[] | undefined>;
};
export type WaitBehavior = "block" | "keep-open";
export type WaitPolicy = {
    timeout: number;
    until?: "any";
    onTimeout?: "proceed" | "error";
    behavior?: WaitBehavior;
};
export type ReachScope = {
    /** who to consider for readiness */
    eager?: boolean;
    discover?: PublicSignKey[];
};
export type RemoteQueryOptions<Q, R, D> = RPCRequestAllOptions<Q, R> & {
    replicate?: boolean;
    minAge?: number;
    throwOnMissing?: boolean;
    retryMissingResponses?: boolean;
    strategy?: "fallback";
    domain?: {
        args: ExtractArgs<D>;
    } | {
        range: CoverRange<number | bigint>;
    };
    /** WHO can answer? How do we grow the candidate set? */
    reach?: ReachScope;
    /** WHEN are we allowed to proceed? Quorum semantics over a chosen group. */
    wait?: WaitPolicy;
};
export type QueryOptions<T, I, D, Resolve extends boolean | undefined> = {
    remote?: boolean | RemoteQueryOptions<types.AbstractSearchRequest, types.AbstractSearchResult, D>;
    local?: boolean;
    resolve?: Resolve;
    signal?: AbortSignal;
    updates?: UpdateOptions<T, I, Resolve>;
    outOfOrder?: {
        mode?: "drop";
        handle?: (evt: LateResultsEvent<"drop">, helpers: LateResultsHelpers<"drop">) => void | Promise<void>;
    } | {
        mode: "queue";
        handle?: (evt: LateResultsEvent<"queue">, helpers: LateResultsHelpers<"queue">) => void | Promise<void>;
    };
    /**
     * Controls iterator liveness after batches are consumed.
     * - 'onEmpty' (default): close when no more results
     * - 'manual': keep open until iterator.close() or program close; good for live updates
     */
    closePolicy?: "onEmpty" | "manual";
};
export type GetOptions<_T, _I, D, Resolve extends boolean | undefined> = {
    remote?: boolean | RemoteQueryOptions<types.AbstractSearchRequest, types.AbstractSearchResult, D>;
    local?: boolean;
    resolve?: Resolve;
    signal?: AbortSignal;
    waitFor?: number;
};
export type SearchOptions<T, I, D, Resolve extends boolean | undefined> = QueryOptions<T, I, D, Resolve>;
type Transformer<T, I> = (obj: T, context: types.Context) => MaybePromise<I>;
export type ResultsIterator<T> = {
    close: () => Promise<void>;
    next: (number: number) => Promise<T[]>;
    done: () => boolean;
    all: () => Promise<T[]>;
    pending: () => MaybePromise<number | undefined>;
    first: () => Promise<T | undefined>;
    [Symbol.asyncIterator]: () => AsyncIterator<T>;
};
type QueryLike = {
    query?: indexerTypes.Query[] | indexerTypes.QueryLike;
    sort?: indexerTypes.Sort[] | indexerTypes.Sort | indexerTypes.SortLike;
};
type ExtractResolveFromOptions<O> = O extends QueryOptions<any, any, any, infer X> ? X extends boolean ? X : true : true;
export type CanSearch = (request: types.SearchRequest | types.IterationRequest | types.CollectNextRequest, from: PublicSignKey) => Promise<boolean> | boolean;
export type CanRead<T> = (result: T, from: PublicSignKey) => Promise<boolean> | boolean;
export type CanReadIndexed<I> = (result: I, from: PublicSignKey) => Promise<boolean> | boolean;
export type WithContext<I> = {
    __context: types.Context;
} & I;
export declare const INDEX_CONTEXT_SHAPE: {
    readonly __context: {
        readonly created: true;
        readonly modified: true;
        readonly head: true;
        readonly gid: true;
        readonly size: true;
    };
};
export type IndexedContextOnly<I extends Record<string, any>> = indexerTypes.ReturnTypeFromShape<WithContext<I>, typeof INDEX_CONTEXT_SHAPE>;
export type WithIndexed<T, I> = {
    __indexed: I;
} & T;
export type WithIndexedContext<T, I> = WithContext<WithIndexed<T, I>>;
export type ValueTypeFromRequest<Resolve extends boolean | undefined, T, I> = Resolve extends false ? WithContext<I> : WithIndexedContext<T, I>;
export type TransformerAsConstructor<T, I> = {
    type?: new (arg: T, context: types.Context) => I;
};
export type TransformerAsFunction<T, I> = {
    type: AbstractType<I>;
    transform: (arg: T, context: types.Context) => I | Promise<I>;
};
export type TransformOptions<T, I> = TransformerAsConstructor<T, I> | TransformerAsFunction<T, I>;
export type PrefetchOptions = {
    predictor?: QueryPredictor;
    ttl: number;
    accumulator: Prefetch;
    strict?: boolean;
};
export type OpenOptions<T, I, D extends ReplicationDomain<any, Operation, any>> = {
    documentEvents: TypedEventTarget<DocumentEvents<T, I>>;
    documentType: AbstractType<T>;
    dbType: AbstractType<types.IDocumentStore<T>>;
    log: SharedLog<Operation, D, any>;
    canRead?: CanRead<I>;
    canSearch?: CanSearch;
    replicate: (request: types.SearchRequest | types.SearchRequestIndexed | types.IterationRequest, results: types.Results<types.ResultTypeFromRequest<types.SearchRequest | types.SearchRequestIndexed | types.IterationRequest, T, I>>) => Promise<void>;
    indexBy?: string | string[];
    transform?: TransformOptions<T, I>;
    cache?: {
        resolver?: number;
        query?: QueryCacheOptions;
    };
    compatibility: 6 | 7 | 8 | 9 | undefined;
    maybeOpen: (value: T & Program) => Promise<T & Program>;
    prefetch?: boolean | Partial<PrefetchOptions>;
    includeIndexed?: boolean;
};
type IndexableClass<I> = new (value: I, context: types.Context) => WithContext<I>;
export declare const coerceWithContext: <T>(value: T | WithContext<T>, context: types.Context) => WithContext<T>;
export declare const coerceWithIndexed: <T, I>(value: T | WithIndexed<T, I>, indexed: I) => WithIndexed<T, I>;
export declare class DocumentIndex<T, I extends Record<string, any>, D extends ReplicationDomain<any, Operation, any>> extends Program<OpenOptions<T, I, D>> {
    _query: RPC<types.AbstractSearchRequest, types.AbstractSearchResult>;
    documentType: AbstractType<T>;
    transformer: Transformer<T, I>;
    wrappedIndexedType: IndexableClass<I>;
    indexedType: AbstractType<I>;
    dbType: AbstractType<types.IDocumentStore<T>>;
    indexedTypeIsDocumentType: boolean;
    private indexBy;
    private indexByResolver;
    index: indexerTypes.Index<WithContext<I>>;
    private _resumableIterators;
    private _prefetch?;
    private includeIndexed;
    compatibility: 6 | 7 | 8 | 9 | undefined;
    private _valueEncoding;
    private _sync;
    private _log;
    private _resolverProgramCache?;
    private _resolverCache?;
    private isProgramValued;
    private _maybeOpen;
    private canSearch?;
    private canRead?;
    private documentEvents;
    private _joinListener?;
    private _resultQueue;
    private iteratorKeepAliveTimers?;
    constructor(properties?: {
        query?: RPC<types.AbstractSearchRequest, types.AbstractSearchResult>;
    });
    get valueEncoding(): Encoding<T>;
    private ensurePrefetchAccumulator;
    private wrapPushResults;
    private drainQueuedResults;
    private handleDocumentChange;
    private get nestedProperties();
    open(properties: OpenOptions<T, I, D>): Promise<void>;
    get prefetch(): PrefetchOptions | undefined;
    private queryRPCResponseHandler;
    private handleSearchRequest;
    afterOpen(): Promise<void>;
    getPending(cursorId: string): Promise<number | undefined>;
    get hasPending(): boolean;
    close(from?: Program): Promise<boolean>;
    drop(from?: Program): Promise<boolean>;
    get<Options extends GetOptions<T, I, D, true | undefined>>(key: indexerTypes.Ideable | indexerTypes.IdKey, options?: Options): Promise<WithIndexedContext<T, I>>;
    get<Options extends GetOptions<T, I, D, false>>(key: indexerTypes.Ideable | indexerTypes.IdKey, options?: Options): Promise<WithContext<I>>;
    getFromGid(gid: string): Promise<indexerTypes.IndexedResult<WithContext<I>>>;
    getFromHash(hash: string): Promise<indexerTypes.IndexedResult<WithContext<I>>>;
    put(value: T, id: indexerTypes.IdKey, entry: Entry<Operation>, existing: indexerTypes.IndexedResult<WithContext<I>> | indexerTypes.IndexedResult<IndexedContextOnly<I>> | null | undefined): Promise<{
        context: types.Context;
        indexable: I;
    }>;
    putWithContext(value: T, id: indexerTypes.IdKey, context: types.Context, options?: {
        replace?: boolean;
    }): Promise<{
        context: types.Context;
        indexable: I;
    }>;
    del(key: indexerTypes.IdKey): indexerTypes.IdKey[] | Promise<indexerTypes.IdKey[]>;
    getDetailed<Options extends QueryOptions<T, I, D, Resolve>, Resolve extends boolean | undefined = ExtractResolveFromOptions<Options>, RT extends types.Result = Resolve extends true ? types.ResultValue<WithIndexedContext<T, I>> : types.ResultIndexedValue<WithContext<I>>>(key: indexerTypes.IdKey | indexerTypes.IdPrimitive, options?: QueryOptions<T, I, D, Resolve>): Promise<types.Results<RT>[] | undefined>;
    getSize(): Promise<number> | number;
    private resolveDocument;
    processQuery<R extends types.SearchRequest | types.SearchRequestIndexed | types.IterationRequest | types.CollectNextRequest>(query: R, from: PublicSignKey, isLocal: boolean, options?: {
        canRead?: CanRead<I>;
    }): Promise<types.Results<types.ResultTypeFromRequest<R, T, I>>>;
    private scheduleIteratorKeepAlive;
    private cancelIteratorKeepAlive;
    private clearResultsQueue;
    get countIteratorsInProgress(): number;
    private clearAllResultQueues;
    private waitForCoverReady;
    private createReplicatorJoinListener;
    processCloseIteratorRequest(query: types.CloseIteratorRequest, publicKey: PublicSignKey): void;
    /**
     * Query and retrieve results with most details
     * @param queryRequest
     * @param options
     * @returns
     */
    private queryCommence;
    search(queryRequest: QueryLike, options?: SearchOptions<T, I, D, true>): Promise<ValueTypeFromRequest<true, T, I>[]>;
    search(queryRequest: QueryLike, options?: SearchOptions<T, I, D, false>): Promise<ValueTypeFromRequest<false, T, I>[]>;
    private resolveIndexed;
    iterate(query?: QueryLike, options?: QueryOptions<T, I, D, undefined>): ResultsIterator<ValueTypeFromRequest<true, T, I>>;
    iterate<Resolve extends boolean>(query?: QueryLike, options?: QueryOptions<T, I, D, Resolve>): ResultsIterator<ValueTypeFromRequest<Resolve, T, I>>;
    updateResults<R extends boolean, RT = R extends true ? T : I>(into: WithContext<RT>[], change: {
        added?: WithContext<T>[] | WithContext<I>[];
        removed?: WithContext<T>[] | WithContext<I>[];
    }, query: QueryLike, resolve: R): Promise<WithContext<RT>[]>;
    /**
     * Resolve the primary key for a document or indexed representation using the configured indexBy fields.
     * Useful when consumers need a stable id without assuming a specific property name exists.
     */
    resolveId(value: ValueTypeFromRequest<any, T, I> | WithContext<I> | WithIndexedContext<T, I> | WithIndexed<T, I> | I): indexerTypes.IdKey;
    waitFor(other: PeerRefs, options?: {
        seek?: "any" | "present";
        signal?: AbortSignal;
        timeout?: number;
    }): Promise<string[]>;
}
export {};
//# sourceMappingURL=search.d.ts.map