/** Removes all null and undefined values from an array. */
export declare function filterAbsent<V>(arr: ReadonlyArray<V>): ReadonlyArray<Exclude<V, null | undefined>>;
declare const atLeastOneSymbol: unique symbol;
export type AtLeastOne<V> = ReadonlyArray<V> & {
    readonly [atLeastOneSymbol]: undefined;
};
export declare function atLeastOne<V>(arr: ReadonlyArray<V>): AtLeastOne<V>;
declare const atLeastTwoSymbol: unique symbol;
export type AtLeastTwo<V> = AtLeastOne<V> & {
    readonly [atLeastTwoSymbol]: undefined;
};
export declare function atLeastTwo<V>(arr: ReadonlyArray<V>): AtLeastTwo<V>;
/** Returns a shuffled version of the input array. */
export declare function shuffled<V>(arr: ReadonlyArray<V>): ReadonlyArray<V>;
/**
 * Returns the only element in an iterable, throwing if the iterable has more or
 * fewer elemets.
 */
export declare function onlyElement<V>(iter: Iterable<V>): V;
/** Returns the first element from an iterable, if any. */
export declare function firstElement<V>(iter: Iterable<V>): V | undefined;
/**
 * Returns all consecutive pairs of elements. The returned iterable as the same
 * number of elements as the input one.
 */
export declare function consecutiveElementPairs<V>(iter: Iterable<V>, last?: V): Iterable<[V, V]>;
/** Returns true if the array is sorted in ascending order */
export declare function isSorted<V>(arr: ReadonlyArray<V>, comp?: (v1: V, v2: V) => number): boolean;
/**
 * Creates a range from `from` inclusive (defaulting to 0) to `to` exclusive.
 */
export declare function range(to: number, from?: number): ReadonlyArray<number>;
/** Base multimap class. */
declare abstract class Multimap<K, V, C extends Iterable<V>> implements Iterable<[K, V]> {
    private _size;
    protected readonly data: Map<K, C>;
    protected abstract emptyValues(): C;
    protected abstract addValues(col: C, vals: Iterable<V>): void;
    protected abstract valueCount(col: C): number;
    get size(): number;
    add(key: K, val: V): void;
    addAll(key: K, vals: Iterable<V>): void;
    has(key: K): boolean;
    get(key: K): Readonly<C>;
    delete(key: K): void;
    clear(): void;
    toMap(): ReadonlyMap<K, Readonly<C>>;
    [Symbol.iterator](): Iterator<[K, V]>;
}
/** Array-backed multimap. */
export declare class ArrayMultimap<K, V> extends Multimap<K, V, V[]> {
    protected emptyValues(): V[];
    protected valueCount(col: V[]): number;
    protected addValues(col: V[], vals: Iterable<V>): void;
}
/** Set-backed multimap. */
export declare class SetMultimap<K, V> extends Multimap<K, V, Set<V>> {
    protected emptyValues(): Set<V>;
    protected valueCount(col: Set<V>): number;
    protected addValues(col: Set<V>, vals: Iterable<V>): void;
}
/**
 * Non-negative counter. Keys are iterated in the order in which they were last
 * added (i.e. reached a positive count).
 */
export declare class Multiset<K> implements Iterable<K> {
    private readonly data;
    private _size;
    /**
     * Updates a key's count, updating it by the given value. If the resulting
     * count is non-positive, the key will be removed.
     */
    add(key: K, count?: number): void;
    /**
     * Adds each key in the input iterable. This method is optimized for the case
     * when the input is also a multiset.
     */
    addAll(keys: Iterable<K>): void;
    /** Returns the count of occurrences of a given value, or 0 if not found. */
    get(key: K): number;
    /**
     * Returns the total of (non-distinct) elements in the multiset. Use
     * `.toMap().size` for the total number of distinct elements.
     */
    get size(): number;
    clear(): void;
    /** Returns a map of counts. */
    toMap(): ReadonlyMap<K, number>;
    [Symbol.iterator](): Iterator<K>;
    /** Returns an array of entries in descending count order. */
    descending(): [K, number][];
    /**
     * Returns the entry with the highest count. If multiple entries have the
     * highest count, the one with the first latest creation will be returned.
     */
    mostCommon(): [K, number] | undefined;
}
/** Maps over an `Iterable`. */
export declare function mapIterable<V, W>(iter: Iterable<V>, fn: (val: V, ix: number) => W): Iterable<W>;
/** Maps over an `AsyncIterable`. */
export declare function mapAsyncIterable<V, W>(iter: AsyncIterable<V>, fn: (val: V, ix: number) => W): AsyncIterable<W>;
/** Checks whether the argument is an `AsyncIterable`. */
export declare function isAsyncIterable(arg: unknown): arg is AsyncIterable<unknown>;
/** Converts an `Iterable` to an `AsyncIterable`. */
export declare function toAsyncIterable<V>(arr: Iterable<V>): AsyncIterable<V>;
/** Converts an `AsyncIterable` to an array. */
export declare function fromAsyncIterable<V>(iter: AsyncIterable<V>): Promise<ReadonlyArray<V>>;
export {};