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

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

@@ -1,5 +1,5 @@
 /*
- * Microsoft Application Insights Core Javascript SDK, 3.0.0-beta.2210-01
+ * Microsoft Application Insights Core Javascript SDK, 3.0.0-beta.2210-03
  * Copyright (c) Microsoft and contributors. All rights reserved.
  *
  * Microsoft Application Insights Team
@@ -17,6 +17,7 @@ import { arrForEach } from '@nevware21/ts-utils';
 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';
@@ -73,8 +74,8 @@ export declare function __getRegisteredEvents(target: any, eventName?: string, e
 
 /**
  * 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
  */
@@ -82,8 +83,8 @@ export declare function addEventHandler(eventName: string, callback: any, evtNam
 
 /**
  * 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
@@ -130,33 +131,7 @@ export declare function addPageShowEventListener(listener: any, excludeEvents?:
  */
 export declare function addPageUnloadEventListener(listener: any, excludeEvents?: string[], evtNamespace?: string | string[]): boolean;
 
-export declare class AppInsightsCore extends BaseCore implements IAppInsightsCore {
-    constructor();
-    initialize(config: IConfiguration, extensions: IPlugin[], logger?: IDiagnosticLogger, notificationManager?: INotificationManager): void;
-    track(telemetryItem: ITelemetryItem): void;
-}
-
-export declare 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
- */
-export declare function attachEvent(obj: any, eventNameWithoutOn: string, handlerRef: any, useCapture?: boolean): boolean;
-
-export declare class BaseCore implements IAppInsightsCore {
+export declare class AppInsightsCore implements IAppInsightsCore {
     static defaultConfig: IConfiguration;
     config: IConfiguration;
     logger: IDiagnosticLogger;
@@ -172,12 +147,12 @@ export 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;
     /**
@@ -205,7 +180,7 @@ export 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
@@ -227,6 +202,12 @@ export 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
      */
@@ -254,6 +235,18 @@ export 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.
@@ -264,6 +257,30 @@ export declare class BaseCore implements IAppInsightsCore {
     protected _updateHook?(updateCtx: IProcessTelemetryUpdateContext, updateState: ITelemetryUpdateState): void | boolean;
 }
 
+export declare function applyDefaults<C>(theConfig: C, defaultValues: IConfigDefaults<C>): C;
+
+export declare 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
+ */
+export declare 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
@@ -354,18 +371,27 @@ export 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;
 }
 
 /**
  * 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
  */
 export declare function createClassFromInterface<T>(defaults?: T): new () => T;
 
 export declare 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)
+ */
+export declare 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
@@ -382,7 +408,7 @@ export declare const createEnumStyle: <E>(values: {
  * @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
  */
-export declare function createProcessTelemetryContext(telemetryChain: ITelemetryPluginChain | null, config: IConfiguration, core: IAppInsightsCore, startAt?: IPlugin): IProcessTelemetryContext;
+export declare function createProcessTelemetryContext(telemetryChain: ITelemetryPluginChain | null, cfg: IConfiguration, core: IAppInsightsCore, startAt?: IPlugin): IProcessTelemetryContext;
 
 /**
  * Create a new ITraceParent instance using the provided values.
@@ -424,13 +450,13 @@ export { deepFreeze }
 
 /**
  * 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
  */
 export declare function detachEvent(obj: any, eventNameWithoutOn: string, handlerRef: any, useCapture?: boolean): void;
 
@@ -463,18 +489,18 @@ export declare class DiagnosticLogger implements IDiagnosticLogger {
     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;
     /**
      * 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;
     /**
@@ -483,10 +509,11 @@ export declare class DiagnosticLogger implements 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;
+    update(updateState: ITelemetryUpdateState): void;
 }
 
 /**
@@ -614,10 +641,16 @@ export declare const enum _eInternalMessageId {
     TrackPageActionEventFailed = 103,
     FailedAddingCustomDefinedRequestContext = 104,
     InMemoryStorageBufferFull = 105,
-    InstrumentationKeyDeprecation = 106
+    InstrumentationKeyDeprecation = 106,
+    ConfigWatcherException = 107,
+    DynamicConfigException = 108
 }
 
 export declare const enum eLoggingSeverity {
+    /**
+     * No Logging will be enabled
+     */
+    DISABLED = 0,
     /**
      * Error will be sent as internal telemetry
      */
@@ -632,27 +665,27 @@ export declare type EnumValue<E = any> = EnumCls<E>;
 
 /**
  * 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
  */
 export declare 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
  */
 export declare function eventOn<T>(target: T, eventName: string, handlerRef: any, evtNamespace?: string | string[] | null, useCapture?: boolean): boolean;
@@ -715,17 +748,19 @@ export declare function getDebugListener(config: IConfiguration): INotificationL
 
 export { getDocument }
 
+/**
+ * @internal
+ * Get the dynamic config handler if the value is already dynamic
+ * @param value
+ * @returns
+ */
+export declare function getDynamicConfigHandler<T>(value: T | IDynamicConfigHandler<T>): IDynamicConfigHandler<T> | null;
+
 /**
  * Returns the name of object if it's an Error. Otherwise, returns empty string.
  */
 export declare function getExceptionName(object: any): string;
 
-export declare 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
@@ -829,12 +864,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;
     /**
@@ -842,7 +877,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;
     /**
@@ -874,6 +909,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
      */
@@ -883,6 +926,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)
@@ -902,6 +950,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;
 }
 
 export declare interface IBaseProcessingContext {
@@ -920,13 +975,13 @@ export 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;
     /**
@@ -997,6 +1052,51 @@ export declare interface IChannelControls extends ITelemetryPlugin {
     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.
+ */
+export declare type IConfigCheckFn<V> = (value: V) => boolean;
+
+/**
+ * The default values with a check function
+ */
+export 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
+ */
+export 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
+ */
+export declare type IConfigSetFn<T, V> = (value: any, defValue: V, theConfig: T) => V;
+
 /**
  * Configuration provided to SDK core
  */
@@ -1178,6 +1278,11 @@ export 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;
 }
 
 /**
@@ -1271,20 +1376,20 @@ export 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;
     /**
@@ -1293,10 +1398,15 @@ export 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;
 }
 
 export declare interface IDistributedTraceContext {
@@ -1343,6 +1453,50 @@ export declare interface IDistributedTraceContext {
     setTraceFlags(newValue?: number): void;
 }
 
+/**
+ * This interface identifies the config which can track changes
+ */
+export 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;
+}
+
+export declare 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>[];
+}
+
 export declare interface IInstrumentCallDetails {
     name: string;
     inst: any;
@@ -1377,7 +1531,7 @@ export declare interface IInstrumentCallDetails {
 /**
  * The holder of the specific instance callback
  */
-export declare interface IInstrumentHook {
+export declare interface IInstrumentHook extends IUnloadHook {
     /** Unique Id for this callback on the hooked method */
     id: number;
     /** Holds the callbacks */
@@ -1422,6 +1576,16 @@ export declare interface IInstrumentHooksCallbacks {
     fnErr?: InstrumentorHooksCallback;
 }
 
+/**
+ * An alternate interface which provides automatic removal during unloading of the component
+ */
+export declare interface ILegacyUnloadHook {
+    /**
+     * Legacy Self remove the referenced component
+     */
+    remove: () => void;
+}
+
 export declare interface ILoadedPlugin<T extends IPlugin> {
     plugin: T;
     /**
@@ -1443,9 +1607,9 @@ export declare interface ILoadedPlugin<T extends IPlugin> {
 /**
  * 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
  */
 export declare function initializePlugins(processContext: IProcessTelemetryContext, extensions: IPlugin[]): void;
 
@@ -1456,20 +1620,20 @@ export declare function initializePlugins(processContext: IProcessTelemetryConte
 export 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;
     /**
@@ -1487,36 +1651,36 @@ export 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;
 }
@@ -1578,11 +1742,6 @@ export 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;
 
 /**
@@ -1650,14 +1809,14 @@ export 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;
     /**
@@ -1683,7 +1842,7 @@ export declare interface IPerfManagerProvider {
     getPerfMgr(): IPerfManager;
     /**
      * Set the current performance manager
-     * @param perfMgr The performance manager
+     * @param perfMgr - The performance manager
      */
     setPerfMgr(perfMgr: IPerfManager): void;
 }
@@ -1900,7 +2059,7 @@ export declare interface ITelemetryInitializerContainer {
     addTelemetryInitializer(telemetryInitializer: TelemetryInitializerFunction): ITelemetryInitializerHandler | void;
 }
 
-export declare interface ITelemetryInitializerHandler {
+export declare interface ITelemetryInitializerHandler extends ILegacyUnloadHook {
     remove(): void;
 }
 
@@ -2018,12 +2177,22 @@ export 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)
      */
@@ -2084,6 +2253,26 @@ export declare interface IUnloadHandlerContainer {
     run: (itemCtx: IProcessTelemetryUnloadContext, unloadState: ITelemetryUnloadState) => void;
 }
 
+/**
+ * An interface which provides automatic removal during unloading of the component
+ */
+export declare interface IUnloadHook {
+    /**
+     * Self remove the referenced component
+     */
+    rm: () => void;
+}
+
+export declare interface IWatchDetails<T extends IConfiguration> {
+    cfg: T;
+    hdlr: IDynamicConfigHandler<T>;
+}
+
+export declare interface IWatcherHandler<T extends IConfiguration> extends IUnloadHook {
+    fn: WatcherFunction<T>;
+    rm: () => void;
+}
+
 export declare const LoggingSeverity: EnumValue<typeof eLoggingSeverity>;
 
 export declare type LoggingSeverity = number | eLoggingSeverity;
@@ -2091,8 +2280,8 @@ export declare type LoggingSeverity = number | eLoggingSeverity;
 /**
  * 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.
  */
 export declare function _logInternalMessage(logger: IDiagnosticLogger, severity: LoggingSeverity, message: _InternalLogMessage): void;
 
@@ -2128,7 +2317,7 @@ export declare function newId(maxLength?: number): string;
  * 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
  */
 export declare function normalizeJsName(name: string): string;
 
@@ -2140,30 +2329,30 @@ export declare class NotificationManager implements INotificationManager {
     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;
     /**
@@ -2202,6 +2391,17 @@ export { objSeal }
 
 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
+ */
+export declare 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
@@ -2269,14 +2469,14 @@ export declare class PerfManager implements 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, 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;
     /**
@@ -2307,7 +2507,7 @@ export declare class ProcessTelemetryContext implements IProcessTelemetryContext
      * 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
@@ -2419,9 +2619,9 @@ export declare function randomValue(maxValue: number): number;
 
 /**
  * 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.
@@ -2430,8 +2630,8 @@ export declare function removeEventHandler(eventName: string, callback: any, evt
 
 /**
  * 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.
  */
 export declare function removeEventListeners(events: string[], listener: any, evtNamespace?: string | string[]): void;
@@ -2606,6 +2806,7 @@ export declare const enum TelemetryUpdateReason {
     /**
      * The configuration has ben updated or changed
      */
+    ConfigurationChanged = 1,
     /**
      * One or more plugins have been added
      */
@@ -2624,15 +2825,15 @@ export { throwError }
  * 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.
  */
 export declare function _throwInternal(logger: IDiagnosticLogger, severity: LoggingSeverity, msgId: _InternalMessageId, msg: string, properties?: Object, isUserAct?: boolean): void;
 
 /**
  * Convert a date to I.S.O. format in IE8
  */
-export declare function toISOString(date: Date): any;
+export declare function toISOString(date: Date): string;
 
 export declare function uaDisallowsSameSiteNone(userAgent: string): boolean;
 
@@ -2656,8 +2857,10 @@ export declare function useXDomainRequest(): boolean | undefined;
 /**
  * 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.
  */
 export declare function _warnToConsole(logger: IDiagnosticLogger, message: string): void;
 
+export declare type WatcherFunction<T extends IConfiguration> = (details: IWatchDetails<T>) => void;
+
 export { }