import { type AbstractType } from "@dao-xyz/borsh";
import type { QueryCacheOptions } from "@peerbit/indexer-cache";
import * as indexerTypes from "@peerbit/indexer-interface";
import { type Change, Entry, type ShallowOrFullEntry, type TrimOptions } from "@peerbit/log";
import { Program, type ProgramEvents } from "@peerbit/program";
import { type EntryReplicated, type ReplicationDomain, type SharedAppendOptions, SharedLog, type SharedLogOptions } from "@peerbit/shared-log";
import type { CustomDocumentDomain } from "./domain.js";
import type { DocumentEvents } from "./events.js";
import { DeleteOperation, type Operation, PutOperation } from "./operation.js";
import { type CanRead, type CanSearch, DocumentIndex, type GetOptions, type PrefetchOptions, type ReachScope, type TransformOptions } from "./search.js";
export declare class OperationError extends Error {
    constructor(message?: string);
}
type MaybePromise<T> = Promise<T> | T;
export type CountEstimate = {
    estimate: number;
    /**
     * Relative error margin (0..1), where e.g. `0.1` means ~±10%.
     *
     * Only non-`undefined` when the replication domain is expected to be uniformly
     * distributed (currently: `domain.type === "hash"`), and when there is
     * sufficient local sample information to compute it.
     *
     * When `undefined`, the caller should treat `estimate` as unreliable.
     */
    errorMargin: number | undefined;
};
type CanPerformPut<T> = {
    type: "put";
    value: T;
    operation: PutOperation;
    entry: Entry<PutOperation>;
};
type CanPerformDelete = {
    type: "delete";
    operation: DeleteOperation;
    entry: Entry<DeleteOperation>;
};
export type CanPerformOperations<T> = CanPerformPut<T> | CanPerformDelete;
export type CanPerform<T> = (properties: CanPerformOperations<T>) => MaybePromise<boolean>;
type InferR<D> = D extends ReplicationDomain<any, any, infer I> ? I : "u32";
export type SetupOptions<T, I extends Record<string, any> = T extends Record<string, any> ? T : any, D extends ReplicationDomain<any, Operation, any> = any> = {
    type: AbstractType<T>;
    canOpen?: (program: T) => MaybePromise<boolean>;
    canPerform?: CanPerform<T>;
    strictHistory?: boolean;
    id?: (obj: any) => indexerTypes.IdPrimitive;
    index?: {
        canSearch?: CanSearch;
        canRead?: CanRead<I>;
        idProperty?: string | string[];
        cache?: {
            resolver?: number;
            query?: QueryCacheOptions;
        };
        prefetch?: boolean | Partial<PrefetchOptions>;
        includeIndexed?: boolean;
    } & TransformOptions<T, I>;
    log?: {
        trim?: TrimOptions;
    };
    compatibility?: 6 | 7;
    domain?: (db: Documents<T, I, D>) => CustomDocumentDomain<InferR<D>>;
    keep?: ((entry: ShallowOrFullEntry<Operation> | EntryReplicated<InferR<D>>) => Promise<boolean> | boolean) | "self";
} & Omit<SharedLogOptions<Operation, D, InferR<D>>, "compatibility" | "domain" | "keep">;
export type ExtractArgs<T> = T extends ReplicationDomain<infer Args, any, any> ? Args : never;
export declare class Documents<T, I extends Record<string, any> = T extends Record<string, any> ? T : any, D extends ReplicationDomain<any, Operation, any> = any> extends Program<SetupOptions<T, I, D>, DocumentEvents<T, I> & ProgramEvents> {
    log: SharedLog<Operation, D, InferR<D>>;
    immutable: boolean;
    private _index;
    private _clazz;
    private _optionCanPerform?;
    private idResolver;
    private domain?;
    private strictHistory;
    canOpen?: (program: T) => Promise<boolean> | boolean;
    compatibility: 6 | 7 | undefined;
    constructor(properties?: {
        id?: Uint8Array;
        immutable?: boolean;
        index?: DocumentIndex<T, I, ExtractArgs<D>>;
    });
    get index(): DocumentIndex<T, I, D>;
    private getLocalIndexedContext;
    private getExistingContext;
    get changes(): import("@libp2p/interface").TypedEventTarget<DocumentEvents<T, I> & ProgramEvents>;
    private maybeSubprogramOpen;
    private keepCache;
    open(options: SetupOptions<T, I, D>): Promise<void>;
    recover(): Promise<void>;
    private _resolveEntry;
    protected canAppend(entry: Entry<Operation>, reference?: {
        document: T;
        operation: PutOperation;
    }): Promise<boolean>;
    protected _canAppend(entry: Entry<Operation>, reference?: {
        document: T;
        operation: PutOperation;
    }): Promise<PutOperation | DeleteOperation | false>;
    put(doc: T, options?: SharedAppendOptions<Operation> & {
        unique?: boolean;
        replicate?: boolean;
        checkRemote?: boolean;
    }): Promise<{
        entry: Entry<Operation>;
        removed: ShallowOrFullEntry<Operation>[];
    }>;
    get(id: indexerTypes.Ideable | indexerTypes.IdKey, options?: Omit<GetOptions<T, I, D, true | undefined>, "resolve">): Promise<T | undefined>;
    del(id: indexerTypes.Ideable | indexerTypes.IdKey, options?: SharedAppendOptions<Operation>): Promise<{
        entry: Entry<Operation>;
        removed: ShallowOrFullEntry<Operation>[];
    }>;
    handleChanges(change: Change<Operation>, reference?: {
        document: T;
        operation: PutOperation;
        unique?: boolean;
    }): Promise<void>;
    /**
     * Count documents locally (default), or estimate the global count.
     *
     * - `count()` / `count({ query })`: exact local count from the index.
     * - `count({ approximate: true })`: estimated global count from replication metadata (no remote queries) + error margin when available.
     */
    count(options?: {
        query?: indexerTypes.Query | indexerTypes.QueryLike;
        approximate?: false | undefined;
    }): Promise<number>;
    count(options: {
        query?: indexerTypes.Query | indexerTypes.QueryLike;
        approximate: true | {
            scope?: ReachScope;
        };
    }): Promise<CountEstimate>;
}
export {};
//# sourceMappingURL=program.d.ts.map