import { ObjKey, RecordedRead } from "../common";
import { WatchedProxyHandler } from "../watchedProxyFacade";
import { RecordedReadOnProxiedObjectExt } from "../RecordedReadOnProxiedObjectExt";
import { DualUseTracker, ForWatchedProxyHandler, IWatchedProxyHandler_common } from "../proxyFacade";
/**
 * Listeners for one array.
 * 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 Arrays
 */
declare class ArrayChangeHooks {
}
export declare const changeHooksForArray: WeakMap<unknown[], ArrayChangeHooks>;
export declare function getChangeHooksForArray(array: unknown[]): ArrayChangeHooks;
/**
 * 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 ArrayChangeTracker<T> extends Array<T> implements DualUseTracker<Array<T>> {
    get _watchedProxyHandler(): IWatchedProxyHandler_common | undefined;
    protected _withUnspecificChange<R>(changeFn: () => R): R;
    pop(...args: any[]): T | undefined;
    /**
     * Will return the original object when this class is used as supervisor class in the WatchedProxyHandler
     */
    get _target(): Array<T>;
    /**
     * Pretend that this is an array
     */
    get ["constructor"](): ArrayConstructor;
    shift(...args: any[]): T | undefined;
    sort(...args: any[]): this;
    fill(...args: any[]): this;
    forEach(callbackfn: (value: T, index: number, array: this) => void, thisArg?: any): void;
}
export declare class RecordedArrayValuesRead extends RecordedReadOnProxiedObjectExt {
    values: unknown[];
    origObj: unknown[];
    constructor(values: unknown[]);
    getAffectingChangeHooks(target: this["origObj"]): import("../common").EventHook[];
    equals(other: RecordedRead): boolean;
    get isChanged(): boolean;
}
/**
 * Patches methods / accessors
 */
export declare class ArrayReadTracker<T> extends Array<T> implements ForWatchedProxyHandler<Array<T>> {
    get _watchedProxyHandler(): WatchedProxyHandler;
    get _target(): Array<T>;
    protected _fireAfterValuesRead(): void;
    /**
     * Pretend that this is an array
     */
    get ["constructor"](): ArrayConstructor;
    values(): ArrayIterator<T>;
    entries(): ArrayIterator<[number, T]>;
    [Symbol.iterator](): ArrayIterator<T>;
    get length(): number;
    shift(...args: any[]): T | undefined;
    /**
     * Keep this method so it it treated as handled and not as making-unspecific-reads
     */
    forEach(callbackfn: (value: T, index: number, array: this) => void, thisArg?: any): void;
    pop(...args: any[]): T | undefined;
}
export declare const config: {
    clazz: ArrayConstructor;
    readTracker: typeof ArrayReadTracker;
    changeTracker: typeof ArrayChangeTracker;
    /**
     * Built-in Methods, which are using fields / calling methods on the proxy transparently/loyally, so those methods don't call/use internal stuff directly.
     * Tested with, see dev_generateEsRuntimeBehaviourCheckerCode.ts
     * May include read-only / reader methods
     */
    knownHighLevelMethods: Set<ObjKey>;
    /**
     * Non-high level. These fire `RecordedUnspecificRead`s then. So better implement them instead to fire i.e RecordedArrayValuesRead.
     */
    readOnlyMethods: Set<ObjKey>;
    /**
     * Non-high level. Same as above: better implement them
     */
    readOnlyFields: Set<ObjKey>;
    /**
     *
     */
    receiverMustBeNonProxied: boolean;
    trackSettingObjectProperties: boolean;
    worksForSubclasses: boolean;
    trackTreads: boolean;
    proxyUnhandledMethodResults: boolean;
    getTrackerClasses(): import("../common").Clazz[];
};
export {};
//# sourceMappingURL=Array.d.ts.map