@microsoft/applicationinsights-web-basic 2.8.0-beta.2202-07 → 2.8.0-beta.2203-03

package/dist/applicationinsights-web-basic.rollup.d.ts

@@ -1,5 +1,5 @@
 /*
- * Microsoft.ApplicationInsights, 2.8.0-beta.2202-07
+ * Microsoft.ApplicationInsights, 2.8.0-beta.2203-03
  * Copyright (c) Microsoft and contributors. All rights reserved.
  *
  * Microsoft Application Insights Team
@@ -106,7 +106,26 @@ declare class BaseCore implements IAppInsightsCore {
      * @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?: () => void): 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;
 }
 
@@ -155,9 +174,32 @@ declare abstract class BaseTelemetryPlugin implements ITelemetryPlugin {
      * Internal helper to allow setting of the internal initialized setting for inherited instances and unit testing
      */
     protected setInitialized: (isInitialized: boolean) => void;
+    /**
+     * Teardown / Unload hook to allow implementations to perform some additional unload operations before the BaseTelemetryPlugin
+     * finishes it's removal.
+     * @param unloadCtx - This is the context that should be used during unloading.
+     * @param unloadState - The details / state of the unload process, it holds details like whether it should be unloaded synchronously or asynchronously and the reason for the unload.
+     * @param asyncCallback - An optional callback that the plugin must call if it returns true to inform the caller that it has completed any async unload/teardown operations.
+     * @returns boolean - true if the plugin has or will call asyncCallback, this allows the plugin to perform any asynchronous operations.
+     */
+    protected _doTeardown?: (unloadCtx?: IProcessTelemetryUnloadContext, unloadState?: ITelemetryUnloadState, 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;
+    /**
+     * 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
@@ -173,7 +215,15 @@ declare abstract class BaseTelemetryPlugin implements ITelemetryPlugin {
  */
 export declare const CoreUtils: ICoreUtils;
 
-declare enum DistributedTracingModes {
+declare const DistributedTracingModes: {
+    AI: number;
+    AI_AND_W3C: number;
+    W3C: number;
+};
+
+declare type DistributedTracingModes = number | eDistributedTracingModes;
+
+declare const enum eDistributedTracingModes {
     /**
      * (Default) Send Application Insights correlation headers
      */
@@ -188,6 +238,102 @@ declare enum DistributedTracingModes {
     W3C = 2
 }
 
+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
+}
+
+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
+}
+
 declare const enum GetExtCfgMergeType {
     None = 0,
     MergeDefaultOnly = 1,
@@ -241,11 +387,36 @@ export declare interface IAppInsightsCore extends IPerfManagerProvider {
      * 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;
 }
 
 /**
@@ -329,6 +500,67 @@ declare interface IBackendResponse {
     readonly appId?: string;
 }
 
+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: Function, 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;
+}
+
 /**
  * Provides data transmission capabilities
  */
@@ -342,9 +574,14 @@ 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
@@ -1028,7 +1265,7 @@ 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
@@ -1257,6 +1494,20 @@ declare interface IInstrumentHooksCallbacks {
 
 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;
 }
 
 export declare interface IMetricTelemetry extends IPartC {
@@ -1478,7 +1729,7 @@ declare const _InternalMessageId: {
     InMemoryStorageBufferFull: number;
 };
 
-declare type _InternalMessageId = number | typeof _InternalMessageId;
+declare type _InternalMessageId = number | _eInternalMessageId;
 
 export declare interface IPageViewPerformanceTelemetry extends IPartC {
     /**
@@ -1693,10 +1944,14 @@ 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
      */
@@ -1711,67 +1966,42 @@ declare interface IPlugin {
  * The current context for the current call to processTelemetry(), used to support sharing the same plugin instance
  * between multiple AppInsights instances
  */
-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, 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;
+declare interface IProcessTelemetryContext extends IBaseProcessingContext {
     /**
      * 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)
      */
-    processNext: (env: ITelemetryItem) => void;
-    /**
-     * Synchronously iterate over the context chain running the callback for each plugin, once
-     * every plugin has been executed via the callback, any associated onComplete will be called.
-     * @param callback - The function call for each plugin in the context chain
-     */
-    iterate: <T extends ITelemetryPlugin = ITelemetryPlugin>(callback: (plugin: T) => void) => void;
+    processNext: (env: ITelemetryItem) => 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;
+}
+
+/**
+ * The current context for the current call to processTelemetry(), used to support sharing the same plugin instance
+ * between multiple AppInsights instances
+ */
+declare interface IProcessTelemetryUnloadContext extends IBaseProcessingContext {
     /**
-     * Set the function to call when the current chain has executed all processNext or unloadNext items.
+     * 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)
      */
-    onComplete: (onComplete: () => void) => void;
+    processNext: (unloadState: ITelemetryUnloadState) => 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) => IProcessTelemetryUnloadContext;
 }
 
 declare interface IRequestContext {
@@ -1966,15 +2196,7 @@ export declare interface ITelemetryItem {
 /**
  * Configuration provided to SDK core
  */
-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;
+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
@@ -1990,7 +2212,7 @@ declare interface ITelemetryPlugin extends IPlugin {
 /**
  * Configuration provided to SDK core
  */
-declare interface ITelemetryPluginChain {
+declare interface ITelemetryPluginChain extends ITelemetryProcessor {
     /**
      * Returns the underlying plugin that is being proxied for the processTelemetry call
      */
@@ -1999,6 +2221,16 @@ 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
@@ -2006,7 +2238,13 @@ 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;
+}
+
+declare interface ITelemetryUnloadState {
+    reason: TelemetryUnloadReason;
+    isAsync: boolean;
+    flushComplete?: boolean;
 }
 
 export declare interface ITraceTelemetry extends IPartC {
@@ -2030,16 +2268,12 @@ export declare interface ITraceTelemetry extends IPartC {
     iKey?: string;
 }
 
-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
-}
+declare const LoggingSeverity: {
+    CRITICAL: number;
+    WARNING: number;
+};
+
+declare type LoggingSeverity = number | eLoggingSeverity;
 
 export declare class Sender extends BaseTelemetryPlugin implements IChannelControlsAI {
     static constructEnvelope(orig: ITelemetryItem, iKey: string, logger: IDiagnosticLogger, convertUndefined?: any): IEnvelope;
@@ -2156,6 +2390,10 @@ 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
      */
@@ -2183,6 +2421,30 @@ declare interface Tags {
 
 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().
+ */
+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
+}
+
+declare type UnloadHandler = (itemCtx: IProcessTelemetryUnloadContext, unloadState: ITelemetryUnloadState) => void;
+
 declare interface XDomainRequest extends XMLHttpRequestEventTarget {
     readonly responseText: string;
     send(payload: string): void;

package/dist-esm/index.js

@@ -1,5 +1,5 @@
 /*
- * Application Insights JavaScript Web SDK - Basic, 2.8.0-beta.2202-07
+ * Application Insights JavaScript Web SDK - Basic, 2.8.0-beta.2203-03
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@microsoft/applicationinsights-web-basic",
-    "version": "2.8.0-beta.2202-07",
+    "version": "2.8.0-beta.2203-03",
     "description": "Microsoft Application Insights Javascript SDK core and channel",
     "homepage": "https://github.com/microsoft/ApplicationInsights-JS#readme",
     "author": "Microsoft Application Insights Team",
@@ -49,9 +49,9 @@
     "dependencies": {
         "@microsoft/dynamicproto-js": "^1.1.4",
         "@microsoft/applicationinsights-shims": "2.0.1",
-        "@microsoft/applicationinsights-common": "2.8.0-beta.2202-07",
-        "@microsoft/applicationinsights-channel-js": "2.8.0-beta.2202-07",
-        "@microsoft/applicationinsights-core-js": "2.8.0-beta.2202-07"
+        "@microsoft/applicationinsights-common": "2.8.0-beta.2203-03",
+        "@microsoft/applicationinsights-channel-js": "2.8.0-beta.2203-03",
+        "@microsoft/applicationinsights-core-js": "2.8.0-beta.2203-03"
     },
     "license": "MIT",
     "publishConfig": {

package/browser/aib.2.8.0-beta.2202-07.integrity.json

@@ -1,26 +0,0 @@
-{
-    "name": "aib",
-    "version": "2.8.0-beta.2202-07",
-    "ext": {
-        "@js": {
-            "file": "aib.2.8.0-beta.2202-07.js",
-            "type": "text/javascript; charset=utf-8",
-            "integrity": "sha256-/jE9jDCTgKaw42c/SciSg/5fU2dYoiFFE0aTFWDKezU= sha384-I0HQbhCWlNmCB32bhjwzVxi0WrIPWeU89mQ/TxCW1U+NlglCDcY8Pd3qLGbFNRgx sha512-VuytWh9pRHMAA4HgtCs67aMOz1wpyfTAlGwNkmNnZNU0nCrHBx+ZVb/nO9RKYZcUUnLgYsHcdZ35wvFZn0rCjQ==",
-            "hashes": {
-                "sha256": "/jE9jDCTgKaw42c/SciSg/5fU2dYoiFFE0aTFWDKezU=",
-                "sha384": "I0HQbhCWlNmCB32bhjwzVxi0WrIPWeU89mQ/TxCW1U+NlglCDcY8Pd3qLGbFNRgx",
-                "sha512": "VuytWh9pRHMAA4HgtCs67aMOz1wpyfTAlGwNkmNnZNU0nCrHBx+ZVb/nO9RKYZcUUnLgYsHcdZ35wvFZn0rCjQ=="
-            }
-        },
-        "@min.js": {
-            "file": "aib.2.8.0-beta.2202-07.min.js",
-            "type": "text/javascript; charset=utf-8",
-            "integrity": "sha256-JiRszJemSh2CQdIjW89TGYu+q0pr3SzmUu9dvKOK+Pw= sha384-2RgIzyKlFEJ8divMlstNTyQGwj2yShTTGRCbDtKEUOn55zEqGwFEDDLYAEiokw3R sha512-sSRhL+sNkS44HKDoXak5fXdPy6zwfYqhREQWMIWd0mIbGkBIpVLgzw9pJRsL4B+TpzKyoDK/6A2nEBcK2YtwYQ==",
-            "hashes": {
-                "sha256": "JiRszJemSh2CQdIjW89TGYu+q0pr3SzmUu9dvKOK+Pw=",
-                "sha384": "2RgIzyKlFEJ8divMlstNTyQGwj2yShTTGRCbDtKEUOn55zEqGwFEDDLYAEiokw3R",
-                "sha512": "sSRhL+sNkS44HKDoXak5fXdPy6zwfYqhREQWMIWd0mIbGkBIpVLgzw9pJRsL4B+TpzKyoDK/6A2nEBcK2YtwYQ=="
-            }
-        }
-    }
-}