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

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

@@ -1,5 +1,5 @@
 /*
- * Microsoft.ApplicationInsights, 3.0.0-beta.2210-01
+ * Microsoft.ApplicationInsights, 3.0.0-beta.2210-02
  * Copyright (c) Microsoft and contributors. All rights reserved.
  *
  * Microsoft Application Insights Team
@@ -12,81 +12,7 @@ declare namespace ApplicationInsights {
     import { isNullOrUndefined } from '@nevware21/ts-utils';
     import { throwError } from '@nevware21/ts-utils';
 
-    class AppInsightsCore extends BaseCore implements IAppInsightsCore {
-        constructor();
-        initialize(config: IConfiguration, extensions: IPlugin[], logger?: IDiagnosticLogger, notificationManager?: INotificationManager): void;
-        track(telemetryItem: ITelemetryItem): void;
-    }
-
-    /**
-     * @export
-     * @class ApplicationInsights
-     */
-    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 }
-
-    class BaseCore implements IAppInsightsCore {
+    class AppInsightsCore implements IAppInsightsCore {
         static defaultConfig: IConfiguration;
         config: IConfiguration;
         logger: IDiagnosticLogger;
@@ -102,12 +28,12 @@ declare namespace ApplicationInsights {
          * 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;
         /**
@@ -135,7 +61,7 @@ declare namespace ApplicationInsights {
          * @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
@@ -157,6 +83,12 @@ declare namespace ApplicationInsights {
          * @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
          */
@@ -184,6 +116,18 @@ declare namespace ApplicationInsights {
          * 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.
@@ -194,6 +138,74 @@ declare namespace ApplicationInsights {
         protected _updateHook?(updateCtx: IProcessTelemetryUpdateContext, updateState: ITelemetryUpdateState): void | boolean;
     }
 
+    /**
+     * @export
+     * @class ApplicationInsights
+     */
+    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
@@ -284,7 +296,7 @@ declare namespace ApplicationInsights {
          * 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;
     }
 
     const DistributedTracingModes: EnumValue<typeof eDistributedTracingModes>;
@@ -389,10 +401,16 @@ declare namespace ApplicationInsights {
         TrackPageActionEventFailed = 103,
         FailedAddingCustomDefinedRequestContext = 104,
         InMemoryStorageBufferFull = 105,
-        InstrumentationKeyDeprecation = 106
+        InstrumentationKeyDeprecation = 106,
+        ConfigWatcherException = 107,
+        DynamicConfigException = 108
     }
 
     const enum eLoggingSeverity {
+        /**
+         * No Logging will be enabled
+         */
+        DISABLED = 0,
         /**
          * Error will be sent as internal telemetry
          */
@@ -416,12 +434,6 @@ declare namespace ApplicationInsights {
         Critical = 4
     }
 
-    const enum GetExtCfgMergeType {
-        None = 0,
-        MergeDefaultOnly = 1,
-        MergeDefaultFromRootOrDefault = 2
-    }
-
     interface IAppInsightsCore extends IPerfManagerProvider {
         config: IConfiguration;
         logger: IDiagnosticLogger;
@@ -449,12 +461,12 @@ declare namespace ApplicationInsights {
          * 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;
         /**
@@ -462,7 +474,7 @@ declare namespace ApplicationInsights {
          * @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;
         /**
@@ -494,6 +506,14 @@ declare namespace ApplicationInsights {
          * @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
          */
@@ -503,6 +523,11 @@ declare namespace ApplicationInsights {
          * @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)
@@ -522,6 +547,13 @@ declare namespace ApplicationInsights {
          * 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;
     }
 
     /**
@@ -621,13 +653,13 @@ declare namespace ApplicationInsights {
         /**
          * 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;
         /**
@@ -1019,6 +1051,51 @@ declare namespace ApplicationInsights {
         addIntEndpoints?: boolean;
     }
 
+    /**
+     * The type to identify whether the default value should be applied in preference to the provided value.
+     */
+    type IConfigCheckFn<V> = (value: V) => boolean;
+
+    /**
+     * The default values with a check function
+     */
+    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
+     */
+    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
+     */
+    type IConfigSetFn<T, V> = (value: any, defValue: V, theConfig: T) => V;
+
     /**
      * Configuration provided to SDK core
      */
@@ -1200,6 +1277,11 @@ declare namespace ApplicationInsights {
          * @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;
     }
 
     /**
@@ -1300,20 +1382,20 @@ declare namespace ApplicationInsights {
         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;
+        throwInternal(severity: LoggingSeverity, msgId: _eInternalMessageId, 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;
         /**
@@ -1322,10 +1404,15 @@ declare namespace ApplicationInsights {
         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;
     }
 
     interface IDistributedTraceContext {
@@ -1372,6 +1459,39 @@ declare namespace ApplicationInsights {
         setTraceFlags(newValue?: number): void;
     }
 
+    /**
+     * This interface identifies the config which can track changes
+     */
+    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;
+    }
+
     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.
@@ -1424,76 +1544,14 @@ declare namespace ApplicationInsights {
         iKey?: string;
     }
 
-    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
      */
-    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
-     */
-    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[];
+    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;
     }
 
     interface ILoadedPlugin<T extends IPlugin> {
@@ -1567,20 +1625,20 @@ declare namespace ApplicationInsights {
     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;
         /**
@@ -1598,60 +1656,47 @@ declare namespace ApplicationInsights {
         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.
-     */
-    type InstrumentorHooksCallback = (funcArgs: IInstrumentCallDetails, ...orgArgs: any[]) => void;
-
     class _InternalLogMessage {
         static dataType: string;
         message: string;
-        messageId: _InternalMessageId;
-        constructor(msgId: _InternalMessageId, msg: string, isUserAct?: boolean, properties?: Object);
+        messageId: _eInternalMessageId;
+        constructor(msgId: _eInternalMessageId, msg: string, isUserAct?: boolean, properties?: Object);
     }
 
-    /**
-     * Internal message ID. Please create a new one for every conceptually different message. Please keep alphabetically ordered
-     */
-    const _InternalMessageId: EnumValue<typeof _eInternalMessageId>;
-
-    type _InternalMessageId = number | _eInternalMessageId;
-
     interface IPageViewPerformanceTelemetry extends IPartC {
         /**
          * name String - The name of the page. Defaults to the document title.
@@ -1811,14 +1856,14 @@ declare namespace ApplicationInsights {
         /**
          * 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;
         /**
@@ -1844,7 +1889,7 @@ declare namespace ApplicationInsights {
         getPerfMgr(): IPerfManager;
         /**
          * Set the current performance manager
-         * @param perfMgr The performance manager
+         * @param perfMgr - The performance manager
          */
         setPerfMgr(perfMgr: IPerfManager): void;
     }
@@ -2013,68 +2058,68 @@ declare namespace ApplicationInsights {
         /**
          * 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;
     }
 
     interface ISerializable {
@@ -2093,7 +2138,7 @@ declare namespace ApplicationInsights {
         obj: string[];
     }
 
-    interface ITelemetryInitializerHandler {
+    interface ITelemetryInitializerHandler extends ILegacyUnloadHook {
         remove(): void;
     }
 
@@ -2211,12 +2256,22 @@ declare namespace ApplicationInsights {
          * 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)
          */
@@ -2248,6 +2303,26 @@ declare namespace ApplicationInsights {
         iKey?: string;
     }
 
+    /**
+     * An interface which provides automatic removal during unloading of the component
+     */
+    interface IUnloadHook {
+        /**
+         * Self remove the referenced component
+         */
+        rm: () => void;
+    }
+
+    interface IWatchDetails<T extends IConfiguration> {
+        cfg: T;
+        hdlr: IDynamicConfigHandler<T>;
+    }
+
+    interface IWatcherHandler<T extends IConfiguration> extends IUnloadHook {
+        fn: WatcherFunction<T>;
+        rm: () => void;
+    }
+
     const LoggingSeverity: EnumValue<typeof eLoggingSeverity>;
 
     type LoggingSeverity = number | eLoggingSeverity;
@@ -2314,8 +2389,8 @@ declare namespace ApplicationInsights {
         _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;
         /**
@@ -2336,8 +2411,8 @@ declare namespace ApplicationInsights {
         _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;
     }
@@ -2436,6 +2511,7 @@ declare namespace ApplicationInsights {
         /**
          * The configuration has ben updated or changed
          */
+        ConfigurationChanged = 1,
         /**
          * One or more plugins have been added
          */
@@ -2450,6 +2526,8 @@ declare namespace ApplicationInsights {
 
     type UnloadHandler = (itemCtx: IProcessTelemetryUnloadContext, unloadState: ITelemetryUnloadState) => void;
 
+    type WatcherFunction<T extends IConfiguration> = (details: IWatchDetails<T>) => void;
+
     interface XDomainRequest extends XMLHttpRequestEventTarget {
         readonly responseText: string;
         send(payload: string): void;