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

package/types/JavaScriptSDK.Enums/EnumHelperFuncs.d.ts

@@ -0,0 +1,34 @@
+export declare type EnumValue<E = any> = {
+    readonly [key in keyof E]: E[key];
+};
+export declare type EnumMap<E = any, I = E> = {
+    readonly [key in keyof E extends string ? keyof E : never]: key extends string ? key : keyof E;
+} & I;
+/**
+ * Create an enum style object which has both the key => value and value => key mappings
+ * @param values - The values to populate on the new object
+ * @returns
+ */
+export declare function createEnumStyle<E>(values: {
+    [key in keyof E]: E[keyof E];
+}): EnumValue<E>;
+/**
+ * Create a 2 index map that maps an enum's key as both the key and value, X["key"] => "key" and X[0] => "keyof 0".
+ * @param values - The values to populate on the new object
+ * @returns
+ */
+export declare function createEnumMap<E, I = keyof E>(values: {
+    [key in keyof E]: E[keyof E];
+}): EnumMap<E, I>;
+/**
+ * Create a 2 index map that maps an enum's key and value to the defined map value, X["key"] => mapValue and X[0] => mapValue.
+ * Generic values
+ * - E = the const enum type (typeof eRequestHeaders);
+ * - V = Identifies the valid values for the keys, this should include both the enum numeric and string key of the type. The
+ * resulting "Value" of each entry identifies the valid values withing the assignments.
+ * @param values - The values to populate on the new object
+ * @returns
+ */
+export declare function createValueMap<E, V = E>(values: {
+    [key in keyof E]: [eValue: E[keyof E], mapValue: V[keyof V]];
+}): V;

package/types/JavaScriptSDK.Enums/EventsDiscardedReason.d.ts

@@ -1,29 +1,34 @@
 /**
- * The EventsDiscardedReason enumeration contains a set of values that specify the reason for discarding an event.
+ * The eEventsDiscardedReason enumeration contains a set of values that specify the reason for discarding an event.
  */
-export declare const EventsDiscardedReason: {
+export declare const enum eEventsDiscardedReason {
     /**
      * Unknown.
      */
-    Unknown: number;
+    Unknown = 0,
     /**
      * Status set to non-retryable.
      */
-    NonRetryableStatus: number;
+    NonRetryableStatus = 1,
     /**
      * The event is invalid.
      */
-    InvalidEvent: number;
+    InvalidEvent = 2,
     /**
      * The size of the event is too large.
      */
-    SizeLimitExceeded: number;
+    SizeLimitExceeded = 3,
     /**
      * The server is not accepting events from this instrumentation key.
      */
-    KillSwitch: number;
+    KillSwitch = 4,
     /**
      * The event queue is full.
      */
-    QueueFull: number;
-};
+    QueueFull = 5
+}
+/**
+ * The EventsDiscardedReason enumeration contains a set of values that specify the reason for discarding an event.
+ */
+export declare const EventsDiscardedReason: import("../JavaScriptSDK.Enums/EnumHelperFuncs").EnumValue<typeof eEventsDiscardedReason>;
+export declare type EventsDiscardedReason = number | eEventsDiscardedReason;

package/types/JavaScriptSDK.Enums/LoggingEnums.d.ts

@@ -1,4 +1,4 @@
-export declare enum LoggingSeverity {
+export declare const enum eLoggingSeverity {
     /**
      * Error will be sent as internal telemetry
      */
@@ -8,91 +8,94 @@ export declare enum LoggingSeverity {
      */
     WARNING = 2
 }
+export declare const LoggingSeverity: import("../JavaScriptSDK.Enums/EnumHelperFuncs").EnumValue<typeof eLoggingSeverity>;
+export declare type LoggingSeverity = number | eLoggingSeverity;
+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
+}
 /**
  * Internal message ID. Please create a new one for every conceptually different message. Please keep alphabetically ordered
  */
-export declare const _InternalMessageId: {
-    BrowserDoesNotSupportLocalStorage: number;
-    BrowserCannotReadLocalStorage: number;
-    BrowserCannotReadSessionStorage: number;
-    BrowserCannotWriteLocalStorage: number;
-    BrowserCannotWriteSessionStorage: number;
-    BrowserFailedRemovalFromLocalStorage: number;
-    BrowserFailedRemovalFromSessionStorage: number;
-    CannotSendEmptyTelemetry: number;
-    ClientPerformanceMathError: number;
-    ErrorParsingAISessionCookie: number;
-    ErrorPVCalc: number;
-    ExceptionWhileLoggingError: number;
-    FailedAddingTelemetryToBuffer: number;
-    FailedMonitorAjaxAbort: number;
-    FailedMonitorAjaxDur: number;
-    FailedMonitorAjaxOpen: number;
-    FailedMonitorAjaxRSC: number;
-    FailedMonitorAjaxSend: number;
-    FailedMonitorAjaxGetCorrelationHeader: number;
-    FailedToAddHandlerForOnBeforeUnload: number;
-    FailedToSendQueuedTelemetry: number;
-    FailedToReportDataLoss: number;
-    FlushFailed: number;
-    MessageLimitPerPVExceeded: number;
-    MissingRequiredFieldSpecification: number;
-    NavigationTimingNotSupported: number;
-    OnError: number;
-    SessionRenewalDateIsZero: number;
-    SenderNotInitialized: number;
-    StartTrackEventFailed: number;
-    StopTrackEventFailed: number;
-    StartTrackFailed: number;
-    StopTrackFailed: number;
-    TelemetrySampledAndNotSent: number;
-    TrackEventFailed: number;
-    TrackExceptionFailed: number;
-    TrackMetricFailed: number;
-    TrackPVFailed: number;
-    TrackPVFailedCalc: number;
-    TrackTraceFailed: number;
-    TransmissionFailed: number;
-    FailedToSetStorageBuffer: number;
-    FailedToRestoreStorageBuffer: number;
-    InvalidBackendResponse: number;
-    FailedToFixDepricatedValues: number;
-    InvalidDurationValue: number;
-    TelemetryEnvelopeInvalid: number;
-    CreateEnvelopeError: number;
-    CannotSerializeObject: number;
-    CannotSerializeObjectNonSerializable: number;
-    CircularReferenceDetected: number;
-    ClearAuthContextFailed: number;
-    ExceptionTruncated: number;
-    IllegalCharsInName: number;
-    ItemNotInArray: number;
-    MaxAjaxPerPVExceeded: number;
-    MessageTruncated: number;
-    NameTooLong: number;
-    SampleRateOutOfRange: number;
-    SetAuthContextFailed: number;
-    SetAuthContextFailedAccountName: number;
-    StringValueTooLong: number;
-    StartCalledMoreThanOnce: number;
-    StopCalledWithoutStart: number;
-    TelemetryInitializerFailed: number;
-    TrackArgumentsNotSpecified: number;
-    UrlTooLong: number;
-    SessionStorageBufferFull: number;
-    CannotAccessCookie: number;
-    IdTooLong: number;
-    InvalidEvent: number;
-    FailedMonitorAjaxSetRequestHeader: number;
-    SendBrowserInfoOnUserInit: number;
-    PluginException: number;
-    NotificationException: number;
-    SnippetScriptLoadFailure: number;
-    InvalidInstrumentationKey: number;
-    CannotParseAiBlobValue: number;
-    InvalidContentBlob: number;
-    TrackPageActionEventFailed: number;
-    FailedAddingCustomDefinedRequestContext: number;
-    InMemoryStorageBufferFull: number;
-};
-export declare type _InternalMessageId = number | typeof _InternalMessageId;
+export declare const _InternalMessageId: import("../JavaScriptSDK.Enums/EnumHelperFuncs").EnumValue<typeof _eInternalMessageId>;
+export declare type _InternalMessageId = number | _eInternalMessageId;

package/types/JavaScriptSDK.Enums/SendRequestReason.d.ts

@@ -30,6 +30,10 @@ export declare const enum SendRequestReason {
      * The event(s) being sent as a retry
      */
     Retry = 5,
+    /**
+     * The SDK is unloading
+     */
+    SdkUnload = 6,
     /**
      * Maximum batch size would be exceeded
      */

package/types/JavaScriptSDK.Enums/TelemetryUnloadReason.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The TelemetryUnloadReason enumeration contains the possible reasons for why a plugin is being unloaded / torndown().
+ */
+export declare const enum TelemetryUnloadReason {
+    /**
+     * Teardown has been called without any context.
+     */
+    ManualTeardown = 0,
+    /**
+     * Just this plugin is being removed
+     */
+    PluginUnload = 1,
+    /**
+     * This instance of the plugin is being removed and replaced
+     */
+    PluginReplace = 2,
+    /**
+     * The entire SDK is being unloaded
+     */
+    SdkUnload = 50
+}

package/types/JavaScriptSDK.Enums/TelemetryUpdateReason.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The TelemetryUpdateReason enumeration contains a set of bit-wise values that specify the reason for update request.
+ */
+export declare const enum TelemetryUpdateReason {
+    /**
+     * Unknown.
+     */
+    Unknown = 0,
+    /**
+     * The configuration has ben updated or changed
+     */
+    /**
+     * One or more plugins have been added
+     */
+    PluginAdded = 16,
+    /**
+     * One or more plugins have been removed
+     */
+    PluginRemoved = 32
+}

package/types/JavaScriptSDK.Interfaces/IAppInsightsCore.d.ts

@@ -1,6 +1,6 @@
 import { ITelemetryItem } from "./ITelemetryItem";
 import { IChannelControls } from "./IChannelControls";
-import { IPlugin } from "./ITelemetryPlugin";
+import { IPlugin, ITelemetryPlugin } from "./ITelemetryPlugin";
 import { IConfiguration } from "./IConfiguration";
 import { INotificationManager } from "./INotificationManager";
 import { INotificationListener } from "./INotificationListener";
@@ -8,6 +8,27 @@ import { IDiagnosticLogger } from "./IDiagnosticLogger";
 import { IProcessTelemetryContext } from "./IProcessTelemetryContext";
 import { IPerfManagerProvider } from "./IPerfManager";
 import { ICookieMgr } from "./ICookieMgr";
+import { ITelemetryInitializerHandler, TelemetryInitializerFunction } from "./ITelemetryInitializers";
+import { ITelemetryUnloadState } from "./ITelemetryUnloadState";
+import { UnloadHandler } from "../JavaScriptSDK/UnloadHandlerContainer";
+import { SendRequestReason } from "../JavaScriptSDK.Enums/SendRequestReason";
+export 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 interface IAppInsightsCore extends IPerfManagerProvider {
     config: IConfiguration;
     logger: IDiagnosticLogger;
@@ -43,10 +64,60 @@ export 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;
 }

package/types/JavaScriptSDK.Interfaces/IChannelControls.d.ts

@@ -1,4 +1,7 @@
+import { SendRequestReason } from "../JavaScriptSDK.Enums/SendRequestReason";
+import { IProcessTelemetryUnloadContext } from "./IProcessTelemetryContext";
 import { ITelemetryPlugin } from "./ITelemetryPlugin";
+import { ITelemetryUnloadState } from "./ITelemetryUnloadState";
 /**
  * Provides data transmission capabilities
  */
@@ -12,14 +15,22 @@ export interface IChannelControls extends ITelemetryPlugin {
      */
     resume(): void;
     /**
-     * Tear down transmission pipeline
+     * Tear down the plugin and remove any hooked value, the plugin should be removed so that it is no longer initialized and
+     * therefore could be re-initialized after being torn down. The plugin should ensure that once this has been called any further
+     * processTelemetry calls are ignored and it just calls the processNext() with the provided context.
+     * @param unloadCtx - This is the context that should be used during unloading.
+     * @param unloadState - The details / state of the unload process, it holds details like whether it should be unloaded synchronously or asynchronously and the reason for the unload.
+     * @returns boolean - true if the plugin has or will call processNext(), this for backward compatibility as previously teardown was synchronous and returned nothing.
      */
-    teardown(): void;
+    teardown: (unloadCtx?: IProcessTelemetryUnloadContext, unloadState?: ITelemetryUnloadState) => void | boolean;
     /**
      * Flush to send data immediately; channel should default to sending data asynchronously
-     * @param async: send data asynchronously when true
-     * @param callBack: if specified, notify caller when send is complete
+     * @param async - send data asynchronously when true
+     * @param callBack - if specified, notify caller when send is complete, the channel should return true to indicate to the caller that it will be called.
+     * If the caller doesn't return true the caller should assume that it may never be called.
+     * @param sendReason - specify the reason that you are calling "flush" defaults to ManualFlush (1) if not specified
+     * @returns - true if the callback will be return after the flush is complete otherwise the caller should assume that any provided callback will never be called
      */
-    flush(async: boolean, callBack?: () => void): void;
+    flush(async: boolean, callBack?: (flushComplete?: boolean) => void, sendReason?: SendRequestReason): boolean | void;
 }
 export declare const MinChannelPriorty: number;

package/types/JavaScriptSDK.Interfaces/IInstrumentHooks.d.ts

@@ -8,6 +8,11 @@ export declare type InstrumentorHooksCallback = (funcArgs: IInstrumentCallDetail
  * You must always supply the error callback
  */
 export 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
      */
@@ -68,4 +73,8 @@ export interface IInstrumentCallDetails {
      * The error (exception) which occurred while executing the original method
      */
     err?: Error;
+    /**
+     * The Event object from (window.event) at the start of the original call
+     */
+    evt?: Event;
 }

package/types/JavaScriptSDK.Interfaces/IProcessTelemetryContext.d.ts

@@ -1,14 +1,17 @@
 import { IAppInsightsCore } from "./IAppInsightsCore";
-import { IDiagnosticLogger } from "./IDiagnosticLogger";
 import { IConfiguration } from "./IConfiguration";
+import { IDiagnosticLogger } from "./IDiagnosticLogger";
 import { ITelemetryItem } from "./ITelemetryItem";
-import { IPlugin } from "./ITelemetryPlugin";
+import { IPlugin, ITelemetryPlugin } from "./ITelemetryPlugin";
 import { ITelemetryPluginChain } from "./ITelemetryPluginChain";
-/**
- * The current context for the current call to processTelemetry(), used to support sharing the same plugin instance
- * between multiple AppInsights instances
- */
-export interface IProcessTelemetryContext {
+import { ITelemetryUnloadState } from "./ITelemetryUnloadState";
+import { ITelemetryUpdateState } from "./ITelemetryUpdateState";
+export declare const enum GetExtCfgMergeType {
+    None = 0,
+    MergeDefaultOnly = 1,
+    MergeDefaultFromRootOrDefault = 2
+}
+export interface IBaseProcessingContext {
     /**
      * The current core instance for the request
      */
@@ -24,7 +27,7 @@ export interface IProcessTelemetryContext {
     /**
      * Gets the named extension config
      */
-    getExtCfg: <T>(identifier: string, defaultValue?: T | any) => T;
+    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
@@ -32,7 +35,7 @@ export interface IProcessTelemetryContext {
      * @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) => number | string | boolean;
+    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
@@ -46,13 +49,41 @@ export interface IProcessTelemetryContext {
      * 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;
+}
+/**
+ * The current context for the current call to processTelemetry(), used to support sharing the same plugin instance
+ * between multiple AppInsights instances
+ */
+export 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;
+    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
@@ -60,3 +91,43 @@ export interface IProcessTelemetryContext {
      */
     createNew: (plugins?: IPlugin[] | ITelemetryPluginChain, startAt?: IPlugin) => IProcessTelemetryContext;
 }
+/**
+ * The current context for the current call to teardown() implementations, used to support when plugins are being removed
+ * or the SDK is being unloaded.
+ */
+export interface IProcessTelemetryUnloadContext extends IBaseProcessingContext {
+    /**
+     * 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)
+     */
+    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;
+}
+/**
+ * The current context for the current call to the plugin update() implementations, used to support the notifications
+ * for when plugins are added, removed or the configuration was changed.
+ */
+export 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;
+}

package/types/JavaScriptSDK.Interfaces/ITelemetryInitializers.d.ts

@@ -0,0 +1,13 @@
+import { ITelemetryItem } from "./ITelemetryItem";
+export declare type TelemetryInitializerFunction = <T extends ITelemetryItem>(item: T) => boolean | void;
+export interface ITelemetryInitializerHandler {
+    remove(): void;
+}
+export interface ITelemetryInitializerContainer {
+    /**
+     * Add a telemetry processor to decorate or drop telemetry events.
+     * @param telemetryInitializer - The Telemetry Initializer function
+     * @returns - A ITelemetryInitializerHandler to enable the initializer to be removed
+     */
+    addTelemetryInitializer(telemetryInitializer: TelemetryInitializerFunction): ITelemetryInitializerHandler | void;
+}