si-funciona 2.0.0 → 2.0.1

package/dist/helpers/functions/relevancyFilter.d.ts

@@ -0,0 +1,36 @@
+import 'core-js/stable';
+/**
+ * An object having an integer valued property named 'relevance'.
+ * @typedef {Object} relevanceObject
+ * @memberOf module:functionHelpers
+ * @property {Array|Object} source
+ * @property {Array|Object} object
+ * @property {number} relevance
+ */
+export type relevanceObject = {
+    source: Array<any> | Object;
+    object: Array<any> | Object;
+    relevance: number;
+};
+/**
+ * A map of relevanceObjects which can be manipulated to filter results.
+ * @typedef {Array.<relevanceObject>} relevanceMap
+ * @memberOf module:functionHelpers
+ */
+export type relevanceMap = Array<relevanceObject>;
+type relevancyFilterOptions = {
+    mapLimit?: number;
+    relevancyRange?: number;
+};
+/**
+ * Remove elements out of relevance range and update the max relevance.
+ * @function
+ * @memberOf module:functionHelpers
+ * @param {relevanceMap} map
+ * @param {Object} [options={}]
+ * @param {int} [options.mapLimit=1000]
+ * @param {int} [options.relevancyRange=100]
+ * @returns {relevanceMap}
+ */
+declare const relevancyFilter: (map: relevanceMap, { mapLimit, relevancyRange }?: relevancyFilterOptions) => relevanceMap;
+export default relevancyFilter;

package/dist/helpers/functions/trace.d.ts

@@ -0,0 +1,13 @@
+import 'core-js/stable';
+import 'regenerator-runtime/runtime';
+type outputAndReturn = (value: any) => any;
+/**
+ * Output the value with label to the console and return the value to not interrupt the code.
+ * @function
+ * @memberOf module:functionHelpers
+ * @param {string} label - Pass an identifying label of the value being output.
+ * @param useClone - Determines if the logged data should be a clone of the original to preserve state.
+ * @returns {function(*=)}
+ */
+declare const trace: (label: string, useClone?: boolean) => outputAndReturn;
+export default trace;

package/dist/helpers/functions.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Manage how functions are called with these utilities.
+ * @file
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ * @module functionHelpers
+ * @memberOf module:siFunciona
+ */
+import 'core-js/stable';
+declare const _default: {
+    callWithParams: (fn: Function, params?: any[], minimum?: number) => any;
+    curry: (fn: Function) => any;
+    delay: (time?: number) => {
+        resolver: Promise<any>;
+        cancel: () => void;
+    };
+    onBodyLoad: (callback: Function, reset?: boolean) => Function[];
+    pipe: (...fns: Function[]) => any;
+    preloadParams: (fn: Function, params?: any[], unassignedParam?: number) => (missing: any) => any;
+    queueManager: (queue?: import("./functions/queueManager").queuedItem[]) => import("./functions/queueManager").queueManagerHandle;
+    queueTimeout: (queueManagerHandle?: import("./functions/queueManager").queueManagerHandle) => (fn: Function, time: number, ...args: any) => Promise<any>;
+    relevancyFilter: (map: import("./functions/relevancyFilter").relevanceMap, { mapLimit, relevancyRange }?: {
+        mapLimit?: number;
+        relevancyRange?: number;
+    }) => import("./functions/relevancyFilter").relevanceMap;
+    trace: (label: string, useClone?: boolean) => (value: any) => any;
+};
+export default _default;

package/dist/helpers/numbers/absoluteMax.d.ts

@@ -0,0 +1,11 @@
+import 'core-js/stable';
+/**
+ * Helper for returning the absolute max value
+ * @function
+ * @memberOf module:numberHelpers
+ * @param {number} num1 - A number to compare
+ * @param {number} num2 - Another number to be compared against
+ * @returns {number}
+ */
+declare const absoluteMax: (num1: number, num2: number) => number;
+export default absoluteMax;

package/dist/helpers/numbers/absoluteMin.d.ts

@@ -0,0 +1,11 @@
+import 'core-js/stable';
+/**
+ * Helper for returning the absolute min value
+ * @function
+ * @memberOf module:numberHelpers
+ * @param {number} num1 - A number to compare
+ * @param {number} num2 - Another number to be compared against
+ * @returns {number}
+ */
+declare const absoluteMin: (num1: number, num2: number) => number;
+export default absoluteMin;

package/dist/helpers/numbers/compare.d.ts

@@ -0,0 +1,14 @@
+import 'core-js/stable';
+/**
+ * Compare two numbers and return:
+ * -1 to indicate val1 is less than val2
+ * 0 to indicate both values are the equal
+ * 1 to indicate val1 is greater than val2
+ * @function
+ * @memberOf module:numberHelpers
+ * @param {number} val1 - The first number to compare
+ * @param {number} val2 - The second number to compare
+ * @returns {number}
+ */
+declare const compare: (val1: number, val2: number) => number;
+export default compare;

package/dist/helpers/numbers/randomInteger.d.ts

@@ -0,0 +1,14 @@
+import 'core-js/stable';
+/**
+ * Create a single random integer within provide range. And with optional offset,
+ * The distance between the result numbers can be adjusted with interval.
+ * @function
+ * @memberOf module:numberHelpers
+ * @param {number} range - Choose the breadth of the random number (0-100 would be 100 for range)
+ * @param {number} [offset=0] - Choose the starting number (1-10 would be 1 for offset, 9 for range)
+ * @param {number} [interval=1] - Choose the distance between numbers (5, 10, 15 would be 5 for interval, 1 for
+ * offset, 2 for range)
+ * @returns {number}
+ */
+declare const randomInteger: (range: number, offset?: number, interval?: number) => number;
+export default randomInteger;

package/dist/helpers/numbers/randomNumber.d.ts

@@ -0,0 +1,14 @@
+import 'core-js/stable';
+/**
+ * Create a single random number within provided range. And with optional offset,
+ * The distance between the result numbers can be adjusted with interval.
+ * @function
+ * @memberOf module:numberHelpers
+ * @param {number} range - Choose the breadth of the random number (0-100 would be 100 for range)
+ * @param {number} [offset=0] - Choose the starting number (1-10 would be 1 for offset, 9 for range)
+ * @param {number} [interval=1] - Choose the distance between numbers (~5, ~10, ~15 would be 5 for interval, 1 for
+ * offset, 2 for range)
+ * @returns {number}
+ */
+declare const randomNumber: (range: number, offset?: number, interval?: number) => number;
+export default randomNumber;

package/dist/helpers/numbers.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Some number comparators and random number generators.
+ * @file
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ * @module numberHelpers
+ * @memberOf module:siFunciona
+ */
+import 'core-js/stable';
+declare const _default: {
+    absoluteMax: (num1: number, num2: number) => number;
+    absoluteMin: (num1: number, num2: number) => number;
+    compare: (val1: number, val2: number) => number;
+    randomInteger: (range: number, offset?: number, interval?: number) => number;
+    randomNumber: (range: number, offset?: number, interval?: number) => number;
+};
+export default _default;

package/dist/helpers/objects/cloneObject.d.ts

@@ -0,0 +1,21 @@
+import 'core-js/stable';
+type cloneObjectOptions = {
+    mapLimit?: number;
+    depthLimit?: number;
+    relevancyRange?: number;
+};
+/**
+ * Clone objects for manipulation without data corruption, returns a copy of the provided object.
+ * NOTE: Use the mapLimit and relevancyRange to resolve "too much recursion" when the object is large and is known to
+ * have circular references. A high mapLimit may lead to heavy memory usage and slow performance.
+ * @function
+ * @memberOf module:objectHelpers
+ * @param {Object} object - The original object that is being cloned
+ * @param {Object} [options={}]
+ * @param {number} [options.mapLimit=100] - Size of temporary reference array used in memory before assessing relevancy.
+ * @param {number} [options.depthLimit=-1] - Control how many nested levels deep will be used, -1 = no limit, >-1 = nth level limited.
+ * @param {number} [options.relevancyRange=1000] - Total reference map length subtract this range, any relevancy less than that amount at time of evaluation will be removed.
+ * @returns {Object}
+ */
+declare const cloneObject: (object: object, { mapLimit, depthLimit, relevancyRange }?: cloneObjectOptions) => object;
+export default cloneObject;

package/dist/helpers/objects/dotGet.d.ts

@@ -0,0 +1,13 @@
+import 'core-js/stable';
+import { dotNotateableItem, dotNotationString } from './dotNotate';
+/**
+ * Get a nested property value from an object.
+ * @function
+ * @memberOf module:objectHelpers
+ * @param {Object} arrayObject - The array or object to get the property from
+ * @param {string} dotNotation - The path to the property
+ * @param {string|null} [defaultValue=null] - The default value to return if the property is not found
+ * @returns {*} The value of the property
+ */
+declare const dotGet: (arrayObject: dotNotateableItem, dotNotation: dotNotationString, defaultValue?: string | null) => any;
+export default dotGet;

package/dist/helpers/objects/dotNotate.d.ts

@@ -0,0 +1,29 @@
+import 'core-js/stable';
+export type dotNotateableItem = Array<any> | {
+    [k: string]: any;
+};
+/**
+ * A string representing the full-path to a property in an object. Each depth of the path is separated by a period.
+ * @example 'a.b.c'
+ * @typedef {string} DotNotationString
+ * @memberOf module:objectHelpers
+ */
+export type dotNotationString = string;
+/**
+ * An array or object where all properties have been flatted and keyed by a dot-notated string.
+ * @typedef {Object.<DotNotationString, *>} DotNotatedObject
+ * @memberOf module:objectHelpers
+ */
+type dotNotatedObject = {
+    [k: dotNotationString]: any;
+};
+/**
+ * Convert an array or object to a single dimensional associative array with dot notation.
+ * @function
+ * @memberOf module:objectHelpers
+ * @param {Object} arrayObject - The array or object to dot-notate
+ * @param {Array.<DotNotationString>} [retainObjects=[]] - An array of keys to retain as objects
+ * @returns {DotNotatedObject} The dot-notated object
+ */
+declare const dotNotate: (arrayObject: object, retainObjects?: Array<dotNotationString>) => dotNotatedObject;
+export default dotNotate;

package/dist/helpers/objects/dotSet.d.ts

@@ -0,0 +1,13 @@
+import 'core-js/stable';
+import { dotNotateableItem, dotNotationString } from './dotNotate';
+/**
+ * Set a nested property value an object.
+ * @function
+ * @memberOf module:objectHelpers
+ * @param {Object} arrayObject - The array or object to set the property on
+ * @param {string} dotNotation - The path for the property
+ * @param {*} value - The default value to return if the property is not found
+ * @returns {Object} The modified object
+ */
+declare const dotSet: (arrayObject: dotNotateableItem, dotNotation: dotNotationString, value?: any) => dotNotateableItem;
+export default dotSet;

package/dist/helpers/objects/dotUnset.d.ts

@@ -0,0 +1,12 @@
+import 'core-js/stable';
+import { dotNotateableItem, dotNotationString } from './dotNotate';
+/**
+ * Unset a nested property value an object.
+ * @function
+ * @memberOf module:objectHelpers
+ * @param {Object} arrayObject - The array or object to set the property on
+ * @param {string} dotNotation - The path for the property
+ * @returns {Object} The modified object
+ */
+declare const dotUnset: (arrayObject: dotNotateableItem, dotNotation: dotNotationString) => dotNotateableItem;
+export default dotUnset;

package/dist/helpers/objects/emptyObject.d.ts

@@ -0,0 +1,10 @@
+import 'core-js/stable';
+/**
+ * Helper function for testing if the item is an Object or Array that does not have any properties
+ * @function
+ * @memberOf module:objectHelpers
+ * @param {Object|Array} item - Object or Array to test
+ * @returns {boolean}
+ */
+declare const emptyObject: (item: Array<any> | Object) => boolean;
+export default emptyObject;

package/dist/helpers/objects/filterObject.d.ts

@@ -0,0 +1,28 @@
+import 'core-js/stable';
+type filterableItem = Array<any> | {
+    [k: number | string]: any;
+};
+/**
+ * Function is a predicate, to test each property value of the object. Return true to keep the element, false
+ * otherwise, taking three arguments
+ * @callback module:objectHelpers~filterCallback
+ * @memberOf module:objectHelpers
+ * @param {*} currentProperty - The current property being processed in the object.
+ * @param {string} [currentIndex] - The property name of the current property being processed in the object.
+ * @param {Object|Array} [object] - The object filter was called upon.
+ * @returns {boolean}
+ */
+type filterCallback = (currentProperty: any, currentIndex: keyof filterableItem, object: filterableItem) => boolean;
+/**
+ * This function is intended to replicate behaviour of the Array.filter() function but for Objects.
+ * If an array is passed in instead then it will perform standard filter(). It is recommended to
+ * always use the standard filter() function when it is known that the object is actually an array.
+ * @function
+ * @memberOf module:objectHelpers
+ * @param {Object|Array} obj - The Object (or Array) to be filtered
+ * @param {module:objectHelpers~filterCallback|Function} fn - The function to be processed for each filtered property
+ * @param {Object|Array} [thisArg] - Optional. Value to use as this when executing callback.
+ * @returns {Object|Array}
+ */
+declare const filterObject: (obj: filterableItem, fn: filterCallback, thisArg?: filterableItem) => filterableItem;
+export default filterObject;

package/dist/helpers/objects/isCloneable.d.ts

@@ -0,0 +1,10 @@
+import 'core-js/stable';
+/**
+ * Determine if the value is a reference instance
+ * @function
+ * @memberOf module:objectHelpers
+ * @param {Array|Object|*} value
+ * @returns {boolean}
+ */
+declare const isCloneable: (value: Array<any> | Object | any) => boolean;
+export default isCloneable;

package/dist/helpers/objects/isInstanceObject.d.ts

@@ -0,0 +1,10 @@
+import 'core-js/stable';
+/**
+ * Check if the current object has inherited properties.
+ * @function
+ * @memberOf module:objectHelpers
+ * @param {Object|Array} object
+ * @returns {boolean}
+ */
+declare const isInstanceObject: (object: Array<any> | Object) => boolean;
+export default isInstanceObject;

package/dist/helpers/objects/isObject.d.ts

@@ -0,0 +1,10 @@
+import 'core-js/stable';
+/**
+ * Check if the provided thing is an object / array.
+ * @function
+ * @memberOf module:objectHelpers
+ * @param {*} object
+ * @returns {boolean}
+ */
+declare const isObject: (object: any) => boolean;
+export default isObject;

package/dist/helpers/objects/mapObject.d.ts

@@ -0,0 +1,27 @@
+import 'core-js/stable';
+type mappableItem = Array<any> | {
+    [k: number | string]: any;
+};
+/**
+ * Function that produces a property of the new Object, taking three arguments
+ * @callback module:objectHelpers~mapCallback
+ * @memberOf module:objectHelpers
+ * @param {*} currentProperty - The current property being processed in the object.
+ * @param {string} [currentIndex] - The property name of the current property being processed in the object.
+ * @param {Object|Array} [object] - The object map was called upon.
+ * @returns {*}
+ */
+type mapCallback = (currentProperty: any, currentIndex: keyof mappableItem, object: mappableItem) => any;
+/**
+ * This function is intended to replicate behaviour of the Array.map() function but for Objects.
+ * If an array is passed in instead then it will perform standard map(). It is recommended to
+ * always use the standard map() function when it is known that the object is actually an array.
+ * @function
+ * @memberOf module:objectHelpers
+ * @param {Object|Array} obj - The Object (or Array) to be mapped
+ * @param {module:objectHelpers~mapCallback|Function} fn - The function to be processed for each mapped property
+ * @param {Object|Array} [thisArg] - Optional. Value to use as this when executing callback.
+ * @returns {Object|Array}
+ */
+declare const mapObject: (obj: mappableItem, fn: mapCallback, thisArg?: mappableItem) => mappableItem;
+export default mapObject;

package/dist/helpers/objects/mergeObjects.d.ts

@@ -0,0 +1,14 @@
+import 'core-js/stable';
+/**
+ * Uses mergeObjectsBase deep merge objects and arrays, merge by value.
+ * @function
+ * @memberOf module:objectHelpers
+ * @see {@link module:objectHelpers~mergeObjectsCallback}
+ * @param {...Object} objects - Provide a list of objects which will be merged starting from the end up into the first
+ * @returns {*}
+ */
+declare const mergeObjects: (...objects: Object[]) => any[] | {
+    [k: string]: any;
+    [k: number]: any;
+};
+export default mergeObjects;

package/dist/helpers/objects/mergeObjectsBase.d.ts

@@ -0,0 +1,37 @@
+import 'core-js/stable';
+import { relevanceMap } from '../functions/relevancyFilter';
+type mergeableItem = Array<any> | {
+    [k: number | string]: any;
+};
+/**
+ * Function that takes one or more objects and combines them into one.
+ * @typedef {Function} module:objectHelpers~mergeObjectsCallback
+ * @memberOf module:objectHelpers
+ * @param {...Object} objects - Provide a list of objects which will be merged starting from the end up into the first
+ * @returns {*}
+ */
+type mergeObjectsCallback = (...objects: Array<Object>) => mergeableItem;
+type mergeObjectsBaseOptions = {
+    mapLimit?: number;
+    depthLimit?: number;
+    relevancyRange?: number;
+    map?: relevanceMap;
+    useClone?: boolean;
+};
+/**
+ * Perform a deep merge of objects. This will return a function that will combine all objects and sub-objects.
+ * Objects having the same attributes will overwrite from last object to first.
+ * NOTE: Use the mapLimit and relevancyRange to resolve "too much recursion" when the object is large and is known to
+ * have circular references. A high mapLimit may lead to heavy memory usage and slow performance.
+ * @function
+ * @memberOf module:objectHelpers
+ * @param {Object} [options={}]
+ * @param {number} [options.mapLimit=100] - Size of temporary reference array used in memory before assessing relevancy.
+ * @param {number} [options.depthLimit=-1] - Control how many nested levels deep will be used, -1 = no limit, >-1 = nth level limited.
+ * @param {number} [options.relevancyRange=1000] - Total reference map length subtract this range, any relevancy less than that amount at time of evaluation will be removed.
+ * @param {Iterable|array} [options.map=[]] - A predetermined list of references gathered (to be passed to itself during recursion).
+ * @param {boolean} [options.useClone=false]
+ * @returns {module:objectHelpers~mergeObjectsCallback|mergeObjectsCallback}
+ */
+declare const mergeObjectsBase: ({ mapLimit, depthLimit, relevancyRange, map, useClone, }?: mergeObjectsBaseOptions) => mergeObjectsCallback;
+export default mergeObjectsBase;

package/dist/helpers/objects/mergeObjectsMutable.d.ts

@@ -0,0 +1,14 @@
+import 'core-js/stable';
+/**
+ * Uses mergeObjectsBase deep merge objects and arrays, merge by reference.
+ * @function
+ * @memberOf module:objectHelpers
+ * @see {@link module:objectHelpers~mergeObjectsCallback}
+ * @param {...Object} objects - Provide a list of objects which will be merged starting from the end up into the first
+ * @returns {*}
+ */
+declare const mergeObjectsMutable: (...objects: Object[]) => any[] | {
+    [k: string]: any;
+    [k: number]: any;
+};
+export default mergeObjectsMutable;

package/dist/helpers/objects/objectKeys.d.ts

@@ -0,0 +1,15 @@
+import 'core-js/stable';
+type keyableItem = Array<any> | {
+    [k: number | string]: any;
+};
+/**
+ * Get an array of keys from any object or array. Will return empty array when invalid or there are no keys.
+ * Optional flag will include the inherited keys from prototype chain when set.
+ * @function
+ * @memberOf module:objectHelpers
+ * @param {Object|Array} object
+ * @param {boolean} [includeInherited=false]
+ * @returns {Array.<string|number>}
+ */
+declare const objectKeys: (object: keyableItem, includeInherited?: boolean) => Array<any>;
+export default objectKeys;

package/dist/helpers/objects/objectValues.d.ts

@@ -0,0 +1,15 @@
+import 'core-js/stable';
+type arrayObjectItem = Array<any> | {
+    [k: number | string]: any;
+};
+/**
+ * Get an array of values from any object or array. Will return empty array when invalid or there are no values.
+ * Optional flag will include the inherited values from prototype chain when set.
+ * @function
+ * @memberOf module:objectHelpers
+ * @param {Object|Array} object
+ * @param {boolean} [includeInherited=false]
+ * @returns {Array}
+ */
+declare const objectValues: (object: arrayObjectItem, includeInherited?: boolean) => Array<any>;
+export default objectValues;

package/dist/helpers/objects/reduceObject.d.ts

@@ -0,0 +1,32 @@
+import 'core-js/stable';
+type reduceableItem = Array<any> | {
+    [k: number | string]: any;
+};
+/**
+ * Function to execute on each property in the object, taking four arguments
+ * @callback module:objectHelpers~reduceCallback
+ * @memberOf module:objectHelpers
+ * @param {*} [accumulator={}] - The accumulator accumulates the callback's return values; it is the accumulated
+ * value previously returned in the last invocation of the callback, or initialValue, if supplied (see below).
+ * @param {*} [currentProperty={}] - The current property being processed in the object.
+ * @param {string} [currentIndex=0] - The index of the current element being processed in the array. Starts at index
+ * 0, if an initialValue is provided, and at index 1 otherwise.
+ * @param {Object|Array} [object={}] - The object reduce was called upon.
+ * @returns {*}
+ */
+type reduceCallback = (accumulator: any, currentProperty: any, currentIndex: keyof reduceableItem, object: reduceableItem) => any;
+/**
+ * This function is intended to replicate behaviour of the Array.reduce() function but for Objects.
+ * If an array is passed in instead then it will perform standard reduce(). It is recommended to
+ * always use the standard reduce() function when it is known that the object is actually an array.
+ * @function
+ * @memberOf module:objectHelpers
+ * @param {Object|Array} obj - The Object (or Array) to be filtered
+ * @param {module:objectHelpers~reduceCallback|Function|reduceCallback} fn - The function to be processed for each filtered property
+ * @param {Object|Array} [initialValue] - Optional. Value to use as the first argument to the first call of the
+ * callback. If no initial value is supplied, the first element in the array will be used. Calling reduce on an empty
+ * array without an initial value is an error.
+ * @returns {*}
+ */
+declare const reduceObject: (obj: reduceableItem, fn: reduceCallback, initialValue?: reduceableItem) => any;
+export default reduceObject;

package/dist/helpers/objects/setAndReturnValue.d.ts

@@ -0,0 +1,15 @@
+import 'core-js/stable';
+type settableItem = Array<any> | {
+    [k: number | string]: any;
+};
+/**
+ * Set a value on an item, then return the value
+ * @function
+ * @memberOf module:objectHelpers
+ * @param {Object|Array} item - An object or array to be updated
+ * @param {string|number} key - The key on the item which will have its value set
+ * @param {*} value - Any value to be applied to the key
+ * @returns {*}
+ */
+declare const setAndReturnValue: (item: settableItem, key: keyof settableItem, value: any) => any;
+export default setAndReturnValue;

package/dist/helpers/objects/setValue.d.ts

@@ -0,0 +1,16 @@
+import 'core-js/stable';
+type settableItem = Array<any> | {
+    [k: number | string]: any;
+};
+/**
+ * Set a value on an item, then return the item.
+ * NOTE: Argument order designed for usage with pipe
+ * @function
+ * @memberOf module:objectHelpers
+ * @param {string|number} key - The key on the item which will have its value set
+ * @param {*} value - Any value to be applied to the key
+ * @param {Object|Array} item - An object or array to be updated
+ * @returns {Object|Array}
+ */
+declare const setValue: (key: number | string, value: any, item: settableItem) => settableItem;
+export default setValue;

package/dist/helpers/objects.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Simplify working with object by providing array-like parsing. Also, provides cloning and merging along with accessors that always have a return value for optimal nesting.
+ * @file
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ * @module objectHelpers
+ * @memberOf module:siFunciona
+ */
+import 'core-js/stable';
+declare const _default: {
+    cloneObject: (object: object, { mapLimit, depthLimit, relevancyRange }?: {
+        mapLimit?: number;
+        depthLimit?: number;
+        relevancyRange?: number;
+    }) => object;
+    dotGet: (arrayObject: import("./objects/dotNotate").dotNotateableItem, dotNotation: string, defaultValue?: string) => any;
+    dotNotate: (arrayObject: object, retainObjects?: string[]) => {
+        [k: string]: any;
+    };
+    dotSet: (arrayObject: import("./objects/dotNotate").dotNotateableItem, dotNotation: string, value?: any) => import("./objects/dotNotate").dotNotateableItem;
+    dotUnset: (arrayObject: import("./objects/dotNotate").dotNotateableItem, dotNotation: string) => import("./objects/dotNotate").dotNotateableItem;
+    emptyObject: (item: Object | any[]) => boolean;
+    filterObject: (obj: any[] | {
+        [k: string]: any;
+        [k: number]: any;
+    }, fn: (currentProperty: any, currentIndex: number | "length" | "toString" | "concat" | "indexOf" | "lastIndexOf" | "slice" | "includes" | "at" | "toLocaleString" | "join" | "every" | "some" | "forEach" | "map" | "filter" | "reduce" | "reduceRight" | "find" | "findIndex" | "entries" | "keys" | "values" | "flatMap" | "flat" | "pop" | "push" | "reverse" | "shift" | "sort" | "splice" | "unshift" | "fill" | "copyWithin", object: any[] | {
+        [k: string]: any;
+        [k: number]: any;
+    }) => boolean, thisArg?: any[] | {
+        [k: string]: any;
+        [k: number]: any;
+    }) => any[] | {
+        [k: string]: any;
+        [k: number]: any;
+    };
+    isCloneable: (value: any) => boolean;
+    isInstanceObject: (object: Object | any[]) => boolean;
+    isObject: (object: any) => boolean;
+    mapObject: (obj: any[] | {
+        [k: string]: any;
+        [k: number]: any;
+    }, fn: (currentProperty: any, currentIndex: number | "length" | "toString" | "concat" | "indexOf" | "lastIndexOf" | "slice" | "includes" | "at" | "toLocaleString" | "join" | "every" | "some" | "forEach" | "map" | "filter" | "reduce" | "reduceRight" | "find" | "findIndex" | "entries" | "keys" | "values" | "flatMap" | "flat" | "pop" | "push" | "reverse" | "shift" | "sort" | "splice" | "unshift" | "fill" | "copyWithin", object: any[] | {
+        [k: string]: any;
+        [k: number]: any;
+    }) => any, thisArg?: any[] | {
+        [k: string]: any;
+        [k: number]: any;
+    }) => any[] | {
+        [k: string]: any;
+        [k: number]: any;
+    };
+    mergeObjects: (...objects: Object[]) => any[] | {
+        [k: string]: any;
+        [k: number]: any;
+    };
+    mergeObjectsBase: ({ mapLimit, depthLimit, relevancyRange, map, useClone, }?: {
+        mapLimit?: number;
+        depthLimit?: number;
+        relevancyRange?: number;
+        map?: import("./functions/relevancyFilter").relevanceMap;
+        useClone?: boolean;
+    }) => (...objects: Object[]) => any[] | {
+        [k: string]: any;
+        [k: number]: any;
+    };
+    mergeObjectsMutable: (...objects: Object[]) => any[] | {
+        [k: string]: any;
+        [k: number]: any;
+    };
+    objectKeys: (object: any[] | {
+        [k: string]: any;
+        [k: number]: any;
+    }, includeInherited?: boolean) => any[];
+    objectValues: (object: any[] | {
+        [k: string]: any;
+        [k: number]: any;
+    }, includeInherited?: boolean) => any[];
+    reduceObject: (obj: any[] | {
+        [k: string]: any;
+        [k: number]: any;
+    }, fn: (accumulator: any, currentProperty: any, currentIndex: number | "length" | "toString" | "concat" | "indexOf" | "lastIndexOf" | "slice" | "includes" | "at" | "toLocaleString" | "join" | "every" | "some" | "forEach" | "map" | "filter" | "reduce" | "reduceRight" | "find" | "findIndex" | "entries" | "keys" | "values" | "flatMap" | "flat" | "pop" | "push" | "reverse" | "shift" | "sort" | "splice" | "unshift" | "fill" | "copyWithin", object: any[] | {
+        [k: string]: any;
+        [k: number]: any;
+    }) => any, initialValue?: any[] | {
+        [k: string]: any;
+        [k: number]: any;
+    }) => any;
+    setAndReturnValue: (item: any[] | {
+        [k: string]: any;
+        [k: number]: any;
+    }, key: number | "length" | "toString" | "concat" | "indexOf" | "lastIndexOf" | "slice" | "includes" | "at" | "toLocaleString" | "join" | "every" | "some" | "forEach" | "map" | "filter" | "reduce" | "reduceRight" | "find" | "findIndex" | "entries" | "keys" | "values" | "flatMap" | "flat" | "pop" | "push" | "reverse" | "shift" | "sort" | "splice" | "unshift" | "fill" | "copyWithin", value: any) => any;
+    setValue: (key: string | number, value: any, item: any[] | {
+        [k: string]: any;
+        [k: number]: any;
+    }) => any[] | {
+        [k: string]: any;
+        [k: number]: any;
+    };
+};
+export default _default;