@microsoft/applicationinsights-core-js 3.0.0-beta.2209-03 → 3.0.0-beta.2210-02

package/dist/applicationinsights-core-js.d.ts

@@ -1,5 +1,5 @@
 /*
- * Microsoft Application Insights Core Javascript SDK, 3.0.0-beta.2209-03
+ * Microsoft Application Insights Core Javascript SDK, 3.0.0-beta.2210-02
  * Copyright (c) Microsoft and contributors. All rights reserved.
  *
  * Microsoft Application Insights Team
@@ -11,6 +11,7 @@ declare namespace ApplicationInsights {
     import { arrIndexOf } from '@nevware21/ts-utils';
     import { arrMap } from '@nevware21/ts-utils';
     import { arrReduce } from '@nevware21/ts-utils';
+    import { asString } from '@nevware21/ts-utils';
     import { objDeepFreeze as deepFreeze } from '@nevware21/ts-utils';
     import { dumpObj } from '@nevware21/ts-utils';
     import { EnumCls } from '@nevware21/ts-utils';
@@ -67,8 +68,8 @@ declare namespace ApplicationInsights {
 
     /**
      * Trys to add an event handler for the specified event to the window, body and document
-     * @param eventName {string} - The name of the event
-     * @param callback {any} - The callback function that needs to be executed for the given event
+     * @param eventName - {string} - The name of the event
+     * @param callback - {any} - The callback function that needs to be executed for the given event
      * @param evtNamespace - [Optional] Namespace(s) to append to the event listeners so they can be uniquely identified and removed based on this namespace.
      * @return {boolean} - true if the handler was successfully added
      */
@@ -76,8 +77,8 @@ declare namespace ApplicationInsights {
 
     /**
      * Bind the listener to the array of events
-     * @param events An string array of event names to bind the listener to
-     * @param listener The event callback to call when the event is triggered
+     * @param events - An string array of event names to bind the listener to
+     * @param listener - The event callback to call when the event is triggered
      * @param excludeEvents - [Optional] An array of events that should not be hooked (if possible), unless no other events can be.
      * @param evtNamespace - [Optional] Namespace(s) to append to the event listeners so they can be uniquely identified and removed based on this namespace.
      * @returns true - when at least one of the events was registered otherwise false
@@ -124,33 +125,7 @@ declare namespace ApplicationInsights {
      */
     function addPageUnloadEventListener(listener: any, excludeEvents?: string[], evtNamespace?: string | string[]): boolean;
 
-    class AppInsightsCore extends BaseCore implements IAppInsightsCore {
-        constructor();
-        initialize(config: IConfiguration, extensions: IPlugin[], logger?: IDiagnosticLogger, notificationManager?: INotificationManager): void;
-        track(telemetryItem: ITelemetryItem): void;
-    }
-
-    function areCookiesSupported(logger?: IDiagnosticLogger): any;
-
-    export { arrForEach }
-
-    export { arrIndexOf }
-
-    export { arrMap }
-
-    export { arrReduce }
-
-    /**
-     * Binds the specified function to an event, so that the function gets called whenever the event fires on the object
-     * @param obj Object to add the event too.
-     * @param eventNameWithoutOn String that specifies any of the standard DHTML Events without "on" prefix and optional (dot "." prefixed) namespaces "click" "click.mynamespace".
-     * @param handlerRef Pointer that specifies the function to call when event fires
-     * @param useCapture [Optional] Defaults to false
-     * @returns True if the function was bound successfully to the event, otherwise false
-     */
-    function attachEvent(obj: any, eventNameWithoutOn: string, handlerRef: any, useCapture?: boolean): boolean;
-
-    class BaseCore implements IAppInsightsCore {
+    class AppInsightsCore implements IAppInsightsCore {
         static defaultConfig: IConfiguration;
         config: IConfiguration;
         logger: IDiagnosticLogger;
@@ -166,12 +141,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;
         /**
@@ -199,7 +174,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
@@ -221,6 +196,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
          */
@@ -248,6 +229,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.
@@ -258,6 +251,30 @@ declare namespace ApplicationInsights {
         protected _updateHook?(updateCtx: IProcessTelemetryUpdateContext, updateState: ITelemetryUpdateState): void | boolean;
     }
 
+    function applyDefaults<C>(theConfig: C, defaultValues: IConfigDefaults<C>): C;
+
+    function areCookiesSupported(logger?: IDiagnosticLogger): any;
+
+    export { arrForEach }
+
+    export { arrIndexOf }
+
+    export { arrMap }
+
+    export { arrReduce }
+
+    export { asString }
+
+    /**
+     * Binds the specified function to an event, so that the function gets called whenever the event fires on the object
+     * @param obj - Object to add the event too.
+     * @param eventNameWithoutOn - String that specifies any of the standard DHTML Events without "on" prefix and optional (dot "." prefixed) namespaces "click" "click.mynamespace".
+     * @param handlerRef - Pointer that specifies the function to call when event fires
+     * @param useCapture - [Optional] Defaults to false
+     * @returns True if the function was bound successfully to the event, otherwise false
+     */
+    function attachEvent(obj: any, eventNameWithoutOn: string, handlerRef: any, useCapture?: boolean): boolean;
+
     /**
      * 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
@@ -348,18 +365,27 @@ 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;
     }
 
     /**
      * Simpler helper to create a dynamic class that implements the interface and populates the values with the defaults.
      * Only instance properties (hasOwnProperty) values are copied from the defaults to the new instance
-     * @param defaults Simple helper
+     * @param defaults - Simple helper
      */
     function createClassFromInterface<T>(defaults?: T): new () => T;
 
     function createCookieMgr(rootConfig?: IConfiguration, logger?: IDiagnosticLogger): ICookieMgr;
 
+    /**
+     * Create or return a dynamic version of the passed config, if it is not already dynamic
+     * @param config - The config to be converted into a dynamic config
+     * @param defaultConfig - The default values to apply on the config if the properties don't already exist
+     * @param inPlace - Should the config be converted in-place into a dynamic config or a new instance returned, defaults to true
+     * @returns The dynamic config handler for the config (whether new or existing)
+     */
+    function createDynamicConfig<T extends IConfiguration>(config: T, defaultConfig?: IConfigDefaults<T>, logger?: IDiagnosticLogger, inPlace?: boolean): IDynamicConfigHandler<T>;
+
     /**
      * 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
@@ -376,7 +402,7 @@ declare namespace ApplicationInsights {
      * @param core - The current core instance
      * @param startAt - Identifies the next plugin to execute, if null there is no "next" plugin and if undefined it should assume the start of the chain
      */
-    function createProcessTelemetryContext(telemetryChain: ITelemetryPluginChain | null, config: IConfiguration, core: IAppInsightsCore, startAt?: IPlugin): IProcessTelemetryContext;
+    function createProcessTelemetryContext(telemetryChain: ITelemetryPluginChain | null, cfg: IConfiguration, core: IAppInsightsCore, startAt?: IPlugin): IProcessTelemetryContext;
 
     /**
      * Create a new ITraceParent instance using the provided values.
@@ -418,13 +444,13 @@ declare namespace ApplicationInsights {
 
     /**
      * Removes an event handler for the specified event
-     * @param Object to remove the event from
-     * @param eventNameWithoutOn {string} - The name of the event, with optional namespaces or just the namespaces,
+     * @param Object - to remove the event from
+     * @param eventNameWithoutOn - {string} - The name of the event, with optional namespaces or just the namespaces,
      * such as "click", "click.mynamespace" or ".mynamespace"
-     * @param handlerRef {any} - The callback function that needs to be removed from the given event, when using a
+     * @param handlerRef - {any} - The callback function that needs to be removed from the given event, when using a
      * namespace (with or without a qualifying event) this may be null to remove all previously attached event handlers
      * otherwise this will only remove events with this specific handler.
-     * @param useCapture [Optional] Defaults to false
+     * @param useCapture - [Optional] Defaults to false
      */
     function detachEvent(obj: any, eventNameWithoutOn: string, handlerRef: any, useCapture?: boolean): void;
 
@@ -457,18 +483,18 @@ declare namespace ApplicationInsights {
         maxInternalMessageLimit(): number;
         /**
          * 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
-         * @param message {string} - The warning message
+         * @param message - {string} - The warning message
          */
         errorToConsole(message: string): void;
         /**
@@ -477,10 +503,11 @@ 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;
+        update(updateState: ITelemetryUpdateState): void;
     }
 
     /**
@@ -608,10 +635,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
          */
@@ -626,27 +659,27 @@ declare namespace ApplicationInsights {
 
     /**
      * Removes an event handler for the specified event
-     * @param Object to remove the event from
-     * @param eventName {string} - The name of the event, with optional namespaces or just the namespaces,
+     * @param Object - to remove the event from
+     * @param eventName - {string} - The name of the event, with optional namespaces or just the namespaces,
      * such as "click", "click.mynamespace" or ".mynamespace"
-     * @param handlerRef {any} - The callback function that needs to be removed from the given event, when using a
+     * @param handlerRef - {any} - The callback function that needs to be removed from the given event, when using a
      * namespace (with or without a qualifying event) this may be null to remove all previously attached event handlers
      * otherwise this will only remove events with this specific handler.
      * @param evtNamespace - [Optional] Additional namespace(s) to append to the event listeners so they can be uniquely identified and removed based on this namespace,
      * if the eventName also includes a namespace the namespace(s) are merged into a single namespace
-     * @param useCapture [Optional] Defaults to false
+     * @param useCapture - [Optional] Defaults to false
      */
     function eventOff<T>(target: T, eventName: string, handlerRef: any, evtNamespace?: string | string[] | null, useCapture?: boolean): void;
 
     /**
      * Binds the specified function to an event, so that the function gets called whenever the event fires on the object
-     * @param obj Object to add the event too.
-     * @param eventName String that specifies any of the standard DHTML Events without "on" prefix, if may also include an optional (dot "." prefixed)
+     * @param obj - Object to add the event too.
+     * @param eventName - String that specifies any of the standard DHTML Events without "on" prefix, if may also include an optional (dot "." prefixed)
      * namespaces "click" "click.mynamespace" in addition to specific namespaces.
-     * @param handlerRef Pointer that specifies the function to call when event fires
+     * @param handlerRef - Pointer that specifies the function to call when event fires
      * @param evtNamespace - [Optional] Additional namespace(s) to append to the event listeners so they can be uniquely identified and removed based on this namespace,
      * if the eventName also includes a namespace the namespace(s) are merged into a single namespace
-     * @param useCapture [Optional] Defaults to false
+     * @param useCapture - [Optional] Defaults to false
      * @returns True if the function was bound successfully to the event, otherwise false
      */
     function eventOn<T>(target: T, eventName: string, handlerRef: any, evtNamespace?: string | string[] | null, useCapture?: boolean): boolean;
@@ -709,17 +742,19 @@ declare namespace ApplicationInsights {
 
     export { getDocument }
 
+    /**
+     * @internal
+     * Get the dynamic config handler if the value is already dynamic
+     * @param value
+     * @returns
+     */
+    function getDynamicConfigHandler<T>(value: T | IDynamicConfigHandler<T>): IDynamicConfigHandler<T> | null;
+
     /**
      * Returns the name of object if it's an Error. Otherwise, returns empty string.
      */
     function getExceptionName(object: any): string;
 
-    const enum GetExtCfgMergeType {
-        None = 0,
-        MergeDefaultOnly = 1,
-        MergeDefaultFromRootOrDefault = 2
-    }
-
     /**
      * Get the current global performance manager that will be used with no performance manager is supplied.
      * @returns - The current default manager
@@ -823,12 +858,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;
         /**
@@ -836,7 +871,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;
         /**
@@ -868,6 +903,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
          */
@@ -877,6 +920,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)
@@ -896,6 +944,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;
     }
 
     interface IBaseProcessingContext {
@@ -914,13 +969,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;
         /**
@@ -991,6 +1046,51 @@ declare namespace ApplicationInsights {
         flush(async: boolean, callBack?: (flushComplete?: boolean) => void, sendReason?: SendRequestReason): boolean | void;
     }
 
+    /**
+     * 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
      */
@@ -1172,6 +1272,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;
     }
 
     /**
@@ -1265,20 +1370,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;
         /**
@@ -1287,10 +1392,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 {
@@ -1337,6 +1447,50 @@ 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 IDynamicPropertyHandler<T> {
+        /**
+         * Identifies the name of the field that is handled by this handler
+         */
+        n: string;
+        /**
+         * The current collection is watcher handlers which should be called if the value changes
+         */
+        h: IWatcherHandler<T>[];
+    }
+
     interface IInstrumentCallDetails {
         name: string;
         inst: any;
@@ -1371,7 +1525,7 @@ declare namespace ApplicationInsights {
     /**
      * The holder of the specific instance callback
      */
-    interface IInstrumentHook {
+    interface IInstrumentHook extends IUnloadHook {
         /** Unique Id for this callback on the hooked method */
         id: number;
         /** Holds the callbacks */
@@ -1416,6 +1570,16 @@ declare namespace ApplicationInsights {
         fnErr?: InstrumentorHooksCallback;
     }
 
+    /**
+     * An alternate interface which provides automatic removal during unloading of the component
+     */
+    interface ILegacyUnloadHook {
+        /**
+         * Legacy Self remove the referenced component
+         */
+        remove: () => void;
+    }
+
     interface ILoadedPlugin<T extends IPlugin> {
         plugin: T;
         /**
@@ -1437,9 +1601,9 @@ declare namespace ApplicationInsights {
     /**
      * Initialize the queue of plugins
      * @param plugins - The array of plugins to initialize and setting of the next plugin
-     * @param config The current config for the instance
-     * @param core THe current core instance
-     * @param extensions The extensions
+     * @param config - The current config for the instance
+     * @param core - THe current core instance
+     * @param extensions - The extensions
      */
     function initializePlugins(processContext: IProcessTelemetryContext, extensions: IPlugin[]): void;
 
@@ -1450,20 +1614,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;
         /**
@@ -1481,36 +1645,36 @@ 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;
     }
@@ -1568,17 +1732,10 @@ declare namespace ApplicationInsights {
     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;
-
     /**
      * This interface identifies the details of an internal performance event - it does not represent an outgoing reported event
      */
@@ -1644,14 +1801,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;
         /**
@@ -1677,7 +1834,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;
     }
@@ -1894,7 +2051,7 @@ declare namespace ApplicationInsights {
         addTelemetryInitializer(telemetryInitializer: TelemetryInitializerFunction): ITelemetryInitializerHandler | void;
     }
 
-    interface ITelemetryInitializerHandler {
+    interface ITelemetryInitializerHandler extends ILegacyUnloadHook {
         remove(): void;
     }
 
@@ -2012,12 +2169,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)
          */
@@ -2078,6 +2245,26 @@ declare namespace ApplicationInsights {
         run: (itemCtx: IProcessTelemetryUnloadContext, unloadState: ITelemetryUnloadState) => void;
     }
 
+    /**
+     * 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;
@@ -2085,8 +2272,8 @@ declare namespace ApplicationInsights {
     /**
      * Logs a message to the internal queue.
      * @param logger - The Diagnostic Logger instance to use.
-     * @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.
      */
     function _logInternalMessage(logger: IDiagnosticLogger, severity: LoggingSeverity, message: _InternalLogMessage): void;
 
@@ -2122,7 +2309,7 @@ declare namespace ApplicationInsights {
      * normalizes the name so that it would. This method does not identify or change any keywords
      * meaning that if you pass in a known keyword the same value will be returned.
      * This is a simplified version
-     * @param name The name to validate
+     * @param name - The name to validate
      */
     function normalizeJsName(name: string): string;
 
@@ -2134,30 +2321,30 @@ declare namespace ApplicationInsights {
         constructor(config?: IConfiguration);
         /**
          * 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;
         /**
@@ -2196,6 +2383,17 @@ declare namespace ApplicationInsights {
 
     export { objToString }
 
+    /**
+     * Watch and track changes for accesses to the current config, the provided config MUST already be
+     * a dynamic config or a child accessed via the dynamic config
+     * @param config
+     * @param configHandler
+     * @param logger - The logger instance to use if there is no existing handler
+     * @returns A watcher handler instance that can be used to remove itself when being unloaded
+     * @throws TypeError if the provided config is not a dynamic config instance
+     */
+    function onConfigChange<T>(config: T, configHandler: WatcherFunction<T>, logger?: IDiagnosticLogger): IWatcherHandler<T>;
+
     /**
      * A helper function to assist with JIT performance for objects that have properties added / removed dynamically
      * this is primarily for chromium based browsers and has limited effects on Firefox and none of IE. Only call this
@@ -2263,14 +2461,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, payload?: 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;
         /**
@@ -2301,7 +2499,7 @@ declare namespace ApplicationInsights {
          * Gets the current core config instance
          */
         getCfg: () => IConfiguration;
-        getExtCfg: <T>(identifier: string, defaultValue?: T | any) => T;
+        getExtCfg: <T>(identifier: string, defaultValue?: IConfigDefaults<T>) => T;
         getConfig: (identifier: string, field: string, defaultValue?: number | string | boolean | string[] | RegExp[] | Function) => number | string | boolean | string[] | RegExp[] | Function;
         /**
          * Returns the IAppInsightsCore instance for the current request
@@ -2413,9 +2611,9 @@ declare namespace ApplicationInsights {
 
     /**
      * Trys to remove event handler(s) for the specified event/namespace to the window, body and document
-     * @param eventName {string} - The name of the event, with optional namespaces or just the namespaces,
+     * @param eventName - {string} - The name of the event, with optional namespaces or just the namespaces,
      * such as "click", "click.mynamespace" or ".mynamespace"
-     * @param callback {any} - - The callback function that needs to be removed from the given event, when using a
+     * @param callback - {any} - - The callback function that needs to be removed from the given event, when using a
      * namespace (with or without a qualifying event) this may be null to remove all previously attached event handlers
      * otherwise this will only remove events with this specific handler.
      * @param evtNamespace - [Optional] Namespace(s) to append to the event listeners so they can be uniquely identified and removed based on this namespace.
@@ -2424,8 +2622,8 @@ declare namespace ApplicationInsights {
 
     /**
      * Remove the listener from the array of events
-     * @param events An string array of event names to bind the listener to
-     * @param listener The event callback to call when the event is triggered
+     * @param events - An string array of event names to bind the listener to
+     * @param listener - The event callback to call when the event is triggered
      * @param evtNamespace - [Optional] Namespace(s) to append to the event listeners so they can be uniquely identified and removed based on this namespace.
      */
     function removeEventListeners(events: string[], listener: any, evtNamespace?: string | string[]): void;
@@ -2600,6 +2798,7 @@ declare namespace ApplicationInsights {
         /**
          * The configuration has ben updated or changed
          */
+        ConfigurationChanged = 1,
         /**
          * One or more plugins have been added
          */
@@ -2618,15 +2817,15 @@ declare namespace ApplicationInsights {
      * support minification as logger.throwInternal() will not compress the publish "throwInternal" used throughout
      * the code.
      * @param logger - The Diagnostic Logger instance to use.
-     * @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.
      */
-    function _throwInternal(logger: IDiagnosticLogger, severity: LoggingSeverity, msgId: _InternalMessageId, msg: string, properties?: Object, isUserAct?: boolean): void;
+    function _throwInternal(logger: IDiagnosticLogger, severity: LoggingSeverity, msgId: _eInternalMessageId, msg: string, properties?: Object, isUserAct?: boolean): void;
 
     /**
      * Convert a date to I.S.O. format in IE8
      */
-    function toISOString(date: Date): any;
+    function toISOString(date: Date): string;
 
     function uaDisallowsSameSiteNone(userAgent: string): boolean;
 
@@ -2650,9 +2849,11 @@ declare namespace ApplicationInsights {
     /**
      * This is a helper method which will call warnToConsole on the passed logger with the provided message.
      * @param logger - The Diagnostic Logger instance to use.
-     * @param message {_InternalLogMessage} - The log message.
+     * @param message - {_InternalLogMessage} - The log message.
      */
     function _warnToConsole(logger: IDiagnosticLogger, message: string): void;
 
+    type WatcherFunction<T extends IConfiguration> = (details: IWatchDetails<T>) => void;
+
     
 }