import { ObjKey, RecordedRead, EventHook } from "../common";
import { WatchedProxyHandler } from "../watchedProxyFacade";
import { RecordedReadOnProxiedObjectExt } from "../RecordedReadOnProxiedObjectExt";
import { DualUseTracker, ForWatchedProxyHandler, IWatchedProxyHandler_common } from "../proxyFacade";
/**
 * Listeners for one set.
 * Note for specificity: There will be only one of the **change** events fired. The Recorded...Read.onChange handler will add the listeners to all possible candidates. It's this way around.
 * {@link ObjectChangeHooks} are also subscribed on Sets
 */
declare class SetChangeHooks {
    afterSpecificValueChanged: import("../Util").DefaultMap<unknown, EventHook>;
    afterAnyValueChanged: EventHook;
}
export declare const changeHooksForSet: WeakMap<Set<unknown>, SetChangeHooks>;
export declare function getChangeHooksForSet(set: Set<unknown>): SetChangeHooks;
/**
 * Can be either used as a supervisor-class in a WatchedProxyHandler, or installed on the non-proxied object via Object.setPrototypeOf
 * The "this" may be different in these cases.
 */
export declare class SetChangeTracker<T> extends Set<T> implements DualUseTracker<Set<T>> {
    get _watchedProxyHandler(): IWatchedProxyHandler_common | undefined;
    protected _withUnspecificChange<R>(changeFn: () => R): R;
    /**
     * Will return the original object when this class is used as supervisor class in the WatchedProxyHandler
     */
    get _target(): Set<T>;
    /**
     * Pretend that this is a Set
     */
    get ["constructor"](): SetConstructor;
    add(value: T): this;
    delete(value: T): boolean;
    clear(): any;
}
export declare class RecordedSet_has extends RecordedReadOnProxiedObjectExt {
    value: unknown;
    /**
     * Result of the .has call
     */
    result: boolean;
    origObj: Set<unknown>;
    constructor(value: unknown, result: boolean);
    get isChanged(): boolean;
    getAffectingChangeHooks(target: this["origObj"]): EventHook[];
    equals(other: RecordedRead): boolean;
}
export declare class RecordedSetValuesRead extends RecordedReadOnProxiedObjectExt {
    values: Array<unknown>;
    origObj: Set<unknown>;
    constructor(values: Array<unknown>);
    getAffectingChangeHooks(target: this["origObj"]): EventHook[];
    equals(other: RecordedRead): boolean;
    get isChanged(): boolean;
}
export declare class SetReadTracker<T> extends Set<T> implements ForWatchedProxyHandler<Set<T>> {
    get _watchedProxyHandler(): WatchedProxyHandler;
    get _target(): Set<T>;
    protected _fireAfterValuesRead(): void;
    /**
     * Pretend that this is a Set
     */
    get ["constructor"](): SetConstructor;
    has(value: T): boolean;
    values(): SetIterator<T>;
    entries(): SetIterator<[T, T]>;
    keys(): SetIterator<T>;
    forEach(callbackfn: (value: T, value2: T, set: Set<T>, ...restOfArgs: unknown[]) => void, ...restOfArgs: unknown[]): void;
    [Symbol.iterator](): SetIterator<T>;
    get size(): number;
}
export declare const config: {
    clazz: SetConstructor;
    readTracker: typeof SetReadTracker;
    changeTracker: typeof SetChangeTracker;
    receiverMustBeNonProxied: boolean;
    worksForSubclasses: boolean;
    knownHighLevelMethods: Set<ObjKey>;
    readOnlyMethods: Set<ObjKey>;
    readOnlyFields: Set<ObjKey>;
    trackTreads: boolean;
    trackSettingObjectProperties: boolean;
    proxyUnhandledMethodResults: boolean;
    getTrackerClasses(): import("../common").Clazz[];
};
export {};
//# sourceMappingURL=Set.d.ts.map