/**
 * Number Extension Methods
 *
 * The best from:
 * - Ruby (times, upto, downto, even?, odd?, between?, clamp, abs, round, ceil, floor, digits)
 * - Kotlin (coerceIn, coerceAtLeast, coerceAtMost, rangeTo, downTo, compareTo)
 * - Swift (isMultiple(of:), magnitude, negate)
 * - Rust (clamp, pow, checked_add, saturating_add, wrapping_add)
 * - Python (math module: gcd, lcm, factorial, comb, perm, isqrt)
 * - Scala (to, until, max, min, abs, signum, toByte, toShort, toInt, toLong)
 * - Haskell (div, mod, divMod, quot, rem, gcd, lcm, even, odd)
 * - Most-requested JS/TS: clamp, lerp, remap, isEven, isOdd, random range, ordinal
 */
declare function clamp(n: number, min: number, max: number): number;
declare function lerp(start: number, end: number, t: number): number;
declare function inverseLerp(start: number, end: number, value: number): number;
declare function remap(n: number, fromMin: number, fromMax: number, toMin: number, toMax: number): number;
declare function roundTo(n: number, decimals: number): number;
declare function ceilTo(n: number, decimals: number): number;
declare function floorTo(n: number, decimals: number): number;
declare function truncTo(n: number, decimals: number): number;
declare function snap(n: number, step: number): number;
declare function isEven(n: number): boolean;
declare function isOdd(n: number): boolean;
declare function isPositive(n: number): boolean;
declare function isNegative(n: number): boolean;
declare function isZero(n: number): boolean;
declare function isInteger(n: number): boolean;
declare function isFiniteNum(n: number): boolean;
declare function isNaN_(n: number): boolean;
declare function isBetween(n: number, min: number, max: number): boolean;
declare function isMultipleOf(n: number, divisor: number): boolean;
declare function isPrime(n: number): boolean;
declare function isPerfectSquare(n: number): boolean;
declare function isPowerOfTwo(n: number): boolean;
declare function gcd(a: number, b: number): number;
declare function lcm(a: number, b: number): number;
declare function factorial(n: number): number;
declare function fibonacci(n: number): number;
declare function nCr(n: number, r: number): number;
declare function nPr(n: number, r: number): number;
declare function isqrt(n: number): number;
declare function digits(n: number, base?: number): number[];
declare function digitSum(n: number): number;
declare function divisors(n: number): number[];
declare function toBin(n: number): string;
declare function toOct(n: number): string;
declare function toHex(n: number): string;
declare function toBase(n: number, base: number): string;
declare function toOrdinal(n: number): string;
declare function toWords(n: number): string;
declare function toRoman(n: number): string;
declare function padStart(n: number, length: number, fill?: string): string;
declare function toPercent(n: number, decimals?: number): string;
declare function toFileSize(bytes: number, decimals?: number): string;
declare function toDuration(ms: number): string;
declare function toCompact(n: number): string;
declare function times<T>(n: number, fn: (i: number) => T): T[];
declare function timesVoid(n: number, fn: (i: number) => void): void;
declare function upTo(start: number, end: number, step?: number): Generator<number>;
declare function downTo(start: number, end: number, step?: number): Generator<number>;
declare function rangeTo(start: number, end: number, step?: number): number[];
declare function rangeUntil(start: number, end: number, step?: number): number[];
declare function saturatingAdd(a: number, b: number, max?: number): number;
declare function saturatingSub(a: number, b: number, min?: number): number;
declare function wrappingAdd(a: number, b: number, bits?: number): number;
declare function wrappingSub(a: number, b: number, bits?: number): number;
declare function randomInt(min: number, max: number): number;
declare function randomFloat(min: number, max: number): number;
declare const NumberExt: {
    readonly clamp: typeof clamp;
    readonly lerp: typeof lerp;
    readonly inverseLerp: typeof inverseLerp;
    readonly remap: typeof remap;
    readonly roundTo: typeof roundTo;
    readonly ceilTo: typeof ceilTo;
    readonly floorTo: typeof floorTo;
    readonly truncTo: typeof truncTo;
    readonly snap: typeof snap;
    readonly isEven: typeof isEven;
    readonly isOdd: typeof isOdd;
    readonly isPositive: typeof isPositive;
    readonly isNegative: typeof isNegative;
    readonly isZero: typeof isZero;
    readonly isInteger: typeof isInteger;
    readonly isFinite: typeof isFiniteNum;
    readonly isNaN: typeof isNaN_;
    readonly isBetween: typeof isBetween;
    readonly isMultipleOf: typeof isMultipleOf;
    readonly isPrime: typeof isPrime;
    readonly isPerfectSquare: typeof isPerfectSquare;
    readonly isPowerOfTwo: typeof isPowerOfTwo;
    readonly gcd: typeof gcd;
    readonly lcm: typeof lcm;
    readonly factorial: typeof factorial;
    readonly fibonacci: typeof fibonacci;
    readonly nCr: typeof nCr;
    readonly nPr: typeof nPr;
    readonly isqrt: typeof isqrt;
    readonly digits: typeof digits;
    readonly digitSum: typeof digitSum;
    readonly divisors: typeof divisors;
    readonly toBin: typeof toBin;
    readonly toOct: typeof toOct;
    readonly toHex: typeof toHex;
    readonly toBase: typeof toBase;
    readonly toOrdinal: typeof toOrdinal;
    readonly toWords: typeof toWords;
    readonly toRoman: typeof toRoman;
    readonly padStart: typeof padStart;
    readonly toPercent: typeof toPercent;
    readonly toFileSize: typeof toFileSize;
    readonly toDuration: typeof toDuration;
    readonly toCompact: typeof toCompact;
    readonly times: typeof times;
    readonly timesVoid: typeof timesVoid;
    readonly upTo: typeof upTo;
    readonly downTo: typeof downTo;
    readonly rangeTo: typeof rangeTo;
    readonly rangeUntil: typeof rangeUntil;
    readonly saturatingAdd: typeof saturatingAdd;
    readonly saturatingSub: typeof saturatingSub;
    readonly wrappingAdd: typeof wrappingAdd;
    readonly wrappingSub: typeof wrappingSub;
    readonly randomInt: typeof randomInt;
    readonly randomFloat: typeof randomFloat;
};

/**
 * String Extension Methods
 *
 * The best from:
 * - Ruby (capitalize, downcase, upcase, strip, squeeze, chars, lines, scan, gsub, tr)
 * - Kotlin (isBlank, isNotBlank, trimIndent, removeSurrounding, substringBefore/After, lines)
 * - Swift (hasPrefix, hasSuffix, lowercased, uppercased, trimmingCharacters, components)
 * - Python (str methods: title, swapcase, center, ljust, rjust, zfill, isalpha, isdigit, isalnum)
 * - Scala (stripMargin, stripPrefix, stripSuffix, r (regex), split, mkString)
 * - Rust (chars, contains, starts_with, ends_with, trim, to_lowercase, to_uppercase, repeat)
 * - Lodash/Ramda (camelCase, snakeCase, kebabCase, startCase, words, truncate, pad, escape, unescape)
 * - Most-requested JS/TS: slugify, truncate, template, reverse, isEmail, isURL, toNumber
 */
declare function capitalize(s: string): string;
declare function uncapitalize(s: string): string;
declare function titleCase(s: string): string;
declare function swapCase(s: string): string;
declare function camelCase(s: string): string;
declare function pascalCase(s: string): string;
declare function snakeCase(s: string): string;
declare function kebabCase(s: string): string;
declare function constantCase(s: string): string;
declare function dotCase(s: string): string;
declare function pathCase(s: string): string;
declare function sentenceCase(s: string): string;
declare function words(s: string): string[];
declare function lines(s: string): string[];
declare function chars(s: string): string[];
declare function graphemes(s: string): string[];
declare function trimIndent(s: string): string;
declare function stripMargin(s: string, marginChar?: string): string;
declare function stripPrefix(s: string, prefix: string): string;
declare function stripSuffix(s: string, suffix: string): string;
declare function removeSurrounding(s: string, prefix: string, suffix?: string): string;
declare function squeeze(s: string, char?: string): string;
declare function collapseWhitespace(s: string): string;
declare function center(s: string, width: number, fill?: string): string;
declare function padLeft(s: string, width: number, fill?: string): string;
declare function padRight(s: string, width: number, fill?: string): string;
declare function zfill(s: string, width: number): string;
declare function truncate(s: string, maxLength: number, suffix?: string): string;
declare function truncateWords(s: string, maxWords: number, suffix?: string): string;
declare function ellipsis(s: string, maxLength: number): string;
declare function substringBefore(s: string, delimiter: string): string;
declare function substringAfter(s: string, delimiter: string): string;
declare function substringBeforeLast(s: string, delimiter: string): string;
declare function substringAfterLast(s: string, delimiter: string): string;
declare function between(s: string, start: string, end: string): string;
declare function scan(s: string, pattern: RegExp): string[];
declare function count(s: string, sub: string): number;
declare function reverse(s: string): string;
declare function replaceAll(s: string, search: string, replacement: string): string;
declare function insert(s: string, index: number, value: string): string;
declare function remove(s: string, pattern: string | RegExp): string;
declare function wrap(s: string, wrapper: string): string;
declare function unwrap(s: string, wrapper: string): string;
declare function indent(s: string, spaces?: number, char?: string): string;
declare function dedent(s: string): string;
declare function mask(s: string, start?: number, end?: number, maskChar?: string): string;
declare function isBlank(s: string): boolean;
declare function isNotBlank(s: string): boolean;
declare function isAlpha(s: string): boolean;
declare function isAlphaNumeric(s: string): boolean;
declare function isDigit(s: string): boolean;
declare function isLowerCase(s: string): boolean;
declare function isUpperCase(s: string): boolean;
declare function isAscii(s: string): boolean;
declare function isPalindrome(s: string): boolean;
declare function isEmail(s: string): boolean;
declare function isUrl(s: string): boolean;
declare function isJson(s: string): boolean;
declare function isUuid(s: string): boolean;
declare function isHex(s: string): boolean;
declare function toSlug(s: string): string;
declare function toNumber(s: string): number | undefined;
declare function toInt$1(s: string, radix?: number): number | undefined;
declare function toFloat(s: string): number | undefined;
declare function toBoolean(s: string): boolean | undefined;
declare function toCharCodes(s: string): number[];
declare function fromCharCodes(codes: number[]): string;
declare function escapeHtml(s: string): string;
declare function unescapeHtml(s: string): string;
declare function escapeRegex(s: string): string;
declare function toBase64(s: string): string;
declare function fromBase64(s: string): string;
declare const StringExt: {
    readonly capitalize: typeof capitalize;
    readonly uncapitalize: typeof uncapitalize;
    readonly titleCase: typeof titleCase;
    readonly swapCase: typeof swapCase;
    readonly camelCase: typeof camelCase;
    readonly pascalCase: typeof pascalCase;
    readonly snakeCase: typeof snakeCase;
    readonly kebabCase: typeof kebabCase;
    readonly constantCase: typeof constantCase;
    readonly dotCase: typeof dotCase;
    readonly pathCase: typeof pathCase;
    readonly sentenceCase: typeof sentenceCase;
    readonly words: typeof words;
    readonly lines: typeof lines;
    readonly chars: typeof chars;
    readonly graphemes: typeof graphemes;
    readonly trimIndent: typeof trimIndent;
    readonly stripMargin: typeof stripMargin;
    readonly stripPrefix: typeof stripPrefix;
    readonly stripSuffix: typeof stripSuffix;
    readonly removeSurrounding: typeof removeSurrounding;
    readonly squeeze: typeof squeeze;
    readonly collapseWhitespace: typeof collapseWhitespace;
    readonly center: typeof center;
    readonly padLeft: typeof padLeft;
    readonly padRight: typeof padRight;
    readonly zfill: typeof zfill;
    readonly truncate: typeof truncate;
    readonly truncateWords: typeof truncateWords;
    readonly ellipsis: typeof ellipsis;
    readonly substringBefore: typeof substringBefore;
    readonly substringAfter: typeof substringAfter;
    readonly substringBeforeLast: typeof substringBeforeLast;
    readonly substringAfterLast: typeof substringAfterLast;
    readonly between: typeof between;
    readonly scan: typeof scan;
    readonly count: typeof count;
    readonly reverse: typeof reverse;
    readonly replaceAll: typeof replaceAll;
    readonly insert: typeof insert;
    readonly remove: typeof remove;
    readonly wrap: typeof wrap;
    readonly unwrap: typeof unwrap;
    readonly indent: typeof indent;
    readonly dedent: typeof dedent;
    readonly mask: typeof mask;
    readonly isBlank: typeof isBlank;
    readonly isNotBlank: typeof isNotBlank;
    readonly isAlpha: typeof isAlpha;
    readonly isAlphaNumeric: typeof isAlphaNumeric;
    readonly isDigit: typeof isDigit;
    readonly isLowerCase: typeof isLowerCase;
    readonly isUpperCase: typeof isUpperCase;
    readonly isAscii: typeof isAscii;
    readonly isPalindrome: typeof isPalindrome;
    readonly isEmail: typeof isEmail;
    readonly isUrl: typeof isUrl;
    readonly isJson: typeof isJson;
    readonly isUuid: typeof isUuid;
    readonly isHex: typeof isHex;
    readonly toSlug: typeof toSlug;
    readonly toNumber: typeof toNumber;
    readonly toInt: typeof toInt$1;
    readonly toFloat: typeof toFloat;
    readonly toBoolean: typeof toBoolean;
    readonly toCharCodes: typeof toCharCodes;
    readonly fromCharCodes: typeof fromCharCodes;
    readonly escapeHtml: typeof escapeHtml;
    readonly unescapeHtml: typeof unescapeHtml;
    readonly escapeRegex: typeof escapeRegex;
    readonly toBase64: typeof toBase64;
    readonly fromBase64: typeof fromBase64;
};

/**
 * Array Extension Methods
 *
 * The best from:
 * - Scala (head, tail, init, last, take, drop, zip, unzip, groupBy, partition,
 *          sliding, grouped, span, splitAt, foldRight, scanLeft, scanRight,
 *          collect, flatMap, distinct, intersperse, mkString, corresponds,
 *          forall, exists, count, minBy, maxBy, sortBy, tails, inits)
 * - Haskell (head, tail, init, last, take, drop, zip, unzip, group, groupBy,
 *            partition, span, break, splitAt, foldl, foldr, scanl, scanr,
 *            intercalate, intersperse, transpose, subsequences, permutations,
 *            nub, nubBy, sort, sortBy, sortOn, tails, inits, isPrefixOf, isSuffixOf)
 * - Ruby (each_cons, each_slice, flatten, compact, zip, uniq, rotate, sample, tally, sum)
 * - Kotlin (chunked, windowed, zipWithNext, associate, associateBy, distinctBy,
 *           flatten, flatMap, groupBy, partition, none, all, any, count, sumOf,
 *           minByOrNull, maxByOrNull, sortedBy, first, last, firstOrNull, lastOrNull)
 * - Rust (chunks, windows, dedup, flatten, chain, enumerate, zip, unzip, partition,
 *         fold, scan, take_while, skip_while, peekable, collect)
 * - Lodash (chunk, compact, difference, intersection, union, uniq, uniqBy, zip,
 *           zipObject, groupBy, keyBy, partition, sortBy, orderBy, flatten, flattenDeep)
 * - Python (enumerate, zip, reversed, sorted, all, any, sum, min, max, filter, map)
 * - Most-requested JS/TS: groupBy, unique, chunk, shuffle, sample, range, zip, compact
 */
declare function head<A>(arr: readonly A[]): A | undefined;
declare function tail<A>(arr: readonly A[]): A[];
declare function init<A>(arr: readonly A[]): A[];
declare function last<A>(arr: readonly A[]): A | undefined;
declare function headOrThrow<A>(arr: readonly A[]): A;
declare function lastOrThrow<A>(arr: readonly A[]): A;
declare function nth<A>(arr: readonly A[], n: number): A | undefined;
declare function take<A>(arr: readonly A[], n: number): A[];
declare function drop<A>(arr: readonly A[], n: number): A[];
declare function takeRight<A>(arr: readonly A[], n: number): A[];
declare function dropRight<A>(arr: readonly A[], n: number): A[];
declare function takeWhile<A>(arr: readonly A[], pred: (a: A) => boolean): A[];
declare function dropWhile<A>(arr: readonly A[], pred: (a: A) => boolean): A[];
declare function splitAt<A>(arr: readonly A[], n: number): [A[], A[]];
declare function span<A>(arr: readonly A[], pred: (a: A) => boolean): [A[], A[]];
declare function groupBy<A, K extends string | number | symbol>(arr: readonly A[], fn: (a: A) => K): Record<K, A[]>;
declare function keyBy<A, K extends string | number | symbol>(arr: readonly A[], fn: (a: A) => K): Record<K, A>;
declare function countBy<A, K extends string | number | symbol>(arr: readonly A[], fn: (a: A) => K): Record<K, number>;
declare function chunk<A>(arr: readonly A[], size: number): A[][];
declare function sliding<A>(arr: readonly A[], size: number, step?: number): A[][];
declare function partition<A>(arr: readonly A[], pred: (a: A) => boolean): [A[], A[]];
declare function zip<A, B>(a: readonly A[], b: readonly B[]): [A, B][];
declare function zip3<A, B, C>(a: readonly A[], b: readonly B[], c: readonly C[]): [A, B, C][];
declare function zipWith<A, B, C>(a: readonly A[], b: readonly B[], fn: (a: A, b: B) => C): C[];
declare function zipWithIndex<A>(arr: readonly A[]): [A, number][];
declare function zipWithNext<A>(arr: readonly A[]): [A, A][];
declare function unzip<A, B>(arr: readonly [A, B][]): [A[], B[]];
declare function unique<A>(arr: readonly A[]): A[];
declare function uniqueBy<A, K>(arr: readonly A[], fn: (a: A) => K): A[];
declare function duplicates<A>(arr: readonly A[]): A[];
declare function frequencies<A>(arr: readonly A[]): Map<A, number>;
declare function difference<A>(a: readonly A[], b: readonly A[]): A[];
declare function intersection<A>(a: readonly A[], b: readonly A[]): A[];
declare function union<A>(a: readonly A[], b: readonly A[]): A[];
declare function symmetricDifference<A>(a: readonly A[], b: readonly A[]): A[];
declare function isSubsetOf<A>(a: readonly A[], b: readonly A[]): boolean;
declare function isSupersetOf<A>(a: readonly A[], b: readonly A[]): boolean;
declare function foldRight<A, B>(arr: readonly A[], init: B, fn: (a: A, acc: B) => B): B;
declare function scanLeft<A, B>(arr: readonly A[], init: B, fn: (acc: B, a: A) => B): B[];
declare function scanRight<A, B>(arr: readonly A[], init: B, fn: (a: A, acc: B) => B): B[];
declare function reduceRight<A>(arr: readonly A[], fn: (a: A, acc: A) => A): A;
declare function sumBy<A>(arr: readonly A[], fn: (a: A) => number): number;
declare function minBy<A>(arr: readonly A[], fn: (a: A) => number): A | undefined;
declare function maxBy<A>(arr: readonly A[], fn: (a: A) => number): A | undefined;
declare function average(arr: readonly number[]): number;
declare function median(arr: readonly number[]): number;
declare function product(arr: readonly number[]): number;
declare function sortBy<A, K>(arr: readonly A[], fn: (a: A) => K): A[];
declare function sortByDesc<A, K>(arr: readonly A[], fn: (a: A) => K): A[];
declare function intersperse<A>(arr: readonly A[], sep: A): A[];
declare function intercalate<A>(arr: readonly A[][], sep: readonly A[]): A[];
declare function compact<A>(arr: readonly (A | null | undefined | false | 0 | "")[]): A[];
declare function flatten<A>(arr: readonly (A | A[])[]): A[];
declare function flattenDeep(arr: readonly unknown[]): unknown[];
declare function rotate<A>(arr: readonly A[], n: number): A[];
declare function transpose<A>(arr: readonly (readonly A[])[]): A[][];
declare function interleave<A>(a: readonly A[], b: readonly A[]): A[];
declare function shuffle<A>(arr: readonly A[]): A[];
declare function sample<A>(arr: readonly A[]): A | undefined;
declare function sampleN<A>(arr: readonly A[], n: number): A[];
declare function none<A>(arr: readonly A[], pred: (a: A) => boolean): boolean;
declare function isPrefixOf<A>(prefix: readonly A[], arr: readonly A[]): boolean;
declare function isSuffixOf<A>(suffix: readonly A[], arr: readonly A[]): boolean;
declare function isSorted<A>(arr: readonly A[], compare?: (a: A, b: A) => number): boolean;
declare function tails<A>(arr: readonly A[]): A[][];
declare function inits<A>(arr: readonly A[]): A[][];
declare function mkString<A>(arr: readonly A[], sep?: string, prefix?: string, suffix?: string): string;
declare function associate<A, K extends string | number | symbol, V>(arr: readonly A[], fn: (a: A) => [K, V]): Record<K, V>;
declare function toMap$1<A, K, V>(arr: readonly A[], fn: (a: A) => [K, V]): Map<K, V>;
declare function toSet<A>(arr: readonly A[]): Set<A>;
declare function zipObject<K extends string | number | symbol, V>(keys: readonly K[], values: readonly V[]): Record<K, V>;
declare const ArrayExt: {
    readonly head: typeof head;
    readonly tail: typeof tail;
    readonly init: typeof init;
    readonly last: typeof last;
    readonly headOrThrow: typeof headOrThrow;
    readonly lastOrThrow: typeof lastOrThrow;
    readonly nth: typeof nth;
    readonly take: typeof take;
    readonly drop: typeof drop;
    readonly takeRight: typeof takeRight;
    readonly dropRight: typeof dropRight;
    readonly takeWhile: typeof takeWhile;
    readonly dropWhile: typeof dropWhile;
    readonly splitAt: typeof splitAt;
    readonly span: typeof span;
    readonly groupBy: typeof groupBy;
    readonly keyBy: typeof keyBy;
    readonly countBy: typeof countBy;
    readonly chunk: typeof chunk;
    readonly sliding: typeof sliding;
    readonly partition: typeof partition;
    readonly zip: typeof zip;
    readonly zip3: typeof zip3;
    readonly zipWith: typeof zipWith;
    readonly zipWithIndex: typeof zipWithIndex;
    readonly zipWithNext: typeof zipWithNext;
    readonly unzip: typeof unzip;
    readonly unique: typeof unique;
    readonly uniqueBy: typeof uniqueBy;
    readonly duplicates: typeof duplicates;
    readonly frequencies: typeof frequencies;
    readonly difference: typeof difference;
    readonly intersection: typeof intersection;
    readonly union: typeof union;
    readonly symmetricDifference: typeof symmetricDifference;
    readonly isSubsetOf: typeof isSubsetOf;
    readonly isSupersetOf: typeof isSupersetOf;
    readonly foldRight: typeof foldRight;
    readonly scanLeft: typeof scanLeft;
    readonly scanRight: typeof scanRight;
    readonly reduceRight: typeof reduceRight;
    readonly sumBy: typeof sumBy;
    readonly minBy: typeof minBy;
    readonly maxBy: typeof maxBy;
    readonly average: typeof average;
    readonly median: typeof median;
    readonly product: typeof product;
    readonly sortBy: typeof sortBy;
    readonly sortByDesc: typeof sortByDesc;
    readonly intersperse: typeof intersperse;
    readonly intercalate: typeof intercalate;
    readonly compact: typeof compact;
    readonly flatten: typeof flatten;
    readonly flattenDeep: typeof flattenDeep;
    readonly rotate: typeof rotate;
    readonly transpose: typeof transpose;
    readonly interleave: typeof interleave;
    readonly shuffle: typeof shuffle;
    readonly sample: typeof sample;
    readonly sampleN: typeof sampleN;
    readonly none: typeof none;
    readonly isPrefixOf: typeof isPrefixOf;
    readonly isSuffixOf: typeof isSuffixOf;
    readonly isSorted: typeof isSorted;
    readonly tails: typeof tails;
    readonly inits: typeof inits;
    readonly mkString: typeof mkString;
    readonly associate: typeof associate;
    readonly toMap: typeof toMap$1;
    readonly toSet: typeof toSet;
    readonly zipObject: typeof zipObject;
};

/**
 * Object/Record Extension Methods
 *
 * The best from:
 * - Lodash (pick, omit, mapValues, mapKeys, merge, defaults, invert, toPairs, fromPairs)
 * - Ramda (assoc, dissoc, evolve, mergeDeepRight, path, pathOr, lens)
 * - Kotlin (toList, toMap, filterKeys, filterValues, mapKeys, mapValues)
 * - Ruby (slice, except, transform_keys, transform_values, deep_merge)
 * - Most-requested JS/TS: deep clone, deep merge, deep equal, get/set path, diff
 */
declare function pick<T extends object, K extends keyof T>(obj: T, keys: readonly K[]): Pick<T, K>;
declare function omit<T extends object, K extends keyof T>(obj: T, keys: readonly K[]): Omit<T, K>;
declare function pickBy<V>(obj: Record<string, V>, pred: (value: V, key: string) => boolean): Record<string, V>;
declare function omitBy<V>(obj: Record<string, V>, pred: (value: V, key: string) => boolean): Record<string, V>;
declare function mapValues<V, U>(obj: Record<string, V>, fn: (value: V, key: string) => U): Record<string, U>;
declare function mapKeys<V>(obj: Record<string, V>, fn: (key: string, value: V) => string): Record<string, V>;
declare function mapEntries<V, U>(obj: Record<string, V>, fn: (key: string, value: V) => [string, U]): Record<string, U>;
declare function filterKeys<V>(obj: Record<string, V>, pred: (key: string) => boolean): Record<string, V>;
declare function filterValues<V>(obj: Record<string, V>, pred: (value: V) => boolean): Record<string, V>;
declare function defaults<T extends object>(obj: T, ...sources: Partial<T>[]): T;
declare function deepMerge<T extends Record<string, unknown>>(target: T, ...sources: Partial<T>[]): T;
declare function getPath(obj: unknown, path: string | readonly string[]): unknown;
declare function getPathOr<T>(obj: unknown, path: string | readonly string[], defaultValue: T): T;
declare function setPath<T extends Record<string, unknown>>(obj: T, path: string | readonly string[], value: unknown): T;
declare function invert(obj: Record<string, string>): Record<string, string>;
declare function toPairs<V>(obj: Record<string, V>): [string, V][];
declare function fromPairs<V>(pairs: readonly [string, V][]): Record<string, V>;
declare function toMap<V>(obj: Record<string, V>): Map<string, V>;
declare function fromMap<V>(map: Map<string, V>): Record<string, V>;
declare function deepClone<T>(obj: T): T;
declare function deepEqual(a: unknown, b: unknown): boolean;
declare function deepFreeze<T extends object>(obj: T): Readonly<T>;
declare function diff(a: Record<string, unknown>, b: Record<string, unknown>): Record<string, {
    from: unknown;
    to: unknown;
}>;
declare function isEmpty(obj: object): boolean;
declare function isNotEmpty(obj: object): boolean;
declare function hasKey(obj: object, key: string): boolean;
declare function size(obj: object): number;
declare const ObjectExt: {
    readonly pick: typeof pick;
    readonly omit: typeof omit;
    readonly pickBy: typeof pickBy;
    readonly omitBy: typeof omitBy;
    readonly mapValues: typeof mapValues;
    readonly mapKeys: typeof mapKeys;
    readonly mapEntries: typeof mapEntries;
    readonly filterKeys: typeof filterKeys;
    readonly filterValues: typeof filterValues;
    readonly defaults: typeof defaults;
    readonly deepMerge: typeof deepMerge;
    readonly getPath: typeof getPath;
    readonly getPathOr: typeof getPathOr;
    readonly setPath: typeof setPath;
    readonly invert: typeof invert;
    readonly toPairs: typeof toPairs;
    readonly fromPairs: typeof fromPairs;
    readonly toMap: typeof toMap;
    readonly fromMap: typeof fromMap;
    readonly deepClone: typeof deepClone;
    readonly deepEqual: typeof deepEqual;
    readonly deepFreeze: typeof deepFreeze;
    readonly diff: typeof diff;
    readonly isEmpty: typeof isEmpty;
    readonly isNotEmpty: typeof isNotEmpty;
    readonly hasKey: typeof hasKey;
    readonly size: typeof size;
};

/**
 * Boolean Extension Methods
 *
 * The best from:
 * - Scala (fold on Boolean, implicit conversions)
 * - Kotlin (compareTo, and/or/xor, toInt)
 * - Rust (then, then_some)
 * - Haskell (bool function, Data.Bool)
 * - Ruby (!, &, |, ^)
 * - Most-requested JS/TS: ternary helpers, toInt, toggle, guard/assert patterns
 */
declare function toInt(b: boolean): 0 | 1;
declare function toSign(b: boolean): -1 | 1;
declare function toString(b: boolean): "true" | "false";
declare function toYesNo(b: boolean): "yes" | "no";
declare function toOnOff(b: boolean): "on" | "off";
/** Returns `value` if `true`, otherwise `undefined`. Like Rust's `then_some`. */
declare function thenSome<A>(b: boolean, value: A): A | undefined;
/** Calls `fn` if `true`, otherwise returns `undefined`. Like Rust's `then`. */
declare function then<A>(b: boolean, fn: () => A): A | undefined;
/** Returns `value` if `false`, otherwise `undefined`. */
declare function elseSome<A>(b: boolean, value: A): A | undefined;
/** `bool(falseVal, trueVal, condition)` — Haskell's `bool` function. */
declare function bool<A>(falseVal: A, trueVal: A, b: boolean): A;
/** Fold a boolean: if true call `onTrue()`, if false call `onFalse()`. */
declare function fold<A>(b: boolean, onFalse: () => A, onTrue: () => A): A;
declare function toggle(b: boolean): boolean;
declare function and(a: boolean, b: boolean): boolean;
declare function or(a: boolean, b: boolean): boolean;
declare function xor(a: boolean, b: boolean): boolean;
declare function nand(a: boolean, b: boolean): boolean;
declare function nor(a: boolean, b: boolean): boolean;
declare function implies(a: boolean, b: boolean): boolean;
/** Throws `error` if the boolean is `false`. Useful as a guard. */
declare function guard(b: boolean, error?: string | Error): void;
/** Returns the value if the boolean is `true`, otherwise throws. */
declare function expect<A>(b: boolean, value: A, error?: string): A;
declare function compareTo(a: boolean, b: boolean): -1 | 0 | 1;
declare const BooleanExt: {
    readonly toInt: typeof toInt;
    readonly toSign: typeof toSign;
    readonly toString: typeof toString;
    readonly toYesNo: typeof toYesNo;
    readonly toOnOff: typeof toOnOff;
    readonly thenSome: typeof thenSome;
    readonly then: typeof then;
    readonly elseSome: typeof elseSome;
    readonly bool: typeof bool;
    readonly fold: typeof fold;
    readonly toggle: typeof toggle;
    readonly and: typeof and;
    readonly or: typeof or;
    readonly xor: typeof xor;
    readonly nand: typeof nand;
    readonly nor: typeof nor;
    readonly implies: typeof implies;
    readonly guard: typeof guard;
    readonly expect: typeof expect;
    readonly compareTo: typeof compareTo;
};

/**
 * Date Extension Methods
 *
 * The best from:
 * - date-fns (addDays, subDays, differenceInDays, format, isAfter, isBefore, startOfDay, etc.)
 * - Moment/Luxon (add, subtract, diff, startOf, endOf, isSame, isBetween)
 * - Kotlin (java.time: plusDays, minusDays, atStartOfDay, until, isAfter, isBefore)
 * - Scala (java.time wrappers)
 * - Ruby (beginning_of_day, end_of_day, ago, since, strftime)
 * - Most-requested JS/TS: relative time, format, add/subtract, diff, start/end of period
 */
declare function addMilliseconds(date: Date, ms: number): Date;
declare function addSeconds(date: Date, seconds: number): Date;
declare function addMinutes(date: Date, minutes: number): Date;
declare function addHours(date: Date, hours: number): Date;
declare function addDays(date: Date, days: number): Date;
declare function addWeeks(date: Date, weeks: number): Date;
declare function addMonths(date: Date, months: number): Date;
declare function addYears(date: Date, years: number): Date;
declare function diffInMilliseconds(a: Date, b: Date): number;
declare function diffInSeconds(a: Date, b: Date): number;
declare function diffInMinutes(a: Date, b: Date): number;
declare function diffInHours(a: Date, b: Date): number;
declare function diffInDays(a: Date, b: Date): number;
declare function diffInWeeks(a: Date, b: Date): number;
declare function diffInMonths(a: Date, b: Date): number;
declare function diffInYears(a: Date, b: Date): number;
declare function startOfDay(date: Date): Date;
declare function endOfDay(date: Date): Date;
declare function startOfWeek(date: Date, weekStartsOn?: number): Date;
declare function startOfMonth(date: Date): Date;
declare function endOfMonth(date: Date): Date;
declare function startOfYear(date: Date): Date;
declare function endOfYear(date: Date): Date;
declare function isAfter(date: Date, other: Date): boolean;
declare function isBefore(date: Date, other: Date): boolean;
declare function isSameDay(a: Date, b: Date): boolean;
declare function isSameMonth(a: Date, b: Date): boolean;
declare function isSameYear(a: Date, b: Date): boolean;
declare function isBetweenDates(date: Date, start: Date, end: Date): boolean;
declare function isToday(date: Date): boolean;
declare function isYesterday(date: Date): boolean;
declare function isTomorrow(date: Date): boolean;
declare function isWeekend(date: Date): boolean;
declare function isWeekday(date: Date): boolean;
declare function isLeapYear(date: Date): boolean;
declare function formatRelative(date: Date, now?: Date): string;
declare function formatISO(date: Date): string;
declare function formatDate(date: Date): string;
declare function formatTime(date: Date): string;
declare function formatDateTime(date: Date): string;
declare function dayOfYear(date: Date): number;
declare function weekOfYear(date: Date): number;
declare function daysInMonth(date: Date): number;
declare function daysInYear(date: Date): number;
declare function quarter(date: Date): number;
declare function clampDate(date: Date, min: Date, max: Date): Date;
declare function minDate(...dates: Date[]): Date;
declare function maxDate(...dates: Date[]): Date;
declare function eachDay(start: Date, end: Date): Date[];
declare const DateExt: {
    readonly addMilliseconds: typeof addMilliseconds;
    readonly addSeconds: typeof addSeconds;
    readonly addMinutes: typeof addMinutes;
    readonly addHours: typeof addHours;
    readonly addDays: typeof addDays;
    readonly addWeeks: typeof addWeeks;
    readonly addMonths: typeof addMonths;
    readonly addYears: typeof addYears;
    readonly diffInMilliseconds: typeof diffInMilliseconds;
    readonly diffInSeconds: typeof diffInSeconds;
    readonly diffInMinutes: typeof diffInMinutes;
    readonly diffInHours: typeof diffInHours;
    readonly diffInDays: typeof diffInDays;
    readonly diffInWeeks: typeof diffInWeeks;
    readonly diffInMonths: typeof diffInMonths;
    readonly diffInYears: typeof diffInYears;
    readonly startOfDay: typeof startOfDay;
    readonly endOfDay: typeof endOfDay;
    readonly startOfWeek: typeof startOfWeek;
    readonly startOfMonth: typeof startOfMonth;
    readonly endOfMonth: typeof endOfMonth;
    readonly startOfYear: typeof startOfYear;
    readonly endOfYear: typeof endOfYear;
    readonly isAfter: typeof isAfter;
    readonly isBefore: typeof isBefore;
    readonly isSameDay: typeof isSameDay;
    readonly isSameMonth: typeof isSameMonth;
    readonly isSameYear: typeof isSameYear;
    readonly isBetween: typeof isBetweenDates;
    readonly isToday: typeof isToday;
    readonly isYesterday: typeof isYesterday;
    readonly isTomorrow: typeof isTomorrow;
    readonly isWeekend: typeof isWeekend;
    readonly isWeekday: typeof isWeekday;
    readonly isLeapYear: typeof isLeapYear;
    readonly formatRelative: typeof formatRelative;
    readonly formatISO: typeof formatISO;
    readonly formatDate: typeof formatDate;
    readonly formatTime: typeof formatTime;
    readonly formatDateTime: typeof formatDateTime;
    readonly dayOfYear: typeof dayOfYear;
    readonly weekOfYear: typeof weekOfYear;
    readonly daysInMonth: typeof daysInMonth;
    readonly daysInYear: typeof daysInYear;
    readonly quarter: typeof quarter;
    readonly clamp: typeof clampDate;
    readonly min: typeof minDate;
    readonly max: typeof maxDate;
    readonly eachDay: typeof eachDay;
};

/**
 * Map & Set Extension Methods
 *
 * The best from:
 * - Scala (mapValues, filterKeys, collect, groupBy, toList, getOrElse, updated)
 * - Kotlin (getOrDefault, getOrPut, filterKeys, filterValues, mapKeys, mapValues, toList)
 * - Haskell (Data.Map: union, intersection, difference, mapWithKey, foldlWithKey)
 * - Ruby (merge, transform_keys, transform_values, select, reject, invert)
 * - Java (computeIfAbsent, merge, replaceAll)
 * - Most-requested JS/TS: getOrDefault, groupBy, invert, merge, toObject
 */
declare function getOrDefault<K, V>(map: Map<K, V>, key: K, defaultValue: V): V;
declare function getOrPut<K, V>(map: Map<K, V>, key: K, factory: () => V): V;
declare function mapMapValues<K, V, U>(map: Map<K, V>, fn: (value: V, key: K) => U): Map<K, U>;
declare function mapMapKeys<K, V, K2>(map: Map<K, V>, fn: (key: K, value: V) => K2): Map<K2, V>;
declare function filterMap<K, V>(map: Map<K, V>, pred: (value: V, key: K) => boolean): Map<K, V>;
declare function filterMapKeys<K, V>(map: Map<K, V>, pred: (key: K) => boolean): Map<K, V>;
declare function filterMapValues<K, V>(map: Map<K, V>, pred: (value: V) => boolean): Map<K, V>;
declare function mergeMap<K, V>(a: Map<K, V>, b: Map<K, V>, resolve?: (va: V, vb: V, key: K) => V): Map<K, V>;
declare function mapUnion<K, V>(a: Map<K, V>, b: Map<K, V>): Map<K, V>;
declare function mapIntersection<K, V>(a: Map<K, V>, b: Map<K, V>): Map<K, V>;
declare function mapDifference<K, V>(a: Map<K, V>, b: Map<K, V>): Map<K, V>;
declare function invertMap<K, V>(map: Map<K, V>): Map<V, K>;
declare function groupMapBy<K, V, G>(map: Map<K, V>, fn: (value: V, key: K) => G): Map<G, Map<K, V>>;
declare function mapToObject<V>(map: Map<string, V>): Record<string, V>;
declare function mapToPairs<K, V>(map: Map<K, V>): [K, V][];
declare function mapFromPairs<K, V>(pairs: readonly [K, V][]): Map<K, V>;
declare function mapFold<K, V, B>(map: Map<K, V>, init: B, fn: (acc: B, value: V, key: K) => B): B;
declare function setUnion<A>(a: Set<A>, b: Set<A>): Set<A>;
declare function setIntersection<A>(a: Set<A>, b: Set<A>): Set<A>;
declare function setDifference<A>(a: Set<A>, b: Set<A>): Set<A>;
declare function setSymmetricDifference<A>(a: Set<A>, b: Set<A>): Set<A>;
declare function isSubset<A>(a: Set<A>, b: Set<A>): boolean;
declare function isSuperset<A>(a: Set<A>, b: Set<A>): boolean;
declare function isDisjoint<A>(a: Set<A>, b: Set<A>): boolean;
declare function setMap<A, B>(set: Set<A>, fn: (a: A) => B): Set<B>;
declare function setFilter<A>(set: Set<A>, pred: (a: A) => boolean): Set<A>;
declare function setPartition<A>(set: Set<A>, pred: (a: A) => boolean): [Set<A>, Set<A>];
declare function setToArray<A>(set: Set<A>): A[];
declare function powerSet<A>(set: Set<A>): Set<Set<A>>;
declare const MapExt: {
    readonly getOrDefault: typeof getOrDefault;
    readonly getOrPut: typeof getOrPut;
    readonly mapValues: typeof mapMapValues;
    readonly mapKeys: typeof mapMapKeys;
    readonly filter: typeof filterMap;
    readonly filterKeys: typeof filterMapKeys;
    readonly filterValues: typeof filterMapValues;
    readonly merge: typeof mergeMap;
    readonly union: typeof mapUnion;
    readonly intersection: typeof mapIntersection;
    readonly difference: typeof mapDifference;
    readonly invert: typeof invertMap;
    readonly groupBy: typeof groupMapBy;
    readonly toObject: typeof mapToObject;
    readonly toPairs: typeof mapToPairs;
    readonly fromPairs: typeof mapFromPairs;
    readonly fold: typeof mapFold;
};
declare const SetExt: {
    readonly union: typeof setUnion;
    readonly intersection: typeof setIntersection;
    readonly difference: typeof setDifference;
    readonly symmetricDifference: typeof setSymmetricDifference;
    readonly isSubset: typeof isSubset;
    readonly isSuperset: typeof isSuperset;
    readonly isDisjoint: typeof isDisjoint;
    readonly map: typeof setMap;
    readonly filter: typeof setFilter;
    readonly partition: typeof setPartition;
    readonly toArray: typeof setToArray;
    readonly powerSet: typeof powerSet;
};

/**
 * Promise & Async Extension Methods
 *
 * The best from:
 * - Bluebird (tap, timeout, delay, retry, map, filter, reduce, props, settle)
 * - p-* ecosystem (p-retry, p-timeout, p-map, p-limit, p-settle, p-queue)
 * - Scala Future (recover, recoverWith, fallbackTo, andThen, transform)
 * - Kotlin coroutines (withTimeout, withTimeoutOrNull, async, supervisorScope)
 * - Most-requested JS/TS: retry, timeout, delay, tap, allSettled helpers, debounce async
 */
declare function delay(ms: number): Promise<void>;
declare function timeout<T>(promise: Promise<T>, ms: number, message?: string): Promise<T>;
declare function timeoutOr<T>(promise: Promise<T>, ms: number, fallback: T): Promise<T>;
interface RetryOptions {
    retries: number;
    delay?: number;
    backoff?: "linear" | "exponential";
    maxDelay?: number;
    onRetry?: (error: Error, attempt: number) => void;
    shouldRetry?: (error: Error) => boolean;
}
declare function retry<T>(fn: (attempt: number) => Promise<T>, options: RetryOptions): Promise<T>;
declare function tap<T>(promise: Promise<T>, fn: (value: T) => void | Promise<void>): Promise<T>;
declare function tapError<T>(promise: Promise<T>, fn: (error: Error) => void | Promise<void>): Promise<T>;
declare function recover<T>(promise: Promise<T>, fn: (error: Error) => T | Promise<T>): Promise<T>;
declare function fallbackTo<T>(promise: Promise<T>, fallback: Promise<T>): Promise<T>;
declare function mapConcurrent<A, B>(items: readonly A[], fn: (item: A, index: number) => Promise<B>, concurrency?: number): Promise<B[]>;
declare function filterConcurrent<A>(items: readonly A[], pred: (item: A, index: number) => Promise<boolean>, concurrency?: number): Promise<A[]>;
interface SettledResult<T> {
    status: "fulfilled" | "rejected";
    value?: T;
    reason?: Error;
}
declare function settle<T>(promises: readonly Promise<T>[]): Promise<SettledResult<T>[]>;
declare function allFulfilled<T>(promises: readonly Promise<T>[]): Promise<T[]>;
declare function props<T extends Record<string, Promise<unknown>>>(obj: T): Promise<{
    [K in keyof T]: Awaited<T[K]>;
}>;
declare function createDeferred<T>(): {
    promise: Promise<T>;
    resolve: (value: T) => void;
    reject: (reason?: unknown) => void;
};
declare function sleep(ms: number): Promise<void>;
declare function lazy<T>(fn: () => Promise<T>): () => Promise<T>;
declare function memo<A extends string | number, T>(fn: (arg: A) => Promise<T>): (arg: A) => Promise<T>;
declare const PromiseExt: {
    readonly delay: typeof delay;
    readonly timeout: typeof timeout;
    readonly timeoutOr: typeof timeoutOr;
    readonly retry: typeof retry;
    readonly tap: typeof tap;
    readonly tapError: typeof tapError;
    readonly recover: typeof recover;
    readonly fallbackTo: typeof fallbackTo;
    readonly mapConcurrent: typeof mapConcurrent;
    readonly filterConcurrent: typeof filterConcurrent;
    readonly settle: typeof settle;
    readonly allFulfilled: typeof allFulfilled;
    readonly props: typeof props;
    readonly createDeferred: typeof createDeferred;
    readonly sleep: typeof sleep;
    readonly lazy: typeof lazy;
    readonly memo: typeof memo;
};

/**
 * Function Extension Methods
 *
 * The best from:
 * - Haskell (const, flip, on, fix, curry, uncurry)
 * - Scala (andThen, compose, tupled, untupled, curried)
 * - Lodash (debounce, throttle, once, memoize, negate, partial, ary, rearg)
 * - Ramda (curry, partial, flip, complement, converge, juxt, tap, tryCatch)
 * - Rust (identity, compose, pipe)
 * - Most-requested JS/TS: debounce, throttle, memoize, once, retry, partial
 */
declare function identity<A>(a: A): A;
declare function constant<A>(a: A): () => A;
declare function flip<A, B, C>(fn: (a: A, b: B) => C): (b: B, a: A) => C;
declare function negate<A extends unknown[]>(fn: (...args: A) => boolean): (...args: A) => boolean;
declare function complement<A extends unknown[]>(fn: (...args: A) => boolean): (...args: A) => boolean;
declare function noop(): void;
declare function absurd(_: never): never;
declare function curry2<A, B, C>(fn: (a: A, b: B) => C): (a: A) => (b: B) => C;
declare function curry3<A, B, C, D>(fn: (a: A, b: B, c: C) => D): (a: A) => (b: B) => (c: C) => D;
declare function uncurry2<A, B, C>(fn: (a: A) => (b: B) => C): (a: A, b: B) => C;
declare function uncurry3<A, B, C, D>(fn: (a: A) => (b: B) => (c: C) => D): (a: A, b: B, c: C) => D;
declare function partial<A, B extends unknown[], C>(fn: (a: A, ...rest: B) => C, a: A): (...rest: B) => C;
declare function partial2<A, B, C extends unknown[], D>(fn: (a: A, b: B, ...rest: C) => D, a: A, b: B): (...rest: C) => D;
declare function tupled<A, B, C>(fn: (a: A, b: B) => C): (args: [A, B]) => C;
declare function tupled3<A, B, C, D>(fn: (a: A, b: B, c: C) => D): (args: [A, B, C]) => D;
declare function untupled<A, B, C>(fn: (args: [A, B]) => C): (a: A, b: B) => C;
declare function debounce<A extends unknown[]>(fn: (...args: A) => void, ms: number): (...args: A) => void;
declare function throttle<A extends unknown[]>(fn: (...args: A) => void, ms: number): (...args: A) => void;
declare function memoize<A extends unknown[], R>(fn: (...args: A) => R, keyFn?: (...args: A) => string): (...args: A) => R;
declare function memoizeWeak<A extends object, R>(fn: (a: A) => R): (a: A) => R;
declare function once<A extends unknown[], R>(fn: (...args: A) => R): (...args: A) => R;
declare function after<A extends unknown[], R>(n: number, fn: (...args: A) => R): (...args: A) => R | undefined;
declare function before<A extends unknown[], R>(n: number, fn: (...args: A) => R): (...args: A) => R | undefined;
declare function tryCatch<A extends unknown[], R, E>(fn: (...args: A) => R, onError: (error: Error, ...args: A) => E): (...args: A) => R | E;
declare function juxt<A extends unknown[], R extends unknown[]>(...fns: {
    [K in keyof R]: (...args: A) => R[K];
}): (...args: A) => R;
declare function converge<A extends unknown[], B extends unknown[], C>(after: (...args: B) => C, ...branches: {
    [K in keyof B]: (...args: A) => B[K];
}): (...args: A) => C;
declare function on<A, B, C>(fn: (b1: B, b2: B) => C, transform: (a: A) => B): (a1: A, a2: A) => C;
declare const FunctionExt: {
    readonly identity: typeof identity;
    readonly constant: typeof constant;
    readonly flip: typeof flip;
    readonly negate: typeof negate;
    readonly complement: typeof complement;
    readonly noop: typeof noop;
    readonly absurd: typeof absurd;
    readonly curry2: typeof curry2;
    readonly curry3: typeof curry3;
    readonly uncurry2: typeof uncurry2;
    readonly uncurry3: typeof uncurry3;
    readonly partial: typeof partial;
    readonly partial2: typeof partial2;
    readonly tupled: typeof tupled;
    readonly tupled3: typeof tupled3;
    readonly untupled: typeof untupled;
    readonly debounce: typeof debounce;
    readonly throttle: typeof throttle;
    readonly memoize: typeof memoize;
    readonly memoizeWeak: typeof memoizeWeak;
    readonly once: typeof once;
    readonly after: typeof after;
    readonly before: typeof before;
    readonly tryCatch: typeof tryCatch;
    readonly juxt: typeof juxt;
    readonly converge: typeof converge;
    readonly on: typeof on;
};

export { ArrayExt, BooleanExt, DateExt, FunctionExt, MapExt, NumberExt, ObjectExt, PromiseExt, type RetryOptions, SetExt, type SettledResult, StringExt, absurd, addDays, addHours, addMilliseconds, addMinutes, addMonths, addSeconds, addWeeks, addYears, after, allFulfilled, groupBy as arrayGroupBy, toMap$1 as arrayToMap, before, toInt as boolToInt, camelCase, capitalize, ceilTo, chunk, clamp, clampDate, compact, complement, constant, converge, createDeferred, curry2, curry3, dayOfYear, daysInMonth, daysInYear, debounce, deepMerge, defaults, delay, diffInDays, diffInHours, diffInMilliseconds, diffInMinutes, diffInMonths, diffInSeconds, diffInWeeks, diffInYears, digitSum, digits, divisors, downTo, dropWhile, eachDay, endOfDay, endOfMonth, endOfYear, factorial, fallbackTo, fibonacci, filterConcurrent, filterMapKeys, filterMapValues, flatten, flip, floorTo, formatDate, formatDateTime, formatISO, formatRelative, formatTime, gcd, identity, intersperse, inverseLerp, invert, isAfter, isBefore, isBetween, isBetweenDates, isBlank, isEven, isFiniteNum, isInteger, isLeapYear, isMultipleOf, isNaN_, isNegative, isOdd, isPerfectSquare, isPositive, isPowerOfTwo, isPrime, isSameDay, isSameMonth, isSameYear, isToday, isTomorrow, isWeekday, isWeekend, isYesterday, isZero, isqrt, juxt, kebabCase, lazy, lcm, lerp, mapConcurrent, mapKeys, mapValues, maxDate, memo, memoize, memoizeWeak, minDate, nCr, nPr, negate, noop, toMap as objectToMap, omit, on, once, padStart, toInt$1 as parseIntSafe, partial, partial2, partition, pascalCase, pick, props, quarter, randomFloat, randomInt, rangeTo, rangeUntil, recover, remap, retry, roundTo, saturatingAdd, saturatingSub, setDifference, setIntersection, setUnion, settle, shuffle, sleep, snakeCase, snap, sortBy, startOfDay, startOfMonth, startOfWeek, startOfYear, takeWhile, tap, tapError, throttle, timeout, timeoutOr, times, timesVoid, toBase, toBin, toCompact, toDuration, toFileSize, toHex, toOct, toOrdinal, toPercent, toRoman, toWords, truncTo, truncate, tryCatch, tupled, tupled3, uncurry2, uncurry3, unique, uniqueBy, untupled, upTo, weekOfYear, words, wrappingAdd, wrappingSub, zip, zipWith };
