export { debounce, throttle } from '/Users/enzoinnocenzi/Code/projects/utils/node_modules/.pnpm/@types+throttle-debounce@5.0.2/node_modules/@types/throttle-debounce/index.d.ts';

type Awaitable<T> = T | PromiseLike<T>;
type AwaitableFn<T> = Fn<Awaitable<T>>;
type Nullable<T> = T | null | undefined;
type Arrayable<T> = T | Array<T>;
type Fn<T = void> = () => T;
type Constructor<T = void> = new (...args: any[]) => T;
type ElementOf<T> = T extends (infer E)[] ? E : never;
/**
 * Defines an intersection type of all union items.
 *
 * @param U Union of any types that will be intersected.
 * @returns U items intersected
 * @see https://stackoverflow.com/a/50375286/9259330
 */
type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
/**
 * Infers the arguments type of a function
 */
type ArgumentsType<T> = T extends ((...args: infer A) => any) ? A : never;
type MergeInsertions<T> = T extends object ? {
    [K in keyof T]: MergeInsertions<T[K]>;
} : T;
type DeepMerge<F, S> = MergeInsertions<{
    [K in keyof F | keyof S]: K extends keyof S & keyof F ? DeepMerge<F[K], S[K]> : K extends keyof S ? S[K] : K extends keyof F ? F[K] : never;
}>;
interface Vector2 {
    x: number;
    y: number;
}
interface Vector3 {
    x: number;
    y: number;
    z: number;
}

/**
 * Converts an `Arrayable<T>` to an `Array<T>`.
 *
 * @category Array
 */
declare function toArray<T>(array?: Nullable<Arrayable<T>>): Array<T>;
/**
 * Converts an `Arrayable<T>` to `Array<T>` and flattens it.
 *
 * @category Array
 */
declare function flattenArrayable<T>(array?: Nullable<Arrayable<T | Array<T>>>): Array<T>;
/**
 * Merges multiple `Arrayable<T>`.
 *
 * @category Array
 */
declare function mergeArrayable<T>(...args: Nullable<Arrayable<T>>[]): Array<T>;
type PartitionFilter<T> = (i: T, idx: number, arr: readonly T[]) => any;
/**
 * Divides an array into two parts by a filter function.
 *
 * @category Array
 * @example const [odd, even] = partition([1, 2, 3, 4], (i) => i % 2 != 0)
 */
declare function partition<T>(array: readonly T[], f1: PartitionFilter<T>): [T[], T[]];
declare function partition<T>(array: readonly T[], f1: PartitionFilter<T>, f2: PartitionFilter<T>): [T[], T[], T[]];
declare function partition<T>(array: readonly T[], f1: PartitionFilter<T>, f2: PartitionFilter<T>, f3: PartitionFilter<T>): [T[], T[], T[], T[]];
declare function partition<T>(array: readonly T[], f1: PartitionFilter<T>, f2: PartitionFilter<T>, f3: PartitionFilter<T>, f4: PartitionFilter<T>): [T[], T[], T[], T[], T[]];
declare function partition<T>(array: readonly T[], f1: PartitionFilter<T>, f2: PartitionFilter<T>, f3: PartitionFilter<T>, f4: PartitionFilter<T>, f5: PartitionFilter<T>): [T[], T[], T[], T[], T[], T[]];
declare function partition<T>(array: readonly T[], f1: PartitionFilter<T>, f2: PartitionFilter<T>, f3: PartitionFilter<T>, f4: PartitionFilter<T>, f5: PartitionFilter<T>, f6: PartitionFilter<T>): [T[], T[], T[], T[], T[], T[], T[]];
/**
 * Returns a copy of an array without duplicates.
 *
 * @category Array
 */
declare function uniq<T>(array: readonly T[]): T[];
/**
 * Returns a copy of an array without duplicates using the given equality function.
 *
 * @category Array
 */
declare function uniqueBy<T>(array: readonly T[], equalFn: (a: any, b: any) => boolean): T[];
/**
 * Gets the last item of an array.
 *
 * @category Array
 */
declare function last(array: readonly []): undefined;
declare function last<T>(array: readonly T[]): T;
/**
 * Removes an item from an array.
 *
 * @category Array
 */
declare function remove<T>(array: T[], value: T): boolean;
/**
 * Gets the nth item of an array.
 *
 * @category Array
 */
declare function at(array: readonly [], index: number): undefined;
declare function at<T>(array: readonly T[], index: number): T;
/**
 * Generates a range array of numbers. `stop` is exclusive.
 *
 * @category Array
 */
declare function range(stop: number): number[];
declare function range(start: number, stop: number, step?: number): number[];
/**
 * Moves an element in an array.
 *
 * @category Array
 * @param arr
 * @param from
 * @param to
 */
declare function move<T>(arr: T[], from: number, to: number): T[];
/**
 * Clamps a number to the index range of an array.
 *
 * @category Array
 */
declare function clampArrayRange(n: number, arr: readonly unknown[]): number;
/**
 * Gets random item(s) from an array.
 *
 * @param arr
 * @param quantity - quantity of random items which will be returned
 */
declare function sample<T>(arr: T[], quantity: number): T[];
/**
 * Shuffles an array. This function mutates the array.
 *
 * @category Array
 */
declare function shuffle<T>(array: T[]): T[];
/**
 * Expands a single-dimensional object that uses "dot" notation into a multi-dimensional object.
 */
declare function undot<T extends object>(input: T): any;
/**
 * Flattens a multi-dimensional object into a single-level object that uses "dot" notation to indicate depth:.
 */
declare function dot<T extends Record<string, any>>(input?: T): Record<string, any>;
/**
 * Joins an array of strings with a separator, using a different separator for the last item.
 */
declare function join<T>(array: T[], options?: {
    separator?: string;
    lastSeparator?: string;
}): string;

declare function assert(condition: boolean, message: string): asserts condition;
declare function getTypeAsString(v: any): string;
declare function getTypeName(v: any): string;
declare function noop(): void;

declare function isDeepEqual(value1: any, value2: any): boolean;

/**
 * Utility type to extract the variant of a discriminated union.
 *
 * @template T - The union type.
 * @template K - The discriminator key.
 * @template V - The discriminator value.
 */
type VariantOf<T, K extends keyof T, V> = T extends Record<K, V> ? T : never;
/**
 * Represents a handler for a case in a switch-case structure.
 *
 * @template T - The type of the value being matched.
 * @template R - The return type of the handler function.
 * @property {T} match - A value or a function to match against the input.
 * @property {(val: T) => R} handler - A function that processes the matched value and returns a result.
 */
type CaseHandler<T, R> = {
    match: T;
    handler: (val: T) => R;
} | {
    match: (val: T) => boolean;
    handler: (val: T) => R;
};
/**
 * Interface for building a switch-case structure with fluent API.
 *
 * @template T - The type of the value being matched.
 * @template R - The return type of the handler functions.
 * @template Remaining - The remaining keys that can be matched.
 */
interface SwitchCaseBuilder<T, R, Remaining extends string | number | symbol = never> {
    /**
     * Adds a case to the switch-case structure.
     *
     * @template K - The type of the key being matched.
     * @param {K} match - A value to match or a function to evaluate the match.
     * @param {R | (() => R)} handler - A result or a function that returns a result for the matched case.
     * @returns {SwitchCaseBuilder<T, R, Exclude<Remaining, K>>} - The updated builder with the new case added.
     */
    case: (<K extends Remaining>(match: K, handler: R | (() => R)) => SwitchCaseBuilder<T, R, Exclude<Remaining, K>>) & ((match: (val: T) => boolean, handler: R | ((val: T) => R)) => SwitchCaseBuilder<T, R, Remaining>);
    /**
     * Adds a default handler for unmatched cases.
     *
     * @param {(val: T) => R} handler - A function to handle unmatched cases.
     * @returns {SwitchCaseBuilder<T, R, never>} - The updated builder with the default handler added.
     */
    default: (handler: (val: T) => R) => SwitchCaseBuilder<T, R, never>;
    /**
     * Ensures all cases are handled and returns the result.
     *
     * @returns {Remaining extends never ? R : never} - The result of the matched case or an error if cases are missing.
     */
    exhaustive: () => Remaining extends never ? R : never;
    /**
     * Executes the switch-case structure and returns the result.
     *
     * @returns {R} - The result of the matched case or the default handler.
     */
    run: () => R;
}
/**
 * Interface for building a discriminated union switch-case structure with fluent API.
 *
 * @template T - The type of the value being matched.
 * @template K - The discriminator key.
 * @template R - The return type of the handler functions.
 * @template Remaining - The remaining discriminator values that can be matched.
 */
interface DiscriminatedUnionSwitchCaseBuilder<T, K extends keyof T, R, Remaining extends string | number | symbol = string | number | symbol> {
    /**
     * Adds a case for a specific discriminator value.
     *
     * @template V - The discriminator value.
     * @param {V} value - The discriminator value to match.
     * @param {(val: VariantOf<T, K, V>) => R} handler - Handler for this case.
     * @returns {DiscriminatedUnionSwitchCaseBuilder<T, K, R, Exclude<Remaining, V>>}
     */
    case: <V extends Remaining>(value: V, handler: (val: VariantOf<T, K, V>) => R) => DiscriminatedUnionSwitchCaseBuilder<T, K, R, Exclude<Remaining, V>>;
    /**
     * Adds a default handler for unmatched cases.
     *
     * @param {(val: T) => R} handler - Handler for unmatched cases.
     * @returns {DiscriminatedUnionSwitchCaseBuilder<T, K, R, never>}
     */
    default: (handler: (val: T) => R) => DiscriminatedUnionSwitchCaseBuilder<T, K, R, never>;
    /**
     * Executes the switch-case structure and returns the result.
     *
     * @returns {R} - The result of the matched case or the default handler.
     */
    run: () => R;
}

declare function switchCase<T extends string | number | symbol, R>(value: T, cases: {
    [K in T]: R | (() => R);
}, defaultHandler?: (val: T) => R): R;
declare function switchCase<T, K extends keyof T, V extends T[K] & (string | number), R>(value: T, discriminator: K, cases: {
    [P in V]: R | ((val: T & {
        [Q in K]: P;
    }) => R);
}, defaultHandler?: (val: T) => R): R;
declare function switchCase<T, R>(value: T, cases: Record<string, CaseHandler<T, R>>, defaultHandler?: (val: T) => R): R;
declare function switchCase<T, R>(value: T, cases: Array<{
    match: (val: T) => boolean;
    handler: R | ((val: T) => R);
}>, defaultHandler?: (val: T) => R): R;
declare function switchCase<T extends string | number | symbol, R>(value: T): SwitchCaseBuilder<T, R, T>;
declare function switchCase<T, R>(value: T): SwitchCaseBuilder<T, R, never>;
declare function switchCase<T, K extends keyof T, R>(value: T, discriminator: K): DiscriminatedUnionSwitchCaseBuilder<T, K, R, T[K] & (string | number | symbol)>;

/**
 * Call every function in an array.
 *
 * @category Functions
 */
declare function batchInvoke(functions: Nullable<Fn>[]): void;
/**
 * Calls the given function.
 *
 * @category Functions
 */
declare function invoke(fn: undefined): undefined;
declare function invoke<T>(fn: Fn<T>): T;
/**
 * Calls the given function.
 *
 * @category Functions
 */
declare function asyncInvoke<T>(fn: AwaitableFn<T>): Promise<T>;
/**
 * Returns the given value, or the result of the callback if the value is a function.
 *
 * @category Functions
 */
declare function value(value: undefined): undefined;
declare function value<T>(value: T | Fn<T>): T;
/**
 * Passes the value through the callback, and returns the value.
 *
 * @category Functions
 * @example
 * ```
 * function createUser(name: string): User {
 *   return tap(new User, user => {
 *     user.name = name
 *   })
 * }
 * ```
 */
declare function tap(value: undefined, callback: (value: undefined) => void): undefined;
declare function tap<T>(value: T, callback: (value: T) => void): T;
/**
 * Asynchronously tries the specified promise.
 *
 * @example
 * ```
 * const [result, error] = await tryAsync(fetch(url))
 */
declare function tryAsync<T>(fn: AwaitableFn<T>): Promise<[T, null] | [null, Error]>;
/**
 * Memoizes a value.
 *
 * @example
 * ```
 * const result = memoize(() => expensiveFn())
 * result.value // computed
 * result.value // memoized
 */
declare function memoize<T>(getter: () => T): {
    value: T;
};

/**
 * Filters out nullish values.
 *
 * @category Guards
 * @example array.filter(notNullish)
 */
declare function notNullish<T>(v: T | null | undefined): v is NonNullable<T>;
/**
 * Filters our `null` values.
 *
 * @category Guards
 * @example array.filter(noNull)
 */
declare function noNull<T>(v: T | null): v is Exclude<T, null>;
/**
 * Filters out `undefined` values.
 *
 * @category Guards
 * @example array.filter(notUndefined)
 */
declare function notUndefined<T>(v: T): v is Exclude<T, undefined>;
/**
 * Filters out truthy values.
 *
 * @category Guards
 * @example array.filter(isTruthy)
 */
declare function isTruthy<T>(v: T): v is NonNullable<T>;

declare const isDef: <T = any>(val?: T) => val is T;
declare const isBoolean: (val: any) => val is boolean;
declare const isFunction: <T extends Function>(val: any) => val is T;
declare const isNumber: (val: any) => val is number;
declare const isString: (val: unknown) => val is string;
declare const isObject: (val: any) => val is object;
declare const isUndefined: (val: any) => val is undefined;
declare const isNull: (val: any) => val is null;
declare const isRegExp: (val: any) => val is RegExp;
declare const isDate: (val: any) => val is Date;
declare const isWindow: (val: any) => boolean;
declare const isBrowser: boolean;

/**
 * Clamps the given number between `min` and `max`.
 *
 * @category Math
 */
declare function clamp(n: number, min: number, max: number): number;
/**
 * Returns the sum of all numbers in the given array.
 *
 * @category Math
 */
declare function sum(...args: number[] | number[][]): number;
/**
 * Linearly interpolates between `min` and `max` based on `t`
 *
 * @category Math
 * @param t The interpolation value clamped between 0 and 1
 * @example
 * ```
 * const value = lerp(0, 2, 0.5) // value will be 1
 * ```
 */
declare function lerp(min: number, max: number, t: number): number;
/**
 * Returns the magnitude of a vector with components `a` and `b`.
 *
 * @category Math
 */
declare function magnitude(a: number, b: number): number;
/**
 * Linearly remaps a clamped value from its source range [`inMin`, `inMax`] to the destination range [`outMin`, `outMax`]
 *
 * @category Math
 * @example
 * ```
 * const value = remap(0.5, 0, 1, 200, 400) // value will be 300
 * ```
 */
declare function remap(n: number, inMin: number, inMax: number, outMin: number, outMax: number): number;
/**
 * Gradually changes a value towards a desired goal over time.
 * From: https://github.com/Unity-Technologies/UnityCsReference/blob/02d565cf3dd0f6b15069ba976064c75dc2705b08/Runtime/Export/Math/Mathf.cs#L301-L329
 *
 * @param velocity Reference to current velocity
 * @param smoothTime Larger number = more smoothing
 * @param deltaTime In seconds
 */
declare function smoothDamp(current: number, target: number, velocity: number, smoothTime: number, maxSpeed: number, deltaTime: number): {
    smoothed: number;
    velocity: number;
};

/**
 * Maps key/value pairs for an object, and constructs a new one.
 *
 *
 * @category Object
 *
 * Transform:
 * @example
 * ```
 * objectMap({ a: 1, b: 2 }, (k, v) => [k.toString().toUpperCase(), v.toString()])
 * // { A: '1', B: '2' }
 * ```
 *
 * Swap key/value:
 * @example
 * ```
 * objectMap({ a: 1, b: 2 }, (k, v) => [v, k])
 * // { 1: 'a', 2: 'b' }
 * ```
 *
 * Filter keys:
 * @example
 * ```
 * objectMap({ a: 1, b: 2 }, (k, v) => k === 'a' ? undefined : [k, v])
 * // { b: 2 }
 * ```
 */
declare function objectMap<K extends string, V, NK = K, NV = V>(obj: Record<K, V>, fn: (key: K, value: V) => [NK, NV] | undefined): Record<K, V>;
/**
 * Type guard for any key, `k`.
 * Marks `k` as a key of `T` if `k` is in `obj`.
 *
 * @category Object
 * @param obj object to query for key `k`
 * @param k key to check existence in `obj`
 */
declare function isKeyOf<T extends object>(obj: T, k: keyof any): k is keyof T;
/**
 * Strictly-typed `Object.keys`.
 *
 * @category Object
 */
declare function objectKeys<T extends object>(obj: T): Array<`${keyof T & (string | number | boolean | null | undefined)}`>;
/**
 * Strictly-typed `Object.entries`.
 *
 * @category Object
 */
declare function objectEntries<T extends object>(obj: T): Array<[keyof T, T[keyof T]]>;
/**
 * Deeply merges multiple objects.
 *
 * The first argument is the target object, the rest are the sources.
 * The target object will be mutated and returned.
 *
 * @category Object
 */
declare function deepMerge<T extends object = object, S extends object = T>(target: T, ...sources: S[]): DeepMerge<T, S>;
/**
 * Deeply merges multiple objects, including their arrays.
 *
 * Differs from `deepMerge` in that it merges arrays instead of overriding them.
 *
 * The first argument is the target object, the rest are the sources.
 * The target object will be mutated and returned.
 *
 * @category Object
 */
declare function deepMergeWithArray<T extends object = object, S extends object = T>(target: T, ...sources: S[]): DeepMerge<T, S>;
/**
 * Creates a new object with only the specified keys.
 *
 * @category Object
 */
declare function objectPick<O extends object, T extends keyof O>(obj: O, keys: T[], omitUndefined?: boolean): Pick<O, T>;
/**
 * Creates a new object without the specified keys.
 *
 * @category Object
 */
declare function objectOmit<O extends object, T extends keyof O>(obj: O, keys: T[], omitUndefined?: boolean): Omit<O, T>;
/**
 * Clears undefined fields from an object. It mutates the object.
 *
 * @category Object
 */
declare function clearUndefined<T extends object>(obj: T): T;
/**
 * Determines whether an object has a property with the specified name.
 *
 * @see https://eslint.org/docs/rules/no-prototype-builtins
 * @category Object
 */
declare function hasOwnProperty<T>(obj: T, v: PropertyKey): boolean;

interface POptions {
    /**
     * How many promises are resolved at the same time.
     */
    concurrency?: number | undefined;
}
declare class PInstance<T = any> extends Promise<Awaited<T>[]> {
    items: Iterable<T>;
    options?: POptions | undefined;
    private promises;
    get promise(): Promise<Awaited<T>[]>;
    constructor(items?: Iterable<T>, options?: POptions | undefined);
    add(...args: (T | Promise<T>)[]): void;
    map<U>(fn: (value: Awaited<T>, index: number) => U): PInstance<Promise<U>>;
    filter(fn: (value: Awaited<T>, index: number) => boolean | Promise<boolean>): PInstance<Promise<T>>;
    forEach(fn: (value: Awaited<T>, index: number) => void): Promise<void>;
    reduce<U>(fn: (previousValue: U, currentValue: Awaited<T>, currentIndex: number, array: Awaited<T>[]) => U, initialValue: U): Promise<U>;
    clear(): void;
    then(fn?: () => PromiseLike<any>): Promise<any>;
    catch(fn?: (err: unknown) => PromiseLike<any>): Promise<any>;
    finally(fn?: () => void): Promise<Awaited<T>[]>;
}
/**
 * Utility for managing multiple promises.
 *
 * @see https://github.com/antfu/utils/tree/main/docs/p.md
 * @category Promise
 * @example
 * ```
 * import { p } from '@innocenzi/utils'
 *
 * const items = [1, 2, 3, 4, 5]
 *
 * await p(items)
 *   .map(async i => await multiply(i, 3))
 *   .filter(async i => await isEven(i))
 * // [6, 12]
 * ```
 */
declare function p<T = any>(items?: Iterable<T>, options?: POptions): PInstance<T>;

interface SingletonPromiseReturn<T> {
    (): Promise<T>;
    /**
     * Resets the current staled promise.
     * Await it to have proper shutdown.
     */
    reset: () => Promise<void>;
}
/**
 * Creates a singleton promise function.
 *
 * @category Promise
 * @example
 * ```
 * const fn = createSingletonPromise(async () => {
 *  await doSomething()
 * })
 *
 * await fn
 * fn.reset()
 * ```
 */
declare function createSingletonPromise<T>(fn: () => Promise<T>): SingletonPromiseReturn<T>;
/**
 * Waits for the given amount of milliseconds.
 *
 * @category Promise
 */
declare function sleep(ms: number, callback?: Fn<any>): Promise<void>;
/**
 * Creates a deferred promise.
 *
 * @category Promise
 * @example
 * ```
 * const lock = createPromiseLock()
 *
 * lock.run(async () => {
 *   await doSomething()
 * })
 *
 * // in anther context:
 * await lock.wait() // it will wait all tasking finished
 * ```
 */
declare function createDefferedPromise(): {
    run<T = void>(fn: () => Promise<T>): Promise<T>;
    wait(): Promise<void>;
    isWaiting(): boolean;
    clear(): void;
};
/**
 * Promise with `resolve` and `reject` methods of itself
 */
interface ControlledPromise<T = void> extends Promise<T> {
    resolve: (value: T | PromiseLike<T>) => void;
    reject: (reason?: any) => void;
}
/**
 * Returns a Promise with `resolve` and `reject` methods.
 *
 * @category Promise
 * @example
 * ```
 * const promise = createControlledPromise()
 *
 * await promise
 *
 * // in anther context:
 * promise.resolve(data)
 * ```
 */
declare function createControlledPromise<T>(): ControlledPromise<T>;

/**
 * Replaces backslashes with forward slashes.
 *
 * @category String
 */
declare function toForwardSlashes(str: string): string;
/**
 * Replaces forward slashes with backslashes.
 *
 * @category String
 */
declare function toBackSlashes(str: string): string;
/**
 * Ensures the given string starts with the given prefix.
 *
 * @category String
 */
declare function ensureStartsWith(prefix: string, str: string): string;
/**
 * Returns everything before the given value.
 *
 * @category String
 */
declare function before(str: string, separator: string | number): string;
/**
 * Returns everything before the last occurrence of the given value.
 *
 * @category String
 */
declare function beforeLast(str: string, separator: string | number): string;
/**
 * Returns everything after the given value.
 *
 * @category String
 */
declare function after(str: string, separator: string | number): string;
/**
 * Returns everything after the last occurrence of the given value.
 *
 * @category String
 */
declare function afterLast(str: string, separator: string | number): string;
/**
 * Gets the portion of a string between two given values.
 */
declare function between(str: string, start: string | number, end: string | number): string;
/**
 * Gets the smallest possible portion of a string between two given values.
 */
declare function betweenShrink(str: string, start: string | number, end: string | number): string;
/**
 * Replaces the first occurrence of a given value in a string.
 *
 * @category String
 */
declare function replaceFirst(search: string | number, replace: string | number, str: string): string;
/**
 * Replaces the last occurrence of a given value in a string.
 *
 * @category String
 */
declare function replaceLast(search: string | number, replace: string | number, str: string): string;
/**
 * Ensures the given string ends with the given suffix.
 *
 * @category String
 */
declare function ensureEndsWith(suffix: string, str: string): string;
/**
 * Removes duplicate spaces from a string.
 */
declare function squish(str: string): string;
/**
 * Masks a portion of a string with a repeated character.
 */
declare function mask(str: string, mask: string, index: number, length?: number): string;
/**
 * Dead simple template engine, just like Python's `.format()`
 * Support passing variables as either in index based or object/name based approach
 * While using object/name based approach, you can pass a fallback value as the third argument
 *
 * @category String
 * @example
 * ```
 * const result = template(
 *   'Hello {0}! My name is {1}.',
 *   'Inès',
 *   'Anthony'
 * ) // Hello Inès! My name is Anthony.
 * ```
 *
 * ```
 * const result = namedTemplate(
 *   '{greet}! My name is {name}.',
 *   { greet: 'Hello', name: 'Anthony' }
 * ) // Hello! My name is Anthony.
 * ```
 *
 * const result = namedTemplate(
 *   '{greet}! My name is {name}.',
 *   { greet: 'Hello' }, // name isn't passed hence fallback will be used for name
 *   'placeholder'
 * ) // Hello! My name is placeholder.
 * ```
 */
declare function template(str: string, object: Record<string | number, any>, fallback?: string | ((key: string) => string)): string;
declare function template(str: string, ...args: (string | number | bigint | undefined | null)[]): string;
/**
 * Generate a random string
 * @category String
 */
declare function randomStr(size?: number, dict?: string): string;
/**
 * First letter uppercase, other lowercase
 * @category string
 * @example
 * ```
 * capitalize('hello') => 'Hello'
 * ```
 */
declare function capitalize(str: string): string;

export { after, afterLast, assert, asyncInvoke, at, batchInvoke, before, beforeLast, between, betweenShrink, capitalize, clamp, clampArrayRange, clearUndefined, createControlledPromise, createDefferedPromise, createSingletonPromise, deepMerge, deepMergeWithArray, dot, ensureEndsWith, ensureStartsWith, flattenArrayable, getTypeAsString, getTypeName, hasOwnProperty, invoke, isBoolean, isBrowser, isDate, isDeepEqual, isDef, isFunction, isKeyOf, isNull, isNumber, isObject, isRegExp, isString, isTruthy, isUndefined, isWindow, join, last, lerp, magnitude, mask, switchCase as match, memoize, mergeArrayable, move, noNull, noop, notNullish, notUndefined, objectEntries, objectKeys, objectMap, objectOmit, objectPick, p, partition, randomStr, range, remap, remove, replaceFirst, replaceLast, sample, shuffle, sleep, smoothDamp, squish, sum, tap, template, toArray, toBackSlashes, toForwardSlashes, tryAsync, undot, uniq, uniqueBy, value };
export type { ArgumentsType, Arrayable, Awaitable, AwaitableFn, Constructor, ControlledPromise, DeepMerge, ElementOf, Fn, MergeInsertions, Nullable, PartitionFilter, SingletonPromiseReturn, UnionToIntersection, Vector2, Vector3 };