@microsoft/applicationinsights-web-basic 2.7.5-nightly.2204-03 → 2.7.6

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

@@ -1,5 +1,5 @@
 /*
- * Microsoft.ApplicationInsights, 2.7.5-nightly.2204-03
+ * Microsoft.ApplicationInsights, 2.7.6
  * Copyright (c) Microsoft and contributors. All rights reserved.
  *
  * Microsoft Application Insights Team
@@ -17,6 +17,26 @@ export declare class AppInsightsCore extends BaseCore implements IAppInsightsCor
     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;
 }
 
 /**
@@ -25,6 +45,7 @@ export declare class AppInsightsCore extends BaseCore implements IAppInsightsCor
  */
 export declare class ApplicationInsights {
     config: IConfiguration & IConfig;
+    private core;
     /**
      * Creates an instance of ApplicationInsights.
      * @param {IConfiguration & IConfig} config
@@ -50,51 +71,11 @@ export declare class ApplicationInsights {
      * @memberof ApplicationInsights
      */
     flush(async?: boolean): void;
-    pollInternalLogs(): void;
+    private pollInternalLogs;
     stopPollingInternalLogs(): void;
-    getSKUDefaults(): 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;
-    /**
-     * 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
-     */
-    evtNamespace(): string;
-    /**
-     * Add an unload handler that will be called when the SDK is being unloaded
-     * @param handler - the handler
-     */
-    addUnloadCb(handler: UnloadHandler): void;
+    private getSKUDefaults;
 }
 
-/**
- * Performs the specified action for each element in an array. This helper exists to avoid adding a polyfil for older browsers
- * that do not define Array.prototype.xxxx (eg. ES3 only, IE8) just in case any page checks for presence/absence of the prototype
- * implementation. Note: For consistency this will not use the Array.prototype.xxxx implementation if it exists as this would
- * cause a testing requirement to test with and without the implementations
- * @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 = any>(arr: T[], callbackfn: (value: T, index?: number, array?: T[]) => undefined | void | number, thisArg?: any): void;
-
 declare class BaseCore implements IAppInsightsCore {
     static defaultConfig: IConfiguration;
     config: IConfiguration;
@@ -107,18 +88,6 @@ 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
      */
@@ -131,67 +100,7 @@ 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;
 }
 
 /**
@@ -200,13 +109,6 @@ declare class BaseCore implements IAppInsightsCore {
  * implementation so that new default implementations can be added without breaking all plugins.
  */
 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
@@ -228,6 +130,13 @@ 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
@@ -240,51 +149,12 @@ declare abstract class BaseTelemetryPlugin implements ITelemetryPlugin {
      */
     protected setInitialized: (isInitialized: boolean) => void;
     /**
-     * Teardown / Unload hook to allow implementations to perform some additional unload operations before the BaseTelemetryPlugin
-     * finishes it's removal.
-     * @param unloadCtx - This is the context that should be used during unloading.
-     * @param unloadState - The details / state of the unload process, it holds details like whether it should be unloaded synchronously or asynchronously and the reason for the unload.
-     * @param asyncCallback - An optional callback that the plugin must call if it returns true to inform the caller that it has completed any async unload/teardown operations.
-     * @returns boolean - true if the plugin has or will call asyncCallback, this allows the plugin to perform any asynchronous operations.
+     * Internal helper to initialize the instance
      */
-    protected _doTeardown?: (unloadCtx?: IProcessTelemetryUnloadContext, unloadState?: ITelemetryUnloadState, asyncCallback?: () => void) => void | boolean;
-    /**
-     * Extension hook to allow implementations to perform some additional update operations before the BaseTelemetryPlugin finishes it's removal
-     * @param updateCtx - This is the context that should be used during updating.
-     * @param updateState - The details / state of the update process, it holds details like the current and previous configuration.
-     * @param asyncCallback - An optional callback that the plugin must call if it returns true to inform the caller that it has completed any async update operations.
-     * @returns boolean - true if the plugin has or will call asyncCallback, this allows the plugin to perform any asynchronous operations.
-     */
-    protected _doUpdate?: (updateCtx?: IProcessTelemetryUpdateContext, updateState?: ITelemetryUpdateState, asyncCallback?: () => void) => void | boolean;
+    private _baseTelInit;
     constructor();
     initialize(config: IConfiguration, core: IAppInsightsCore, extensions: IPlugin[], pluginChain?: ITelemetryPluginChain): void;
-    /**
-     * Tear down the plugin and remove any hooked value, the plugin should be removed so that it is no longer initialized and
-     * therefore could be re-initialized after being torn down. The plugin should ensure that once this has been called any further
-     * processTelemetry calls are ignored and it just calls the processNext() with the provided context.
-     * @param unloadCtx - This is the context that should be used during unloading.
-     * @param unloadState - The details / state of the unload process, it holds details like whether it should be unloaded synchronously or asynchronously and the reason for the unload.
-     * @returns boolean - true if the plugin has or will call processNext(), this for backward compatibility as previously teardown was synchronous and returned nothing.
-     */
-    teardown(unloadCtx?: IProcessTelemetryUnloadContext, unloadState?: ITelemetryUnloadState): void | boolean;
     abstract processTelemetry(env: ITelemetryItem, itemCtx?: IProcessTelemetryContext): void;
-    /**
-     * The the plugin should re-evaluate configuration and update any cached configuration settings.
-     * @param updateCtx - This is the context that should be used during updating.
-     * @param updateState - The details / state of the update process, it holds details like the current and previous configuration.
-     * @returns boolean - true if the plugin has or will call updateCtx.processNext(), this allows the plugin to perform any asynchronous operations.
-     */
-    update(updateCtx: IProcessTelemetryUpdateContext, updateState: ITelemetryUpdateState): void | boolean;
-    /**
-     * Add an unload handler that will be called when the SDK is being unloaded
-     * @param handler - the handler
-     */
-    protected _addUnloadCb(handler: UnloadHandler): void;
-    /**
-     * Add this hook so that it is automatically removed during unloading
-     * @param hooks - The single hook or an array of IInstrumentHook objects
-     */
-    protected _addHook(hooks: IInstrumentHook | IInstrumentHook[]): void;
 }
 
 /**
@@ -295,15 +165,7 @@ declare abstract class BaseTelemetryPlugin implements ITelemetryPlugin {
  */
 export declare const CoreUtils: ICoreUtils;
 
-declare const DistributedTracingModes: {
-    AI: number;
-    AI_AND_W3C: number;
-    W3C: number;
-};
-
-declare type DistributedTracingModes = number | eDistributedTracingModes;
-
-declare const enum eDistributedTracingModes {
+declare enum DistributedTracingModes {
     /**
      * (Default) Send Application Insights correlation headers
      */
@@ -318,108 +180,6 @@ declare const enum eDistributedTracingModes {
     W3C = 2
 }
 
-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
-}
-
-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,
-    MergeDefaultFromRootOrDefault = 2
-}
-
 export declare interface IAppInsightsCore extends IPerfManagerProvider {
     config: IConfiguration;
     logger: IDiagnosticLogger;
@@ -455,62 +215,12 @@ 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;
 }
 
 /**
@@ -594,67 +304,6 @@ 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: () => 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;
-}
-
 /**
  * Provides data transmission capabilities
  */
@@ -668,23 +317,15 @@ declare interface IChannelControls extends ITelemetryPlugin {
      */
     resume(): void;
     /**
-     * Tear down the plugin and remove any hooked value, the plugin should be removed so that it is no longer initialized and
-     * therefore could be re-initialized after being torn down. The plugin should ensure that once this has been called any further
-     * processTelemetry calls are ignored and it just calls the processNext() with the provided context.
-     * @param unloadCtx - This is the context that should be used during unloading.
-     * @param unloadState - The details / state of the unload process, it holds details like whether it should be unloaded synchronously or asynchronously and the reason for the unload.
-     * @returns boolean - true if the plugin has or will call processNext(), this for backward compatibility as previously teardown was synchronous and returned nothing.
+     * Tear down transmission pipeline
      */
-    teardown: (unloadCtx?: IProcessTelemetryUnloadContext, unloadState?: ITelemetryUnloadState) => void | boolean;
+    teardown(): void;
     /**
      * Flush to send data immediately; channel should default to sending data asynchronously
-     * @param async - send data asynchronously when true
-     * @param callBack - if specified, notify caller when send is complete, the channel should return true to indicate to the caller that it will be called.
-     * If the caller doesn't return true the caller should assume that it may never be called.
-     * @param sendReason - specify the reason that you are calling "flush" defaults to ManualFlush (1) if not specified
-     * @returns - true if the callback will be return after the flush is complete otherwise the caller should assume that any provided callback will never be called
+     * @param async: send data asynchronously when true
+     * @param callBack: if specified, notify caller when send is complete
      */
-    flush(async: boolean, callBack?: (flushComplete?: boolean) => void, sendReason?: SendRequestReason): boolean | void;
+    flush(async: boolean, callBack?: () => void): void;
 }
 
 declare interface IChannelControlsAI extends IChannelControls {
@@ -1359,7 +1000,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, evtNamespace?: string | string[]) => boolean;
+    addEventHandler: (eventName: string, callback: any) => boolean;
     /**
      * Return the current time via the Date now() function (if available) and falls back to (new Date()).getTime() if now() is unavailable (IE8 or less)
      * https://caniuse.com/#search=Date.now
@@ -1519,96 +1160,6 @@ export declare interface IEventTelemetry extends IPartC {
     iKey?: string;
 }
 
-declare interface IInstrumentCallDetails {
-    name: string;
-    inst: any;
-    /**
-     * This returns an object that the hook function can use to store hook specific
-     * context, it it not shared with any other hook instances and is unique for the
-     * current call.
-     * A hook implementation can use this to pass / share context between different
-     * hook callbacks eg. request/response requst/hookErrors etc.
-     */
-    ctx: () => any;
-    /**
-     * Allows the hook functions to replace the original arguments
-     * @param idx - The argument index (0 based)
-     * @param value - The new value for the argument
-     */
-    set: (idx: number, value: any) => void;
-    /**
-     * The result of the original method, only populated after the original method has returned
-     */
-    rslt?: any;
-    /**
-     * 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;
-}
-
-/**
- * The holder of the specific instance callback
- */
-declare interface IInstrumentHook {
-    /** Unique Id for this callback on the hooked method */
-    id: number;
-    /** Holds the callbacks */
-    cbks: IInstrumentHooksCallbacks;
-    /** Remove this hook from the function */
-    rm: () => void;
-}
-
-/**
- * The callbacks to call for the instrumented function, you must provide at least the request and/or response callbacks, both are not required.
- * You must always supply the error callback
- */
-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
-     */
-    req?: InstrumentorHooksCallback;
-    /**
-     * The hook callback to call after the original function was called
-     */
-    rsp?: InstrumentorHooksCallback;
-    /**
-     * The callback to call if the hook function causes an exception
-     */
-    hkErr?: InstrumentorHooksCallback;
-    /**
-     * The callback to call if the original function causes an exception, even if you
-     * supply a callback the original exception will still be thrown
-     */
-    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;
-}
-
 export declare interface IMetricTelemetry extends IPartC {
     /**
      * @description (required) - name of this metric
@@ -1727,12 +1278,6 @@ declare interface INotificationManager {
     perfEvent?(perfEvent: IPerfEvent): void;
 }
 
-/**
- * A callback function that will be called for the wrapped instrumentation function
- * before the original function is executed.
- */
-declare type InstrumentorHooksCallback = (funcArgs: IInstrumentCallDetails, ...orgArgs: any[]) => void;
-
 declare class _InternalLogMessage {
     static dataType: string;
     message: string;
@@ -1743,7 +1288,7 @@ declare class _InternalLogMessage {
 /**
  * Internal message ID. Please create a new one for every conceptually different message. Please keep alphabetically ordered
  */
-export declare const _InternalMessageId: {
+declare const _InternalMessageId: {
     BrowserDoesNotSupportLocalStorage: number;
     BrowserCannotReadLocalStorage: number;
     BrowserCannotReadSessionStorage: number;
@@ -1828,7 +1373,7 @@ export declare const _InternalMessageId: {
     InMemoryStorageBufferFull: number;
 };
 
-export declare type _InternalMessageId = number | _eInternalMessageId;
+declare type _InternalMessageId = number | typeof _InternalMessageId;
 
 export declare interface IPageViewPerformanceTelemetry extends IPartC {
     /**
@@ -2027,7 +1572,7 @@ declare interface IPerfManagerProvider {
     setPerfMgr(perfMgr: IPerfManager): void;
 }
 
-export declare interface IPlugin {
+declare interface IPlugin {
     /**
      * Initialize plugin loaded by SDK
      * @param config - The config for the plugin to use
@@ -2043,14 +1588,10 @@ export declare interface IPlugin {
      */
     isInitialized?: () => boolean;
     /**
-     * Tear down the plugin and remove any hooked value, the plugin should be removed so that it is no longer initialized and
-     * therefore could be re-initialized after being torn down. The plugin should ensure that once this has been called any further
-     * processTelemetry calls are ignored and it just calls the processNext() with the provided context.
-     * @param unloadCtx - This is the context that should be used during unloading.
-     * @param unloadState - The details / state of the unload process, it holds details like whether it should be unloaded synchronously or asynchronously and the reason for the unload.
-     * @returns boolean - true if the plugin has or will call processNext(), this for backward compatibility as previously teardown was synchronous and returned nothing.
+     * Tear down the plugin and remove any hooked value, the plugin should remove that it is no longer initialized and
+     * therefore can be re-initialized after being torn down.
      */
-    teardown?: (unloadCtx: IProcessTelemetryUnloadContext, unloadState?: ITelemetryUnloadState) => void | boolean;
+    teardown?: () => void;
     /**
      * Extension name
      */
@@ -2065,63 +1606,57 @@ 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
  */
-declare interface IProcessTelemetryContext extends IBaseProcessingContext {
+declare interface IProcessTelemetryContext {
     /**
-     * Call back for telemetry processing before it it is sent
-     * @param env - This is the current event being reported
-     * @returns boolean (true) if there is no more plugins to process otherwise false or undefined (void)
+     * The current core instance for the request
      */
-    processNext: (env: ITelemetryItem) => boolean | void;
+    core: () => IAppInsightsCore;
     /**
-     * Create a new context using the core and config from the current instance, returns a new instance of the same type
-     * @param plugins - The execution order to process the plugins, if null or not supplied
-     *                  then the current execution order will be copied.
-     * @param startAt - The plugin to start processing from, if missing from the execution
-     *                  order then the next plugin will be NOT set.
+     * THe current diagnostic logger for the request
      */
-    createNew: (plugins?: IPlugin[] | ITelemetryPluginChain, startAt?: IPlugin) => IProcessTelemetryContext;
-}
-
-/**
- * The current context for the current call to teardown() implementations, used to support when plugins are being removed
- * or the SDK is being unloaded.
- */
-declare interface IProcessTelemetryUnloadContext extends IBaseProcessingContext {
+    diagLog: () => IDiagnosticLogger;
     /**
-     * This Plugin has finished unloading, so unload the next one
-     * @param uploadState - The state of the unload process
-     * @returns boolean (true) if there is no more plugins to process otherwise false or undefined (void)
+     * Gets the current core config instance
      */
-    processNext: (unloadState: ITelemetryUnloadState) => boolean | void;
+    getCfg: () => IConfiguration;
     /**
-     * Create a new context using the core and config from the current instance, returns a new instance of the same type
-     * @param plugins - The execution order to process the plugins, if null or not supplied
-     *                  then the current execution order will be copied.
-     * @param startAt - The plugin to start processing from, if missing from the execution
-     *                  order then the next plugin will be NOT set.
+     * Gets the named extension config
      */
-    createNew: (plugins?: IPlugin[] | ITelemetryPluginChain, startAt?: IPlugin) => IProcessTelemetryUnloadContext;
-}
-
-/**
- * The current context for the current call to the plugin update() implementations, used to support the notifications
- * for when plugins are added, removed or the configuration was changed.
- */
-declare interface IProcessTelemetryUpdateContext extends IBaseProcessingContext {
+    getExtCfg: <T>(identifier: string, defaultValue?: T | any) => T;
     /**
-     * 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)
+     * 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
      */
-    processNext: (updateState: ITelemetryUpdateState) => boolean | void;
+    getConfig: (identifier: string, field: string, defaultValue?: number | string | boolean) => number | string | boolean;
     /**
-     * Create a new context using the core and config from the current instance, returns a new instance of the same type
+     * 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;
+    /**
+     * Call back for telemetry processing before it it is sent
+     * @param env - This is the current event being reported
+     */
+    processNext: (env: ITelemetryItem) => void;
+    /**
+     * Create a new context using the core and config from the current instance
      * @param plugins - The execution order to process the plugins, if null or not supplied
      *                  then the current execution order will be copied.
      * @param startAt - The plugin to start processing from, if missing from the execution
      *                  order then the next plugin will be NOT set.
      */
-    createNew: (plugins?: IPlugin[] | ITelemetryPluginChain, startAt?: IPlugin) => IProcessTelemetryUpdateContext;
+    createNew: (plugins?: IPlugin[] | ITelemetryPluginChain, startAt?: IPlugin) => IProcessTelemetryContext;
 }
 
 declare interface IRequestContext {
@@ -2258,17 +1793,11 @@ declare interface ISerializable {
     aiDataContract: any;
 }
 
-export declare function isNullOrUndefined(value: any): value is null | undefined;
-
 declare interface IStackDetails {
     src: string;
     obj: string[];
 }
 
-declare interface ITelemetryInitializerHandler {
-    remove(): void;
-}
-
 /**
  * Telemety item supported in Core
  */
@@ -2318,7 +1847,15 @@ export declare interface ITelemetryItem {
 /**
  * Configuration provided to SDK core
  */
-export declare interface ITelemetryPlugin extends ITelemetryProcessor, IPlugin {
+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;
     /**
      * 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
@@ -2334,7 +1871,7 @@ export declare interface ITelemetryPlugin extends ITelemetryProcessor, IPlugin {
 /**
  * Configuration provided to SDK core
  */
-declare interface ITelemetryPluginChain extends ITelemetryProcessor {
+declare interface ITelemetryPluginChain {
     /**
      * Returns the underlying plugin that is being proxied for the processTelemetry call
      */
@@ -2343,16 +1880,6 @@ declare interface ITelemetryPluginChain extends ITelemetryProcessor {
      * 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
@@ -2360,43 +1887,7 @@ declare interface ITelemetryProcessor {
      * can optionally use this to access the current core instance or define / pass additional information
      * to later plugins (vs appending items to the telemetry item)
      */
-    processTelemetry: (env: ITelemetryItem, itemCtx?: IProcessTelemetryContext) => void;
-    /**
-     * The the plugin should re-evaluate configuration and update any cached configuration settings or
-     * plugins. If implemented this method will be called whenever a plugin is added or removed and if
-     * the configuration has bee updated.
-     * @param updateCtx - This is the context that should be used during updating.
-     * @param updateState - The details / state of the update process, it holds details like the current and previous configuration.
-     * @returns boolean - true if the plugin has or will call updateCtx.processNext(), this allows the plugin to perform any asynchronous operations.
-     */
-    update?: (updateCtx: IProcessTelemetryUpdateContext, updateState: ITelemetryUpdateState) => void | boolean;
-}
-
-declare interface ITelemetryUnloadState {
-    reason: TelemetryUnloadReason;
-    isAsync: boolean;
-    flushComplete?: boolean;
-}
-
-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[];
+    processTelemetry: (env: ITelemetryItem, itemCtx: IProcessTelemetryContext) => void;
 }
 
 export declare interface ITraceTelemetry extends IPartC {
@@ -2420,21 +1911,16 @@ export declare interface ITraceTelemetry extends IPartC {
     iKey?: string;
 }
 
-declare const LoggingSeverity: {
-    CRITICAL: number;
-    WARNING: number;
-};
-
-declare type LoggingSeverity = number | eLoggingSeverity;
-
-/**
- * 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
- */
-export declare function proxyFunctions<T, S>(target: T, source: S | (() => S), functionsToProxy: (keyof S)[], overwriteTarget?: boolean): T;
+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 class Sender extends BaseTelemetryPlugin implements IChannelControlsAI {
     static constructEnvelope(orig: ITelemetryItem, iKey: string, logger: IDiagnosticLogger, convertUndefined?: any): IEnvelope;
@@ -2480,6 +1966,7 @@ export declare class Sender extends BaseTelemetryPlugin implements IChannelContr
      * Will not flush if the Send has been paused.
      */
     onunloadFlush(): void;
+    teardown(): void;
     initialize(config: IConfiguration & IConfig, core: IAppInsightsCore, extensions: IPlugin[], pluginChain?: ITelemetryPluginChain): void;
     processTelemetry(telemetryItem: ITelemetryItem, itemCtx?: IProcessTelemetryContext): void;
     /**
@@ -2521,7 +2008,7 @@ declare type SenderFunction = (payload: string[], isAsync: boolean) => void;
 /**
  * The EventsDiscardedReason enumeration contains a set of values that specify the reason for discarding an event.
  */
-export declare const enum SendRequestReason {
+declare const enum SendRequestReason {
     /**
      * No specific reason was specified
      */
@@ -2550,10 +2037,6 @@ 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
      */
@@ -2579,55 +2062,6 @@ declare interface Tags {
     [key: string]: any;
 }
 
-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
-}
-
-/**
- * The TelemetryUpdateReason enumeration contains a set of bit-wise values that specify the reason for update request.
- */
-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;
-
-declare type UnloadHandler = (itemCtx: IProcessTelemetryUnloadContext, unloadState: ITelemetryUnloadState) => void;
-
 declare interface XDomainRequest extends XMLHttpRequestEventTarget {
     readonly responseText: string;
     send(payload: string): void;