export * from 'to-fluent';
export * from 'deep-mutate-object';
export * from 'pick-omit';
export * from './rgb';
export * from './eventemitter';
export { default as isEqual } from './is-equal';
import type { Chunk, Class, Fn, StringOf } from 'everyday-types';
export declare function chunk<T, L extends number>(arr: T[], size: L): Chunk<T, L>[];
export declare function entries<K extends keyof T, V extends T[K], T extends {
    [s: string]: any;
}>(obj: T): readonly [K, V][];
export declare function entries<K extends keyof T, V extends T[K], T extends ArrayLike<any>>(obj: T): readonly [K, V][];
export declare function keys<K extends keyof T, T extends {
    [s: string]: any;
}>(obj: T): readonly K[];
export declare function keys<K extends keyof T, T extends ArrayLike<any>>(obj: T): readonly K[];
export declare function fromEntries<K extends string, V>(entries: readonly [K, V][]): Record<K, V>;
export declare function cheapRandomId(): string;
export declare const randomId: typeof cheapRandomId;
export declare function accessors<S extends {
    [s: string]: any;
}, T>(target: T, source: S, fn: (key: StringOf<keyof S>, value: S[StringOf<keyof S>]) => PropertyDescriptor, filter?: (key: StringOf<keyof S>, value: S[StringOf<keyof S>]) => boolean): () => void;
export declare function kebab(s: string): string;
export declare function styleToCss(style: CSSStyleDeclaration): string;
export declare function shuffle<T>(arr: T[]): T[];
export declare function asyncSerialMap<T, U>(arr: T[], fn: (item: T, index: number, arr: T[]) => Promise<U>): Promise<U[]>;
export declare function asyncSerialReduce<T, U>(arr: T[], fn: (prev: U, next: T, index: number, arr: T[]) => Promise<U>, prev: U): Promise<U>;
export declare function wait(ms: number): Promise<void>;
export declare function tick(): Promise<void>;
export declare function colorHash(string: string, minColorHex?: string): string;
export declare function colorOf(id: string, sat?: number, lum?: number): string;
export declare function ansiColorFor(string: string): string;
export declare function removeFromArray<T>(arr: T[], el: T, quiet?: boolean): T[] | void;
export declare function chainSync(...args: (() => any)[]): () => void;
export declare function shallowEqual(a: object, b: object): boolean;
export declare function shallowEqualArray(a: unknown, b: unknown): boolean;
export declare function getOwnProperty(object: object, name: string): any;
export declare function padCenter(str: string | number, length: number): string;
export declare function getStringLength(str: string | number): number;
export declare function padStart(str: string | number, length: number, char?: string): string;
export declare function padEnd(str: string | number, length: number, char?: string): string;
export declare function repeatString(s: string, x: number): string;
export declare function stripAnsi(str: string | number): string;
export declare function includesAny(str: string, predicates: string[]): boolean;
export declare function asyncFilter<T>(array: T[], fn: (item: T) => Promise<boolean>): Promise<T[]>;
export declare const defineProperty: import("to-fluent").Fluent<(<T>(object: object, name: PropertyKey, value?: T | undefined) => object), Required<{
    configurable: boolean;
    enumerable: boolean;
    writable: boolean;
    get?(): any;
    set?(v: any): void;
}>>;
export declare function filterMap<T, U>(array: T[] | readonly T[], fn: (item: T, index: number, array: T[] | readonly T[]) => U | false | null | undefined): U[];
export declare function sortCompare(a: number | string, b: number | string): 0 | 1 | -1;
export declare function sortCompareKeys([a]: [string, any], [b]: [string, any]): 0 | 1 | -1;
export declare function sortObjectInPlace<T extends Record<string, any>>(data: T): T;
export declare function splitAt(string: string, index: number): readonly [string, string];
export declare function memoize<P extends unknown[], R>(fn: Fn<P, R>, map?: any): Fn<P, R>;
export interface Deferred<T> {
    hasSettled: boolean;
    promise: Promise<T>;
    when: (fn: () => void) => void;
    resolve: (value: T) => void;
    reject: (error?: Error) => void;
    value?: T;
    error?: Error;
}
export declare function Deferred<T>(): Deferred<T>;
export declare function KeyedCache<T, U extends unknown[], V extends string | number>(getter: (key: V, ...args: U) => Promise<T>, maxCacheSize?: number): ((key: V, ...args: U) => Promise<T>) & {
    cache: Map<V, {
        deferred: Deferred<T>;
        accessTime: number;
    }>;
    maxCacheSize: number;
};
export declare type Promised<T, U extends unknown[] = unknown[]> = (...args: U) => Promise<T>;
export declare function promisify(fn: any): (this: any, ...args: any[]) => Promise<any>;
export declare class MapSet<K, V> {
    map: Map<K, Set<V>>;
    constructor(mapSet?: MapSet<K, V>, shallow?: boolean);
    copy(): any;
    shallowCopy(): MapSet<K, V>;
    add(key: K, value: any): number;
    create(key: K): void;
    keys(): IterableIterator<K>;
    values(): V[];
    entries(): [K, V][];
    get(key: K): Set<V> | undefined;
    sort(key: K, compareFn?: (a: V, b: V) => number): void;
    delete(key: K, value: any): boolean;
    has(key: K, value: any): boolean;
    hasKey(key: K): boolean;
    clear(): void;
    get size(): number;
}
export declare class WeakMapSet<K extends object, V> {
    #private;
    set(key: K, value: any): number;
    get(key: K): Set<V> | undefined;
    delete(key: K, value: any): boolean;
    has(key: K, value: any): boolean;
}
export declare class MapMap<KA, KB, V> {
    #private;
    set(keyA: KA, keyB: KB, value: any): number;
    get(keyA: KA, keyB: KB): V | undefined;
    delete(keyA: KA, keyB: KB): boolean;
    has(keyA: KA, keyB: KB): boolean;
    clear(): void;
}
export declare class MapMapSet<KA, KB, V> {
    #private;
    add(keyA: KA, keyB: KB, value: any): number;
    get(keyA: KA, keyB: KB): Set<V> | undefined;
    delete(keyA: KA, keyB: KB, value: any): boolean;
    has(keyA: KA, keyB: KB, value: any): boolean;
    clear(): void;
}
export declare function mutable<T>(array: readonly T[]): T[];
export declare class MapFactory<K, V extends object> extends Map<K, V> {
    defaultArgs: never[];
    get(key: K, ...args: any[]): V;
    ctor: Class<V>;
    constructor(json: {
        entries: readonly [K, V][];
        ctor: Class<V>;
    });
    constructor(ctor: Class<V>, defaultData?: Partial<V>);
    toJSON(): {
        entries: [K, V][];
        ctor: Class<V>;
    };
}
export declare class WeakMapFactory<K extends object, V extends object> extends WeakMap<K, V> {
    ctor: Class<V>;
    defaultArgs: never[];
    get(key: K, ...args: any[]): V;
    constructor(ctor: Class<V>, defaultArgs?: never[]);
}
export declare function isClass(fn: any): boolean;
export declare function bindAll<T extends object, U extends object>(obj: T, target?: T | U): T & U;
export declare function once<T extends ((this: any, ...args: any[]) => any) | void>(fn: T): T;
export declare function checksum(str: string): number;
export declare function debugObjectMethods<T>(obj: T, ignoreKeys?: string[], hooks?: {
    before: (key: string, args: any[], stackErr: Error) => void;
    after: (key: string, args: any[], result: any) => void;
}, name?: string): T;
export declare function attempt(x: () => void, quiet?: boolean): void;
export declare function noop(): void;
export declare function modWrap(x: number, N: number): number;