import { type Nullable } from './types.js';
export type Mapping<S, T> = (src: S) => T;
export type Predicate<S, V = boolean> = (src: S) => V;
export type Flat<T> = T extends Iterable<infer A> ? A : T;
/**
 * Picks the last element of an iterable
 * @returns undefined for null/empty iterable
 */
export declare function last<T>(iterable: Nullable<Iterable<T>>): T | undefined;
/**
 * Picks the first element of an iterable
 * @returns undefined for null/empty iterable
 */
export declare function first<T>(iterable: Nullable<Iterable<T>>): T | undefined;
/**
 * Checks if an iterable is empty
 */
export declare function isEmpty(iterable: Iterable<unknown>): boolean;
/**
 * Evaluate the size of an iterable
 * @returns elements count of iterable, 0 if null
 */
export declare function size(iterable: Nullable<Iterable<unknown>>): number;
/**
 * Finds element by index, including negative index
 * @see Array.at
 * @returns undefined if invalid index or null iterable
 */
export declare function at<T>(iterable: Nullable<Iterable<T>>, index: number): T | undefined;
/**
 * Find the element following an item
 * @returns undefined if item is last or not found
 */
export declare function next<T>(iterable: Nullable<Iterable<T>>, item: T): T | undefined;
/**
 * Find the element before an item
 * @returns undefined if item is first or not found
 */
export declare function prev<T>(iterable: Nullable<Iterable<T>>, item: T): T | undefined;
/**
 * Creates iterable of unique elements
 * @param by - an element identifier (hash) function
 */
export declare function unique<T>(iterable: Nullable<Iterable<T>>, by?: Predicate<T, unknown>): Iterable<T>;
/**
 * Map iterable elements
 * @see Array.map
 */
export declare function map<S, T>(iterable: Nullable<Iterable<S>>, mapFn: Mapping<S, T>): Iterable<T>;
/**
 * @see Array.flatMap
 * @returns a mapped, flattened iterables
 */
export declare function flatMap<S, T>(iterable: Nullable<Iterable<S>>, mapFn: Mapping<S, T | Iterable<T>>): Iterable<Flat<T>>;
/**
 * @see Array.filter
 */
export declare function filter<T>(iterable: Nullable<Iterable<T>>, predicate: Predicate<T>): Iterable<T>;
/**
 * @see Array.concat
 * @returns a concatenated iterable
 */
export declare function concat<T>(...iterables: Nullable<Iterable<T>>[]): Iterable<T>;
/**
 * @see Array.forEach
 */
export declare function forEach<T>(iterable: Nullable<Iterable<T>>, fn: Mapping<T, unknown>): void;
/**
 * @see Array.find
 * @returns the first element the satisfies the predicate
 */
export declare function find<T>(iterable: Nullable<Iterable<T>>, predicate: Predicate<T>): T | undefined;
/**
 * @see Array.includes
 * @returns item is an element of iterable
 */
export declare function includes<T>(iterable: Nullable<Iterable<T>>, item: T): boolean;
/**
 * @see Array.some
 * @returns there is an element satisfies the predicate
 */
export declare function some<T>(iterable: Nullable<Iterable<T>>, predicate: Predicate<T>): boolean;
/**
 * @see Array.every
 * @returns true is all elements satisfy the predicate
 */
export declare function every<T>(iterable: Iterable<T>, predicate: Predicate<T>): boolean;
/**
 * @see Array.flat
 * @param deep - if true, repeat the flattening until all elements are not iterable
 * @returns a flattened iterable,
 *      where elements that are iterable are spread into the result
 */
export declare function flat<T>(iterable: Nullable<Iterable<T | Iterable<T>>>, deep?: boolean): Iterable<Flat<T>>;
/**
 * Calculate a histogram of iterable elements
 * @returns an histogram map (element=\>count)
 */
export declare function histogram<T>(iterable: Iterable<T>): Map<T, number>;
/**
 * @returns true if x is iterable
 */
export declare function isIterable(x: any): x is Iterable<unknown>;
/**
 * @see Array<T>.sort
 * @param by - comparator, returns a negative value if a should precede b
 */
export declare function sort<T>(iterable: Nullable<Iterable<T>>, by?: (a: T, b: T) => number): Iterable<T>;
/**
 * @see Array.reduce
 * @returns reduced object
 */
export declare function reduce<T, A>(iterable: Nullable<Iterable<T>>, reducer: (acc: A, item: T) => A, initial: A): A;
/**
 * @see Array.join
 */
export declare function join<T extends string>(iterable: Nullable<Iterable<T>>, separator: string): string;
/**
 * Skips the first elements of an iterable
 */
export declare function skip<T>(iterable: Nullable<Iterable<T>>, count: number): Iterable<T>;
/**
 * Groups elements by the value of a property
 * @returns A map of the value to an array of elements
 */
export declare function groupBy<T, K extends keyof T>(elements: Iterable<T>, property: K): Map<T[K], T[]>;
//# sourceMappingURL=iterables.d.ts.map