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

package/types/JavaScriptSDK.Interfaces/INotificationListener.d.ts

@@ -1,32 +0,0 @@
-import { ITelemetryItem } from "./ITelemetryItem";
-import { IPerfEvent } from "./IPerfEvent";
-/**
- * An interface used for the notification listener.
- * @interface
- */
-export interface INotificationListener {
-    /**
-     * [Optional] A function called when events are sent.
-     * @param events - The array of events that have been sent.
-     */
-    eventsSent?: (events: ITelemetryItem[]) => void;
-    /**
-     * [Optional] A function called when events are discarded.
-     * @param events - The array of events that have been discarded.
-     * @param reason - The reason for discarding the events. The EventsDiscardedReason
-     * constant should be used to check the different values.
-     */
-    eventsDiscarded?: (events: ITelemetryItem[], reason: number) => void;
-    /**
-     * [Optional] A function called when the events have been requested to be sent to the sever.
-     * @param 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.Interfaces/INotificationManager.d.ts

@@ -1,43 +0,0 @@
-import { ITelemetryItem } from "../JavaScriptSDK.Interfaces/ITelemetryItem";
-import { INotificationListener } from "../JavaScriptSDK.Interfaces/INotificationListener";
-import { IPerfEvent } from "./IPerfEvent";
-/**
- * Class to manage sending notifications to all the listeners.
- */
-export interface INotificationManager {
-    listeners: INotificationListener[];
-    /**
-     * 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 - The perf event details
-     */
-    perfEvent?(perfEvent: IPerfEvent): void;
-}

package/types/JavaScriptSDK.Interfaces/IPerfEvent.d.ts

@@ -1,56 +0,0 @@
-/**
- * This interface identifies the details of an internal performance event - it does not represent an outgoing reported event
- */
-export interface IPerfEvent {
-    /**
-     * The name of the performance event
-     */
-    name: string;
-    /**
-     * The start time of the performance event
-     */
-    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;
-    /**
-     * The Parent event that was started before this event was created
-     */
-    parent?: IPerfEvent;
-    /**
-     * The child perf events that are contained within the total time of this event.
-     */
-    childEvts?: IPerfEvent[];
-    /**
-     * Identifies whether this event is a child event of a parent
-     */
-    isChildEvt: () => boolean;
-    /**
-     * Get the names additional context associated with this perf event
-     */
-    getCtx?: (key: string) => any;
-    /**
-     * Set the named additional context to be associated with this perf event, this will replace any existing value
-     */
-    setCtx?: (key: string, value: any) => void;
-    /**
-     * Mark this event as completed, calculating the total execution time.
-     */
-    complete: () => void;
-}

package/types/JavaScriptSDK.Interfaces/IPerfManager.d.ts

@@ -1,45 +0,0 @@
-import { IPerfEvent } from "./../JavaScriptSDK.Interfaces/IPerfEvent";
-/**
- * Identifies an interface to a host that can provide an IPerfManager implementation
- */
-export interface IPerfManagerProvider {
-    /**
-     * Get the current performance manager
-     */
-    getPerfMgr(): IPerfManager;
-    /**
-     * Set the current performance manager
-     * @param perfMgr - The performance manager
-     */
-    setPerfMgr(perfMgr: IPerfManager): void;
-}
-/**
- * This defines an internal performance manager for tracking and reporting the internal performance of the SDK -- It does
- * not represent or report any event to the server.
- */
-export interface IPerfManager {
-    /**
-     * Create a new event and start timing, the manager may return null/undefined to indicate that it does not
-     * want to monitor this source event.
-     * @param src - The source name of the event
-     * @param payloadDetails - An optional callback function to fetch the payload details for the event.
-     * @param isAsync - Is the event occurring from a async event
-     */
-    create(src: string, payloadDetails?: () => any, isAsync?: boolean): IPerfEvent | null | undefined;
-    /**
-     * Complete the perfEvent and fire any notifications.
-     * @param perfEvent - Fire the event which will also complete the passed event
-     */
-    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;
-}

package/types/JavaScriptSDK.Interfaces/IProcessTelemetryContext.d.ts

@@ -1,129 +0,0 @@
-import { IConfigDefaults } from "../Config/IConfigDefaults";
-import { IAppInsightsCore } from "./IAppInsightsCore";
-import { IConfiguration } from "./IConfiguration";
-import { IDiagnosticLogger } from "./IDiagnosticLogger";
-import { ITelemetryItem } from "./ITelemetryItem";
-import { IPlugin, ITelemetryPlugin } from "./ITelemetryPlugin";
-import { ITelemetryPluginChain } from "./ITelemetryPluginChain";
-import { ITelemetryUnloadState } from "./ITelemetryUnloadState";
-import { ITelemetryUpdateState } from "./ITelemetryUpdateState";
-export interface IBaseProcessingContext {
-    /**
-     * The current core instance for the request
-     */
-    core: () => IAppInsightsCore;
-    /**
-     * THe current diagnostic logger for the request
-     */
-    diagLog: () => IDiagnosticLogger;
-    /**
-     * Gets the current core config instance
-     */
-    getCfg: () => IConfiguration;
-    /**
-     * Gets the named extension config
-     */
-    getExtCfg: <T>(identifier: string, defaultValue?: IConfigDefaults<T>) => T;
-    /**
-     * Gets the named config from either the named identifier extension or core config if neither exist then the
-     * default value is returned
-     * @param identifier - The named extension identifier
-     * @param field - The config field name
-     * @param defaultValue - The default value to return if no defined config exists
-     */
-    getConfig: (identifier: string, field: string, defaultValue?: number | string | boolean | string[] | RegExp[] | Function) => number | string | boolean | string[] | RegExp[] | Function;
-    /**
-     * Helper to allow plugins to check and possibly shortcut executing code only
-     * required if there is a nextPlugin
-     */
-    hasNext: () => boolean;
-    /**
-     * Returns the next configured plugin proxy
-     */
-    getNext: () => ITelemetryPluginChain;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * 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) => IProcessTelemetryUpdateContext;
-}

package/types/JavaScriptSDK.Interfaces/ITelemetryInitializers.d.ts

@@ -1,14 +0,0 @@
-import { ITelemetryItem } from "./ITelemetryItem";
-import { ILegacyUnloadHook } from "./IUnloadHook";
-export declare type TelemetryInitializerFunction = <T extends ITelemetryItem>(item: T) => boolean | void;
-export interface ITelemetryInitializerHandler extends ILegacyUnloadHook {
-    remove(): void;
-}
-export interface ITelemetryInitializerContainer {
-    /**
-     * 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;
-}

package/types/JavaScriptSDK.Interfaces/ITelemetryItem.d.ts

@@ -1,51 +0,0 @@
-/**
- * Telemety item supported in Core
- */
-export interface ITelemetryItem {
-    /**
-     * CommonSchema Version of this SDK
-     */
-    ver?: string;
-    /**
-     * Unique name of the telemetry item
-     */
-    name: string;
-    /**
-     * Timestamp when item was sent
-     */
-    time?: string;
-    /**
-     * Identifier of the resource that uniquely identifies which resource data is sent to
-     */
-    iKey?: string;
-    /**
-     * System context properties of the telemetry item, example: ip address, city etc
-     */
-    ext?: {
-        [key: string]: any;
-    };
-    /**
-     * System context property extensions that are not global (not in ctx)
-     */
-    tags?: Tags & Tags[];
-    /**
-     * Custom data
-     */
-    data?: ICustomProperties;
-    /**
-     * Telemetry type used for part B
-     */
-    baseType?: string;
-    /**
-     * Based on schema for part B
-     */
-    baseData?: {
-        [key: string]: any;
-    };
-}
-export interface Tags {
-    [key: string]: any;
-}
-export interface ICustomProperties {
-    [key: string]: any;
-}

package/types/JavaScriptSDK.Interfaces/ITelemetryPlugin.d.ts

@@ -1,80 +0,0 @@
-import { IAppInsightsCore } from "./IAppInsightsCore";
-import { IConfiguration } from "./IConfiguration";
-import { IProcessTelemetryContext, IProcessTelemetryUnloadContext, IProcessTelemetryUpdateContext } from "./IProcessTelemetryContext";
-import { ITelemetryItem } from "./ITelemetryItem";
-import { ITelemetryPluginChain } from "./ITelemetryPluginChain";
-import { ITelemetryUnloadState } from "./ITelemetryUnloadState";
-import { ITelemetryUpdateState } from "./ITelemetryUpdateState";
-export interface ITelemetryProcessor {
-    /**
-     * 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)
-     */
-    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
-     * now for backward compatibility only.
-     */
-    setNextPlugin?: (next: ITelemetryPlugin | ITelemetryPluginChain) => void;
-    /**
-     * Priority of the extension
-     */
-    readonly priority: number;
-}
-export interface IPlugin {
-    /**
-     * Initialize plugin loaded by SDK
-     * @param config - The config for the plugin to use
-     * @param core - The current App Insights core to use for initializing this plugin instance
-     * @param extensions - The complete set of extensions to be used for initializing the plugin
-     * @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;
-    /**
-     * Returns a value that indicates whether the plugin has already been previously initialized.
-     * New plugins should implement this method to avoid being initialized more than once.
-     */
-    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.
-     */
-    teardown?: (unloadCtx: IProcessTelemetryUnloadContext, unloadState?: ITelemetryUnloadState) => void | boolean;
-    /**
-     * Extension name
-     */
-    readonly identifier: string;
-    /**
-     * Plugin version (available in data.properties.version in common schema)
-     */
-    readonly version?: string;
-    /**
-     * The App Insights core to use for backward compatibility.
-     * Therefore the interface will be able to access the core without needing to cast to "any".
-     * [optional] any 3rd party plugins which are already implementing this interface don't fail to compile.
-     */
-    core?: IAppInsightsCore;
-}

package/types/JavaScriptSDK.Interfaces/ITelemetryPluginChain.d.ts

@@ -1,23 +0,0 @@
-import { IProcessTelemetryUnloadContext } from "./IProcessTelemetryContext";
-import { ITelemetryPlugin, ITelemetryProcessor } from "./ITelemetryPlugin";
-import { ITelemetryUnloadState } from "./ITelemetryUnloadState";
-/**
- * Configuration provided to SDK core
- */
-export interface ITelemetryPluginChain extends ITelemetryProcessor {
-    /**
-     * Returns the underlying plugin that is being proxied for the processTelemetry call
-     */
-    getPlugin: () => ITelemetryPlugin;
-    /**
-     * Returns the next plugin
-     */
-    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
-     */
-    unload?: (unloadCtx: IProcessTelemetryUnloadContext, unloadState: ITelemetryUnloadState) => void;
-}

package/types/JavaScriptSDK.Interfaces/ITelemetryUnloadState.d.ts

@@ -1,6 +0,0 @@
-import { TelemetryUnloadReason } from "../JavaScriptSDK.Enums/TelemetryUnloadReason";
-export interface ITelemetryUnloadState {
-    reason: TelemetryUnloadReason;
-    isAsync: boolean;
-    flushComplete?: boolean;
-}

package/types/JavaScriptSDK.Interfaces/ITelemetryUpdateState.d.ts

@@ -1,33 +0,0 @@
-import { TelemetryUpdateReason } from "../JavaScriptSDK.Enums/TelemetryUpdateReason";
-import { IConfiguration } from "./IConfiguration";
-import { IPlugin } from "./ITelemetryPlugin";
-export interface ITelemetryUpdateState {
-    /**
-     * Identifies the reason for the update notification, this is a bitwise numeric value
-     */
-    reason: TelemetryUpdateReason;
-    /**
-     * This is a new active configuration that should be used
-     */
-    cfg?: IConfiguration;
-    /**
-     * The detected changes
-     */
-    oldCfg?: IConfiguration;
-    /**
-    * If this is a configuration update this was the previous configuration that was used
-    */
-    newConfig?: IConfiguration;
-    /**
-     * Was the new config requested to be merged with the existing config
-     */
-    merge?: boolean;
-    /**
-     * This holds a collection of plugins that have been added (if the reason identifies that one or more plugins have been added)
-     */
-    added?: IPlugin[];
-    /**
-     * This holds a collection of plugins that have been removed (if the reason identifies that one or more plugins have been removed)
-     */
-    removed?: IPlugin[];
-}

package/types/JavaScriptSDK.Interfaces/ITraceParent.d.ts

@@ -1,32 +0,0 @@
-/**
- * This interface represents the components of a W3C traceparent header
- */
-export interface ITraceParent {
-    /**
-     * The version of the definition, this MUST be a string with a length of 2 and only contain lowercase
-     * hexadecimal characters. A value of 'ff' is considered to be an invalid version.
-     */
-    version: string;
-    /**
-     * This is the ID of the whole trace forest and is used to uniquely identify a distributed trace
-     * through a system. It is represented as a 32-character string of lowercase hexadecimal characters,
-     * for example, 4bf92f3577b34da6a3ce929d0e0e4736.
-     * All characters as zero (00000000000000000000000000000000) is considered an invalid value.
-     */
-    traceId: string;
-    /**
-     * This is the ID of the current request as known by the caller (in some tracing systems, this is also
-     * known as the parent-id, where a span is the execution of a client request). It is represented as an
-     * 16-character string of lowercase hexadecimal characters, for example, 00f067aa0ba902b7.
-     * All bytes as zero (0000000000000000) is considered an invalid value.
-     */
-    spanId: string;
-    /**
-     * An 8-bit value of flags that controls tracing such as sampling, trace level, etc. These flags are
-     * recommendations given by the caller rather than strict rules to follow.
-     * As this is a bit field, you cannot interpret flags by decoding the hex value and looking at the resulting
-     * number. For example, a flag 00000001 could be encoded as 01 in hex, or 09 in hex if present with the flag
-     * 00001000. A common mistake in bit fields is forgetting to mask when interpreting flags.
-     */
-    traceFlags: number;
-}

package/types/JavaScriptSDK.Interfaces/IUnloadHook.d.ts

@@ -1,18 +0,0 @@
-/**
- * An interface which provides automatic removal during unloading of the component
- */
-export interface IUnloadHook {
-    /**
-     * Self remove the referenced component
-     */
-    rm: () => void;
-}
-/**
- * An alternate interface which provides automatic removal during unloading of the component
- */
-export interface ILegacyUnloadHook {
-    /**
-     * Legacy Self remove the referenced component
-     */
-    remove: () => void;
-}

package/types/JavaScriptSDK.Interfaces/IUnloadableComponent.d.ts

@@ -1,13 +0,0 @@
-import { IProcessTelemetryUnloadContext } from "./IProcessTelemetryContext";
-import { ITelemetryUnloadState } from "./ITelemetryUnloadState";
-export interface IUnloadableComponent {
-    /**
-    * 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.
-    */
-    _doUnload?: (unloadCtx?: IProcessTelemetryUnloadContext, unloadState?: ITelemetryUnloadState, asyncCallback?: () => void) => void | boolean;
-}

package/types/__DynamicConstants.d.ts

@@ -1,53 +0,0 @@
-export declare const _DYN_TO_LOWER_CASE = "toLowerCase";
-export declare const _DYN_LENGTH = "length";
-export declare const _DYN_RD_ONLY = "rdOnly";
-export declare const _DYN_NOTIFY = "notify";
-export declare const _DYN_THROW_INTERNAL = "throwInternal";
-export declare const _DYN_SET_DF = "setDf";
-export declare const _DYN_WATCH = "watch";
-export declare const _DYN_LOGGER = "logger";
-export declare const _DYN_APPLY = "apply";
-export declare const _DYN_PUSH = "push";
-export declare const _DYN_SPLICE = "splice";
-export declare const _DYN_CANCEL = "cancel";
-export declare const _DYN_INITIALIZE = "initialize";
-export declare const _DYN_IDENTIFIER = "identifier";
-export declare const _DYN_IS_INITIALIZED = "isInitialized";
-export declare const _DYN_GET_PLUGIN = "getPlugin";
-export declare const _DYN_POLL_INTERNAL_LOGS = "pollInternalLogs";
-export declare const _DYN_NAME = "name";
-export declare const _DYN_TIME = "time";
-export declare const _DYN_PROCESS_NEXT = "processNext";
-export declare const _DYN_GET_PROCESS_TEL_CONT0 = "getProcessTelContext";
-export declare const _DYN_GET_NOTIFY_MGR = "getNotifyMgr";
-export declare const _DYN_ADD_NOTIFICATION_LIS1 = "addNotificationListener";
-export declare const _DYN_REMOVE_NOTIFICATION_2 = "removeNotificationListener";
-export declare const _DYN_STOP_POLLING_INTERNA3 = "stopPollingInternalLogs";
-export declare const _DYN_ON_COMPLETE = "onComplete";
-export declare const _DYN_VERSION = "version";
-export declare const _DYN_LOGGING_LEVEL_CONSOL4 = "loggingLevelConsole";
-export declare const _DYN_CREATE_NEW = "createNew";
-export declare const _DYN_TEARDOWN = "teardown";
-export declare const _DYN_MESSAGE_ID = "messageId";
-export declare const _DYN_MESSAGE = "message";
-export declare const _DYN_IS_ASYNC = "isAsync";
-export declare const _DYN_DIAG_LOG = "diagLog";
-export declare const _DYN__DO_TEARDOWN = "_doTeardown";
-export declare const _DYN_UPDATE = "update";
-export declare const _DYN_GET_NEXT = "getNext";
-export declare const _DYN_SET_NEXT_PLUGIN = "setNextPlugin";
-export declare const _DYN_USER_AGENT = "userAgent";
-export declare const _DYN_SPLIT = "split";
-export declare const _DYN_NODE_TYPE = "nodeType";
-export declare const _DYN_REPLACE = "replace";
-export declare const _DYN_LOG_INTERNAL_MESSAGE = "logInternalMessage";
-export declare const _DYN_TYPE = "type";
-export declare const _DYN_HANDLER = "handler";
-export declare const _DYN_LISTENERS = "listeners";
-export declare const _DYN_IS_CHILD_EVT = "isChildEvt";
-export declare const _DYN_GET_CTX = "getCtx";
-export declare const _DYN_SET_CTX = "setCtx";
-export declare const _DYN_COMPLETE = "complete";
-export declare const _DYN_TRACE_ID = "traceId";
-export declare const _DYN_SPAN_ID = "spanId";
-export declare const _DYN_TRACE_FLAGS = "traceFlags";

package/types/tsdoc-metadata.json

@@ -1,11 +0,0 @@
-// This file is read by tools that parse documentation comments conforming to the TSDoc standard.
-// It should be published with your NPM package.  It should not be tracked by Git.
-{
-  "tsdocVersion": "0.12",
-  "toolPackages": [
-    {
-      "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.34.4"
-    }
-  ]
-}