/**
 * Entries is an array of key-value pairs, with unique keys.
 * [📘](https://github.com/nodef/extra-lists/wiki/Entries)
 */
type Entries<K, V> = Iterable<[K, V]>;
/**
 * Lists is a pair of key array and value array, with unique keys.
 * [📘](https://github.com/nodef/extra-lists/wiki/Lists)
 */
type Lists<K, V> = [Iterable<K>, Iterable<V>];
/**
 * Handle reading of a single value.
 * [📘](https://github.com/nodef/extra-lists/wiki/ReadFunction)
 * @returns value
 */
type ReadFunction<T> = () => T;
/**
 * Handle combining of two values.
 * [📘](https://github.com/nodef/extra-lists/wiki/CombineFunction)
 * @param a a value
 * @param b another value
 * @returns combined value
 */
type CombineFunction<T> = (a: T, b: T) => T;
/**
 * Handle comparison of two values.
 * [📘](https://github.com/nodef/extra-lists/wiki/CompareFunction)
 * @param a a value
 * @param b another value
 * @returns a<b: -ve, a=b: 0, a>b: +ve
 */
type CompareFunction<T> = (a: T, b: T) => number;
/**
 * Handle processing of values in lists.
 * [📘](https://github.com/nodef/extra-lists/wiki/ProcessFunction)
 * @param v value in lists
 * @param k key of value in lists
 * @param x lists containing the value
 */
type ProcessFunction<K, V> = (v: V, k: K, x: Lists<K, V>) => void;
/**
 * Handle selection of values in lists.
 * [📘](https://github.com/nodef/extra-lists/wiki/TestFunction)
 * @param v value in lists
 * @param k key of value in lists
 * @param x lists containing the value
 * @returns selected?
 */
type TestFunction<K, V> = (v: V, k: K, x: Lists<K, V>) => boolean;
/**
 * Handle transformation of a value to another.
 * [📘](https://github.com/nodef/extra-lists/wiki/MapFunction)
 * @param v value in lists
 * @param k key of value in lists
 * @param x lists containing the value
 * @returns transformed value
 */
type MapFunction<K, V, W> = (v: V, k: K, x: Lists<K, V>) => W;
/**
 * Handle reduction of multiple values into a single value.
 * [📘](https://github.com/nodef/extra-lists/wiki/ReduceFunction)
 * @param acc accumulator (temporary result)
 * @param v value in lists
 * @param k key of value in lists
 * @param x lists containing the value
 * @returns reduced value
 */
type ReduceFunction<K, V, W> = (acc: W, v: V, k: K, x: Lists<K, V>) => W;
/**
 * Handle ending of combined lists.
 * [📘](https://github.com/nodef/extra-lists/wiki/EndFunction)
 * @param dones iᵗʰ lists done?
 * @returns combined lists done?
 */
type EndFunction = (dones: boolean[]) => boolean;
/**
 * Check if value is lists.
 * [📘](https://github.com/nodef/extra-lists/wiki/is)
 * @param v value
 * @returns v is lists?
 */
declare function is<K, V>(v: any): v is Lists<K, V>;
/**
 * List all keys.
 * [📘](https://github.com/nodef/extra-lists/wiki/keys)
 * @param x lists
 * @returns k₀, k₁, ... | kᵢ ∈ x[0]
 */
declare function keys<K, V>(x: Lists<K, V>): Iterable<K>;
/**
 * List all values.
 * [📘](https://github.com/nodef/extra-lists/wiki/values)
 * @param x lists
 * @returns v₀, v₁, ... | vᵢ ∈ x[1]
 */
declare function values<K, V>(x: Lists<K, V>): Iterable<V>;
/**
 * List all key-value pairs.
 * [📘](https://github.com/nodef/extra-lists/wiki/entries)
 * @param x lists
 * @returns [k₀, v₀], [k₁, v₁], ... | kᵢ ∈ x[0]; vᵢ ∈ x[1]
 */
declare function entries<K, V>(x: Lists<K, V>): Entries<K, V>;
/**
 * Convert lists to entries.
 * [📘](https://github.com/nodef/extra-lists/wiki/fromEntries)
 * @param x entries
 * @returns x as lists
 */
declare function fromEntries<K, V>(x: Entries<K, V>): Lists<K, V>;
/**
 * Find the size of lists.
 * [📘](https://github.com/nodef/extra-lists/wiki/size)
 * @param x lists
 * @returns |x|
 */
declare function size<K, V>(x: Lists<K, V>): number;

/**
 * Check if lists is empty.
 * [📘](https://github.com/nodef/extra-lists/wiki/isEmpty)
 * @param x lists
 * @returns |x| = 0?
 */
declare function isEmpty<K, V>(x: Lists<K, V>): boolean;
/**
 * Compare two lists.
 * [📘](https://github.com/nodef/extra-lists/wiki/compare)
 * @param x lists
 * @param y another lists
 * @param fc compare function (a, b)
 * @param fm map function (v, k, x)
 * @returns x=y: 0, otherwise: -ve/+ve
 */
declare function compare<K, V, W = V>(x: Lists<K, V>, y: Lists<K, V>, fc?: CompareFunction<V | W> | null, fm?: MapFunction<K, V, V | W> | null): number;
/**
 * Check if two lists are equal.
 * [📘](https://github.com/nodef/extra-lists/wiki/isEqual)
 * @param x lists
 * @param y another lists
 * @param fc compare function (a, b)
 * @param fm map function (v, k, x)
 * @returns x=y?
 */
declare function isEqual<K, V, W = V>(x: Lists<K, V>, y: Lists<K, V>, fc?: CompareFunction<V | W> | null, fm?: MapFunction<K, V, V | W> | null): boolean;
/**
 * Get value at key.
 * [📘](https://github.com/nodef/extra-lists/wiki/get)
 * @param x lists
 * @param k key
 * @returns x[k]
 */
declare function get<K, V>(x: Lists<K, V>, k: K): V;
/**
 * Gets values at keys.
 * [📘](https://github.com/nodef/extra-lists/wiki/getAll)
 * @param x lists
 * @param ks keys
 * @returns x[k₀], x[k₁], ... | [k₀, k₁, ...] = ks
 */
declare function getAll<K, V>(x: Lists<K, V>, ks: K[]): Iterable<V>;
/**
 * Get value at path in nested lists.
 * [📘](https://github.com/nodef/extra-lists/wiki/getPath)
 * @param x nested lists
 * @param p path
 * @returns x[k₀][k₁][...] | [k₀, k₁, ...] = p
 */
declare function getPath<K>(x: Lists<K, any>, p: K[]): any;
/**
 * Check if nested lists has a path.
 * [📘](https://github.com/nodef/extra-lists/wiki/hasPath)
 * @param x nested lists
 * @param p search path
 * @returns x[k₀][k₁][...] exists? | [k₀, k₁, ...] = p
 */
declare function hasPath<T>(x: Lists<T, any>, p: T[]): boolean;
/**
 * Set value at key.
 * [📘](https://github.com/nodef/extra-lists/wiki/set)
 * @param x lists
 * @param k key
 * @param v value
 * @returns x' | x' = x; x'[k] = v
 */
declare function set<K, V>(x: Lists<K, V>, k: K, v: V): Lists<K, V>;
/**
 * Exchange two values.
 * [📘](https://github.com/nodef/extra-lists/wiki/swap)
 * @param x lists
 * @param k a key
 * @param l another key
 * @returns x' | x' = x; x'[k] = x[l]; x'[l] = x[k]
 */
declare function swap<K, V>(x: Lists<K, V>, k: K, l: K): Lists<K, V>;
/**
 * Remove value at key.
 * [📘](https://github.com/nodef/extra-lists/wiki/remove)
 * @param x lists
 * @param k key
 * @returns x - [k, v] | v = x[k]
 */
declare function remove<K, V>(x: Lists<K, V>, k: K): Lists<K, V>;
/**
 * Get first entry from lists (default order).
 * [📘](https://github.com/nodef/extra-lists/wiki/head)
 * @param x lists
 * @param ed default entry
 * @returns [k₀, v₀] if x ≠ Φ else ed | [k₀, v₀] ∈ x
 */
declare function head<K, V>(x: Lists<K, V>, ed?: [K, V]): [K, V];
/**
 * Get lists without its first entry (default order).
 * [📘](https://github.com/nodef/extra-lists/wiki/tail)
 * @param x lists
 * @returns x \\ \{[k₀, v₀]\} if x ≠ Φ else x | [k₀, v₀] ∈ x
 */
declare function tail<K, V>(x: Lists<K, V>): Lists<K, V>;
/**
 * Keep first n entries only (default order).
 * [📘](https://github.com/nodef/extra-lists/wiki/take)
 * @param x lists
 * @param n number of entries [1]
 * @returns \{[k₀, v₀], [k₁, v₁], ...\} | [kᵢ, vᵢ] ∈ x and |\{[k₀, v₀], [k₁, v₁], ...\}| ≤ n
 */
declare function take<K, V>(x: Lists<K, V>, n?: number): Lists<K, V>;
/**
 * Remove first n entries (default order).
 * [📘](https://github.com/nodef/extra-lists/wiki/drop)
 * @param x a map
 * @param n number of entries [1]
 * @returns \{[kₙ, vₙ], [kₙ₊₁, vₙ₊₁], ...\} | [kᵢ, vᵢ] ∈ x and |\{[kₙ, vₙ], [kₙ₊₁, vₙ₊₁], ...\}| ≤ max(|x| - n, 0)
 */
declare function drop<K, V>(x: Lists<K, V>, n?: number): Lists<K, V>;
/**
 * Count values which satisfy a test.
 * [📘](https://github.com/nodef/extra-lists/wiki/count)
 * @param x lists
 * @param ft test function (v, k, x)
 * @returns Σtᵢ | tᵢ = 1 if ft(vᵢ) else 0; [kᵢ, vᵢ] ∈ x
 */
declare function count<K, V>(x: Lists<K, V>, ft: TestFunction<K, V>): number;
/**
 * Count occurrences of values.
 * [📘](https://github.com/nodef/extra-lists/wiki/countAs)
 * @param x lists
 * @param fm map function (v, k, x)
 * @returns Map \{value ⇒ count\}
 */
declare function countAs<K, V, W = V>(x: Lists<K, V>, fm?: MapFunction<K, V, V | W> | null): Map<V | W, number>;
/**
 * Find smallest value.
 * [📘](https://github.com/nodef/extra-lists/wiki/min)
 * @param x lists
 * @param fc compare function (a, b)
 * @param fm map function (v, k, x)
 * @returns v | v ≤ vᵢ; [kᵢ, vᵢ] ∈ x
 */
declare function min<K, V, W = V>(x: Lists<K, V>, fc?: CompareFunction<V | W> | null, fm?: MapFunction<K, V, V | W> | null): V;
/**
 * Find smallest entry.
 * [📘](https://github.com/nodef/extra-lists/wiki/minEntry)
 * @param x lists
 * @param fc compare function (a, b)
 * @param fm map function (v, k, x)
 * @returns [min_key, min_value]
 */
declare function minEntry<K, V, W = V>(x: Lists<K, V>, fc?: CompareFunction<V | W> | null, fm?: MapFunction<K, V, V | W> | null): [K, V];
/**
 * Find largest value.
 * [📘](https://github.com/nodef/extra-lists/wiki/max)
 * @param x lists
 * @param fc compare function (a, b)
 * @param fm map function (v, k, x)
 * @returns v | v ≥ vᵢ; [kᵢ, vᵢ] ∈ x
 */
declare function max<K, V, W = V>(x: Lists<K, V>, fc?: CompareFunction<V | W> | null, fm?: MapFunction<K, V, V | W> | null): V;
/**
 * Find largest entry.
 * [📘](https://github.com/nodef/extra-lists/wiki/maxEntry)
 * @param x lists
 * @param fc compare function (a, b)
 * @param fm map function (v, k, x)
 * @returns [max_key, max_value]
 */
declare function maxEntry<K, V, W = V>(x: Lists<K, V>, fc?: CompareFunction<V | W> | null, fm?: MapFunction<K, V, V | W> | null): [K, V];
/**
 * Find smallest and largest values.
 * [📘](https://github.com/nodef/extra-lists/wiki/range)
 * @param x lists
 * @param fc compare function (a, b)
 * @param fm map function (v, k, x)
 * @returns [min_value, max_value]
 */
declare function range<K, V, W = V>(x: Lists<K, V>, fc?: CompareFunction<V | W> | null, fm?: MapFunction<K, V, V | W> | null): [V, V];
/**
 * Find smallest and largest entries.
 * [📘](https://github.com/nodef/extra-lists/wiki/rangeEntries)
 * @param x lists
 * @param fc compare function (a, b)
 * @param fm map function (v, k, x)
 * @returns [min_entry, max_entry]
 */
declare function rangeEntries<K, V, W = V>(x: Lists<K, V>, fc?: CompareFunction<V | W> | null, fm?: MapFunction<K, V, V | W> | null): [[K, V], [K, V]];
/**
 * List all possible subsets.
 * [📘](https://github.com/nodef/extra-lists/wiki/subsets)
 * @param x lists
 * @param n number of entries in each subset [-1 ⇒ any]
 * @returns entries selected by bit from 0..2^|x| if n<0; only of length n otherwise
 */
declare function subsets<K, V>(x: Lists<K, V>, n?: number): Iterable<Lists<K, V>>;
/**
 * Pick an arbitrary key.
 * [📘](https://github.com/nodef/extra-lists/wiki/randomKey)
 * @param x lists
 * @param fr random number generator ([0, 1))
 * @returns kᵢ | kᵢ ∈ x[0]
 */
declare function randomKey<K, V>(x: Lists<K, V>, fr?: ReadFunction<number>): K;

/**
 * Pick an arbitrary value.
 * [📘](https://github.com/nodef/extra-lists/wiki/randomValue)
 * @param x lists
 * @param fr random number generator ([0, 1))
 * @returns vᵢ | vᵢ ∈ x[1]
 */
declare function randomValue<K, V>(x: Lists<K, V>, fr?: ReadFunction<number>): V;

/**
 * Pick an arbitrary entry.
 * [📘](https://github.com/nodef/extra-lists/wiki/randomEntry)
 * @param x lists
 * @param fr random number generator ([0, 1))
 * @returns [kᵢ, vᵢ] | kᵢ ∈ x[0]; vᵢ ∈ x[1]
 */
declare function randomEntry<K, V>(x: Lists<K, V>, fr?: ReadFunction<number>): [K, V];

/**
 * Pick an arbitrary subset.
 * [📘](https://github.com/nodef/extra-lists/wiki/randomSubset)
 * @param x lists
 * @param n number of entries [-1 ⇒ any]
 * @param fr random number generator ([0, 1))
 * @returns [[kᵢ, kⱼ, ...], [vᵢ, vⱼ, ...]] | kᵢ, kⱼ, ... ∈ x[0]; vᵢ, vⱼ, ... ∈ x[1]; |[kᵢ, kⱼ, , ...]| = |x| if n<0 else n
 */
declare function randomSubset<K, V>(x: Lists<K, V>, n?: number, fr?: ReadFunction<number>): Lists<K, V>;

/**
 * Check if lists has a key.
 * [📘](https://github.com/nodef/extra-lists/wiki/has)
 * @param x lists
 * @param k search key
 * @returns k ∈ keys(x)?
 */
declare function has<K, V>(x: Lists<K, V>, k: K): boolean;
/**
 * Check if lists has a value.
 * [📘](https://github.com/nodef/extra-lists/wiki/hasValue)
 * @param x lists
 * @param v search value
 * @param fc compare function (a, b)
 * @param fm map function (v, k, x)
 * @returns v ∈ values(x)?
 */
declare function hasValue<K, V, W = V>(x: Lists<K, V>, v: V, fc?: CompareFunction<V | W> | null, fm?: MapFunction<K, V, V | W> | null): boolean;
/**
 * Check if lists has an entry.
 * [📘](https://github.com/nodef/extra-lists/wiki/hasEntry)
 * @param x lists
 * @param e search entry
 * @param fc compare function (a, b)
 * @param fm map function (v, k, x)
 * @returns k ∈ x[0]; v ∈ x[1]; k ⇒ v? | [k, v] = e
 */
declare function hasEntry<K, V, W = V>(x: Lists<K, V>, e: [K, V], fc?: CompareFunction<V | W> | null, fm?: MapFunction<K, V, V | W> | null): boolean;
/**
 * Check if lists has a subset.
 * [📘](https://github.com/nodef/extra-lists/wiki/hasSubset)
 * @param x lists
 * @param y search subset
 * @param fc compare function (a, b)
 * @param fm map function (v, k, x)
 * @returns y ⊆ x?
 */
declare function hasSubset<K, V, W = V>(x: Lists<K, V>, y: Lists<K, V>, fc?: CompareFunction<V | W> | null, fm?: MapFunction<K, V, V | W> | null): boolean;
/**
 * Find first value passing a test (default order).
 * [📘](https://github.com/nodef/extra-lists/wiki/find)
 * @param x lists
 * @param ft test function (v, k, x)
 * @returns first v | ft(v) = true; [k, v] ∈ x
 */
declare function find<K, V>(x: Lists<K, V>, ft: TestFunction<K, V>): V;
/**
 * Find values passing a test.
 * [📘](https://github.com/nodef/extra-lists/wiki/findAll)
 * @param x lists
 * @param ft test function (v, k, x)
 * @returns v₀, v₁, ... | ft(vᵢ) = true; [kᵢ, vᵢ] ∈ x
 */
declare function findAll<K, V>(x: Lists<K, V>, ft: TestFunction<K, V>): Iterable<V>;
/**
 * Finds key of an entry passing a test.
 * [📘](https://github.com/nodef/extra-lists/wiki/search)
 * @param x lists
 * @param ft test function (v, k, x)
 * @returns key of entry
 */
declare function search<K, V>(x: Lists<K, V>, ft: TestFunction<K, V>): K;
/**
 * Find keys of entries passing a test.
 * [📘](https://github.com/nodef/extra-lists/wiki/searchAll)
 * @param x lists
 * @param ft test function (v, k, x)
 * @returns keys of entries
 */
declare function searchAll<K, V>(x: Lists<K, V>, ft: TestFunction<K, V>): Iterable<K>;
/**
 * Find a key with given value.
 * [📘](https://github.com/nodef/extra-lists/wiki/searchValue)
 * @param x lists
 * @param v search value
 * @param fc compare function (a, b)
 * @param fm map function (v, k, x)
 * @returns key of value
 */
declare function searchValue<K, V, W = V>(x: Lists<K, V>, v: V, fc?: CompareFunction<V | W> | null, fm?: MapFunction<K, V, V | W> | null): K;
/**
 * Find keys with given value.
 * [📘](https://github.com/nodef/extra-lists/wiki/searchValueAll)
 * @param x lists
 * @param v search value
 * @param fc compare function (a, b)
 * @param fm map function (v, k, x)
 * @returns keys of value
 */
declare function searchValueAll<K, V, W = V>(x: Lists<K, V>, v: V, fc?: CompareFunction<V | W> | null, fm?: MapFunction<K, V, V | W> | null): Iterable<K>;
/**
 * Call a function for each value.
 * [📘](https://github.com/nodef/extra-lists/wiki/forEach)
 * @param x lists
 * @param fp process function (v, k, x)
 */
declare function forEach<K, V>(x: Lists<K, V>, fc: ProcessFunction<K, V>): void;
/**
 * Check if any value satisfies a test.
 * [📘](https://github.com/nodef/extra-lists/wiki/some)
 * @param x lists
 * @param ft test function (v, k, x)
 * @returns true if ft(vᵢ) = true for some [kᵢ, vᵢ] ∈ x
 */
declare function some<K, V>(x: Lists<K, V>, ft?: TestFunction<K, V> | null): boolean;
/**
 * Check if all values satisfy a test.
 * [📘](https://github.com/nodef/extra-lists/wiki/every)
 * @param x entries
 * @param ft test function (v, k, x)
 * @returns true if ft(vᵢ) = true for every [kᵢ, vᵢ] ∈ x
 */
declare function every<K, V>(x: Lists<K, V>, ft: TestFunction<K, V>): boolean;
/**
 * Transform values of entries.
 * [📘](https://github.com/nodef/extra-lists/wiki/map)
 * @param x lists
 * @param fm map function (v, k, x)
 * @returns [k₀, fm(v₀)], [k₁, fm(v₁)], ... | [kᵢ, vᵢ] ∈ x
 */
declare function map<K, V, W>(x: Lists<K, V>, fm: MapFunction<K, V, W>): any[][];
/**
 * Reduce values of entries to a single value.
 * [📘](https://github.com/nodef/extra-lists/wiki/reduce)
 * @param x lists
 * @param fr reduce function (acc, v, k, x)
 * @param acc initial value
 * @returns fr(fr(acc, v₀), v₁)... | fr(acc, v₀) = v₀ if acc not given
 */
declare function reduce<K, V, W = V>(x: Lists<K, V>, fr: ReduceFunction<K, V, V | W>, acc?: V | W): V | W;
/**
 * Keep entries which pass a test.
 * [📘](https://github.com/nodef/extra-lists/wiki/filter)
 * @param x lists
 * @param ft test function (v, k, x)
 * @returns [k₀, v₀], [k₁, v₁], ... | ft(vᵢ) = true; [kᵢ, vᵢ] ∈ x
 */
declare function filter<K, V>(x: Lists<K, V>, ft: TestFunction<K, V>): Lists<K, V>;
/**
 * Keep entries with given keys.
 * [📘](https://github.com/nodef/extra-lists/wiki/filterAt)
 * @param x lists
 * @param ks keys
 * @returns [k₀, v₀], [k₁, v₁], ... | kᵢ ∈ ks; [kᵢ, vᵢ] ∈ x
 */
declare function filterAt<K, V>(x: Lists<K, V>, ks: K[]): Lists<K, V>;
/**
 * Discard entries which pass a test.
 * [📘](https://github.com/nodef/extra-lists/wiki/reject)
 * @param x lists
 * @param ft test function (v, k, x)
 * @returns [k₀, v₀], [k₁, v₁], ... | ft(vᵢ) = false; [kᵢ, vᵢ] ∈ x
 */
declare function reject<K, V>(x: Lists<K, V>, ft: TestFunction<K, V>): Lists<K, V>;
/**
 * Discard entries with given keys.
 * [📘](https://github.com/nodef/extra-lists/wiki/rejectAt)
 * @param x lists
 * @param ks keys
 * @returns [k₀, v₀], [k₁, v₁], ... | kᵢ ∉ ks; [kᵢ, vᵢ] ∈ x
 */
declare function rejectAt<K, V>(x: Lists<K, V>, ks: K[]): Lists<K, V>;
/**
 * Flatten nested lists to given depth.
 * [📘](https://github.com/nodef/extra-lists/wiki/flat)
 * @param x nested lists
 * @param n maximum depth [-1 ⇒ all]
 * @param fm map function (v, k, x)
 * @param ft test function for flatten (v, k, x) [is]
 * @returns flat lists
 */
declare function flat<K>(x: Lists<K, any>, n?: number, fm?: MapFunction<K, any, any> | null, ft?: TestFunction<K, any> | null): Lists<K, any>;
/**
 * Flatten nested lists, based on map function.
 * [📘](https://github.com/nodef/extra-lists/wiki/flatMap)
 * @param x nested lists
 * @param fm map function (v, k, x)
 * @param ft test function for flatten (v, k, x) [is]
 * @returns flat lists
 */
declare function flatMap<K>(x: Lists<K, any>, fm?: MapFunction<K, any, any> | null, ft?: TestFunction<K, any> | null): Lists<K, any>;
/**
 * Combine matching entries from all lists.
 * [📘](https://github.com/nodef/extra-lists/wiki/zip)
 * @param xs all lists
 * @param fm map function (vs, k)
 * @param ft end function (dones) [some]
 * @param vd default value
 * @returns fm([x₀[k₀], x₁[k₀], ...]), fm([x₀[k₁], x₁[k₁], ...]), ...
 */
declare function zip<K, V, W = V>(xs: Lists<K, V>[], fm?: MapFunction<K, V[], V[] | W> | null, ft?: EndFunction, vd?: V): Lists<K, V[] | W>;
/**
 * Segregate values by test result.
 * [📘](https://github.com/nodef/extra-lists/wiki/partition)
 * @param x lists
 * @param ft test function (v, k, x)
 * @returns [satisfies, doesnt]
 */
declare function partition<K, V>(x: Lists<K, V>, ft: TestFunction<K, V>): [Lists<K, V>, Lists<K, V>];
/**
 * Segregate entries by similarity.
 * [📘](https://github.com/nodef/extra-lists/wiki/partitionAs)
 * @param x entries
 * @param fm map function (v, k, x)
 * @returns Map \{key ⇒ entries\}
 */
declare function partitionAs<K, V, W = V>(x: Lists<K, V>, fm?: MapFunction<K, V, V | W> | null): Map<V | W, Lists<K, V>>;
/**
 * Break lists into chunks of given size.
 * [📘](https://github.com/nodef/extra-lists/wiki/chunk)
 * @param x lists
 * @param n chunk size [1]
 * @param s chunk step [n]
 * @returns [x[0..n], x[s..s+n], x[2s..2s+n], ...]
 */
declare function chunk<K, V>(x: Lists<K, V>, n?: number, s?: number): Lists<K, V>[];
/**
 * Append entries from all lists, preferring last.
 * [📘](https://github.com/nodef/extra-lists/wiki/concat)
 * @param xs all lists
 * @returns x₀ ∪ x₁ ∪ ... | [x₀, x₁, ...] = xs
 */
declare function concat<K, V>(...xs: Lists<K, V>[]): Lists<K, V>;
/**
 * Join lists together into a string.
 * [📘](https://github.com/nodef/extra-lists/wiki/join)
 * @param x lists
 * @param sep separator [,]
 * @param asc associator [=]
 * @returns "$\{k₀\}=$\{v₀\},$\{k₁\}=$\{v₁\}..." | [kᵢ, vᵢ] ∈ x
 */
declare function join<K, V>(x: Lists<K, V>, sep?: string, asc?: string): string;
/**
 * Check if lists have no common keys.
 * [📘](https://github.com/nodef/extra-lists/wiki/isDisjoint)
 * @param x lists
 * @param y another lists
 * @returns x ∩ y = Φ?
 */
declare function isDisjoint<K, V>(x: Lists<K, V>, y: Lists<K, V>): boolean;
/**
 * Obtain keys present in any lists.
 * [📘](https://github.com/nodef/extra-lists/wiki/unionKeys)
 * @param xs all lists
 * @returns \{k₀, k₁, ...\} | [kᵢ, vᵢ] ∈ x₀ ∪ x₁, ...; [x₀, x₁, ...] = xs
 */
declare function unionKeys<K, V>(...xs: Lists<K, V>[]): Set<K>;
/**
 * Obtain entries present in any lists.
 * [📘](https://github.com/nodef/extra-lists/wiki/union)
 * @param x lists
 * @param y another lists
 * @param fc combine function (a, b)
 * @returns x ∪ y = \{[kᵢ, vᵢ] | [kᵢ, vᵢ] ∈ x or [kᵢ, vᵢ] ∈ y\}
 */
declare function union<K, V>(x: Lists<K, V>, y: Lists<K, V>, fc?: CombineFunction<V> | null): Lists<K, V>;
/**
 * Obtain entries present in both lists.
 * [📘](https://github.com/nodef/extra-lists/wiki/intersection)
 * @param x lists
 * @param y another lists
 * @param fc combine function (a, b)
 * @returns x ∩ y = \{[kᵢ, vᵢ] | [kᵢ, vᵢ] ∈ x and [kᵢ, vᵢ] ∈ y\}
 */
declare function intersection<K, V>(x: Lists<K, V>, y: Lists<K, V>, fc?: CombineFunction<V> | null): Lists<K, V>;
/**
 * Obtain entries not present in another lists.
 * [📘](https://github.com/nodef/extra-lists/wiki/difference)
 * @param x lists
 * @param y another lists
 * @returns x = x - y = \{[kᵢ, vᵢ] | [kᵢ, vᵢ] ∈ x, [kᵢ, *] ∉ y\}
 */
declare function difference<K, V>(x: Lists<K, V>, y: Lists<K, V>): Lists<K, V>;
/**
 * Obtain entries not present in both lists.
 * [📘](https://github.com/nodef/extra-lists/wiki/symmetricDifference)
 * @param x lists
 * @param y another lists
 * @returns x = x-y ∪ y-x
 */
declare function symmetricDifference<K, V>(x: Lists<K, V>, y: Lists<K, V>): Lists<K, V>;

export { CombineFunction, CompareFunction, EndFunction, Entries, Lists, MapFunction, ProcessFunction, ReadFunction, ReduceFunction, TestFunction, chunk, compare, concat, count, countAs, difference, drop, entries, randomEntry as entry, every, filter, filterAt, find, findAll, flat, flatMap, forEach, fromEntries, get, getAll, getPath, has, hasEntry, hasPath, hasSubset, hasValue, head, intersection, is, isDisjoint, isEmpty, isEqual, join, randomKey as key, keys, size as length, map, max, maxEntry, min, minEntry, partition, partitionAs, randomEntry, randomKey, randomSubset, randomValue, range, rangeEntries, reduce, reject, rejectAt, remove, search, searchAll, searchValue, searchValueAll, set, size, some, randomSubset as subset, subsets, swap, symmetricDifference, tail, take, union, unionKeys, randomValue as value, values, zip };