import { Condition } from "../condition/index.js";
import { Level } from "level";
import type { ClientStateManager } from "../state.js";
export type Notifier<Events, S> = {
    [K in keyof Events]: (event: Events[K], state: S) => unknown;
};
type Indexed<T> = {
    item: T;
    index: number;
};
/**
 * Generic interface that represents a structure that ranks elements.
 * Most common is a Priority Queue (heap like) that pops elements in order.
 * An array is also a Ranker, without ordering.
 */
export interface Ranker<T> {
    push(item: T): void;
    pop(): T | undefined;
}
export type ModulatorEvents<T> = {
    ready: Indexed<T>;
};
export interface Modulator<F, M> {
    /**
     * Initializes the modulator and loads any previously existing state from the state manager.
     * @param {Condition} condition The condition under which the client runs.
     * @returns {Promise<boolean>} True if the modulator was initialized successfully.
    */
    init(condition: Condition): Promise<boolean>;
    /**
     * Starts the handling of a fragment by adding it to the todo list.
     * @param {ReadonlyArray<F>} fragments The fragments to be handled.
    */
    push(fragments: ReadonlyArray<F>): Promise<void>;
    /**
     * Checks if the modulator is ready to trigger the ready event.
    */
    checkReady(): Promise<void>;
    /**
     * Called when a fragment has been handled, which removes it from the inflight list.
     * @param index The index of the fragment that has been handled.
    */
    finished(index: number): Promise<void>;
    /**
     * Closes the modulator, which removes it from the factory.
    */
    close(): void;
    /**
     * Returns the number of fragments that are still pending.
    */
    pendingCount(): Promise<number>;
    /**
     * Returns whether a fragment has been encountered before and is in the immutable list.
     * @param {string} url The URL of the element to check.
     * @return {Promise<boolean>} True if the element is in the immutable list.
    */
    seen(url: string): Promise<boolean>;
    /**
     * Returns all fragments that are mutable.
     * @returns {Promise<ReadonlyArray<F>>} The mutable list.
    */
    getAllMutable(): Promise<ReadonlyArray<F>>;
    /**
     * Returns all data entities that have been extracted but not emitted yet.
     * @returns {Promise<ReadonlyArray<M>>} The unemitted list.
    */
    getAllUnemitted(): Promise<ReadonlyArray<M>>;
    /**
     * Returns all fragments that are currently in flight.
     * @returns {Promise<ReadonlyArray<F>>} The inflight list.
    */
    getAllInFlight(): Promise<ReadonlyArray<F>>;
    /**
     * Returns all fragments that are currently in todo.
     * @returns {Promise<ReadonlyArray<F>>} The todo list.
    */
    getAllTodo(): Promise<ReadonlyArray<F>>;
    /**
     * Records the fact that an element is mutable
     * @param {string} url The URL of the element to record.
     * @param {F} fragment The element to record.
     * @returns {Promise<boolean>} True if all is good to proceed, false if must not emit new notifications.
    */
    addMutable(url: string, fragment: F): Promise<boolean>;
    /**
     * Records the fact that an element is immutable.
     * @param {string} url The URL of the element to record.
     * @returns {Promise<boolean>} True if all is good to proceed, false if must not emit new notifications.
    */
    addImmutable(url: string): Promise<boolean>;
    /**
     * Records the fact that a data entity has been emitted.
     * @param {string} url The URL of the emitted data entity.
     * @returns {Promise<boolean>} True if all is good to proceed, false if must not emit new notifications.
    */
    addEmitted(url: string): Promise<boolean>;
    /**
     * Records the fact that a data entity has been extracted but not emitted yet.
     * @param {string} url The URL of the data entity.
     * @param {M} member The extracted data entity.
     * @returns {Promise<boolean>} True if all is good to proceed, false if must not emit new notifications.
    */
    addUnemitted(url: string, member: M): Promise<boolean>;
    /**
     * Returns whether a data entity has been emitted.
     * @param {string} url The URL of the data entity.
     * @returns {Promise<boolean>} True if the data entity has been emitted.
    */
    wasEmitted(url: string): Promise<boolean>;
    /**
     * Removes a data entity from the unemitted list.
     * @param {string} url The URL of the data entity.
     * @returns {Promise<boolean>} True if all is good to proceed, false if must not emit new notifications.
    */
    deleteUnemitted(url: string): Promise<boolean>;
    /**
     * Returns whether the modulator is tracking latest versions
     * @returns {boolean} True if the modulator is tracking latest versions
    */
    hasLatestVersions(): boolean;
    /**
     * Filter out older versions of a member.
     * @param {string} memberId The ID of the member (isVersionOf).
     * @param {number} version The version of the member.
     * @returns {Promise<boolean>} True if the member is old and should be filtered out.
     * @throws {Error} If processing was cancelled and must not continue.
    */
    filterLatest(memberId: string, version: number): Promise<boolean>;
}
type ModulatorState<F, M> = {
    condition: Level<number, string>;
    todo: Level<number, F>;
    inflight: Level<number, F>;
    mutable: Level<string, F>;
    emitted: Level<string, boolean>;
    immutable?: Level<string, boolean>;
    unemitted?: Level<string, M>;
    latestVersions?: Level<string, number>;
    fragmentEncoder?: (item: F) => unknown;
    fragmentParser?: (item: unknown) => F;
    memberEncoder?: (item: M) => unknown;
    memberParser?: (item: unknown) => M;
};
/**
 * Factory that creates Modulators
 * This is a factory to keep track whether the Modulator should be paused or not.
 */
export declare class ModulatorFactory {
    concurrent: number;
    paused: boolean;
    saveState: boolean;
    lastVersionOnly: boolean;
    clientStateManager: ClientStateManager;
    children: {
        [key: string]: Modulator<unknown, unknown>;
    };
    constructor(clientStateManager: ClientStateManager, saveState?: boolean, concurrent?: number, lastVersionOnly?: boolean);
    create<F, M>(name: string, ranker: Ranker<Indexed<F>>, notifier: Notifier<ModulatorEvents<F>, unknown>, fragmentEncoder?: (item: F) => unknown, fragmentParser?: (item: unknown) => F, memberEncoder?: (item: M) => unknown, memberParser?: (item: unknown) => M): Modulator<F, M>;
    pause(): void;
    unpause(): void;
    close(): void;
}
export declare class ModulatorInstance<F, M> implements Modulator<F, M> {
    at: number;
    index: number;
    private modulatorState;
    private ranker;
    private notifier;
    private factory;
    private logger;
    private closed;
    private versionStateSync;
    constructor(state: ModulatorState<F, M>, ranker: Ranker<Indexed<F>>, notifier: Notifier<ModulatorEvents<F>, unknown>, factory: ModulatorFactory);
    init(condition: Condition): Promise<boolean>;
    push(fragments: ReadonlyArray<F>): Promise<void>;
    checkReady(): Promise<void>;
    finished(index: number): Promise<void>;
    close(): void;
    pendingCount(): Promise<number>;
    seen(url: string): Promise<boolean>;
    getAllMutable(): Promise<Array<F>>;
    getAllUnemitted(): Promise<ReadonlyArray<M>>;
    getAllInFlight(): Promise<ReadonlyArray<F>>;
    getAllTodo(): Promise<ReadonlyArray<F>>;
    addMutable(url: string, fragment: F): Promise<boolean>;
    addImmutable(url: string): Promise<boolean>;
    addEmitted(url: string): Promise<boolean>;
    addUnemitted(url: string, member: M): Promise<boolean>;
    wasEmitted(url: string): Promise<boolean>;
    deleteUnemitted(url: string): Promise<boolean>;
    hasLatestVersions(): boolean;
    /**
     * This method uses a promise-chain (versionStateSync) to serialize all version checks and updates,
     * preventing race conditions when multiple fragment extractions occur in parallel.
    */
    filterLatest(memberId: string, version: number): Promise<boolean>;
    /**
     * Clears the todo list.
    */
    private clearAllTodo;
    /**
     * Adds a fragment to the todo list.
    */
    private addTodo;
    /**
     * Clears the in-flight list.
    */
    private clearAllInFlight;
    /**
     * Adds a fragment to the in-flight list.
    */
    private addInFlight;
    /**
     * Utility function to execute an operation on the modulator state.
    */
    private withState;
}
export {};