@microsoft/applicationinsights-core-js 3.0.0-beta.2303-11 → 3.0.0-beta.2304-07

package/types/Config/IDynamicConfigHandler.d.ts

@@ -1,69 +0,0 @@
-import { IConfiguration } from "../JavaScriptSDK.Interfaces/IConfiguration";
-import { IDiagnosticLogger } from "../JavaScriptSDK.Interfaces/IDiagnosticLogger";
-import { IConfigDefaults } from "./IConfigDefaults";
-import { IWatcherHandler, WatcherFunction } from "./IDynamicWatcher";
-/**
- * This interface identifies the config which can track changes
- */
-export 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;
-    /**
-     * Set default values for the config if not present.
-     * @param theConfig - The configuration object to set default on (if missing)
-     * @param defaultValues - The default values to apply to the config
-     */
-    setDf: <C>(theConfig: C, defaultValues: IConfigDefaults<C, T>) => C;
-    /**
-     * Set this named property of the target as referenced, which will cause any object or array instances
-     * to be updated in-place rather than being entirely replaced. All other values will continue to be replaced.
-     * @returns The referenced properties current value
-     */
-    ref: <C, V = any>(target: C, name: string) => V;
-    /**
-     * Set this named property of the target as read-only, which will block this single named property from
-     * ever being changed for the target instance.
-     * This does NOT freeze or seal the instance, it just stops the direct re-assignment of the named property,
-     * if the value is a non-primitive (ie. an object or array) it's properties will still be mutable.
-     * @returns The referenced properties current value
-     */
-    rdOnly: <C, V = any>(target: C, name: string) => V;
-}
-/**
- * @internal
- * @ignore
- */
-export interface _IInternalDynamicConfigHandler<T extends IConfiguration> extends IDynamicConfigHandler<T> {
-    /**
-     * @ignore
-     * Internal function to explicitly block watching for any config updates
-     * @param configHandler - The Callback function to call after blocking update listening
-     * @param allowUpdate - An optional flag to enable updating config properties marked as readonly
-     */
-    _block: (configHandler: WatcherFunction<T>, allowUpdate?: boolean) => void;
-}

package/types/Config/IDynamicPropertyHandler.d.ts

@@ -1,11 +0,0 @@
-import { IWatcherHandler } from "./IDynamicWatcher";
-export 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>[];
-}

package/types/Config/IDynamicWatcher.d.ts

@@ -1,61 +0,0 @@
-import { IConfiguration } from "../JavaScriptSDK.Interfaces/IConfiguration";
-import { IUnloadHook } from "../JavaScriptSDK.Interfaces/IUnloadHook";
-import { IConfigDefaults } from "./IConfigDefaults";
-import { IDynamicPropertyHandler } from "./IDynamicPropertyHandler";
-export interface IWatchDetails<T extends IConfiguration> {
-    /**
-     * The current config object
-     */
-    cfg: 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;
-    /**
-     * Set default values for the config if not present.
-     * @param theConfig - The configuration object to set default on (if missing)
-     * @param defaultValues - The default values to apply to the config
-     */
-    setDf: <C>(theConfig: C, defaultValues: IConfigDefaults<C>) => C;
-    /**
-     * Set this named property of the target as referenced, which will cause any object or array instance
-     * to be updated in-place rather than being entirely replaced. All other values will continue to be replaced.
-     * @returns The referenced properties current value
-     */
-    ref: <C, V = any>(target: C, name: string) => V;
-    /**
-     * Set this named property of the target as read-only, which will block this single named property from
-     * ever being changed for the target instance.
-     * This does NOT freeze or seal the instance, it just stops the direct re-assignment of the named property,
-     * if the value is a non-primitive (ie. an object or array) it's properties will still be mutable.
-     * @returns The referenced properties current value
-     */
-    rdOnly: <C, V = any>(target: C, name: string) => V;
-}
-export type WatcherFunction<T extends IConfiguration> = (details: IWatchDetails<T>) => void;
-/**
- * @internal
- */
-export interface _WatcherChangeDetails<T extends IConfiguration> {
-    d: _IDynamicDetail<T>;
-}
-/**
- * @internal
- */
-export interface _IDynamicDetail<T extends IConfiguration> extends IDynamicPropertyHandler<T> {
-    /**
-     * Add the watcher for monitoring changes
-     */
-    trk: (handler: IWatcherHandler<T>) => void;
-    /**
-     * Clear all of the watchers from monitoring changes
-     */
-    clr: (handler: IWatcherHandler<T>) => void;
-}
-export interface IWatcherHandler<T extends IConfiguration> extends IUnloadHook {
-    fn: WatcherFunction<T>;
-    rm: () => void;
-}

package/types/Config/_IDynamicConfigHandlerState.d.ts

@@ -1,52 +0,0 @@
-import { IDynamicConfigHandler } from "./IDynamicConfigHandler";
-import { IDynamicPropertyHandler } from "./IDynamicPropertyHandler";
-import { IWatcherHandler, WatcherFunction, _IDynamicDetail } from "./IDynamicWatcher";
-/**
- * @internal
- * Interface for internal communication to notifying state changes
- */
-export interface _IDynamicGetter {
-    /**
-     * Cause any listeners of this property to be notified that the value has changed.
-     * Primarily used to ensure that listeners of child properties of an object that is getting replaced
-     * will be notified.
-     */
-    chng: () => void;
-}
-/**
- * @internal
- * Interface for the global dynamic config handler
- */
-export interface _IDynamicConfigHandlerState<T> {
-    prop: symbol;
-    ro: symbol;
-    rf: symbol;
-    /**
-     * Link to the handler
-     */
-    hdlr: IDynamicConfigHandler<T>;
-    /**
-     * Identifies the current active handler
-     */
-    act?: IWatcherHandler<T>;
-    /**
-     * Enable / Disable updates to dynamic readonly properties
-     */
-    upd?: boolean;
-    /**
-     * Helper to call any listeners that are waiting to be notified
-     */
-    notify: () => void;
-    /**
-     * Add this property handler to the collection to be notified
-     */
-    add: (handler: IDynamicPropertyHandler<T>) => void;
-    /**
-     * Add this handler as a handler for
-     */
-    trk: (handler: IWatcherHandler<T>, detail: _IDynamicDetail<T>) => void;
-    /**
-     * Use the provided handler to listen for changes
-     */
-    use: (activeHandler: IWatcherHandler<T>, callback: WatcherFunction<T>) => void;
-}

package/types/JavaScriptSDK/AggregationError.d.ts

@@ -1,6 +0,0 @@
-/**
- * Throws an Aggregation Error which includes all of the errors that led to this error occurring
- * @param message - The message describing the aggregation error (the sourceError details are added to this)
- * @param sourceErrors - An array of the errors that caused this situation
- */
-export declare function throwAggregationError(message: string, sourceErrors: any[]): never;

package/types/JavaScriptSDK/AppInsightsCore.d.ts

@@ -1,158 +0,0 @@
-import { ITimerHandler } from "@nevware21/ts-utils";
-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, 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<CfgType extends IConfiguration = IConfiguration> implements IAppInsightsCore<CfgType> {
-    config: CfgType;
-    logger: IDiagnosticLogger;
-    /**
-     * An array of the installed plugins that provide a version
-     */
-    readonly pluginVersionStringArr: string[];
-    /**
-     * The formatted string of the installed plugins that contain a version number
-     */
-    readonly pluginVersionString: string;
-    /**
-     * Returns a value that indicates whether the instance has already been previously initialized.
-     */
-    isInitialized: () => boolean;
-    /**
-     * Function used to identify the get w parameter used to identify status bit to some channels
-     */
-    getWParam: () => number;
-    constructor();
-    initialize(config: CfgType, extensions: IPlugin[], logger?: IDiagnosticLogger, notificationManager?: INotificationManager): void;
-    getChannels(): 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): ITimerHandler;
-    /**
-     * 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(newConfig: CfgType, 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(handler: WatcherFunction<CfgType>): 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,110 +0,0 @@
-import { IAppInsightsCore } from "../JavaScriptSDK.Interfaces/IAppInsightsCore";
-import { IConfiguration } from "../JavaScriptSDK.Interfaces/IConfiguration";
-import { IDiagnosticLogger } from "../JavaScriptSDK.Interfaces/IDiagnosticLogger";
-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";
-import { IUnloadHookContainer } from "./UnloadHookContainer";
-/**
- * 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
- * implementation so that new default implementations can be added without breaking all plugins.
- */
-export declare abstract class BaseTelemetryPlugin implements ITelemetryPlugin {
-    identifier: string;
-    version?: string;
-    /**
-     * Holds the core instance that was used during initialization
-     */
-    core: IAppInsightsCore;
-    priority: number;
-    /**
-     * Call back for telemetry processing before it it is sent
-     * @param env - This is the current event being reported
-     * @param itemCtx - This is the context for the current request, ITelemetryPlugin instances
-     * can optionally use this to access the current core instance or define / pass additional information
-     * to later plugins (vs appending items to the telemetry item)
-     */
-    processNext: (env: ITelemetryItem, itemCtx: IProcessTelemetryContext) => void;
-    /**
-     * Set next extension for telemetry processing
-     */
-    setNextPlugin: (next: ITelemetryPlugin | ITelemetryPluginChain) => void;
-    /**
-     * Returns the current diagnostic logger that can be used to log issues, if no logger is currently
-     * assigned a new default one will be created and returned.
-     */
-    diagLog: (itemCtx?: IProcessTelemetryContext) => IDiagnosticLogger;
-    /**
-     * Returns whether the plugin has been initialized
-     */
-    isInitialized: () => boolean;
-    /**
-     * Helper to return the current IProcessTelemetryContext, if the passed argument exists this just
-     * returns that value (helps with minification for callers), otherwise it will return the configured
-     * context or a temporary one.
-     * @param currentCtx - [Optional] The current execution context
-     */
-    protected _getTelCtx: (currentCtx?: IProcessTelemetryContext) => IProcessTelemetryContext;
-    /**
-     * Internal helper to allow setting of the internal initialized setting for inherited instances and unit testing
-     */
-    protected setInitialized: (isInitialized: boolean) => void;
-    /**
-     * Teardown / Unload hook to allow implementations to perform some additional unload operations before the BaseTelemetryPlugin
-     * finishes it's removal.
-     * @param unloadCtx - This is the context that should be used during unloading.
-     * @param unloadState - The details / state of the unload process, it holds details like whether it should be unloaded synchronously or asynchronously and the reason for the unload.
-     * @param asyncCallback - An optional callback that the plugin must call if it returns true to inform the caller that it has completed any async unload/teardown operations.
-     * @returns boolean - true if the plugin has or will call asyncCallback, this allows the plugin to perform any asynchronous operations.
-     */
-    protected _doTeardown?: (unloadCtx?: IProcessTelemetryUnloadContext, unloadState?: ITelemetryUnloadState, asyncCallback?: () => void) => void | boolean;
-    /**
-     * Extension hook to allow implementations to perform some additional update operations before the BaseTelemetryPlugin finishes it's removal
-     * @param updateCtx - This is the context that should be used during updating.
-     * @param updateState - The details / state of the update process, it holds details like the current and previous configuration.
-     * @param asyncCallback - An optional callback that the plugin must call if it returns true to inform the caller that it has completed any async update operations.
-     * @returns boolean - true if the plugin has or will call asyncCallback, this allows the plugin to perform any asynchronous operations.
-     */
-    protected _doUpdate?: (updateCtx?: IProcessTelemetryUpdateContext, updateState?: ITelemetryUpdateState, asyncCallback?: () => void) => void | boolean;
-    /**
-     * Exposes the underlying unload hook container instance for this extension to allow it to be passed down to any sub components of the class.
-     * This should NEVER be exposed or called publically as it's scope is for internal use by BaseTelemetryPlugin and any derived class (which is why
-     * it's scoped as protected)
-     */
-    protected readonly _unloadHooks: IUnloadHookContainer;
-    constructor();
-    initialize(config: IConfiguration, core: IAppInsightsCore, extensions: IPlugin[], pluginChain?: ITelemetryPluginChain): void;
-    /**
-     * Tear down the plugin and remove any hooked value, the plugin should be removed so that it is no longer initialized and
-     * therefore could be re-initialized after being torn down. The plugin should ensure that once this has been called any further
-     * processTelemetry calls are ignored and it just calls the processNext() with the provided context.
-     * @param unloadCtx - This is the context that should be used during unloading.
-     * @param unloadState - The details / state of the unload process, it holds details like whether it should be unloaded synchronously or asynchronously and the reason for the unload.
-     * @returns boolean - true if the plugin has or will call processNext(), this for backward compatibility as previously teardown was synchronous and returned nothing.
-     */
-    teardown(unloadCtx?: IProcessTelemetryUnloadContext, unloadState?: ITelemetryUnloadState): void | boolean;
-    abstract processTelemetry(env: ITelemetryItem, itemCtx?: IProcessTelemetryContext): void;
-    /**
-     * The the plugin should re-evaluate configuration and update any cached configuration settings.
-     * @param updateCtx - This is the context that should be used during updating.
-     * @param updateState - The details / state of the update process, it holds details like the current and previous configuration.
-     * @returns boolean - true if the plugin has or will call updateCtx.processNext(), this allows the plugin to perform any asynchronous operations.
-     */
-    update(updateCtx: IProcessTelemetryUpdateContext, updateState: ITelemetryUpdateState): void | boolean;
-    /**
-     * Add an unload handler that will be called when the SDK is being unloaded
-     * @param handler - the handler
-     */
-    protected _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
-     */
-    protected _addHook(hooks: IUnloadHook | IUnloadHook[] | Iterator<IUnloadHook> | ILegacyUnloadHook | ILegacyUnloadHook[] | Iterator<ILegacyUnloadHook>): void;
-}

package/types/JavaScriptSDK/Constants.d.ts

@@ -1 +0,0 @@
-export declare const ChannelControllerPriority = 500;

package/types/JavaScriptSDK/CookieMgr.d.ts

@@ -1,15 +0,0 @@
-import { IAppInsightsCore } from "../JavaScriptSDK.Interfaces/IAppInsightsCore";
-import { IConfiguration } from "../JavaScriptSDK.Interfaces/IConfiguration";
-import { ICookieMgr } from "../JavaScriptSDK.Interfaces/ICookieMgr";
-import { IDiagnosticLogger } from "../JavaScriptSDK.Interfaces/IDiagnosticLogger";
-/**
- * Helper to return the ICookieMgr from the core (if not null/undefined) or a default implementation
- * associated with the configuration or a legacy default.
- * @param core
- * @param config
- * @returns
- */
-export declare function safeGetCookieMgr(core: IAppInsightsCore, config?: IConfiguration): ICookieMgr;
-export declare function createCookieMgr(rootConfig?: IConfiguration, logger?: IDiagnosticLogger): ICookieMgr;
-export declare function areCookiesSupported(logger?: IDiagnosticLogger): any;
-export declare function uaDisallowsSameSiteNone(userAgent: string): boolean;

package/types/JavaScriptSDK/CoreUtils.d.ts

@@ -1,13 +0,0 @@
-export declare const Undefined = "undefined";
-export declare function newGuid(): string;
-/**
- * The strEndsWith() method determines whether a string ends with the characters of a specified string, returning true or false as appropriate.
- * @param value - The value to check whether it ends with the search value.
- * @param search - The characters to be searched for at the end of the value.
- * @returns true if the given search value is found at the end of the string, otherwise false.
- */
-export declare function strEndsWith(value: string, search: string): boolean;
-/**
- * generate W3C trace id
- */
-export declare function generateW3CId(): string;

package/types/JavaScriptSDK/DataCacheHelper.d.ts

@@ -1,13 +0,0 @@
-export interface IDataCache {
-    id: string;
-    accept: (target: any) => boolean;
-    get: <T>(target: any, name: string, defValue?: T, addDefault?: boolean) => T;
-    kill: (target: any, name: string) => void;
-}
-export declare function createUniqueNamespace(name: string, includeVersion?: boolean): string;
-export declare function createElmNodeData(name?: string): {
-    id: string;
-    accept: (target: any) => boolean;
-    get: <T>(target: any, name: string, defValue?: T, addDefault?: boolean) => T;
-    kill: (target: any, name: string) => void;
-};

package/types/JavaScriptSDK/DbgExtensionUtils.d.ts

@@ -1,5 +0,0 @@
-import { IConfiguration } from "../JavaScriptSDK.Interfaces/IConfiguration";
-import { IDbgExtension } from "../JavaScriptSDK.Interfaces/IDbgExtension";
-import { INotificationListener } from "../JavaScriptSDK.Interfaces/INotificationListener";
-export declare function getDebugExt(config: IConfiguration): IDbgExtension;
-export declare function getDebugListener(config: IConfiguration): INotificationListener;

package/types/JavaScriptSDK/DiagnosticLogger.d.ts

@@ -1,76 +0,0 @@
-import { LoggingSeverity, _InternalMessageId } 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);
-}
-export declare function safeGetLogger(core: IAppInsightsCore, config?: IConfiguration): IDiagnosticLogger;
-export declare class DiagnosticLogger implements IDiagnosticLogger {
-    identifier: string;
-    /**
-     * The internal logging queue
-     */
-    queue: _InternalLogMessage[];
-    constructor(config?: IConfiguration);
-    /**
-     * 0: OFF (default)
-     * 1: CRITICAL
-     * 2: >= WARNING
-     */
-    consoleLoggingLevel(): 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.
-     */
-    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
-     */
-    warnToConsole(message: string): void;
-    /**
-     * This will write an error to the console if possible
-     * @param message - {string} - The warning message
-     */
-    errorToConsole(message: string): void;
-    /**
-     * Resets the internal message count
-     */
-    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.
-     */
-    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
- * debug mode or attempt to log the error as a console warning. This helper is provided mostly to better
- * 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.
- */
-export declare function _throwInternal(logger: IDiagnosticLogger, severity: LoggingSeverity, msgId: _InternalMessageId, 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.
- */
-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.
- */
-export declare function _logInternalMessage(logger: IDiagnosticLogger, severity: LoggingSeverity, message: _InternalLogMessage): void;