@microsoft/applicationinsights-core-js 2.7.5-nightly.2204-03 → 2.7.6

package/dist/applicationinsights-core-js.d.ts

@@ -1,5 +1,5 @@
 /*
- * Microsoft Application Insights Core Javascript SDK, 2.7.5-nightly.2204-03
+ * Microsoft Application Insights Core Javascript SDK, 2.7.6
  * Copyright (c) Microsoft and contributors. All rights reserved.
  *
  * Microsoft Application Insights Team
@@ -14,61 +14,39 @@ declare namespace ApplicationInsights {
     import { strShimPrototype as strPrototype } from '@microsoft/applicationinsights-shims';
     import { strShimUndefined as strUndefined } from '@microsoft/applicationinsights-shims';
 
-    /**
-     * 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
-     * @param target - The EventTarget that has registered events
-     * @param eventName - [Optional] The name of the event to return the registered handlers and full name (with namespaces)
-     * @param evtNamespace - [Optional] Additional namespace(s) to append to the event listeners so they can be uniquely identified and removed based on this namespace,
-     * if the eventName also includes a namespace the namespace(s) are merged into a single namespace
-     */
-    function __getRegisteredEvents(target: any, eventName?: string, evtNamespace?: string | string[]): _IRegisteredEvents[];
-
     /**
      * Trys to add an event handler for the specified event to the window, body and document
      * @param eventName {string} - The name of the event
      * @param callback {any} - The callback function that needs to be executed for the given event
-     * @param evtNamespace - [Optional] Namespace(s) to append to the event listeners so they can be uniquely identified and removed based on this namespace.
      * @return {boolean} - true if the handler was successfully added
      */
-    function addEventHandler(eventName: string, callback: any, evtNamespace?: string | string[] | null): boolean;
+    function addEventHandler(eventName: string, callback: any): boolean;
 
     /**
      * Bind the listener to the array of events
      * @param events An string array of event names to bind the listener to
      * @param listener The event callback to call when the event is triggered
      * @param excludeEvents - [Optional] An array of events that should not be hooked (if possible), unless no other events can be.
-     * @param evtNamespace - [Optional] Namespace(s) to append to the event listeners so they can be uniquely identified and removed based on this namespace.
      * @returns true - when at least one of the events was registered otherwise false
      */
-    function addEventListeners(events: string[], listener: any, excludeEvents?: string[], evtNamespace?: string | string[]): boolean;
+    function addEventListeners(events: string[], listener: any, excludeEvents?: string[]): boolean;
 
     /**
-     * Listen to the pagehide and visibility changing to 'hidden' events, because the 'visibilitychange' uses
-     * an internal proxy to detect the visibility state you SHOULD use a unique namespace when if you plan to call
-     * removePageShowEventListener as the remove ignores the listener argument for the 'visibilitychange' event.
+     * Listen to the pagehide and visibility changing to 'hidden' events
      * @param listener - The event callback to call when a page hide event is triggered
      * @param excludeEvents - [Optional] An array of events that should not be hooked (if possible), unless no other events can be.
-     * @param evtNamespace - [Optional] A Namespace to append to the event listeners so they can be uniquely identified and removed
-     * based on this namespace. This call also adds an additional unique "pageshow" namespace to the events
-     * so that only the matching "removePageHideEventListener" can remove these events.
      * Suggestion: pass as true if you are also calling addPageUnloadEventListener as that also hooks pagehide
      * @returns true - when at least one of the events was registered otherwise false
      */
-    function addPageHideEventListener(listener: any, excludeEvents?: string[] | null, evtNamespace?: string | string[] | null): boolean;
+    function addPageHideEventListener(listener: any, excludeEvents?: string[]): boolean;
 
     /**
-     * Listen to the pageshow and visibility changing to 'visible' events, because the 'visibilitychange' uses
-     * an internal proxy to detect the visibility state you SHOULD use a unique namespace when if you plan to call
-     * removePageShowEventListener as the remove ignores the listener argument for the 'visibilitychange' event.
+     * Listen to the pageshow and visibility changing to 'visible' events
      * @param listener - The event callback to call when a page is show event is triggered
      * @param excludeEvents - [Optional] An array of events that should not be hooked (if possible), unless no other events can be.
-     * @param evtNamespace - [Optional/Recommended] A Namespace to append to the event listeners so they can be uniquely
-     * identified and removed based on this namespace. This call also adds an additional unique "pageshow" namespace to the events
-     * so that only the matching "removePageShowEventListener" can remove these events.
      * @returns true - when at least one of the events was registered otherwise false
      */
-    function addPageShowEventListener(listener: any, excludeEvents?: string[] | null, evtNamespace?: string | string[] | null): boolean;
+    function addPageShowEventListener(listener: any, excludeEvents?: string[]): boolean;
 
     /**
      * Listen to the 'beforeunload', 'unload' and 'pagehide' events which indicates a page unload is occurring,
@@ -78,15 +56,34 @@ declare namespace ApplicationInsights {
      * need to listen to the 'addPageHideEventListener' and 'addPageShowEventListener' events.
      * @param listener - The event callback to call when a page unload event is triggered
      * @param excludeEvents - [Optional] An array of events that should not be hooked, unless no other events can be.
-     * @param evtNamespace - [Optional] Namespace(s) to append to the event listeners so they can be uniquely identified and removed based on this namespace.
      * @returns true - when at least one of the events was registered otherwise false
      */
-    function addPageUnloadEventListener(listener: any, excludeEvents?: string[], evtNamespace?: string | string[]): boolean;
+    function addPageUnloadEventListener(listener: any, excludeEvents?: string[]): boolean;
 
     class AppInsightsCore extends BaseCore implements IAppInsightsCore {
         constructor();
         initialize(config: IConfiguration, extensions: IPlugin[], logger?: IDiagnosticLogger, notificationManager?: INotificationManager): void;
         track(telemetryItem: ITelemetryItem): void;
+        /**
+         * Adds a notification listener. The SDK calls methods on the listener when an appropriate notification is raised.
+         * The added plugins must raise notifications. If the plugins do not implement the notifications, then no methods will be
+         * called.
+         * @param {INotificationListener} listener - An INotificationListener object.
+         */
+        addNotificationListener(listener: INotificationListener): void;
+        /**
+         * Removes all instances of the listener.
+         * @param {INotificationListener} listener - INotificationListener to remove.
+         */
+        removeNotificationListener(listener: INotificationListener): void;
+        /**
+         * Periodically check logger.queue for
+         */
+        pollInternalLogs(eventName?: string): number;
+        /**
+         * Periodically check logger.queue for
+         */
+        stopPollingInternalLogs(): void;
     }
 
     function areCookiesSupported(logger?: IDiagnosticLogger): any;
@@ -99,7 +96,7 @@ declare namespace ApplicationInsights {
      * @param callbackfn  A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the array. It can return -1 to break out of the loop
      * @param thisArg  [Optional] An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
      */
-    function arrForEach<T = any>(arr: T[], callbackfn: (value: T, index?: number, array?: T[]) => undefined | void | number, thisArg?: any): void;
+    function arrForEach<T>(arr: T[], callbackfn: (value: T, index?: number, array?: T[]) => void | number, thisArg?: any): void;
 
     /**
      * Returns the index of the first occurrence of a value in an array. This helper exists to avoid adding a polyfil for older browsers
@@ -134,7 +131,7 @@ declare namespace ApplicationInsights {
     /**
      * 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.
-     * @param eventNameWithoutOn String that specifies any of the standard DHTML Events without "on" prefix and optional (dot "." prefixed) namespaces "click" "click.mynamespace".
+     * @param eventNameWithoutOn String that specifies any of the standard DHTML Events without "on" prefix
      * @param handlerRef Pointer that specifies the function to call when event fires
      * @param useCapture [Optional] Defaults to false
      * @returns True if the function was bound successfully to the event, otherwise false
@@ -153,18 +150,6 @@ declare namespace ApplicationInsights {
         track(telemetryItem: ITelemetryItem): void;
         getProcessTelContext(): IProcessTelemetryContext;
         getNotifyMgr(): INotificationManager;
-        /**
-         * Adds a notification listener. The SDK calls methods on the listener when an appropriate notification is raised.
-         * The added plugins must raise notifications. If the plugins do not implement the notifications, then no methods will be
-         * called.
-         * @param {INotificationListener} listener - An INotificationListener object.
-         */
-        addNotificationListener(listener: INotificationListener): void;
-        /**
-         * Removes all instances of the listener.
-         * @param {INotificationListener} listener - INotificationListener to remove.
-         */
-        removeNotificationListener(listener: INotificationListener): void;
         /**
          * Get the current cookie manager for this instance
          */
@@ -177,67 +162,7 @@ declare namespace ApplicationInsights {
         getPerfMgr(): IPerfManager;
         setPerfMgr(perfMgr: IPerfManager): void;
         eventCnt(): number;
-        /**
-         * Periodically check logger.queue for
-         */
-        pollInternalLogs(eventName?: string): number;
-        /**
-         * Periodically check logger.queue for
-         */
-        stopPollingInternalLogs(): void;
-        /**
-         * Add a telemetry processor to decorate or drop telemetry events.
-         * @param telemetryInitializer - The Telemetry Initializer function
-         * @returns - A ITelemetryInitializerHandler to enable the initializer to be removed
-         */
-        addTelemetryInitializer(telemetryInitializer: TelemetryInitializerFunction): ITelemetryInitializerHandler | void;
-        /**
-         * Unload and Tear down the SDK and any initialized plugins, after calling this the SDK will be considered
-         * to be un-initialized and non-operational, re-initializing the SDK should only be attempted if the previous
-         * unload call return `true` stating that all plugins reported that they also unloaded, the recommended
-         * approach is to create a new instance and initialize that instance.
-         * This is due to possible unexpected side effects caused by plugins not supporting unload / teardown, unable
-         * to successfully remove any global references or they may just be completing the unload process asynchronously.
-         * @param isAsync - Can the unload be performed asynchronously (default)
-         * @param unloadComplete - An optional callback that will be called once the unload has completed
-         * @param cbTimeout - An optional timeout to wait for any flush operations to complete before proceeding with the unload. Defaults to 5 seconds.
-         */
-        unload(isAsync?: boolean, unloadComplete?: (unloadState: ITelemetryUnloadState) => void, cbTimeout?: number): void;
-        getPlugin<T extends IPlugin = IPlugin>(pluginIdentifier: string): ILoadedPlugin<T>;
-        /**
-         * Add a new plugin to the installation
-         * @param plugin - The new plugin to add
-         * @param replaceExisting - should any existing plugin be replaced, default is false
-         * @param doAsync - Should the add be performed asynchronously
-         * @param addCb - [Optional] callback to call after the plugin has been added
-         */
-        addPlugin<T extends IPlugin = ITelemetryPlugin>(plugin: T, replaceExisting?: boolean, doAsync?: boolean, addCb?: (added?: boolean) => void): void;
-        /**
-         * Returns the unique event namespace that should be used
-         */
-        evtNamespace(): string;
-        /**
-         * Add an unload handler that will be called when the SDK is being unloaded
-         * @param handler - the handler
-         */
-        addUnloadCb(handler: UnloadHandler): void;
-        /**
-         * Flush and send any batched / cached data immediately
-         * @param async - send data asynchronously when true (defaults to true)
-         * @param callBack - if specified, notify caller when send is complete, the channel should return true to indicate to the caller that it will be called.
-         * If the caller doesn't return true the caller should assume that it may never be called.
-         * @param sendReason - specify the reason that you are calling "flush" defaults to ManualFlush (1) if not specified
-         * @returns - true if the callback will be return after the flush is complete otherwise the caller should assume that any provided callback will never be called
-         */
-        flush(isAsync?: boolean, callBack?: (flushComplete?: boolean) => void, sendReason?: SendRequestReason): void;
         protected releaseQueue(): void;
-        /**
-         * Hook for Core extensions to allow them to update their own configuration before updating all of the plugins.
-         * @param updateCtx - The plugin update context
-         * @param updateState - The Update State
-         * @returns boolean - True means the extension class will call updateState otherwise the Core will
-         */
-        protected _updateHook?(updateCtx: IProcessTelemetryUpdateContext, updateState: ITelemetryUpdateState): void | boolean;
     }
 
     /**
@@ -246,13 +171,6 @@ declare namespace ApplicationInsights {
      * implementation so that new default implementations can be added without breaking all plugins.
      */
     abstract class BaseTelemetryPlugin implements ITelemetryPlugin {
-        identifier: string;
-        version?: string;
-        /**
-         * Holds the core instance that was used during initialization
-         */
-        core: IAppInsightsCore;
-        priority: number;
         /**
          * Call back for telemetry processing before it it is sent
          * @param env - This is the current event being reported
@@ -274,6 +192,13 @@ declare namespace ApplicationInsights {
          * Returns whether the plugin has been initialized
          */
         isInitialized: () => boolean;
+        identifier: string;
+        version?: string;
+        /**
+         * Holds the core instance that was used during initialization
+         */
+        core: IAppInsightsCore;
+        priority: number;
         /**
          * Helper to return the current IProcessTelemetryContext, if the passed argument exists this just
          * returns that value (helps with minification for callers), otherwise it will return the configured
@@ -286,51 +211,12 @@ declare namespace ApplicationInsights {
          */
         protected setInitialized: (isInitialized: boolean) => void;
         /**
-         * Teardown / Unload hook to allow implementations to perform some additional unload operations before the BaseTelemetryPlugin
-         * finishes it's removal.
-         * @param unloadCtx - This is the context that should be used during unloading.
-         * @param unloadState - The details / state of the unload process, it holds details like whether it should be unloaded synchronously or asynchronously and the reason for the unload.
-         * @param asyncCallback - An optional callback that the plugin must call if it returns true to inform the caller that it has completed any async unload/teardown operations.
-         * @returns boolean - true if the plugin has or will call asyncCallback, this allows the plugin to perform any asynchronous operations.
+         * Internal helper to initialize the instance
          */
-        protected _doTeardown?: (unloadCtx?: IProcessTelemetryUnloadContext, unloadState?: ITelemetryUnloadState, asyncCallback?: () => void) => void | boolean;
-        /**
-         * Extension hook to allow implementations to perform some additional update operations before the BaseTelemetryPlugin finishes it's removal
-         * @param updateCtx - This is the context that should be used during updating.
-         * @param updateState - The details / state of the update process, it holds details like the current and previous configuration.
-         * @param asyncCallback - An optional callback that the plugin must call if it returns true to inform the caller that it has completed any async update operations.
-         * @returns boolean - true if the plugin has or will call asyncCallback, this allows the plugin to perform any asynchronous operations.
-         */
-        protected _doUpdate?: (updateCtx?: IProcessTelemetryUpdateContext, updateState?: ITelemetryUpdateState, asyncCallback?: () => void) => void | boolean;
+        private _baseTelInit;
         constructor();
         initialize(config: IConfiguration, core: IAppInsightsCore, extensions: IPlugin[], pluginChain?: ITelemetryPluginChain): void;
-        /**
-         * Tear down the plugin and remove any hooked value, the plugin should be removed so that it is no longer initialized and
-         * therefore could be re-initialized after being torn down. The plugin should ensure that once this has been called any further
-         * processTelemetry calls are ignored and it just calls the processNext() with the provided context.
-         * @param unloadCtx - This is the context that should be used during unloading.
-         * @param unloadState - The details / state of the unload process, it holds details like whether it should be unloaded synchronously or asynchronously and the reason for the unload.
-         * @returns boolean - true if the plugin has or will call processNext(), this for backward compatibility as previously teardown was synchronous and returned nothing.
-         */
-        teardown(unloadCtx?: IProcessTelemetryUnloadContext, unloadState?: ITelemetryUnloadState): void | boolean;
         abstract processTelemetry(env: ITelemetryItem, itemCtx?: IProcessTelemetryContext): void;
-        /**
-         * The the plugin should re-evaluate configuration and update any cached configuration settings.
-         * @param updateCtx - This is the context that should be used during updating.
-         * @param updateState - The details / state of the update process, it holds details like the current and previous configuration.
-         * @returns boolean - true if the plugin has or will call updateCtx.processNext(), this allows the plugin to perform any asynchronous operations.
-         */
-        update(updateCtx: IProcessTelemetryUpdateContext, updateState: ITelemetryUpdateState): void | boolean;
-        /**
-         * Add an unload handler that will be called when the SDK is being unloaded
-         * @param handler - the handler
-         */
-        protected _addUnloadCb(handler: UnloadHandler): void;
-        /**
-         * Add this hook so that it is automatically removed during unloading
-         * @param hooks - The single hook or an array of IInstrumentHook objects
-         */
-        protected _addHook(hooks: IInstrumentHook | IInstrumentHook[]): void;
     }
 
     /**
@@ -356,29 +242,6 @@ declare namespace ApplicationInsights {
 
     function createCookieMgr(rootConfig?: IConfiguration, logger?: IDiagnosticLogger): ICookieMgr;
 
-    /**
-     * Create an enum style object which has both the key => value and value => key mappings
-     * @param values - The values to populate on the new object
-     * @returns
-     */
-    function createEnumStyle<T>(values: T): T;
-
-    /**
-     * Creates a new Telemetry Item context with the current config, core and plugin execution chain
-     * @param plugins - The plugin instances that will be executed
-     * @param config - The current config
-     * @param core - The current core instance
-     * @param startAt - Identifies the next plugin to execute, if null there is no "next" plugin and if undefined it should assume the start of the chain
-     */
-    function createProcessTelemetryContext(telemetryChain: ITelemetryPluginChain | null, config: IConfiguration, core: IAppInsightsCore, startAt?: IPlugin): IProcessTelemetryContext;
-
-    function createUniqueNamespace(name: string, includeVersion?: boolean): string;
-
-    function createUnloadHandlerContainer(): {
-        add: (handler: UnloadHandler) => void;
-        run: (unloadCtx: IProcessTelemetryUnloadContext, unloadState: ITelemetryUnloadState) => void;
-    };
-
     /**
      * Return the current time via the Date now() function (if available) and falls back to (new Date()).getTime() if now() is unavailable (IE8 or less)
      * https://caniuse.com/#search=Date.now
@@ -395,11 +258,8 @@ declare namespace ApplicationInsights {
     /**
      * Removes an event handler for the specified event
      * @param Object to remove the event from
-     * @param eventNameWithoutOn {string} - The name of the event, with optional namespaces or just the namespaces,
-     * such as "click", "click.mynamespace" or ".mynamespace"
-     * @param handlerRef {any} - The callback function that needs to be removed from the given event, when using a
-     * namespace (with or without a qualifying event) this may be null to remove all previously attached event handlers
-     * otherwise this will only remove events with this specific handler.
+     * @param eventNameWithoutOn {string} - The name of the event
+     * @param handlerRef {any} - The callback function that needs to be executed for the given event
      * @param useCapture [Optional] Defaults to false
      */
     function detachEvent(obj: any, eventNameWithoutOn: string, handlerRef: any, useCapture?: boolean): void;
@@ -480,131 +340,8 @@ declare namespace ApplicationInsights {
      */
     function dumpObj(object: any): string;
 
-    const enum _eInternalMessageId {
-        BrowserDoesNotSupportLocalStorage = 0,
-        BrowserCannotReadLocalStorage = 1,
-        BrowserCannotReadSessionStorage = 2,
-        BrowserCannotWriteLocalStorage = 3,
-        BrowserCannotWriteSessionStorage = 4,
-        BrowserFailedRemovalFromLocalStorage = 5,
-        BrowserFailedRemovalFromSessionStorage = 6,
-        CannotSendEmptyTelemetry = 7,
-        ClientPerformanceMathError = 8,
-        ErrorParsingAISessionCookie = 9,
-        ErrorPVCalc = 10,
-        ExceptionWhileLoggingError = 11,
-        FailedAddingTelemetryToBuffer = 12,
-        FailedMonitorAjaxAbort = 13,
-        FailedMonitorAjaxDur = 14,
-        FailedMonitorAjaxOpen = 15,
-        FailedMonitorAjaxRSC = 16,
-        FailedMonitorAjaxSend = 17,
-        FailedMonitorAjaxGetCorrelationHeader = 18,
-        FailedToAddHandlerForOnBeforeUnload = 19,
-        FailedToSendQueuedTelemetry = 20,
-        FailedToReportDataLoss = 21,
-        FlushFailed = 22,
-        MessageLimitPerPVExceeded = 23,
-        MissingRequiredFieldSpecification = 24,
-        NavigationTimingNotSupported = 25,
-        OnError = 26,
-        SessionRenewalDateIsZero = 27,
-        SenderNotInitialized = 28,
-        StartTrackEventFailed = 29,
-        StopTrackEventFailed = 30,
-        StartTrackFailed = 31,
-        StopTrackFailed = 32,
-        TelemetrySampledAndNotSent = 33,
-        TrackEventFailed = 34,
-        TrackExceptionFailed = 35,
-        TrackMetricFailed = 36,
-        TrackPVFailed = 37,
-        TrackPVFailedCalc = 38,
-        TrackTraceFailed = 39,
-        TransmissionFailed = 40,
-        FailedToSetStorageBuffer = 41,
-        FailedToRestoreStorageBuffer = 42,
-        InvalidBackendResponse = 43,
-        FailedToFixDepricatedValues = 44,
-        InvalidDurationValue = 45,
-        TelemetryEnvelopeInvalid = 46,
-        CreateEnvelopeError = 47,
-        CannotSerializeObject = 48,
-        CannotSerializeObjectNonSerializable = 49,
-        CircularReferenceDetected = 50,
-        ClearAuthContextFailed = 51,
-        ExceptionTruncated = 52,
-        IllegalCharsInName = 53,
-        ItemNotInArray = 54,
-        MaxAjaxPerPVExceeded = 55,
-        MessageTruncated = 56,
-        NameTooLong = 57,
-        SampleRateOutOfRange = 58,
-        SetAuthContextFailed = 59,
-        SetAuthContextFailedAccountName = 60,
-        StringValueTooLong = 61,
-        StartCalledMoreThanOnce = 62,
-        StopCalledWithoutStart = 63,
-        TelemetryInitializerFailed = 64,
-        TrackArgumentsNotSpecified = 65,
-        UrlTooLong = 66,
-        SessionStorageBufferFull = 67,
-        CannotAccessCookie = 68,
-        IdTooLong = 69,
-        InvalidEvent = 70,
-        FailedMonitorAjaxSetRequestHeader = 71,
-        SendBrowserInfoOnUserInit = 72,
-        PluginException = 73,
-        NotificationException = 74,
-        SnippetScriptLoadFailure = 99,
-        InvalidInstrumentationKey = 100,
-        CannotParseAiBlobValue = 101,
-        InvalidContentBlob = 102,
-        TrackPageActionEventFailed = 103,
-        FailedAddingCustomDefinedRequestContext = 104,
-        InMemoryStorageBufferFull = 105
-    }
-
-    const enum eLoggingSeverity {
-        /**
-         * Error will be sent as internal telemetry
-         */
-        CRITICAL = 1,
-        /**
-         * Error will NOT be sent as internal telemetry, and will only be shown in browser console
-         */
-        WARNING = 2
-    }
-
     const EventHelper: IEventHelper;
 
-    /**
-     * Removes an event handler for the specified event
-     * @param Object to remove the event from
-     * @param eventName {string} - The name of the event, with optional namespaces or just the namespaces,
-     * such as "click", "click.mynamespace" or ".mynamespace"
-     * @param handlerRef {any} - The callback function that needs to be removed from the given event, when using a
-     * namespace (with or without a qualifying event) this may be null to remove all previously attached event handlers
-     * otherwise this will only remove events with this specific handler.
-     * @param evtNamespace - [Optional] Additional namespace(s) to append to the event listeners so they can be uniquely identified and removed based on this namespace,
-     * if the eventName also includes a namespace the namespace(s) are merged into a single namespace
-     * @param useCapture [Optional] Defaults to false
-     */
-    function eventOff<T>(target: T, eventName: string, handlerRef: any, evtNamespace?: string | string[] | null, useCapture?: boolean): void;
-
-    /**
-     * 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.
-     * @param eventName String that specifies any of the standard DHTML Events without "on" prefix, if may also include an optional (dot "." prefixed)
-     * namespaces "click" "click.mynamespace" in addition to specific namespaces.
-     * @param handlerRef Pointer that specifies the function to call when event fires
-     * @param evtNamespace - [Optional] Additional namespace(s) to append to the event listeners so they can be uniquely identified and removed based on this namespace,
-     * if the eventName also includes a namespace the namespace(s) are merged into a single namespace
-     * @param useCapture [Optional] Defaults to false
-     * @returns True if the function was bound successfully to the event, otherwise false
-     */
-    function eventOn<T>(target: T, eventName: string, handlerRef: any, evtNamespace?: string | string[] | null, useCapture?: boolean): boolean;
-
     /**
      * The EventsDiscardedReason enumeration contains a set of values that specify the reason for discarding an event.
      */
@@ -674,12 +411,6 @@ declare namespace ApplicationInsights {
      */
     function getExceptionName(object: any): string;
 
-    const enum GetExtCfgMergeType {
-        None = 0,
-        MergeDefaultOnly = 1,
-        MergeDefaultFromRootOrDefault = 2
-    }
-
     /**
      * Get the current global performance manager that will be used with no performance manager is supplied.
      * @returns - The current default manager
@@ -838,123 +569,12 @@ declare namespace ApplicationInsights {
          * @param {INotificationListener} listener - INotificationListener to remove.
          */
         removeNotificationListener?(listener: INotificationListener): void;
-        /**
-         * Add a telemetry processor to decorate or drop telemetry events.
-         * @param telemetryInitializer - The Telemetry Initializer function
-         * @returns - A ITelemetryInitializerHandler to enable the initializer to be removed
-         */
-        addTelemetryInitializer(telemetryInitializer: TelemetryInitializerFunction): ITelemetryInitializerHandler | void;
         pollInternalLogs?(eventName?: string): number;
         stopPollingInternalLogs?(): void;
         /**
          * Return a new instance of the IProcessTelemetryContext for processing events
          */
         getProcessTelContext(): IProcessTelemetryContext;
-        /**
-         * Unload and Tear down the SDK and any initialized plugins, after calling this the SDK will be considered
-         * to be un-initialized and non-operational, re-initializing the SDK should only be attempted if the previous
-         * unload call return `true` stating that all plugins reported that they also unloaded, the recommended
-         * approach is to create a new instance and initialize that instance.
-         * This is due to possible unexpected side effects caused by plugins not supporting unload / teardown, unable
-         * to successfully remove any global references or they may just be completing the unload process asynchronously.
-         * @param isAsync - Can the unload be performed asynchronously (default)
-         * @param unloadComplete - An optional callback that will be called once the unload has completed
-         * @param cbTimeout - An optional timeout to wait for any flush operations to complete before proceeding with the unload. Defaults to 5 seconds.
-         */
-        unload(isAsync?: boolean, unloadComplete?: (unloadState: ITelemetryUnloadState) => void, cbTimeout?: number): void;
-        /**
-         * Find and return the (first) plugin with the specified identifier if present
-         * @param pluginIdentifier
-         */
-        getPlugin<T extends IPlugin = IPlugin>(pluginIdentifier: string): ILoadedPlugin<T>;
-        /**
-         * Add a new plugin to the installation
-         * @param plugin - The new plugin to add
-         * @param replaceExisting - should any existing plugin be replaced, default is false
-         * @param doAsync - Should the add be performed asynchronously
-         * @param addCb - [Optional] callback to call after the plugin has been added
-         */
-        addPlugin<T extends IPlugin = ITelemetryPlugin>(plugin: T, replaceExisting?: boolean, doAsync?: boolean, addCb?: (added?: boolean) => void): void;
-        /**
-         * Returns the unique event namespace that should be used when registering events
-         */
-        evtNamespace(): string;
-        /**
-         * Add a handler that will be called when the SDK is being unloaded
-         * @param handler - the handler
-         */
-        addUnloadCb(handler: UnloadHandler): void;
-        /**
-         * Flush and send any batched / cached data immediately
-         * @param async - send data asynchronously when true (defaults to true)
-         * @param callBack - if specified, notify caller when send is complete, the channel should return true to indicate to the caller that it will be called.
-         * If the caller doesn't return true the caller should assume that it may never be called.
-         * @param sendReason - specify the reason that you are calling "flush" defaults to ManualFlush (1) if not specified
-         * @param cbTimeout - An optional timeout to wait for any flush operations to complete before proceeding with the unload. Defaults to 5 seconds.
-         * @returns - true if the callback will be return after the flush is complete otherwise the caller should assume that any provided callback will never be called
-         */
-        flush(isAsync?: boolean, callBack?: (flushComplete?: boolean) => void, sendReason?: SendRequestReason, cbTimeout?: number): boolean | void;
-    }
-
-    interface IBaseProcessingContext {
-        /**
-         * The current core instance for the request
-         */
-        core: () => IAppInsightsCore;
-        /**
-         * THe current diagnostic logger for the request
-         */
-        diagLog: () => IDiagnosticLogger;
-        /**
-         * Gets the current core config instance
-         */
-        getCfg: () => IConfiguration;
-        /**
-         * Gets the named extension config
-         */
-        getExtCfg: <T>(identifier: string, defaultValue?: T | any, mergeDefault?: GetExtCfgMergeType) => T;
-        /**
-         * Gets the named config from either the named identifier extension or core config if neither exist then the
-         * default value is returned
-         * @param identifier The named extension identifier
-         * @param field The config field name
-         * @param defaultValue The default value to return if no defined config exists
-         */
-        getConfig: (identifier: string, field: string, defaultValue?: number | string | boolean | string[] | RegExp[] | Function) => number | string | boolean | string[] | RegExp[] | Function;
-        /**
-         * Helper to allow plugins to check and possibly shortcut executing code only
-         * required if there is a nextPlugin
-         */
-        hasNext: () => boolean;
-        /**
-         * Returns the next configured plugin proxy
-         */
-        getNext: () => ITelemetryPluginChain;
-        /**
-         * Helper to set the next plugin proxy
-         */
-        setNext: (nextCtx: ITelemetryPluginChain) => void;
-        /**
-         * Synchronously iterate over the context chain running the callback for each plugin, once
-         * every plugin has been executed via the callback, any associated onComplete will be called.
-         * @param callback - The function call for each plugin in the context chain
-         */
-        iterate: <T extends ITelemetryPlugin = ITelemetryPlugin>(callback: (plugin: T) => void) => void;
-        /**
-         * Set the function to call when the current chain has executed all processNext or unloadNext items.
-         * @param onComplete - The onComplete to call
-         * @param that - The "this" value to use for the onComplete call, if not provided or undefined defaults to the current context
-         * @param args - Any additional arguments to pass to the onComplete function
-         */
-        onComplete: (onComplete: () => void, that?: any, ...args: any[]) => void;
-        /**
-         * Create a new context using the core and config from the current instance, returns a new instance of the same type
-         * @param plugins - The execution order to process the plugins, if null or not supplied
-         *                  then the current execution order will be copied.
-         * @param startAt - The plugin to start processing from, if missing from the execution
-         *                  order then the next plugin will be NOT set.
-         */
-        createNew: (plugins?: IPlugin[] | ITelemetryPluginChain, startAt?: IPlugin) => IBaseProcessingContext;
     }
 
     /**
@@ -970,23 +590,15 @@ declare namespace ApplicationInsights {
          */
         resume(): void;
         /**
-         * Tear down the plugin and remove any hooked value, the plugin should be removed so that it is no longer initialized and
-         * therefore could be re-initialized after being torn down. The plugin should ensure that once this has been called any further
-         * processTelemetry calls are ignored and it just calls the processNext() with the provided context.
-         * @param unloadCtx - This is the context that should be used during unloading.
-         * @param unloadState - The details / state of the unload process, it holds details like whether it should be unloaded synchronously or asynchronously and the reason for the unload.
-         * @returns boolean - true if the plugin has or will call processNext(), this for backward compatibility as previously teardown was synchronous and returned nothing.
+         * Tear down transmission pipeline
          */
-        teardown: (unloadCtx?: IProcessTelemetryUnloadContext, unloadState?: ITelemetryUnloadState) => void | boolean;
+        teardown(): void;
         /**
          * Flush to send data immediately; channel should default to sending data asynchronously
-         * @param async - send data asynchronously when true
-         * @param callBack - if specified, notify caller when send is complete, the channel should return true to indicate to the caller that it will be called.
-         * If the caller doesn't return true the caller should assume that it may never be called.
-         * @param sendReason - specify the reason that you are calling "flush" defaults to ManualFlush (1) if not specified
-         * @returns - true if the callback will be return after the flush is complete otherwise the caller should assume that any provided callback will never be called
+         * @param async: send data asynchronously when true
+         * @param callBack: if specified, notify caller when send is complete
          */
-        flush(async: boolean, callBack?: (flushComplete?: boolean) => void, sendReason?: SendRequestReason): boolean | void;
+        flush(async: boolean, callBack?: () => void): void;
     }
 
     /**
@@ -1346,7 +958,7 @@ declare namespace ApplicationInsights {
          * @param callback {any} - The callback function that needs to be executed for the given event
          * @return {boolean} - true if the handler was successfully added
          */
-        addEventHandler: (eventName: string, callback: any, evtNamespace?: string | string[]) => boolean;
+        addEventHandler: (eventName: string, callback: any) => boolean;
         /**
          * Return the current time via the Date now() function (if available) and falls back to (new Date()).getTime() if now() is unavailable (IE8 or less)
          * https://caniuse.com/#search=Date.now
@@ -1531,10 +1143,6 @@ declare namespace ApplicationInsights {
          * The error (exception) which occurred while executing the original method
          */
         err?: Error;
-        /**
-         * The Event object from (window.event) at the start of the original call
-         */
-        evt?: Event;
     }
 
     /**
@@ -1561,11 +1169,6 @@ declare namespace ApplicationInsights {
      * You must always supply the error callback
      */
     interface IInstrumentHooksCallbacks {
-        /**
-         * [Optional] Namespace details (same as the namespace used for events), useful for debugging and testing to
-         * identify the source of the instrumented hooks
-         */
-        ns?: string | string[];
         /**
          * The hook callback to call before the original function is called
          */
@@ -1585,24 +1188,6 @@ declare namespace ApplicationInsights {
         fnErr?: InstrumentorHooksCallback;
     }
 
-    interface ILoadedPlugin<T extends IPlugin> {
-        plugin: T;
-        /**
-         * Identifies whether the plugin is enabled and can process events. This is slightly different from isInitialized as the plugin may be initialized but disabled
-         * via the setEnabled() or it may be a shared plugin which has had it's teardown function called from another instance..
-         * @returns boolean = true if the plugin is in a state where it is operational.
-         */
-        isEnabled: () => boolean;
-        /**
-         * You can optionally enable / disable a plugin from processing events.
-         * Setting enabled to true will not necessarily cause the `isEnabled()` to also return true
-         * as the plugin must also have been successfully initialized and not had it's `teardown` method called
-         * (unless it's also been re-initialized)
-         */
-        setEnabled: (isEnabled: boolean) => void;
-        remove: (isAsync?: boolean, removeCb?: (removed?: boolean) => void) => void;
-    }
-
     /**
      * Initialize the queue of plugins
      * @param plugins - The array of plugins to initialize and setting of the next plugin
@@ -1610,7 +1195,7 @@ declare namespace ApplicationInsights {
      * @param core THe current core instance
      * @param extensions The extensions
      */
-    function initializePlugins(processContext: IProcessTelemetryContext, extensions: IPlugin[]): void;
+    function initializePlugins(processContext: ProcessTelemetryContext, extensions: IPlugin[]): void;
 
     /**
      * An interface used for the notification listener.
@@ -1819,7 +1404,7 @@ declare namespace ApplicationInsights {
         InMemoryStorageBufferFull: number;
     };
 
-    type _InternalMessageId = number | _eInternalMessageId;
+    type _InternalMessageId = number | typeof _InternalMessageId;
 
     /**
      * This interface identifies the details of an internal performance event - it does not represent an outgoing reported event
@@ -1940,14 +1525,10 @@ declare namespace ApplicationInsights {
          */
         isInitialized?: () => boolean;
         /**
-         * Tear down the plugin and remove any hooked value, the plugin should be removed so that it is no longer initialized and
-         * therefore could be re-initialized after being torn down. The plugin should ensure that once this has been called any further
-         * processTelemetry calls are ignored and it just calls the processNext() with the provided context.
-         * @param unloadCtx - This is the context that should be used during unloading.
-         * @param unloadState - The details / state of the unload process, it holds details like whether it should be unloaded synchronously or asynchronously and the reason for the unload.
-         * @returns boolean - true if the plugin has or will call processNext(), this for backward compatibility as previously teardown was synchronous and returned nothing.
+         * Tear down the plugin and remove any hooked value, the plugin should remove that it is no longer initialized and
+         * therefore can be re-initialized after being torn down.
          */
-        teardown?: (unloadCtx: IProcessTelemetryUnloadContext, unloadState?: ITelemetryUnloadState) => void | boolean;
+        teardown?: () => void;
         /**
          * Extension name
          */
@@ -1962,73 +1543,61 @@ declare namespace ApplicationInsights {
      * The current context for the current call to processTelemetry(), used to support sharing the same plugin instance
      * between multiple AppInsights instances
      */
-    interface IProcessTelemetryContext extends IBaseProcessingContext {
+    interface IProcessTelemetryContext {
         /**
-         * Call back for telemetry processing before it it is sent
-         * @param env - This is the current event being reported
-         * @returns boolean (true) if there is no more plugins to process otherwise false or undefined (void)
+         * The current core instance for the request
          */
-        processNext: (env: ITelemetryItem) => boolean | void;
+        core: () => IAppInsightsCore;
         /**
-         * Create a new context using the core and config from the current instance, returns a new instance of the same type
-         * @param plugins - The execution order to process the plugins, if null or not supplied
-         *                  then the current execution order will be copied.
-         * @param startAt - The plugin to start processing from, if missing from the execution
-         *                  order then the next plugin will be NOT set.
+         * THe current diagnostic logger for the request
          */
-        createNew: (plugins?: IPlugin[] | ITelemetryPluginChain, startAt?: IPlugin) => IProcessTelemetryContext;
-    }
-
-    /**
-     * The current context for the current call to teardown() implementations, used to support when plugins are being removed
-     * or the SDK is being unloaded.
-     */
-    interface IProcessTelemetryUnloadContext extends IBaseProcessingContext {
+        diagLog: () => IDiagnosticLogger;
         /**
-         * This Plugin has finished unloading, so unload the next one
-         * @param uploadState - The state of the unload process
-         * @returns boolean (true) if there is no more plugins to process otherwise false or undefined (void)
+         * Gets the current core config instance
          */
-        processNext: (unloadState: ITelemetryUnloadState) => boolean | void;
+        getCfg: () => IConfiguration;
         /**
-         * Create a new context using the core and config from the current instance, returns a new instance of the same type
-         * @param plugins - The execution order to process the plugins, if null or not supplied
-         *                  then the current execution order will be copied.
-         * @param startAt - The plugin to start processing from, if missing from the execution
-         *                  order then the next plugin will be NOT set.
+         * Gets the named extension config
          */
-        createNew: (plugins?: IPlugin[] | ITelemetryPluginChain, startAt?: IPlugin) => IProcessTelemetryUnloadContext;
-    }
-
-    /**
-     * The current context for the current call to the plugin update() implementations, used to support the notifications
-     * for when plugins are added, removed or the configuration was changed.
-     */
-    interface IProcessTelemetryUpdateContext extends IBaseProcessingContext {
+        getExtCfg: <T>(identifier: string, defaultValue?: T | any) => T;
+        /**
+         * Gets the named config from either the named identifier extension or core config if neither exist then the
+         * default value is returned
+         * @param identifier The named extension identifier
+         * @param field The config field name
+         * @param defaultValue The default value to return if no defined config exists
+         */
+        getConfig: (identifier: string, field: string, defaultValue?: number | string | boolean) => number | string | boolean;
+        /**
+         * Helper to allow plugins to check and possibly shortcut executing code only
+         * required if there is a nextPlugin
+         */
+        hasNext: () => boolean;
+        /**
+         * Returns the next configured plugin proxy
+         */
+        getNext: () => ITelemetryPluginChain;
         /**
-         * This Plugin has finished unloading, so unload the next one
-         * @param updateState - The update State
-         * @returns boolean (true) if there is no more plugins to process otherwise false or undefined (void)
+         * Helper to set the next plugin proxy
+         */
+        setNext: (nextCtx: ITelemetryPluginChain) => void;
+        /**
+         * Call back for telemetry processing before it it is sent
+         * @param env - This is the current event being reported
          */
-        processNext: (updateState: ITelemetryUpdateState) => boolean | void;
+        processNext: (env: ITelemetryItem) => void;
         /**
-         * Create a new context using the core and config from the current instance, returns a new instance of the same type
+         * Create a new context using the core and config from the current instance
          * @param plugins - The execution order to process the plugins, if null or not supplied
          *                  then the current execution order will be copied.
          * @param startAt - The plugin to start processing from, if missing from the execution
          *                  order then the next plugin will be NOT set.
          */
-        createNew: (plugins?: IPlugin[] | ITelemetryPluginChain, startAt?: IPlugin) => IProcessTelemetryUpdateContext;
-    }
-
-    interface _IRegisteredEvents {
-        name: string;
-        handler: any;
+        createNew: (plugins?: IPlugin[] | ITelemetryPluginChain, startAt?: IPlugin) => IProcessTelemetryContext;
     }
 
     /**
-     * Check if an object is of type Array with optional generic T, the generic type is not validated
-     * and exists to help with TypeScript validation only.
+     * Check if an object is of type Array
      */
     let isArray: <T = any>(obj: any) => obj is Array<T>;
 
@@ -2069,13 +1638,13 @@ declare namespace ApplicationInsights {
      */
     function isIE(): boolean;
 
-    function isNotNullOrUndefined<T>(value: T): value is T;
+    function isNotNullOrUndefined(value: any): boolean;
 
     function isNotTruthy(value: any): boolean;
 
-    function isNotUndefined<T>(value: T): value is T;
+    function isNotUndefined(value: any): boolean;
 
-    function isNullOrUndefined(value: any): value is null | undefined;
+    function isNullOrUndefined(value: any): boolean;
 
     /**
      * Checks if the type of value is a number.
@@ -2084,7 +1653,7 @@ declare namespace ApplicationInsights {
      */
     function isNumber(value: any): value is number;
 
-    function isObject<T>(value: T): value is T;
+    function isObject(value: any): boolean;
 
     /**
      * Returns whether the environment is reporting that we are running in a React Native Environment
@@ -2112,7 +1681,7 @@ declare namespace ApplicationInsights {
 
     function isTypeof(value: any, theType: string): boolean;
 
-    function isUndefined(value: any): value is undefined;
+    function isUndefined(value: any): boolean;
 
     /**
      * Checks if XMLHttpRequest is supported
@@ -2120,19 +1689,6 @@ declare namespace ApplicationInsights {
      */
     function isXhrSupported(): boolean;
 
-    interface ITelemetryInitializerContainer {
-        /**
-         * Add a telemetry processor to decorate or drop telemetry events.
-         * @param telemetryInitializer - The Telemetry Initializer function
-         * @returns - A ITelemetryInitializerHandler to enable the initializer to be removed
-         */
-        addTelemetryInitializer(telemetryInitializer: TelemetryInitializerFunction): ITelemetryInitializerHandler | void;
-    }
-
-    interface ITelemetryInitializerHandler {
-        remove(): void;
-    }
-
     /**
      * Telemety item supported in Core
      */
@@ -2182,7 +1738,15 @@ declare namespace ApplicationInsights {
     /**
      * Configuration provided to SDK core
      */
-    interface ITelemetryPlugin extends ITelemetryProcessor, IPlugin {
+    interface ITelemetryPlugin extends IPlugin {
+        /**
+         * Call back for telemetry processing before it it is sent
+         * @param env - This is the current event being reported
+         * @param itemCtx - This is the context for the current request, ITelemetryPlugin instances
+         * can optionally use this to access the current core instance or define / pass additional information
+         * to later plugins (vs appending items to the telemetry item)
+         */
+        processTelemetry: (env: ITelemetryItem, itemCtx?: IProcessTelemetryContext) => void;
         /**
          * Set next extension for telemetry processing, this is not optional as plugins should use the
          * processNext() function of the passed IProcessTelemetryContext instead. It is being kept for
@@ -2198,7 +1762,7 @@ declare namespace ApplicationInsights {
     /**
      * Configuration provided to SDK core
      */
-    interface ITelemetryPluginChain extends ITelemetryProcessor {
+    interface ITelemetryPluginChain {
         /**
          * Returns the underlying plugin that is being proxied for the processTelemetry call
          */
@@ -2207,16 +1771,6 @@ declare namespace ApplicationInsights {
          * Returns the next plugin
          */
         getNext: () => ITelemetryPluginChain;
-        /**
-         * This plugin is being unloaded and should remove any hooked events and cleanup any global/scoped values, after this
-         * call the plugin will be removed from the telemetry processing chain and will no longer receive any events..
-         * @param unloadCtx - The unload context to use for this call.
-         * @param unloadState - The details of the unload operation
-         */
-        unload?: (unloadCtx: IProcessTelemetryUnloadContext, unloadState: ITelemetryUnloadState) => void;
-    }
-
-    interface ITelemetryProcessor {
         /**
          * Call back for telemetry processing before it it is sent
          * @param env - This is the current event being reported
@@ -2224,60 +1778,7 @@ declare namespace ApplicationInsights {
          * can optionally use this to access the current core instance or define / pass additional information
          * to later plugins (vs appending items to the telemetry item)
          */
-        processTelemetry: (env: ITelemetryItem, itemCtx?: IProcessTelemetryContext) => void;
-        /**
-         * The the plugin should re-evaluate configuration and update any cached configuration settings or
-         * plugins. If implemented this method will be called whenever a plugin is added or removed and if
-         * the configuration has bee updated.
-         * @param updateCtx - This is the context that should be used during updating.
-         * @param updateState - The details / state of the update process, it holds details like the current and previous configuration.
-         * @returns boolean - true if the plugin has or will call updateCtx.processNext(), this allows the plugin to perform any asynchronous operations.
-         */
-        update?: (updateCtx: IProcessTelemetryUpdateContext, updateState: ITelemetryUpdateState) => void | boolean;
-    }
-
-    interface ITelemetryUnloadState {
-        reason: TelemetryUnloadReason;
-        isAsync: boolean;
-        flushComplete?: boolean;
-    }
-
-    interface ITelemetryUpdateState {
-        /**
-         * Identifies the reason for the update notification, this is a bitwise numeric value
-         */
-        reason: TelemetryUpdateReason;
-        /**
-         * If this is a configuration update this was the previous configuration that was used
-         */
-        /**
-         * If this is a configuration update is the new configuration that is being used
-         */
-        /**
-         * This holds a collection of plugins that have been added (if the reason identifies that one or more plugins have been added)
-         */
-        added?: IPlugin[];
-        /**
-         * This holds a collection of plugins that have been removed (if the reason identifies that one or more plugins have been removed)
-         */
-        removed?: IPlugin[];
-    }
-
-    interface IUnloadableComponent {
-        /**
-         * Teardown / Unload hook to allow implementations to perform some additional unload operations before the BaseTelemetryPlugin
-         * finishes it's removal.
-         * @param unloadCtx - This is the context that should be used during unloading.
-         * @param unloadState - The details / state of the unload process, it holds details like whether it should be unloaded synchronously or asynchronously and the reason for the unload.
-         * @param asyncCallback - An optional callback that the plugin must call if it returns true to inform the caller that it has completed any async unload/teardown operations.
-         * @returns boolean - true if the plugin has or will call asyncCallback, this allows the plugin to perform any asynchronous operations.
-         */
-        _doUnload?: (unloadCtx?: IProcessTelemetryUnloadContext, unloadState?: ITelemetryUnloadState, asyncCallback?: () => void) => void | boolean;
-    }
-
-    interface IUnloadHandlerContainer {
-        add: (handler: UnloadHandler) => void;
-        run: (itemCtx: IProcessTelemetryUnloadContext, unloadState: ITelemetryUnloadState) => void;
+        processTelemetry: (env: ITelemetryItem, itemCtx: IProcessTelemetryContext) => void;
     }
 
     /**
@@ -2292,14 +1793,16 @@ declare namespace ApplicationInsights {
      */
     function _legacyCookieMgr(config?: IConfiguration, logger?: IDiagnosticLogger): ICookieMgr;
 
-    const LoggingSeverity: {
-        CRITICAL: number;
-        WARNING: number;
-    };
-
-    type LoggingSeverity = number | eLoggingSeverity;
-
-    function mergeEvtNamespace(theNamespace: string, namespaces?: string | string[] | null): string | string[];
+    enum LoggingSeverity {
+        /**
+         * Error will be sent as internal telemetry
+         */
+        CRITICAL = 1,
+        /**
+         * Error will NOT be sent as internal telemetry, and will only be shown in browser console
+         */
+        WARNING = 2
+    }
 
     const MinChannelPriorty: number;
 
@@ -2391,27 +1894,13 @@ declare namespace ApplicationInsights {
      */
     function objDefineAccessors<T>(target: any, prop: string, getProp?: () => T, setProp?: (v: T) => void): boolean;
 
-    /**
-     * 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.
-     * @param obj1 - object to merge.  Set this argument to 'true' for a deep extend.
-     * @param obj2 - object to merge.
-     * @param obj3 - object to merge.
-     * @param obj4 - object to merge.
-     * @param obj5 - object to merge.
-     * @returns The extended first object.
-     */
-    function objExtend<T2, T3, T4, T5, T6>(deepExtend?: boolean, obj2?: T2, obj3?: T3, obj4?: T4, obj5?: T5, obj6?: T6): T2 & T3 & T4 & T5 & T6;
-
-    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;
-
     /**
      * This is a helper function for the equivalent of arForEach(objKeys(target), callbackFn), this is a
      * performance optimization to avoid the creation of a new array for large objects
      * @param target The target object to find and process the keys
      * @param callbackfn The function to call with the details
      */
-    function objForEachKey<T = any>(target: T, callbackfn: (name: string, value: T[keyof T]) => void): void;
+    function objForEachKey(target: any, callbackfn: (name: string, value: any) => void): void;
 
     const objFreeze: <T>(value: T) => T;
 
@@ -2425,8 +1914,6 @@ declare namespace ApplicationInsights {
 
     const objSeal: <T>(value: T) => T;
 
-    function objToString(obj: any): any;
-
     /**
      * A helper function to assist with JIT performance for objects that have properties added / removed dynamically
      * this is primarily for chromium based browsers and has limited effects on Firefox and none of IE. Only call this
@@ -2482,7 +1969,7 @@ declare namespace ApplicationInsights {
          * Defined as private so it can be visualized via the DebugPlugin
          */
         private ctx;
-        constructor(manager?: INotificationManager);
+        constructor(manager: INotificationManager);
         /**
          * Create a new event and start timing, the manager may return null/undefined to indicate that it does not
          * want to monitor this source event.
@@ -2515,17 +2002,13 @@ declare namespace ApplicationInsights {
      */
     function perfNow(): number;
 
-    /**
-     * This class will be removed!
-     * @deprecated use createProcessTelemetryContext() instead
-     */
     class ProcessTelemetryContext implements IProcessTelemetryContext {
         /**
          * Gets the current core config instance
          */
         getCfg: () => IConfiguration;
         getExtCfg: <T>(identifier: string, defaultValue?: T | any) => T;
-        getConfig: (identifier: string, field: string, defaultValue?: number | string | boolean | string[] | RegExp[] | Function) => number | string | boolean | string[] | RegExp[] | Function;
+        getConfig: (identifier: string, field: string, defaultValue?: number | string | boolean) => number | string | boolean;
         /**
          * Returns the IAppInsightsCore instance for the current request
          */
@@ -2553,34 +2036,19 @@ declare namespace ApplicationInsights {
          * @param itemCtx - This is the context for the current request, ITelemetryPlugin instances
          * can optionally use this to access the current core instance or define / pass additional information
          * to later plugins (vs appending items to the telemetry item)
-         * @returns boolean (true) if there is no more plugins to process otherwise false or undefined (void)
-         */
-        processNext: (env: ITelemetryItem) => boolean | void;
-        /**
-         * Synchronously iterate over the context chain running the callback for each plugin, once
-         * every plugin has been executed via the callback, any associated onComplete will be called.
-         * @param callback - The function call for each plugin in the context chain
          */
-        iterate: <T extends ITelemetryPlugin = ITelemetryPlugin>(callback: (plugin: T) => void) => void;
+        processNext: (env: ITelemetryItem) => void;
         /**
          * Create a new context using the core and config from the current instance
-         * @param plugins - The execution order to process the plugins, if null or not supplied
-         *                  then the current execution order will be copied.
-         * @param startAt - The plugin to start processing from, if missing from the execution
-         *                  order then the next plugin will be NOT set.
          */
         createNew: (plugins?: IPlugin[] | ITelemetryPluginChain, startAt?: IPlugin) => IProcessTelemetryContext;
-        /**
-         * Set the function to call when the current chain has executed all processNext or unloadNext items.
-         */
-        onComplete: (onComplete: () => void) => void;
         /**
          * Creates a new Telemetry Item context with the current config, core and plugin execution chain
          * @param plugins - The plugin instances that will be executed
          * @param config - The current config
          * @param core - The current core instance
          */
-        constructor(pluginChain: ITelemetryPluginChain, config: IConfiguration, core: IAppInsightsCore, startAt?: IPlugin);
+        constructor(plugins: IPlugin[] | ITelemetryPluginChain, config: IConfiguration, core: IAppInsightsCore, startAt?: IPlugin);
     }
 
     /**
@@ -2597,19 +2065,9 @@ declare namespace ApplicationInsights {
      * @param target - The target object to be assigned with the source properties and functions
      * @param source - The source object which will be assigned / called by setting / calling the targets proxies
      * @param chkSet - An optional callback to determine whether a specific property/function should be proxied
+     * @memberof Initialization
      */
-    function proxyAssign<T, S>(target: T, source: S, chkSet?: (name: string, isFunc?: boolean, source?: S, target?: T) => boolean): T;
-
-    function proxyFunctionAs<T, S>(target: T, name: string, source: S | (() => S), theFunc: (keyof S), overwriteTarget?: boolean): void;
-
-    /**
-     * Creates proxy functions on the target which internally will call the source version with all arguments passed to the target method.
-     *
-     * @param target - The target object to be assigned with the source properties and functions
-     * @param source - The source object which will be assigned / called by setting / calling the targets proxies
-     * @param functionsToProxy - An array of function names that will be proxied on the target
-     */
-    function proxyFunctions<T, S>(target: T, source: S | (() => S), functionsToProxy: (keyof S)[], overwriteTarget?: boolean): T;
+    function proxyAssign(target: any, source: any, chkSet?: (name: string, isFunc?: boolean, source?: any, target?: any) => boolean): any;
 
     /**
      * generate a random 32-bit number (0x000000..0xFFFFFFFF) or (-0x80000000..0x7FFFFFFF), defaults un-unsigned.
@@ -2624,52 +2082,6 @@ declare namespace ApplicationInsights {
      */
     function randomValue(maxValue: number): number;
 
-    /**
-     * 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,
-     * such as "click", "click.mynamespace" or ".mynamespace"
-     * @param callback {any} - - The callback function that needs to be removed from the given event, when using a
-     * namespace (with or without a qualifying event) this may be null to remove all previously attached event handlers
-     * otherwise this will only remove events with this specific handler.
-     * @param evtNamespace - [Optional] Namespace(s) to append to the event listeners so they can be uniquely identified and removed based on this namespace.
-     */
-    function removeEventHandler(eventName: string, callback: any, evtNamespace?: string | string[] | null): void;
-
-    /**
-     * Remove the listener from the array of events
-     * @param events An string array of event names to bind the listener to
-     * @param listener The event callback to call when the event is triggered
-     * @param evtNamespace - [Optional] Namespace(s) to append to the event listeners so they can be uniquely identified and removed based on this namespace.
-     */
-    function removeEventListeners(events: string[], listener: any, evtNamespace?: string | string[]): void;
-
-    /**
-     * Removes the pageHide event listeners added by addPageHideEventListener, because the 'visibilitychange' uses
-     * an internal proxy to detect the visibility state you SHOULD use a unique namespace when calling addPageHideEventListener
-     * as the remove ignores the listener argument for the 'visibilitychange' event.
-     * @param listener - The specific listener to remove for the 'pageshow' event only (ignored for 'visibilitychange')
-     * @param evtNamespace - The unique namespace used when calling addPageShowEventListener
-     */
-    function removePageHideEventListener(listener: any, evtNamespace?: string | string[] | null): void;
-
-    /**
-     * Removes the pageShow event listeners added by addPageShowEventListener, because the 'visibilitychange' uses
-     * an internal proxy to detect the visibility state you SHOULD use a unique namespace when calling addPageShowEventListener
-     * as the remove ignores the listener argument for the 'visibilitychange' event.
-     * @param listener - The specific listener to remove for the 'pageshow' event only (ignored for 'visibilitychange')
-     * @param evtNamespace - The unique namespace used when calling addPageShowEventListener
-     */
-    function removePageShowEventListener(listener: any, evtNamespace?: string | string[] | null): void;
-
-    /**
-     * Remove any matching 'beforeunload', 'unload' and 'pagehide' events that may have been added via addEventListener,
-     * addEventListeners, addPageUnloadEventListener or addPageHideEventListener.
-     * @param listener - The specific event callback to to be removed
-     * @param evtNamespace - [Optional] Namespace(s) uniquely identified and removed based on this namespace.
-     * @returns true - when at least one of the events was registered otherwise false
-     */
-    function removePageUnloadEventListener(listener: any, evtNamespace?: string | string[]): void;
-
     /**
      * Helper to return the ICookieMgr from the core (if not null/undefined) or a default implementation
      * associated with the configuration or a legacy default.
@@ -2713,10 +2125,6 @@ declare namespace ApplicationInsights {
          * The event(s) being sent as a retry
          */
         Retry = 5,
-        /**
-         * The SDK is unloading
-         */
-        SdkUnload = 6,
         /**
          * Maximum batch size would be exceeded
          */
@@ -2755,9 +2163,9 @@ declare namespace ApplicationInsights {
      * @param srcChk - [Optional] Callback to check to original value that if supplied will be called if the new value should be set (if allowed)
      * @returns The existing or new value, depending what was set
      */
-    function setValue<T, K extends keyof T>(target: T, field: K, value: T[K], valChk?: ((value: T[K]) => boolean) | null, srcChk?: ((value: T[K]) => boolean) | null): T[K];
+    function setValue<T, K extends keyof T>(target: T, field: K, value: T[K], valChk?: (value: T[K]) => boolean, srcChk?: (value: T[K]) => boolean): T[K];
 
-    function sortPlugins<T = IPlugin>(plugins: T[]): T[];
+    function sortPlugins(plugins: IPlugin[]): IPlugin[];
 
     /**
      * A simple wrapper (for minification support) to check if the value contains the search string.
@@ -2803,64 +2211,8 @@ declare namespace ApplicationInsights {
         [key: string]: any;
     }
 
-    type TelemetryInitializerFunction = <T extends ITelemetryItem>(item: T) => boolean | void;
-
-    /**
-     * The TelemetryUnloadReason enumeration contains the possible reasons for why a plugin is being unloaded / torndown().
-     */
-    const enum TelemetryUnloadReason {
-        /**
-         * Teardown has been called without any context.
-         */
-        ManualTeardown = 0,
-        /**
-         * Just this plugin is being removed
-         */
-        PluginUnload = 1,
-        /**
-         * This instance of the plugin is being removed and replaced
-         */
-        PluginReplace = 2,
-        /**
-         * The entire SDK is being unloaded
-         */
-        SdkUnload = 50
-    }
-
-    /**
-     * The TelemetryUpdateReason enumeration contains a set of bit-wise values that specify the reason for update request.
-     */
-    const enum TelemetryUpdateReason {
-        /**
-         * Unknown.
-         */
-        Unknown = 0,
-        /**
-         * The configuration has ben updated or changed
-         */
-        /**
-         * One or more plugins have been added
-         */
-        PluginAdded = 16,
-        /**
-         * One or more plugins have been removed
-         */
-        PluginRemoved = 32
-    }
-
     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
-     * support minification as logger.throwInternal() will not compress the publish "throwInternal" used throughout
-     * the code.
-     * @param logger - The Diagnostic Logger instance to use.
-     * @param severity {LoggingSeverity} - The severity of the log message
-     * @param message {_InternalLogMessage} - The log message.
-     */
-    function _throwInternal(logger: IDiagnosticLogger, severity: LoggingSeverity, msgId: _InternalMessageId, msg: string, properties?: Object, isUserAct?: boolean): void;
-
     /**
      * Convert a date to I.S.O. format in IE8
      */
@@ -2870,19 +2222,6 @@ declare namespace ApplicationInsights {
 
     const Undefined = "undefined";
 
-    /**
-     * Teardown / Unload helper to perform teardown/unloading operations for the provided components synchronously or asynchronously, this will call any
-     * _doTeardown() or _doUnload() functions on the provided components to allow them to finish removal.
-     * @param components - The components you want to unload
-     * @param unloadCtx - This is the context that should be used during unloading.
-     * @param unloadState - The details / state of the unload process, it holds details like whether it should be unloaded synchronously or asynchronously and the reason for the unload.
-     * @param asyncCallback - An optional callback that the plugin must call if it returns true to inform the caller that it has completed any async unload/teardown operations.
-     * @returns boolean - true if the plugin has or will call asyncCallback, this allows the plugin to perform any asynchronous operations.
-     */
-    function unloadComponents(components: any | IUnloadableComponent[], unloadCtx?: IProcessTelemetryUnloadContext, unloadState?: ITelemetryUnloadState, asyncCallback?: () => void): void | boolean;
-
-    type UnloadHandler = (itemCtx: IProcessTelemetryUnloadContext, unloadState: ITelemetryUnloadState) => void;
-
     function useXDomainRequest(): boolean | undefined;