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

package/types/JavaScriptSDK/EnvUtils.d.ts

@@ -1,81 +0,0 @@
-/**
- * Enable the lookup of test mock objects if requested
- * @param enabled
- */
-export declare function setEnableEnvMocks(enabled: boolean): void;
-/**
- * Returns the global location object if it is present otherwise null.
- * This helper is used to access the location object without causing an exception
- * "Uncaught ReferenceError: location is not defined"
- */
-export declare function getLocation(checkForMock?: boolean): Location | null;
-/**
- * Returns the global console object
- */
-export declare function getConsole(): Console | null;
-/**
- * Checks if JSON object is available, this is required as we support the API running without a
- * window /document (eg. Node server, electron webworkers) and if we attempt to assign a history
- * object to a local variable or pass as an argument an "Uncaught ReferenceError: JSON is not defined"
- * exception will be thrown.
- * Defined as a function to support lazy / late binding environments.
- */
-export declare function hasJSON(): boolean;
-/**
- * Returns the global JSON object if it is present otherwise null.
- * This helper is used to access the JSON object without causing an exception
- * "Uncaught ReferenceError: JSON is not defined"
- */
-export declare function getJSON(): JSON | null;
-/**
- * Returns the crypto object if it is present otherwise null.
- * This helper is used to access the crypto object from the current
- * global instance which could be window or globalThis for a web worker
- */
-export declare function getCrypto(): Crypto | null;
-/**
- * Returns the crypto object if it is present otherwise null.
- * This helper is used to access the crypto object from the current
- * global instance which could be window or globalThis for a web worker
- */
-export declare function getMsCrypto(): Crypto | null;
-/**
- * Returns whether the environment is reporting that we are running in a React Native Environment
- */
-export declare function isReactNative(): boolean;
-/**
- * Identifies whether the current environment appears to be IE
- */
-export declare function isIE(): boolean;
-/**
- * Gets IE version returning the document emulation mode if we are running on IE, or null otherwise
- */
-export declare function getIEVersion(userAgentStr?: string): number;
-export declare function isSafari(userAgentStr?: string): boolean;
-/**
- * Checks if HTML5 Beacons are supported in the current environment.
- * @returns True if supported, false otherwise.
- */
-export declare function isBeaconsSupported(): boolean;
-/**
- * Checks if the Fetch API is supported in the current environment.
- * @param withKeepAlive - [Optional] If True, check if fetch is available and it supports the keepalive feature, otherwise only check if fetch is supported
- * @returns True if supported, otherwise false
- */
-export declare function isFetchSupported(withKeepAlive?: boolean): boolean;
-export declare function useXDomainRequest(): boolean | undefined;
-/**
- * Checks if XMLHttpRequest is supported
- * @returns True if supported, otherwise false
- */
-export declare function isXhrSupported(): boolean;
-/**
- * Helper function to fetch the named meta-tag from the page.
- * @param name
- */
-export declare function findMetaTag(name: string): any;
-/**
- * Helper function to fetch the named server timing value from the page response (first navigation event).
- * @param name
- */
-export declare function findNamedServerTiming(name: string): any;

package/types/JavaScriptSDK/EventHelpers.d.ts

@@ -1,154 +0,0 @@
-export interface _IRegisteredEvents {
-    name: string;
-    handler: any;
-}
-/**
- * Get all of the registered events on the target object, this is primarily used for testing cleanup but may also be used by
- * applications to remove their own events
- * @param target - The EventTarget that has registered events
- * @param eventName - [Optional] The name of the event to return the registered handlers and full name (with namespaces)
- * @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
- */
-export declare function __getRegisteredEvents(target: any, eventName?: string, evtNamespace?: string | string[]): _IRegisteredEvents[];
-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)
- * namespaces "click" "click.mynamespace" in addition to specific namespaces.
- * @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
- * @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,
- * 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
- * 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
- */
-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
- * @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,
- * 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
- * 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
- */
-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 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,
- * 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
- * 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.
- */
-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 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
- */
-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 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;
-/**
- * Listen to the 'beforeunload', 'unload' and 'pagehide' events which indicates a page unload is occurring,
- * this does NOT listen to the 'visibilitychange' event as while it does indicate that the page is being hidden
- * it does not *necessarily* mean that the page is being completely unloaded, it can mean that the user is
- * just navigating to a different Tab and may come back (without unloading the page). As such you may also
- * need to listen to the 'addPageHideEventListener' and 'addPageShowEventListener' events.
- * @param listener - The event callback to call when a page unload event is triggered
- * @param excludeEvents - [Optional] An array of events that should not be hooked, 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
- */
-export declare function addPageUnloadEventListener(listener: any, excludeEvents?: string[], evtNamespace?: string | string[]): boolean;
-/**
- * Remove any matching 'beforeunload', 'unload' and 'pagehide' events that may have been added via addEventListener,
- * addEventListeners, addPageUnloadEventListener or addPageHideEventListener.
- * @param listener - The specific event callback to to be removed
- * @param evtNamespace - [Optional] Namespace(s) uniquely identified and removed based on this namespace.
- * @returns true - when at least one of the events was registered otherwise false
- */
-export declare function removePageUnloadEventListener(listener: any, evtNamespace?: string | string[]): void;
-/**
- * Listen to the pagehide and visibility changing to 'hidden' events, because the 'visibilitychange' uses
- * an internal proxy to detect the visibility state you SHOULD use a unique namespace when if you plan to call
- * removePageShowEventListener as the remove ignores the listener argument for the 'visibilitychange' event.
- * @param listener - The event callback to call when a page hide 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] A Namespace to append to the event listeners so they can be uniquely identified and removed
- * based on this namespace. This call also adds an additional unique "pageshow" namespace to the events
- * so that only the matching "removePageHideEventListener" can remove these events.
- * Suggestion: pass as true if you are also calling addPageUnloadEventListener as that also hooks pagehide
- * @returns true - when at least one of the events was registered otherwise false
- */
-export declare function addPageHideEventListener(listener: any, excludeEvents?: string[] | null, evtNamespace?: string | string[] | null): boolean;
-/**
- * Removes the pageHide event listeners added by addPageHideEventListener, because the 'visibilitychange' uses
- * an internal proxy to detect the visibility state you SHOULD use a unique namespace when calling addPageHideEventListener
- * as the remove ignores the listener argument for the 'visibilitychange' event.
- * @param listener - The specific listener to remove for the 'pageshow' event only (ignored for 'visibilitychange')
- * @param evtNamespace - The unique namespace used when calling addPageShowEventListener
- */
-export declare function removePageHideEventListener(listener: any, evtNamespace?: string | string[] | null): void;
-/**
- * Listen to the pageshow and visibility changing to 'visible' events, because the 'visibilitychange' uses
- * an internal proxy to detect the visibility state you SHOULD use a unique namespace when if you plan to call
- * removePageShowEventListener as the remove ignores the listener argument for the 'visibilitychange' event.
- * @param listener - The event callback to call when a page is show 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/Recommended] A Namespace to append to the event listeners so they can be uniquely
- * identified and removed based on this namespace. This call also adds an additional unique "pageshow" namespace to the events
- * so that only the matching "removePageShowEventListener" can remove these events.
- * @returns true - when at least one of the events was registered otherwise false
- */
-export declare function addPageShowEventListener(listener: any, excludeEvents?: string[] | null, evtNamespace?: string | string[] | null): boolean;
-/**
- * Removes the pageShow event listeners added by addPageShowEventListener, because the 'visibilitychange' uses
- * an internal proxy to detect the visibility state you SHOULD use a unique namespace when calling addPageShowEventListener
- * as the remove ignores the listener argument for the 'visibilitychange' event.
- * @param listener - The specific listener to remove for the 'pageshow' event only (ignored for 'visibilitychange')
- * @param evtNamespace - The unique namespace used when calling addPageShowEventListener
- */
-export declare function removePageShowEventListener(listener: any, evtNamespace?: string | string[] | null): void;

package/types/JavaScriptSDK/HelperFuncs.d.ts

@@ -1,106 +0,0 @@
-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;
-/**
- * Validates that the string name conforms to the JS IdentifierName specification and if not
- * 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
- */
-export declare function normalizeJsName(name: string): string;
-/**
- * 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
- * @param search - The value search within the value
- */
-export declare function strContains(value: string, search: string): boolean;
-/**
- * Convert a date to I.S.O. format in IE8
- */
-export declare function toISOString(date: Date): string;
-export declare const deepFreeze: <T>(obj: T) => T;
-/**
- * Returns the name of object if it's an Error. Otherwise, returns empty string.
- */
-export declare function getExceptionName(object: any): string;
-/**
- * Sets the provided value on the target instance using the field name when the provided chk function returns true, the chk
- * function will only be called if the new value is no equal to the original value.
- * @param target - The target object
- * @param field - The key of the target
- * @param value - The value to set
- * @param valChk - [Optional] Callback to check the value that if supplied will be called check if the new value can be set
- * @param srcChk - [Optional] Callback to check to original value that if supplied will be called if the new value should be set (if allowed)
- * @returns The existing or new value, depending what was set
- */
-export declare function setValue<T, K extends keyof T>(target: T, field: K, value: T[K], valChk?: ((value: T[K]) => boolean) | null, srcChk?: ((value: T[K]) => boolean) | null): T[K];
-/**
- * Returns the current value from the target object if not null or undefined otherwise sets the new value and returns it
- * @param target - The target object to return or set the default value
- * @param field - The key for the field to set on the target
- * @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];
-/**
- * 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
- * implementation issues by assigning prototype functions as instance ones
- *
- * This method is the primary method used to "update" the snippet proxy with the ultimate implementations.
- *
- * Special ES3 Notes:
- * Updates (setting) of direct property values on the target or indirectly on the source object WILL NOT WORK PROPERLY, updates to the
- * properties of "referenced" object will work (target.context.newValue = 10 => will be reflected in the source.context as it's the
- * same object). ES3 Failures: assigning target.myProp = 3 -> Won't change source.myProp = 3, likewise the reverse would also fail.
- * @param target - The target object to be assigned with the source properties and functions
- * @param source - The source object which will be assigned / called by setting / calling the targets proxies
- * @param chkSet - An optional callback to determine whether a specific property/function should be proxied
- */
-export declare function proxyAssign<T, S>(target: T, source: S, chkSet?: (name: string, isFunc?: boolean, source?: S, target?: T) => boolean): T;
-/**
- * Creates a proxy function on the target which internally will call the source version with all arguments passed to the target method.
- *
- * @param target - The target object to be assigned with the source properties and functions
- * @param name - The function name that will be added on the target
- * @param source - The source object which will be assigned / called by setting / calling the targets proxies
- * @param theFunc - The function name on the source that will be proxied on the target
- * @param overwriteTarget - If `false` this will not replace any pre-existing name otherwise (the default) it will overwrite any existing name
- */
-export declare function proxyFunctionAs<T, S>(target: T, name: string, source: S | (() => S), theFunc: (keyof S), overwriteTarget?: boolean): void;
-/**
- * Creates proxy functions on the target which internally will call the source version with all arguments passed to the target method.
- *
- * @param target - The target object to be assigned with the source properties and functions
- * @param source - The source object which will be assigned / called by setting / calling the targets proxies
- * @param functionsToProxy - An array of function names that will be proxied on the target
- * @param overwriteTarget - If false this will not replace any pre-existing name otherwise (the default) it will overwrite any existing name
- */
-export declare function proxyFunctions<T, S>(target: T, source: S | (() => S), functionsToProxy: (keyof S)[], overwriteTarget?: boolean): T;
-/**
- * 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
- */
-export declare function createClassFromInterface<T>(defaults?: T): new () => T;
-/**
- * A helper function to assist with JIT performance for objects that have properties added / removed dynamically
- * this is primarily for chromium based browsers and has limited effects on Firefox and none of IE. Only call this
- * function after you have finished "updating" the object, calling this within loops reduces or defeats the benefits.
- * This helps when iterating using for..in, objKeys() and objForEach()
- * @param theObject - The object to be optimized if possible
- */
-export declare function optimizeObject<T>(theObject: T): T;
-/**
- * Pass in the objects to merge as arguments, this will only "merge" (extend) properties that are owned by the object.
- * It will NOT merge inherited or non-enumerable properties.
- * @param obj1 - object to merge.  Set this argument to 'true' for a deep extend.
- * @param obj2 - object to merge.
- * @param obj3 - object to merge.
- * @param obj4 - object to merge.
- * @param obj5 - object to merge.
- * @returns The extended first object.
- */
-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/InstrumentHooks.d.ts

@@ -1,43 +0,0 @@
-import { IInstrumentHook, IInstrumentHooksCallbacks } from "../JavaScriptSDK.Interfaces/IInstrumentHooks";
-/**
- * Intercept the named prototype functions for the target class / object
- * @param target - The target object
- * @param funcName - The function name
- * @param callbacks - The callbacks to configure and call whenever the function is called
- */
-export declare function InstrumentProto(target: any, funcName: string, callbacks: IInstrumentHooksCallbacks): IInstrumentHook;
-/**
- * Intercept the named prototype functions for the target class / object
- * @param target - The target object
- * @param funcNames - The function names to intercept and call
- * @param callbacks - The callbacks to configure and call whenever the function is called
- */
-export declare function InstrumentProtos(target: any, funcNames: string[], callbacks: IInstrumentHooksCallbacks): IInstrumentHook[];
-/**
- * Intercept the named prototype functions for the target class / object
- * @param target - The target object
- * @param funcName - The function name
- * @param callbacks - The callbacks to configure and call whenever the function is called
- * @param checkPrototype - If the function doesn't exist on the target should it attempt to hook the prototype function
- * @param checkParentProto - If the function doesn't exist on the target or it's prototype should it attempt to hook the parent's prototype
- */
-export declare function InstrumentFunc(target: any, funcName: string, callbacks: IInstrumentHooksCallbacks, checkPrototype?: boolean, checkParentProto?: boolean): IInstrumentHook;
-/**
- * Intercept the named functions for the target class / object
- * @param target - The target object
- * @param funcNames - The function names to intercept and call
- * @param callbacks - The callbacks to configure and call whenever the function is called
- * @param checkPrototype - If the function doesn't exist on the target should it attempt to hook the prototype function
- * @param checkParentProto - If the function doesn't exist on the target or it's prototype should it attempt to hook the parent's prototype
- */
-export declare function InstrumentFuncs(target: any, funcNames: string[], callbacks: IInstrumentHooksCallbacks, checkPrototype?: boolean, checkParentProto?: boolean): IInstrumentHook[];
-/**
- * Add an instrumentation hook to the provided named "event" for the target class / object, this doesn't check whether the
- * named "event" is in fact a function and just assigns the instrumentation hook to the target[evtName]
- * @param target - The target object
- * @param evtName - The name of the event
- * @param callbacks - The callbacks to configure and call whenever the function is called
- * @param checkPrototype - If the function doesn't exist on the target should it attempt to hook the prototype function
- * @param checkParentProto - If the function doesn't exist on the target or it's prototype should it attempt to hook the parent's prototype
- */
-export declare function InstrumentEvent(target: any, evtName: string, callbacks: IInstrumentHooksCallbacks, checkPrototype?: boolean, checkParentProto?: boolean): IInstrumentHook;

package/types/JavaScriptSDK/InternalConstants.d.ts

@@ -1,20 +0,0 @@
-export declare const UNDEFINED_VALUE: any;
-export declare const STR_EMPTY = "";
-export declare const STR_CHANNELS = "channels";
-export declare const STR_CORE = "core";
-export declare const STR_CREATE_PERF_MGR = "createPerfMgr";
-export declare const STR_DISABLED = "disabled";
-export declare const STR_EXTENSION_CONFIG = "extensionConfig";
-export declare const STR_EXTENSIONS = "extensions";
-export declare const STR_PROCESS_TELEMETRY = "processTelemetry";
-export declare const STR_PRIORITY = "priority";
-export declare const STR_EVENTS_SENT = "eventsSent";
-export declare const STR_EVENTS_DISCARDED = "eventsDiscarded";
-export declare const STR_EVENTS_SEND_REQUEST = "eventsSendRequest";
-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

@@ -1,46 +0,0 @@
-import { IConfiguration } from "../JavaScriptSDK.Interfaces/IConfiguration";
-import { INotificationListener } from "../JavaScriptSDK.Interfaces/INotificationListener";
-import { INotificationManager } from "../JavaScriptSDK.Interfaces/INotificationManager";
-import { IPerfEvent } from "../JavaScriptSDK.Interfaces/IPerfEvent";
-import { ITelemetryItem } from "../JavaScriptSDK.Interfaces/ITelemetryItem";
-/**
- * Class to manage sending notifications to all the listeners.
- */
-export declare class NotificationManager implements INotificationManager {
-    listeners: INotificationListener[];
-    constructor(config?: IConfiguration);
-    /**
-     * Adds a notification listener.
-     * @param listener - The notification listener to be added.
-     */
-    addNotificationListener(listener: INotificationListener): void;
-    /**
-     * Removes all instances of the listener.
-     * @param listener - AWTNotificationListener to remove.
-     */
-    removeNotificationListener(listener: INotificationListener): void;
-    /**
-     * Notification for events sent.
-     * @param events - The array of events that have been sent.
-     */
-    eventsSent(events: ITelemetryItem[]): void;
-    /**
-     * Notification for events being discarded.
-     * @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 sendReason - The reason why the event batch is being sent.
-     * @param isAsync - A flag which identifies whether the requests are being sent in an async or sync manner.
-     */
-    eventsSendRequest?(sendReason: number, isAsync: boolean): void;
-    /**
-     * [Optional] This event is sent if you have enabled perf events, they are primarily used to track internal performance testing and debugging
-     * the event can be displayed via the debug plugin extension.
-     * @param perfEvent
-     */
-    perfEvent?(perfEvent: IPerfEvent): void;
-}

package/types/JavaScriptSDK/PerfManager.d.ts

@@ -1,93 +0,0 @@
-import { INotificationManager } from "../JavaScriptSDK.Interfaces/INotificationManager";
-import { IPerfEvent } from "../JavaScriptSDK.Interfaces/IPerfEvent";
-import { IPerfManager, IPerfManagerProvider } from "../JavaScriptSDK.Interfaces/IPerfManager";
-export declare class PerfEvent implements IPerfEvent {
-    static ParentContextKey: string;
-    static ChildrenContextKey: string;
-    /**
-     * The name of the event
-     */
-    name: string;
-    /**
-     * The start time of the event in ms
-     */
-    start: number;
-    /**
-     * The payload (contents) of the perfEvent, may be null or only set after the event has completed depending on
-     * the runtime environment.
-     */
-    payload: any;
-    /**
-     * Is this occurring from an asynchronous event
-     */
-    isAsync: boolean;
-    /**
-     * Identifies the total inclusive time spent for this event, including the time spent for child events,
-     * this will be undefined until the event is completed
-     */
-    time?: number;
-    /**
-     * Identifies the exclusive time spent in for this event (not including child events),
-     * this will be undefined until the event is completed.
-     */
-    exTime?: number;
-    /**
-     * Identifies whether this event is a child event of a parent
-     */
-    isChildEvt: () => boolean;
-    getCtx?: (key: string) => any | null | undefined;
-    setCtx?: (key: string, value: any) => void;
-    complete: () => void;
-    constructor(name: string, payloadDetails: () => any, isAsync: boolean);
-}
-export declare class PerfManager implements IPerfManager {
-    /**
-     * General bucket used for execution context set and retrieved via setCtx() and getCtx.
-     * Defined as private so it can be visualized via the DebugPlugin
-     */
-    private ctx;
-    constructor(manager?: INotificationManager);
-    /**
-     * 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 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
-     */
-    fire(perfEvent: IPerfEvent): void;
-    /**
-     * Set an execution context value
-     * @param key - The context key name
-     * @param value - The value
-     */
-    setCtx(key: string, value: any): void;
-    /**
-     * Get the execution context value
-     * @param key - The context key
-     */
-    getCtx(key: string): any;
-}
-/**
- * Helper function to wrap a function with a perf event
- * @param mgrSource - The Performance Manager or a Performance provider source (may be null)
- * @param getSource - The callback to create the source name for the event (if perf monitoring is enabled)
- * @param func - The function to call and measure
- * @param details - A function to return the payload details
- * @param isAsync - Is the event / function being call asynchronously or synchronously
- */
-export declare function doPerf<T>(mgrSource: IPerfManagerProvider | IPerfManager, getSource: () => string, func: (perfEvt?: IPerfEvent) => T, details?: () => any, isAsync?: boolean): T;
-/**
- * Set the global performance manager to use when there is no core instance or it has not been initialized yet.
- * @param perfManager - The IPerfManager instance to use when no performance manager is supplied.
- */
-export declare function setGblPerfMgr(perfManager: IPerfManager): void;
-/**
- * Get the current global performance manager that will be used with no performance manager is supplied.
- * @returns - The current default manager
- */
-export declare function getGblPerfMgr(): IPerfManager;