import { Clazz } from "./common";
export declare function throwError(e: string | Error): void;
export declare function reThrowWithHint(e: unknown, hint: string): void;
export declare function isObject(value: unknown): value is object;
/**
 * A Map<K, Set<V>>. But automatically add a new Set if needed
 */
export declare class MapSet<K, V> {
    map: Map<K, Set<V>>;
    add(key: K, value: V): void;
    delete(key: K, value: V): void;
    get(key: K): Set<V> | undefined;
    /**
     * @param key
     * @return the set for the specified key (an empty one will be created if needed) on which you should call `add` or `delete` **immediately**, so no empty set is left there consuming memory.
     * It is automatically cleaned up after the last delete
     */
    get4use(key: K): Set<V>;
}
/**
 * This Map does not return empty values, so there's always a default value created
 */
export declare abstract class DefaultMap<K, V> extends Map<K, V> {
    abstract createDefaultValue(key: K): V;
    get(key: K): V;
}
/**
 * This Map does not return empty values, so there's always a default value created
 */
export declare abstract class DefaultWeakMap<K extends Object, V> extends WeakMap<K, V> {
    abstract createDefaultValue(key: K): V;
    get(key: K): V;
}
/**
 *
 * @param createDefaultValueFn
 * @returns a Map that creates and inserts a default value when that value does not exist. So the #get method always returns something.
 */
export declare function newDefaultMap<K, V>(createDefaultValueFn: (key: K) => V): DefaultMap<K, V>;
/**
 *
 * @param createDefaultValueFn
 * @returns a WeakMap that creates and inserts a default value when that value does not exist. So the #get method always returns something.
 */
export declare function newDefaultWeakMap<K, V>(createDefaultValueFn: (key: K) => V): DefaultMap<K, V>;
/**
 * A WeakMap<K, Set<V>>. But automatically add a new Set if needed
 */
export declare class WeakMapSet<K extends WeakKey, V> extends MapSet<K, V> {
    map: Map<K, Set<V>>;
}
export declare function arraysAreEqualsByPredicateFn<A, B>(a: A[], b: B[], equalsFn: (a: A, b: B) => boolean): boolean;
export type PromiseState<T> = {
    state: "pending";
    promise: Promise<T>;
} | {
    state: "resolved";
    resolvedValue: T;
} | {
    state: "rejected";
    rejectReason: any;
};
type VisitReplaceContext = {
    /**
     * Not safely escaped. Should be used for diag only !
     */
    diagnosis_path?: string;
    parentObject?: object;
    key?: unknown;
};
/**
 * Usage:
 *  <pre><code>
 *  const result = visitReplace(target, (value, visitChilds, context) => {
 *      return value === 'needle' ? 'replaced' : visitChilds(value, context)
 *  });
 *  </code></pre>
 *
 * @param value
 * @param visitor
 * @param trackPath whether to pass on the context object. This hurts performance because the path is concatted every time, so use it only when needed. Setting this to "onError" re-executes the visitprelace with the concetxt when an error was thrown
 */
export declare function visitReplace<O>(value: O, visitor: (value: unknown, visitChilds: (value: unknown, context: VisitReplaceContext) => unknown, context: VisitReplaceContext) => unknown, trackPath?: boolean | "onError"): O;
/**
 * Just do something the runtime can't optimize away
 * @param value
 */
export declare function read(value: any): void;
export declare function arraysAreShallowlyEqual(a: unknown[], b: unknown[]): boolean;
/**
 * Like arraysAreShallowlyEqual but this time for an array of entries (tuple of 2 values) like from Map#entries()
 * @param a
 * @param b
 */
export declare function arraysWithEntriesAreShallowlyEqual(a: Array<[unknown, unknown]>, b: Array<[unknown, unknown]>): boolean;
export declare function classIsSubclassOf(clazz: Clazz, superClass: Clazz): boolean;
export {};
//# sourceMappingURL=Util.d.ts.map