@microsoft/applicationinsights-core-js 2.8.0-nightly.2202-06 → 2.8.0-nightly.2204-06

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

@@ -1,5 +1,5 @@
 /*
- * Microsoft Application Insights Core Javascript SDK, 2.8.0-nightly.2202-06
+ * Microsoft Application Insights Core Javascript SDK, 2.8.0-nightly.2204-06
  * Copyright (c) Microsoft and contributors. All rights reserved.
  *
  * Microsoft Application Insights Team
@@ -20,39 +20,61 @@ import { strShimObject as strObject } from '@microsoft/applicationinsights-shims
 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
+ */
+export declare 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
  */
-export declare function addEventHandler(eventName: string, callback: any): boolean;
+export declare function addEventHandler(eventName: string, callback: any, evtNamespace?: string | string[] | null): 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
  */
-export declare function addEventListeners(events: string[], listener: any, excludeEvents?: string[]): boolean;
+export declare function addEventListeners(events: string[], listener: any, excludeEvents?: string[], evtNamespace?: string | string[]): boolean;
 
 /**
- * Listen to the pagehide and visibility changing to 'hidden' events
+ * 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.
  * @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
  */
-export declare function addPageHideEventListener(listener: any, excludeEvents?: string[]): boolean;
+export declare function addPageHideEventListener(listener: any, excludeEvents?: string[] | null, evtNamespace?: string | string[] | null): boolean;
 
 /**
- * Listen to the pageshow and visibility changing to 'visible' events
+ * 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.
  * @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
  */
-export declare function addPageShowEventListener(listener: any, excludeEvents?: string[]): boolean;
+export declare function addPageShowEventListener(listener: any, excludeEvents?: string[] | null, evtNamespace?: string | string[] | null): boolean;
 
 /**
  * Listen to the 'beforeunload', 'unload' and 'pagehide' events which indicates a page unload is occurring,
@@ -62,34 +84,15 @@ export declare function addPageShowEventListener(listener: any, excludeEvents?:
  * 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
  */
-export declare function addPageUnloadEventListener(listener: any, excludeEvents?: string[]): boolean;
+export declare function addPageUnloadEventListener(listener: any, excludeEvents?: string[], evtNamespace?: string | string[]): boolean;
 
 export declare 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;
 }
 
 export declare function areCookiesSupported(logger?: IDiagnosticLogger): any;
@@ -102,7 +105,7 @@ export declare function areCookiesSupported(logger?: IDiagnosticLogger): any;
  * @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.
  */
-export declare function arrForEach<T>(arr: T[], callbackfn: (value: T, index?: number, array?: T[]) => void | number, thisArg?: any): void;
+export declare function arrForEach<T = any>(arr: T[], callbackfn: (value: T, index?: number, array?: T[]) => undefined | 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
@@ -137,7 +140,7 @@ export declare function arrReduce<T, R>(arr: T[], callbackfn: (previousValue: T
 /**
  * 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
+ * @param eventNameWithoutOn String that specifies any of the standard DHTML Events without "on" prefix and optional (dot "." prefixed) namespaces "click" "click.mynamespace".
  * @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
@@ -156,6 +159,18 @@ export declare class BaseCore implements IAppInsightsCore {
     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
      */
@@ -168,7 +183,67 @@ export declare class BaseCore implements IAppInsightsCore {
     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;
 }
 
 /**
@@ -177,6 +252,13 @@ export declare class BaseCore implements IAppInsightsCore {
  * implementation so that new default implementations can be added without breaking all plugins.
  */
 export declare 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
@@ -198,13 +280,6 @@ export declare abstract class BaseTelemetryPlugin implements ITelemetryPlugin {
      * 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
@@ -217,12 +292,51 @@ export declare abstract class BaseTelemetryPlugin implements ITelemetryPlugin {
      */
     protected setInitialized: (isInitialized: boolean) => void;
     /**
-     * Internal helper to initialize the instance
+     * 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.
      */
-    private _baseTelInit;
+    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;
     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;
 }
 
 /**
@@ -248,6 +362,53 @@ export declare function createClassFromInterface<T>(defaults?: T): new () => T;
 
 export declare function createCookieMgr(rootConfig?: IConfiguration, logger?: IDiagnosticLogger): ICookieMgr;
 
+/**
+ * Create a 2 index map that maps an enum's key as both the key and value, X["key"] => "key" and X[0] => "keyof 0".
+ * @param values - The values to populate on the new object
+ * @returns
+ */
+export declare function createEnumMap<E, I = keyof E>(values: {
+    [key in keyof E]: E[keyof E];
+}): EnumMap<E, I>;
+
+/**
+ * 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
+ */
+export declare function createEnumStyle<E>(values: {
+    [key in keyof E]: E[keyof E];
+}): EnumValue<E>;
+
+/**
+ * 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
+ */
+export declare function createProcessTelemetryContext(telemetryChain: ITelemetryPluginChain | null, config: IConfiguration, core: IAppInsightsCore, startAt?: IPlugin): IProcessTelemetryContext;
+
+export declare function createUniqueNamespace(name: string, includeVersion?: boolean): string;
+
+export declare function createUnloadHandlerContainer(): {
+    add: (handler: UnloadHandler) => void;
+    run: (unloadCtx: IProcessTelemetryUnloadContext, unloadState: ITelemetryUnloadState) => void;
+};
+
+/**
+ * Create a 2 index map that maps an enum's key and value to the defined map value, X["key"] => mapValue and X[0] => mapValue.
+ * Generic values
+ * - E = the const enum type (typeof eRequestHeaders);
+ * - V = Identifies the valid values for the keys, this should include both the enum numeric and string key of the type. The
+ * resulting "Value" of each entry identifies the valid values withing the assignments.
+ * @param values - The values to populate on the new object
+ * @returns
+ */
+export declare function createValueMap<E, V = E>(values: {
+    [key in keyof E]: [eValue: E[keyof E], mapValue: V[keyof V]];
+}): V;
+
 /**
  * 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
@@ -264,8 +425,11 @@ export declare function deleteCookie(logger: IDiagnosticLogger, name: string): b
 /**
  * Removes an event handler for the specified event
  * @param Object to remove the event from
- * @param eventNameWithoutOn {string} - The name of the event
- * @param handlerRef {any} - The callback function that needs to be executed for the given event
+ * @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 useCapture [Optional] Defaults to false
  */
 export declare function detachEvent(obj: any, eventNameWithoutOn: string, handlerRef: any, useCapture?: boolean): void;
@@ -346,38 +510,176 @@ export declare function doPerf<T>(mgrSource: IPerfManagerProvider | IPerfManager
  */
 export declare function dumpObj(object: any): string;
 
-export declare const EventHelper: IEventHelper;
-
 /**
- * The EventsDiscardedReason enumeration contains a set of values that specify the reason for discarding an event.
+ * The eEventsDiscardedReason enumeration contains a set of values that specify the reason for discarding an event.
  */
-export declare const EventsDiscardedReason: {
+export declare const enum eEventsDiscardedReason {
     /**
      * Unknown.
      */
-    Unknown: number;
+    Unknown = 0,
     /**
      * Status set to non-retryable.
      */
-    NonRetryableStatus: number;
+    NonRetryableStatus = 1,
     /**
      * The event is invalid.
      */
-    InvalidEvent: number;
+    InvalidEvent = 2,
     /**
      * The size of the event is too large.
      */
-    SizeLimitExceeded: number;
+    SizeLimitExceeded = 3,
     /**
      * The server is not accepting events from this instrumentation key.
      */
-    KillSwitch: number;
+    KillSwitch = 4,
     /**
      * The event queue is full.
      */
-    QueueFull: number;
+    QueueFull = 5
+}
+
+export declare 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
+}
+
+export declare 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
+}
+
+export declare type EnumMap<E = any, I = E> = {
+    readonly [key in keyof E extends string ? keyof E : never]: key extends string ? key : keyof E;
+} & I;
+
+export declare type EnumValue<E = any> = {
+    readonly [key in keyof E]: E[key];
 };
 
+export declare 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
+ */
+export declare 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
+ */
+export declare 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.
+ */
+export declare const EventsDiscardedReason: EnumValue<typeof eEventsDiscardedReason>;
+
+export declare type EventsDiscardedReason = number | eEventsDiscardedReason;
+
 /**
  * generate W3C trace id
  */
@@ -417,6 +719,12 @@ export declare function getDocument(): Document | null;
  */
 export declare function getExceptionName(object: any): string;
 
+export declare 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
@@ -575,12 +883,123 @@ export declare interface IAppInsightsCore extends IPerfManagerProvider {
      * @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;
+}
+
+export declare 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;
 }
 
 /**
@@ -596,15 +1015,23 @@ export declare interface IChannelControls extends ITelemetryPlugin {
      */
     resume(): void;
     /**
-     * Tear down transmission pipeline
+     * 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(): void;
+    teardown: (unloadCtx?: IProcessTelemetryUnloadContext, unloadState?: ITelemetryUnloadState) => void | boolean;
     /**
      * 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
+     * @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
      */
-    flush(async: boolean, callBack?: () => void): void;
+    flush(async: boolean, callBack?: (flushComplete?: boolean) => void, sendReason?: SendRequestReason): boolean | void;
 }
 
 /**
@@ -964,7 +1391,7 @@ export declare interface ICoreUtils {
      * @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) => boolean;
+    addEventHandler: (eventName: string, callback: any, evtNamespace?: string | string[]) => 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
@@ -1149,6 +1576,10 @@ export declare interface IInstrumentCallDetails {
      * 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;
 }
 
 /**
@@ -1175,6 +1606,11 @@ export declare interface IInstrumentHooks {
  * You must always supply the error callback
  */
 export declare 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
      */
@@ -1194,6 +1630,24 @@ export declare interface IInstrumentHooksCallbacks {
     fnErr?: InstrumentorHooksCallback;
 }
 
+export declare 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
@@ -1201,7 +1655,7 @@ export declare interface IInstrumentHooksCallbacks {
  * @param core THe current core instance
  * @param extensions The extensions
  */
-export declare function initializePlugins(processContext: ProcessTelemetryContext, extensions: IPlugin[]): void;
+export declare function initializePlugins(processContext: IProcessTelemetryContext, extensions: IPlugin[]): void;
 
 /**
  * An interface used for the notification listener.
@@ -1325,92 +1779,9 @@ export declare class _InternalLogMessage {
 /**
  * Internal message ID. Please create a new one for every conceptually different message. Please keep alphabetically ordered
  */
-export declare const _InternalMessageId: {
-    BrowserDoesNotSupportLocalStorage: number;
-    BrowserCannotReadLocalStorage: number;
-    BrowserCannotReadSessionStorage: number;
-    BrowserCannotWriteLocalStorage: number;
-    BrowserCannotWriteSessionStorage: number;
-    BrowserFailedRemovalFromLocalStorage: number;
-    BrowserFailedRemovalFromSessionStorage: number;
-    CannotSendEmptyTelemetry: number;
-    ClientPerformanceMathError: number;
-    ErrorParsingAISessionCookie: number;
-    ErrorPVCalc: number;
-    ExceptionWhileLoggingError: number;
-    FailedAddingTelemetryToBuffer: number;
-    FailedMonitorAjaxAbort: number;
-    FailedMonitorAjaxDur: number;
-    FailedMonitorAjaxOpen: number;
-    FailedMonitorAjaxRSC: number;
-    FailedMonitorAjaxSend: number;
-    FailedMonitorAjaxGetCorrelationHeader: number;
-    FailedToAddHandlerForOnBeforeUnload: number;
-    FailedToSendQueuedTelemetry: number;
-    FailedToReportDataLoss: number;
-    FlushFailed: number;
-    MessageLimitPerPVExceeded: number;
-    MissingRequiredFieldSpecification: number;
-    NavigationTimingNotSupported: number;
-    OnError: number;
-    SessionRenewalDateIsZero: number;
-    SenderNotInitialized: number;
-    StartTrackEventFailed: number;
-    StopTrackEventFailed: number;
-    StartTrackFailed: number;
-    StopTrackFailed: number;
-    TelemetrySampledAndNotSent: number;
-    TrackEventFailed: number;
-    TrackExceptionFailed: number;
-    TrackMetricFailed: number;
-    TrackPVFailed: number;
-    TrackPVFailedCalc: number;
-    TrackTraceFailed: number;
-    TransmissionFailed: number;
-    FailedToSetStorageBuffer: number;
-    FailedToRestoreStorageBuffer: number;
-    InvalidBackendResponse: number;
-    FailedToFixDepricatedValues: number;
-    InvalidDurationValue: number;
-    TelemetryEnvelopeInvalid: number;
-    CreateEnvelopeError: number;
-    CannotSerializeObject: number;
-    CannotSerializeObjectNonSerializable: number;
-    CircularReferenceDetected: number;
-    ClearAuthContextFailed: number;
-    ExceptionTruncated: number;
-    IllegalCharsInName: number;
-    ItemNotInArray: number;
-    MaxAjaxPerPVExceeded: number;
-    MessageTruncated: number;
-    NameTooLong: number;
-    SampleRateOutOfRange: number;
-    SetAuthContextFailed: number;
-    SetAuthContextFailedAccountName: number;
-    StringValueTooLong: number;
-    StartCalledMoreThanOnce: number;
-    StopCalledWithoutStart: number;
-    TelemetryInitializerFailed: number;
-    TrackArgumentsNotSpecified: number;
-    UrlTooLong: number;
-    SessionStorageBufferFull: number;
-    CannotAccessCookie: number;
-    IdTooLong: number;
-    InvalidEvent: number;
-    FailedMonitorAjaxSetRequestHeader: number;
-    SendBrowserInfoOnUserInit: number;
-    PluginException: number;
-    NotificationException: number;
-    SnippetScriptLoadFailure: number;
-    InvalidInstrumentationKey: number;
-    CannotParseAiBlobValue: number;
-    InvalidContentBlob: number;
-    TrackPageActionEventFailed: number;
-    FailedAddingCustomDefinedRequestContext: number;
-    InMemoryStorageBufferFull: number;
-};
+export declare const _InternalMessageId: EnumValue<typeof _eInternalMessageId>;
 
-export declare type _InternalMessageId = number | typeof _InternalMessageId;
+export declare type _InternalMessageId = number | _eInternalMessageId;
 
 /**
  * This interface identifies the details of an internal performance event - it does not represent an outgoing reported event
@@ -1531,10 +1902,14 @@ export declare interface IPlugin {
      */
     isInitialized?: () => boolean;
     /**
-     * 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.
+     * 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?: () => void;
+    teardown?: (unloadCtx: IProcessTelemetryUnloadContext, unloadState?: ITelemetryUnloadState) => void | boolean;
     /**
      * Extension name
      */
@@ -1549,61 +1924,73 @@ export declare interface IPlugin {
  * The current context for the current call to processTelemetry(), used to support sharing the same plugin instance
  * between multiple AppInsights instances
  */
-export declare interface IProcessTelemetryContext {
-    /**
-     * 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) => T;
+export declare interface IProcessTelemetryContext extends IBaseProcessingContext {
     /**
-     * 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
+     * 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)
      */
-    getConfig: (identifier: string, field: string, defaultValue?: number | string | boolean) => number | string | boolean;
+    processNext: (env: ITelemetryItem) => boolean | void;
     /**
-     * Helper to allow plugins to check and possibly shortcut executing code only
-     * required if there is a nextPlugin
+     * 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.
      */
-    hasNext: () => boolean;
+    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.
+ */
+export declare interface IProcessTelemetryUnloadContext extends IBaseProcessingContext {
     /**
-     * Returns the next configured plugin proxy
+     * 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)
      */
-    getNext: () => ITelemetryPluginChain;
+    processNext: (unloadState: ITelemetryUnloadState) => boolean | void;
     /**
-     * Helper to set the next plugin proxy
+     * 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.
      */
-    setNext: (nextCtx: ITelemetryPluginChain) => void;
+    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.
+ */
+export declare interface IProcessTelemetryUpdateContext extends IBaseProcessingContext {
     /**
-     * Call back for telemetry processing before it it is sent
-     * @param env - This is the current event being reported
+     * 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)
      */
-    processNext: (env: ITelemetryItem) => void;
+    processNext: (updateState: ITelemetryUpdateState) => boolean | void;
     /**
-     * Create a new context using the core and config from the current instance
+     * 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) => IProcessTelemetryContext;
+    createNew: (plugins?: IPlugin[] | ITelemetryPluginChain, startAt?: IPlugin) => IProcessTelemetryUpdateContext;
+}
+
+export declare interface _IRegisteredEvents {
+    name: string;
+    handler: any;
 }
 
 /**
- * Check if an object is of type Array
+ * 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.
  */
 export declare let isArray: <T = any>(obj: any) => obj is Array<T>;
 
@@ -1644,13 +2031,13 @@ export declare function isFunction(value: any): value is Function;
  */
 export declare function isIE(): boolean;
 
-export declare function isNotNullOrUndefined(value: any): boolean;
+export declare function isNotNullOrUndefined<T>(value: T): value is T;
 
 export declare function isNotTruthy(value: any): boolean;
 
-export declare function isNotUndefined(value: any): boolean;
+export declare function isNotUndefined<T>(value: T): value is T;
 
-export declare function isNullOrUndefined(value: any): boolean;
+export declare function isNullOrUndefined(value: any): value is null | undefined;
 
 /**
  * Checks if the type of value is a number.
@@ -1659,7 +2046,7 @@ export declare function isNullOrUndefined(value: any): boolean;
  */
 export declare function isNumber(value: any): value is number;
 
-export declare function isObject(value: any): boolean;
+export declare function isObject<T>(value: T): value is T;
 
 /**
  * Returns whether the environment is reporting that we are running in a React Native Environment
@@ -1687,7 +2074,7 @@ export declare function isTruthy(value: any): boolean;
 
 export declare function isTypeof(value: any, theType: string): boolean;
 
-export declare function isUndefined(value: any): boolean;
+export declare function isUndefined(value: any): value is undefined;
 
 /**
  * Checks if XMLHttpRequest is supported
@@ -1695,6 +2082,19 @@ export declare function isUndefined(value: any): boolean;
  */
 export declare function isXhrSupported(): boolean;
 
+export declare 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;
+}
+
+export declare interface ITelemetryInitializerHandler {
+    remove(): void;
+}
+
 /**
  * Telemety item supported in Core
  */
@@ -1744,15 +2144,7 @@ export declare interface ITelemetryItem {
 /**
  * Configuration provided to SDK core
  */
-export declare 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;
+export declare interface ITelemetryPlugin extends ITelemetryProcessor, IPlugin {
     /**
      * 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
@@ -1768,7 +2160,7 @@ export declare interface ITelemetryPlugin extends IPlugin {
 /**
  * Configuration provided to SDK core
  */
-export declare interface ITelemetryPluginChain {
+export declare interface ITelemetryPluginChain extends ITelemetryProcessor {
     /**
      * Returns the underlying plugin that is being proxied for the processTelemetry call
      */
@@ -1777,6 +2169,16 @@ export declare interface ITelemetryPluginChain {
      * 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;
+}
+
+declare interface ITelemetryProcessor {
     /**
      * Call back for telemetry processing before it it is sent
      * @param env - This is the current event being reported
@@ -1784,7 +2186,60 @@ export declare interface ITelemetryPluginChain {
      * 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;
+    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;
+}
+
+export declare interface ITelemetryUnloadState {
+    reason: TelemetryUnloadReason;
+    isAsync: boolean;
+    flushComplete?: boolean;
+}
+
+export declare 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[];
+}
+
+export declare 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;
+}
+
+export declare interface IUnloadHandlerContainer {
+    add: (handler: UnloadHandler) => void;
+    run: (itemCtx: IProcessTelemetryUnloadContext, unloadState: ITelemetryUnloadState) => void;
 }
 
 /**
@@ -1799,16 +2254,19 @@ export declare interface ITelemetryPluginChain {
  */
 export declare function _legacyCookieMgr(config?: IConfiguration, logger?: IDiagnosticLogger): ICookieMgr;
 
-export declare 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
-}
+export declare const LoggingSeverity: EnumValue<typeof eLoggingSeverity>;
+
+export declare type LoggingSeverity = number | eLoggingSeverity;
+
+/**
+ * Logs a message to the internal queue.
+ * @param logger - The Diagnostic Logger instance to use.
+ * @param severity {LoggingSeverity} - The severity of the log message
+ * @param message {_InternalLogMessage} - The message to log.
+ */
+export declare function _logInternalMessage(logger: IDiagnosticLogger, severity: LoggingSeverity, message: _InternalLogMessage): void;
+
+export declare function mergeEvtNamespace(theNamespace: string, namespaces?: string | string[] | null): string | string[];
 
 export declare const MinChannelPriorty: number;
 
@@ -1900,13 +2358,27 @@ export { objCreate }
  */
 export declare 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.
+ */
+export declare function objExtend<T2, T3, T4, T5, T6>(deepExtend?: boolean, obj2?: T2, obj3?: T3, obj4?: T4, obj5?: T5, obj6?: T6): T2 & T3 & T4 & T5 & T6;
+
+export declare 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
  */
-export declare function objForEachKey(target: any, callbackfn: (name: string, value: any) => void): void;
+export declare function objForEachKey<T = any>(target: T, callbackfn: (name: string, value: T[keyof T]) => void): void;
 
 export declare const objFreeze: <T>(value: T) => T;
 
@@ -1920,6 +2392,8 @@ export declare function objKeys(obj: {}): string[];
 
 export declare const objSeal: <T>(value: T) => T;
 
+export declare 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
@@ -1975,7 +2449,7 @@ export declare class PerfManager implements IPerfManager {
      * 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.
@@ -2008,13 +2482,17 @@ export declare class PerfManager implements IPerfManager {
  */
 export declare function perfNow(): number;
 
+/**
+ * This class will be removed!
+ * @deprecated use createProcessTelemetryContext() instead
+ */
 export declare 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) => number | string | boolean;
+    getConfig: (identifier: string, field: string, defaultValue?: number | string | boolean | string[] | RegExp[] | Function) => number | string | boolean | string[] | RegExp[] | Function;
     /**
      * Returns the IAppInsightsCore instance for the current request
      */
@@ -2042,19 +2520,34 @@ export declare class ProcessTelemetryContext implements IProcessTelemetryContext
      * @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) => 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;
     /**
      * 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(plugins: IPlugin[] | ITelemetryPluginChain, config: IConfiguration, core: IAppInsightsCore, startAt?: IPlugin);
+    constructor(pluginChain: ITelemetryPluginChain, config: IConfiguration, core: IAppInsightsCore, startAt?: IPlugin);
 }
 
 /**
@@ -2071,9 +2564,29 @@ export declare class ProcessTelemetryContext implements IProcessTelemetryContext
  * @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
  */
-export declare function proxyAssign(target: any, source: any, chkSet?: (name: string, isFunc?: boolean, source?: any, target?: any) => boolean): any;
+export declare function proxyAssign<T, S>(target: T, source: S, chkSet?: (name: string, isFunc?: boolean, source?: S, target?: T) => boolean): T;
+
+/**
+ * Creates a proxy function 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 name - The function name that will be added on the target
+ * @param source - The source object which will be assigned / called by setting / calling the targets proxies
+ * @param theFunc - The function name on the source that will be proxied on the target
+ * @param overwriteTarget - If `false` this will not replace any pre-existing name otherwise (the default) it will overwrite any existing name
+ */
+export declare 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
+ * @param overwriteTarget - If false this will not replace any pre-existing name otherwise (the default) it will overwrite any existing name
+ */
+export declare function proxyFunctions<T, S>(target: T, source: S | (() => S), functionsToProxy: (keyof S)[], overwriteTarget?: boolean): T;
 
 /**
  * generate a random 32-bit number (0x000000..0xFFFFFFFF) or (-0x80000000..0x7FFFFFFF), defaults un-unsigned.
@@ -2088,6 +2601,52 @@ export declare function random32(signed?: boolean): number;
  */
 export declare 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.
+ */
+export declare 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.
+ */
+export declare 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
+ */
+export declare 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
+ */
+export declare 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
+ */
+export declare 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.
@@ -2131,6 +2690,10 @@ export declare const enum SendRequestReason {
      * The event(s) being sent as a retry
      */
     Retry = 5,
+    /**
+     * The SDK is unloading
+     */
+    SdkUnload = 6,
     /**
      * Maximum batch size would be exceeded
      */
@@ -2169,9 +2732,9 @@ export declare function setGblPerfMgr(perfManager: IPerfManager): void;
  * @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
  */
-export declare 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];
+export declare 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];
 
-export declare function sortPlugins(plugins: IPlugin[]): IPlugin[];
+export declare function sortPlugins<T = IPlugin>(plugins: T[]): T[];
 
 /**
  * A simple wrapper (for minification support) to check if the value contains the search string.
@@ -2217,8 +2780,64 @@ export declare interface Tags {
     [key: string]: any;
 }
 
+export declare type TelemetryInitializerFunction = <T extends ITelemetryItem>(item: T) => boolean | void;
+
+/**
+ * The TelemetryUnloadReason enumeration contains the possible reasons for why a plugin is being unloaded / torndown().
+ */
+export declare 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.
+ */
+export declare 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
+}
+
 export declare 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.
+ */
+export declare 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
  */
@@ -2228,6 +2847,26 @@ export declare function uaDisallowsSameSiteNone(userAgent: string): boolean;
 
 export declare 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.
+ */
+export declare function unloadComponents(components: any | IUnloadableComponent[], unloadCtx?: IProcessTelemetryUnloadContext, unloadState?: ITelemetryUnloadState, asyncCallback?: () => void): void | boolean;
+
+export declare type UnloadHandler = (itemCtx: IProcessTelemetryUnloadContext, unloadState: ITelemetryUnloadState) => void;
+
 export declare function useXDomainRequest(): boolean | undefined;
 
+/**
+ * This is a helper method which will call warnToConsole on the passed logger with the provided message.
+ * @param logger - The Diagnostic Logger instance to use.
+ * @param message {_InternalLogMessage} - The log message.
+ */
+export declare function _warnToConsole(logger: IDiagnosticLogger, message: string): void;
+
 export { }