radashi 12.1.0 → 12.2.0-beta.0dc9c8a

package/dist/radashi.d.ts

@@ -0,0 +1,1212 @@
+/**
+ * Sort an array without modifying it and return the newly sorted
+ * value. Allows for a string sorting value.
+ */
+declare function alphabetical<T>(array: readonly T[], getter: (item: T) => string, direction?: 'asc' | 'desc'): T[];
+
+/**
+ * Go through a list of items, starting with the first item, and
+ * comparing with the second. Keep the one you want then compare that
+ * to the next item in the list with the same
+ *
+ * ```ts
+ * boil([1, 2, 3, 0], (a, b) => a > b ? a : b) // 3
+ * ```
+ */
+declare function boil<T>(array: readonly T[], compareFunc: (a: T, b: T) => T): T | null;
+
+/**
+ * Splits a single list into many lists of the desired size.
+ *
+ * ```ts
+ * cluster([1, 2, 3, 4, 5, 6], 2)
+ * // [[1, 2], [3, 4], [5, 6]]
+ * ```
+ */
+declare function cluster<T>(array: readonly T[], size?: number): T[][];
+
+/**
+ * Counts the occurrences of each unique value returned by the `identity`
+ * function when applied to each item in the array.
+ *
+ * ```ts
+ * counting([1, 2, 3, 4], (n) => n % 2 === 0 ? 'even' : 'odd')
+ * // { even: 2, odd: 2 }
+ * ```
+ */
+declare function counting<T, TId extends string | number | symbol>(array: readonly T[], identity: (item: T) => TId): Record<TId, number>;
+
+/**
+ * Returns all items from the first list that do not exist in the
+ * second list.
+ *
+ * ```ts
+ * diff([1, 2, 3, 4], [2, 4])
+ * // [1, 3]
+ *
+ * diff([{a:1}, {a:2}, {a:3}], [{a:2}, {a:4}], (n) => n.a)
+ * // [{a:1}, {a:3}]
+ * ```
+ */
+declare function diff<T>(root: readonly T[], other: readonly T[], identity?: (item: T) => string | number | symbol): T[];
+
+/**
+ * Get the first item in an array or a default value
+ *
+ * ```ts
+ * first([1, 2, 3, 4])
+ * // 1
+ *
+ * first([], 0)
+ * // 0
+ * ```
+ */
+declare function first<T>(array: readonly T[]): T | undefined;
+declare function first<T, U>(array: readonly T[], defaultValue: U): T | U;
+
+/**
+ * Given an array of arrays, returns a single dimensional array with
+ * all items in it.
+ *
+ * ```ts
+ * flat([[1, 2], [[3], 4], [5]])
+ * // [1, 2, [3], 4, 5]
+ * ```
+ */
+declare function flat<T>(lists: readonly T[][]): T[];
+
+/**
+ * Split an array into two array based on a true/false condition
+ * function
+ *
+ * ```ts
+ * fork([1, 2, 3, 4], (n) => n % 2 === 0)
+ * // [[2, 4], [1, 3]]
+ * ```
+ */
+declare function fork<T>(array: readonly T[], condition: (item: T) => boolean): [T[], T[]];
+
+/**
+ * Sorts an `array` of items into groups. The return value is a map
+ * where the keys are the group IDs the given `getGroupId` function
+ * produced and the value is an array of each item in that group.
+ *
+ * ```ts
+ * group([1, 2, 3, 4], (n) => n % 2 === 0 ? 'even' : 'odd')
+ * // { even: [2], odd: [1, 3, 4] }
+ * ```
+ */
+declare function group<T, Key extends string | number | symbol>(array: readonly T[], getGroupId: (item: T) => Key): {
+    [K in Key]?: T[];
+};
+
+/**
+ * Given two arrays, returns true if any elements intersect.
+ *
+ * ```ts
+ * intersects([1, 2, 3], [4, 5, 6])
+ * // false
+ *
+ * intersects([1, 0, 0], [0, 1], (n) => n > 1)
+ * // true
+ * ```
+ */
+declare function intersects<T, K>(listA: readonly T[], listB: readonly T[], identity?: (t: T) => K): boolean;
+
+/**
+ * Like a reduce but does not require an array. Only need a number and
+ * will iterate the function as many times as specified.
+ *
+ * NOTE: This is NOT zero indexed. If you pass count=5 you will get 1,
+ * 2, 3, 4, 5 iteration in the callback function
+ *
+ * ```ts
+ * iterate(3, (total, i) => total + i, 0)
+ * // 6
+ * ```
+ */
+declare function iterate<T>(count: number, func: (currentValue: T, iteration: number) => T, initValue: T): T;
+
+/**
+ * Get the last item in an array or a default value
+ *
+ * ```ts
+ * last([1, 2, 3, 4])
+ * // 4
+ *
+ * last([], 0)
+ * // 0
+ * ```
+ */
+declare function last<T>(array: readonly T[]): T | undefined;
+declare function last<T, U>(array: readonly T[], defaultValue: U): T | U;
+
+/**
+ * Creates a list of given start, end, value, and step parameters.
+ *
+ * ```ts
+ * list(3)                  // 0, 1, 2, 3
+ * list(0, 3)               // 0, 1, 2, 3
+ * list(0, 3, 'y')          // y, y, y, y
+ * list(0, 3, () => 'y')    // y, y, y, y
+ * list(0, 3, i => i)       // 0, 1, 2, 3
+ * list(0, 3, i => `y${i}`) // y0, y1, y2, y3
+ * list(0, 3, obj)          // obj, obj, obj, obj
+ * list(0, 6, i => i, 2)    // 0, 2, 4, 6
+ * ```
+ */
+declare function list<T = number>(startOrLength: number, end?: number, valueOrMapper?: T | ((i: number) => T), step?: number): T[];
+
+declare function mapify<T, Key, Value = T>(array: readonly T[], getKey: (item: T) => Key, getValue?: (item: T) => Value): Map<Key, Value>;
+
+/**
+ * Max gets the greatest value from a list
+ *
+ * ```ts
+ * max([2, 3, 5]) // => 5
+ * max([{ num: 1 }, { num: 2 }], x => x.num) // => { num: 2 }
+ * ```
+ */
+declare function max(array: readonly [number, ...number[]]): number;
+declare function max(array: readonly number[]): number | null;
+declare function max<T>(array: readonly T[], getter: (item: T) => number): T | null;
+
+/**
+ * Given two arrays of the same type, iterate the first list and
+ * replace items matched by the `matcher` function in the first place.
+ * The given arrays are never modified.
+ *
+ * ```ts
+ * merge(
+ *   [{id: 1}, {id: 2}],
+ *   [{id: 3}, {id: 1, name: 'John'}],
+ *   (obj) => obj.id
+ * )
+ * // [{id: 1, name: 'John'}, {id: 2}]
+ * ```
+ */
+declare function merge<T>(prev: readonly T[], array: readonly T[], toKey: (item: T) => any): T[];
+
+/**
+ * Min gets the smallest value from a list
+ *
+ * ```ts
+ * min([1, 2, 3, 4]) // => 1
+ * min([{ num: 1 }, { num: 2 }], x => x.num) // => { num: 1 }
+ * ```
+ */
+declare function min(array: readonly [number, ...number[]]): number;
+declare function min(array: readonly number[]): number | null;
+declare function min<T>(array: readonly T[], getter: (item: T) => number): T | null;
+
+/**
+ * Convert an array to a dictionary by mapping each item into a
+ * dictionary key & value
+ *
+ * ```ts
+ * objectify([1, 2, 3], (n) => '#' + n)
+ * // { '#1': 1, '#2': 2, '#3': 3 }
+ *
+ * objectify(
+ *   [{id: 1, name: 'John'}, {id: 2, name: 'Jane'}],
+ *   (obj) => obj.id,
+ *   (obj) => obj.name
+ * )
+ * // { 1: 'John', 2: 'Jane' }
+ * ```
+ */
+declare function objectify<T, Key extends string | number | symbol, Value = T>(array: readonly T[], getKey: (item: T) => Key, getValue?: (item: T) => Value): Record<Key, Value>;
+
+/**
+ * Creates a generator that will produce an iteration through the
+ * range of number as requested.
+ *
+ * ```ts
+ * range(3)                  // yields 0, 1, 2, 3
+ * range(0, 3)               // yields 0, 1, 2, 3
+ * range(0, 3, 'y')          // yields y, y, y, y
+ * range(0, 3, () => 'y')    // yields y, y, y, y
+ * range(0, 3, i => i)       // yields 0, 1, 2, 3
+ * range(0, 3, i => `y${i}`) // yields y0, y1, y2, y3
+ * range(0, 3, obj)          // yields obj, obj, obj, obj
+ * range(0, 6, i => i, 2)    // yields 0, 2, 4, 6
+ * ```
+ */
+declare function range<T = number>(startOrLength: number, end?: number, valueOrMapper?: T | ((i: number) => T), step?: number): Generator<T>;
+
+/**
+ * Replace an element in an array with a new item without modifying
+ * the array and return the new value
+ *
+ * ```ts
+ * replace([1, 2, 3], 4, (n) => n === 2)
+ * // [1, 4, 3]
+ * ```
+ */
+declare function replace<T>(array: readonly T[], newItem: T, match: (item: T, idx: number) => boolean): T[];
+
+/**
+ * Replace the first occurrence of an item in an array where the
+ * `match` function returns true. If no items match, append the new
+ * item to the end of the list.
+ *
+ * ```ts
+ * replaceOrAppend([1, 2, 3], 4, (n) => n > 1)
+ * // [1, 4, 3]
+ *
+ * replaceOrAppend([1, 2, 3], 4, (n) => n > 100)
+ * // [1, 2, 3, 4]
+ * ```
+ */
+declare function replaceOrAppend<T>(array: readonly T[], newItem: T, match: (a: T, idx: number) => boolean): T[];
+
+/**
+ * Select performs a filter and a mapper inside of a reduce, only
+ * iterating the list one time. If condition is omitted, will
+ * select all mapped values that are non-nullish.
+ *
+ * ```ts
+ * select(
+ *   [1, 2, 3, 4],
+ *   x => x * x,
+ *   x => x > 2
+ * )
+ * // => [9, 16]
+ * ```
+ */
+declare function select<T, U>(array: readonly T[], mapper: (item: T, index: number) => U, condition: (item: T, index: number) => boolean): U[];
+declare function select<T, U>(array: readonly T[], mapper: (item: T, index: number) => U | null | undefined): U[];
+
+/**
+ * Select performs a find + map operation, short-circuiting on the first
+ * element that satisfies the prescribed condition. If condition is omitted,
+ * will select the first mapped value which is non-nullish.
+ *
+ * ```ts
+ * selectFirst(
+ *   [1, 2, 3, 4],
+ *   x => x * x,
+ *   x => x > 2
+ * )
+ * // => 9
+ * ```
+ */
+declare function selectFirst<T, U>(array: readonly T[], mapper: (item: T, index: number) => U, condition?: (item: T, index: number) => boolean): U | undefined;
+
+/**
+ * Shifts array items by `n` steps. If `n` is greater than 0, items
+ * will shift `n` steps to the right. If `n` is less than 0, items
+ * will shift `n` steps to the left.
+ *
+ * ```ts
+ * shift([1, 2, 3], 1) // [3, 1, 2]
+ * shift([1, 2, 3], -1) // [2, 3, 1]
+ * ```
+ */
+declare function shift<T>(arr: T[], n: number): T[];
+
+type Falsy = null | undefined | false | '' | 0 | 0n;
+/**
+ * Given a list returns a new list with only truthy values
+ *
+ * ```ts
+ * sift([0, 1, undefined, null, 2, false, 3, ''])
+ * // => [1, 2, 3]
+ * ```
+ */
+declare function sift<T>(array: readonly (T | Falsy)[]): T[];
+
+/**
+ * Sort an array without modifying it and return the newly sorted
+ * value
+ *
+ * ```ts
+ * const fish = [
+ *   { name: 'Marlin', weight: 105 },
+ *   { name: 'Bass', weight: 8 },
+ *   { name: 'Trout', weight: 13 }
+ * ]
+ *
+ * sort(fish, f => f.weight) // => [Bass, Trout, Marlin]
+ * sort(fish, f => f.weight, true) // => [Marlin, Trout, Bass]
+ * ```
+ */
+declare function sort<T>(array: readonly T[], getter: (item: T) => number, desc?: boolean): T[];
+
+/**
+ * Sum all numbers in an array. Optionally provide a function to
+ * convert objects in the array to number values.
+ *
+ * ```ts
+ * sum([1, 2, 3])
+ * // => 6
+ *
+ * sum([
+ *   {value: 1},
+ *   {value: 2},
+ *   {value: 3}
+ * ], (item) => item.value)
+ * // => 6
+ * ```
+ */
+declare function sum<T extends number>(array: readonly T[]): number;
+declare function sum<T extends object>(array: readonly T[], fn: (item: T) => number): number;
+
+/**
+ * If the item matching the condition already exists in the list it
+ * will be removed. If it does not it will be added.
+ *
+ * ```ts
+ * toggle([1, 2, 3], 4) // => [1, 2, 3, 4]
+ * toggle([1, 2, 3], 2) // => [1, 3]
+ *
+ * toggle(
+ *   [
+ *     { id: 1 },
+ *     { id: 2 },
+ *   ],
+ *   { id: 3 },
+ *   (obj) => obj.id,
+ *   { strategy: 'prepend' }
+ * )
+ * // => [{ id: 3 }, { id: 1 }, { id: 2 }]
+ * ```
+ */
+declare function toggle<T>(array: readonly T[], item: T, 
+/**
+ * Converts an item of type T item into a value that can be checked
+ * for equality
+ */
+toKey?: null | ((item: T, idx: number) => number | string | symbol), options?: {
+    strategy?: 'prepend' | 'append';
+}): T[];
+
+/**
+ * Given a list of items returns a new list with only unique items.
+ * Accepts an optional identity function to convert each item in the
+ * list to a comparable identity value
+ *
+ * ```ts
+ * unique([1, 1, 2, 2]) // => [1, 2]
+ * unique([1, 2, 3], (n) => n % 2) // => [1, 2]
+ * ```
+ */
+declare function unique<T, K = T>(array: readonly T[], toKey?: (item: T) => K): T[];
+
+/**
+ * Creates an array of ungrouped elements, where each resulting array
+ * contains all elements at a specific index from the input arrays.
+ * The first array contains all first elements, the second array
+ * contains all second elements, and so on.
+ *
+ * ```ts
+ * unzip([['a', 1, true], ['b', 2, false]])
+ * // [['a', 'b'], [1, 2], [true, false]]
+ * ```
+ */
+declare function unzip<T>(arrays: readonly (readonly T[])[]): T[][];
+
+/**
+ * Creates an array of grouped elements, the first of which contains
+ * the first elements of the given arrays, the second of which
+ * contains the second elements of the given arrays, and so on.
+ *
+ * ```ts
+ * zip(['a', 'b'], [1, 2], [true, false])
+ * // [['a', 1, true], ['b', 2, false]]
+ * ```
+ */
+declare function zip<T1, T2, T3, T4, T5>(array1: readonly T1[], array2: readonly T2[], array3: readonly T3[], array4: readonly T4[], array5: readonly T5[]): [T1, T2, T3, T4, T5][];
+declare function zip<T1, T2, T3, T4>(array1: readonly T1[], array2: readonly T2[], array3: readonly T3[], array4: readonly T4[]): [T1, T2, T3, T4][];
+declare function zip<T1, T2, T3>(array1: readonly T1[], array2: readonly T2[], array3: readonly T3[]): [T1, T2, T3][];
+declare function zip<T1, T2>(array1: readonly T1[], array2: readonly T2[]): [T1, T2][];
+
+/**
+ * Creates an object mapping the specified keys to their corresponding
+ * values
+ *
+ * ```ts
+ * zipToObject(['a', 'b'], [1, 2])
+ * // { a: 1, b: 2 }
+ *
+ * zipToObject(['a', 'b'], (k, i) => k + i)
+ * // { a: 'a0', b: 'b1' }
+ *
+ * zipToObject(['a', 'b'], 1)
+ * // { a: 1, b: 1 }
+ * ```
+ */
+declare function zipToObject<K extends string | number | symbol, V>(keys: K[], values: V | ((key: K, idx: number) => V) | V[]): Record<K, V>;
+
+/**
+ * Support for the built-in AggregateError is still new. Node < 15
+ * doesn't have it so patching here.
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AggregateError#browser_compatibility
+ */
+declare class AggregateError extends Error {
+    errors: Error[];
+    constructor(errors?: Error[]);
+}
+
+type PromiseValues<T extends Promise<any>[]> = {
+    [K in keyof T]: T[K] extends Promise<infer U> ? U : never;
+};
+/**
+ * Functionally similar to `Promise.all` or `Promise.allSettled`. If
+ * any errors are thrown, all errors are gathered and thrown in an
+ * `AggregateError`.
+ *
+ * ```ts
+ * const [user] = await all([
+ *   api.users.create(...),
+ *   s3.buckets.create(...),
+ *   slack.customerSuccessChannel.sendMessage(...)
+ * ])
+ * ```
+ */
+declare function all<T extends [Promise<any>, ...Promise<any>[]]>(promises: T): Promise<PromiseValues<T>>;
+declare function all<T extends Promise<any>[]>(promises: T): Promise<PromiseValues<T>>;
+/**
+ * Functionally similar to `Promise.all` or `Promise.allSettled`. If
+ * any errors are thrown, all errors are gathered and thrown in an
+ * `AggregateError`.
+ *
+ * ```ts
+ * const { user } = await all({
+ *   user: api.users.create(...),
+ *   bucket: s3.buckets.create(...),
+ *   message: slack.customerSuccessChannel.sendMessage(...)
+ * })
+ * ```
+ */
+declare function all<T extends Record<string, Promise<any>>>(promises: T): Promise<{
+    [K in keyof T]: Awaited<T[K]>;
+}>;
+
+/**
+ * Useful when for script like things where cleanup should be done on
+ * fail or sucess no matter.
+ *
+ * You can call defer many times to register many defered functions
+ * that will all be called when the function exits in any state.
+ */
+declare function defer<TResponse>(func: (register: (fn: (error?: any) => any, options?: {
+    rethrow?: boolean;
+}) => void) => Promise<TResponse>): Promise<TResponse>;
+
+/**
+ * A helper to try an async function that returns undefined if it
+ * fails.
+ *
+ * ```ts
+ * const result = await guard(fetchUsers)() ?? [];
+ * ```
+ */
+declare function guard<TFunction extends () => any>(func: TFunction, shouldGuard?: (err: any) => boolean): ReturnType<TFunction> extends Promise<any> ? Promise<Awaited<ReturnType<TFunction>> | undefined> : ReturnType<TFunction> | undefined;
+
+/**
+ * An async map function. Works like the built-in Array.map function
+ * but handles an async mapper function
+ */
+declare function map<T, K>(array: readonly T[], asyncMapFunc: (item: T, index: number) => Promise<K>): Promise<K[]>;
+
+/**
+ * Executes many async functions in parallel. Returns the results from
+ * all functions as an array. After all functions have resolved, if
+ * any errors were thrown, they are rethrown in an instance of
+ * AggregateError
+ */
+declare function parallel<T, K>(limit: number, array: readonly T[], func: (item: T) => Promise<K>): Promise<K[]>;
+
+/**
+ * An async reduce function. Works like the built-in Array.reduce
+ * function but handles an async reducer function
+ */
+declare function reduce<T, K>(array: readonly T[], asyncReducer: (acc: K, item: T, index: number) => Promise<K>, initValue?: K): Promise<K>;
+
+type RetryOptions = {
+    times?: number;
+    delay?: number | null;
+    backoff?: (count: number) => number;
+};
+/**
+ * Retries the given function the specified number of times.
+ */
+declare function retry<TResponse>(options: RetryOptions, func: (exit: (err: any) => void) => Promise<TResponse>): Promise<TResponse>;
+
+/**
+ * Async wait
+ */
+declare function sleep(milliseconds: number): Promise<void>;
+
+/**
+ * The result of a `tryit` function.
+ *
+ * If the function returns a promise, the result is a promise that
+ * resolves to an error-first callback-_like_ array response as
+ * `[Error, result]`.
+ *
+ * If the function returns a non-promise, the result is an error-first
+ * callback-_like_ array response as `[Error, result]`.
+ */
+type TryitResult<Return> = Return extends Promise<any> ? Promise<[Error, undefined] | [undefined, Awaited<Return>]> : [Error, undefined] | [undefined, Return];
+/**
+ * A helper to try an async function without forking the control flow.
+ * Returns an error-first callback-_like_ array response as `[Error,
+ * result]`
+ */
+declare function tryit<Args extends any[], Return>(func: (...args: Args) => Return): (...args: Args) => TryitResult<Return>;
+
+/**
+ * Make an object callable. Given an object and a function the
+ * returned object will be a function with all the objects properties.
+ *
+ * ```ts
+ * const car = callable({
+ *   wheels: 2
+ * }, self => () => {
+ *   return 'driving'
+ * })
+ *
+ * car.wheels // => 2
+ * car() // => 'driving'
+ * ```
+ */
+declare function callable<TValue, TObj extends Record<string | number | symbol, TValue>, TFunc extends (...args: any) => any>(obj: TObj, fn: (self: TObj) => TFunc): TObj & TFunc;
+
+declare function chain<T1 extends any[], T2, T3>(f1: (...arg: T1) => T2, f2: (arg: T2) => T3): (...arg: T1) => T3;
+declare function chain<T1 extends any[], T2, T3, T4>(f1: (...arg: T1) => T2, f2: (arg: T2) => T3, f3: (arg: T3) => T4): (...arg: T1) => T4;
+declare function chain<T1 extends any[], T2, T3, T4, T5>(f1: (...arg: T1) => T2, f2: (arg: T2) => T3, f3: (arg: T3) => T4, f4: (arg: T3) => T5): (...arg: T1) => T5;
+declare function chain<T1 extends any[], T2, T3, T4, T5, T6>(f1: (...arg: T1) => T2, f2: (arg: T2) => T3, f3: (arg: T3) => T4, f4: (arg: T3) => T5, f5: (arg: T3) => T6): (...arg: T1) => T6;
+declare function chain<T1 extends any[], T2, T3, T4, T5, T6, T7>(f1: (...arg: T1) => T2, f2: (arg: T2) => T3, f3: (arg: T3) => T4, f4: (arg: T3) => T5, f5: (arg: T3) => T6, f6: (arg: T3) => T7): (...arg: T1) => T7;
+declare function chain<T1 extends any[], T2, T3, T4, T5, T6, T7, T8>(f1: (...arg: T1) => T2, f2: (arg: T2) => T3, f3: (arg: T3) => T4, f4: (arg: T3) => T5, f5: (arg: T3) => T6, f6: (arg: T3) => T7, f7: (arg: T3) => T8): (...arg: T1) => T8;
+declare function chain<T1 extends any[], T2, T3, T4, T5, T6, T7, T8, T9>(f1: (...arg: T1) => T2, f2: (arg: T2) => T3, f3: (arg: T3) => T4, f4: (arg: T3) => T5, f5: (arg: T3) => T6, f6: (arg: T3) => T7, f7: (arg: T3) => T8, f8: (arg: T3) => T9): (...arg: T1) => T9;
+declare function chain<T1 extends any[], T2, T3, T4, T5, T6, T7, T8, T9, T10>(f1: (...arg: T1) => T2, f2: (arg: T2) => T3, f3: (arg: T3) => T4, f4: (arg: T3) => T5, f5: (arg: T3) => T6, f6: (arg: T3) => T7, f7: (arg: T3) => T8, f8: (arg: T3) => T9, f9: (arg: T3) => T10): (...arg: T1) => T10;
+declare function chain<T1 extends any[], T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(f1: (...arg: T1) => T2, f2: (arg: T2) => T3, f3: (arg: T3) => T4, f4: (arg: T3) => T5, f5: (arg: T3) => T6, f6: (arg: T3) => T7, f7: (arg: T3) => T8, f8: (arg: T3) => T9, f9: (arg: T3) => T10, f10: (arg: T3) => T11): (...arg: T1) => T11;
+
+declare function compose<F1Result, F1Args extends any[], F1NextArgs extends any[], LastResult>(f1: (next: (...args: F1NextArgs) => LastResult) => (...args: F1Args) => F1Result, last: (...args: F1NextArgs) => LastResult): (...args: F1Args) => F1Result;
+declare function compose<F1Result, F1Args extends any[], F1NextArgs extends any[], F2Result, F2NextArgs extends any[], LastResult>(f1: (next: (...args: F1NextArgs) => F2Result) => (...args: F1Args) => F1Result, f2: (next: (...args: F2NextArgs) => LastResult) => (...args: F1NextArgs) => F2Result, last: (...args: F2NextArgs) => LastResult): (...args: F1Args) => F1Result;
+declare function compose<F1Result, F1Args extends any[], F1NextArgs extends any[], F2NextArgs extends any[], F2Result, F3NextArgs extends any[], F3Result, LastResult>(f1: (next: (...args: F1NextArgs) => F2Result) => (...args: F1Args) => F1Result, f2: (next: (...args: F2NextArgs) => F3Result) => (...args: F1NextArgs) => F2Result, f3: (next: (...args: F3NextArgs) => LastResult) => (...args: F2NextArgs) => F3Result, last: (...args: F3NextArgs) => LastResult): (...args: F1Args) => F1Result;
+declare function compose<F1Result, F1Args extends any[], F1NextArgs extends any[], F2NextArgs extends any[], F2Result, F3NextArgs extends any[], F3Result, F4NextArgs extends any[], F4Result, LastResult>(f1: (next: (...args: F1NextArgs) => F2Result) => (...args: F1Args) => F1Result, f2: (next: (...args: F2NextArgs) => F3Result) => (...args: F1NextArgs) => F2Result, f3: (next: (...args: F3NextArgs) => F4Result) => (...args: F2NextArgs) => F3Result, f4: (next: (...args: F4NextArgs) => LastResult) => (...args: F3NextArgs) => F4Result, last: (...args: F4NextArgs) => LastResult): (...args: F1Args) => F1Result;
+declare function compose<F1Result, F1Args extends any[], F1NextArgs extends any[], F2NextArgs extends any[], F2Result, F3NextArgs extends any[], F3Result, F4NextArgs extends any[], F4Result, F5NextArgs extends any[], F5Result, LastResult>(f1: (next: (...args: F1NextArgs) => F2Result) => (...args: F1Args) => F1Result, f2: (next: (...args: F2NextArgs) => F3Result) => (...args: F1NextArgs) => F2Result, f3: (next: (...args: F3NextArgs) => F4Result) => (...args: F2NextArgs) => F3Result, f4: (next: (...args: F4NextArgs) => F5Result) => (...args: F3NextArgs) => F4Result, f5: (next: (...args: F5NextArgs) => LastResult) => (...args: F4NextArgs) => F5Result, last: (...args: F5NextArgs) => LastResult): (...args: F1Args) => F1Result;
+declare function compose<F1Result, F1Args extends any[], F1NextArgs extends any[], F2NextArgs extends any[], F2Result, F3NextArgs extends any[], F3Result, F4NextArgs extends any[], F4Result, F5NextArgs extends any[], F5Result, F6NextArgs extends any[], F6Result, LastResult>(f1: (next: (...args: F1NextArgs) => F2Result) => (...args: F1Args) => F1Result, f2: (next: (...args: F2NextArgs) => F3Result) => (...args: F1NextArgs) => F2Result, f3: (next: (...args: F3NextArgs) => F4Result) => (...args: F2NextArgs) => F3Result, f4: (next: (...args: F4NextArgs) => F5Result) => (...args: F3NextArgs) => F4Result, f5: (next: (...args: F5NextArgs) => F6Result) => (...args: F4NextArgs) => F5Result, f6: (next: (...args: F6NextArgs) => LastResult) => (...args: F5NextArgs) => F6Result, last: (...args: F6NextArgs) => LastResult): (...args: F1Args) => F1Result;
+declare function compose<F1Result, F1Args extends any[], F1NextArgs extends any[], F2NextArgs extends any[], F2Result, F3NextArgs extends any[], F3Result, F4NextArgs extends any[], F4Result, F5NextArgs extends any[], F5Result, F6NextArgs extends any[], F6Result, F7NextArgs extends any[], F7Result, LastResult>(f1: (next: (...args: F1NextArgs) => F2Result) => (...args: F1Args) => F1Result, f2: (next: (...args: F2NextArgs) => F3Result) => (...args: F1NextArgs) => F2Result, f3: (next: (...args: F3NextArgs) => F4Result) => (...args: F2NextArgs) => F3Result, f4: (next: (...args: F4NextArgs) => F5Result) => (...args: F3NextArgs) => F4Result, f5: (next: (...args: F5NextArgs) => F6Result) => (...args: F4NextArgs) => F5Result, f6: (next: (...args: F6NextArgs) => F7Result) => (...args: F5NextArgs) => F6Result, f7: (next: (...args: F7NextArgs) => LastResult) => (...args: F6NextArgs) => F7Result, last: (...args: F7NextArgs) => LastResult): (...args: F1Args) => F1Result;
+declare function compose<F1Result, F1Args extends any[], F1NextArgs extends any[], F2NextArgs extends any[], F2Result, F3NextArgs extends any[], F3Result, F4NextArgs extends any[], F4Result, F5NextArgs extends any[], F5Result, F6NextArgs extends any[], F6Result, F7NextArgs extends any[], F7Result, F8NextArgs extends any[], F8Result, LastResult>(f1: (next: (...args: F1NextArgs) => F2Result) => (...args: F1Args) => F1Result, f2: (next: (...args: F2NextArgs) => F3Result) => (...args: F1NextArgs) => F2Result, f3: (next: (...args: F3NextArgs) => F4Result) => (...args: F2NextArgs) => F3Result, f4: (next: (...args: F4NextArgs) => F5Result) => (...args: F3NextArgs) => F4Result, f5: (next: (...args: F5NextArgs) => F6Result) => (...args: F4NextArgs) => F5Result, f6: (next: (...args: F6NextArgs) => F7Result) => (...args: F5NextArgs) => F6Result, f7: (next: (...args: F7NextArgs) => LastResult) => (...args: F6NextArgs) => F7Result, f8: (next: (...args: F8NextArgs) => LastResult) => (...args: F7NextArgs) => F8Result, last: (...args: F8NextArgs) => LastResult): (...args: F1Args) => F1Result;
+declare function compose<F1Result, F1Args extends any[], F1NextArgs extends any[], F2NextArgs extends any[], F2Result, F3NextArgs extends any[], F3Result, F4NextArgs extends any[], F4Result, F5NextArgs extends any[], F5Result, F6NextArgs extends any[], F6Result, F7NextArgs extends any[], F7Result, F8NextArgs extends any[], F8Result, F9NextArgs extends any[], F9Result, LastResult>(f1: (next: (...args: F1NextArgs) => F2Result) => (...args: F1Args) => F1Result, f2: (next: (...args: F2NextArgs) => F3Result) => (...args: F1NextArgs) => F2Result, f3: (next: (...args: F3NextArgs) => F4Result) => (...args: F2NextArgs) => F3Result, f4: (next: (...args: F4NextArgs) => F5Result) => (...args: F3NextArgs) => F4Result, f5: (next: (...args: F5NextArgs) => F6Result) => (...args: F4NextArgs) => F5Result, f6: (next: (...args: F6NextArgs) => F7Result) => (...args: F5NextArgs) => F6Result, f7: (next: (...args: F7NextArgs) => LastResult) => (...args: F6NextArgs) => F7Result, f8: (next: (...args: F8NextArgs) => LastResult) => (...args: F7NextArgs) => F8Result, f9: (next: (...args: F9NextArgs) => LastResult) => (...args: F8NextArgs) => F9Result, last: (...args: F9NextArgs) => LastResult): (...args: F1Args) => F1Result;
+
+type DebounceFunction<TArgs extends any[]> = {
+    (...args: TArgs): void;
+    /**
+     * Cancels the debounced function
+     */
+    cancel(): void;
+    /**
+     * Checks if there is any invocation debounced
+     */
+    isPending(): boolean;
+    /**
+     * Runs the debounced function immediately
+     */
+    flush(...args: TArgs): void;
+};
+/**
+ * Given a delay and a function returns a new function that will only
+ * call the source function after delay milliseconds have passed
+ * without any invocations.
+ *
+ * The debounce function comes with a `cancel` method to cancel
+ * delayed `func` invocations and a `flush` method to invoke them
+ * immediately
+ */
+declare function debounce<TArgs extends any[]>({ delay }: {
+    delay: number;
+}, func: (...args: TArgs) => any): DebounceFunction<TArgs>;
+
+declare function flip<Args extends any[], Result>(fn: (...args: Args) => Result): (...args: Flip<Args>) => Result;
+type Flip<T extends any[]> = T extends [infer A, infer B, ...infer R] ? [B, A, ...R] : never;
+
+interface MemoOptions<TArgs extends any[]> {
+    key?: (...args: TArgs) => string;
+    ttl?: number;
+}
+/**
+ * Creates a memoized function. The returned function will only
+ * execute the source function when no value has previously been
+ * computed. If a ttl (milliseconds) is given previously computed
+ * values will be checked for expiration before being returned.
+ */
+declare function memo<TArgs extends any[], TResult>(func: (...args: TArgs) => TResult, options?: MemoOptions<TArgs>): (...args: TArgs) => TResult;
+
+declare const onceSymbol: unique symbol;
+/**
+ * The type of a function wrapped with `once`.
+ */
+interface OnceFunction<Args extends unknown[] = unknown[], Return = unknown, This = unknown> {
+    (this: This, ...args: Args): Return;
+    [onceSymbol]?: Return | typeof onceSymbol;
+}
+/**
+ * Create a function that runs at most once, no matter how many times
+ * it's called. If it was already called before, returns the result
+ * from the first call. This is a lighter version of `memo()`.
+ *
+ * To allow the function to be called again, use `onceReset()`.
+ *
+ * ```ts
+ * const fn = once(() => Math.random())
+ * fn() // 0.5
+ * fn() // 0.5
+ * ```
+ */
+declare const once: {
+    <Args extends unknown[], Return, This = unknown>(fn: (this: This, ...args: Args) => Return): (this: This, ...args: Args) => Return;
+    /**
+     * Reset the result of a function that was created with `once`,
+     * allowing it to be called again.
+     *
+     * ```ts
+     * const fn = once(() => Math.random())
+     * fn() // 0.5
+     * fn() // 0.5
+     * once.reset(fn)
+     * fn() // 0.3
+     * fn() // 0.3
+     * ```
+     */
+    reset(fn: OnceFunction): void;
+};
+
+/**
+ * This type produces the type array of `TItems` with all the type items
+ * in `TItemsToRemove` removed from the start of the array type.
+ *
+ * ```ts
+ * type T = RemoveItemsInFront<[number, number], [number]>
+ * // [number]
+ *
+ * type T = RemoveItemsInFront<[File, number, string], [File, number]>
+ * // [string]
+ * ```
+ */
+type RemoveItemsInFront<TItems extends any[], TItemsToRemove extends any[]> = TItems extends [...TItemsToRemove, ...infer TRest] ? TRest : TItems;
+/**
+ * Create a partial function by providing some (or all) of the
+ * arguments the given function needs.
+ *
+ * ```ts
+ * const add = (a: number, b: number) => a + b
+ *
+ * const addFive = partial(add, 5)
+ *
+ * addFive(2) // => 7
+ * ```
+ */
+declare function partial<T extends any[], TA extends Partial<T>, R>(fn: (...args: T) => R, ...args: TA): (...rest: RemoveItemsInFront<T, TA>) => R;
+
+/**
+ * Like partial but for unary functions that accept a single object
+ * argument
+ */
+declare function partob<T, K, PartialArgs extends Partial<T>>(fn: (args: T) => K, argobj: PartialArgs): (restobj: Omit<T, keyof PartialArgs>) => K;
+
+/**
+ * Creates a Proxy object that will dynamically call the handler
+ * argument when attributes are accessed
+ */
+declare function proxied<T, K>(handler: (propertyName: T) => K): Record<string, K>;
+
+type ThrottledFunction<TArgs extends any[]> = {
+    (...args: TArgs): void;
+    /**
+     * Checks if there is any invocation throttled
+     */
+    isThrottled(): boolean;
+};
+/**
+ * Given an interval and a function returns a new function that will
+ * only call the source function if interval milliseconds have passed
+ * since the last invocation
+ */
+declare function throttle<TArgs extends any[]>({ interval }: {
+    interval: number;
+}, func: (...args: TArgs) => any): ThrottledFunction<TArgs>;
+
+/**
+ * Checks if the given number is between zero (0) and the ending
+ * number. 0 is inclusive.
+ *
+ * * Numbers can be negative or positive.
+ * * Ending number is exclusive.
+ *
+ * @param {number} number The number to check.
+ * @param {number} end The end of the range. Exclusive. @returns
+ * {boolean} Returns `true` if `number` is in the range, else `false`.
+ */
+declare function inRange(number: number, end: number): boolean;
+/**
+ * Checks if the given number is between two numbers.
+ *
+ * * Numbers can be negative or positive.
+ * * Starting number is inclusive.
+ * * Ending number is exclusive.
+ * * The start and the end of the range can be ascending OR descending
+ *   order.
+ *
+ * @param {number} number The number to check.
+ * @param {number} start The start of the range. Inclusive. @param
+ * {number} end The end of the range. Exclusive. @returns {boolean}
+ * Returns `true` if `number` is in the range, else `false`.
+ */
+declare function inRange(number: number, start: number, end: number): boolean;
+
+/**
+ * Linearly interpolates between two numbers.
+ *
+ * ```
+ * lerp(0, 10, 0.5) // => 5
+ * lerp(5, 15, 0.2) // => 7
+ * lerp(-10, 10, 0.75) // => 5
+ * ```
+ */
+declare function lerp(from: number, to: number, amount: number): number;
+
+/**
+ * Rounds a number to the given precision. The default `precision` is
+ * zero. An optional rounding function (e.g. `Math.floor` or
+ * `Math.ceil`) can be provided.
+ *
+ * The `precision` argument is limited to be within the range of -323
+ * to +292. Without this limit, precision values outside this range
+ * can result in NaN.
+ *
+ * ```ts
+ * round(123.456)
+ * // => 123.5
+ *
+ * round(1234.56, -2)
+ * // => 1200
+ *
+ * round(1234.56, 1, Math.floor)
+ * // => 1234.5
+ *
+ * round(1234.54, 1, Math.ceil)
+ * // => 1234.6
+ * ```
+ */
+declare function round(value: number, precision?: number, toInteger?: (value: number) => number): number;
+
+declare function toFloat(value: unknown): number;
+declare function toFloat(value: unknown, defaultValue: number): number;
+declare function toFloat<T>(value: unknown, defaultValue: T): number | Exclude<T, undefined>;
+
+declare function toInt(value: unknown): number;
+declare function toInt(value: unknown, defaultValue: number): number;
+declare function toInt<T>(value: unknown, defaultValue: T): number | Exclude<T, undefined>;
+
+/**
+ * Merges two objects together recursivly into a new object applying
+ * values from right to left. Recursion only applies to child object
+ * properties.
+ */
+declare function assign<X extends Record<string | symbol | number, any>>(initial: X, override: X): X;
+
+/**
+ * Creates a shallow copy of the given obejct/value.
+ * @param {*} obj value to clone @returns {*} shallow clone of the
+ * given value
+ */
+declare function clone<T>(obj: T): T;
+
+/**
+ * The opposite of crush, given an object that was crushed into key
+ * paths and values will return the original object reconstructed.
+ *
+ * ```ts
+ * construct({ name: 'ra', 'children.0.name': 'hathor' })
+ * // { name: 'ra', children: [{ name: 'hathor' }] }
+ * ```
+ */
+declare function construct<TObject extends object>(obj: TObject): object;
+
+/**
+ * Flattens a deep object to a single dimension, converting the keys
+ * to dot notation.
+ *
+ * ```ts
+ * crush({ name: 'ra', children: [{ name: 'hathor' }] })
+ * // { name: 'ra', 'children.0.name': 'hathor' }
+ * ```
+ */
+declare function crush<TValue extends object>(value: TValue): object;
+
+type KeyOf<T extends object> = object extends T ? keyof any : keyof T;
+type ValueOf<T extends object> = object extends T ? unknown : T[keyof T];
+type KeyFilterFunction<T extends object = object> = (value: ValueOf<T>, key: KeyOf<T>, obj: T) => boolean;
+/**
+ * Functions can use this type to accept either an array of keys or a
+ * filter function.
+ */
+type KeyFilter<T extends object = object, Key extends keyof any = keyof any> = KeyFilterFunction<T> | readonly Key[];
+/**
+ * Extract the keys of an object that pass a filter.
+ */
+type FilteredKeys<T extends object, F extends KeyFilter<T> | null | undefined> = Extract<keyof T, F extends readonly any[] ? F[number] : any>;
+/**
+ * Returns true if the key is in the “keys array” or if the “filter
+ * function” returns true.
+ */
+declare function filterKey<T extends object>(obj: T, key: keyof T, filter: KeyFilter<T, keyof T> | null | undefined): boolean;
+declare function filterKey(obj: object, key: keyof any, filter: KeyFilter | null | undefined): boolean;
+
+/**
+ * Dynamically get a nested value from an array or object with a
+ * string.
+ *
+ * ```ts
+ * const person = {
+ *   name: 'John',
+ *   friends: [{ name: 'Jane' }]
+ * }
+ *
+ * get(person, 'friends[0].name')
+ * // => 'Jane'
+ * ```
+ */
+declare function get<TDefault = unknown>(value: any, path: string, defaultValue?: TDefault): TDefault;
+
+/**
+ * Returns a new object whose keys are the values of the given object
+ * and its values are the keys of the given object.
+ */
+declare function invert<TKey extends string | number | symbol, TValue extends string | number | symbol>(obj: Record<TKey, TValue>): Record<TValue, TKey>;
+
+/**
+ * Get a string list of all key names that exist in an object (deep).
+ *
+ * ```ts
+ * keys({ name: 'ra' }) // ['name']
+ *
+ * keys({ name: 'ra', children: [{ name: 'hathor' }] })
+ * // ['name', 'children.0.name']
+ * ```
+ */
+declare function keys(value: object): string[];
+
+/**
+ * Convert an object to a list, mapping each entry into a list item
+ */
+declare function listify<Value, Key extends string | number | symbol, Item>(obj: Record<Key, Value>, toItem: (key: Key, value: Value) => Item): Item[];
+
+type LowercaseKeys<T extends Record<string, any>> = {
+    [P in keyof T & string as Lowercase<P>]: T[P];
+};
+/**
+ * Convert all keys in an object to lower case
+ */
+declare function lowerize<T extends Record<string, any>>(obj: T): LowercaseKeys<T>;
+
+/**
+ * Map over all the keys to create a new object
+ */
+declare function mapEntries<TKey extends string | number | symbol, TValue, TNewKey extends string | number | symbol, TNewValue>(obj: Record<TKey, TValue>, toEntry: (key: TKey, value: TValue) => [TNewKey, TNewValue]): Record<TNewKey, TNewValue>;
+
+/**
+ * Map over all the keys of an object to return a new object
+ */
+declare function mapKeys<TValue, TKey extends string | number | symbol, TNewKey extends string | number | symbol>(obj: Record<TKey, TValue>, mapFunc: (key: TKey, value: TValue) => TNewKey): Record<TNewKey, TValue>;
+
+/**
+ * Map over all the keys to create a new object
+ */
+declare function mapValues<TValue, TKey extends string | number | symbol, TNewValue>(obj: {
+    [K in TKey]: TValue;
+}, mapFunc: (value: TValue, key: TKey) => TNewValue): {
+    [K in TKey]: TNewValue;
+};
+declare function mapValues<TValue, TKey extends string | number | symbol, TNewValue>(obj: {
+    [K in TKey]?: TValue;
+}, mapFunc: (value: TValue, key: TKey) => TNewValue): {
+    [K in TKey]?: TNewValue;
+};
+
+/**
+ * Omit a list of properties from an object returning a new object
+ * with the properties that remain
+ */
+declare function omit<T, TKeys extends keyof T>(obj: T, keys: TKeys[]): Omit<T, TKeys>;
+
+/**
+ * Pick a list of properties from an object into a new object
+ */
+declare function pick<T extends object, F extends KeyFilter<T, keyof T>>(obj: T, filter: F): Pick<T, FilteredKeys<T, F>>;
+
+/**
+ * Opposite of get, dynamically set a nested value into an object
+ * using a key path. Does not modify the given initial object.
+ *
+ * ```ts
+ * set({}, 'name', 'ra') // => { name: 'ra' }
+ * set({}, 'cards[0].value', 2) // => { cards: [{ value: 2 }] }
+ * ```
+ */
+declare function set<T extends object, K>(initial: T, path: string, value: K): T;
+
+/**
+ * Removes (shakes out) undefined entries from an object. Optional
+ * second argument shakes out values by custom evaluation.
+ */
+declare function shake<T extends object>(obj: T, filter?: (value: T[keyof T]) => boolean): T;
+
+type UppercaseKeys<T extends Record<string, any>> = {
+    [P in keyof T & string as Uppercase<P>]: T[P];
+};
+/**
+ * Convert all keys in an object to upper case
+ */
+declare function upperize<T extends Record<string, any>>(obj: T): UppercaseKeys<T>;
+
+/**
+ * Draw a random item from a list. Returns null if the list is empty
+ */
+declare function draw<T>(array: readonly T[]): T | null;
+
+/**
+ * Generates a random number between min and max
+ */
+declare function random(min: number, max: number): number;
+
+declare function shuffle<T>(array: readonly T[], random?: (min: number, max: number) => number): T[];
+
+declare function uid(length: number, specials?: string): string;
+
+interface Series<T> {
+    min: (a: T, b: T) => T;
+    max: (a: T, b: T) => T;
+    first: () => T;
+    last: () => T;
+    next: (current: T, defaultValue?: T) => T;
+    previous: (current: T, defaultValue?: T) => T;
+    spin: (current: T, num: number) => T;
+}
+/**
+ * Creates a series object around a list of values that should be
+ * treated with order.
+ */
+declare const series: <T>(items: readonly T[], toKey?: (item: T) => string | symbol) => Series<T>;
+
+/**
+ * Formats the given string in camel case fashion
+ *
+ * camel('hello world')   -> 'helloWorld' camel('va va-VOOM') ->
+ * 'vaVaVoom' camel('helloWorld') -> 'helloWorld'
+ */
+declare function camel(str: string): string;
+
+/**
+ * Capitalize the first word of the string
+ *
+ * capitalize('hello')   -> 'Hello' capitalize('va va voom') -> 'Va va
+ * voom'
+ */
+declare function capitalize(str: string): string;
+
+/**
+ * Formats the given string in dash case fashion
+ *
+ * dash('hello world')   -> 'hello-world' dash('va va_VOOM') ->
+ * 'va-va-voom' dash('helloWord') -> 'hello-word'
+ */
+declare function dash(str: string): string;
+
+/**
+ * Formats the given string in pascal case fashion
+ *
+ * pascal('hello world') -> 'HelloWorld' pascal('va va boom') ->
+ * 'VaVaBoom'
+ */
+declare function pascal(str: string): string;
+
+/**
+ * Formats the given string in snake case fashion
+ *
+ * snake('hello world')   -> 'hello_world' snake('va va-VOOM') ->
+ * 'va_va_voom' snake('helloWord') -> 'hello_world'
+ */
+declare function snake(str: string, options?: {
+    splitOnNumber?: boolean;
+}): string;
+
+/**
+ * Replace data by name in template strings. The default expression
+ * looks for `{{name}}` to identify names.
+ *
+ * ```ts
+ * template('Hello, {{name}}', { name: 'Radashi' })
+ * // "Hello, Radashi"
+ *
+ * template('Hello, <name>', { name: 'Radashi' }, /<(.+?)>/g)
+ * // "Hello, Radashi"
+ * ```
+ */
+declare function template(str: string, data: Record<string, any>, regex?: RegExp): string;
+
+/**
+ * Formats the given string in title case fashion
+ *
+ * title('hello world') -> 'Hello World' title('va_va_boom') -> 'Va Va
+ * Boom' title('root-hook') -> 'Root Hook' title('queryItems') ->
+ * 'Query Items'
+ */
+declare function title(str: string | null | undefined): string;
+
+/**
+ * Trims all prefix and suffix characters from the given string. Like
+ * the builtin trim function but accepts other characters you would
+ * like to trim and trims multiple characters.
+ *
+ * ```typescript
+ * trim('  hello ') // => 'hello'
+ * trim('__hello__', '_') // => 'hello'
+ * trim('/repos/:owner/:repo/', '/') // => 'repos/:owner/:repo'
+ * trim('222222__hello__1111111', '12_') // => 'hello'
+ * ```
+ */
+declare function trim(str: string | null | undefined, charsToTrim?: string): string;
+
+declare const isArray: <Input>(value: Input) => value is ExtractArray<Input>;
+/**
+ * An absurdly complicated but accurate type for extracting Array types.
+ *
+ * It's like `Extract<T, any[]>` but better with edge cases.
+ */
+type ExtractArray<T> = T extends any ? [StrictExtract<T, readonly any[]>] extends [readonly any[]] ? Extract<T, readonly any[]> : [StrictExtract<T, any[]>] extends [any[]] ? Extract<T, any[]> : unknown[] extends T ? unknown[] : never : never;
+
+declare function isDate(value: unknown): value is Date;
+
+declare function isEmpty(value: any): boolean;
+
+declare function isEqual<TType>(x: TType, y: TType): boolean;
+
+declare function isFloat(value: any): value is number;
+
+declare function isFunction(value: any): value is Function;
+
+declare const isInt: (value: unknown) => value is number;
+
+declare function isIntString(value: any): value is string;
+
+declare function isMap<Input>(value: Input): value is ExtractMap<Input>;
+/**
+ * An absurdly complicated but accurate type for extracting Map types.
+ *
+ * It's like `Extract<T, Map<any, any>>` but better with edge cases.
+ */
+type ExtractMap<T> = T extends any ? [StrictExtract<T, ReadonlyMap<unknown, unknown>>] extends [
+    ReadonlyMap<unknown, unknown>
+] ? Extract<T, ReadonlyMap<unknown, unknown>> : [StrictExtract<T, Map<unknown, unknown>>] extends [Map<unknown, unknown>] ? Extract<T, Map<unknown, unknown>> : Map<unknown, unknown> extends T ? Map<unknown, unknown> : never : never;
+
+declare function isNumber(value: unknown): value is number;
+
+/**
+ * Returns true if `value` is a plain object, a class instance
+ * (excluding built-in classes like Date/RegExp), or an
+ * `Object.create(null)` result. Objects from [other realms][1] are
+ * also supported.
+ *
+ * [1]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/instanceof#instanceof_and_multiple_realms
+ *
+ * ```
+ * isObject({}) // true
+ * isObject(new Object()) // true
+ * isObject(Object.create(null)) // true
+ * isObject(new class {}) // true
+ *
+ * isObject([]) // false
+ * isObject(/.+/g) // false
+ * isObject(new Date()) // false
+ * isObject(new Map()) // false
+ * isObject(new Set()) // false
+ * ```
+ */
+declare function isObject(value: unknown): value is object;
+
+declare function isPlainObject(value: any): value is object;
+
+/**
+ * Checks if the given value is primitive.
+ *
+ * Primitive Types: number , string , boolean , symbol, bigint,
+ * undefined, null
+ *
+ * @param {*} value value to check
+ * @returns {boolean} result
+ */
+declare function isPrimitive(value: any): boolean;
+
+/**
+ * This is really a _best guess_ promise checking. You should probably
+ * use Promise.resolve(value) to be 100% sure you're handling it
+ * correctly.
+ */
+declare function isPromise(value: any): value is Promise<any>;
+
+declare function isRegExp(value: unknown): value is RegExp;
+
+declare function isSet<Input>(value: Input): value is ExtractSet<Input>;
+/**
+ * An absurdly complicated but accurate type for extracting Set types.
+ *
+ * It's like `Extract<T, Set<any>>` but better with edge cases.
+ */
+type ExtractSet<T> = T extends any ? [StrictExtract<T, ReadonlySet<unknown>>] extends [ReadonlySet<unknown>] ? Extract<T, ReadonlySet<unknown>> : [StrictExtract<T, Set<unknown>>] extends [Set<unknown>] ? Extract<T, Set<unknown>> : Set<unknown> extends T ? Set<unknown> : never : never;
+
+declare function isString(value: unknown): value is string;
+
+declare function isSymbol(value: unknown): value is symbol;
+
+/**
+ * Compare the given tag to the result of `Object.prototype.toString`.
+ *
+ * ⚠️ You probably won't use this except when implementing another type guard.
+ *
+ * ```ts
+ * isTagged('foo', '[object String]') // true
+ * ```
+ */
+declare function isTagged(value: unknown, tag: string): boolean;
+
+declare function isWeakMap<K extends WeakKey = WeakKey, V = unknown>(value: unknown): value is WeakMap<K, V>;
+
+declare function isWeakSet<T extends WeakKey = WeakKey>(value: unknown): value is WeakSet<T>;
+
+/**
+ * The `Any` class does not exist at runtime. It's used in type
+ * definitions to detect an `any` type.
+ *
+ * ```ts
+ * type IsAny<T> = [T] extends [Any] ? 'is any' : 'is not any'
+ * ```
+ */
+declare class Any {
+    private any;
+}
+/**
+ * Extracts `T` if `T` is not `any`, otherwise `never`.
+ *
+ * ```ts
+ * type A = ExtractNotAny<any, string>
+ * //   ^? never
+ * type B = ExtractNotAny<string | number, string>
+ * //   ^? string
+ * ```
+ */
+type ExtractNotAny<T, U> = Extract<[T] extends [Any] ? never : T, U>;
+type SwitchAny<T, U> = [T] extends [Any] ? U : T;
+type SwitchNever<T, U> = [T] extends [never] ? U : T;
+/**
+ * Extract types in `T` that are assignable to `U`. Coerce `any` and
+ * `never` types to unknown.
+ */
+type StrictExtract<T, U> = SwitchNever<Extract<SwitchAny<T, unknown>, U>, unknown>;
+
+export { AggregateError, Any, type DebounceFunction, type ExtractArray, type ExtractMap, type ExtractNotAny, type ExtractSet, type FilteredKeys, type Flip, type KeyFilter, type KeyFilterFunction, type LowercaseKeys, type MemoOptions, type OnceFunction, type RetryOptions, type Series, type StrictExtract, type SwitchAny, type SwitchNever, type ThrottledFunction, type TryitResult, type UppercaseKeys, all, alphabetical, assign, boil, callable, camel, capitalize, chain, clone, cluster, compose, construct, counting, crush, dash, debounce, defer, diff, draw, filterKey, first, flat, flip, fork, get, group, guard, inRange, intersects, invert, isArray, isDate, isEmpty, isEqual, isFloat, isFunction, isInt, isIntString, isMap, isNumber, isObject, isPlainObject, isPrimitive, isPromise, isRegExp, isSet, isString, isSymbol, isTagged, isWeakMap, isWeakSet, iterate, keys, last, lerp, list, listify, lowerize, map, mapEntries, mapKeys, mapValues, mapify, max, memo, merge, min, objectify, omit, once, parallel, partial, partob, pascal, pick, proxied, random, range, reduce, replace, replaceOrAppend, retry, round, select, selectFirst, series, set, shake, shift, shuffle, sift, sleep, snake, sort, sum, template, throttle, title, toFloat, toInt, toggle, trim, tryit as try, tryit, uid, unique, unzip, upperize, zip, zipToObject };