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

package/dist/applicationinsights-web.api.md

@@ -16,33 +16,25 @@ export class AppInsightsCore extends BaseCore implements IAppInsightsCore {
 // @public (undocumented)
 export class ApplicationAnalytics extends BaseTelemetryPlugin implements IAppInsights, IAppInsightsInternal {
     constructor();
+    // Warning: (ae-forgotten-export) The symbol "ITelemetryInitializerHandler" needs to be exported by the entry point applicationinsights-web.d.ts
+    //
     // (undocumented)
-    addTelemetryInitializer(telemetryInitializer: (item: ITelemetryItem) => boolean | void): void;
+    addTelemetryInitializer(telemetryInitializer: (item: ITelemetryItem) => boolean | void): ITelemetryInitializerHandler | void;
     // (undocumented)
     autoRoutePVDelay: number;
     // (undocumented)
     config: IConfig;
     // Warning: (ae-forgotten-export) The symbol "ICookieMgr" needs to be exported by the entry point applicationinsights-web.d.ts
     getCookieMgr(): ICookieMgr;
+    // Warning: (ae-forgotten-export) The symbol "_getDefaultConfig" needs to be exported by the entry point applicationinsights-web.d.ts
+    //
     // (undocumented)
-    static getDefaultConfig(config?: IConfig): IConfig;
+    static getDefaultConfig: typeof _getDefaultConfig;
     // (undocumented)
     identifier: string;
     // (undocumented)
     initialize(config: IConfiguration & IConfig, core: IAppInsightsCore, extensions: IPlugin[], pluginChain?: ITelemetryPluginChain): void;
     _onerror(exception: IAutoExceptionTelemetry): void;
-    // Warning: (ae-forgotten-export) The symbol "PageViewManager" needs to be exported by the entry point applicationinsights-web.d.ts
-    //
-    // (undocumented)
-    protected _pageViewManager: PageViewManager;
-    // Warning: (ae-forgotten-export) The symbol "PageViewPerformanceManager" needs to be exported by the entry point applicationinsights-web.d.ts
-    //
-    // (undocumented)
-    protected _pageViewPerformanceManager: PageViewPerformanceManager;
-    // Warning: (ae-forgotten-export) The symbol "PageVisitTimeManager" needs to be exported by the entry point applicationinsights-web.d.ts
-    //
-    // (undocumented)
-    protected _pageVisitTimeManager: PageVisitTimeManager;
     // (undocumented)
     priority: number;
     // (undocumented)
@@ -79,8 +71,6 @@ export class ApplicationAnalytics extends BaseTelemetryPlugin implements IAppIns
         [key: string]: number;
     }): void;
     // (undocumented)
-    protected _telemetryInitializers: Array<(envelope: ITelemetryItem) => boolean | void>;
-    // (undocumented)
     trackEvent(event: IEventTelemetry, customProperties?: ICustomProperties): void;
     trackException(exception: IExceptionTelemetry, customProperties?: ICustomProperties): void;
     trackMetric(metric: IMetricTelemetry, customProperties?: ICustomProperties): void;
@@ -97,7 +87,7 @@ export class ApplicationInsights implements IApplicationInsights {
     // (undocumented)
     addHousekeepingBeforeUnload(appInsightsInstance: IApplicationInsights): void;
     // (undocumented)
-    addTelemetryInitializer(telemetryInitializer: (item: ITelemetryItem) => boolean | void): void;
+    addTelemetryInitializer(telemetryInitializer: (item: ITelemetryItem) => boolean | void): void | ITelemetryInitializerHandler;
     // (undocumented)
     appInsights: ApplicationAnalytics;
     clearAuthenticatedUserContext(): void;
@@ -157,9 +147,12 @@ export class ApplicationInsightsContainer {
 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;
     // Warning: (ae-forgotten-export) The symbol "TelemetryInitializerFunction" needs to be exported by the entry point applicationinsights-web.d.ts
-    // Warning: (ae-forgotten-export) The symbol "ITelemetryInitializerHandler" needs to be exported by the entry point applicationinsights-web.d.ts
     addTelemetryInitializer(telemetryInitializer: TelemetryInitializerFunction): ITelemetryInitializerHandler | void;
+    // Warning: (ae-forgotten-export) The symbol "UnloadHandler" needs to be exported by the entry point applicationinsights-web.d.ts
+    addUnloadCb(handler: UnloadHandler): void;
     // (undocumented)
     config: IConfiguration;
     // (undocumented)
@@ -200,6 +193,11 @@ export class BaseCore implements IAppInsightsCore {
     stopPollingInternalLogs(): void;
     // (undocumented)
     track(telemetryItem: ITelemetryItem): void;
+    // Warning: (ae-forgotten-export) The symbol "ITelemetryUnloadState" needs to be exported by the entry point applicationinsights-web.d.ts
+    unload(isAsync?: boolean, unloadComplete?: (unloadState: ITelemetryUnloadState) => void, cbTimeout?: number): void;
+    // Warning: (ae-forgotten-export) The symbol "IProcessTelemetryUpdateContext" needs to be exported by the entry point applicationinsights-web.d.ts
+    // Warning: (ae-forgotten-export) The symbol "ITelemetryUpdateState" needs to be exported by the entry point applicationinsights-web.d.ts
+    protected _updateHook?(updateCtx: IProcessTelemetryUpdateContext, updateState: ITelemetryUpdateState): void | boolean;
 }
 
 // @public
@@ -207,11 +205,12 @@ export abstract class BaseTelemetryPlugin implements ITelemetryPlugin {
     constructor();
     // Warning: (ae-forgotten-export) The symbol "IInstrumentHook" needs to be exported by the entry point applicationinsights-web.d.ts
     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-web.d.ts
-    // Warning: (ae-forgotten-export) The symbol "ITelemetryUnloadState" needs to be exported by the entry point applicationinsights-web.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;
@@ -226,6 +225,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;
 }
@@ -391,7 +391,9 @@ export interface IAppInsights {
 // @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;
@@ -414,6 +416,7 @@ export interface IAppInsightsCore extends IPerfManagerProvider {
     stopPollingInternalLogs?(): void;
     // (undocumented)
     track(telemetryItem: ITelemetryItem): void;
+    unload(isAsync?: boolean, unloadComplete?: () => void): void;
 }
 
 // @public (undocumented)

package/dist/applicationinsights-web.d.ts

@@ -1,5 +1,5 @@
 /*
- * Microsoft.ApplicationInsights, 2.8.0-beta.2203-02
+ * Microsoft.ApplicationInsights, 2.8.0-beta.2203-05
  * Copyright (c) Microsoft and contributors. All rights reserved.
  *
  * Microsoft Application Insights Team
@@ -48,16 +48,12 @@ declare namespace ApplicationInsights {
 
     class ApplicationAnalytics extends BaseTelemetryPlugin implements IAppInsights, IAppInsightsInternal {
         static Version: string;
-        static getDefaultConfig(config?: IConfig): IConfig;
+        static getDefaultConfig: typeof _getDefaultConfig;
         identifier: string;
         priority: number;
         config: IConfig;
         queue: Array<() => void>;
         autoRoutePVDelay: number;
-        protected _telemetryInitializers: Array<(envelope: ITelemetryItem) => boolean | void>;
-        protected _pageViewManager: PageViewManager;
-        protected _pageViewPerformanceManager: PageViewPerformanceManager;
-        protected _pageVisitTimeManager: PageVisitTimeManager;
         constructor();
         /**
          * Get the current cookie manager for this instance
@@ -181,7 +177,7 @@ declare namespace ApplicationInsights {
          * @memberof ApplicationInsights
          */
         _onerror(exception: IAutoExceptionTelemetry): void;
-        addTelemetryInitializer(telemetryInitializer: (item: ITelemetryItem) => boolean | void): void;
+        addTelemetryInitializer(telemetryInitializer: (item: ITelemetryItem) => boolean | void): ITelemetryInitializerHandler | void;
         initialize(config: IConfiguration & IConfig, core: IAppInsightsCore, extensions: IPlugin[], pluginChain?: ITelemetryPluginChain): void;
     }
 
@@ -292,7 +288,7 @@ declare namespace ApplicationInsights {
         }, measurements?: {
             [key: string]: number;
         }): void;
-        addTelemetryInitializer(telemetryInitializer: (item: ITelemetryItem) => boolean | void): void;
+        addTelemetryInitializer(telemetryInitializer: (item: ITelemetryItem) => boolean | void): void | ITelemetryInitializerHandler;
         /**
          * Set the authenticated user id and the account id. Used for identifying a specific signed-in user. Parameters must not contain whitespace or ,;=|
          *
@@ -417,12 +413,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;
     }
 
     /**
@@ -479,6 +497,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;
         /**
@@ -491,6 +517,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
@@ -957,6 +995,8 @@ declare namespace ApplicationInsights {
      */
     function _formatErrorCode(errorObj: any): any;
 
+    function _getDefaultConfig(config?: IConfig): IConfig;
+
     const enum GetExtCfgMergeType {
         None = 0,
         MergeDefaultOnly = 1,
@@ -1050,15 +1090,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 IAppInsightsDeprecated {
@@ -2678,6 +2739,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
          */
@@ -2736,6 +2802,7 @@ declare namespace ApplicationInsights {
          * (unless it's also been re-initialized)
          */
         setEnabled: (isEnabled: boolean) => void;
+        remove: (isAsync?: boolean, removeCb?: (removed?: boolean) => void) => void;
     }
 
     interface ILocation {
@@ -3257,8 +3324,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 {
         /**
@@ -3277,6 +3344,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 IPropertiesPlugin {
         readonly context: ITelemetryContext;
     }
@@ -3673,6 +3761,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 ITelemetryTrace {
@@ -3700,6 +3797,27 @@ 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 ITraceState {
     }
 
@@ -4145,26 +4263,6 @@ declare namespace ApplicationInsights {
         constructor();
     }
 
-    /**
-     * Class encapsulates sending page views and page view performance telemetry.
-     */
-    class PageViewManager {
-        constructor(appInsights: IAppInsightsInternal, overridePageViewDuration: boolean, core: IAppInsightsCore, pageViewPerformanceManager: PageViewPerformanceManager);
-        /**
-         * Currently supported cases:
-         * 1) (default case) track page view called with default parameters, overridePageViewDuration = false. Page view is sent with page view performance when navigation timing data is available.
-         *    a. If navigation timing is not supported then page view is sent right away with undefined duration. Page view performance is not sent.
-         * 2) overridePageViewDuration = true, custom duration provided. Custom duration is used, page view sends right away.
-         * 3) overridePageViewDuration = true, custom duration NOT provided. Page view is sent right away, duration is time spent from page load till now (or undefined if navigation timing is not supported).
-         * 4) overridePageViewDuration = false, custom duration is provided. Page view is sent right away with custom duration.
-         *
-         * In all cases page view performance is sent once (only for the 1st call of trackPageView), or not sent if navigation timing is not supported.
-         */
-        trackPageView(pageView: IPageViewTelemetry, customProperties?: {
-            [key: string]: any;
-        }): void;
-    }
-
     /**
      * An instance of PageViewPerf represents: a page view with no performance data, a page view with performance data, or just the performance data of an earlier page request.
      */
@@ -4242,81 +4340,6 @@ declare namespace ApplicationInsights {
         }, cs4BaseData?: IPageViewPerformanceTelemetry);
     }
 
-    /**
-     * Class encapsulates sending page view performance telemetry.
-     */
-    class PageViewPerformanceManager {
-        private _logger;
-        private MAX_DURATION_ALLOWED;
-        constructor(core: IAppInsightsCore);
-        populatePageViewPerformanceEvent(pageViewPerformance: IPageViewPerformanceTelemetryInternal): void;
-        getPerformanceTiming(): PerformanceTiming | null;
-        getPerformanceNavigationTiming(): PerformanceNavigationTiming | null;
-        /**
-         * Returns true is window PerformanceNavigationTiming API is supported, false otherwise.
-         */
-        isPerformanceNavigationTimingSupported(): boolean;
-        /**
-         * Returns true is window performance timing API is supported, false otherwise.
-         */
-        isPerformanceTimingSupported(): PerformanceTiming;
-        /**
-         * As page loads different parts of performance timing numbers get set. When all of them are set we can report it.
-         * Returns true if ready, false otherwise.
-         */
-        isPerformanceTimingDataReady(): boolean;
-        /**
-         * This method tells if given durations should be excluded from collection.
-         */
-        shouldCollectDuration(...durations: number[]): boolean;
-    }
-
-    class PageVisitData {
-        pageName: string;
-        pageUrl: string;
-        pageVisitStartTime: number;
-        pageVisitTime: number;
-        constructor(pageName: string, pageUrl: string);
-    }
-
-    /**
-     * Used to track page visit durations
-     */
-    class PageVisitTimeManager {
-        private prevPageVisitDataKeyName;
-        private pageVisitTimeTrackingHandler;
-        private _logger;
-        /**
-         * Creates a new instance of PageVisitTimeManager
-         * @param pageVisitTimeTrackingHandler Delegate that will be called to send telemetry data to AI (when trackPreviousPageVisit is called)
-         * @returns {}
-         */
-        constructor(logger: IDiagnosticLogger, pageVisitTimeTrackingHandler: (pageName: string, pageUrl: string, pageVisitTime: number) => void);
-        /**
-         * Tracks the previous page visit time telemetry (if exists) and starts timing of new page visit time
-         * @param currentPageName Name of page to begin timing for visit duration
-         * @param currentPageUrl Url of page to begin timing for visit duration
-         */
-        trackPreviousPageVisit(currentPageName: string, currentPageUrl: string): void;
-        /**
-         * Stops timing of current page (if exists) and starts timing for duration of visit to pageName
-         * @param pageName Name of page to begin timing visit duration
-         * @returns {PageVisitData} Page visit data (including duration) of pageName from last call to start or restart, if exists. Null if not.
-         */
-        restartPageVisitTimer(pageName: string, pageUrl: string): PageVisitData;
-        /**
-         * Starts timing visit duration of pageName
-         * @param pageName
-         * @returns {}
-         */
-        startPageVisitTimer(pageName: string, pageUrl: string): void;
-        /**
-         * Stops timing of current page, if exists.
-         * @returns {PageVisitData} Page visit data (including duration) of pageName from call to start, if exists. Null if not.
-         */
-        stopPageVisitTimer(): PageVisitData;
-    }
-
     function parseConnectionString(connectionString?: string): ConnectionString;
 
     class PerfEvent implements IPerfEvent {
@@ -4604,6 +4627,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
          */
@@ -4789,7 +4816,40 @@ 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
     }
 
     class Trace extends MessageData implements ISerializable {
@@ -4809,6 +4869,8 @@ declare namespace ApplicationInsights {
         });
     }
 
+    type UnloadHandler = (itemCtx: IProcessTelemetryUnloadContext, unloadState: ITelemetryUnloadState) => void;
+
     const Util: IUtil;
 
     interface XDomainRequest extends XMLHttpRequestEventTarget {