@futdevpro/fsm-dynamo 1.16.39 → 1.20.2

package/build/_collections/utils/array.util.d.ts

@@ -1,389 +1,389 @@
-import { DyFM_Paged } from '../../_models/interfaces/paged.interface';
-/**
- * the return type of the sortForTrue function
- */
-export type DyFM_SortDirection = 0 | 1 | -1;
-export type DyFM_List = DyFM_Array;
-export declare class DyFM_Array {
-    /**
-     * Asynchronously iterates over an array and applies a function to each element.
-     * @param list - The array to iterate over.
-     * @param func - The function to apply to each element.
-     * @returns A promise that resolves when all elements have been processed.
-     *
-     * @example
-     * ```ts
-     * const list: number[] = [ 1, 2, 3 ];
-     * await DyFM_Array.asyncForEach(list, async (element: number, index?: number, array?: number[]): Promise<void> => {
-     *   console.log(element, index, array);
-     * });
-     * ```
-     */
-    static asyncForEach<T>(list: T[], func: (element: T, index?: number, array?: T[]) => Promise<void>): Promise<void>;
-    /**
-     * Asynchronously iterates over an array and applies a function to each element, returning a single result.
-     * @param startData - The initial data to pass to the function.
-     * @param list - The array to iterate over.
-     * @param func - The function to apply to each element.
-     * @returns A promise that resolves to the final result.
-     *
-     * @example
-     * ```ts
-     * const list: number[] = [ 1, 2, 3 ];
-     * const result = await DyFM_Array.asyncForEachReturnToOne(0, list, async (element: number, dataCurrent: number, index?: number, array?: number[]): Promise<number> => {
-     *   return dataCurrent + element;
-     * });
-     * ```
-     */
-    static asyncForEachReturnToOne<T, K>(startData: K, list: T[], func: (element: T, dataCurrent: K, index?: number, array?: T[]) => Promise<K>): Promise<K>;
-    /**
-     * Asynchronously iterates over an array and applies a function to each element, returning an array of results.
-     * @param list - The array to iterate over.
-     * @param func - The function to apply to each element.
-     * @returns A promise that resolves to an array of results.
-     *
-     * @example
-     * ```ts
-     * const list: number[] = [ 1, 2, 3 ];
-     * const result = await DyFM_Array.asyncForEachReturnToAll(list, async (element: number, index?: number, array?: number[]): Promise<number> => {
-     *   return element * 2;
-     * });
-     * ```
-     */
-    static asyncForEachReturnToAll<T, K>(list: T[], func: (element: T, index?: number, array?: T[]) => Promise<K>): Promise<K[]>;
-    /**
-     * Asynchronously iterates over an array and applies a function to each element, returning an array of results.
-     * @param list - The array to iterate over.
-     * @param func - The function to apply to each element.
-     * @returns A promise that resolves to an array of results.
-     *
-     * @example
-     * ```ts
-     * const list: number[] = [ 1, 2, 3 ];
-     * const result = await DyFM_Array.asyncForEachAllAtOnce(list, async (element: number, index?: number, array?: number[]): Promise<number> => {
-     *   return [ element * 2, element * 3 ];
-     * });
-     * console.log(result); // [ [ 2, 3 ], [ 4, 6 ], [ 6, 9 ] ]
-     * ```
-     */
-    static asyncForEachAllAtOnce<T, R>(list: T[], func: (element: T, index?: number, array?: T[]) => Promise<R>): Promise<R[]>;
-    /**
-     * Asynchronously filters an array based on a function.
-     * @param list - The array to filter.
-     * @param filterFunc - The function to apply to each element.
-     * @returns A promise that resolves to an array of results.
-     *
-     * @example
-     * ```ts
-     * const list: number[] = [ 1, 2, 3 ];
-     * const result = await DyFM_Array.asyncFilter(list, async (element: number, index?: number, array?: number[]): Promise<boolean> => {
-     *   return element % 2 === 0;
-     * });
-     * console.log(result); // [ 2 ]
-     * ```
-     */
-    static asyncFilter<T>(list: T[], filterFunc: (element: T, index?: number, array?: T[]) => Promise<boolean>): Promise<T[]>;
-    /**
-     * Asynchronously maps an array based on a function.
-     * @param list - The array to map.
-     * @param mapFunc - The function to apply to each element.
-     * @returns A promise that resolves to an array of results.
-     *
-     * @example
-     * ```ts
-     * const list: number[] = [ 1, 2, 3 ];
-     * const result = await DyFM_Array.asyncMap(list, async (element: number, index?: number, array?: number[]): Promise<number> => {
-     *   return element * 2;
-     * });
-     * console.log(result); // [ 2, 4, 6 ]
-     * ```
-     */
-    static asyncMap<T, R>(list: T[], mapFunc: (element: T, index?: number, array?: T[]) => Promise<R>): Promise<R[]>;
-    /**
-     * Returns the last element of an array.
-     * @param array - The array to get the last element from.
-     * @returns The last element of the array, or null if the array is empty.
-     *
-     * @example
-     * ```ts
-     * const list: number[] = [ 1, 2, 3 ];
-     * const result = DyFM_Array.last(list);
-     * console.log(result); // 3
-     * ```
-     */
-    static last<T>(array: T[]): T | null;
-    /**
-     * Returns true if the string is the last element of the array.
-     * @param string - The string to check.
-     * @param array - The array to check.
-     * @returns True if the string is the last element of the array, false otherwise.
-     *
-     * @example
-     * ```ts
-     * const list: number[] = [ 1, 2, 3 ];
-     * const result = DyFM_Array.isLast(3, list);
-     * console.log(result); // true
-     * ```
-     */
-    static isLast<T>(element: T, array: T[]): boolean;
-    /**
-     * Returns true if the string is the last element of the array.
-     * @param string - The string to check.
-     * @param array - The array to check.
-     * @returns True if the string is the last element of the array, false otherwise.
-     *
-     * @example
-     * ```ts
-     * const list: number[] = [ 1, 2, 3 ];
-     * const result = DyFM_Array.isLastIndex(2, list);
-     * console.log(result); // true
-     * ```
-     */
-    static isLastIndex<T>(index: number, array: T[]): boolean;
-    /**
-     * Returns true if the string is the first element of the array.
-     * @param string - The string to check.
-     * @param array - The array to check.
-     * @returns True if the string is the first element of the array, false otherwise.
-     *
-     * @example
-     * ```ts
-     * const list: number[] = [ 1, 2, 3 ];
-     * const result = DyFM_Array.isFirst(1, list);
-     * console.log(result); // true
-     * ```
-     */
-    static isFirst<T>(element: T, array: T[]): boolean;
-    /**
-     * Returns the last character of a string.
-     * @param string - The string to get the last character from.
-     * @returns The last character of the string, or null if the string is empty.
-     *
-     * @example
-     * ```ts
-     * const string = 'hello';
-     * const result = DyFM_Array.lastCharacter(string);
-     * console.log(result); // 'o'
-     * ```
-     */
-    static lastCharacter(string: string): string | null;
-    /**
-     * Returns the first element of an array.
-     * @param array - The array to get the first element from.
-     * @returns The first element of the array, or null if the array is empty.
-     *
-     * @example
-     * ```ts
-     * const list: number[] = [ 1, 2, 3 ];
-     * const result = DyFM_Array.first(list);
-     * console.log(result); // 1
-     * ```
-     */
-    static first<T>(array: T[]): T | null;
-    /**
-     * Removes an element from an array.
-     * @param array - The array to remove the element from.
-     * @param element - The element to remove from the array.
-     * @returns The array with the element removed.
-     *
-     * @example
-     * ```ts
-     * const list: number[] = [ 1, 2, 3 ];
-     * const result = DyFM_Array.remove(list, 2);
-     * console.log(result); // [ 1, 3 ]
-     * ```
-     */
-    static remove<T>(array: T[], element: T): T[];
-    /**
-     * Finds an element in an array and removes it.
-     * @param array - The array to find and remove the element from.
-     * @param func - The function to apply to each element.
-     * @returns The array with the element removed.
-     *
-     * @example
-     * ```ts
-     * const list: number[] = [ 1, 2, 3 ];
-     * const result = DyFM_Array.findNRemove(list, (element: number, index?: number, array?: number[]): boolean => {
-     *   return element === 2;
-     * });
-     * console.log(result); // [ 1, 3 ]
-     * ```
-     */
-    static findNRemove<T>(array: T[], func: (element: T, index?: number, array?: T[]) => boolean): T[];
-    /**
-     * Shuffles an array.
-     * @param array - The array to shuffle.
-     * @returns The shuffled array.
-     *
-     * @example
-     * ```ts
-     * const list: number[] = [ 1, 2, 3 ];
-     * const result = DyFM_Array.shuffle(list);
-     * console.log(result); // [ 3, 1, 2 ]
-     * ```
-     */
-    static shuffle<T>(array: T[]): T[];
-    /**
-     * Pages an array.
-     * @param array - The array to page.
-     * @param pageIndex - The index of the page to return.
-     * @param pageSize - The size of the page.
-     * @returns The page of the array.
-     *
-     * @example
-     * ```ts
-     * const list: number[] = [ 1, 2, 3, 4, 5, 6, 7, 8 ];
-     * const result = DyFM_Array.page(list, 0, 2);
-     * console.log(result); // [ 1, 2 ]
-     * ```
-     */
-    static page<T>(array: T[], pageIndex: number, pageSize: number): T[];
-    /**
-     * Pages an array.
-     * @param array - The array to page.
-     * @param pageIndex - The index of the page to return.
-     * @param pageSize - The size of the page.
-     * @returns The page of the array.
-     *
-     * @example
-     * ```ts
-     * const list: number[] = [ 1, 2, 3, 4, 5, 6, 7, 8 ];
-     * const result = DyFM_Array.paged(list, 0, 2);
-     * console.log(result); // { pageIndex: 0, pageSize: 2, total: 8, totalPageCount: 4, items: [ 1, 2 ] }
-     * ```
-     */
-    static paged<T>(array: T[], pageIndex: number, pageSize: number): DyFM_Paged<T>;
-    /**
-     * Swaps two elements in an array.
-     * @param array - The array to swap the elements in.
-     * @param indexA - The index of the first element to swap.
-     * @param indexB - The index of the second element to swap.
-     * @returns The array with the elements swapped.
-     *
-     * @example
-     * ```ts
-     * const list: number[] = [ 1, 2, 3 ];
-     * const result = DyFM_Array.swap(list, 0, 2);
-     * console.log(result); // [ 3, 2, 1 ]
-     * ```
-     */
-    static swap<T>(array: T[], indexA: number, indexB: number): T[];
-    /**
-     * Checks if a string list has multiplications.
-     * @param stringList - The string list to check.
-     * @returns True if the string list has multiplications, false otherwise.
-     *
-     * @example
-     * ```ts
-     * const list: string[] = [ 'a', 'b', 'c', 'a' ];
-     * const result = DyFM_Array.stringListHasMultiplications(list);
-     * console.log(result); // true
-     * ```
-     */
-    static stringListHasMultiplications(stringList: string[]): boolean;
-    /**
-     * Filters a string list to remove multiplications.
-     * @param stringList - The string list to filter.
-     * @returns The filtered string list.
-     *
-     * @example
-     * ```ts
-     * const list: string[] = [ 'a', 'b', 'c', 'a' ];
-     * const result = DyFM_Array.filterStringMultiplications(list);
-     * console.log(result); // [ 'a', 'b', 'c' ]
-     * ```
-     */
-    static filterStringMultiplications(stringList: string[]): string[];
-    /**
-     * Gathers multiplications from a string list.
-     * @param stringList - The string list to gather multiplications from.
-     * @returns The gathered multiplications.
-     *
-     * @example
-     * ```ts
-     * const list: string[] = [ 'a', 'b', 'c', 'a' ];
-     * const result = DyFM_Array.gatherStringMultiplications(list);
-     * console.log(result); // [ [ 'a', 'a' ] ]
-     * ```
-     */
-    static gatherStringMultiplications(stringList: string[]): string[][];
-    /**
-     * Checks if a data list has multiplications.
-     * @param dataList - The data list to check.
-     * @param byKey - The key to check for multiplications.
-     * @returns True if the data list has multiplications, false otherwise.
-     *
-     * @example
-     * ```ts
-     * const list: { _id: number, name: string }[] = [ { _id: 1, name: 'John' }, { _id: 2, name: 'Jane' }, { _id: 1, name: 'Bob' } ];
-     * const result = DyFM_Array.haveMultiplications(list, '_id');
-     * console.log(result); // true
-     * ```
-     */
-    static haveMultiplications<T extends object>(dataList: T[], byKey?: keyof T): boolean;
-    /**
-     * Filters a data list to remove multiplications.
-     * @param dataList - The data list to filter.
-     * @param byKey - The key to filter for multiplications.
-     * @returns The filtered data list.
-     *
-     * @example
-     * ```ts
-     * const list: { _id: number, name: string }[] = [ { _id: 1, name: 'John' }, { _id: 2, name: 'Jane' }, { _id: 1, name: 'Bob' } ];
-     * const result = DyFM_Array.filterMultiplications(list, '_id');
-     * console.log(result); // [ { _id: 1, name: 'John' } , { _id: 2, name: 'Jane' } ]
-     * ```
-     */
-    static filterMultiplications<T extends object>(dataList: T[], byKey?: keyof T): T[];
-    /**
-     * Gathers multiplications from a data list.
-     * @param dataList - The data list to gather multiplications from.
-     * @param byKey - The key to gather multiplications from.
-     * @returns The gathered multiplications.
-     *
-     * @example
-     * ```ts
-     * const list: { _id: number, name: string }[] = [ { _id: 1, name: 'John' }, { _id: 2, name: 'Jane' }, { _id: 1, name: 'Bob' } ];
-     * const result = DyFM_Array.gatherMultiplications(list, '_id');
-     * console.log(result); // [ [ { _id: 1, name: 'John' }, { _id: 1, name: 'Bob' } ] ]
-     * ```
-     */
-    static gatherMultiplications<T extends object>(dataList: T[], byKey?: keyof T): T[][];
-    /**
-     * Finds an element in an array from the end.
-     * @param array - The array to find the element in.
-     * @param func - The function to apply to each element.
-     * @returns The element found, or null if no element is found.
-     *
-     * @example
-     * ```ts
-     * const list: number[] = [ 1, 2, 3 ];
-     * const result = DyFM_Array.findFromEnd(list, (element: number, index?: number, array?: number[]): boolean => {
-     *   return element === 2;
-     * });
-     * console.log(result); // 2
-     * ```
-     */
-    static findFromEnd<T>(array: T[], func: (element: T, index?: number, array?: T[]) => boolean): T | null;
-    /**
-     * returns a function that can be used to sort an array of objects
-     * sorts so that the objects that have the value true for the checkFor function are at the beginning of the array
-     * @param checkFor
-     * @returns
-     *
-     */
-    static getSortForTrueFn<T>(checkFor: (a: T) => boolean): (a: T, b: T) => DyFM_SortDirection;
-    /**
-     * You might be use getSortForTrueFn instead for a shorter expression
-     *
-     * @param a
-     * @param b
-     * @param check
-     * @returns
-     *
-     * @example
-     * codes.sort((a,b) => sortForTrue(a,b,(c: Code) => c.haveImg));
-     */
-    static sortForTrue<T>(a: T, b: T, check: (a: T) => boolean): DyFM_SortDirection;
-}
+import { DyFM_Paged } from '../../_models/interfaces/paged.interface';
+/**
+ * the return type of the sortForTrue function
+ */
+export type DyFM_SortDirection = 0 | 1 | -1;
+export type DyFM_List = DyFM_Array;
+export declare class DyFM_Array {
+    /**
+     * Asynchronously iterates over an array and applies a function to each element.
+     * @param list - The array to iterate over.
+     * @param func - The function to apply to each element.
+     * @returns A promise that resolves when all elements have been processed.
+     *
+     * @example
+     * ```ts
+     * const list: number[] = [ 1, 2, 3 ];
+     * await DyFM_Array.asyncForEach(list, async (element: number, index?: number, array?: number[]): Promise<void> => {
+     *   console.log(element, index, array);
+     * });
+     * ```
+     */
+    static asyncForEach<T>(list: T[], func: (element: T, index?: number, array?: T[]) => Promise<void>): Promise<void>;
+    /**
+     * Asynchronously iterates over an array and applies a function to each element, returning a single result.
+     * @param startData - The initial data to pass to the function.
+     * @param list - The array to iterate over.
+     * @param func - The function to apply to each element.
+     * @returns A promise that resolves to the final result.
+     *
+     * @example
+     * ```ts
+     * const list: number[] = [ 1, 2, 3 ];
+     * const result = await DyFM_Array.asyncForEachReturnToOne(0, list, async (element: number, dataCurrent: number, index?: number, array?: number[]): Promise<number> => {
+     *   return dataCurrent + element;
+     * });
+     * ```
+     */
+    static asyncForEachReturnToOne<T, K>(startData: K, list: T[], func: (element: T, dataCurrent: K, index?: number, array?: T[]) => Promise<K>): Promise<K>;
+    /**
+     * Asynchronously iterates over an array and applies a function to each element, returning an array of results.
+     * @param list - The array to iterate over.
+     * @param func - The function to apply to each element.
+     * @returns A promise that resolves to an array of results.
+     *
+     * @example
+     * ```ts
+     * const list: number[] = [ 1, 2, 3 ];
+     * const result = await DyFM_Array.asyncForEachReturnToAll(list, async (element: number, index?: number, array?: number[]): Promise<number> => {
+     *   return element * 2;
+     * });
+     * ```
+     */
+    static asyncForEachReturnToAll<T, K>(list: T[], func: (element: T, index?: number, array?: T[]) => Promise<K>): Promise<K[]>;
+    /**
+     * Asynchronously iterates over an array and applies a function to each element, returning an array of results.
+     * @param list - The array to iterate over.
+     * @param func - The function to apply to each element.
+     * @returns A promise that resolves to an array of results.
+     *
+     * @example
+     * ```ts
+     * const list: number[] = [ 1, 2, 3 ];
+     * const result = await DyFM_Array.asyncForEachAllAtOnce(list, async (element: number, index?: number, array?: number[]): Promise<number> => {
+     *   return [ element * 2, element * 3 ];
+     * });
+     * console.log(result); // [ [ 2, 3 ], [ 4, 6 ], [ 6, 9 ] ]
+     * ```
+     */
+    static asyncForEachAllAtOnce<T, R>(list: T[], func: (element: T, index?: number, array?: T[]) => Promise<R>): Promise<R[]>;
+    /**
+     * Asynchronously filters an array based on a function.
+     * @param list - The array to filter.
+     * @param filterFunc - The function to apply to each element.
+     * @returns A promise that resolves to an array of results.
+     *
+     * @example
+     * ```ts
+     * const list: number[] = [ 1, 2, 3 ];
+     * const result = await DyFM_Array.asyncFilter(list, async (element: number, index?: number, array?: number[]): Promise<boolean> => {
+     *   return element % 2 === 0;
+     * });
+     * console.log(result); // [ 2 ]
+     * ```
+     */
+    static asyncFilter<T>(list: T[], filterFunc: (element: T, index?: number, array?: T[]) => Promise<boolean>): Promise<T[]>;
+    /**
+     * Asynchronously maps an array based on a function.
+     * @param list - The array to map.
+     * @param mapFunc - The function to apply to each element.
+     * @returns A promise that resolves to an array of results.
+     *
+     * @example
+     * ```ts
+     * const list: number[] = [ 1, 2, 3 ];
+     * const result = await DyFM_Array.asyncMap(list, async (element: number, index?: number, array?: number[]): Promise<number> => {
+     *   return element * 2;
+     * });
+     * console.log(result); // [ 2, 4, 6 ]
+     * ```
+     */
+    static asyncMap<T, R>(list: T[], mapFunc: (element: T, index?: number, array?: T[]) => Promise<R>): Promise<R[]>;
+    /**
+     * Returns the last element of an array.
+     * @param array - The array to get the last element from.
+     * @returns The last element of the array, or null if the array is empty.
+     *
+     * @example
+     * ```ts
+     * const list: number[] = [ 1, 2, 3 ];
+     * const result = DyFM_Array.last(list);
+     * console.log(result); // 3
+     * ```
+     */
+    static last<T>(array: T[]): T | null;
+    /**
+     * Returns true if the string is the last element of the array.
+     * @param string - The string to check.
+     * @param array - The array to check.
+     * @returns True if the string is the last element of the array, false otherwise.
+     *
+     * @example
+     * ```ts
+     * const list: number[] = [ 1, 2, 3 ];
+     * const result = DyFM_Array.isLast(3, list);
+     * console.log(result); // true
+     * ```
+     */
+    static isLast<T>(element: T, array: T[]): boolean;
+    /**
+     * Returns true if the string is the last element of the array.
+     * @param string - The string to check.
+     * @param array - The array to check.
+     * @returns True if the string is the last element of the array, false otherwise.
+     *
+     * @example
+     * ```ts
+     * const list: number[] = [ 1, 2, 3 ];
+     * const result = DyFM_Array.isLastIndex(2, list);
+     * console.log(result); // true
+     * ```
+     */
+    static isLastIndex<T>(index: number, array: T[]): boolean;
+    /**
+     * Returns true if the string is the first element of the array.
+     * @param string - The string to check.
+     * @param array - The array to check.
+     * @returns True if the string is the first element of the array, false otherwise.
+     *
+     * @example
+     * ```ts
+     * const list: number[] = [ 1, 2, 3 ];
+     * const result = DyFM_Array.isFirst(1, list);
+     * console.log(result); // true
+     * ```
+     */
+    static isFirst<T>(element: T, array: T[]): boolean;
+    /**
+     * Returns the last character of a string.
+     * @param string - The string to get the last character from.
+     * @returns The last character of the string, or null if the string is empty.
+     *
+     * @example
+     * ```ts
+     * const string = 'hello';
+     * const result = DyFM_Array.lastCharacter(string);
+     * console.log(result); // 'o'
+     * ```
+     */
+    static lastCharacter(string: string): string | null;
+    /**
+     * Returns the first element of an array.
+     * @param array - The array to get the first element from.
+     * @returns The first element of the array, or null if the array is empty.
+     *
+     * @example
+     * ```ts
+     * const list: number[] = [ 1, 2, 3 ];
+     * const result = DyFM_Array.first(list);
+     * console.log(result); // 1
+     * ```
+     */
+    static first<T>(array: T[]): T | null;
+    /**
+     * Removes an element from an array.
+     * @param array - The array to remove the element from.
+     * @param element - The element to remove from the array.
+     * @returns The array with the element removed.
+     *
+     * @example
+     * ```ts
+     * const list: number[] = [ 1, 2, 3 ];
+     * const result = DyFM_Array.remove(list, 2);
+     * console.log(result); // [ 1, 3 ]
+     * ```
+     */
+    static remove<T>(array: T[], element: T): T[];
+    /**
+     * Finds an element in an array and removes it.
+     * @param array - The array to find and remove the element from.
+     * @param func - The function to apply to each element.
+     * @returns The array with the element removed.
+     *
+     * @example
+     * ```ts
+     * const list: number[] = [ 1, 2, 3 ];
+     * const result = DyFM_Array.findNRemove(list, (element: number, index?: number, array?: number[]): boolean => {
+     *   return element === 2;
+     * });
+     * console.log(result); // [ 1, 3 ]
+     * ```
+     */
+    static findNRemove<T>(array: T[], func: (element: T, index?: number, array?: T[]) => boolean): T[];
+    /**
+     * Shuffles an array.
+     * @param array - The array to shuffle.
+     * @returns The shuffled array.
+     *
+     * @example
+     * ```ts
+     * const list: number[] = [ 1, 2, 3 ];
+     * const result = DyFM_Array.shuffle(list);
+     * console.log(result); // [ 3, 1, 2 ]
+     * ```
+     */
+    static shuffle<T>(array: T[]): T[];
+    /**
+     * Pages an array.
+     * @param array - The array to page.
+     * @param pageIndex - The index of the page to return.
+     * @param pageSize - The size of the page.
+     * @returns The page of the array.
+     *
+     * @example
+     * ```ts
+     * const list: number[] = [ 1, 2, 3, 4, 5, 6, 7, 8 ];
+     * const result = DyFM_Array.page(list, 0, 2);
+     * console.log(result); // [ 1, 2 ]
+     * ```
+     */
+    static page<T>(array: T[], pageIndex: number, pageSize: number): T[];
+    /**
+     * Pages an array.
+     * @param array - The array to page.
+     * @param pageIndex - The index of the page to return.
+     * @param pageSize - The size of the page.
+     * @returns The page of the array.
+     *
+     * @example
+     * ```ts
+     * const list: number[] = [ 1, 2, 3, 4, 5, 6, 7, 8 ];
+     * const result = DyFM_Array.paged(list, 0, 2);
+     * console.log(result); // { pageIndex: 0, pageSize: 2, total: 8, totalPageCount: 4, items: [ 1, 2 ] }
+     * ```
+     */
+    static paged<T>(array: T[], pageIndex: number, pageSize: number): DyFM_Paged<T>;
+    /**
+     * Swaps two elements in an array.
+     * @param array - The array to swap the elements in.
+     * @param indexA - The index of the first element to swap.
+     * @param indexB - The index of the second element to swap.
+     * @returns The array with the elements swapped.
+     *
+     * @example
+     * ```ts
+     * const list: number[] = [ 1, 2, 3 ];
+     * const result = DyFM_Array.swap(list, 0, 2);
+     * console.log(result); // [ 3, 2, 1 ]
+     * ```
+     */
+    static swap<T>(array: T[], indexA: number, indexB: number): T[];
+    /**
+     * Checks if a string list has multiplications.
+     * @param stringList - The string list to check.
+     * @returns True if the string list has multiplications, false otherwise.
+     *
+     * @example
+     * ```ts
+     * const list: string[] = [ 'a', 'b', 'c', 'a' ];
+     * const result = DyFM_Array.stringListHasMultiplications(list);
+     * console.log(result); // true
+     * ```
+     */
+    static stringListHasMultiplications(stringList: string[]): boolean;
+    /**
+     * Filters a string list to remove multiplications.
+     * @param stringList - The string list to filter.
+     * @returns The filtered string list.
+     *
+     * @example
+     * ```ts
+     * const list: string[] = [ 'a', 'b', 'c', 'a' ];
+     * const result = DyFM_Array.filterStringMultiplications(list);
+     * console.log(result); // [ 'a', 'b', 'c' ]
+     * ```
+     */
+    static filterStringMultiplications(stringList: string[]): string[];
+    /**
+     * Gathers multiplications from a string list.
+     * @param stringList - The string list to gather multiplications from.
+     * @returns The gathered multiplications.
+     *
+     * @example
+     * ```ts
+     * const list: string[] = [ 'a', 'b', 'c', 'a' ];
+     * const result = DyFM_Array.gatherStringMultiplications(list);
+     * console.log(result); // [ [ 'a', 'a' ] ]
+     * ```
+     */
+    static gatherStringMultiplications(stringList: string[]): string[][];
+    /**
+     * Checks if a data list has multiplications.
+     * @param dataList - The data list to check.
+     * @param byKey - The key to check for multiplications.
+     * @returns True if the data list has multiplications, false otherwise.
+     *
+     * @example
+     * ```ts
+     * const list: { _id: number, name: string }[] = [ { _id: 1, name: 'John' }, { _id: 2, name: 'Jane' }, { _id: 1, name: 'Bob' } ];
+     * const result = DyFM_Array.haveMultiplications(list, '_id');
+     * console.log(result); // true
+     * ```
+     */
+    static haveMultiplications<T extends object>(dataList: T[], byKey?: keyof T): boolean;
+    /**
+     * Filters a data list to remove multiplications.
+     * @param dataList - The data list to filter.
+     * @param byKey - The key to filter for multiplications.
+     * @returns The filtered data list.
+     *
+     * @example
+     * ```ts
+     * const list: { _id: number, name: string }[] = [ { _id: 1, name: 'John' }, { _id: 2, name: 'Jane' }, { _id: 1, name: 'Bob' } ];
+     * const result = DyFM_Array.filterMultiplications(list, '_id');
+     * console.log(result); // [ { _id: 1, name: 'John' } , { _id: 2, name: 'Jane' } ]
+     * ```
+     */
+    static filterMultiplications<T extends object>(dataList: T[], byKey?: keyof T): T[];
+    /**
+     * Gathers multiplications from a data list.
+     * @param dataList - The data list to gather multiplications from.
+     * @param byKey - The key to gather multiplications from.
+     * @returns The gathered multiplications.
+     *
+     * @example
+     * ```ts
+     * const list: { _id: number, name: string }[] = [ { _id: 1, name: 'John' }, { _id: 2, name: 'Jane' }, { _id: 1, name: 'Bob' } ];
+     * const result = DyFM_Array.gatherMultiplications(list, '_id');
+     * console.log(result); // [ [ { _id: 1, name: 'John' }, { _id: 1, name: 'Bob' } ] ]
+     * ```
+     */
+    static gatherMultiplications<T extends object>(dataList: T[], byKey?: keyof T): T[][];
+    /**
+     * Finds an element in an array from the end.
+     * @param array - The array to find the element in.
+     * @param func - The function to apply to each element.
+     * @returns The element found, or null if no element is found.
+     *
+     * @example
+     * ```ts
+     * const list: number[] = [ 1, 2, 3 ];
+     * const result = DyFM_Array.findFromEnd(list, (element: number, index?: number, array?: number[]): boolean => {
+     *   return element === 2;
+     * });
+     * console.log(result); // 2
+     * ```
+     */
+    static findFromEnd<T>(array: T[], func: (element: T, index?: number, array?: T[]) => boolean): T | null;
+    /**
+     * returns a function that can be used to sort an array of objects
+     * sorts so that the objects that have the value true for the checkFor function are at the beginning of the array
+     * @param checkFor
+     * @returns
+     *
+     */
+    static getSortForTrueFn<T>(checkFor: (a: T) => boolean): (a: T, b: T) => DyFM_SortDirection;
+    /**
+     * You might be use getSortForTrueFn instead for a shorter expression
+     *
+     * @param a
+     * @param b
+     * @param check
+     * @returns
+     *
+     * @example
+     * codes.sort((a,b) => sortForTrue(a,b,(c: Code) => c.haveImg));
+     */
+    static sortForTrue<T>(a: T, b: T, check: (a: T) => boolean): DyFM_SortDirection;
+}
 //# sourceMappingURL=array.util.d.ts.map