@bigbinary/neeto-commons-frontend 2.1.39 → 3.0.0

package/pure.d.ts

@@ -1,1801 +0,0 @@
-import { Draft } from "immer";
-export type Primitives = symbol | string | number | boolean | null | undefined;
-export type ObjectAndPrimitives = Primitives | object;
-type KeyType = string | number | symbol;
-type NilOr<T> = T | null | undefined;
-type Matchable<Obj, Parent, key extends keyof Obj> = ((object: Obj[key], parent: Parent) => boolean) | MatchPattern<Obj[key], Parent> | Primitives;
-type MatchPattern<Obj = any, Parent = Obj> = Obj extends any[] ? Matchable<Obj, Parent, number>[] | {
-  [key: number]: Matchable<Obj, Parent, number>;
-} : Obj extends Primitives ? Obj : ({ [key in keyof Partial<Obj>]: Matchable<Obj, Parent, key> } & {
-  [key: KeyType]: Matchable<any, Parent, KeyType>;
-});
-/**
- *
- * The camelToSnakeCase function converts a camelCase string to snake_case.
- *
- * @example 
- *
- * camelToSnakeCase("firstName"); // "first_name"
- * @endexample
-*/
-export function camelToSnakeCase(string: string): string;
-export function _camelToSnakeCase(string: NilOr<string>): NilOr<string>;
-/**
- *
- * The capitalize function converts the first character of a string to uppercase.
- *
- * @example 
- *
- * capitalize("oliver"); // "Oliver"
- * capitalize("OLIVER"); // "OLIVER"
- * capitalize("oLIVER"); // "OLIVER"
- * @endexample
-*/
-export function capitalize(string: string): string;
-export function _capitalize(string: NilOr<string>): NilOr<string>;
-/**
- *
- * The copyKeys function is similar to the renameKeys function
- *
- * but retains both the source and destination keys in the resulting array. For
- *
- * deep copying of nested objects refer to copyKeysDeep
- *
- * function.
- *
- * @example 
- *
- * const data = [
- *   { id: 1, name: "Tomato", quantity: 10 },
- *   { id: 2, name: "Potato", quantity: 20 },
- * ];
- * 
- * // copy name to label and id to value
- * copyKeys({ name: "label", id: "value" }, data);
- * 
- * 
- * output: [
- *   { label: "Tomato", value: 1, id: 1, name: "Tomato", quantity: 10 },
- *   { label: "Potato", value: 2, id: 2, name: "Potato", quantity: 20 },
- * ];
- * 
- * @endexample
-*/
-export function copyKeys<T>(keyMap: { [key in keyof Partial<T>]: string }, objectArray: T[]): (T & {
-  [key: string]: any;
-})[];
-/**
- *
- * The copyKeys function is similar to the renameKeys function
- *
- * but retains both the source and destination keys in the resulting array. For
- *
- * deep copying of nested objects refer to copyKeysDeep
- *
- * function.
- *
- * @example 
- *
- * const data = [
- *   { id: 1, name: "Tomato", quantity: 10 },
- *   { id: 2, name: "Potato", quantity: 20 },
- * ];
- * 
- * // copy name to label and id to value
- * copyKeys({ name: "label", id: "value" }, data);
- * 
- * 
- * output: [
- *   { label: "Tomato", value: 1, id: 1, name: "Tomato", quantity: 10 },
- *   { label: "Potato", value: 2, id: 2, name: "Potato", quantity: 20 },
- * ];
- * 
- * @endexample
-*/
-export function copyKeys(keyMap: {
-  [key: string]: string;
-}): <T>(objectArray: T[]) => (T & {
-  [key: string]: any;
-})[];
-export function _copyKeys<T>(keyMap: { [key in keyof Partial<T>]: string }, objectArray: NilOr<T[]>): NilOr<(T & {
-  [key: string]: any;
-})[]>;
-export function _copyKeys(keyMap: {
-  [key: string]: string;
-}): <T>(objectArray: NilOr<T[]>) => NilOr<(T & {
-  [key: string]: any;
-})[]>;
-/**
- *
- * The copyKeysDeep function is an advanced version of the
- *
- * copyKeys function. It supports deep copying with nested objects
- *
- * and offers flexibility in specifying key mappings for the copy operation.
- *
- * @example 
- *
- * const data = [
- *   {
- *     id: 1,
- *     name: "Tomato",
- *     quantity: 10,
- *     user: { id: 1, name: "John", bonusQty: 3 },
- *     address: { street: "First street", pin: 101283 },
- *   },
- *   {
- *     id: 2,
- *     name: "Potato",
- *     quantity: 20,
- *     user: { id: 2, name: "Jane", bonusQty: 2 },
- *     address: { street: "Second street", pin: 998472 },
- *   },
- * ];
- * 
- * // Create a new array to hold the transformed objects
- * copyKeysDeep(
- *   {
- *     name: "label",
- *     quantity: (qty, root) => qty + root.user.bonusQty,
- *     user: { pin: ["address", "pin"] },
- *   },
- *   data
- * );
- * 
- * 
- * output: [
- *   {
- *     label: "Tomato", // label copied
- *     id: 1,
- *     name: "Tomato",
- *     quantity: 13, // quantity updated
- *     user: { pin: 101283, id: 1, name: "John", bonusQty: 3 }, // pin copied
- *     address: { street: "First street", pin: 101283 },
- *   },
- *   {
- *     label: "Potato",
- *     id: 2,
- *     name: "Potato",
- *     quantity: 22,
- *     user: { id: 2, name: "Jane", bonusQty: 2 },
- *     address: { pin: 998472, street: "Second street" },
- *   },
- * ];
- * 
- * @endexample
-*/
-export function copyKeysDeep(keyMap: object, objectArray: object[]): object[];
-/**
- *
- * The copyKeysDeep function is an advanced version of the
- *
- * copyKeys function. It supports deep copying with nested objects
- *
- * and offers flexibility in specifying key mappings for the copy operation.
- *
- * @example 
- *
- * const data = [
- *   {
- *     id: 1,
- *     name: "Tomato",
- *     quantity: 10,
- *     user: { id: 1, name: "John", bonusQty: 3 },
- *     address: { street: "First street", pin: 101283 },
- *   },
- *   {
- *     id: 2,
- *     name: "Potato",
- *     quantity: 20,
- *     user: { id: 2, name: "Jane", bonusQty: 2 },
- *     address: { street: "Second street", pin: 998472 },
- *   },
- * ];
- * 
- * // Create a new array to hold the transformed objects
- * copyKeysDeep(
- *   {
- *     name: "label",
- *     quantity: (qty, root) => qty + root.user.bonusQty,
- *     user: { pin: ["address", "pin"] },
- *   },
- *   data
- * );
- * 
- * 
- * output: [
- *   {
- *     label: "Tomato", // label copied
- *     id: 1,
- *     name: "Tomato",
- *     quantity: 13, // quantity updated
- *     user: { pin: 101283, id: 1, name: "John", bonusQty: 3 }, // pin copied
- *     address: { street: "First street", pin: 101283 },
- *   },
- *   {
- *     label: "Potato",
- *     id: 2,
- *     name: "Potato",
- *     quantity: 22,
- *     user: { id: 2, name: "Jane", bonusQty: 2 },
- *     address: { pin: 998472, street: "Second street" },
- *   },
- * ];
- * 
- * @endexample
-*/
-export function copyKeysDeep(keyMap: object): (objectArray: object[]) => object[];
-export function _copyKeysDeep(keyMap: object, objectArray: NilOr<object[]>): NilOr<object[]>;
-export function _copyKeysDeep(keyMap: object): (objectArray: NilOr<object[]>) => NilOr<object[]>;
-/**
- *
- * The countBy function counts the number of items in an array that match the
- *
- * provided pattern.
- *
- * @example 
- *
- * const array = [
- *   { name: "Oliver", age: 20 },
- *   { name: "Sam", age: 40 },
- *   { name: "George", age: 41 },
- *   { name: "Smith", age: 20 },
- * ];
- * 
- * countBy({ age: 20 }, array); // returns 2
- * countBy({ age: gt(__, 40) }, array); // returns 1
- * countBy({ age: 50 }, array); // returns 0
- * @endexample
-*/
-export function countBy<T>(pattern: MatchPattern<T>, entityArray: T[]): number;
-/**
- *
- * The countBy function counts the number of items in an array that match the
- *
- * provided pattern.
- *
- * @example 
- *
- * const array = [
- *   { name: "Oliver", age: 20 },
- *   { name: "Sam", age: 40 },
- *   { name: "George", age: 41 },
- *   { name: "Smith", age: 20 },
- * ];
- * 
- * countBy({ age: 20 }, array); // returns 2
- * countBy({ age: gt(__, 40) }, array); // returns 1
- * countBy({ age: 50 }, array); // returns 0
- * @endexample
-*/
-export function countBy(pattern: MatchPattern): (entityArray: object[]) => number;
-export function _countBy<T>(pattern: MatchPattern<T>, entityArray: NilOr<T[]>): NilOr<number>;
-export function _countBy(pattern: MatchPattern): (entityArray: NilOr<object[]>) => NilOr<number>;
-/**
- *
- * The deepFreezeObject function is used to make an object immutable by
- *
- * recursively freezing each property that is of type object. Freezing an object
- *
- * prevents any changes to its properties, making it effectively immutable.
- *
- * @example 
- *
- * const user = {
- *   address: { city: "Miami", phoneNumber: "389791382" },
- *   firstName: "Oliver",
- * };
- * deepFreezeObject(user);
- * 
- * user.address.phoneNumber = "123456789"; // fails silently in non-strict mode
- * user.lastName = "Smith"; // fails silently in non-strict mode
- * 
- * console.log(user);
- * 
- * 
- * {
- *   address: { city: "Miami", phoneNumber: "389791382" },
- *   firstName: "Oliver",
- * };
- * 
- * @endexample
- * The assignment operation will throw the error only when we execute it in strict
- *
- * mode, in non-strict mode it will fail silently.
- *
- * @example 
- *
- * "use strict"; user.address.phoneNumber = "123456789";
- * 
- * Cannot assign to read only property 'phoneNumber' of object '#<Object>
- * 
- * 
- * "use strict"; user.lastName = "Smith";
- * 
- * Cannot add property lastName, object is not extensible
- * 
- * @endexample
-*/
-export function deepFreezeObject<T>(object: T): Readonly<T>;
-/**
- *
- * The dynamicArray function constructs an array of a specified length using a
- *
- * provided function to generate each element. The function takes the index as a
- *
- * parameter and is expected to return the element corresponding to that index.
- *
- * This function does not include a failsafe mechanism, so it is important to
- *
- * ensure that the provided function and length are valid to prevent errors.
- *
- * @example 
- *
- * dynamicArray(3, index => `option ${index + 1}`);
- * 
- * // output: ["option 1", "option 2", "option 3"]
- * @endexample
-*/
-export function dynamicArray<T>(count: number, elementGenerator: (index: number) => T): T[];
-/**
- *
- * The existsBy function searches for an item in the array that matches the
- *
- * provided pattern and returns true if found, or false otherwise.
- *
- * @example 
- *
- * const array = [
- *   { id: 1, name: "Sam", address: { street: "First street", pin: 101283 } },
- *   { id: 2, name: "Oliver", address: { street: "Second street", pin: 998472 } },
- * ];
- * 
- * existsBy({ name: "Sam" }, array); // true
- * existsBy({ name: "Harry" }, array); // false
- * @endexample
-*/
-export function existsBy<T>(pattern: MatchPattern<T>, entityArray: T[]): boolean;
-/**
- *
- * The existsBy function searches for an item in the array that matches the
- *
- * provided pattern and returns true if found, or false otherwise.
- *
- * @example 
- *
- * const array = [
- *   { id: 1, name: "Sam", address: { street: "First street", pin: 101283 } },
- *   { id: 2, name: "Oliver", address: { street: "Second street", pin: 998472 } },
- * ];
- * 
- * existsBy({ name: "Sam" }, array); // true
- * existsBy({ name: "Harry" }, array); // false
- * @endexample
-*/
-export function existsBy(pattern: MatchPattern): (entityArray: object[]) => boolean;
-export function _existsBy<T>(pattern: MatchPattern<T>, entityArray: NilOr<T[]>): NilOr<boolean>;
-export function _existsBy(pattern: MatchPattern): (entityArray: NilOr<object[]>) => NilOr<boolean>;
-/**
- *
- * The existsById function searches for an item in the provided array using the
- *
- * given id.
- *
- * @example 
- *
- * const array = [
- *   { id: 1, name: "Sam" },
- *   { id: 2, name: "Oliver" },
- * ];
- * 
- * existsById(2, array); // true Oliver's id is 2
- * existsById(5, array); // false no one has an id of 5
- * @endexample
-*/
-export function existsById(id: any, entityArray: object[]): boolean;
-/**
- *
- * The existsById function searches for an item in the provided array using the
- *
- * given id.
- *
- * @example 
- *
- * const array = [
- *   { id: 1, name: "Sam" },
- *   { id: 2, name: "Oliver" },
- * ];
- * 
- * existsById(2, array); // true Oliver's id is 2
- * existsById(5, array); // false no one has an id of 5
- * @endexample
-*/
-export function existsById(id: any): (entityArray: object[]) => boolean;
-export function _existsById(id: any, entityArray: NilOr<object[]>): NilOr<boolean>;
-export function _existsById(id: any): (entityArray: NilOr<object[]>) => NilOr<boolean>;
-/**
- *
- * The filterBy function filters an array of items based on pattern matching.
- *
- * @example 
- *
- * const array = [
- *   { name: "Oliver", age: 20 },
- *   { name: "Sam", age: 40 },
- *   { name: "George", age: 41 },
- *   { name: "Smith", age: 20 },
- * ];
- * 
- * filterBy({ age: 20 }, array); // [{ name: "Oliver", age: 20 }, { name: "Smith", age: 20 }]
- * filterBy({ age: gt(__, 40) }, array); // [{ name: "George", age: 41 }]
- * filterBy({ age: 50 }, array); // []
- * @endexample
-*/
-export function filterBy<T>(pattern: MatchPattern<T>, entityArray: T[]): T[];
-/**
- *
- * The filterBy function filters an array of items based on pattern matching.
- *
- * @example 
- *
- * const array = [
- *   { name: "Oliver", age: 20 },
- *   { name: "Sam", age: 40 },
- *   { name: "George", age: 41 },
- *   { name: "Smith", age: 20 },
- * ];
- * 
- * filterBy({ age: 20 }, array); // [{ name: "Oliver", age: 20 }, { name: "Smith", age: 20 }]
- * filterBy({ age: gt(__, 40) }, array); // [{ name: "George", age: 41 }]
- * filterBy({ age: 50 }, array); // []
- * @endexample
-*/
-export function filterBy(pattern: MatchPattern): <T>(entityArray: T[]) => T[];
-export function _filterBy<T>(pattern: MatchPattern<T>, entityArray: NilOr<T[]>): NilOr<T[]>;
-export function _filterBy(pattern: MatchPattern): <T>(entityArray: NilOr<T[]>) => NilOr<T[]>;
-/**
- *
- * The filterNonNull function accepts an object and returns a new object with
- *
- * only the properties that are not null or undefined. It filters out
- *
- * properties with these values, creating a new object with only the non-null and
- *
- * non-undefined properties.
- *
- * @example 
- *
- * filterNonNull({
- *   firstName: "Oliver",
- *   lastName: null,
- *   phoneNumbers: { home: undefined, office: "1234567890" },
- * });
- * 
- * 
- * {
- *   firstName: "Oliver",
- *   phoneNumbers: { office: "1234567890" },
- * }
- * 
- * @endexample
-*/
-export function filterNonNull(object: object): object;
-export function _filterNonNull(object: NilOr<object>): NilOr<object>;
-/**
- *
- * The findBy function locates the first item in the array that matches the
- *
- * provided pattern.
- *
- * @example 
- *
- * const array = [
- *   { id: 1, name: "Sam", address: { street: "First street", pin: 123456 } },
- *   { id: 2, name: "Oliver", address: { street: "Second street", pin: 654321 } },
- * ];
- * 
- * findBy({ name: "Sam" }, array); // returns object corresponding to Sam
- * findBy({ id: 2, address: { pin: 654321 } }, array); // returns object corresponding to Oliver
- * findBy({ id: 3 }, array); // returns undefined
- * @endexample
-*/
-export function findBy<T>(pattern: MatchPattern<T>, entityArray: T[]): T;
-/**
- *
- * The findBy function locates the first item in the array that matches the
- *
- * provided pattern.
- *
- * @example 
- *
- * const array = [
- *   { id: 1, name: "Sam", address: { street: "First street", pin: 123456 } },
- *   { id: 2, name: "Oliver", address: { street: "Second street", pin: 654321 } },
- * ];
- * 
- * findBy({ name: "Sam" }, array); // returns object corresponding to Sam
- * findBy({ id: 2, address: { pin: 654321 } }, array); // returns object corresponding to Oliver
- * findBy({ id: 3 }, array); // returns undefined
- * @endexample
-*/
-export function findBy(pattern: MatchPattern): <T>(entityArray: T[]) => T;
-export function _findBy<T>(pattern: MatchPattern<T>, entityArray: NilOr<T[]>): NilOr<T>;
-export function _findBy(pattern: MatchPattern): <T>(entityArray: NilOr<T[]>) => NilOr<T>;
-/**
- *
- * The findById function is used to locate an object within an array based on the
- *
- * provided Id.
- *
- * @example 
- *
- * const array = [
- *   { id: 1, name: "Sam" },
- *   { id: 2, name: "Oliver" },
- * ];
- * const idOfItemToBeFind = 2;
- * 
- * findById(idOfItemToBeFind, array);
- * // { id: 2, name: "Oliver" }
- * @endexample
-*/
-export function findById<T>(id: any, entityArray: T[]): T;
-/**
- *
- * The findById function is used to locate an object within an array based on the
- *
- * provided Id.
- *
- * @example 
- *
- * const array = [
- *   { id: 1, name: "Sam" },
- *   { id: 2, name: "Oliver" },
- * ];
- * const idOfItemToBeFind = 2;
- * 
- * findById(idOfItemToBeFind, array);
- * // { id: 2, name: "Oliver" }
- * @endexample
-*/
-export function findById(id: any): <T>(entityArray: T[]) => T;
-export function _findById<T>(id: any, entityArray: NilOr<T[]>): NilOr<T>;
-export function _findById(id: any): <T>(entityArray: NilOr<T[]>) => NilOr<T>;
-/**
- *
- * The findIndexBy function finds the index of the item in the array that matches
- *
- * the provided pattern.
- *
- * @example 
- *
- * const array = [
- *   { id: 1, name: "Sam", address: { street: "First street", pin: 123456 } },
- *   { id: 2, name: "Oliver", address: { street: "Second street", pin: 654321 } },
- * ];
- * 
- * findIndexBy({ name: "Sam" }, array); // returns 0
- * findIndexBy({ id: 2, address: { pin: 654321 } }, array); // returns 1
- * findIndexBy({ id: 3 }, array); // returns -1
- * @endexample
-*/
-export function findIndexBy<T>(pattern: MatchPattern<T>, entityArray: T[]): number;
-/**
- *
- * The findIndexBy function finds the index of the item in the array that matches
- *
- * the provided pattern.
- *
- * @example 
- *
- * const array = [
- *   { id: 1, name: "Sam", address: { street: "First street", pin: 123456 } },
- *   { id: 2, name: "Oliver", address: { street: "Second street", pin: 654321 } },
- * ];
- * 
- * findIndexBy({ name: "Sam" }, array); // returns 0
- * findIndexBy({ id: 2, address: { pin: 654321 } }, array); // returns 1
- * findIndexBy({ id: 3 }, array); // returns -1
- * @endexample
-*/
-export function findIndexBy(pattern: MatchPattern): (entityArray: object[]) => number;
-export function _findIndexBy<T>(pattern: MatchPattern<T>, entityArray: NilOr<T[]>): NilOr<number>;
-export function _findIndexBy(pattern: MatchPattern): (entityArray: NilOr<object[]>) => NilOr<number>;
-/**
- *
- * The findIndexById function is used to find the index of an item within an
- *
- * array of items based on the id property of the entities within it.
- *
- * @example 
- *
- * const array = [
- *   { id: "1001", name: "Sam" },
- *   { id: "2001", name: "Oliver" },
- * ];
- * 
- * findIndexById("2001", array); // returns 1
- * findIndexById("1001", array); // returns 0
- * findIndexById("3001", array); // returns -1
- * @endexample
-*/
-export function findIndexById(id: any, entityArray: object[]): number;
-/**
- *
- * The findIndexById function is used to find the index of an item within an
- *
- * array of items based on the id property of the entities within it.
- *
- * @example 
- *
- * const array = [
- *   { id: "1001", name: "Sam" },
- *   { id: "2001", name: "Oliver" },
- * ];
- * 
- * findIndexById("2001", array); // returns 1
- * findIndexById("1001", array); // returns 0
- * findIndexById("3001", array); // returns -1
- * @endexample
-*/
-export function findIndexById(id: any): (entityArray: object[]) => number;
-export function _findIndexById(id: any, entityArray: NilOr<object[]>): NilOr<number>;
-export function _findIndexById(id: any): (entityArray: NilOr<object[]>) => NilOr<number>;
-/**
- *
- * The findLastBy function finds the last item in the array that matches the
- *
- * provided pattern.
- *
- * @example 
- *
- * const array = [
- *   { name: "Oliver", age: 20 },
- *   { name: "Sam", age: 40 },
- *   { name: "George", age: 41 },
- *   { name: "Smith", age: 20 },
- * ];
- * 
- * findLastBy({ age: 20 }, array); // { name: "Smith", age: 20 }
- * findLastBy({ name: includes("e") }, array); // { name: "George", age: 41 }
- * @endexample
-*/
-export function findLastBy<T>(pattern: MatchPattern<T>, entityArray: T[]): T;
-/**
- *
- * The findLastBy function finds the last item in the array that matches the
- *
- * provided pattern.
- *
- * @example 
- *
- * const array = [
- *   { name: "Oliver", age: 20 },
- *   { name: "Sam", age: 40 },
- *   { name: "George", age: 41 },
- *   { name: "Smith", age: 20 },
- * ];
- * 
- * findLastBy({ age: 20 }, array); // { name: "Smith", age: 20 }
- * findLastBy({ name: includes("e") }, array); // { name: "George", age: 41 }
- * @endexample
-*/
-export function findLastBy(pattern: MatchPattern): <T>(entityArray: T[]) => T;
-export function _findLastBy<T>(pattern: MatchPattern<T>, entityArray: NilOr<T[]>): NilOr<T>;
-export function _findLastBy(pattern: MatchPattern): <T>(entityArray: NilOr<T[]>) => NilOr<T>;
-/**
- *
- * The findLastIndexBy function finds the last index of an item in the array that
- *
- * matches the provided pattern.
- *
- * @example 
- *
- * const array = [
- *   { name: "Oliver", age: 20 },
- *   { name: "Sam", age: 40 },
- *   { name: "George", age: 41 },
- *   { name: "Smith", age: 20 },
- * ];
- * 
- * findLastIndexBy({ age: 20 }, array); // returns 3
- * findLastIndexBy({ name: includes("e") }, array); // returns 2
- * @endexample
-*/
-export function findLastIndexBy(id: any, entityArray: object[]): number;
-/**
- *
- * The findLastIndexBy function finds the last index of an item in the array that
- *
- * matches the provided pattern.
- *
- * @example 
- *
- * const array = [
- *   { name: "Oliver", age: 20 },
- *   { name: "Sam", age: 40 },
- *   { name: "George", age: 41 },
- *   { name: "Smith", age: 20 },
- * ];
- * 
- * findLastIndexBy({ age: 20 }, array); // returns 3
- * findLastIndexBy({ name: includes("e") }, array); // returns 2
- * @endexample
-*/
-export function findLastIndexBy(id: any): (entityArray: object[]) => number;
-export function _findLastIndexBy(id: any, entityArray: NilOr<object[]>): NilOr<number>;
-export function _findLastIndexBy(id: any): (entityArray: NilOr<object[]>) => NilOr<number>;
-/**
- *
- * The getRandomInt function generates a random integer within a specified range.
- *
- * If only one argument is provided, it is considered as the upper bound, and the
- *
- * lower bound is assumed to be 0.
- *
- * @example 
- *
- * getRandomInt(); // returns a random integer between 0 and 9007199254740991 (MAX_SAFE_INTEGER)
- * getRandomInt(10); // returns a random integer between 0 and 10
- * getRandomInt(1, 5); // returns a random integer between 1 and 5
- * @endexample
-*/
-export function getRandomInt(a?: number, b?: number): number;
-/**
- *
- * The humanize function converts common developer-friendly string formats such
- *
- * as camelCase, snake_case, dash-case, etc., into human-readable strings.
- *
- * @example 
- *
- * humanize("helloWorld"); // "Hello world"
- * humanize("hello-world"); // "Hello world"
- * humanize("__hello_world"); // "Hello world"
- * humanize("HelloUSA"); // "Hello usa"
- * @endexample
-*/
-export function humanize(string: string): string;
-export function _humanize(string: NilOr<string>): NilOr<string>;
-/**
- *
- * The isNot function returns true if the given values (or references) are not
- *
- * equal and false otherwise. It provides the opposite behavior of the
- *
- * Object.is() method.
- *
- * The primary difference between isNot() and !== is that isNot() is a
- *
- * curried function, which means you can partially apply it to create a new
- *
- * function that's pre-configured to compare one value against another value
- *
- * repeatedly.
- *
- * @example 
- *
- * const value1 = 10;
- * const isNotValue1 = isNot(value1);
- * const value2 = 20;
- * isNotValue1(value2); // true
- * 
- * // Filter out fruits that are not Apple
- * const fruits = ["Apple", "Orange", "Lemon"];
- * fruits.filter(notEquals("Apple")); // ["Orange", "Lemon"];
- * @endexample
-*/
-export function isNot(a: any, b: any): boolean;
-/**
- *
- * The isNot function returns true if the given values (or references) are not
- *
- * equal and false otherwise. It provides the opposite behavior of the
- *
- * Object.is() method.
- *
- * The primary difference between isNot() and !== is that isNot() is a
- *
- * curried function, which means you can partially apply it to create a new
- *
- * function that's pre-configured to compare one value against another value
- *
- * repeatedly.
- *
- * @example 
- *
- * const value1 = 10;
- * const isNotValue1 = isNot(value1);
- * const value2 = 20;
- * isNotValue1(value2); // true
- * 
- * // Filter out fruits that are not Apple
- * const fruits = ["Apple", "Orange", "Lemon"];
- * fruits.filter(notEquals("Apple")); // ["Orange", "Lemon"];
- * @endexample
-*/
-export function isNot(a: any): (b: any) => boolean;
-/**
- *
- * The isNotEmpty returns true if the given value is not empty (includes
- *
- * strings, arrays, objects) and false otherwise. It provides the opposite
- *
- * behavior of checking if a value is empty, similar to the isEmpty function in
- *
- * Ramda.
- *
- * @example 
- *
- * isNotEmpty(""); // returns false
- * isNotEmpty(["a"]); // returns true
- * isNotEmpty({ name: "Oliver" }); //return true
- * @endexample
-*/
-export const isNotEmpty: (a: any) => boolean;
-/**
- *
- * The isNotEqualDeep function returns true if the given values are not equal,
- *
- * considering deep equality. It checks for deep inequality between objects or
- *
- * arrays.
- *
- * @example 
- *
- * const object1 = {
- *   a: 1,
- *   b: { c: 3 },
- * };
- * 
- * const object2 = {
- *   a: 1,
- *   b: { c: 2 },
- * };
- * 
- * isNotEqualsDeep(object1, object2); //returns true
- * notEqualsDeep(object1, object2); //returns true
- * @endexample
-*/
-export function isNotEqualDeep(a: any, b: any): boolean;
-/**
- *
- * The isNotEqualDeep function returns true if the given values are not equal,
- *
- * considering deep equality. It checks for deep inequality between objects or
- *
- * arrays.
- *
- * @example 
- *
- * const object1 = {
- *   a: 1,
- *   b: { c: 3 },
- * };
- * 
- * const object2 = {
- *   a: 1,
- *   b: { c: 2 },
- * };
- * 
- * isNotEqualsDeep(object1, object2); //returns true
- * notEqualsDeep(object1, object2); //returns true
- * @endexample
-*/
-export function isNotEqualDeep(a: any): (b: any) => boolean;
-/**
- *
- * The keysToCamelCase function recursively converts the snake-cased object keys
- *
- * to camel case.
- *
- * @example 
- *
- * keysToCamelCase({
- *   first_name: "Oliver",
- *   last_name: "Smith",
- *   address: { city: "Miami", phone_number: "389791382" },
- * });
- * 
- * {
- *   address: {city: 'Miami', phoneNumber: '389791382'},
- *   firstName: "Oliver",
- *   lastName: "Smith",
- * }
- * 
- * @endexample
-*/
-export function keysToCamelCase(object: any): any;
-/**
- *
- * The keysToSnakeCase function recursively converts the camel-cased object keys
- *
- * to snake case.
- *
- * @example 
- *
- * keysToSnakeCase({
- *   address: { city: "Miami", phoneNumber: "389791382" },
- *   firstName: "Oliver",
- *   lastName: "Smith",
- * });
- * 
- * {
- *   first_name: "Oliver",
- *   last_name: "Smith",
- *   address: { city: "Miami", phone_number: "389791382" },
- * }
- * 
- * @endexample
-*/
-export function keysToSnakeCase(object: any): any;
-/**
- *
- * The matches function checks whether the given object matches the given
- *
- * pattern. It compares the primitive value (int, boolean, string, etc.) in the
- *
- * object with the corresponding values in the pattern (deeply) and checks if all
- *
- * conditions (functions) are satisfied for a match.
- *
- * @example 
- *
- * const user = {
- *   firstName: "Oliver",
- *   address: { city: "Miami", phoneNumber: "389791382" },
- *   cars: [{ brand: "Ford" }, { brand: "Honda" }],
- * };
- * 
- * matches({ firstName: "Oliver" }, user); // true
- * matches({ address: { city: "Miami" } }, user); // true
- * matches({ cars: [{ brand: "Ford" }] }, user); // true
- * matches({ firstName: "Sam" }, user); // false
- * matches({ address: { country: "US" } }, user); // false
- * matches({ cars: [{ brand: "Honda" }] }, user); // false
- * // array index as object key
- * matches({ cars: { 1: { brand: "Honda" } } }, user); // true
- * // conditional functions
- * matches({ cars: arr => arr.length === 2 }, user); // true
- * // point-free functions with ramda
- * matches({ firstName: startsWith("O") }, user); // true
- * @endexample
-*/
-export function matches<T>(pattern: MatchPattern<T>, data: T): boolean;
-/**
- *
- * The matches function checks whether the given object matches the given
- *
- * pattern. It compares the primitive value (int, boolean, string, etc.) in the
- *
- * object with the corresponding values in the pattern (deeply) and checks if all
- *
- * conditions (functions) are satisfied for a match.
- *
- * @example 
- *
- * const user = {
- *   firstName: "Oliver",
- *   address: { city: "Miami", phoneNumber: "389791382" },
- *   cars: [{ brand: "Ford" }, { brand: "Honda" }],
- * };
- * 
- * matches({ firstName: "Oliver" }, user); // true
- * matches({ address: { city: "Miami" } }, user); // true
- * matches({ cars: [{ brand: "Ford" }] }, user); // true
- * matches({ firstName: "Sam" }, user); // false
- * matches({ address: { country: "US" } }, user); // false
- * matches({ cars: [{ brand: "Honda" }] }, user); // false
- * // array index as object key
- * matches({ cars: { 1: { brand: "Honda" } } }, user); // true
- * // conditional functions
- * matches({ cars: arr => arr.length === 2 }, user); // true
- * // point-free functions with ramda
- * matches({ firstName: startsWith("O") }, user); // true
- * @endexample
-*/
-export function matches(pattern: MatchPattern): (data: any) => boolean;
-/**
- *
- * The modifyBy function modifies all items in the array that match the provided
- *
- * pattern using the given modifier function.
- *
- * @example 
- *
- * const array = [
- *   { id: 1, name: "Sam", address: { street: "First street", pin: 101283 } },
- *   { id: 2, name: "Oliver", address: { street: "Second street", pin: 998472 } },
- * ];
- * const modifier = item => assoc("name", item.name.toUpperCase(), item);
- * 
- * modifyBy({ name: "Oliver" }, modifier, array);
- * 
- * [{id: 1, name: "Sam"}, {id: 2, name: "OLIVER"}]
- *  
- * @endexample
-*/
-export function modifyBy<T>(pattern: MatchPattern<T>, modifier: (previous: T) => T, entityArray: T[]): T[];
-/**
- *
- * The modifyBy function modifies all items in the array that match the provided
- *
- * pattern using the given modifier function.
- *
- * @example 
- *
- * const array = [
- *   { id: 1, name: "Sam", address: { street: "First street", pin: 101283 } },
- *   { id: 2, name: "Oliver", address: { street: "Second street", pin: 998472 } },
- * ];
- * const modifier = item => assoc("name", item.name.toUpperCase(), item);
- * 
- * modifyBy({ name: "Oliver" }, modifier, array);
- * 
- * [{id: 1, name: "Sam"}, {id: 2, name: "OLIVER"}]
- *  
- * @endexample
-*/
-export function modifyBy<T>(pattern: MatchPattern<T>, modifier: (previous: T) => T): (entityArray: T[]) => T[];
-/**
- *
- * The modifyBy function modifies all items in the array that match the provided
- *
- * pattern using the given modifier function.
- *
- * @example 
- *
- * const array = [
- *   { id: 1, name: "Sam", address: { street: "First street", pin: 101283 } },
- *   { id: 2, name: "Oliver", address: { street: "Second street", pin: 998472 } },
- * ];
- * const modifier = item => assoc("name", item.name.toUpperCase(), item);
- * 
- * modifyBy({ name: "Oliver" }, modifier, array);
- * 
- * [{id: 1, name: "Sam"}, {id: 2, name: "OLIVER"}]
- *  
- * @endexample
-*/
-export function modifyBy(pattern: MatchPattern): <T>(modifier: (previous: T) => T, entityArray: T[]) => T[];
-/**
- *
- * The modifyBy function modifies all items in the array that match the provided
- *
- * pattern using the given modifier function.
- *
- * @example 
- *
- * const array = [
- *   { id: 1, name: "Sam", address: { street: "First street", pin: 101283 } },
- *   { id: 2, name: "Oliver", address: { street: "Second street", pin: 998472 } },
- * ];
- * const modifier = item => assoc("name", item.name.toUpperCase(), item);
- * 
- * modifyBy({ name: "Oliver" }, modifier, array);
- * 
- * [{id: 1, name: "Sam"}, {id: 2, name: "OLIVER"}]
- *  
- * @endexample
-*/
-export function modifyBy(pattern: MatchPattern): <T>(modifier: (previous: T) => T) => (entityArray: T[]) => T[];
-export function _modifyBy<T>(pattern: MatchPattern<T>, modifier: (previous: T) => T, entityArray: NilOr<T[]>): NilOr<T[]>;
-export function _modifyBy<T>(pattern: MatchPattern<T>, modifier: (previous: T) => T): (entityArray: NilOr<T[]>) => NilOr<T[]>;
-export function _modifyBy(pattern: MatchPattern): <T>(modifier: (previous: T) => T, entityArray: NilOr<T[]>) => NilOr<T[]>;
-export function _modifyBy(pattern: MatchPattern): <T>(modifier: (previous: T) => T) => (entityArray: NilOr<T[]>) => NilOr<T[]>;
-/**
- *
- * The modifyById function applies a modifier function to the item with the
- *
- * specified id in an array and returns a new array with the modified item in the
- *
- * same index.
- *
- * @example 
- *
- * const array = [
- *   { id: 1, name: "Sam" },
- *   { id: 2, name: "Oliver" },
- * ];
- * const idOfItemToBeModified = 2;
- * const modifier = item => assoc("name", item.name.toUpperCase(), item);
- * 
- * modifyById(idOfItemToBeModified, modifier, array);
- * 
- * [{ id: 1, name: "Sam" }, { id: 2, name: "OLIVER" }]
- * 
- * @endexample
-*/
-export function modifyById<T>(id: any, modifier: (previous: T) => T, entityArray: T[]): T[];
-/**
- *
- * The modifyById function applies a modifier function to the item with the
- *
- * specified id in an array and returns a new array with the modified item in the
- *
- * same index.
- *
- * @example 
- *
- * const array = [
- *   { id: 1, name: "Sam" },
- *   { id: 2, name: "Oliver" },
- * ];
- * const idOfItemToBeModified = 2;
- * const modifier = item => assoc("name", item.name.toUpperCase(), item);
- * 
- * modifyById(idOfItemToBeModified, modifier, array);
- * 
- * [{ id: 1, name: "Sam" }, { id: 2, name: "OLIVER" }]
- * 
- * @endexample
-*/
-export function modifyById<T>(id: any, modifier: (previous: T) => T): (entityArray: T[]) => T[];
-/**
- *
- * The modifyById function applies a modifier function to the item with the
- *
- * specified id in an array and returns a new array with the modified item in the
- *
- * same index.
- *
- * @example 
- *
- * const array = [
- *   { id: 1, name: "Sam" },
- *   { id: 2, name: "Oliver" },
- * ];
- * const idOfItemToBeModified = 2;
- * const modifier = item => assoc("name", item.name.toUpperCase(), item);
- * 
- * modifyById(idOfItemToBeModified, modifier, array);
- * 
- * [{ id: 1, name: "Sam" }, { id: 2, name: "OLIVER" }]
- * 
- * @endexample
-*/
-export function modifyById(id: any): <T>(modifier: (previous: T) => T, entityArray: T[]) => T[];
-/**
- *
- * The modifyById function applies a modifier function to the item with the
- *
- * specified id in an array and returns a new array with the modified item in the
- *
- * same index.
- *
- * @example 
- *
- * const array = [
- *   { id: 1, name: "Sam" },
- *   { id: 2, name: "Oliver" },
- * ];
- * const idOfItemToBeModified = 2;
- * const modifier = item => assoc("name", item.name.toUpperCase(), item);
- * 
- * modifyById(idOfItemToBeModified, modifier, array);
- * 
- * [{ id: 1, name: "Sam" }, { id: 2, name: "OLIVER" }]
- * 
- * @endexample
-*/
-export function modifyById(id: any): <T>(modifier: (previous: T) => T) => (entityArray: T[]) => T[];
-export function _modifyById<T>(id: any, modifier: (previous: T) => T, entityArray: NilOr<T[]>): NilOr<T[]>;
-export function _modifyById<T>(id: any, modifier: (previous: T) => T): (entityArray: NilOr<T[]>) => NilOr<T[]>;
-export function _modifyById(id: any): <T>(modifier: (previous: T) => T, entityArray: NilOr<T[]>) => NilOr<T[]>;
-export function _modifyById(id: any): <T>(modifier: (previous: T) => T) => (entityArray: NilOr<T[]>) => NilOr<T[]>;
-/**
- *
- * The noop function is a "no-operation" function that does nothing when called and
- *
- * returns undefined. It is often used as a placeholder or a default function
- *
- * when a function is expected but no action is required.
- *
-*/
-export function noop(...args: any[]): void;
-export function notEquals(a: any, b: any): boolean;
-export function notEquals(a: any): (b: any) => boolean;
-export function notEqualsDeep(a: any, b: any): boolean;
-export function notEqualsDeep(a: any): (b: any) => boolean;
-/**
- *
- * The randomPick function accepts a variable number of arguments and returns a
- *
- * random element from the list of arguments. It randomly selects one of the
- *
- * provided values and returns it.
- *
- * @example 
- *
- * randomPick("arg1", "arg2", "arg3", "arg4", "arg5");
- * 
- * // output: a random element from the list "arg1", "arg2", "arg3", "arg4" and "arg5"
- * @endexample
-*/
-export function randomPick<T>(...args: T[]): T;
-/**
- *
- * The removeBy function removes all items in the array that match the provided
- *
- * pattern.
- *
- * @example 
- *
- * const array = [
- *   { id: 1, name: "Sam", address: { street: "First street", pin: 101283 } },
- *   { id: 2, name: "Oliver", address: { street: "Second street", pin: 998472 } },
- * ];
- * 
- * removeBy({ name: "Sam" }, array); // removes Sam
- * removeBy({ id: 2, address: { pin: 654321 } }, array); // removes Oliver
- * removeBy({ id: 3 }, array); // does nothing
- * @endexample
-*/
-export function removeBy<T>(pattern: MatchPattern<T>, entityArray: T[]): T[];
-/**
- *
- * The removeBy function removes all items in the array that match the provided
- *
- * pattern.
- *
- * @example 
- *
- * const array = [
- *   { id: 1, name: "Sam", address: { street: "First street", pin: 101283 } },
- *   { id: 2, name: "Oliver", address: { street: "Second street", pin: 998472 } },
- * ];
- * 
- * removeBy({ name: "Sam" }, array); // removes Sam
- * removeBy({ id: 2, address: { pin: 654321 } }, array); // removes Oliver
- * removeBy({ id: 3 }, array); // does nothing
- * @endexample
-*/
-export function removeBy(pattern: MatchPattern): <T>(entityArray: T[]) => T[];
-export function _removeBy<T>(pattern: MatchPattern<T>, entityArray: NilOr<T[]>): NilOr<T[]>;
-export function _removeBy(pattern: MatchPattern): <T>(entityArray: NilOr<T[]>) => NilOr<T[]>;
-/**
- *
- * The removeById function generates a new array with the item possessing the
- *
- * specified id removed.
- *
- * @example 
- *
- * const array = [
- *   { id: 1, name: "Sam" },
- *   { id: 2, name: "Oliver" },
- * ];
- * const idOfItemToBeRemoved = 2;
- * 
- * removeById(idOfItemToBeRemoved, array);
- * // [{ id: 1, name: "Sam" }]
- * @endexample
-*/
-export function removeById<T>(id: any, entityArray: T[]): T[];
-/**
- *
- * The removeById function generates a new array with the item possessing the
- *
- * specified id removed.
- *
- * @example 
- *
- * const array = [
- *   { id: 1, name: "Sam" },
- *   { id: 2, name: "Oliver" },
- * ];
- * const idOfItemToBeRemoved = 2;
- * 
- * removeById(idOfItemToBeRemoved, array);
- * // [{ id: 1, name: "Sam" }]
- * @endexample
-*/
-export function removeById(id: any): <T>(entityArray: T[]) => T[];
-export function _removeById<T>(id: any, entityArray: NilOr<T[]>): NilOr<T[]>;
-export function _removeById(id: any): <T>(entityArray: NilOr<T[]>) => NilOr<T[]>;
-/**
- *
- * The renameKeys function renames specified keys in each object of an array
- *
- * while keeping their values the same. It creates a new instance and does not
- *
- * mutate the original array.
- *
- * @example 
- *
- * const data = [
- *   { id: 1, name: "Tomato", quantity: 10 },
- *   { id: 2, name: "Potato", quantity: 20 },
- * ];
- * 
- * // rename name to label and id to value
- * renameKeys({ name: "label", id: "value" }, data);
- * 
- * 
- * output: [
- *   { label: "Tomato", value: 1, quantity: 10 },
- *   { label: "Potato", value: 2, quantity: 20 },
- * ];
- * 
- * @endexample
-*/
-export function renameKeys<T, M extends { [key in keyof Partial<T>]: string }>(keyMap: M, entityArray: T[]): (Omit<T, keyof M> & {
-  [key: string]: any;
-})[];
-/**
- *
- * The renameKeys function renames specified keys in each object of an array
- *
- * while keeping their values the same. It creates a new instance and does not
- *
- * mutate the original array.
- *
- * @example 
- *
- * const data = [
- *   { id: 1, name: "Tomato", quantity: 10 },
- *   { id: 2, name: "Potato", quantity: 20 },
- * ];
- * 
- * // rename name to label and id to value
- * renameKeys({ name: "label", id: "value" }, data);
- * 
- * 
- * output: [
- *   { label: "Tomato", value: 1, quantity: 10 },
- *   { label: "Potato", value: 2, quantity: 20 },
- * ];
- * 
- * @endexample
-*/
-export function renameKeys<M extends {
-  [key: string]: string;
-}>(keyMap: M): <T>(entityArray: T[]) => (Omit<T, keyof M> & {
-  [key: string]: any;
-})[];
-export function _renameKeys<T, M extends { [key in keyof Partial<T>]: string }>(keyMap: M, entityArray: NilOr<T[]>): NilOr<(Omit<T, keyof M> & {
-  [key: string]: any;
-})[]>;
-export function _renameKeys<M extends {
-  [key: string]: string;
-}>(keyMap: M): <T>(entityArray: NilOr<T[]>) => NilOr<(Omit<T, keyof M> & {
-  [key: string]: any;
-})[]>;
-/**
- *
- * The replaceBy function replaces all items in the array that match the provided
- *
- * pattern with the given item.
- *
- * @example 
- *
- * const array = [
- *   { id: 1, name: "Sam", address: { street: "First street", pin: 101283 } },
- *   { id: 2, name: "Oliver", address: { street: "Second street", pin: 998472 } },
- * ];
- * const newItem = { id: 2, name: "John" };
- * 
- * replaceBy({ name: "Oliver" }, newItem, array);
- * 
- * [{id: 1, name: "Sam"}, {id: 2, name: "John"}]
- *  
- * @endexample
-*/
-export function replaceBy<T>(pattern: MatchPattern<T>, entity: T, entityArray: T[]): T[];
-/**
- *
- * The replaceBy function replaces all items in the array that match the provided
- *
- * pattern with the given item.
- *
- * @example 
- *
- * const array = [
- *   { id: 1, name: "Sam", address: { street: "First street", pin: 101283 } },
- *   { id: 2, name: "Oliver", address: { street: "Second street", pin: 998472 } },
- * ];
- * const newItem = { id: 2, name: "John" };
- * 
- * replaceBy({ name: "Oliver" }, newItem, array);
- * 
- * [{id: 1, name: "Sam"}, {id: 2, name: "John"}]
- *  
- * @endexample
-*/
-export function replaceBy<T>(pattern: MatchPattern<T>, entity: T): <T>(entityArray: T[]) => T[];
-/**
- *
- * The replaceBy function replaces all items in the array that match the provided
- *
- * pattern with the given item.
- *
- * @example 
- *
- * const array = [
- *   { id: 1, name: "Sam", address: { street: "First street", pin: 101283 } },
- *   { id: 2, name: "Oliver", address: { street: "Second street", pin: 998472 } },
- * ];
- * const newItem = { id: 2, name: "John" };
- * 
- * replaceBy({ name: "Oliver" }, newItem, array);
- * 
- * [{id: 1, name: "Sam"}, {id: 2, name: "John"}]
- *  
- * @endexample
-*/
-export function replaceBy(pattern: MatchPattern): <T>(entity: T) => (entityArray: T[]) => T[];
-export function _replaceBy<T>(pattern: MatchPattern<T>, entity: NilOr<T>, entityArray: NilOr<T[]>): NilOr<T[]>;
-export function _replaceBy<T>(pattern: MatchPattern<T>, entity: NilOr<T>): <T>(entityArray: NilOr<T[]>) => NilOr<T[]>;
-export function _replaceBy(pattern: MatchPattern): <T>(entity: NilOr<T>) => <T>(entityArray: NilOr<T[]>) => NilOr<T[]>;
-/**
- *
- * The replaceById function returns a new array with the item having the
- *
- * specified id replaced by the provided object.
- *
- * @example 
- *
- * const array = [
- *   { id: 1, name: "Sam" },
- *   { id: 2, name: "Oliver" },
- * ];
- * const idOfItemToBeReplaced = 2;
- * const newItem = { id: 3, name: "John" };
- * 
- * replaceById(idOfItemToBeReplaced, newItem, array);
- * 
- * [{ id: 1, name: "Sam" }, { id: 3, name: "John" }]
- * 
- * @endexample
-*/
-export function replaceById<T>(id: any, entity: T, entityArray: T[]): T[];
-/**
- *
- * The replaceById function returns a new array with the item having the
- *
- * specified id replaced by the provided object.
- *
- * @example 
- *
- * const array = [
- *   { id: 1, name: "Sam" },
- *   { id: 2, name: "Oliver" },
- * ];
- * const idOfItemToBeReplaced = 2;
- * const newItem = { id: 3, name: "John" };
- * 
- * replaceById(idOfItemToBeReplaced, newItem, array);
- * 
- * [{ id: 1, name: "Sam" }, { id: 3, name: "John" }]
- * 
- * @endexample
-*/
-export function replaceById<T>(id: any, entity: T): <T>(entityArray: T[]) => T[];
-/**
- *
- * The replaceById function returns a new array with the item having the
- *
- * specified id replaced by the provided object.
- *
- * @example 
- *
- * const array = [
- *   { id: 1, name: "Sam" },
- *   { id: 2, name: "Oliver" },
- * ];
- * const idOfItemToBeReplaced = 2;
- * const newItem = { id: 3, name: "John" };
- * 
- * replaceById(idOfItemToBeReplaced, newItem, array);
- * 
- * [{ id: 1, name: "Sam" }, { id: 3, name: "John" }]
- * 
- * @endexample
-*/
-export function replaceById(id: any): <T>(entity: T) => <T>(entityArray: T[]) => T[];
-export function _replaceById<T>(id: any, entity: NilOr<T>, entityArray: NilOr<T[]>): NilOr<T[]>;
-export function _replaceById<T>(id: any, entity: NilOr<T>): <T>(entityArray: NilOr<T[]>) => NilOr<T[]>;
-export function _replaceById(id: any): <T>(entity: NilOr<T>) => <T>(entityArray: NilOr<T[]>) => NilOr<T[]>;
-/**
- *
- * The serializeKeysToSnakeCase function recursively converts the camel-cased
- *
- * object keys to snake case. It gracefully handles special objects like Date and
- *
- * dayjs instances. Additionally, while converting, this function checks if the
- *
- * value being processed is an object and if it has a toJSON function. If the
- *
- * toJSON function is present, it calls the function and uses the return value
- *
- * for further processing.
- *
- * Example 1:
- *
- * @example 
- *
- * serializeKeysToSnakeCase({
- *   name: { toJSON: () => ({ firstName: "Oliver", lastName: "Smith" }) },
- *   phoneNumber: "389791382",
- * });
- * 
- * 
- * {
- *   name: { first_name: "Oliver", last_name: "Smith" },
- *   phone_number: "389791382",
- * }
- * 
- * @endexample
- * Example 2: (Real world example)
- *
- * @example 
- *
- * serializeKeysToSnakeCase({
- *   address: { city: "Miami", phoneNumber: "389791382" },
- *   firstName: "Oliver",
- *   lastName: "Smith",
- *   dob: new Date("1980-01-01"),
- * });
- * 
- * 
- * {
- *   first_name: "Oliver",
- *   last_name: "Smith",
- *   address: { city: "Miami", phone_number: "389791382" },
- *   dob: "1980-01-01T00:00:00.000Z",
- * }
- * 
- * @endexample
- * In the above example, the value of dob is an date object and has toJSON
- *
- * method present in it. The toJSON method returns the date in ISO format which
- *
- * will be used for further processing instead of recursively converting the
- *
- * original date object.
- *
-*/
-export function serializeKeysToSnakeCase(object: object): object;
-/**
- *
- * The preprocessForSerialization function creates a ready-to-be-serialized
- *
- * version of the given object by recursively traversing all the object properties
- *
- * and replacing them with their JSON serializable versions. This is particularly
- *
- * helpful when serializing objects that include non-serializable data types, such
- *
- * as Date objects, dayjs objects or custom classes.
- *
- * @example 
- *
- * preprocessForSerialization(dayjs("1980-01-01")); // returns "1980-01-01T00:00:00.000Z"
- * preprocessForSerialization({
- *   toJSON: () => ({ firstName: "Oliver", lastName: "Smith" }),
- * }); // returns { firstName: "Oliver", lastName: "Smith" }
- * @endexample
-*/
-export function preprocessForSerialization(object: object): object;
-/**
- *
- * The slugify function converts a given string into a slug. A slug is a
- *
- * URL-friendly representation of a string, typically used for creating
- *
- * human-readable and SEO-friendly URLs. This function transforms a string by
- *
- * removing spaces, special characters, and converting it to lowercase to create a
- *
- * valid slug.
- *
- * @example 
- *
- * slugify("My quiz"); // "my-quiz"
- * slugify("my-quiz"); // "my-quiz"
- * slugify("-----my----quiz"); // "my-quiz"
- * slugify("Me & my quiz"); // "me-and-my-quiz"
- * slugify("my!@#$%^*(quiz"); // "myquiz"
- * @endexample
-*/
-export function slugify(string: string): string;
-export function _slugify(string: NilOr<string>): NilOr<string>;
-/**
- *
- * The snakeToCamelCase function converts a snake_case string to camelCase.
- *
- * @example 
- *
- * snakeToCamelCase("first_name"); // "firstName"
- * @endexample
-*/
-export function snakeToCamelCase(string: string): string;
-export function _snakeToCamelCase(string: NilOr<string>): NilOr<string>;
-/**
- *
- * The toLabelAndValue function takes a string as an argument and returns an
- *
- * object with keys "label" and "value." It is often used to transform a string
- *
- * into an object with specific key-value pairs.
- *
- * @example 
- *
- * toLabelAndValue("test");
- * 
- * // output: {label: "test", value: "test"}
- * @endexample
-*/
-export function toLabelAndValue(string: string): {
-  label: string;
-  value: string;
-};
-/**
- *
- * The transformObjectDeep function passes each key and value of the given object
- *
- * (recursively) to the provided transformer function. It reconstructs an object of
- *
- * the same hierarchy with the key-value pairs that the transformer function
- *
- * returns.
- *
- * Usage:
- *
- * @example 
- *
- * transformObjectDeep(
- *   {
- *     name: "Oliver",
- *     email: "oliver@example.com",
- *     address: { street: "First street", pin: 123456 },
- *   },
- *   (key, value) => [key.toUpperCase(), value]
- * );
- * 
- * output: {
- *   NAME: "Oliver",
- *   EMAIL: "oliver@example.com",
- *   ADDRESS: { STREET: "First street", PIN: 123456 },
- * }
- * 
- * 
- * transformObjectDeep(
- *   [
- *     [1, 2, 3],
- *     [4, 5, 6],
- *     [7, 8, 9],
- *   ],
- *   (key, value) => [key, value],
- *   item => (Array.isArray(item) ? item.slice(1) : item)
- * );
- * 
- * output: [[5, 6], [8, 9]]
- * 
- * @endexample
-*/
-export function transformObjectDeep(object: object, keyValueTransformer: (key: string | number | symbol, object: any) => any[], objectPreProcessor?: (object: any) => any): object;
-/**
- *
- * The truncate function truncates a string by adding "..." if it exceeds a
- *
- * specified maximum length.
- *
- * @example 
- *
- * truncate("Hello World", 5); //  "Hello..."
- * truncate("Hello World", 15); // "Hello World"
- * @endexample
-*/
-export function truncate(string: string, length: number): string;
-/**
- *
- * The truncate function truncates a string by adding "..." if it exceeds a
- *
- * specified maximum length.
- *
- * @example 
- *
- * truncate("Hello World", 5); //  "Hello..."
- * truncate("Hello World", 15); // "Hello World"
- * @endexample
-*/
-export function truncate(string: NilOr<string>, length: number): NilOr<string>;
-export function nullSafe<T extends Function>(func: T): (...args: any) => ReturnType<T>;
-/**
- *
- * The isNotPresent function is a utility that checks if a value is not present.
- *
- * It combines checks for null and empty values. It is worth noting that we also
- *
- * have a isPresent utility function that returns the complement of
- *
- * isNotPresent.
- *
-*/
-export function isNotPresent(object: any): boolean;
-export function isPresent(object: any): boolean;
-/**
- *
- * The modifyWithImmer function is designed for immutable modification of values
- *
- * and is an abstraction over Immer's produce method. Immer is a library that
- *
- * simplifies working with complex data structures and state updates in a more
- *
- * immutable manner.
- *
- * This function does not include a failsafe mechanism, so it is important to use
- *
- * it with care, especially when working with complex data structures.
- *
- * You can read more about Immer here.
- *
- * Returns the new modified value.
- *
- * @example 
- *
- * const data = { name: "Oliver" };
- * modifyWithImmer(draft => {
- *   draft.name = "Oliver smith";
- * })(data);
- * // outputs: { name: "Oliver smith" }
- * @endexample
- * We can utilize currying with state updator functions:
- *
- * @example 
- *
- * const { setUsers } = useZustandStore.pick();
- * 
- * setUsers(
- *   modifyWithImmer(draft => {
- *     draft[0].addresses.push("Oliver smith");
- *   })
- * );
- * 
- * // updates users to: [{ name: "Oliver smith" }, { name: "Eve" }]
- * @endexample
-*/
-export function modifyWithImmer<T>(modifier: (draft: Draft<T>) => void, data: T): T;
-/**
- *
- * The modifyWithImmer function is designed for immutable modification of values
- *
- * and is an abstraction over Immer's produce method. Immer is a library that
- *
- * simplifies working with complex data structures and state updates in a more
- *
- * immutable manner.
- *
- * This function does not include a failsafe mechanism, so it is important to use
- *
- * it with care, especially when working with complex data structures.
- *
- * You can read more about Immer here.
- *
- * Returns the new modified value.
- *
- * @example 
- *
- * const data = { name: "Oliver" };
- * modifyWithImmer(draft => {
- *   draft.name = "Oliver smith";
- * })(data);
- * // outputs: { name: "Oliver smith" }
- * @endexample
- * We can utilize currying with state updator functions:
- *
- * @example 
- *
- * const { setUsers } = useZustandStore.pick();
- * 
- * setUsers(
- *   modifyWithImmer(draft => {
- *     draft[0].addresses.push("Oliver smith");
- *   })
- * );
- * 
- * // updates users to: [{ name: "Oliver smith" }, { name: "Eve" }]
- * @endexample
-*/
-export function modifyWithImmer<T>(modifier: (draft: Draft<T>) => void): (data: T) => T;