export declare function reversed<T>(thing: Iterable<T>): Iterable<T>;
/**
 * [TODO] Implement an iterator that goes through the array as if it were a ring
 * and starts with a random offset and direction.
 *
 * @param thing
 */
export declare function randomShifted<T>(thing: Iterable<T>): Iterable<T>;
/**
 * Creates a generator that yields the values of a given Map in random order.
 *
 * The function first creates an array of keys from the map, then shuffles
 * this array using the Fisher-Yates algorithm. Finally, it yields the map's
 * values in the order of the shuffled keys. The original Map is not modified.
 *
 * Note: This function is not space efficient for large maps as it creates
 * an additional array for the keys.
 *
 * @template K - The type of the keys of the map.
 * @template V - The type of the values of the map.
 * @param {Map<K, V>} map - The map whose values are to be yielded in random order.
 * @yields {V} - The next value from the map in random order.
 *
 * @example
 * let map = new Map<string, number>();
 * map.set('a', 1);
 * map.set('b', 2);
 * map.set('c', 3);
 * map.set('d', 4);
 * let iter = shuffleMapIterator(map);
 * for (let value of iter) {
 *     console.log(value);  // Prints values in random order
 * }
 */
export declare function shuffleMapIterator<K, V>(map: Map<K, V>): IterableIterator<V>;