@microsoft/applicationinsights-core-js 3.0.8 → 3.0.9

package/types/applicationinsights-core-js.namespaced.d.ts

@@ -1,5 +1,5 @@
 /*
- * Microsoft Application Insights Core Javascript SDK, 3.0.8
+ * Microsoft Application Insights Core Javascript SDK, 3.0.9
  * Copyright (c) Microsoft and contributors. All rights reserved.
  *
  * Microsoft Application Insights Team
@@ -7,59 +7,6 @@
  */
 
 declare namespace ApplicationInsights {
-    import { arrForEach } from '@nevware21/ts-utils';
-    import { arrIndexOf } from '@nevware21/ts-utils';
-    import { arrMap } from '@nevware21/ts-utils';
-    import { arrReduce } from '@nevware21/ts-utils';
-    import { asString } from '@nevware21/ts-utils';
-    import { utcNow as dateNow } from '@nevware21/ts-utils';
-    import { objDeepFreeze as deepFreeze } from '@nevware21/ts-utils';
-    import { dumpObj } from '@nevware21/ts-utils';
-    import { EnumCls } from '@nevware21/ts-utils';
-    import { getDocument } from '@nevware21/ts-utils';
-    import { getGlobal } from '@microsoft/applicationinsights-shims';
-    import { getInst as getGlobalInst } from '@nevware21/ts-utils';
-    import { getHistory } from '@nevware21/ts-utils';
-    import { getNavigator } from '@nevware21/ts-utils';
-    import { getPerformance } from '@nevware21/ts-utils';
-    import { getWindow } from '@nevware21/ts-utils';
-    import { hasDocument } from '@nevware21/ts-utils';
-    import { hasHistory } from '@nevware21/ts-utils';
-    import { hasNavigator } from '@nevware21/ts-utils';
-    import { objHasOwnProperty as hasOwnProperty } from '@nevware21/ts-utils';
-    import { hasWindow } from '@nevware21/ts-utils';
-    import { IPromise } from '@nevware21/ts-async';
-    import { isArray } from '@nevware21/ts-utils';
-    import { isBoolean } from '@nevware21/ts-utils';
-    import { isDate } from '@nevware21/ts-utils';
-    import { isError } from '@nevware21/ts-utils';
-    import { isFunction } from '@nevware21/ts-utils';
-    import { isNotTruthy } from '@nevware21/ts-utils';
-    import { isNullOrUndefined } from '@nevware21/ts-utils';
-    import { isNumber } from '@nevware21/ts-utils';
-    import { isObject } from '@nevware21/ts-utils';
-    import { isString } from '@nevware21/ts-utils';
-    import { isSymbol } from '@nevware21/ts-utils';
-    import { isTruthy } from '@nevware21/ts-utils';
-    import { isTypeof } from '@nevware21/ts-utils';
-    import { isUndefined } from '@nevware21/ts-utils';
-    import { ITimerHandler } from '@nevware21/ts-utils';
-    import { objDefineAccessors } from '@nevware21/ts-utils';
-    import { objForEachKey } from '@nevware21/ts-utils';
-    import { objFreeze } from '@nevware21/ts-utils';
-    import { objKeys } from '@nevware21/ts-utils';
-    import { objSeal } from '@nevware21/ts-utils';
-    import { objToString } from '@nevware21/ts-utils';
-    import { perfNow } from '@nevware21/ts-utils';
-    import { strEndsWith } from '@nevware21/ts-utils';
-    import { strShimFunction as strFunction } from '@microsoft/applicationinsights-shims';
-    import { strShimObject as strObject } from '@microsoft/applicationinsights-shims';
-    import { strShimPrototype as strPrototype } from '@microsoft/applicationinsights-shims';
-    import { strStartsWith } from '@nevware21/ts-utils';
-    import { strTrim } from '@nevware21/ts-utils';
-    import { strShimUndefined as strUndefined } from '@microsoft/applicationinsights-shims';
-    import { throwError } from '@nevware21/ts-utils';
-
     /**
      * Get all of the registered events on the target object, this is primarily used for testing cleanup but may also be used by
      * applications to remove their own events
@@ -284,11 +231,269 @@ declare namespace ApplicationInsights {
 
     function areCookiesSupported(logger?: IDiagnosticLogger): any;
 
-    
-    
-    
-    
-    
+    /**
+     * Calls the provided `callbackFn` function once for each element in an array in ascending index order. It is not invoked for index properties
+     * that have been deleted or are uninitialized. And unlike the ES6 forEach() you CAN stop or break the iteration by returning -1 from the
+     * `callbackFn` function.
+     *
+     * The range (number of elements) processed by arrForEach() is set before the first call to the `callbackFn`. Any elements added beyond the range
+     * or elements which as assigned to indexes already processed will not be visited by the `callbackFn`.
+     * @group Array
+     * @group ArrayLike
+     * @typeParam T - Identifies the element type of the array
+     * @param theArray - The array or array like object of elements to be searched.
+     * @param callbackfn A `synchronous` function that accepts up to three arguments. arrForEach calls the callbackfn function one time for each element in the array.
+     * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, null or undefined
+     * the array will be used as the this value.
+     * @remarks
+     * arrForEach expects a `synchronous` function.
+     * arrForEach does not wait for promises. Make sure you are aware of the implications while using promises (or async functions) as forEach callback.
+     * @example
+     * ```ts
+     * const items = ['item1', 'item2', 'item3'];
+     * const copyItems = [];
+     *
+     * // before using for loop
+     * for (let i = 0; i < items.length; i++) {
+     *   copyItems.push(items[i]);
+     * }
+     *
+     * // before using forEach()
+     * items.forEach((item) => {
+     *   copyItems.push(item);
+     * });
+     *
+     * // after
+     * arrForEach(items, (item) => {
+     *   copyItems.push(item);
+     *   // May return -1 to abort the iteration
+     * });
+     *
+     * // Also supports input as an array like object
+     * const items = { length: 3, 0: 'item1', 1: 'item2', 2: 'item3' };
+     * ```
+     */
+    function arrForEach<T = any>(theArray: ArrayLike<T>, callbackfn: (value: T, index: number, array: T[]) => void | number, thisArg?: any): void;
+
+    /**
+     * The arrIndexOf() method returns the first index at which a given element can be found in the array,
+     * or -1 if it is not present.
+     * `arrIndexOf()` compares searchElement to elements of the Array using strict equality (the same
+     * method used by the === or triple-equals operator).
+     * @group Array
+     * @group ArrayLike
+     * @typeParam T - Identifies the type of array elements
+     * @param theArray - The array or array like object of elements to be searched.
+     * @param searchElement - The element to locate in the array.
+     * @param fromIndex - The index to start the search at. If the index is greater than or equal to
+     * the array's length, -1 is returned, which means the array will not be searched. If the provided
+     * index value is a negative number, it is taken as the offset from the end of the array.
+     * Note: if the provided index is negative, the array is still searched from front to back. If the
+     * provided index is 0, then the whole array will be searched. Default: 0 (entire array is searched).
+     * @return The first index of the element in the array; -1 if not found.
+     * @example
+     * ```ts
+     * const array = [2, 9, 9];
+     * arrIndexOf(array, 2);     // 0
+     * arrIndexOf(array, 7);     // -1
+     * arrIndexOf(array, 9, 2);  // 2
+     * arrIndexOf(array, 2, -1); // -1
+     * arrIndexOf(array, 2, -3); // 0
+     *
+     * let indices: number[] = [];
+     * const array = ['a', 'b', 'a', 'c', 'a', 'd'];
+     * const element = 'a';
+     * let idx = arrIndexOf(array, element);
+     * while (idx !== -1) {
+     *   indices.push(idx);
+     *   idx = arrIndexOf(array, element, idx + 1);
+     * }
+     * console.log(indices);
+     * // [0, 2, 4]
+     *
+     * function updateVegetablesCollection (veggies, veggie) {
+     *     if (arrIndexOf(veggies, veggie) === -1) {
+     *         veggies.push(veggie);
+     *         console.log('New veggies collection is : ' + veggies);
+     *     } else {
+     *         console.log(veggie + ' already exists in the veggies collection.');
+     *     }
+     * }
+     *
+     * let veggies = ['potato', 'tomato', 'chillies', 'green-pepper'];
+     *
+     * updateVegetablesCollection(veggies, 'spinach');
+     * // New veggies collection is : potato,tomato,chillies,green-pepper,spinach
+     * updateVegetablesCollection(veggies, 'spinach');
+     * // spinach already exists in the veggies collection.
+     *
+     * // Array Like
+     * let arrayLike = {
+     *   length: 3,
+     *   0: "potato",
+     *   1: "tomato",
+     *   2: "chillies",
+     *   3: "green-pepper"  // Not checked as index is > length
+     * };
+     *
+     * arrIndexOf(arrayLike, "potato"); // 0
+     * arrIndexOf(arrayLike, "tomato"); // 1
+     * arrIndexOf(arrayLike, "chillies"); 2
+     * arrIndexOf(arrayLike, "green-pepper"); // -1
+     * ```
+     */
+    const arrIndexOf: <T>(theArray: ArrayLike<T>, searchElement: T, fromIndex?: number) => number;
+
+    /**
+     * The arrMap() method creates a new array populated with the results of calling a provided function on every
+     * element in the calling array.
+     *
+     * `arrMap` calls a provided callbackFn function once for each element in an array, in order, and constructs
+     * a new array from the results. callbackFn is invoked only for indexes of the array which have assigned
+     * values (including undefined).
+     *
+     * It is not called for missing elements of the array; that is:
+     * - indexes that have never been set;
+     * - indexes which have been deleted.
+     *
+     * @since 0.3.3
+     * @group Array
+     * @group ArrayLike
+     * @typeParam T - Identifies the type of the array elements
+     * @typeParam R - Identifies the type of the elements returned by the callback function, defaults to T.
+     * @param theArray - The array or array like object of elements to be searched.
+     * @param callbackFn - The function that is called for evetn element of `theArray`.
+     * @param thisArg - The value to use as the `this` when executing the `callbackFn`.
+     * @example
+     * ```ts
+     * const numbers = [1, 4, 9];
+     * const roots = arrMap(numbers, (num) => Math.sqrt(num));
+     *
+     * // roots is now     [1, 2, 3]
+     * // numbers is still [1, 4, 9]
+     *
+     * const kvArray = [{ key: 1, value: 10 },
+     *                  { key: 2, value: 20 },
+     *                  { key: 3, value: 30 }];
+     *
+     * const reformattedArray = arrMap(kvArray, ({ key, value}) => ({ [key]: value }));
+     *
+     * // reformattedArray is now [{1: 10}, {2: 20}, {3: 30}],
+     *
+     * // kvArray is still:
+     * // [{key: 1, value: 10},
+     * //  {key: 2, value: 20},
+     * //  {key: 3, value: 30}]
+     *
+     * // Also supports Array Like objects with same output
+     * const kvArray = {
+     *   length: 3,
+     *   0: { key: 1, value: 10 },
+     *   1: { key: 2, value: 20 },
+     *   2: { key: 3, value: 30 }
+     * };
+     * ```
+     */
+    const arrMap: <T, R = T>(theArray: ArrayLike<T>, callbackFn: ArrMapCallbackFn<T, R>, thisArg?: any) => R[];
+
+    /**
+     * Callback signature for {@link arrMap} that is called for every element of array. Each time callbackFn
+     * executes, the returned value is added to newArray.
+     *
+     * @since 0.3.3
+     * @group Array
+     * @group ArrayLike
+     * @typeParam T - Identifies the type of the array elements
+     * @typeParam R - Identifies the type of the elements returned by the callback function, defaults to T.
+     * @param value - The current element being processed in the array.
+     * @param index - The index of the current element being processed in the array.
+     * @param array - The array that the `map` function was called on.
+     */
+    type ArrMapCallbackFn<T, R = T> = (value: T, index?: number, array?: T[]) => R;
+
+    /**
+     * The arrReduce() method executes a user-supplied "reducer" callback function on each element of the array,
+     * in order, passing in the return value from the calculation on the preceding element. The final result of
+     * running the reducer across all elements of the array is a single value.
+     *
+     * The first time that the callback is run there is no "return value of the previous calculation". If supplied,
+     * an initial value may be used in its place. Otherwise the array element at index 0 is used as the initial
+     * value and iteration starts from the next element (index 1 instead of index 0).
+     * @group Array
+     * @group ArrayLike
+     * @typeParam T - Identifies the type of array elements
+     * @param theArray - The array or array like object of elements to be searched.
+     * @param callbackfn A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the array.
+     * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.
+     * @returns The value that results from running the "reducer" callback function to completion over the entire array.
+     * @example
+     * ```ts
+     * const getMax = (a: number, b: number) => Math.max(a, b);
+     *
+     * // callback is invoked for each element in the array starting at index 0
+     * arrReduce([1, 100], getMax, 50); // 100
+     * arrReduce([    50], getMax, 10); // 50
+     *
+     * // callback is invoked once for element at index 1
+     * arrReduce([1, 100], getMax);     // 100
+     *
+     * // callback is not invoked
+     * arrReduce([    50], getMax);     // 50
+     * arrReduce([      ], getMax, 1);  // 1
+     *
+     * arrReduce([      ], getMax);     // throws TypeError
+     *
+     * // Also supports Array like objects
+     * arrReduce({ length: 2, 0: 1, 1: 100 }, getMax, 50); // 100
+     * arrReduce({ length: 1, 0: 50 }, getMax, 10); // 50
+     *
+     * // callback is invoked once for element at index 1
+     * arrReduce({ length: 2, 0: 1, 1: 100 }, getMax);     // 100
+     *
+     * // callback is not invoked
+     * arrReduce({ length: 1, 0: 50 }, getMax);     // 50
+     * arrReduce({ length: 0 }, getMax, 1);  // 1
+     * ```
+     */
+    const arrReduce: <T, R = T>(theArray: ArrayLike<T>, callbackfn: ArrReduceCallbackFn<T, R>, initialValue?: T | R) => R;
+
+    /**
+     * The `reducer` function called for {@link arrReduce}.
+     * @group Array
+     * @group ArrayLike
+     * @typeParam T - Identifies the type of array elements
+     * @typeParam R - Identifies the type of the return array elements (defaults to T)
+     * @param previousValue - The value resulting from the previous call to callbackFn. On first call, initialValue if
+     * specified, otherwise the value of array[0].
+     * @param currentValue - The value of the current element. On first call, the value of array[0] if an initialValue
+     * was specified, otherwise the value of array[1].
+     * @param currentIndex - The index position of currentValue in the array. On first call, 0 if initialValue was
+     * specified, otherwise 1.
+     * @param array -The array being traversed.
+     */
+    type ArrReduceCallbackFn<T, R = T> = (previousValue: T | R, currentValue: T, currentIndex: number, array: T[]) => R;
+
+    /**
+     * The asString() method returns a string representing the value by
+     * explicitly using `String(`value`)`.
+     *
+     * @since 0.4.3
+     * @group String
+     * @group Conversion
+     * @group Value
+     * @param value - The value to get a string representation of
+     * @example
+     * ```ts
+     * const arr = [ 1, 2, 3];
+     * asString(arr);       // "1,2,3"
+     * asString(null);      // "null"
+     * asString(undefined); // "undefined"
+     * asString(42);        // "42"
+     * asString(Symbol.for("Hello"));   // "Symbol(Hello)"
+     * ```
+     */
+    const asString: (value: any) => string;
+
     /**
      * Binds the specified function to an event, so that the function gets called whenever the event fires on the object
      * @param obj - Object to add the event too.
@@ -594,8 +799,33 @@ declare namespace ApplicationInsights {
         [key in keyof E]: [E[keyof E], V[keyof V]];
     }) => V;
 
-    
-    
+    /**
+     * Return the number of milliseconds that have elapsed since January 1, 1970 00:00:00 UTC.
+     *
+     * To offer protection against timing attacks and fingerprinting, the precision of utcNow()
+     * might get rounded depending on browser settings. In Firefox, the privacy.reduceTimerPrecision
+     * preference is enabled by default and defaults to 20µs in Firefox 59; in 60 it will be 2ms.
+     *
+     * @since 0.4.4
+     * @group Timer
+     *
+     * @returns A Number representing the milliseconds elapsed since the UNIX epoch.
+     * @example
+     * ```ts
+     * let now = utcNow();
+     * ```
+     */
+    function dateNow(): number;
+
+    /**
+     * Perform a deep freeze on the object and all of it's contained values / properties by recursively calling
+     * `objFreeze()` on all enumerable properties of the object and on each property returned.
+     * @group Object
+     * @param value - the object to be completly frozen.
+     * @returns The originally passed in object.
+     */
+    function deepFreeze<T>(value: T): T;
+
     /**
      * Removes an event handler for the specified event
      * @param Object - to remove the event from
@@ -689,7 +919,62 @@ declare namespace ApplicationInsights {
         unload?: (isAsync?: boolean) => T | IPromise<T>;
     }>, isAsync?: boolean, done?: () => void): void | IPromise<void>;
 
-    
+    /**
+     * Returns string representation of an object suitable for diagnostics logging.
+     * @group Error
+     * @group Diagnostic
+     * @param object - The object to be converted to a diagnostic string value
+     * @param format - Identifies whether the JSON value should be formated
+     * - `true` - Format with 4 spaces
+     * - 'number' - The number of spaces to format with
+     * - `false` (or not Truthy) - Do not format
+     * @returns A string representation of the object suitable for diagnostics logging
+     * @example
+     * ```ts
+     * let obj = { a: 1, b: "Hello", c: { d: 2, e: "Darkness" } };
+     *
+     * let objStr = dumpObj(obj);
+     * // objStr === "[object Object]: { a: 1, b: "Hello", c: { d: 2, e: "Darkness" } }"
+     *
+     * let objStrFmt = dumpObj(obj, true);
+     * // objStrFmt === "[object Object]: {\n    a: 1,\n    b: "Hello",\n    c: {\n        d: 2,\n        e: "Darkness"\n    }\n}"
+     *
+     * let objStrFmt2 = dumpObj(obj, 2);
+     * // objStrFmt2 === "[object Object]: {\n  a: 1,\n  b: "Hello",\n  c: {\n    d: 2,\n    e: "Darkness"\n  }\n}"
+     *
+     * let objStrFmt3 = dumpObj(obj, 0);
+     * // objStrFmt3 === "[object Object]: { a: 1, b: "Hello", c: { d: 2, e: "Darkness" } }"
+     *
+     * let objStrFmt4 = dumpObj(obj, false);
+     * // objStrFmt4 === "[object Object]: { a: 1, b: "Hello", c: { d: 2, e: "Darkness" } }"
+     *
+     * let objStrFmt5 = dumpObj(obj, null);
+     * // objStrFmt5 === "[object Object]: { a: 1, b: "Hello", c: { d: 2, e: "Darkness" } }"
+     *
+     * let objStrFmt6 = dumpObj(obj, undefined);
+     * // objStrFmt6 === "[object Object]: { a: 1, b: "Hello", c: { d: 2, e: "Darkness" } }"
+     *
+     * let objStrFmt7 = dumpObj(obj, "");
+     * // objStrFmt7 === "[object Object]: { a: 1, b: "Hello", c: { d: 2, e: "Darkness" } }"
+     *
+     * let err = new Error("Hello Darkness");
+     * let errStr = dumpObj(err);
+     * // errStr === "[object Error]: { stack: 'Error: Hello Darkness\n    at <anonymous>:1:13', message: 'Hello Darkness', name: 'Error'"
+     *
+     * let errStrFmt = dumpObj(err, true);
+     * // errStrFmt === "[object Error]: {\n    stack: "Error: Hello Darkness\n    at <anonymous>:1:13",\n    message: "Hello Darkness",\n    name: "Error"\n}"
+     *
+     * let errStrFmt2 = dumpObj(err, 2);
+     * // errStrFmt2 === "[object Error]: {\n  stack: "Error: Hello Darkness\n    at <anonymous>:1:13",\n  message: "Hello Darkness",\n  name: "Error"\n}"
+     *
+     * let errStrFmt3 = dumpObj(err, 0);
+     * // errStrFmt3 === "[object Error]: { stack: "Error: Hello Darkness\n    at <anonymous>:1:13", message: "Hello Darkness", name: "Error" }"
+     *
+     * ```
+     * @see {@link dumpObj}
+     */
+    function dumpObj(object: any, format?: boolean | number): string;
+
     /**
      * The eEventsDiscardedReason enumeration contains a set of values that specify the reason for discarding an event.
      */
@@ -769,6 +1054,7 @@ declare namespace ApplicationInsights {
         InvalidDurationValue = 45,
         TelemetryEnvelopeInvalid = 46,
         CreateEnvelopeError = 47,
+        MaxUnloadHookExceeded = 48,
         CannotSerializeObject = 48,
         CannotSerializeObjectNonSerializable = 49,
         CircularReferenceDetected = 50,
@@ -831,6 +1117,19 @@ declare namespace ApplicationInsights {
         DEBUG = 3
     }
 
+    /**
+     * A type that identifies an enum class generated from a constant enum.
+     * @group Enum
+     * @typeParam E - The constant enum type
+     *
+     * Returned from {@link createEnum}
+     */
+    type EnumCls<E = any> = {
+        readonly [key in keyof E extends string | number | symbol ? keyof E : never]: key extends string ? E[key] : key;
+    } & {
+        readonly [key in keyof E]: E[key];
+    };
+
     type EnumValue<E = any> = EnumCls<E>;
 
     /**
@@ -882,6 +1181,11 @@ declare namespace ApplicationInsights {
         enable = 3
     }
 
+    /**
+     * This defines the handler function that is called via the finally when the promise is resolved or rejected
+     */
+    type FinallyPromiseHandler = (() => void) | undefined | null;
+
     /**
      * Helper function to fetch the named meta-tag from the page.
      * @param name
@@ -949,7 +1253,13 @@ declare namespace ApplicationInsights {
 
     function getDebugListener(config: IConfiguration): INotificationListener;
 
-    
+    /**
+     * Return the global `document` instance.
+     * @group Environment
+     * @returns
+     */
+    const getDocument: () => Document;
+
     /**
      * @internal
      * Get the dynamic config handler if the value is already dynamic
@@ -969,9 +1279,54 @@ declare namespace ApplicationInsights {
      */
     function getGblPerfMgr(): IPerfManager;
 
-    
-    
-    
+    /**
+     * Returns the current global scope object, for a normal web page this will be the current
+     * window, for a Web Worker this will be current worker global scope via "self". The internal
+     * implementation returns the first available instance object in the following order
+     * - globalThis (New standard)
+     * - self (Will return the current window instance for supported browsers)
+     * - window (fallback for older browser implementations)
+     * - global (NodeJS standard)
+     * - <null> (When all else fails)
+     * While the return type is a Window for the normal case, not all environments will support all
+     * of the properties or functions. And this caches the lookup of the global as in some environments
+     * this can be an expensive operation.
+     * @group Environment
+     * @param useCached - [Optional] used for testing to bypass the cached lookup, when `true` this will
+     * cause the cached global to be reset.
+     */
+    function getGlobal(useCached?: boolean): Window;
+
+    /**
+     * Return the named global object if available, will return null if the object is not available.
+     * @group Environment
+     * @param name The globally named object, may be any valid property key (string, number or symbol)
+     * @param useCached - [Optional] used for testing to bypass the cached lookup, when `true` this will
+     * cause the cached global to be reset.
+     * @example
+     * ```ts
+     * // This does not cause the evaluation to occur
+     * window.myGlobal = "Hello";
+     * let cachedValue = getInst("myGlobal");
+     * // cachedValue === "Hello"
+     *
+     * window.myGlobal = "Darkness";
+     * // getInst("myGlobal") === "Darkness"
+     *
+     * let promiseCls = getInst("Promise");
+     * // May throw if the global is not supported by the runtime
+     * // otherwise the Promise class.
+     * ```
+     */
+    function getGlobalInst<T>(name: string | number | symbol, useCached?: boolean): T | null;
+
+    /**
+     * Returns the global `history` instance
+     * @group Environment
+     * @returns
+     */
+    const getHistory: () => History;
+
     /**
      * Gets IE version returning the document emulation mode if we are running on IE, or null otherwise
      */
@@ -998,8 +1353,25 @@ declare namespace ApplicationInsights {
      */
     function getMsCrypto(): Crypto | null;
 
-    
-    
+    /**
+     * Returns the global `navigator` instance
+     * @group Environment
+     * @returns
+     */
+    const getNavigator: () => Navigator;
+
+    /**
+     * Returns the global `performance` Object if available, which can be used to
+     * gather performance information about the current document. It serves as the
+     * point of exposure for the Performance Timeline API, the High Resolution Time
+     * API, the Navigation Timing API, the User Timing API, and the Resource Timing API.
+     *
+     * @since 0.4.4
+     * @group Environment
+     * @returns The global performance object if available.
+     */
+    function getPerformance(): Performance;
+
     /**
      * Returns the current value from the target object if not null or undefined otherwise sets the new value and returns it
      * @param target - The target object to return or set the default value
@@ -1008,9 +1380,27 @@ declare namespace ApplicationInsights {
      */
     function getSetValue<T, K extends keyof T>(target: T, field: K, defValue?: T[K]): T[K];
 
-    
-    
-    
+    /**
+     * Return the global `window` instance.
+     * @group Environment
+     * @returns
+     */
+    const getWindow: () => Window;
+
+    /**
+     * Identify whether the runtime contains a `document` object
+     * @group Environment
+     * @returns - True if a `document` exists
+     */
+    function hasDocument(): boolean;
+
+    /**
+     * Identifies whether the runtime contains a `history` object
+     * @group Environment
+     * @returns
+     */
+    function hasHistory(): boolean;
+
     /**
      * Checks if JSON object is available, this is required as we support the API running without a
      * window /document (eg. Node server, electron webworkers) and if we attempt to assign a history
@@ -1020,9 +1410,54 @@ declare namespace ApplicationInsights {
      */
     function hasJSON(): boolean;
 
-    
-    
-    
+    /**
+     * Identify whether the runtimne contains a `navigator` object
+     * @group Environment
+     * @returns
+     */
+    function hasNavigator(): boolean;
+
+    /**
+     * The objHasOwnProperty() method returns a boolean indicating whether the object
+     * has the specified property as its own property (as opposed to inheriting it).
+     *
+     * The objHasOwnProperty() method returns true if the specified property is a direct
+     * property of the object — even if the value is null or undefined. The method returns
+     * false if the property is inherited, or has not been declared at all. Unlike the in
+     * operator, this method does not check for the specified property in the object's
+     * prototype chain.
+     *
+     * The method can be called on most JavaScript objects, because most objects descend
+     * from Object, and hence inherit its methods. For example Array is an Object, so you
+     * can use objHasOwnProperty() method to check whether an index exists:
+     * @group Object
+     * @param obj - The object being evaluated
+     * @param prop - The String or Symbol of the property to test
+     * @returns `true` if the object has the specified property as own property; otherwise `false`
+     * @example
+     * ```ts
+     * let example = {};
+     * objHasOwnProperty(example, 'prop');   // false
+     *
+     * example.prop = 'exists';
+     * objHasOwnProperty(example, 'prop');   // true - 'prop' has been defined
+     *
+     * example.prop = null;
+     * objHasOwnProperty(example, 'prop');   // true - own property exists with value of null
+     *
+     * example.prop = undefined;
+     * objHasOwnProperty(example, 'prop');   // true - own property exists with value of undefined
+     * ```
+     */
+    function hasOwnProperty<T = any>(obj: T, prop: PropertyKey): boolean;
+
+    /**
+     * Identify whether the runtime contains a `window` object
+     * @group Environment
+     * @returns
+     */
+    function hasWindow(): boolean;
+
     interface IAppInsightsCore<CfgType extends IConfiguration = IConfiguration> extends IPerfManagerProvider {
         readonly config: CfgType;
         /**
@@ -2347,12 +2782,241 @@ declare namespace ApplicationInsights {
         createNew: (plugins?: IPlugin[] | ITelemetryPluginChain, startAt?: IPlugin) => IProcessTelemetryUpdateContext;
     }
 
+    /**
+     * Create a Promise object that represents the eventual completion (or failure) of an asynchronous operation and its resulting value.
+     * This interface definition, closely mirrors the typescript / javascript PromiseLike<T> and Promise<T> definitions as well as providing
+     * simular functions as that provided by jQuery deferred objects.
+     *
+     * The returned Promise is a proxy for a value not necessarily known when the promise is created. It allows you to associate handlers
+     * with an asynchronous action's eventual success value or failure reason. This lets asynchronous methods return values like synchronous
+     * methods: instead of immediately returning the final value, the asynchronous method returns a promise to supply the value at some point
+     * in the future.
+     *
+     * A Promise is in one of these states:
+     * <ul>
+     * <li> pending: initial state, neither fulfilled nor rejected.
+     * <li> fulfilled: meaning that the operation was completed successfully.
+     * <li> rejected: meaning that the operation failed.
+     * </ul>
+     *
+     * A pending promise can either be fulfilled with a value or rejected with a reason (error). When either of these options happens, the
+     * associated handlers queued up by a promise's then method are called synchronously. If the promise has already been fulfilled or rejected
+     * when a corresponding handler is attached, the handler will be called synchronously, so there is no race condition between an asynchronous
+     * operation completing and its handlers being attached.
+     *
+     * As the `then()` and `catch()` methods return promises, they can be chained.
+     * @typeParam T - Identifies the expected return type from the promise
+     */
+    interface IPromise<T> extends PromiseLike<T>, Promise<T> {
+        /**
+         * Returns a string representation of the current state of the promise. The promise can be in one of four states.
+         * <ul>
+         * <li> <b>"pending"</b>: The promise is not yet in a completed state (neither "rejected"; or "resolved").</li>
+         * <li> <b>"resolved"</b>: The promise is in the resolved state.</li>
+         * <li> <b>"rejected"</b>: The promise is in the rejected state.</li>
+         * </ul>
+         * @example
+         * ```ts
+         * let doResolve;
+         * let promise: IPromise<any> = createSyncPromise((resolve) => {
+         *  doResolve = resolve;
+         * });
+         *
+         * let state: string = promise.state();
+         * console.log("State: " + state);      // State: pending
+         * doResolve(true);                     // Promise will resolve synchronously as it's a synchronous promise
+         * console.log("State: " + state);      // State: resolved
+         * ```
+         */
+        state?: string;
+        /**
+         * Attaches callbacks for the resolution and/or rejection of the Promise.
+         * @param onResolved The callback to execute when the Promise is resolved.
+         * @param onRejected The callback to execute when the Promise is rejected.
+         * @returns A Promise for the completion of which ever callback is executed.
+         * @example
+         * ```ts
+         * const promise1 = createPromise((resolve, reject) => {
+         *   resolve('Success!');
+         * });
+         *
+         * promise1.then((value) => {
+         *   console.log(value);
+         *   // expected output: "Success!"
+         * });
+         * ```
+         */
+        then<TResult1 = T, TResult2 = never>(onResolved?: ResolvedPromiseHandler<T, TResult1>, onRejected?: RejectedPromiseHandler<TResult2>): IPromise<TResult1 | TResult2>;
+        /**
+         * Attaches callbacks for the resolution and/or rejection of the Promise.
+         * @param onResolved The callback to execute when the Promise is resolved.
+         * @param onRejected The callback to execute when the Promise is rejected.
+         * @returns A Promise for the completion of which ever callback is executed.
+         * @example
+         * ```ts
+         * const promise1 = createPromise((resolve, reject) => {
+         *   resolve('Success!');
+         * });
+         *
+         * promise1.then((value) => {
+         *   console.log(value);
+         *   // expected output: "Success!"
+         * });
+         * ```
+         */
+        then<TResult1 = T, TResult2 = never>(onResolved?: ResolvedPromiseHandler<T, TResult1>, onRejected?: RejectedPromiseHandler<TResult2>): PromiseLike<TResult1 | TResult2>;
+        /**
+         * Attaches callbacks for the resolution and/or rejection of the Promise.
+         * @param onResolved The callback to execute when the Promise is resolved.
+         * @param onRejected The callback to execute when the Promise is rejected.
+         * @returns A Promise for the completion of which ever callback is executed.
+         * @example
+         * ```ts
+         * const promise1 = createPromise((resolve, reject) => {
+         *   resolve('Success!');
+         * });
+         *
+         * promise1.then((value) => {
+         *   console.log(value);
+         *   // expected output: "Success!"
+         * });
+         * ```
+         */
+        then<TResult1 = T, TResult2 = never>(onResolved?: ResolvedPromiseHandler<T, TResult1>, onRejected?: RejectedPromiseHandler<TResult2>): Promise<TResult1 | TResult2>;
+        /**
+         * Attaches a callback for only the rejection of the Promise.
+         * @param onRejected The callback to execute when the Promise is rejected.
+         * @returns A Promise for the completion of the callback.
+         * @example
+         * ```ts
+         * const promise1 = createPromise((resolve, reject) => {
+         *   throw 'Uh-oh!';
+         * });
+         *
+         * promise1.catch((error) => {
+         *   console.error(error);
+         * });
+         * // expected output: Uh-oh!
+         * ```
+         */
+        catch<TResult = never>(onRejected?: ((reason: any) => TResult | IPromise<TResult>) | undefined | null): IPromise<T | TResult>;
+        /**
+         * Attaches a callback for only the rejection of the Promise.
+         * @param onRejected The callback to execute when the Promise is rejected.
+         * @returns A Promise for the completion of the callback.
+         * @example
+         * ```ts
+         * const promise1 = createPromise((resolve, reject) => {
+         *   throw 'Uh-oh!';
+         * });
+         *
+         * promise1.catch((error) => {
+         *   console.error(error);
+         * });
+         * // expected output: Uh-oh!
+         * ```
+         */
+        catch<TResult = never>(onRejected?: ((reason: any) => TResult | IPromise<TResult>) | undefined | null): PromiseLike<T | TResult>;
+        /**
+         * Attaches a callback for only the rejection of the Promise.
+         * @param onRejected The callback to execute when the Promise is rejected.
+         * @returns A Promise for the completion of the callback.
+         * @example
+         * ```ts
+         * const promise1 = createPromise((resolve, reject) => {
+         *   throw 'Uh-oh!';
+         * });
+         *
+         * promise1.catch((error) => {
+         *   console.error(error);
+         * });
+         * // expected output: Uh-oh!
+         * ```
+         */
+        catch<TResult = never>(onRejected?: ((reason: any) => TResult | IPromise<TResult>) | undefined | null): Promise<T | TResult>;
+        /**
+         * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
+         * resolved value cannot be modified from the callback.
+         * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
+         * @returns A Promise for the completion of the callback.
+         * @example
+         * ```ts
+         * function doFunction() {
+         *   return createPromise((resolve, reject) => {
+         *     if (Math.random() > 0.5) {
+         *       resolve('Function has completed');
+         *     } else {
+         *       reject(new Error('Function failed to process'));
+         *     }
+         *   });
+         * }
+         *
+         * doFunction().then((data) => {
+         *     console.log(data);
+         * }).catch((err) => {
+         *     console.error(err);
+         * }).finally(() => {
+         *     console.log('Function processing completed');
+         * });
+         * ```
+         */
+        finally(onfinally?: FinallyPromiseHandler): IPromise<T>;
+        /**
+         * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
+         * resolved value cannot be modified from the callback.
+         * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
+         * @returns A Promise for the completion of the callback.
+         * @example
+         * ```ts
+         * function doFunction() {
+         *   return createPromise((resolve, reject) => {
+         *     if (Math.random() > 0.5) {
+         *       resolve('Function has completed');
+         *     } else {
+         *       reject(new Error('Function failed to process'));
+         *     }
+         *   });
+         * }
+         *
+         * doFunction().then((data) => {
+         *     console.log(data);
+         * }).catch((err) => {
+         *     console.error(err);
+         * }).finally(() => {
+         *     console.log('Function processing completed');
+         * });
+         * ```
+         */
+        finally(onFinally?: FinallyPromiseHandler): Promise<T>;
+    }
+
     interface _IRegisteredEvents {
         name: string;
         handler: any;
     }
 
-    
+    /**
+     * Checks if the type of value is an Array.
+     *
+     * @group Type Identity
+     * @group Array
+     * @param {any} value - Value to be checked.
+     * @return {boolean} True if the value is a Array, false otherwise.
+     * @example
+     * ```ts
+     * import { isArray, isObject } from "@nevware21/ts-utils";
+     *
+     * function performAction(value: any) {
+     *     if (isArray(value) || isObject(value)) {
+     *         // Do something
+     *     } else {
+     *         // Do something else
+     *     }
+     * }
+     * ```
+     */
+    const isArray: <T = any>(arg: any) => arg is Array<T>;
+
     /**
      * Checks if HTML5 Beacons are supported in the current environment.
      * @param useCached - [Optional] used for testing to bypass the cached lookup, when `true` this will
@@ -2361,9 +3025,41 @@ declare namespace ApplicationInsights {
      */
     function isBeaconsSupported(useCached?: boolean): boolean;
 
-    
-    
-    
+    /**
+     * Checks if the type of value is a boolean.
+     * @group Type Identity
+     * @param {any} value - Value to be checked.
+     * @return {boolean} True if the value is a boolean, false otherwise.
+     */
+    const isBoolean: (value: any) => value is boolean;
+
+    /**
+     * Check if an object is of type Date
+     * @group Type Identity
+     * @example
+     * ```ts
+     * import { isDate } from "@nevware21/ts-utils";
+     *
+     * let _theDate = null;
+     *
+     * function getSetDate(newDate?: any) {
+     *     _theDate = isDate(newDate) ? newDate : new Date();
+     *
+     *     return _theDate;
+     * }
+     * ```
+     */
+    const isDate: (value: any) => value is Date;
+
+    /**
+     * Checks if the type of value is a Error object.
+     * @group Type Identity
+     * @group Error
+     * @param {any} value - Value to be checked.
+     * @return {boolean} True if the value is a Error, false otherwise.
+     */
+    const isError: (value: any) => value is Error;
+
     function isFeatureEnabled<T extends IConfiguration = IConfiguration>(feature?: string, cfg?: T): boolean;
 
     /**
@@ -2373,7 +3069,30 @@ declare namespace ApplicationInsights {
      */
     function isFetchSupported(withKeepAlive?: boolean): boolean;
 
-    
+    /**
+     * Checks to see if the past value is a function value
+     * @group Type Identity
+     * @param value - The value to check
+     * @returns
+     * @example
+     * ```ts
+     * function myFunction() { }
+     * isFunction(null);            // false
+     * isFunction(undefined);       // false
+     * isFunction("null");          // false
+     * isFunction("undefined");     // false
+     * isFunction("1");             // false
+     * isFunction("aa");            // false
+     * isFunction(new Date());      // false
+     * isFunction(1);               // false
+     * isFunction("");              // false
+     * isFunction(myFunction);      // true
+     * isFunction([]);              // false
+     * isFunction(new Array(1));    // false
+     * ```
+     */
+    const isFunction: (value: any) => value is Function;
+
     /**
      * Identifies whether the current environment appears to be IE
      */
@@ -2381,12 +3100,61 @@ declare namespace ApplicationInsights {
 
     function isNotNullOrUndefined<T>(value: T): value is T;
 
-    
+    /**
+     * Checks if the type of value does not evaluate to true value, handling some special
+     * case usages of Boolean(true/false) and new Boolean(true/false).
+     * @group Value Check
+     * @param {any} value - Value to be checked.
+     * @return {boolean} True if the value is not truthy, false otherwise.
+     */
+    function isNotTruthy(value: any): boolean;
+
     function isNotUndefined<T>(value: T): value is T;
 
-    
-    
-    
+    /**
+     * Checks if the provided value is null, undefined or contains the string value of "undefined".
+     * @group Type Identity
+     * @group Value Check
+     * @param value - The value to check
+     * @returns `true` if the value is `null` or `undefined`
+     * @example
+     * ```ts
+     * isNullOrUndefined(null);         // true
+     * isNullOrUndefined(undefined);    // true
+     * isNullOrUndefined("undefined");  // true
+     *
+     * let value = null;
+     * isNullOrUndefined(value);        // true
+     * let value = undefined;
+     * isNullOrUndefined(value);        // true
+     *
+     * isNullOrUndefined("");           // false
+     * isNullOrUndefined(0);            // false
+     * isNullOrUndefined(new Date());   // false
+     * isNullOrUndefined(true);         // false
+     * isNullOrUndefined(false);        // false
+     * ```
+     */
+    function isNullOrUndefined(value: any): boolean;
+
+    /**
+     * Checks if the type of value is a number.
+     * @group Type Identity
+     * @param {any} value - Value to be checked.
+     * @return {boolean} True if the value is a number, false otherwise.
+     */
+    const isNumber: (value: any) => value is number;
+
+    /**
+     * Checks to see if the past value is an object value
+     * @group Type Identity
+     * @group Object
+     * @typeParam T - The object type, defaults to any
+     * @param value - The value to check
+     * @returns
+     */
+    function isObject<T>(value: T): value is T;
+
     /**
      * Returns whether the environment is reporting that we are running in a React Native Environment
      */
@@ -2401,11 +3169,103 @@ declare namespace ApplicationInsights {
      */
     function isSampledFlag(value: ITraceParent): boolean;
 
-    
-    
-    
-    
-    
+    /**
+     * Checks to see if the past value is a string value
+     * @group Type Identity
+     * @group String
+     * @param value - The value to check
+     * @returns
+     * @example
+     * ```ts
+     * isString("");            // true
+     * isString("null");        // true
+     * isString("undefined");   // true
+     * isString(String(""));    // true
+     *
+     * isString(null);          // false
+     * isString(undefined);     // false
+     * isString(0);             // false
+     * ```
+     */
+    const isString: (value: any) => value is string;
+
+    /**
+     * Checks if the type of value is a symbol.
+     * @group Symbol
+     * @param {any} value - Value to be checked.
+     * @return {boolean} True if the value is a symbol, false otherwise.
+     */
+    const isSymbol: (value: any) => value is symbol;
+
+    /**
+     * Checks if the type of value evaluates to true value, handling some special
+     * case usages of Boolean(true/false) and new Boolean(true/false).
+     * @group Value Check
+     * @param {any} value - Value to be checked.
+     * @return {boolean} True if the value is not truthy, false otherwise.
+     */
+    function isTruthy(value: any): boolean;
+
+    /**
+     * Validate if the provided value object is of the expected type
+     * @group Type Identity
+     * @param value - The value to check
+     * @param theType - The expected type name as a string
+     * @returns `true` if the value matches the provided type
+     */
+    function isTypeof(value: any, theType: string): boolean;
+
+    /**
+     * Checks if the provided value is undefined or contains the string value "undefined",
+     * if you want to consider the string value as undefined see {@link isStrictUndefined}
+     * @group Type Identity
+     * @group Value Check
+     * @param value - The value to check
+     * @returns true if the value is undefined or "undefined", otherwise false
+     * @example
+     * ```ts
+     * isUndefined(undefined);              // true
+     * isUndefined("undefined");            // true
+     *
+     * isUndefined(null);                   // false
+     * isUndefined("null");                 // false
+     * isUndefined("1");                    // false
+     * isUndefined("aa");                   // false
+     * isUndefined(new Date());             // false
+     * isUndefined(1);                      // false
+     * isUndefined("");                     // false
+     * isUndefined(_dummyFunction);         // false
+     * isUndefined([]);                     // false
+     * isUndefined(new Array(1));           // false
+     * isUndefined(true);                   // false
+     * isUndefined(false);                  // false
+     * isUndefined("true");                 // false
+     * isUndefined("false");                // false
+     * isUndefined(new Boolean(true));      // false
+     * isUndefined(new Boolean(false));     // false
+     * isUndefined(new Boolean("true"));    // false
+     * isUndefined(new Boolean("false"));   // false
+     * isUndefined(Boolean(true));          // false
+     * isUndefined(Boolean(false));         // false
+     * isUndefined(Boolean("true"));        // false
+     * isUndefined(Boolean("false"));       // false
+     * isUndefined(new RegExp(""));         // false
+     * isUndefined(new ArrayBuffer(0));     // false
+     * isUndefined(new Error("Test Error"));// false
+     * isUndefined(new TypeError("Test TypeError"));    // false
+     * isUndefined(new TestError("Test TestError"));    // false
+     * isUndefined(_dummyError());          // false
+     * isUndefined(Promise.reject());       // false
+     * isUndefined(Promise.resolve());      // false
+     * isUndefined(new Promise(() => {}));  // false
+     * isUndefined(_simplePromise());       // false
+     * isUndefined(_simplePromiseLike());   // false
+     * isUndefined(Object.create(null));    // false
+     * isUndefined(polyObjCreate(null));    // false
+     * ```
+     */
+    function isUndefined(value: any): boolean;
+
     /**
      * Is the provided W3c span id (aka. parent id) a valid string representation, it must be a 16-character
      * string of lowercase hexadecimal characters, for example, 00f067aa0ba902b7.
@@ -2590,6 +3450,120 @@ declare namespace ApplicationInsights {
         removed?: IPlugin[];
     }
 
+    /**
+     * A Timer handler which is returned from {@link scheduleTimeout} which contains functions to
+     * cancel or restart (refresh) the timeout function.
+     *
+     * @since 0.4.4
+     * @group Timer
+     */
+    interface ITimerHandler {
+        /**
+         * Cancels a timeout that was previously scheduled, after calling this function any previously
+         * scheduled timer will not execute.
+         * @example
+         * ```ts
+         * let theTimer = scheduleTimeout(...);
+         * theTimer.cancel();
+         * ```
+         */
+        cancel(): void;
+        /**
+         * Reschedules the timer to call its callback at the previously specified duration
+         * adjusted to the current time. This is useful for refreshing a timer without allocating
+         * a new JavaScript object.
+         *
+         * Using this on a timer that has already called its callback will reactivate the timer.
+         * Calling on a timer that has not yet executed will just reschedule the current timer.
+         * @example
+         * ```ts
+         * let theTimer = scheduleTimeout(...);
+         * // The timer will be restarted (if already executed) or rescheduled (if it has not yet executed)
+         * theTimer.refresh();
+         * ```
+         */
+        refresh(): ITimerHandler;
+        /**
+         * When called, requests that the event loop not exit so long when the ITimerHandler is active.
+         * Calling timer.ref() multiple times will have no effect. By default, all ITimerHandler objects
+         * will create "ref'ed" instances, making it normally unnecessary to call timer.ref() unless
+         * timer.unref() had been called previously.
+         * @since 0.7.0
+         * @returns the ITimerHandler instance
+         * @example
+         * ```ts
+         * let theTimer = createTimeout(...);
+         *
+         * // Make sure the timer is referenced (the default) so that the runtime (Node) does not terminate
+         * // if there is a waiting referenced timer.
+         * theTimer.ref();
+         * ```
+         */
+        ref(): this;
+        /**
+         * When called, the any active ITimerHandler instance will not require the event loop to remain
+         * active (Node.js). If there is no other activity keeping the event loop running, the process may
+         * exit before the ITimerHandler instance callback is invoked. Calling timer.unref() multiple times
+         * will have no effect.
+         * @since 0.7.0
+         * @returns the ITimerHandler instance
+         * @example
+         * ```ts
+         * let theTimer = createTimeout(...);
+         *
+         * // Unreference the timer so that the runtime (Node) may terminate if nothing else is running.
+         * theTimer.unref();
+         * ```
+         */
+        unref(): this;
+        /**
+         * If true, any running referenced `ITimerHandler` instance will keep the Node.js event loop active.
+         * @since 0.7.0
+         * @example
+         * ```ts
+         * let theTimer = createTimeout(...);
+         *
+         * // Unreference the timer so that the runtime (Node) may terminate if nothing else is running.
+         * theTimer.unref();
+         * let hasRef = theTimer.hasRef(); // false
+         *
+         * theTimer.ref();
+         * hasRef = theTimer.hasRef(); // true
+         * ```
+         */
+        hasRef(): boolean;
+        /**
+         * Gets or Sets a flag indicating if the underlying timer is currently enabled and running.
+         * Setting the enabled flag to the same as it's current value has no effect, setting to `true`
+         * when already `true` will not {@link ITimerHandler.refresh | refresh}() the timer.
+         * And setting to 'false` will {@link ITimerHandler.cancel | cancel}() the timer.
+         * @since 0.8.1
+         * @example
+         * ```ts
+         * let theTimer = createTimeout(...);
+         *
+         * // Check if enabled
+         * theTimer.enabled; // false
+         *
+         * // Start the timer
+         * theTimer.enabled = true;     // Same as calling refresh()
+         * theTimer.enabled; //true
+         *
+         * // Has no effect as it's already running
+         * theTimer.enabled = true;
+         *
+         * // Will refresh / restart the time
+         * theTimer.refresh()
+         *
+         * let theTimer = scheduleTimeout(...);
+         *
+         * // Check if enabled
+         * theTimer.enabled; // true
+         * ```
+         */
+        enabled: boolean;
+    }
+
     /**
      * This interface represents the components of a W3C traceparent header
      */
@@ -2804,7 +3778,24 @@ declare namespace ApplicationInsights {
         unload?(isAsync?: boolean): void | IPromise<void>;
     }
 
-    
+    /**
+     * Try to define get/set object property accessors for the target object/prototype, this will provide compatibility with
+     * existing API definition when run within an ES5+ container that supports accessors but still enable the code to be loaded
+     * and executed in an ES3 container, providing basic IE8 compatibility.
+     * @deprecated It is recommended that you use {@link objDefine} instead {@link objDefineAccessors} as this internally creates
+     * the {@link ObjDefinePropDescriptor} definition based on your provided arguments. And only using a minimum set of functions
+     * reduces your overall bundle size.
+     * @group Object
+     * @param target - The object on which to define the property.
+     * @param prop - The name of the property to be defined or modified.
+     * @param getProp - The getter function to wire against the getter.
+     * @param setProp - The setter function to wire against the setter.
+     * @param configurable - Can the value be changed, defaults to true
+     * @param enumerable - Should this get property be enumerable, defaults to true.
+     * @returns The object that was passed to the function
+     */
+    function objDefineAccessors<T, V = any>(target: T, prop: PropertyKey, getProp?: (() => V) | null, setProp?: ((v: V) => void) | null, configurable?: boolean, enumerable?: boolean): T;
+
     /**
      * Pass in the objects to merge as arguments, this will only "merge" (extend) properties that are owned by the object.
      * It will NOT merge inherited or non-enumerable properties.
@@ -2819,11 +3810,125 @@ declare namespace ApplicationInsights {
 
     function objExtend<T1, T2, T3, T4, T5, T6>(obj1?: T1, obj2?: T2, obj3?: T3, obj4?: T4, obj5?: T5, obj6?: T6): T1 & T2 & T3 & T4 & T5 & T6;
 
-    
-    
-    
-    
-    
+    /**
+     * Calls the provided `callbackFn` function once for each key in an object. This is equivelent to `arrForEach(Object.keys(theObject), callbackFn)` or
+     * if not using the array helper `Object.keys(theObject).forEach(callbackFn)` except that this helper avoid creating a temporary of the object
+     * keys before iterating over them and like the `arrForEach` helper you CAN stop or break the iteration by returning -1 from the `callbackFn` function.
+     * @group Object
+     * @typeParam T - The object type
+     * @param callbackfn  A function that accepts up to two arguments, the key name and the current value of the property represented by the key.
+     * @param thisArg  [Optional] An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, null or undefined
+     * the object will be used as the this value.
+     * @example
+     * ```ts
+     * function performAction<T>(target: T, source: any) {
+     *    if (!isNullOrUndefined(source)) {
+     *        objForEachKey(source, (key, value) => {
+     *            // Set the target with a reference to the same value with the same name
+     *            target[key] = value;
+     *        });
+     *    }
+     *
+     *    return target;
+     * }
+     * ```
+     */
+    function objForEachKey<T>(theObject: T, callbackfn: (key: string, value: T[keyof T]) => void | number, thisArg?: any): void;
+
+    /**
+     * The `objFreeze()` method freezes an object. A frozen object can no longer be changed; freezing an object
+     * prevents new properties from being added to it, existing properties from being removed, prevents changing the
+     * enumerability, configurability, or writability of existing properties, and prevents the values of existing
+     * properties from being changed. In addition, freezing an object also prevents its prototype from being changed.
+     * `objFreeze()` returns the same object that was passed in.
+     *
+     * Nothing can be added to or removed from the properties set of a frozen object. Any attempt to do so will fail,
+     * either silently or by throwing a TypeError exception (most commonly, but not exclusively, when in strict mode).
+     *
+     * For data properties of a frozen object, values cannot be changed, the writable and configurable attributes are
+     * set to false. Accessor properties (getters and setters) work the same (and still give the illusion that you are
+     * changing the value). Note that values that are objects can still be modified, unless they are also frozen. As
+     * an object, an array can be frozen; after doing so, its elements cannot be altered and no elements can be added
+     * to or removed from the array.
+     *
+     * `objFreeze()` returns the same object that was passed into the function. It does not create a frozen copy.
+     * @group Object
+     * @param value - The object to freeze.
+     * @returns The object that was passed to the function.
+     */
+    const objFreeze: <T>(value: T) => T;
+
+    /**
+     * The `objKeys()` method returns an array of a given object's own enumerable property names, iterated in
+     * the same order that a normal loop would.
+     *
+     * objKeys() returns an array whose elements are strings corresponding to the enumerable properties found
+     * directly upon object. The ordering of the properties is the same as that given by looping over the
+     * properties of the object manually.
+     * @group Object
+     * @param value - The object to obtain a copy of the keys from
+     * @returns An array of the properties names for the value object.
+     * @example
+     * ```ts
+     * // simple array
+     * const arr = ['a', 'b', 'c'];
+     * console.log(objKeys(arr)); // console: ['0', '1', '2']
+     *
+     * // array-like object
+     * const obj = { 0: 'a', 1: 'b', 2: 'c' };
+     * console.log(objKeys(obj)); // console: ['0', '1', '2']
+     *
+     * // array-like object with random key ordering
+     * const anObj = { 100: 'a', 2: 'b', 7: 'c' };
+     * console.log(objKeys(anObj)); // console: ['2', '7', '100']
+     *
+     * // getFoo is a property which isn't enumerable
+     * const myObj = objCreate({}, {
+     *   getFoo: {
+     *     value() { return this.foo; }
+     *   }
+     * });
+     * myObj.foo = 1;
+     * console.log(objKeys(myObj)); // console: ['foo']
+     * ```
+     */
+    const objKeys: (value: any) => string[];
+
+    /**
+     * The `objSeal()` method seals an object, preventing new properties from being added to it and marking all
+     * existing properties as non-configurable. Values of present properties can still be changed as long as they
+     * are writable.
+     * @group Object
+     * @param value - The object which should be sealed.
+     * @returns The object being sealed.
+     */
+    const objSeal: <T>(value: T) => T;
+
+    /**
+     * The `objToString()` method returns a string representing the object. This explicitly
+     * always calls the `Object.prototype.toString()` method.
+     *
+     * An object's toString() method is most commonly invoked when that object undergoes:
+     * - explicit type conversion to a string (for example, String(myObject))
+     * - implicit type coercion into a string (for example, myObject + "hello world")
+     *
+     * @group Object
+     * @param value - The object to be converted into a string
+     * @returns A string representation of the object
+     * @example
+     * ```ts
+     * objToString(new Date()); // [object Date]
+     * objToString(new String()); // [object String]
+     *
+     * // Math has its Symbol.toStringTag
+     * objToString(Math); // [object Math]
+     *
+     * objToString(undefined); // [object Undefined]
+     * objToString(null); // [object Null]
+     * ```
+     */
+    function objToString(value: any): string;
+
     type OnCompleteCallback = (status: number, headers: {
         [headerName: string]: string;
     }, response?: string) => void;
@@ -2930,7 +4035,23 @@ declare namespace ApplicationInsights {
         getCtx(key: string): any;
     }
 
-    
+    /**
+     * Returns the number of milliseconds that has elapsed since the time origin, if
+     * the runtime does not support the `performance` API it will fallback to return
+     * the number of milliseconds since the unix epoch.
+     *
+     * @since 0.4.4
+     * @group Timer
+     *
+     * @returns The number of milliseconds as a `DOMHighResTimeStamp` double value or
+     * an integer depending on the runtime.
+     * @example
+     * ```ts
+     * let now = perfNow();
+     * ```
+     */
+    function perfNow(): number;
+
     /**
      * This class will be removed!
      * @deprecated use createProcessTelemetryContext() instead
@@ -3050,6 +4171,13 @@ declare namespace ApplicationInsights {
      */
     function randomValue(maxValue: number): number;
 
+    /**
+     * This defines the handler function for when a promise is rejected.
+     * @param value This is the value passed as part of resolving the Promise
+     * @return This may return a value, another Promise or void. @see {@link IPromise.then} for how the value is handled.
+     */
+    type RejectedPromiseHandler<T = never> = (((reason: any) => T | IPromise<T> | PromiseLike<T>) | undefined | null);
+
     /**
      * Trys to remove event handler(s) for the specified event/namespace to the window, body and document
      * @param eventName - {string} - The name of the event, with optional namespaces or just the namespaces,
@@ -3096,6 +4224,13 @@ declare namespace ApplicationInsights {
      */
     function removePageUnloadEventListener(listener: any, evtNamespace?: string | string[]): void;
 
+    /**
+     * This defines the handler function for when a promise is resolved.
+     * @param value This is the value passed as part of resolving the Promise
+     * @return This may return a value, another Promise or void. @see {@link IPromise.then} for how the value is handled.
+     */
+    type ResolvedPromiseHandler<T, TResult1 = T> = (((value: T) => TResult1 | IPromise<TResult1> | PromiseLike<TResult1>) | undefined | null);
+
     /**
      * Run the unload function of the target object if it exists
      * @param target - The target object that contains the unload function
@@ -3208,13 +4343,48 @@ declare namespace ApplicationInsights {
      */
     function strContains(value: string, search: string): boolean;
 
-    
-    
-    
-    
-    
-    
-    
+    /**
+     * This method lets you determine whether or not a string ends with another string. This method is case-sensitive.
+     * @group String
+     * @param value - The value to be checked
+     * @param searchString - The characters to be searched for at the end of `value` string.
+     * @param length - If provided, it is used as the length of `value`. Defaults to value.length.
+     */
+    const strEndsWith: (value: string, searchString: string, length?: number) => boolean;
+
+    const strFunction = "function";
+
+    const strObject = "object";
+
+    const strPrototype = "prototype";
+
+    /**
+     * This method lets you determine whether or not a string begins with another string. This method is case-sensitive.
+     * @group String
+     * @param value - The value to be checked
+     * @param searchString - The characters to be searched for at the start of the string
+     * @param position - [Optional] The position in this string at which to begin searching for `searchString`.
+     * Defaults to 0
+     * @returns `true` if the given characters are found at the beginning of the string; otherwise, `false`.
+     */
+    const strStartsWith: (value: string, searchString: string, length?: number) => boolean;
+
+    /**
+     * The trim() method removes whitespace from both ends of a string and returns a new string,
+     * without modifying the original string. Whitespace in this context is all the whitespace
+     * characters (space, tab, no-break space, etc.) and all the line terminator characters
+     * (LF, CR, etc.).
+     * @group String
+     * @param value - The string value to be trimmed.
+     * @returns A new string representing str stripped of whitespace from both its beginning and end.
+     * If neither the beginning or end of str has any whitespace, a new string is still returned (essentially
+     * a copy of str), with no exception being thrown.
+     * To return a new string with whitespace trimmed from just one end, use `strTrimStart()` or `strTrimEnd()`.
+     */
+    const strTrim: (value: string) => string;
+
+    const strUndefined = "undefined";
+
     interface Tags {
         [key: string]: any;
     }
@@ -3265,6 +4435,14 @@ declare namespace ApplicationInsights {
         PluginRemoved = 32
     }
 
+    /**
+     * Test hook for setting the maximum number of unload hooks and calling a monitor function when the hooks are added or removed
+     * This allows for automatic test failure when the maximum number of unload hooks is exceeded
+     * @param maxHooks - The maximum number of unload hooks
+     * @param addMonitor - The monitor function to call when hooks are added or removed
+     */
+    function _testHookMaxUnloadHooksCb(maxHooks?: number, addMonitor?: (state: string, hooks: Array<ILegacyUnloadHook | IUnloadHook>) => void): void;
+
     /**
      * Throws an Aggregation Error which includes all of the errors that led to this error occurring
      * @param message - The message describing the aggregation error (the sourceError details are added to this)
@@ -3272,7 +4450,13 @@ declare namespace ApplicationInsights {
      */
     function throwAggregationError(message: string, sourceErrors: any[]): never;
 
-    
+    /**
+     * Throw an error exception with the specified optional message
+     * @group Error
+     * @param message
+     */
+    function throwError(message?: string): never;
+
     /**
      * This is a helper method which will call throwInternal on the passed logger, will throw exceptions in
      * debug mode or attempt to log the error as a console warning. This helper is provided mostly to better
@@ -3336,5 +4520,4 @@ declare namespace ApplicationInsights {
 
     type WatcherFunction<T = IConfiguration> = (details: IWatchDetails<T>) => void;
 
-    
 }