/**
 * A mirror of Python's `collections.Counter` class.
 */
export declare class Counter<T> extends Map<T, number> {
    constructor(iterable?: Iterable<readonly [T, number]>);
    update(iterable: Iterable<T>): void;
}
/**
 * Return a global version of the given regex pattern.
 */
export declare const toGlobal: (pat: RegExp) => RegExp;
/**
 * Parse a string to an integer, throwing an error if the entire string
 * is not formatted as an integer.
 */
export declare const parseIntStrict: (str: string) => number;
/**
 * Replace the first `count` instanaces of `pat` in `inputStr` with `repl`,
 * which may either be a new string, or a function that takes the matched
 * string and returns a new string. Converts `regex` to a global regex if
 * it is not already so that all instances could be replaced.
 */
export declare const subn: (regex: RegExp, replacer: (substring: string, ...args: any[]) => string, str: string, count?: number) => [string, number];
export declare const sub: (regex: RegExp, replacer: (substring: string, ...args: any[]) => string, str: string) => string;
/**
 * A mirror of Python's `str.isspace()` method.
 */
export declare const isspace: (s: string) => boolean;
/**
 * Return `!!x`.
 */
export declare const bool: (x: any) => boolean;
/**
 * Convert a boolean to 1 if true, 0 if false.
 */
export declare const boolToNumber: (b: boolean) => 1 | 0;
/**
 * Return the quotient and remainder of the division of `x` by `y`.
 *
 * A mirror of Python's `divmod()` function.
 */
export declare const divmod: (x: number, y: number) => [number, number];
/**
 * Get the number of bits necessary to represent `n` in binary.
 *
 * A mirror of Python's `int.bit_length()` method.
 */
export declare const bitLength: (n: number | bigint) => number;
/**
 * Number of ones in the binary representation of the absolute value of `n`.
 * Also known as the population count.
 *
 * A mirror of Python's `int.bit_count()` method.
 */
export declare const bitCount: (n: number | bigint) => number;
/**
 * A mirror of Python's `range()` function.
 */
export declare function range(start: number, stop?: number, step?: number): IterableIterator<number>;
/**
 * A mirror of Python's `enumerate()` function.
 */
export declare function enumerate<T>(iterable: Iterable<T>, start?: number): IterableIterator<[number, T]>;
/**
 * A mirror of Python's `itertools.chain` function.
 */
export declare function iterChain<T>(...iterables: Iterable<T>[]): IterableIterator<T>;
/**
 * A mirror of Python's `itertools.islice` function.
 */
export declare function islice<T>(iterable: Iterable<T>, start: number | null, stop: number | null, step?: number): IterableIterator<T>;
/**
 * A mirror of Python's `StopIteration` error.
 */
export declare class StopIteration extends Error {
    constructor(message?: string);
}
/**
 * A mirror of Python's `next()` function. Throws `StopIteration` if the
 * iterable is exhausted.
 */
export declare const iterNext: <T>(iterable: IterableIterator<T>) => T;
/**
 * Return `true` if `value` is equal to any element in the iterable according to `equalityCheck`.
 */
export declare const iterIncludes: <T>(iterable: Iterable<T>, value: T, equalityCheck?: (a: T, b: T) => boolean) => boolean;
/**
 * Return `true` if any element of the iterable is truthy according to `isTruthy`.
 * If none are true or the iterable is empty, return `false`.
 */
export declare const iterAny: <T>(iterable: Iterable<T>, isTruthy?: (value: T) => boolean) => boolean;
/**
 * Return `true` if all elements of the iterable are truthy according to `isTruthy`.
 * Returns `true` for an empty iterable.
 */
export declare const iterAll: <T>(iterable: Iterable<T>, isTruthy?: (value: T) => boolean) => boolean;
/**
 * Yield the elements of `iterable` that are truthy against `predicate`.
 */
export declare function iterFilter<T>(iterable: Iterable<T>, predicate?: (value: T) => boolean): IterableIterator<T>;
/**
 * Maps each element of `iterable` to a new value using `callback`.
 */
export declare function iterMap<T1, T2>(iterable: IterableIterator<T1>, callback: (value: T1) => T2): IterableIterator<T2>;
/**
 * Remove the first occurrence of `element` from `src` in-place.
 */
export declare const remove: <T>(src: T[], element: T) => void;
declare const _default: {
    Counter: typeof Counter;
    toGlobal: (pat: RegExp) => RegExp;
    parseIntStrict: (str: string) => number;
    subn: (regex: RegExp, replacer: (substring: string, ...args: any[]) => string, str: string, count?: number) => [string, number];
    sub: (regex: RegExp, replacer: (substring: string, ...args: any[]) => string, str: string) => string;
    isspace: (s: string) => boolean;
    bool: (x: any) => boolean;
    boolToNumber: (b: boolean) => 0 | 1;
    divmod: (x: number, y: number) => [number, number];
    bitLength: (n: number | bigint) => number;
    bitCount: (n: number | bigint) => number;
    range: typeof range;
    enumerate: typeof enumerate;
    iterChain: typeof iterChain;
    islice: typeof islice;
    StopIteration: typeof StopIteration;
    iterNext: <T>(iterable: IterableIterator<T>) => T;
    iterIncludes: <T_1>(iterable: Iterable<T_1>, value: T_1, equalityCheck?: (a: T_1, b: T_1) => boolean) => boolean;
    iterAny: <T_2>(iterable: Iterable<T_2>, isTruthy?: (value: T_2) => boolean) => boolean;
    iterAll: <T_3>(iterable: Iterable<T_3>, isTruthy?: (value: T_3) => boolean) => boolean;
    iterFilter: typeof iterFilter;
    iterMap: typeof iterMap;
    remove: <T_4>(src: T_4[], element: T_4) => void;
};
export default _default;
//# sourceMappingURL=utils.d.ts.map