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

package/types/JavaScriptSDK/AppInsightsCore.d.ts

@@ -1,12 +1,144 @@
-import { IAppInsightsCore } from "../JavaScriptSDK.Interfaces/IAppInsightsCore";
+import { WatcherFunction } from "../Config/IDynamicWatcher";
+import { SendRequestReason } from "../JavaScriptSDK.Enums/SendRequestReason";
+import { IAppInsightsCore, ILoadedPlugin } from "../JavaScriptSDK.Interfaces/IAppInsightsCore";
+import { IChannelControls } from "../JavaScriptSDK.Interfaces/IChannelControls";
 import { IConfiguration } from "../JavaScriptSDK.Interfaces/IConfiguration";
+import { ICookieMgr } from "../JavaScriptSDK.Interfaces/ICookieMgr";
 import { IDiagnosticLogger } from "../JavaScriptSDK.Interfaces/IDiagnosticLogger";
+import { IDistributedTraceContext } from "../JavaScriptSDK.Interfaces/IDistributedTraceContext";
+import { INotificationListener } from "../JavaScriptSDK.Interfaces/INotificationListener";
 import { INotificationManager } from "../JavaScriptSDK.Interfaces/INotificationManager";
+import { IPerfManager } from "../JavaScriptSDK.Interfaces/IPerfManager";
+import { IProcessTelemetryContext, IProcessTelemetryUpdateContext } from "../JavaScriptSDK.Interfaces/IProcessTelemetryContext";
+import { ITelemetryInitializerHandler, TelemetryInitializerFunction } from "../JavaScriptSDK.Interfaces/ITelemetryInitializers";
 import { ITelemetryItem } from "../JavaScriptSDK.Interfaces/ITelemetryItem";
-import { IPlugin } from "../JavaScriptSDK.Interfaces/ITelemetryPlugin";
-import { BaseCore } from "./BaseCore";
-export declare class AppInsightsCore extends BaseCore implements IAppInsightsCore {
+import { IPlugin, ITelemetryPlugin } from "../JavaScriptSDK.Interfaces/ITelemetryPlugin";
+import { ITelemetryUnloadState } from "../JavaScriptSDK.Interfaces/ITelemetryUnloadState";
+import { ITelemetryUpdateState } from "../JavaScriptSDK.Interfaces/ITelemetryUpdateState";
+import { ILegacyUnloadHook, IUnloadHook } from "../JavaScriptSDK.Interfaces/IUnloadHook";
+import { UnloadHandler } from "./UnloadHandlerContainer";
+export declare class AppInsightsCore implements IAppInsightsCore {
+    static defaultConfig: IConfiguration;
+    config: IConfiguration;
+    logger: IDiagnosticLogger;
+    _extensions: IPlugin[];
+    isInitialized: () => boolean;
     constructor();
     initialize(config: IConfiguration, extensions: IPlugin[], logger?: IDiagnosticLogger, notificationManager?: INotificationManager): void;
+    getTransmissionControls(): IChannelControls[][];
     track(telemetryItem: ITelemetryItem): void;
+    getProcessTelContext(): IProcessTelemetryContext;
+    getNotifyMgr(): INotificationManager;
+    /**
+     * 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 listener - An INotificationListener object.
+     */
+    addNotificationListener(listener: INotificationListener): void;
+    /**
+     * Removes all instances of the listener.
+     * @param listener - INotificationListener to remove.
+     */
+    removeNotificationListener(listener: INotificationListener): void;
+    /**
+     * Get the current cookie manager for this instance
+     */
+    getCookieMgr(): ICookieMgr;
+    /**
+     * Set the current cookie manager for this instance
+     * @param cookieMgr - The manager, if set to null/undefined will cause the default to be created
+     */
+    setCookieMgr(cookieMgr: ICookieMgr): void;
+    getPerfMgr(): IPerfManager;
+    setPerfMgr(perfMgr: IPerfManager): void;
+    eventCnt(): number;
+    /**
+     * Periodically check logger.queue for
+     */
+    pollInternalLogs(eventName?: string): number;
+    /**
+     * Periodically check logger.queue for
+     */
+    stopPollingInternalLogs(): void;
+    /**
+     * Add a telemetry processor to decorate or drop telemetry events.
+     * @param telemetryInitializer - The Telemetry Initializer function
+     * @returns - A ITelemetryInitializerHandler to enable the initializer to be removed
+     */
+    addTelemetryInitializer(telemetryInitializer: TelemetryInitializerFunction): ITelemetryInitializerHandler;
+    /**
+     * Unload and Tear down the SDK and any initialized plugins, after calling this the SDK will be considered
+     * to be un-initialized and non-operational, re-initializing the SDK should only be attempted if the previous
+     * unload call return `true` stating that all plugins reported that they also unloaded, the recommended
+     * approach is to create a new instance and initialize that instance.
+     * This is due to possible unexpected side effects caused by plugins not supporting unload / teardown, unable
+     * to successfully remove any global references or they may just be completing the unload process asynchronously.
+     * @param isAsync - Can the unload be performed asynchronously (default)
+     * @param unloadComplete - An optional callback that will be called once the unload has completed
+     * @param cbTimeout - An optional timeout to wait for any flush operations to complete before proceeding with the unload. Defaults to 5 seconds.
+     */
+    unload(isAsync?: boolean, unloadComplete?: (unloadState: ITelemetryUnloadState) => void, cbTimeout?: number): void;
+    getPlugin<T extends IPlugin = IPlugin>(pluginIdentifier: string): ILoadedPlugin<T>;
+    /**
+     * Add a new plugin to the installation
+     * @param plugin - The new plugin to add
+     * @param replaceExisting - should any existing plugin be replaced, default is false
+     * @param doAsync - Should the add be performed asynchronously
+     * @param addCb - [Optional] callback to call after the plugin has been added
+     */
+    addPlugin<T extends IPlugin = ITelemetryPlugin>(plugin: T, replaceExisting?: boolean, doAsync?: boolean, addCb?: (added?: boolean) => void): void;
+    /**
+     * 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
+     */
+    evtNamespace(): string;
+    /**
+     * Add an unload handler that will be called when the SDK is being unloaded
+     * @param handler - the handler
+     */
+    addUnloadCb(handler: UnloadHandler): void;
+    /**
+     * Flush and send any batched / cached data immediately
+     * @param async - send data asynchronously when true (defaults to true)
+     * @param callBack - if specified, notify caller when send is complete, the channel should return true to indicate to the caller that it will be called.
+     * If the caller doesn't return true the caller should assume that it may never be called.
+     * @param sendReason - specify the reason that you are calling "flush" defaults to ManualFlush (1) if not specified
+     * @returns - true if the callback will be return after the flush is complete otherwise the caller should assume that any provided callback will never be called
+     */
+    flush(isAsync?: boolean, callBack?: (flushComplete?: boolean) => void, sendReason?: SendRequestReason): void;
+    /**
+     * Gets the current distributed trace context for this instance if available
+     * @param createNew - Optional flag to create a new instance if one doesn't currently exist, defaults to true
+     */
+    getTraceCtx(createNew?: boolean): IDistributedTraceContext | null;
+    /**
+     * 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.
+     * @param updateCtx - The plugin update context
+     * @param updateState - The Update State
+     * @returns boolean - True means the extension class will call updateState otherwise the Core will
+     */
+    protected _updateHook?(updateCtx: IProcessTelemetryUpdateContext, updateState: ITelemetryUpdateState): void | boolean;
 }

package/types/JavaScriptSDK/BaseTelemetryPlugin.d.ts

@@ -1,13 +1,13 @@
 import { IAppInsightsCore } from "../JavaScriptSDK.Interfaces/IAppInsightsCore";
 import { IConfiguration } from "../JavaScriptSDK.Interfaces/IConfiguration";
 import { IDiagnosticLogger } from "../JavaScriptSDK.Interfaces/IDiagnosticLogger";
-import { IInstrumentHook } from "../JavaScriptSDK.Interfaces/IInstrumentHooks";
 import { IProcessTelemetryContext, IProcessTelemetryUnloadContext, IProcessTelemetryUpdateContext } from "../JavaScriptSDK.Interfaces/IProcessTelemetryContext";
 import { ITelemetryItem } from "../JavaScriptSDK.Interfaces/ITelemetryItem";
 import { IPlugin, ITelemetryPlugin } from "../JavaScriptSDK.Interfaces/ITelemetryPlugin";
 import { ITelemetryPluginChain } from "../JavaScriptSDK.Interfaces/ITelemetryPluginChain";
 import { ITelemetryUnloadState } from "../JavaScriptSDK.Interfaces/ITelemetryUnloadState";
 import { ITelemetryUpdateState } from "../JavaScriptSDK.Interfaces/ITelemetryUpdateState";
+import { ILegacyUnloadHook, IUnloadHook } from "../JavaScriptSDK.Interfaces/IUnloadHook";
 import { UnloadHandler } from "./UnloadHandlerContainer";
 /**
  * BaseTelemetryPlugin provides a basic implementation of the ITelemetryPlugin interface so that plugins
@@ -99,5 +99,5 @@ 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;
 }

package/types/JavaScriptSDK/CookieMgr.d.ts

@@ -2,16 +2,6 @@ import { IAppInsightsCore } from "../JavaScriptSDK.Interfaces/IAppInsightsCore";
 import { IConfiguration } from "../JavaScriptSDK.Interfaces/IConfiguration";
 import { ICookieMgr } from "../JavaScriptSDK.Interfaces/ICookieMgr";
 import { IDiagnosticLogger } from "../JavaScriptSDK.Interfaces/IDiagnosticLogger";
-/**
- * @ignore
- * DO NOT USE or export from the module, this is exposed as public to support backward compatibility of previous static utility methods only.
- * If you want to manager cookies either use the ICookieMgr available from the core instance via getCookieMgr() or create
- * your own instance of the CookieMgr and use that.
- * Using this directly for enabling / disabling cookie handling will not only affect your usage but EVERY user of cookies.
- * Example, if you are using a shared component that is also using Application Insights you will affect their cookie handling.
- * @param logger - The DiagnosticLogger to use for reporting errors.
- */
-export declare function _gblCookieMgr(config?: IConfiguration, logger?: IDiagnosticLogger): ICookieMgr;
 /**
  * Helper to return the ICookieMgr from the core (if not null/undefined) or a default implementation
  * associated with the configuration or a legacy default.

package/types/JavaScriptSDK/DiagnosticLogger.d.ts

@@ -1,12 +1,13 @@
-import { LoggingSeverity, _InternalMessageId } from "../JavaScriptSDK.Enums/LoggingEnums";
+import { LoggingSeverity, _eInternalMessageId } from "../JavaScriptSDK.Enums/LoggingEnums";
 import { IAppInsightsCore } from "../JavaScriptSDK.Interfaces/IAppInsightsCore";
 import { IConfiguration } from "../JavaScriptSDK.Interfaces/IConfiguration";
 import { IDiagnosticLogger } from "../JavaScriptSDK.Interfaces/IDiagnosticLogger";
+import { ITelemetryUpdateState } from "../JavaScriptSDK.Interfaces/ITelemetryUpdateState";
 export declare 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);
 }
 export declare function safeGetLogger(core: IAppInsightsCore, config?: IConfiguration): IDiagnosticLogger;
 export declare class DiagnosticLogger implements IDiagnosticLogger {
@@ -38,18 +39,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;
+    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;
     /**
@@ -58,10 +59,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;
 }
 /**
  * This is a helper method which will call throwInternal on the passed logger, will throw exceptions in
@@ -69,20 +71,20 @@ export declare class DiagnosticLogger implements IDiagnosticLogger {
  * 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;
+export declare function _throwInternal(logger: IDiagnosticLogger, severity: LoggingSeverity, msgId: _eInternalMessageId, msg: string, properties?: Object, isUserAct?: boolean): void;
 /**
  * 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;
 /**
  * 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;

package/types/JavaScriptSDK/EventHelpers.d.ts

@@ -14,62 +14,62 @@ export declare function __getRegisteredEvents(target: any, eventName?: string, e
 export declare function mergeEvtNamespace(theNamespace: string, namespaces?: string | string[] | null): string | string[];
 /**
  * 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;
 /**
  * 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 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
+ * @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;
 /**
  * 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;
 /**
  * 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
  */
 export declare function addEventHandler(eventName: string, callback: any, evtNamespace?: string | string[] | null): boolean;
 /**
  * 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.
@@ -77,8 +77,8 @@ export declare function addEventHandler(eventName: string, callback: any, evtNam
 export declare function removeEventHandler(eventName: string, callback: any, evtNamespace?: string | string[] | null): void;
 /**
  * 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
@@ -86,8 +86,8 @@ export declare function removeEventHandler(eventName: string, callback: any, evt
 export declare function addEventListeners(events: string[], listener: any, excludeEvents?: string[], evtNamespace?: string | string[]): boolean;
 /**
  * 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;

package/types/JavaScriptSDK/HelperFuncs.d.ts

@@ -1,5 +1,5 @@
-export declare let _getObjProto: any;
-export declare function objToString(obj: any): any;
+import { objForEachKey as objForEachKey21 } from "@nevware21/ts-utils";
+export declare let _getObjProto: (o: any) => any;
 export declare function isNotUndefined<T>(value: T): value is T;
 export declare function isNotNullOrUndefined<T>(value: T): value is T;
 /**
@@ -7,9 +7,16 @@ export declare function isNotNullOrUndefined<T>(value: T): value is T;
  * 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;
+/**
+ * This is a helper function for the equivalent of arForEach(objKeys(target), callbackFn), this is a
+ * performance optimization to avoid the creation of a new array for large objects
+ * @param target - The target object to find and process the keys
+ * @param callbackfn - The function to call with the details
+ */
+export declare const objForEachKey: typeof objForEachKey21;
 /**
  * A simple wrapper (for minification support) to check if the value contains the search string.
  * @param value - The string value to check for the existence of the search value
@@ -24,7 +31,7 @@ export declare function isPlainObject(value: any): boolean;
 /**
  * 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 const deepFreeze: <T>(obj: T) => T;
 /**
  * Return the current time via the Date now() function (if available) and falls back to (new Date()).getTime() if now() is unavailable (IE8 or less)
@@ -53,12 +60,6 @@ export declare function setValue<T, K extends keyof T>(target: T, field: K, valu
  * @param defValue - [Optional] The value to set if not already present, when not provided a empty object will be added
  */
 export declare function getSetValue<T, K extends keyof T>(target: T, field: K, defValue?: T[K]): T[K];
-/**
- * Get the mapped config value, if null or undefined any supplied defaultValue will be returned.
- * @param field - The name of the field as the named enum value (number) or the string name.
- * @param defaultValue - The default value to return if the config field is not present, null or undefined.
- */
-export declare function getCfgValue<V>(theValue: V, defaultValue?: V): V;
 /**
  * Effectively assigns all enumerable properties (not just own properties) and functions (including inherited prototype) from
  * the source object to the target, it attempts to use proxy getters / setters (if possible) and proxy functions to avoid potential
@@ -97,7 +98,7 @@ export declare function proxyFunctions<T, S>(target: T, source: S | (() => S), f
 /**
  * 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;
 /**
@@ -120,3 +121,4 @@ export declare function optimizeObject<T>(theObject: T): T;
  */
 export declare function objExtend<T2, T3, T4, T5, T6>(deepExtend?: boolean, obj2?: T2, obj3?: T3, obj4?: T4, obj5?: T5, obj6?: T6): T2 & T3 & T4 & T5 & T6;
 export declare function objExtend<T1, T2, T3, T4, T5, T6>(obj1?: T1, obj2?: T2, obj3?: T3, obj4?: T4, obj5?: T5, obj6?: T6): T1 & T2 & T3 & T4 & T5 & T6;
+export declare const asString: (value: any) => string;

package/types/JavaScriptSDK/InternalConstants.d.ts

@@ -1,3 +1,4 @@
+export declare const UNDEFINED_VALUE: any;
 export declare const STR_EMPTY = "";
 export declare const STR_CHANNELS = "channels";
 export declare const STR_CORE = "core";
@@ -14,3 +15,6 @@ export declare const STR_PERF_EVENT = "perfEvent";
 export declare const STR_ERROR_TO_CONSOLE = "errorToConsole";
 export declare const STR_WARN_TO_CONSOLE = "warnToConsole";
 export declare const STR_GET_PERF_MGR = "getPerfMgr";
+export declare const STR_DOMAIN = "domain";
+export declare const STR_PATH = "path";
+export declare const STR_NOT_DYNAMIC_ERROR = "Not dynamic - ";

package/types/JavaScriptSDK/NotificationManager.d.ts

@@ -11,30 +11,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;
     /**

package/types/JavaScriptSDK/PerfManager.d.ts

@@ -50,14 +50,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;
     /**

package/types/JavaScriptSDK/ProcessTelemetryContext.d.ts

@@ -1,3 +1,4 @@
+import { IConfigDefaults } from "../Config/IConfigDefaults";
 import { IAppInsightsCore } from "../JavaScriptSDK.Interfaces/IAppInsightsCore";
 import { IConfiguration } from "../JavaScriptSDK.Interfaces/IConfiguration";
 import { IDiagnosticLogger } from "../JavaScriptSDK.Interfaces/IDiagnosticLogger";
@@ -12,7 +13,7 @@ import { ITelemetryPluginChain } from "../JavaScriptSDK.Interfaces/ITelemetryPlu
  * @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;
 /**
  * Creates a new Telemetry Item context with the current config, core and plugin execution chain for handling the unloading of the chain
  * @param plugins - The plugin instances that will be executed
@@ -58,7 +59,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

package/types/JavaScriptSDK/TelemetryHelpers.d.ts

@@ -14,9 +14,9 @@ export declare function _getPluginState(plugin: IPlugin): IPluginState;
 /**
  * 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;
 export declare function sortPlugins<T = IPlugin>(plugins: T[]): T[];

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

@@ -1,4 +1,8 @@
 export declare const enum eLoggingSeverity {
+    /**
+     * No Logging will be enabled
+     */
+    DISABLED = 0,
     /**
      * Error will be sent as internal telemetry
      */
@@ -93,10 +97,8 @@ export declare const enum _eInternalMessageId {
     TrackPageActionEventFailed = 103,
     FailedAddingCustomDefinedRequestContext = 104,
     InMemoryStorageBufferFull = 105,
-    InstrumentationKeyDeprecation = 106
+    InstrumentationKeyDeprecation = 106,
+    ConfigWatcherException = 107,
+    DynamicConfigException = 108
 }
-/**
- * Internal message ID. Please create a new one for every conceptually different message. Please keep alphabetically ordered
- */
-export declare const _InternalMessageId: import("../JavaScriptSDK.Enums/EnumHelperFuncs").EnumValue<typeof _eInternalMessageId>;
 export declare type _InternalMessageId = number | _eInternalMessageId;

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

@@ -9,6 +9,7 @@ export declare const enum TelemetryUpdateReason {
     /**
      * The configuration has ben updated or changed
      */
+    ConfigurationChanged = 1,
     /**
      * One or more plugins have been added
      */