@microsoft/applicationinsights-web-basic 3.0.0-beta.2210-01 → 3.0.0-beta.2210-03

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

@@ -1,5 +1,5 @@
 /*
- * Microsoft.ApplicationInsights, 3.0.0-beta.2210-01
+ * Microsoft.ApplicationInsights, 3.0.0-beta.2210-03
  * Copyright (c) Microsoft and contributors. All rights reserved.
  *
  * Microsoft Application Insights Team
@@ -18,81 +18,7 @@ import { EnumCls } from '@nevware21/ts-utils';
 import { isNullOrUndefined } from '@nevware21/ts-utils';
 import { throwError } from '@nevware21/ts-utils';
 
-export declare class AppInsightsCore extends BaseCore implements IAppInsightsCore {
-    constructor();
-    initialize(config: IConfiguration, extensions: IPlugin[], logger?: IDiagnosticLogger, notificationManager?: INotificationManager): void;
-    track(telemetryItem: ITelemetryItem): void;
-}
-
-/**
- * @export
- * @class ApplicationInsights
- */
-export declare class ApplicationInsights {
-    config: IConfiguration & IConfig;
-    /**
-     * Creates an instance of ApplicationInsights.
-     * @param {IConfiguration & IConfig} config
-     * @memberof ApplicationInsights
-     */
-    constructor(config: IConfiguration & IConfig);
-    /**
-     * Initialize this instance of ApplicationInsights
-     *
-     * @memberof ApplicationInsights
-     */
-    initialize(): void;
-    /**
-     * Send a manually constructed custom event
-     *
-     * @param {ITelemetryItem} item
-     * @memberof ApplicationInsights
-     */
-    track(item: ITelemetryItem): void;
-    /**
-     * Immediately send all batched telemetry
-     * @param {boolean} [async=true]
-     * @memberof ApplicationInsights
-     */
-    flush(async?: boolean): void;
-    pollInternalLogs(): void;
-    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;
-}
-
-export { arrForEach }
-
-declare class BaseCore implements IAppInsightsCore {
+export declare class AppInsightsCore implements IAppInsightsCore {
     static defaultConfig: IConfiguration;
     config: IConfiguration;
     logger: IDiagnosticLogger;
@@ -108,12 +34,12 @@ declare class BaseCore implements IAppInsightsCore {
      * 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.
+     * @param listener - An INotificationListener object.
      */
     addNotificationListener(listener: INotificationListener): void;
     /**
      * Removes all instances of the listener.
-     * @param {INotificationListener} listener - INotificationListener to remove.
+     * @param listener - INotificationListener to remove.
      */
     removeNotificationListener(listener: INotificationListener): void;
     /**
@@ -141,7 +67,7 @@ declare class BaseCore implements IAppInsightsCore {
      * @param telemetryInitializer - The Telemetry Initializer function
      * @returns - A ITelemetryInitializerHandler to enable the initializer to be removed
      */
-    addTelemetryInitializer(telemetryInitializer: TelemetryInitializerFunction): ITelemetryInitializerHandler | void;
+    addTelemetryInitializer(telemetryInitializer: TelemetryInitializerFunction): ITelemetryInitializerHandler;
     /**
      * 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
@@ -163,6 +89,12 @@ declare class BaseCore implements IAppInsightsCore {
      * @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;
+    /**
+     * Update the configuration used and broadcast the changes to all loaded plugins
+     * @param newConfig - The new configuration is apply
+     * @param mergeExisting - Should the new configuration merge with the existing or just replace it. Default is to true.
+     */
+    updateCfg<T extends IConfiguration = IConfiguration>(newConfig: T, mergeExisting?: boolean): void;
     /**
      * Returns the unique event namespace that should be used
      */
@@ -190,6 +122,18 @@ declare class BaseCore implements IAppInsightsCore {
      * Sets the current distributed trace context for this instance if available
      */
     setTraceCtx(newTracectx: IDistributedTraceContext): void;
+    /**
+     * Add this hook so that it is automatically removed during unloading
+     * @param hooks - The single hook or an array of IInstrumentHook objects
+     */
+    addUnloadHook(hooks: IUnloadHook | IUnloadHook[] | Iterator<IUnloadHook> | ILegacyUnloadHook | ILegacyUnloadHook[] | Iterator<ILegacyUnloadHook>): void;
+    /**
+     * Watches and tracks changes for accesses to the current config, and if the accessed config changes the
+     * handler will be recalled.
+     * @param handler
+     * @returns A watcher handler instance that can be used to remove itself when being unloaded
+     */
+    onCfgChange<T extends IConfiguration = IConfiguration>(handler: WatcherFunction<T>): IUnloadHook;
     protected releaseQueue(): void;
     /**
      * Hook for Core extensions to allow them to update their own configuration before updating all of the plugins.
@@ -200,6 +144,74 @@ declare class BaseCore implements IAppInsightsCore {
     protected _updateHook?(updateCtx: IProcessTelemetryUpdateContext, updateState: ITelemetryUpdateState): void | boolean;
 }
 
+/**
+ * @export
+ * @class ApplicationInsights
+ */
+export declare class ApplicationInsights {
+    readonly config: IConfiguration & IConfig;
+    /**
+     * Creates an instance of ApplicationInsights.
+     * @param config
+     * @memberof ApplicationInsights
+     */
+    constructor(config: IConfiguration & IConfig);
+    /**
+     * Initialize this instance of ApplicationInsights
+     *
+     * @memberof ApplicationInsights
+     */
+    initialize(): void;
+    /**
+     * Send a manually constructed custom event
+     *
+     * @param item
+     * @memberof ApplicationInsights
+     */
+    track(item: ITelemetryItem): void;
+    /**
+     * Immediately send all batched telemetry
+     * @param [async=true]
+     * @memberof ApplicationInsights
+     */
+    flush(async?: boolean): void;
+    pollInternalLogs(): void;
+    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;
+}
+
+export { arrForEach }
+
 /**
  * BaseTelemetryPlugin provides a basic implementation of the ITelemetryPlugin interface so that plugins
  * can avoid implementation the same set of boiler plate code as well as provide a base
@@ -290,7 +302,7 @@ declare abstract class BaseTelemetryPlugin implements ITelemetryPlugin {
      * 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;
+    protected _addHook(hooks: IUnloadHook | IUnloadHook[] | ILegacyUnloadHook | ILegacyUnloadHook[]): void;
 }
 
 declare const DistributedTracingModes: EnumValue<typeof eDistributedTracingModes>;
@@ -395,10 +407,16 @@ export declare const enum _eInternalMessageId {
     TrackPageActionEventFailed = 103,
     FailedAddingCustomDefinedRequestContext = 104,
     InMemoryStorageBufferFull = 105,
-    InstrumentationKeyDeprecation = 106
+    InstrumentationKeyDeprecation = 106,
+    ConfigWatcherException = 107,
+    DynamicConfigException = 108
 }
 
 declare const enum eLoggingSeverity {
+    /**
+     * No Logging will be enabled
+     */
+    DISABLED = 0,
     /**
      * Error will be sent as internal telemetry
      */
@@ -422,12 +440,6 @@ export declare const enum eSeverityLevel {
     Critical = 4
 }
 
-declare const enum GetExtCfgMergeType {
-    None = 0,
-    MergeDefaultOnly = 1,
-    MergeDefaultFromRootOrDefault = 2
-}
-
 export declare interface IAppInsightsCore extends IPerfManagerProvider {
     config: IConfiguration;
     logger: IDiagnosticLogger;
@@ -455,12 +467,12 @@ export declare interface IAppInsightsCore extends IPerfManagerProvider {
      * 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.
+     * @param listener - An INotificationListener object.
      */
     addNotificationListener?(listener: INotificationListener): void;
     /**
      * Removes all instances of the listener.
-     * @param {INotificationListener} listener - INotificationListener to remove.
+     * @param listener - INotificationListener to remove.
      */
     removeNotificationListener?(listener: INotificationListener): void;
     /**
@@ -468,7 +480,7 @@ export declare interface IAppInsightsCore extends IPerfManagerProvider {
      * @param telemetryInitializer - The Telemetry Initializer function
      * @returns - A ITelemetryInitializerHandler to enable the initializer to be removed
      */
-    addTelemetryInitializer(telemetryInitializer: TelemetryInitializerFunction): ITelemetryInitializerHandler | void;
+    addTelemetryInitializer(telemetryInitializer: TelemetryInitializerFunction): ITelemetryInitializerHandler;
     pollInternalLogs?(eventName?: string): number;
     stopPollingInternalLogs?(): void;
     /**
@@ -500,6 +512,14 @@ export declare interface IAppInsightsCore extends IPerfManagerProvider {
      * @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;
+    /**
+     * Update the configuration used and broadcast the changes to all loaded plugins, this does NOT support updating, adding or removing
+     * any the plugins (extensions or channels). It will notify each plugin (if supported) that the configuration has changed but it will
+     * not remove or add any new plugins, you need to call addPlugin or getPlugin(identifier).remove();
+     * @param newConfig - The new configuration is apply
+     * @param mergeExisting - Should the new configuration merge with the existing or just replace it. Default is to merge.
+     */
+    updateCfg<T extends IConfiguration = IConfiguration>(newConfig: T, mergeExisting?: boolean): void;
     /**
      * Returns the unique event namespace that should be used when registering events
      */
@@ -509,6 +529,11 @@ export declare interface IAppInsightsCore extends IPerfManagerProvider {
      * @param handler - the handler
      */
     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
+     */
+    addUnloadHook(hooks: IUnloadHook | IUnloadHook[] | Iterator<IUnloadHook> | ILegacyUnloadHook | ILegacyUnloadHook[] | Iterator<ILegacyUnloadHook>): void;
     /**
      * Flush and send any batched / cached data immediately
      * @param async - send data asynchronously when true (defaults to true)
@@ -528,6 +553,13 @@ export declare interface IAppInsightsCore extends IPerfManagerProvider {
      * Sets the current distributed trace context for this instance if available
      */
     setTraceCtx(newTraceCtx: IDistributedTraceContext | null | undefined): void;
+    /**
+     * Watches and tracks changes for accesses to the current config, and if the accessed config changes the
+     * handler will be recalled.
+     * @param handler
+     * @returns A watcher handler instance that can be used to remove itself when being unloaded
+     */
+    onCfgChange<T extends IConfiguration = IConfiguration>(handler: WatcherFunction<T>): IUnloadHook;
 }
 
 /**
@@ -627,13 +659,13 @@ declare interface IBaseProcessingContext {
     /**
      * Gets the named extension config
      */
-    getExtCfg: <T>(identifier: string, defaultValue?: T | any, mergeDefault?: GetExtCfgMergeType) => T;
+    getExtCfg: <T>(identifier: string, defaultValue?: IConfigDefaults<T>) => 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
+     * @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;
     /**
@@ -1025,6 +1057,51 @@ declare interface IConfig {
     addIntEndpoints?: boolean;
 }
 
+/**
+ * The type to identify whether the default value should be applied in preference to the provided value.
+ */
+declare type IConfigCheckFn<V> = (value: V) => boolean;
+
+/**
+ * The default values with a check function
+ */
+declare interface IConfigDefaultCheck<T, V, C extends IConfiguration = IConfiguration> {
+    /**
+     * Callback function to check if the user-supplied value is valid, if not the default will be applied
+     */
+    isVal?: IConfigCheckFn<V>;
+    /**
+     * Optional function to allow converting and setting of the default value
+     */
+    set?: IConfigSetFn<T, V>;
+    /**
+     * The default value to apply if the user-supplied value is not valid
+     */
+    v?: V;
+    /**
+     *  The default fallback key if the main key is not present, this is the key value from the config
+     */
+    fb?: keyof T | keyof C | Array<keyof T | keyof C>;
+    /**
+     * Use this check to determine the default fallback, default only checked whether the property isDefined,
+     * therefore `null`; `""` are considered to be valid values.
+     */
+    dfVal?: (value: any) => boolean;
+}
+
+/**
+ * The Type definition to define default values to be applied to the config
+ * The value may be either the direct value or a ConfigDefaultCheck definition
+ */
+declare type IConfigDefaults<T, C extends IConfiguration = IConfiguration> = {
+    [key in keyof T]: T[key] | IConfigDefaultCheck<T, T[key], C>;
+};
+
+/**
+ * The type which identifies the function use to validate the user supplied value
+ */
+declare type IConfigSetFn<T, V> = (value: any, defValue: V, theConfig: T) => V;
+
 /**
  * Configuration provided to SDK core
  */
@@ -1206,6 +1283,11 @@ declare interface ICookieMgr {
      * @returns - True if the cookie was marked for deletion otherwise false (Because cookie usage is not available)
      */
     purge(name: string, path?: string): boolean;
+    /**
+     * Optional Callback hook to allow the diagnostic logger to update it's configuration
+     * @param updateState
+     */
+    update?(updateState: ITelemetryUpdateState): void;
 }
 
 /**
@@ -1306,20 +1388,20 @@ declare interface IDiagnosticLogger {
     queue: _InternalLogMessage[];
     /**
      * This method will throw exceptions in debug mode or attempt to log the error as a console warning.
-     * @param severity {LoggingSeverity} - The severity of the log message
-     * @param message {_InternalLogMessage} - The log message.
+     * @param severity - {LoggingSeverity} - The severity of the log message
+     * @param message - {_InternalLogMessage} - The log message.
      */
     throwInternal(severity: LoggingSeverity, msgId: _InternalMessageId, msg: string, properties?: Object, isUserAct?: boolean): void;
     /**
      * This will write a warning to the console if possible
-     * @param message {string} - The warning message
+     * @param message - {string} - The warning message
      */
     warnToConsole(message: string): void;
     /**
      * This will write an error to the console if possible.
      * Provided by the default DiagnosticLogger instance, and internally the SDK will fall back to warnToConsole, however,
      * direct callers MUST check for its existence on the logger as you can provide your own IDiagnosticLogger instance.
-     * @param message {string} - The error message
+     * @param message - {string} - The error message
      */
     errorToConsole?(message: string): void;
     /**
@@ -1328,10 +1410,15 @@ declare interface IDiagnosticLogger {
     resetInternalMessageCount(): void;
     /**
      * Logs a message to the internal queue.
-     * @param severity {LoggingSeverity} - The severity of the log message
-     * @param message {_InternalLogMessage} - The message to log.
+     * @param severity - {LoggingSeverity} - The severity of the log message
+     * @param message - {_InternalLogMessage} - The message to log.
      */
     logInternalMessage?(severity: LoggingSeverity, message: _InternalLogMessage): void;
+    /**
+     * Optional Callback hook to allow the diagnostic logger to update it's configuration
+     * @param updateState
+     */
+    update?(updateState: ITelemetryUpdateState): void;
 }
 
 declare interface IDistributedTraceContext {
@@ -1378,6 +1465,39 @@ declare interface IDistributedTraceContext {
     setTraceFlags(newValue?: number): void;
 }
 
+/**
+ * This interface identifies the config which can track changes
+ */
+declare interface IDynamicConfigHandler<T extends IConfiguration> {
+    /**
+     * Unique Id for this config handler
+     */
+    readonly uid: string;
+    /**
+     * Link back to the configuration object that should be used to get/set values
+     */
+    cfg: T;
+    /**
+     * The logger instance to use to loger any issues
+     */
+    logger: IDiagnosticLogger;
+    /**
+     * Helper to call any listeners that are waiting to be notified
+     */
+    notify: () => void;
+    /**
+     * Watch and track changes for accesses to the current config anb
+     */
+    watch: (configHandler: WatcherFunction<T>) => IWatcherHandler<T>;
+    /**
+     * Set the value against the provided config/name with the value, the property
+     * will be converted to be dynamic (if not already) as long as the provided config
+     * is already a tracked dynamic object.
+     * @throws TypeError if the provided config is not a monitored dynamic config
+     */
+    set: <C, V>(theConfig: C, name: string, value: V) => V;
+}
+
 declare interface IEnvelope extends ISerializable {
     /**
      * Envelope version. For internal use only. By assigning this the default, it will not be serialized within the payload unless changed to a value other than #1.
@@ -1430,76 +1550,14 @@ 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
+ * An alternate interface which provides automatic removal during unloading of the component
  */
-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[];
+declare interface ILegacyUnloadHook {
     /**
-     * The hook callback to call before the original function is called
+     * Legacy Self remove the referenced component
      */
-    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;
+    remove: () => void;
 }
 
 export declare interface ILoadedPlugin<T extends IPlugin> {
@@ -1573,20 +1631,20 @@ export declare interface IMetricTelemetry extends IPartC {
 declare interface INotificationListener {
     /**
      * [Optional] A function called when events are sent.
-     * @param {ITelemetryItem[]} events - The array of events that have been sent.
+     * @param events - The array of events that have been sent.
      */
     eventsSent?: (events: ITelemetryItem[]) => void;
     /**
      * [Optional] A function called when events are discarded.
-     * @param {ITelemetryItem[]} events - The array of events that have been discarded.
-     * @param {number} reason           - The reason for discarding the events. The EventsDiscardedReason
+     * @param events - The array of events that have been discarded.
+     * @param reason - The reason for discarding the events. The EventsDiscardedReason
      * constant should be used to check the different values.
      */
     eventsDiscarded?: (events: ITelemetryItem[], reason: number) => void;
     /**
      * [Optional] A function called when the events have been requested to be sent to the sever.
-     * @param {number} sendReason - The reason why the event batch is being sent.
-     * @param {boolean} isAsync   - A flag which identifies whether the requests are being sent in an async or sync manner.
+     * @param sendReason - The reason why the event batch is being sent.
+     * @param isAsync - A flag which identifies whether the requests are being sent in an async or sync manner.
      */
     eventsSendRequest?: (sendReason: number, isAsync?: boolean) => void;
     /**
@@ -1604,46 +1662,40 @@ declare interface INotificationManager {
     listeners: INotificationListener[];
     /**
      * Adds a notification listener.
-     * @param {INotificationListener} listener - The notification listener to be added.
+     * @param listener - The notification listener to be added.
      */
     addNotificationListener(listener: INotificationListener): void;
     /**
      * Removes all instances of the listener.
-     * @param {INotificationListener} listener - AWTNotificationListener to remove.
+     * @param listener - AWTNotificationListener to remove.
      */
     removeNotificationListener(listener: INotificationListener): void;
     /**
      * Notification for events sent.
-     * @param {ITelemetryItem[]} events - The array of events that have been sent.
+     * @param events - The array of events that have been sent.
      */
     eventsSent(events: ITelemetryItem[]): void;
     /**
      * Notification for events being discarded.
-     * @param {ITelemetryItem[]} events - The array of events that have been discarded by the SDK.
-     * @param {number} reason           - The reason for which the SDK discarded the events. The EventsDiscardedReason
+     * @param events - The array of events that have been discarded by the SDK.
+     * @param reason - The reason for which the SDK discarded the events. The EventsDiscardedReason
      * constant should be used to check the different values.
      */
     eventsDiscarded(events: ITelemetryItem[], reason: number): void;
     /**
      * [Optional] A function called when the events have been requested to be sent to the sever.
-     * @param {number} sendReason - The reason why the event batch is being sent.
-     * @param {boolean} isAsync   - A flag which identifies whether the requests are being sent in an async or sync manner.
+     * @param sendReason - The reason why the event batch is being sent.
+     * @param isAsync - A flag which identifies whether the requests are being sent in an async or sync manner.
      */
     eventsSendRequest?(sendReason: number, isAsync: boolean): void;
     /**
      * [Optional] This event is sent if you have enabled perf events, they are primarily used to track internal performance testing and debugging
      * the event can be displayed via the debug plugin extension.
-     * @param perfEvent
+     * @param perfEvent - The perf event details
      */
     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;
@@ -1651,12 +1703,7 @@ declare class _InternalLogMessage {
     constructor(msgId: _InternalMessageId, msg: string, isUserAct?: boolean, properties?: Object);
 }
 
-/**
- * Internal message ID. Please create a new one for every conceptually different message. Please keep alphabetically ordered
- */
-export declare const _InternalMessageId: EnumValue<typeof _eInternalMessageId>;
-
-export declare type _InternalMessageId = number | _eInternalMessageId;
+declare type _InternalMessageId = number | _eInternalMessageId;
 
 export declare interface IPageViewPerformanceTelemetry extends IPartC {
     /**
@@ -1817,14 +1864,14 @@ declare interface IPerfManager {
     /**
      * Create a new event and start timing, the manager may return null/undefined to indicate that it does not
      * want to monitor this source event.
-     * @param src The source name of the event
+     * @param src - The source name of the event
      * @param payloadDetails - An optional callback function to fetch the payload details for the event.
      * @param isAsync - Is the event occurring from a async event
      */
     create(src: string, payloadDetails?: () => any, isAsync?: boolean): IPerfEvent | null | undefined;
     /**
      * Complete the perfEvent and fire any notifications.
-     * @param perfEvent Fire the event which will also complete the passed event
+     * @param perfEvent - Fire the event which will also complete the passed event
      */
     fire(perfEvent: IPerfEvent): void;
     /**
@@ -1850,7 +1897,7 @@ declare interface IPerfManagerProvider {
     getPerfMgr(): IPerfManager;
     /**
      * Set the current performance manager
-     * @param perfMgr The performance manager
+     * @param perfMgr - The performance manager
      */
     setPerfMgr(perfMgr: IPerfManager): void;
 }
@@ -2019,68 +2066,68 @@ declare interface ISenderConfig {
     /**
      * The url to which payloads will be sent
      */
-    endpointUrl: () => string;
+    endpointUrl: string;
     /**
      * The JSON format (normal vs line delimited). True means line delimited JSON.
      */
-    emitLineDelimitedJson: () => boolean;
+    emitLineDelimitedJson: boolean;
     /**
      * The maximum size of a batch in bytes
      */
-    maxBatchSizeInBytes: () => number;
+    maxBatchSizeInBytes: number;
     /**
      * The maximum interval allowed between calls to batchInvoke
      */
-    maxBatchInterval: () => number;
+    maxBatchInterval: number;
     /**
      * The master off switch.  Do not send any data if set to TRUE
      */
-    disableTelemetry: () => boolean;
+    disableTelemetry: boolean;
     /**
      * Store a copy of a send buffer in the session storage
      */
-    enableSessionStorageBuffer: () => boolean;
+    enableSessionStorageBuffer: boolean;
     /**
      * Is retry handler disabled.
      * If enabled, retry on 206 (partial success), 408 (timeout), 429 (too many requests), 500 (internal server error) and 503 (service unavailable).
      */
-    isRetryDisabled: () => boolean;
-    isBeaconApiDisabled: () => boolean;
+    isRetryDisabled: boolean;
+    isBeaconApiDisabled: boolean;
     /**
      * Don't use XMLHttpRequest or XDomainRequest (for IE < 9) by default instead attempt to use fetch() or sendBeacon.
      * If no other transport is available it will still use XMLHttpRequest
      */
-    disableXhr: () => boolean;
+    disableXhr: boolean;
     /**
      * If fetch keepalive is supported do not use it for sending events during unload, it may still fallback to fetch() without keepalive
      */
-    onunloadDisableFetch: () => boolean;
+    onunloadDisableFetch: boolean;
     /**
      * Is beacon disabled on page unload.
      * If enabled, flush events through beaconSender.
      */
-    onunloadDisableBeacon: () => boolean;
+    onunloadDisableBeacon: boolean;
     /**
      * (Optional) Override the instrumentation key that this channel instance sends to
      */
-    instrumentationKey: () => string;
-    namePrefix: () => string;
-    samplingPercentage: () => number;
+    instrumentationKey: string;
+    namePrefix: string;
+    samplingPercentage: number;
     /**
      * (Optional) The ability for the user to provide extra headers
      */
-    customHeaders: () => [{
+    customHeaders: [{
         header: string;
         value: string;
     }];
     /**
      * (Optional) Provide user an option to convert undefined field to user defined value.
      */
-    convertUndefined: () => any;
+    convertUndefined: any;
     /**
      * (Optional) The number of events that can be kept in memory before the SDK starts to drop events. By default, this is 10,000.
      */
-    eventsLimitInMem: () => number;
+    eventsLimitInMem: number;
 }
 
 declare interface ISerializable {
@@ -2099,7 +2146,7 @@ declare interface IStackDetails {
     obj: string[];
 }
 
-declare interface ITelemetryInitializerHandler {
+declare interface ITelemetryInitializerHandler extends ILegacyUnloadHook {
     remove(): void;
 }
 
@@ -2217,12 +2264,22 @@ declare interface ITelemetryUpdateState {
      * Identifies the reason for the update notification, this is a bitwise numeric value
      */
     reason: TelemetryUpdateReason;
+    /**
+     * This is a new active configuration that should be used
+     */
+    cfg?: IConfiguration;
+    /**
+     * The detected changes
+     */
+    oldCfg?: IConfiguration;
     /**
      * If this is a configuration update this was the previous configuration that was used
      */
+    newConfig?: IConfiguration;
     /**
-     * If this is a configuration update is the new configuration that is being used
+     * Was the new config requested to be merged with the existing config
      */
+    merge?: boolean;
     /**
      * This holds a collection of plugins that have been added (if the reason identifies that one or more plugins have been added)
      */
@@ -2254,6 +2311,26 @@ export declare interface ITraceTelemetry extends IPartC {
     iKey?: string;
 }
 
+/**
+ * An interface which provides automatic removal during unloading of the component
+ */
+declare interface IUnloadHook {
+    /**
+     * Self remove the referenced component
+     */
+    rm: () => void;
+}
+
+declare interface IWatchDetails<T extends IConfiguration> {
+    cfg: T;
+    hdlr: IDynamicConfigHandler<T>;
+}
+
+declare interface IWatcherHandler<T extends IConfiguration> extends IUnloadHook {
+    fn: WatcherFunction<T>;
+    rm: () => void;
+}
+
 declare const LoggingSeverity: EnumValue<typeof eLoggingSeverity>;
 
 declare type LoggingSeverity = number | eLoggingSeverity;
@@ -2320,8 +2397,8 @@ export declare class Sender extends BaseTelemetryPlugin implements IChannelContr
     _xhrReadyStateChange(xhr: XMLHttpRequest, payload: string[], countOfItemsInPayload: number): void;
     /**
      * Immediately send buffered data
-     * @param async {boolean} - Indicates if the events should be sent asynchronously
-     * @param forcedSender {SenderFunction} - Indicates the forcedSender, undefined if not passed
+     * @param async - {boolean} - Indicates if the events should be sent asynchronously
+     * @param forcedSender - {SenderFunction} - Indicates the forcedSender, undefined if not passed
      */
     triggerSend(async?: boolean, forcedSender?: SenderFunction, sendReason?: SendRequestReason): void;
     /**
@@ -2342,8 +2419,8 @@ export declare class Sender extends BaseTelemetryPlugin implements IChannelContr
     _xdrOnLoad(xdr: XDomainRequest, payload: string[]): void;
     /**
      * Add header to request
-     * @param name   - Header name.
-     * @param value  - Header value.
+     * @param name - Header name.
+     * @param value - Header value.
      */
     addHeader(name: string, value: string): void;
 }
@@ -2442,6 +2519,7 @@ declare const enum TelemetryUpdateReason {
     /**
      * The configuration has ben updated or changed
      */
+    ConfigurationChanged = 1,
     /**
      * One or more plugins have been added
      */
@@ -2456,6 +2534,8 @@ export { throwError }
 
 declare type UnloadHandler = (itemCtx: IProcessTelemetryUnloadContext, unloadState: ITelemetryUnloadState) => void;
 
+declare type WatcherFunction<T extends IConfiguration> = (details: IWatchDetails<T>) => void;
+
 declare interface XDomainRequest extends XMLHttpRequestEventTarget {
     readonly responseText: string;
     send(payload: string): void;