@microsoft/applicationinsights-core-js 2.7.5-nightly.2203-03 → 2.7.5

package/src/JavaScriptSDK.Interfaces/IAppInsightsCore.ts

@@ -2,7 +2,7 @@
 // Licensed under the MIT License.
 import { ITelemetryItem } from "./ITelemetryItem";
 import { IChannelControls } from "./IChannelControls";
-import { IPlugin, ITelemetryPlugin } from "./ITelemetryPlugin";
+import { IPlugin } from "./ITelemetryPlugin";
 import { IConfiguration } from "./IConfiguration";
 import { INotificationManager } from "./INotificationManager";
 import { INotificationListener } from "./INotificationListener";
@@ -10,31 +10,8 @@ import { IDiagnosticLogger } from "./IDiagnosticLogger";
 import { IProcessTelemetryContext } from "./IProcessTelemetryContext";
 import { IPerfManagerProvider } from "./IPerfManager";
 import { ICookieMgr } from "./ICookieMgr";
-import { ITelemetryInitializerHandler, TelemetryInitializerFunction } from "./ITelemetryInitializers";
-import { ITelemetryUnloadState } from "./ITelemetryUnloadState";
-import { UnloadHandler } from "../JavaScriptSDK/UnloadHandlerContainer";
-import { SendRequestReason } from "../JavaScriptSDK.Enums/SendRequestReason";
 
-export interface ILoadedPlugin<T extends IPlugin> {
-    plugin: T;
-
-    /**
-     * Identifies whether the plugin is enabled and can process events. This is slightly different from isInitialized as the plugin may be initialized but disabled
-     * via the setEnabled() or it may be a shared plugin which has had it's teardown function called from another instance..
-     * @returns boolean = true if the plugin is in a state where it is operational.
-     */
-    isEnabled: () => boolean;
-
-    /**
-     * You can optionally enable / disable a plugin from processing events.
-     * Setting enabled to true will not necessarily cause the `isEnabled()` to also return true
-     * as the plugin must also have been successfully initialized and not had it's `teardown` method called
-     * (unless it's also been re-initialized)
-     */
-    setEnabled: (isEnabled: boolean) => void;
-
-    remove: (isAsync?: boolean, removeCb?: (removed?: boolean) => void) => void;
-}
+"use strict";
 
 export interface IAppInsightsCore extends IPerfManagerProvider {
 
@@ -95,13 +72,6 @@ export interface IAppInsightsCore extends IPerfManagerProvider {
      */
     removeNotificationListener?(listener: INotificationListener): 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 | void;
-
     pollInternalLogs?(eventName?: string): number;
 
     stopPollingInternalLogs?(): void;
@@ -110,54 +80,4 @@ export interface IAppInsightsCore extends IPerfManagerProvider {
      * Return a new instance of the IProcessTelemetryContext for processing events
      */
     getProcessTelContext() : IProcessTelemetryContext;
-
-    /**
-     * 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;
-
-    /**
-     * Find and return the (first) plugin with the specified identifier if present
-     * @param pluginIdentifier
-     */
-    getPlugin<T extends IPlugin = IPlugin>(pluginIdentifier: string): ILoadedPlugin<T>;
-  
-    /**
-     * Add a new plugin to the installation
-     * @param plugin - The new plugin to add
-     * @param replaceExisting - should any existing plugin be replaced, 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;
-  
-    /**
-     * Returns the unique event namespace that should be used when registering events
-     */
-    evtNamespace(): string;
-  
-    /**
-     * Add a 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
-     * @param cbTimeout - An optional timeout to wait for any flush operations to complete before proceeding with the unload. Defaults to 5 seconds.
-     * @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, cbTimeout?: number): boolean | void;
 }

package/src/JavaScriptSDK.Interfaces/IChannelControls.ts

@@ -1,9 +1,6 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
-import { SendRequestReason } from "../JavaScriptSDK.Enums/SendRequestReason";
-import { IProcessTelemetryUnloadContext } from "./IProcessTelemetryContext";
 import { ITelemetryPlugin } from "./ITelemetryPlugin";
-import { ITelemetryUnloadState } from "./ITelemetryUnloadState";
 
 "use strict";
 
@@ -23,24 +20,16 @@ export interface IChannelControls extends ITelemetryPlugin {
     resume(): 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.
+     * Tear down transmission pipeline
      */
-    teardown: (unloadCtx?: IProcessTelemetryUnloadContext, unloadState?: ITelemetryUnloadState) => void | boolean;
+    teardown(): void;
 
     /**
      * Flush to send data immediately; channel should default to sending data asynchronously
-     * @param async - send data asynchronously when 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
+     * @param async: send data asynchronously when true
+     * @param callBack: if specified, notify caller when send is complete
      */
-    flush(async: boolean, callBack?: (flushComplete?: boolean) => void, sendReason?: SendRequestReason): boolean | void;
+    flush(async: boolean, callBack?: () => void): void;
 }
 
 export const MinChannelPriorty: number = 100;

package/src/JavaScriptSDK.Interfaces/IInstrumentHooks.ts

@@ -12,11 +12,6 @@ export type InstrumentorHooksCallback = (funcArgs:IInstrumentCallDetails, ...org
  * You must always supply the error callback
  */
 export interface IInstrumentHooksCallbacks {
-    /**
-     * [Optional] Namespace details (same as the namespace used for events), useful for debugging and testing to
-     * identify the source of the instrumented hooks
-     */
-    ns?: string | string[];
 
     /**
      * The hook callback to call before the original function is called
@@ -45,20 +40,20 @@ export interface IInstrumentHooksCallbacks {
  */
 export interface IInstrumentHook {
     /** Unique Id for this callback on the hooked method */
-    id: number;
+    id:number;
 
     /** Holds the callbacks */
-    cbks: IInstrumentHooksCallbacks;
+    cbks:IInstrumentHooksCallbacks;
 
     /** Remove this hook from the function */
     rm: () => void;
 }
 
 export interface IInstrumentHooks {
-    i: number;               // Used to create unique ids
-    n: string;               // Function name
-    f: any;                  // Original Function
-    h: IInstrumentHook[];    // The hook
+    i:number;               // Used to create unique ids
+    n:string;               // Function name
+    f:any;                  // Original Function
+    h:IInstrumentHook[];    // The hook
 }
 
 export interface IInstrumentCallDetails {
@@ -90,9 +85,4 @@ export interface IInstrumentCallDetails {
      * The error (exception) which occurred while executing the original method
      */
     err?: Error;
-
-    /**
-     * The Event object from (window.event) at the start of the original call
-     */
-    evt?: Event;
 }

package/src/JavaScriptSDK.Interfaces/IProcessTelemetryContext.ts

@@ -3,21 +3,17 @@
 "use strict";
 
 import { IAppInsightsCore } from "./IAppInsightsCore";
-import { IConfiguration } from "./IConfiguration";
 import { IDiagnosticLogger } from "./IDiagnosticLogger";
+import { IConfiguration } from "./IConfiguration";
 import { ITelemetryItem } from "./ITelemetryItem";
-import { IPlugin, ITelemetryPlugin } from "./ITelemetryPlugin";
+import { IPlugin } from "./ITelemetryPlugin";
 import { ITelemetryPluginChain } from "./ITelemetryPluginChain";
-import { ITelemetryUnloadState } from "./ITelemetryUnloadState";
-import { ITelemetryUpdateState } from "./ITelemetryUpdateState";
-
-export const enum GetExtCfgMergeType {
-    None = 0,
-    MergeDefaultOnly = 1,
-    MergeDefaultFromRootOrDefault = 2,
-}
 
-export interface IBaseProcessingContext {
+/**
+ * The current context for the current call to processTelemetry(), used to support sharing the same plugin instance
+ * between multiple AppInsights instances
+ */
+export interface IProcessTelemetryContext {
     /**
      * The current core instance for the request
      */
@@ -31,12 +27,12 @@ export interface IBaseProcessingContext {
     /**
      * Gets the current core config instance
      */
-    getCfg: () => IConfiguration;
+    getCfg: ()=> IConfiguration;
 
     /**
      * Gets the named extension config
      */
-    getExtCfg: <T>(identifier: string, defaultValue?: T | any, mergeDefault?: GetExtCfgMergeType) => T;
+    getExtCfg: <T>(identifier: string, defaultValue?:T|any) => T;
 
     /**
      * Gets the named config from either the named identifier extension or core config if neither exist then the
@@ -45,7 +41,7 @@ export interface IBaseProcessingContext {
      * @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;
+    getConfig: (identifier: string, field: string, defaultValue?: number | string | boolean) => number | string | boolean;
 
     /**
      * Helper to allow plugins to check and possibly shortcut executing code only
@@ -61,96 +57,20 @@ export interface IBaseProcessingContext {
     /**
      * Helper to set the next plugin proxy
      */
-    setNext: (nextCtx: ITelemetryPluginChain) => void;
-
-    /**
-     * Synchronously iterate over the context chain running the callback for each plugin, once
-     * every plugin has been executed via the callback, any associated onComplete will be called.
-     * @param callback - The function call for each plugin in the context chain
-     */
-    iterate: <T extends ITelemetryPlugin = ITelemetryPlugin>(callback: (plugin: T) => void) => void;
-
-    /**
-     * Set the function to call when the current chain has executed all processNext or unloadNext items.
-     * @param onComplete - The onComplete to call
-     * @param that - The "this" value to use for the onComplete call, if not provided or undefined defaults to the current context
-     * @param args - Any additional arguments to pass to the onComplete function
-     */
-    onComplete: (onComplete: () => void, that?: any, ...args: any[]) => void;
+    setNext: (nextCtx:ITelemetryPluginChain) => void;
 
-    /**
-     * Create a new context using the core and config from the current instance, returns a new instance of the same type
-     * @param plugins - The execution order to process the plugins, if null or not supplied
-     *                  then the current execution order will be copied.
-     * @param startAt - The plugin to start processing from, if missing from the execution
-     *                  order then the next plugin will be NOT set.
-     */
-    createNew: (plugins?: IPlugin[] | ITelemetryPluginChain, startAt?: IPlugin) => IBaseProcessingContext;
-}
-
-/**
- * The current context for the current call to processTelemetry(), used to support sharing the same plugin instance
- * between multiple AppInsights instances
- */
-export interface IProcessTelemetryContext extends IBaseProcessingContext {
     /**
      * Call back for telemetry processing before it it is sent
      * @param env - This is the current event being reported
-     * @returns boolean (true) if there is no more plugins to process otherwise false or undefined (void)
-     */
-    processNext: (env: ITelemetryItem) => boolean | void;
-
-    /**
-     * Create a new context using the core and config from the current instance, returns a new instance of the same type
-     * @param plugins - The execution order to process the plugins, if null or not supplied
-     *                  then the current execution order will be copied.
-     * @param startAt - The plugin to start processing from, if missing from the execution
-     *                  order then the next plugin will be NOT set.
-     */
-     createNew: (plugins?: IPlugin[] | ITelemetryPluginChain, startAt?: IPlugin) => IProcessTelemetryContext;
-}
-
-/**
- * The current context for the current call to teardown() implementations, used to support when plugins are being removed
- * or the SDK is being unloaded.
- */
-export interface IProcessTelemetryUnloadContext extends IBaseProcessingContext {
-
-    /**
-     * This Plugin has finished unloading, so unload the next one
-     * @param uploadState - The state of the unload process
-     * @returns boolean (true) if there is no more plugins to process otherwise false or undefined (void)
-     */
-    processNext: (unloadState: ITelemetryUnloadState) => boolean | void;
-
-    /**
-     * Create a new context using the core and config from the current instance, returns a new instance of the same type
-     * @param plugins - The execution order to process the plugins, if null or not supplied
-     *                  then the current execution order will be copied.
-     * @param startAt - The plugin to start processing from, if missing from the execution
-     *                  order then the next plugin will be NOT set.
-     */
-     createNew: (plugins?: IPlugin[] | ITelemetryPluginChain, startAt?: IPlugin) => IProcessTelemetryUnloadContext;
-}
-
-/**
- * The current context for the current call to the plugin update() implementations, used to support the notifications
- * for when plugins are added, removed or the configuration was changed.
- */
-export interface IProcessTelemetryUpdateContext extends IBaseProcessingContext {
-    /**
-     * This Plugin has finished unloading, so unload the next one
-     * @param updateState - The update State
-     * @returns boolean (true) if there is no more plugins to process otherwise false or undefined (void)
      */
-    processNext: (updateState: ITelemetryUpdateState) => boolean | void;
+    processNext: (env: ITelemetryItem) => void;
 
     /**
-     * Create a new context using the core and config from the current instance, returns a new instance of the same type
+     * Create a new context using the core and config from the current instance
      * @param plugins - The execution order to process the plugins, if null or not supplied
      *                  then the current execution order will be copied.
      * @param startAt - The plugin to start processing from, if missing from the execution
      *                  order then the next plugin will be NOT set.
      */
-     createNew: (plugins?: IPlugin[] | ITelemetryPluginChain, startAt?: IPlugin) => IProcessTelemetryUpdateContext;
+    createNew: (plugins?:IPlugin[]|ITelemetryPluginChain, startAt?:IPlugin) => IProcessTelemetryContext;
 }

package/src/JavaScriptSDK.Interfaces/ITelemetryPlugin.ts

@@ -5,12 +5,13 @@
 import { ITelemetryItem } from "./ITelemetryItem";
 import { IConfiguration } from "./IConfiguration";
 import { IAppInsightsCore } from "./IAppInsightsCore";
-import { IProcessTelemetryContext, IProcessTelemetryUnloadContext, IProcessTelemetryUpdateContext } from "./IProcessTelemetryContext";
+import { IProcessTelemetryContext } from "./IProcessTelemetryContext";
 import { ITelemetryPluginChain } from "./ITelemetryPluginChain";
-import { ITelemetryUnloadState } from "./ITelemetryUnloadState";
-import { ITelemetryUpdateState } from "./ITelemetryUpdateState";
 
-export interface ITelemetryProcessor {
+/**
+ * Configuration provided to SDK core
+ */
+export interface ITelemetryPlugin extends IPlugin {
     /**
      * Call back for telemetry processing before it it is sent
      * @param env - This is the current event being reported
@@ -19,22 +20,7 @@ export interface ITelemetryProcessor {
      * to later plugins (vs appending items to the telemetry item)
      */
     processTelemetry: (env: ITelemetryItem, itemCtx?: IProcessTelemetryContext) => void;
-   
-    /**
-     * The the plugin should re-evaluate configuration and update any cached configuration settings or
-     * plugins. If implemented this method will be called whenever a plugin is added or removed and if
-     * the configuration has bee updated.
-     * @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;
-}
-
-/**
- * Configuration provided to SDK core
- */
-export interface ITelemetryPlugin extends ITelemetryProcessor, IPlugin {
+    
     /**
      * Set next extension for telemetry processing, this is not optional as plugins should use the
      * processNext() function of the passed IProcessTelemetryContext instead. It is being kept for
@@ -57,7 +43,7 @@ export interface IPlugin {
      * @param pluginChain - [Optional] specifies the current plugin chain which identifies the
      * set of plugins and the order they should be executed for the current request.
      */
-    initialize: (config: IConfiguration, core: IAppInsightsCore, extensions: IPlugin[], pluginChain?: ITelemetryPluginChain) => void;
+    initialize: (config: IConfiguration, core: IAppInsightsCore, extensions: IPlugin[], pluginChain?:ITelemetryPluginChain) => void;
     
     /**
      * Returns a value that indicates whether the plugin has already been previously initialized.
@@ -66,14 +52,10 @@ export interface IPlugin {
     isInitialized?: () => boolean;
 
     /**
-     * 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.
+     * Tear down the plugin and remove any hooked value, the plugin should remove that it is no longer initialized and
+     * therefore can be re-initialized after being torn down.
      */
-    teardown?: (unloadCtx: IProcessTelemetryUnloadContext, unloadState?: ITelemetryUnloadState) => void | boolean;
+    teardown?: () => void;
 
     /**
      * Extension name

package/src/JavaScriptSDK.Interfaces/ITelemetryPluginChain.ts

@@ -1,14 +1,15 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
+"use strict";
 
-import { IProcessTelemetryUnloadContext } from "./IProcessTelemetryContext";
-import { ITelemetryPlugin, ITelemetryProcessor } from "./ITelemetryPlugin";
-import { ITelemetryUnloadState } from "./ITelemetryUnloadState";
+import { ITelemetryItem } from "./ITelemetryItem";
+import { IProcessTelemetryContext } from "./IProcessTelemetryContext";
+import { ITelemetryPlugin } from "./ITelemetryPlugin";
 
 /**
  * Configuration provided to SDK core
  */
-export interface ITelemetryPluginChain extends ITelemetryProcessor {
+export interface ITelemetryPluginChain {
 
     /**
      * Returns the underlying plugin that is being proxied for the processTelemetry call
@@ -21,10 +22,11 @@ export interface ITelemetryPluginChain extends ITelemetryProcessor {
     getNext: () => ITelemetryPluginChain;
 
     /**
-     * This plugin is being unloaded and should remove any hooked events and cleanup any global/scoped values, after this
-     * call the plugin will be removed from the telemetry processing chain and will no longer receive any events..
-     * @param unloadCtx - The unload context to use for this call.
-     * @param unloadState - The details of the unload operation
+     * 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)
      */
-    unload?: (unloadCtx: IProcessTelemetryUnloadContext, unloadState: ITelemetryUnloadState) => void;
+    processTelemetry: (env: ITelemetryItem, itemCtx:IProcessTelemetryContext) => void;
 }

package/types/JavaScriptSDK/AppInsightsCore.d.ts

@@ -3,10 +3,31 @@ import { BaseCore } from "./BaseCore";
 import { IConfiguration } from "../JavaScriptSDK.Interfaces/IConfiguration";
 import { IPlugin } from "../JavaScriptSDK.Interfaces/ITelemetryPlugin";
 import { ITelemetryItem } from "../JavaScriptSDK.Interfaces/ITelemetryItem";
+import { INotificationListener } from "../JavaScriptSDK.Interfaces/INotificationListener";
 import { INotificationManager } from "../JavaScriptSDK.Interfaces/INotificationManager";
 import { IDiagnosticLogger } from "../JavaScriptSDK.Interfaces/IDiagnosticLogger";
 export declare class AppInsightsCore extends BaseCore implements IAppInsightsCore {
     constructor();
     initialize(config: IConfiguration, extensions: IPlugin[], logger?: IDiagnosticLogger, notificationManager?: INotificationManager): void;
     track(telemetryItem: ITelemetryItem): void;
+    /**
+     * 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.
+     */
+    addNotificationListener(listener: INotificationListener): void;
+    /**
+     * Removes all instances of the listener.
+     * @param {INotificationListener} listener - INotificationListener to remove.
+     */
+    removeNotificationListener(listener: INotificationListener): void;
+    /**
+     * Periodically check logger.queue for
+     */
+    pollInternalLogs(eventName?: string): number;
+    /**
+     * Periodically check logger.queue for
+     */
+    stopPollingInternalLogs(): void;
 }

package/types/JavaScriptSDK/BaseCore.d.ts

@@ -1,19 +1,13 @@
-import { IAppInsightsCore, ILoadedPlugin } from "../JavaScriptSDK.Interfaces/IAppInsightsCore";
+import { IAppInsightsCore } from "../JavaScriptSDK.Interfaces/IAppInsightsCore";
 import { IConfiguration } from "../JavaScriptSDK.Interfaces/IConfiguration";
-import { IPlugin, ITelemetryPlugin } from "../JavaScriptSDK.Interfaces/ITelemetryPlugin";
+import { IPlugin } from "../JavaScriptSDK.Interfaces/ITelemetryPlugin";
 import { IChannelControls } from "../JavaScriptSDK.Interfaces/IChannelControls";
 import { ITelemetryItem } from "../JavaScriptSDK.Interfaces/ITelemetryItem";
 import { INotificationManager } from "../JavaScriptSDK.Interfaces/INotificationManager";
-import { INotificationListener } from "../JavaScriptSDK.Interfaces/INotificationListener";
 import { IDiagnosticLogger } from "../JavaScriptSDK.Interfaces/IDiagnosticLogger";
-import { IProcessTelemetryContext, IProcessTelemetryUpdateContext } from "../JavaScriptSDK.Interfaces/IProcessTelemetryContext";
+import { IProcessTelemetryContext } from "../JavaScriptSDK.Interfaces/IProcessTelemetryContext";
 import { IPerfManager } from "../JavaScriptSDK.Interfaces/IPerfManager";
 import { ICookieMgr } from "../JavaScriptSDK.Interfaces/ICookieMgr";
-import { ITelemetryInitializerHandler, TelemetryInitializerFunction } from "../JavaScriptSDK.Interfaces/ITelemetryInitializers";
-import { UnloadHandler } from "./UnloadHandlerContainer";
-import { ITelemetryUpdateState } from "../JavaScriptSDK.Interfaces/ITelemetryUpdateState";
-import { ITelemetryUnloadState } from "../JavaScriptSDK.Interfaces/ITelemetryUnloadState";
-import { SendRequestReason } from "../JavaScriptSDK.Enums/SendRequestReason";
 export declare class BaseCore implements IAppInsightsCore {
     static defaultConfig: IConfiguration;
     config: IConfiguration;
@@ -26,18 +20,6 @@ export declare class BaseCore implements IAppInsightsCore {
     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 {INotificationListener} listener - An INotificationListener object.
-     */
-    addNotificationListener(listener: INotificationListener): void;
-    /**
-     * Removes all instances of the listener.
-     * @param {INotificationListener} listener - INotificationListener to remove.
-     */
-    removeNotificationListener(listener: INotificationListener): void;
     /**
      * Get the current cookie manager for this instance
      */
@@ -50,65 +32,5 @@ export declare class BaseCore implements IAppInsightsCore {
     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 | void;
-    /**
-     * Unload and Tear down the SDK and any initialized plugins, after calling this the SDK will be considered
-     * to be un-initialized and non-operational, re-initializing the SDK should only be attempted if the previous
-     * unload call return `true` stating that all plugins reported that they also unloaded, the recommended
-     * approach is to create a new instance and initialize that instance.
-     * This is due to possible unexpected side effects caused by plugins not supporting unload / teardown, unable
-     * to successfully remove any global references or they may just be completing the unload process asynchronously.
-     * @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;
-    /**
-     * 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;
     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;
 }