@microsoft/applicationinsights-core-js 2.8.0-beta.2203-02 → 2.8.0-beta.2203-05

package/dist/applicationinsights-core-js.api.md

@@ -12,7 +12,7 @@ import { strShimPrototype as strPrototype } from '@microsoft/applicationinsights
 import { strShimUndefined as strUndefined } from '@microsoft/applicationinsights-shims';
 
 // @public
-export function __getRegisteredEvents(target: any, evtName?: string): _IRegisteredEvents[];
+export function __getRegisteredEvents(target: any, eventName?: string, evtNamespace?: string | string[]): _IRegisteredEvents[];
 
 // @public
 export function addEventHandler(eventName: string, callback: any, evtNamespace?: string | string[]): boolean;
@@ -60,7 +60,10 @@ export function attachEvent(obj: any, eventNameWithoutOn: string, handlerRef: an
 export class BaseCore implements IAppInsightsCore {
     constructor();
     addNotificationListener(listener: INotificationListener): void;
+    // (undocumented)
+    addPlugin<T extends IPlugin = ITelemetryPlugin>(plugin: T, replaceExisting: boolean, doAsync: boolean, addCb?: (added?: boolean) => void): void;
     addTelemetryInitializer(telemetryInitializer: TelemetryInitializerFunction): ITelemetryInitializerHandler | void;
+    addUnloadCb(handler: UnloadHandler): void;
     // (undocumented)
     config: IConfiguration;
     // (undocumented)
@@ -99,16 +102,19 @@ export class BaseCore implements IAppInsightsCore {
     stopPollingInternalLogs(): void;
     // (undocumented)
     track(telemetryItem: ITelemetryItem): void;
+    unload(isAsync?: boolean, unloadComplete?: (unloadState: ITelemetryUnloadState) => void, cbTimeout?: number): void;
+    protected _updateHook?(updateCtx: IProcessTelemetryUpdateContext, updateState: ITelemetryUpdateState): void | boolean;
 }
 
 // @public
 export abstract class BaseTelemetryPlugin implements ITelemetryPlugin {
     constructor();
     protected _addHook(hooks: IInstrumentHook | IInstrumentHook[]): void;
+    protected _addUnloadCb(handler: UnloadHandler): void;
     core: IAppInsightsCore;
     diagLog: (itemCtx?: IProcessTelemetryContext) => IDiagnosticLogger;
-    // Warning: (ae-forgotten-export) The symbol "IProcessTelemetryUnloadContext" needs to be exported by the entry point applicationinsights-core-js.d.ts
     protected _doTeardown?: (unloadCtx?: IProcessTelemetryUnloadContext, unloadState?: ITelemetryUnloadState, asyncCallback?: () => void) => void | boolean;
+    protected _doUpdate?: (updateCtx?: IProcessTelemetryUpdateContext, updateState?: ITelemetryUpdateState, asyncCallback?: () => void) => void | boolean;
     protected _getTelCtx: (currentCtx?: IProcessTelemetryContext) => IProcessTelemetryContext;
     // (undocumented)
     identifier: string;
@@ -123,6 +129,7 @@ export abstract class BaseTelemetryPlugin implements ITelemetryPlugin {
     protected setInitialized: (isInitialized: boolean) => void;
     setNextPlugin: (next: ITelemetryPlugin | ITelemetryPluginChain) => void;
     teardown(unloadCtx?: IProcessTelemetryUnloadContext, unloadState?: ITelemetryUnloadState): void | boolean;
+    update(updateCtx: IProcessTelemetryUpdateContext, updateState: ITelemetryUpdateState): void | boolean;
     // (undocumented)
     version?: string;
 }
@@ -148,6 +155,12 @@ export function createProcessTelemetryContext(telemetryChain: ITelemetryPluginCh
 // @public (undocumented)
 export function createUniqueNamespace(name: string, includeVersion?: boolean): string;
 
+// @public (undocumented)
+export function createUnloadHandlerContainer(): {
+    add: (handler: UnloadHandler) => void;
+    run: (unloadCtx: IProcessTelemetryUnloadContext, unloadState: ITelemetryUnloadState) => void;
+};
+
 // @public
 export function dateNow(): number;
 
@@ -466,7 +479,9 @@ export function hasWindow(): boolean;
 // @public (undocumented)
 export interface IAppInsightsCore extends IPerfManagerProvider {
     addNotificationListener?(listener: INotificationListener): void;
+    addPlugin<T extends IPlugin = ITelemetryPlugin>(plugin: T, replaceExisting: boolean, doAsync: boolean, addCb?: (added?: boolean) => void): void;
     addTelemetryInitializer(telemetryInitializer: TelemetryInitializerFunction): ITelemetryInitializerHandler | void;
+    addUnloadCb(handler: UnloadHandler): void;
     // (undocumented)
     config: IConfiguration;
     evtNamespace(): string;
@@ -489,6 +504,22 @@ export interface IAppInsightsCore extends IPerfManagerProvider {
     stopPollingInternalLogs?(): void;
     // (undocumented)
     track(telemetryItem: ITelemetryItem): void;
+    unload(isAsync?: boolean, unloadComplete?: () => void): void;
+}
+
+// @public (undocumented)
+export interface IBaseProcessingContext {
+    core: () => IAppInsightsCore;
+    createNew: (plugins?: IPlugin[] | ITelemetryPluginChain, startAt?: IPlugin) => IBaseProcessingContext;
+    diagLog: () => IDiagnosticLogger;
+    getCfg: () => IConfiguration;
+    getConfig: (identifier: string, field: string, defaultValue?: number | string | boolean | string[] | RegExp[] | Function) => number | string | boolean | string[] | RegExp[] | Function;
+    getExtCfg: <T>(identifier: string, defaultValue?: T | any, mergeDefault?: GetExtCfgMergeType) => T;
+    getNext: () => ITelemetryPluginChain;
+    hasNext: () => boolean;
+    iterate: <T extends ITelemetryPlugin = ITelemetryPlugin>(callback: (plugin: T) => void) => void;
+    onComplete: (onComplete: Function, that?: any, ...args: any[]) => void;
+    setNext: (nextCtx: ITelemetryPluginChain) => void;
 }
 
 // @public
@@ -677,6 +708,7 @@ export interface IInstrumentHooks {
 export interface IInstrumentHooksCallbacks {
     fnErr?: InstrumentorHooksCallback;
     hkErr?: InstrumentorHooksCallback;
+    ns?: string | string[];
     req?: InstrumentorHooksCallback;
     rsp?: InstrumentorHooksCallback;
 }
@@ -858,14 +890,24 @@ export interface IPlugin {
     readonly version?: string;
 }
 
-// Warning: (ae-forgotten-export) The symbol "IBaseProcessingContext" needs to be exported by the entry point applicationinsights-core-js.d.ts
-//
 // @public
 export interface IProcessTelemetryContext extends IBaseProcessingContext {
     createNew: (plugins?: IPlugin[] | ITelemetryPluginChain, startAt?: IPlugin) => IProcessTelemetryContext;
     processNext: (env: ITelemetryItem) => boolean | void;
 }
 
+// @public
+export interface IProcessTelemetryUnloadContext extends IBaseProcessingContext {
+    createNew: (plugins?: IPlugin[] | ITelemetryPluginChain, startAt?: IPlugin) => IProcessTelemetryUnloadContext;
+    processNext: (unloadState: ITelemetryUnloadState) => boolean | void;
+}
+
+// @public
+export interface IProcessTelemetryUpdateContext extends IBaseProcessingContext {
+    createNew: (plugins?: IPlugin[] | ITelemetryPluginChain, startAt?: IPlugin) => IProcessTelemetryUpdateContext;
+    processNext: (updateState: ITelemetryUpdateState) => boolean | void;
+}
+
 // @public (undocumented)
 export interface _IRegisteredEvents {
     // (undocumented)
@@ -989,12 +1031,25 @@ export interface ITelemetryUnloadState {
     flushComplete?: boolean;
     // (undocumented)
     isAsync: boolean;
-    // Warning: (ae-forgotten-export) The symbol "TelemetryUnloadReason" needs to be exported by the entry point applicationinsights-core-js.d.ts
-    //
     // (undocumented)
     reason: TelemetryUnloadReason;
 }
 
+// @public (undocumented)
+export interface ITelemetryUpdateState {
+    added?: IPlugin[];
+    reason: TelemetryUpdateReason;
+    removed?: IPlugin[];
+}
+
+// @public (undocumented)
+export interface IUnloadHandlerContainer {
+    // (undocumented)
+    add: (handler: UnloadHandler) => void;
+    // (undocumented)
+    run: (itemCtx: IProcessTelemetryUnloadContext, unloadState: ITelemetryUnloadState) => void;
+}
+
 // @public
 export function _legacyCookieMgr(config?: IConfiguration, logger?: IDiagnosticLogger): ICookieMgr;
 
@@ -1047,7 +1102,10 @@ export { objCreate }
 export function objDefineAccessors<T>(target: any, prop: string, getProp?: () => T, setProp?: (v: T) => void): boolean;
 
 // @public
-export function objExtend<T1, T2, T3, T4, T5, T6>(obj?: boolean | T1, obj2?: T2, obj3?: T3, obj4?: T4, obj5?: T5, obj6?: T6): T1 & T2 & T3 & T4 & T5 & T6;
+export function objExtend<T2, T3, T4, T5, T6>(deepExtend?: boolean, obj2?: T2, obj3?: T3, obj4?: T4, obj5?: T5, obj6?: T6): T2 & T3 & T4 & T5 & T6;
+
+// @public (undocumented)
+export 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;
 
 // @public
 export function objForEachKey<T = any>(target: T, callbackfn: (name: string, value: T[keyof T]) => void): void;
@@ -1158,6 +1216,7 @@ export const enum SendRequestReason {
     NormalSchedule = 1,
     Resumed = 4,
     Retry = 5,
+    SdkUnload = 6,
     SyncEvent = 3,
     Undefined = 0,
     Unload = 2
@@ -1213,9 +1272,27 @@ export interface Tags {
 // @public (undocumented)
 export type TelemetryInitializerFunction = <T extends ITelemetryItem>(item: T) => boolean | void;
 
+// @public
+export const enum TelemetryUnloadReason {
+    ManualTeardown = 0,
+    PluginReplace = 2,
+    PluginUnload = 1,
+    SdkUnload = 50
+}
+
+// @public
+export const enum TelemetryUpdateReason {
+    PluginAdded = 16,
+    PluginRemoved = 32,
+    Unknown = 0
+}
+
 // @public (undocumented)
 export function throwError(message: string): never;
 
+// @public
+export function _throwInternal(logger: IDiagnosticLogger, severity: LoggingSeverity, msgId: _InternalMessageId, msg: string, properties?: Object, isUserAct?: boolean): void;
+
 // @public
 export function toISOString(date: Date): string;
 
@@ -1225,6 +1302,9 @@ export function uaDisallowsSameSiteNone(userAgent: string): boolean;
 // @public (undocumented)
 export const Undefined = "undefined";
 
+// @public (undocumented)
+export type UnloadHandler = (itemCtx: IProcessTelemetryUnloadContext, unloadState: ITelemetryUnloadState) => void;
+
 // @public (undocumented)
 export function useXDomainRequest(): boolean | undefined;
 

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

@@ -1,5 +1,5 @@
 /*
- * Microsoft Application Insights Core Javascript SDK, 2.8.0-beta.2203-02
+ * Microsoft Application Insights Core Javascript SDK, 2.8.0-beta.2203-05
  * Copyright (c) Microsoft and contributors. All rights reserved.
  *
  * Microsoft Application Insights Team
@@ -18,9 +18,11 @@ declare namespace ApplicationInsights {
      * 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 evtName - [Optional] The name of the event to return the registered handlers and full name (with namespaces)
+     * @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, evtName?: string): _IRegisteredEvents[];
+    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
@@ -189,12 +191,34 @@ declare namespace ApplicationInsights {
          * @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.
+         */
+        unload(isAsync?: boolean, unloadComplete?: (unloadState: ITelemetryUnloadState) => void, cbTimeout?: number): void;
         getPlugin<T extends IPlugin = IPlugin>(pluginIdentifier: string): ILoadedPlugin<T>;
+        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;
         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;
     }
 
     /**
@@ -251,6 +275,14 @@ declare namespace ApplicationInsights {
          * @returns boolean - true if the plugin has or will call asyncCallback, this allows the plugin to perform any asynchronous operations.
          */
         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;
         /**
@@ -263,6 +295,18 @@ declare namespace ApplicationInsights {
          */
         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
@@ -305,11 +349,17 @@ declare namespace ApplicationInsights {
      * @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, 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
@@ -781,15 +831,36 @@ declare namespace ApplicationInsights {
          * 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.
+         */
+        unload(isAsync?: boolean, unloadComplete?: () => void): 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
+         * @param doAsync - Should the add be performed asynchronously
+         */
+        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;
     }
 
     interface IBaseProcessingContext {
@@ -1457,6 +1528,11 @@ 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
          */
@@ -1491,6 +1567,7 @@ declare namespace ApplicationInsights {
          * (unless it's also been re-initialized)
          */
         setEnabled: (isEnabled: boolean) => void;
+        remove: (isAsync?: boolean, removeCb?: (removed?: boolean) => void) => void;
     }
 
     /**
@@ -1870,8 +1947,8 @@ declare namespace ApplicationInsights {
     }
 
     /**
-     * The current context for the current call to processTelemetry(), used to support sharing the same plugin instance
-     * between multiple AppInsights instances
+     * 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 {
         /**
@@ -1890,6 +1967,27 @@ declare namespace ApplicationInsights {
         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 {
+        /**
+         * 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: (updateState: ITelemetryUpdateState) => boolean | 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) => IProcessTelemetryUpdateContext;
+    }
+
     interface _IRegisteredEvents {
         name: string;
         handler: any;
@@ -2094,6 +2192,15 @@ declare namespace ApplicationInsights {
          * 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 {
@@ -2102,6 +2209,32 @@ declare namespace ApplicationInsights {
         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 IUnloadHandlerContainer {
+        add: (handler: UnloadHandler) => void;
+        run: (itemCtx: IProcessTelemetryUnloadContext, unloadState: ITelemetryUnloadState) => void;
+    }
+
     /**
      * Helper to support backward compatibility for users that use the legacy cookie handling functions and the use the internal
      * CoreUtils._canUseCookies global flag to enable/disable cookies usage.
@@ -2223,7 +2356,9 @@ declare namespace ApplicationInsights {
      * @param obj5 - object to merge.
      * @returns The extended first object.
      */
-    function objExtend<T1, T2, T3, T4, T5, T6>(obj?: boolean | T1, obj2?: T2, obj3?: T3, obj4?: T4, obj5?: T5, obj6?: T6): T1 & T2 & T3 & T4 & T5 & T6;
+    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
@@ -2522,6 +2657,10 @@ 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
          */
@@ -2617,11 +2756,55 @@ declare namespace ApplicationInsights {
         /**
          * Teardown has been called without any context.
          */
-        ManualTeardown = 0
+        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
      */
@@ -2631,6 +2814,8 @@ declare namespace ApplicationInsights {
 
     const Undefined = "undefined";
 
+    type UnloadHandler = (itemCtx: IProcessTelemetryUnloadContext, unloadState: ITelemetryUnloadState) => void;
+
     function useXDomainRequest(): boolean | undefined;