@microsoft/1ds-post-js 4.1.0-nightly3.2402-08 → 4.1.0-nightly3.2402-12

package/types/1ds-post-js.namespaced.d.ts

@@ -1,5 +1,5 @@
 /*
- * 1DS JS SDK Post Channel, 4.1.0-nightly3.2402-08
+ * 1DS JS SDK Post Channel, 4.1.0-nightly3.2402-12
  * Copyright (c) Microsoft and contributors. All rights reserved.
  *
  * Microsoft Application Insights Team
@@ -7,24 +7,104 @@
  */
 
 declare namespace oneDS {
-    import { BaseTelemetryPlugin } from '@microsoft/1ds-core-js';
-    import { IAppInsightsCore } from '@microsoft/1ds-core-js';
-    import { IChannelControls } from '@microsoft/1ds-core-js';
-    import { IDiagnosticLogger } from '@microsoft/1ds-core-js';
-    import { IExtendedConfiguration } from '@microsoft/1ds-core-js';
-    import { IInternalOfflineSupport } from '@microsoft/1ds-core-js';
-    import { IPayloadData } from '@microsoft/1ds-core-js';
-    import { IPlugin } from '@microsoft/1ds-core-js';
-    import { IProcessTelemetryContext } from '@microsoft/1ds-core-js';
-    import { IPromise } from '@nevware21/ts-async';
-    import { ITelemetryItem } from '@microsoft/1ds-core-js';
-    import { ITelemetryPlugin } from '@microsoft/1ds-core-js';
-    import { IUnloadHook } from '@microsoft/1ds-core-js';
-    import { IValueSanitizer } from '@microsoft/1ds-core-js';
-    import { IXHROverride } from '@microsoft/1ds-core-js';
-    import { OnCompleteCallback } from '@microsoft/1ds-core-js';
-    import { SendPOSTFunction } from '@microsoft/1ds-core-js';
-    import { SendRequestReason } from '@microsoft/1ds-core-js';
+    /**
+     * BaseTelemetryPlugin provides a basic implementation of the ITelemetryPlugin interface so that plugins
+     * can avoid implementation the same set of boiler plate code as well as provide a base
+     * implementation so that new default implementations can be added without breaking all plugins.
+     */
+    abstract class BaseTelemetryPlugin implements ITelemetryPlugin {
+        identifier: string;
+        version?: string;
+        /**
+         * Holds the core instance that was used during initialization
+         */
+        core: IAppInsightsCore;
+        priority: number;
+        /**
+         * Call back for telemetry processing before it it is sent
+         * @param env - This is the current event being reported
+         * @param itemCtx - This is the context for the current request, ITelemetryPlugin instances
+         * can optionally use this to access the current core instance or define / pass additional information
+         * to later plugins (vs appending items to the telemetry item)
+         */
+        processNext: (env: ITelemetryItem, itemCtx: IProcessTelemetryContext) => void;
+        /**
+         * Set next extension for telemetry processing
+         */
+        setNextPlugin: (next: ITelemetryPlugin | ITelemetryPluginChain) => void;
+        /**
+         * Returns the current diagnostic logger that can be used to log issues, if no logger is currently
+         * assigned a new default one will be created and returned.
+         */
+        diagLog: (itemCtx?: IProcessTelemetryContext) => IDiagnosticLogger;
+        /**
+         * Returns whether the plugin has been initialized
+         */
+        isInitialized: () => boolean;
+        /**
+         * Helper to return the current IProcessTelemetryContext, if the passed argument exists this just
+         * returns that value (helps with minification for callers), otherwise it will return the configured
+         * context or a temporary one.
+         * @param currentCtx - [Optional] The current execution context
+         */
+        protected _getTelCtx: (currentCtx?: IProcessTelemetryContext) => IProcessTelemetryContext;
+        /**
+         * Internal helper to allow setting of the internal initialized setting for inherited instances and unit testing
+         */
+        protected setInitialized: (isInitialized: boolean) => void;
+        /**
+         * Teardown / Unload hook to allow implementations to perform some additional unload operations before the BaseTelemetryPlugin
+         * finishes it's removal.
+         * @param unloadCtx - This is the context that should be used during unloading.
+         * @param unloadState - The details / state of the unload process, it holds details like whether it should be unloaded synchronously or asynchronously and the reason for the unload.
+         * @param asyncCallback - An optional callback that the plugin must call if it returns true to inform the caller that it has completed any async unload/teardown operations.
+         * @returns boolean - true if the plugin has or will call asyncCallback, this allows the plugin to perform any asynchronous operations.
+         */
+        protected _doTeardown?: (unloadCtx?: IProcessTelemetryUnloadContext, unloadState?: ITelemetryUnloadState, asyncCallback?: () => void) => void | boolean;
+        /**
+         * Extension hook to allow implementations to perform some additional update operations before the BaseTelemetryPlugin finishes it's removal
+         * @param updateCtx - This is the context that should be used during updating.
+         * @param updateState - The details / state of the update process, it holds details like the current and previous configuration.
+         * @param asyncCallback - An optional callback that the plugin must call if it returns true to inform the caller that it has completed any async update operations.
+         * @returns boolean - true if the plugin has or will call asyncCallback, this allows the plugin to perform any asynchronous operations.
+         */
+        protected _doUpdate?: (updateCtx?: IProcessTelemetryUpdateContext, updateState?: ITelemetryUpdateState, asyncCallback?: () => void) => void | boolean;
+        /**
+         * Exposes the underlying unload hook container instance for this extension to allow it to be passed down to any sub components of the class.
+         * This should NEVER be exposed or called publically as it's scope is for internal use by BaseTelemetryPlugin and any derived class (which is why
+         * it's scoped as protected)
+         */
+        protected readonly _unloadHooks: IUnloadHookContainer;
+        constructor();
+        initialize(config: IConfiguration, core: IAppInsightsCore, extensions: IPlugin[], pluginChain?: ITelemetryPluginChain): void;
+        /**
+         * Tear down the plugin and remove any hooked value, the plugin should be removed so that it is no longer initialized and
+         * therefore could be re-initialized after being torn down. The plugin should ensure that once this has been called any further
+         * processTelemetry calls are ignored and it just calls the processNext() with the provided context.
+         * @param unloadCtx - This is the context that should be used during unloading.
+         * @param unloadState - The details / state of the unload process, it holds details like whether it should be unloaded synchronously or asynchronously and the reason for the unload.
+         * @returns boolean - true if the plugin has or will call processNext(), this for backward compatibility as previously teardown was synchronous and returned nothing.
+         */
+        teardown(unloadCtx?: IProcessTelemetryUnloadContext, unloadState?: ITelemetryUnloadState): void | boolean;
+        abstract processTelemetry(env: ITelemetryItem, itemCtx?: IProcessTelemetryContext): void;
+        /**
+         * The the plugin should re-evaluate configuration and update any cached configuration settings.
+         * @param updateCtx - This is the context that should be used during updating.
+         * @param updateState - The details / state of the update process, it holds details like the current and previous configuration.
+         * @returns boolean - true if the plugin has or will call updateCtx.processNext(), this allows the plugin to perform any asynchronous operations.
+         */
+        update(updateCtx: IProcessTelemetryUpdateContext, updateState: ITelemetryUpdateState): void | boolean;
+        /**
+         * Add an unload handler that will be called when the SDK is being unloaded
+         * @param handler - the handler
+         */
+        protected _addUnloadCb(handler: UnloadHandler): void;
+        /**
+         * Add this hook so that it is automatically removed during unloading
+         * @param hooks - The single hook or an array of IInstrumentHook objects
+         */
+        protected _addHook(hooks: IUnloadHook | IUnloadHook[] | Iterator<IUnloadHook> | ILegacyUnloadHook | ILegacyUnloadHook[] | Iterator<ILegacyUnloadHook>): void;
+    }
 
     /**
      * Best Effort. RealTime Latency events are sent every 9 sec and
@@ -32,6 +112,371 @@ declare namespace oneDS {
      */
     const BE_PROFILE = "BEST_EFFORT";
 
+    const enum _eInternalMessageId {
+        BrowserDoesNotSupportLocalStorage = 0,
+        BrowserCannotReadLocalStorage = 1,
+        BrowserCannotReadSessionStorage = 2,
+        BrowserCannotWriteLocalStorage = 3,
+        BrowserCannotWriteSessionStorage = 4,
+        BrowserFailedRemovalFromLocalStorage = 5,
+        BrowserFailedRemovalFromSessionStorage = 6,
+        CannotSendEmptyTelemetry = 7,
+        ClientPerformanceMathError = 8,
+        ErrorParsingAISessionCookie = 9,
+        ErrorPVCalc = 10,
+        ExceptionWhileLoggingError = 11,
+        FailedAddingTelemetryToBuffer = 12,
+        FailedMonitorAjaxAbort = 13,
+        FailedMonitorAjaxDur = 14,
+        FailedMonitorAjaxOpen = 15,
+        FailedMonitorAjaxRSC = 16,
+        FailedMonitorAjaxSend = 17,
+        FailedMonitorAjaxGetCorrelationHeader = 18,
+        FailedToAddHandlerForOnBeforeUnload = 19,
+        FailedToSendQueuedTelemetry = 20,
+        FailedToReportDataLoss = 21,
+        FlushFailed = 22,
+        MessageLimitPerPVExceeded = 23,
+        MissingRequiredFieldSpecification = 24,
+        NavigationTimingNotSupported = 25,
+        OnError = 26,
+        SessionRenewalDateIsZero = 27,
+        SenderNotInitialized = 28,
+        StartTrackEventFailed = 29,
+        StopTrackEventFailed = 30,
+        StartTrackFailed = 31,
+        StopTrackFailed = 32,
+        TelemetrySampledAndNotSent = 33,
+        TrackEventFailed = 34,
+        TrackExceptionFailed = 35,
+        TrackMetricFailed = 36,
+        TrackPVFailed = 37,
+        TrackPVFailedCalc = 38,
+        TrackTraceFailed = 39,
+        TransmissionFailed = 40,
+        FailedToSetStorageBuffer = 41,
+        FailedToRestoreStorageBuffer = 42,
+        InvalidBackendResponse = 43,
+        FailedToFixDepricatedValues = 44,
+        InvalidDurationValue = 45,
+        TelemetryEnvelopeInvalid = 46,
+        CreateEnvelopeError = 47,
+        CannotSerializeObject = 48,
+        CannotSerializeObjectNonSerializable = 49,
+        CircularReferenceDetected = 50,
+        ClearAuthContextFailed = 51,
+        ExceptionTruncated = 52,
+        IllegalCharsInName = 53,
+        ItemNotInArray = 54,
+        MaxAjaxPerPVExceeded = 55,
+        MessageTruncated = 56,
+        NameTooLong = 57,
+        SampleRateOutOfRange = 58,
+        SetAuthContextFailed = 59,
+        SetAuthContextFailedAccountName = 60,
+        StringValueTooLong = 61,
+        StartCalledMoreThanOnce = 62,
+        StopCalledWithoutStart = 63,
+        TelemetryInitializerFailed = 64,
+        TrackArgumentsNotSpecified = 65,
+        UrlTooLong = 66,
+        SessionStorageBufferFull = 67,
+        CannotAccessCookie = 68,
+        IdTooLong = 69,
+        InvalidEvent = 70,
+        FailedMonitorAjaxSetRequestHeader = 71,
+        SendBrowserInfoOnUserInit = 72,
+        PluginException = 73,
+        NotificationException = 74,
+        SnippetScriptLoadFailure = 99,
+        InvalidInstrumentationKey = 100,
+        CannotParseAiBlobValue = 101,
+        InvalidContentBlob = 102,
+        TrackPageActionEventFailed = 103,
+        FailedAddingCustomDefinedRequestContext = 104,
+        InMemoryStorageBufferFull = 105,
+        InstrumentationKeyDeprecation = 106,
+        ConfigWatcherException = 107,
+        DynamicConfigException = 108,
+        DefaultThrottleMsgKey = 109,
+        CdnDeprecation = 110,
+        SdkLdrUpdate = 111
+    }
+
+    const enum eLoggingSeverity {
+        /**
+         * No Logging will be enabled
+         */
+        DISABLED = 0,
+        /**
+         * Error will be sent as internal telemetry
+         */
+        CRITICAL = 1,
+        /**
+         * Error will NOT be sent as internal telemetry, and will only be shown in browser console
+         */
+        WARNING = 2,
+        /**
+         * The Error will NOT be sent as an internal telemetry, and will only be shown in the browser
+         * console if the logging level allows it.
+         */
+        DEBUG = 3
+    }
+
+    /**
+     * A type that identifies an enum class generated from a constant enum.
+     * @group Enum
+     * @typeParam E - The constant enum type
+     *
+     * Returned from {@link createEnum}
+     */
+    type EnumCls<E = any> = {
+        readonly [key in keyof E extends string | number | symbol ? keyof E : never]: key extends string ? E[key] : key;
+    } & {
+        readonly [key in keyof E]: E[key];
+    };
+
+    type EnumValue<E = any> = EnumCls<E>;
+
+    const enum FeatureOptInMode {
+        /**
+         * not set, completely depends on cdn cfg
+         */
+        none = 1,
+        /**
+         * try to not apply config from cdn
+         */
+        disable = 2,
+        /**
+         * try to apply config from cdn
+         */
+        enable = 3
+    }
+
+    type FieldValueSanitizerFunc = (details: IFieldSanitizerDetails) => IEventProperty | null;
+
+    const enum FieldValueSanitizerType {
+        NotSet = 0,
+        String = 1,
+        Number = 2,
+        Boolean = 3,
+        Object = 4,
+        Array = 4096,
+        EventProperty = 8192
+    }
+
+    type FieldValueSanitizerTypes = string | number | boolean | object | string[] | number[] | boolean[] | IEventProperty;
+
+    /**
+     * This defines the handler function that is called via the finally when the promise is resolved or rejected
+     */
+    type FinallyPromiseHandler = (() => void) | undefined | null;
+
+    interface IAppInsightsCore<CfgType extends IConfiguration = IConfiguration> extends IPerfManagerProvider {
+        readonly config: CfgType;
+        /**
+         * The current logger instance for this instance.
+         */
+        readonly logger: IDiagnosticLogger;
+        /**
+         * An array of the installed plugins that provide a version
+         */
+        readonly pluginVersionStringArr: string[];
+        /**
+         * The formatted string of the installed plugins that contain a version number
+         */
+        readonly pluginVersionString: string;
+        /**
+         * Returns a value that indicates whether the instance has already been previously initialized.
+         */
+        isInitialized?: () => boolean;
+        initialize(config: CfgType, extensions: IPlugin[], logger?: IDiagnosticLogger, notificationManager?: INotificationManager): void;
+        getChannels(): IChannelControls[];
+        track(telemetryItem: ITelemetryItem): void;
+        /**
+         * Get the current notification manager
+         */
+        getNotifyMgr(): INotificationManager;
+        /**
+         * Get the current cookie manager for this instance
+         */
+        getCookieMgr(): ICookieMgr;
+        /**
+         * Set the current cookie manager for this instance
+         * @param cookieMgr - The manager, if set to null/undefined will cause the default to be created
+         */
+        setCookieMgr(cookieMgr: ICookieMgr): void;
+        /**
+         * Adds a notification listener. The SDK calls methods on the listener when an appropriate notification is raised.
+         * The added plugins must raise notifications. If the plugins do not implement the notifications, then no methods will be
+         * called.
+         * @param listener - An INotificationListener object.
+         */
+        addNotificationListener?(listener: INotificationListener): void;
+        /**
+         * Removes all instances of the listener.
+         * @param listener - INotificationListener to remove.
+         */
+        removeNotificationListener?(listener: INotificationListener): void;
+        /**
+         * 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;
+        pollInternalLogs?(eventName?: string): ITimerHandler;
+        stopPollingInternalLogs?(): void;
+        /**
+         * 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.
+         * If you pass isAsync as `true` (also the default) and DO NOT pass a callback function then an [IPromise](https://nevware21.github.io/ts-async/typedoc/interfaces/IPromise.html)
+         * will be returned which will resolve once the unload is complete. The actual implementation of the `IPromise`
+         * will be a native Promise (if supported) or the default as supplied by [ts-async library](https://github.com/nevware21/ts-async)
+         * @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.
+         * @return Nothing or if occurring asynchronously a [IPromise](https://nevware21.github.io/ts-async/typedoc/interfaces/IPromise.html)
+         * which will be resolved once the unload is complete, the [IPromise](https://nevware21.github.io/ts-async/typedoc/interfaces/IPromise.html)
+         * will only be returned when no callback is provided and isAsync is true
+         */
+        unload(isAsync?: boolean, unloadComplete?: (unloadState: ITelemetryUnloadState) => void, cbTimeout?: number): void | IPromise<ITelemetryUnloadState>;
+        /**
+         * 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;
+        /**
+         * Update the configuration used and broadcast the changes to all loaded plugins, this does NOT support updating, adding or removing
+         * any the plugins (extensions or channels). It will notify each plugin (if supported) that the configuration has changed but it will
+         * not remove or add any new plugins, you need to call addPlugin or getPlugin(identifier).remove();
+         * @param newConfig - The new configuration is apply
+         * @param mergeExisting - Should the new configuration merge with the existing or just replace it. Default is to merge.
+         */
+        updateCfg(newConfig: CfgType, mergeExisting?: boolean): 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;
+        /**
+         * Add this hook so that it is automatically removed during unloading
+         * @param hooks - The single hook or an array of IInstrumentHook objects
+         */
+        addUnloadHook(hooks: IUnloadHook | IUnloadHook[] | Iterator<IUnloadHook> | ILegacyUnloadHook | ILegacyUnloadHook[] | Iterator<ILegacyUnloadHook>): void;
+        /**
+         * 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;
+        /**
+         * Gets the current distributed trace context for this instance if available
+         * @param createNew - Optional flag to create a new instance if one doesn't currently exist, defaults to true
+         */
+        getTraceCtx(createNew?: boolean): IDistributedTraceContext | null;
+        /**
+         * Sets the current distributed trace context for this instance if available
+         */
+        setTraceCtx(newTraceCtx: IDistributedTraceContext | null | undefined): void;
+        /**
+         * Watches and tracks changes for accesses to the current config, and if the accessed config changes the
+         * handler will be recalled.
+         * @param handler
+         * @returns A watcher handler instance that can be used to remove itself when being unloaded
+         */
+        onCfgChange(handler: WatcherFunction<CfgType>): IUnloadHook;
+        /**
+         * Function used to identify the get w parameter used to identify status bit to some channels
+         */
+        getWParam: () => number;
+    }
+
+    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 IChannelConfiguration interface holds the configuration details passed to Post module.
      */
@@ -217,136 +662,1757 @@ declare namespace oneDS {
         excludeCsMetaData?: boolean;
     }
 
-    
     /**
-     * Post channel interface
+     * Provides data transmission capabilities
      */
-    interface IPostChannel extends ITelemetryPlugin {
+    interface IChannelControls extends ITelemetryPlugin {
         /**
-         * Diagnostic logger
+         * Pause sending data
          */
-        diagLog: (itemCtx?: IProcessTelemetryContext) => IDiagnosticLogger;
+        pause?(): void;
         /**
-         * Override for setTimeout
+         * Resume sending data
          */
-        _setTimeoutOverride?: (callback: (...args: any[]) => void, ms: number, ...args: any[]) => any;
+        resume?(): void;
         /**
-         * Backs off transmission. This exponentially increases all the timers.
+         * 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.
          */
-        _backOffTransmission(): void;
+        teardown?: (unloadCtx?: IProcessTelemetryUnloadContext, unloadState?: ITelemetryUnloadState) => void | boolean;
         /**
-         * Clears back off for transmission.
+         * Flush to send data immediately; channel should default to sending data asynchronously. If executing asynchronously and
+         * you DO NOT pass a callback function then a [IPromise](https://nevware21.github.io/ts-async/typedoc/interfaces/IPromise.html)
+         * will be returned which will resolve once the flush is complete. The actual implementation of the `IPromise`
+         * will be a native Promise (if supported) or the default as supplied by [ts-async library](https://github.com/nevware21/ts-async)
+         * @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 - If a callback is provided `true` to indicate that callback will be called after the flush is complete otherwise the caller
+         * should assume that any provided callback will never be called, Nothing or if occurring asynchronously a
+         * [IPromise](https://nevware21.github.io/ts-async/typedoc/interfaces/IPromise.html) which will be resolved once the unload is complete,
+         * the [IPromise](https://nevware21.github.io/ts-async/typedoc/interfaces/IPromise.html) will only be returned when no callback is provided
+         * and async is true.
          */
-        _clearBackOff(): void;
+        flush?(async: boolean, callBack?: (flushComplete?: boolean) => void, sendReason?: SendRequestReason): boolean | void | IPromise<boolean>;
         /**
-         * Add handler to be executed with request response text.
+         * Get offline support
+         * @returns IInternalOfflineSupport
          */
-        addResponseHandler(responseHandler: (responseText: string) => void): IUnloadHook;
+        getOfflineSupport?: () => IInternalOfflineSupport;
     }
 
-    
-    /**
-     * Near Real Time profile. RealTime Latency events are sent every 3 sec and
-     * Normal Latency events are sent every 6 sec.
-     */
-    const NRT_PROFILE = "NEAR_REAL_TIME";
-
-    
-    /**
-     * Defines the function signature of a payload listener, which is called after the payload has been sent to the server. The listener is passed
-     * both the initial payload object and any altered (modified) payload from a preprocessor so it can determine what payload it may want to log or send.
-     * Used by the Remove DDV extension to listen to server send events.
-     * @param orgPayload - The initially constructed payload object
-     * @param sendPayload - The alternative (possibly modified by a preprocessor) payload
-     * @param isSync - A boolean flag indicating whether this request was initiated as part of a sync response (unload / flush request), this is for informative only.
-     * @param isBeaconSend - A boolean flag indicating whether the payload was sent using the navigator.sendBeacon() API.
-     */
-    type PayloadListenerFunction = (orgPayload: IPayloadData, sendPayload?: IPayloadData, isSync?: boolean, isBeaconSend?: boolean) => void;
-
     /**
-     * Defines the function signature for the Payload Preprocessor.
-     * @param payload - The Initial constructed payload that if not modified should be passed onto the callback function.
-     * @param callback - The preprocessor MUST call the callback function to ensure that the events are sent to the server, failing to call WILL result in dropped events.
-     * The modifiedBuffer argument can be either the original payload or may be modified by performing GZipping of the payload and adding the content header.
-     * @param isSync - A boolean flag indicating whether this request was initiated as part of a sync response (unload / flush request), this is for informative only.
-     * e.g the preprocessor may wish to not perform any GZip operations if the request was a sync request which is normally called as part of an unload request.
+     * The type to identify whether the default value should be applied in preference to the provided value.
      */
-    type PayloadPreprocessorFunction = (payload: IPayloadData, callback: (modifiedBuffer: IPayloadData) => void, isSync?: boolean) => void;
+    type IConfigCheckFn<V> = (value: V) => boolean;
 
     /**
-     * Class that manages adding events to inbound queues and batching of events
-     * into requests.
-     * @group Classes
-     * @group Entrypoint
+     * The default values with a check function
      */
-    class PostChannel extends BaseTelemetryPlugin implements IChannelControls, IPostChannel {
-        identifier: string;
-        priority: number;
-        version: string;
-        constructor();
+    interface IConfigDefaultCheck<T, V, C = IConfiguration> {
         /**
-         * Start the queue manager to batch and send events via post.
-         * @param config - The core configuration.
+         * Callback function to check if the user-supplied value is valid, if not the default will be applied
          */
-        initialize(coreConfig: IExtendedConfiguration, core: IAppInsightsCore, extensions: IPlugin[]): void;
+        isVal?: IConfigCheckFn<V>;
         /**
-         * Add an event to the appropriate inbound queue based on its latency.
-         * @param ev - The event to be added to the queue.
-         * @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)
+         * Optional function to allow converting and setting of the default value
          */
-        processTelemetry(ev: ITelemetryItem, itemCtx?: IProcessTelemetryContext): void;
+        set?: IConfigSetFn<T, V>;
         /**
-         * Sets the event queue limits at runtime (after initialization), if the number of queued events is greater than the
-         * eventLimit or autoFlushLimit then a flush() operation will be scheduled.
-         * @param eventLimit The number of events that can be kept in memory before the SDK starts to drop events. If the value passed is less than or
-         * equal to zero the value will be reset to the default (10,000).
-         * @param autoFlushLimit When defined, once this number of events has been queued the system perform a flush() to send the queued events
-         * without waiting for the normal schedule timers. Passing undefined, null or a value less than or equal to zero will disable the auto flush.
+         * The default value to apply if the user-supplied value is not valid
          */
-        setEventQueueLimits(eventLimit: number, autoFlushLimit?: number): void;
+        v?: V | IConfigDefaults<V, T>;
         /**
-         * Pause the transmission of any requests
+         *  The default fallback key if the main key is not present, this is the key value from the config
          */
-        pause(): void;
+        fb?: keyof T | keyof C | Array<keyof T | keyof C>;
         /**
-         * Resumes transmission of events.
+         * Use this check to determine the default fallback, default only checked whether the property isDefined,
+         * therefore `null`; `""` are considered to be valid values.
          */
-        resume(): void;
+        dfVal?: (value: any) => boolean;
         /**
-         * Add handler to be executed with request response text.
+         * Specify that any provided value should have the default value(s) merged into the value rather than
+         * just using either the default of user provided values. Mergeed objects will automatically be marked
+         * as referenced.
          */
-        addResponseHandler(responseHanlder: (responseText: string) => void): IUnloadHook;
+        mrg?: boolean;
         /**
-         * Flush to send data immediately; channel should default to sending data asynchronously. If executing asynchronously (the default) and
-         * you DO NOT pass a callback function then a [IPromise](https://nevware21.github.io/ts-async/typedoc/interfaces/IPromise.html)
-         * will be returned which will resolve once the flush is complete. The actual implementation of the `IPromise`
-         * will be a native Promise (if supported) or the default as supplied by [ts-async library](https://github.com/nevware21/ts-async)
-         * @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 - If a callback is provided `true` to indicate that callback will be called after the flush is complete otherwise the caller
-         * should assume that any provided callback will never be called, Nothing or if occurring asynchronously a
-         * [IPromise](https://nevware21.github.io/ts-async/typedoc/interfaces/IPromise.html) which will be resolved once the unload is complete,
-         * the [IPromise](https://nevware21.github.io/ts-async/typedoc/interfaces/IPromise.html) will only be returned when no callback is provided
-         * and async is true.
+         * Set this field of the target as referenced, which will cause any object or array instance
+         * to be updated in-place rather than being entirely replaced. All other values will continue to be replaced.
+         * This is required for nested default objects to avoid multiple repetitive updates to listeners
+         * @returns The referenced properties current value
          */
-        flush(async?: boolean, callBack?: (flushComplete?: boolean) => void, sendReason?: SendRequestReason): boolean | void | IPromise<boolean>;
+        ref?: boolean;
         /**
-         * Set AuthMsaDeviceTicket header
-         * @param ticket - Ticket value.
+         * Set this field of the target as read-only, which will block this single named property from
+         * ever being changed for the target instance.
+         * This does NOT freeze or seal the instance, it just stops the direct re-assignment of the named property,
+         * if the value is a non-primitive (ie. an object or array) it's properties will still be mutable.
+         * @returns The referenced properties current value
          */
-        setMsaAuthTicket(ticket: string): void;
+        rdOnly?: boolean;
         /**
-         * Set setAuthPluginHeader header
-         * @param token - token value.
+         * Block the value associated with this property from having it's properties / values converted into
+         * dynamic properties, this is generally used to block objects or arrays provided by external libraries
+         * which may be a plain object with readonly (non-configurable) or const properties.
          */
-        setAuthPluginHeader(token: string): void;
+        blkVal?: boolean;
+    }
+
+    /**
+     * The Type definition to define default values to be applied to the config
+     * The value may be either the direct value or a ConfigDefaultCheck definition
+     */
+    type IConfigDefaults<T, C = IConfiguration> = {
+        [key in keyof T]: T[key] | IConfigDefaultCheck<T, T[key], C>;
+    };
+
+    /**
+     * The type which identifies the function use to validate the user supplied value
+     */
+    type IConfigSetFn<T, V> = (value: any, defValue: V, theConfig: T) => V;
+
+    /**
+     * Configuration provided to SDK core
+     */
+    interface IConfiguration {
         /**
-         * remove AuthPlugin Header
-         * @param token - token value.
+         * Instrumentation key of resource. Either this or connectionString must be specified.
+         */
+        instrumentationKey?: string;
+        /**
+         * Connection string of resource. Either this or instrumentationKey must be specified.
+         */
+        connectionString?: string;
+        /**
+         * Set the timer interval (in ms) for internal logging queue, this is the
+         * amount of time to wait after logger.queue messages are detected to be sent.
+         * Note: since 3.0.1 and 2.8.13 the diagnostic logger timer is a normal timeout timer
+         * and not an interval timer. So this now represents the timer "delay" and not
+         * the frequency at which the events are sent.
+         */
+        diagnosticLogInterval?: number;
+        /**
+         * Maximum number of iKey transmitted logging telemetry per page view
+         */
+        maxMessageLimit?: number;
+        /**
+         * Console logging level. All logs with a severity level higher
+         * than the configured level will be printed to console. Otherwise
+         * they are suppressed. ie Level 2 will print both CRITICAL and
+         * WARNING logs to console, level 1 prints only CRITICAL.
+         *
+         * Note: Logs sent as telemetry to instrumentation key will also
+         * be logged to console if their severity meets the configured loggingConsoleLevel
+         *
+         * 0: ALL console logging off
+         * 1: logs to console: severity >= CRITICAL
+         * 2: logs to console: severity >= WARNING
+         */
+        loggingLevelConsole?: number;
+        /**
+         * Telemtry logging level to instrumentation key. All logs with a severity
+         * level higher than the configured level will sent as telemetry data to
+         * the configured instrumentation key.
+         *
+         * 0: ALL iKey logging off
+         * 1: logs to iKey: severity >= CRITICAL
+         * 2: logs to iKey: severity >= WARNING
+         */
+        loggingLevelTelemetry?: number;
+        /**
+         * If enabled, uncaught exceptions will be thrown to help with debugging
+         */
+        enableDebug?: boolean;
+        /**
+         * Endpoint where telemetry data is sent
+         */
+        endpointUrl?: string;
+        /**
+         * Extension configs loaded in SDK
+         */
+        extensionConfig?: {
+            [key: string]: any;
+        };
+        /**
+         * Additional plugins that should be loaded by core at runtime
+         */
+        readonly extensions?: ITelemetryPlugin[];
+        /**
+         * Channel queues that is setup by caller in desired order.
+         * If channels are provided here, core will ignore any channels that are already setup, example if there is a SKU with an initialized channel
+         */
+        readonly channels?: IChannelControls[][];
+        /**
+         * @type {boolean}
+         * Flag that disables the Instrumentation Key validation.
+         */
+        disableInstrumentationKeyValidation?: boolean;
+        /**
+         * [Optional] When enabled this will create local perfEvents based on sections of the code that have been instrumented
+         * to emit perfEvents (via the doPerf()) when this is enabled. This can be used to identify performance issues within
+         * the SDK, the way you are using it or optionally your own instrumented code.
+         * The provided IPerfManager implementation does NOT send any additional telemetry events to the server it will only fire
+         * the new perfEvent() on the INotificationManager which you can listen to.
+         * This also does not use the window.performance API, so it will work in environments where this API is not supported.
+         */
+        enablePerfMgr?: boolean;
+        /**
+         * [Optional] Callback function that will be called to create a the IPerfManager instance when required and ```enablePerfMgr```
+         * is enabled, this enables you to override the default creation of a PerfManager() without needing to ```setPerfMgr()```
+         * after initialization.
+         */
+        createPerfMgr?: (core: IAppInsightsCore, notificationManager: INotificationManager) => IPerfManager;
+        /**
+         * [Optional] Fire every single performance event not just the top level root performance event. Defaults to false.
+         */
+        perfEvtsSendAll?: boolean;
+        /**
+         * [Optional] Identifies the default length used to generate random session and user id's if non currently exists for the user / session.
+         * Defaults to 22, previous default value was 5, if you need to keep the previous maximum length you should set this value to 5.
+         */
+        idLength?: number;
+        /**
+         * @description Custom cookie domain. This is helpful if you want to share Application Insights cookies across subdomains. It
+         * can be set here or as part of the cookieCfg.domain, the cookieCfg takes precedence if both are specified.
+         * @type {string}
+         * @defaultValue ""
+         */
+        cookieDomain?: string;
+        /**
+         * @description Custom cookie path. This is helpful if you want to share Application Insights cookies behind an application
+         * gateway. It can be set here or as part of the cookieCfg.domain, the cookieCfg takes precedence if both are specified.
+         * @type {string}
+         * @defaultValue ""
+         */
+        cookiePath?: string;
+        /**
+         * [Optional] A boolean that indicated whether to disable the use of cookies by the SDK. If true, the SDK will not store or
+         * read any data from cookies. Cookie usage can be re-enabled after initialization via the core.getCookieMgr().enable().
+         */
+        disableCookiesUsage?: boolean;
+        /**
+         * [Optional] A Cookie Manager configuration which includes hooks to allow interception of the get, set and delete cookie
+         * operations. If this configuration is specified any specified enabled and domain properties will take precedence over the
+         * cookieDomain and disableCookiesUsage values.
+         */
+        cookieCfg?: ICookieMgrConfig;
+        /**
+         * [Optional] An array of the page unload events that you would like to be ignored, special note there must be at least one valid unload
+         * event hooked, if you list all or the runtime environment only supports a listed "disabled" event it will still be hooked, if required by the SDK.
+         * Unload events include "beforeunload", "unload", "visibilitychange" (with 'hidden' state) and "pagehide"
+         */
+        disablePageUnloadEvents?: string[];
+        /**
+         * [Optional] An array of page show events that you would like to be ignored, special note there must be at lease one valid show event
+         * hooked, if you list all or the runtime environment only supports a listed (disabled) event it will STILL be hooked, if required by the SDK.
+         * Page Show events include "pageshow" and "visibilitychange" (with 'visible' state)
+         */
+        disablePageShowEvents?: string[];
+        /**
+         * [Optional] A flag for performance optimization to disable attempting to use the Chrome Debug Extension, if disabled and the extension is installed
+         * this will not send any notifications.
+         */
+        disableDbgExt?: boolean;
+        /**
+         * Add "&w=0" parameter to support UA Parsing when web-workers don't have access to Document.
+         * Default is false
+         */
+        enableWParam?: boolean;
+        /**
+         * Custom optional value that will be added as a prefix for storage name.
+         * @defaultValue undefined
+         */
+        storagePrefix?: string;
+        /**
+         * Custom optional value to opt in features
+         * @defaultValue undefined
+         */
+        featureOptIn?: IFeatureOptIn;
+    }
+
+    interface ICookieMgr {
+        /**
+         * Enable or Disable the usage of cookies
+         */
+        setEnabled(value: boolean): void;
+        /**
+         * Can the system use cookies, if this returns false then all cookie setting and access functions will return nothing
+         */
+        isEnabled(): boolean;
+        /**
+         * Set the named cookie with the value and optional domain and optional
+         * @param name - The name of the cookie
+         * @param value - The value of the cookie (Must already be encoded)
+         * @param maxAgeSec - [optional] The maximum number of SECONDS that this cookie should survive
+         * @param domain - [optional] The domain to set for the cookie
+         * @param path - [optional] Path to set for the cookie, if not supplied will default to "/"
+         * @returns - True if the cookie was set otherwise false (Because cookie usage is not enabled or available)
+         */
+        set(name: string, value: string, maxAgeSec?: number, domain?: string, path?: string): boolean;
+        /**
+         * Get the value of the named cookie
+         * @param name - The name of the cookie
+         */
+        get(name: string): string;
+        /**
+         * Delete/Remove the named cookie if cookie support is available and enabled.
+         * Note: Not using "delete" as the name because it's a reserved word which would cause issues on older browsers
+         * @param name - The name of the cookie
+         * @param path - [optional] Path to set for the cookie, if not supplied will default to "/"
+         * @returns - True if the cookie was marked for deletion otherwise false (Because cookie usage is not enabled or available)
+         */
+        del(name: string, path?: string): boolean;
+        /**
+         * Purge the cookie from the system if cookie support is available, this function ignores the enabled setting of the manager
+         * so any cookie will be removed.
+         * Note: Not using "delete" as the name because it's a reserved word which would cause issues on older browsers
+         * @param name - The name of the cookie
+         * @param path - [optional] Path to set for the cookie, if not supplied will default to "/"
+         * @returns - True if the cookie was marked for deletion otherwise false (Because cookie usage is not available)
+         */
+        purge(name: string, path?: string): boolean;
+        /**
+         * Optional Callback hook to allow the cookie manager to update it's configuration, not generally implemented now that
+         * dynamic configuration is supported
+         * @param updateState
+         */
+        update?(updateState: ITelemetryUpdateState): void;
+        /**
+         * Unload and remove any state that this ICookieMgr may be holding, this is generally called when the
+         * owning SDK is being unloaded.
+         * @param isAsync - Can the unload be performed asynchronously (default)
+         * @return If the unload occurs synchronously then nothing should be returned, if happening asynchronously then
+         * the function should return an [IPromise](https://nevware21.github.io/ts-async/typedoc/interfaces/IPromise.html)
+         * / Promise to allow any listeners to wait for the operation to complete.
+         */
+        unload?(isAsync?: boolean): void | IPromise<void>;
+    }
+
+    /**
+     * Configuration definition for instance based cookie management configuration
+     */
+    interface ICookieMgrConfig {
+        /**
+         * Defaults to true, A boolean that indicates whether the use of cookies by the SDK is enabled by the current instance.
+         * If false, the instance of the SDK initialized by this configuration will not store or read any data from cookies
+         */
+        enabled?: boolean;
+        /**
+         * Custom cookie domain. This is helpful if you want to share Application Insights cookies across subdomains.
+         */
+        domain?: string;
+        /**
+         * Specifies the path to use for the cookie, defaults to '/'
+         */
+        path?: string;
+        /**
+         * Specify the cookie name(s) to be ignored, this will cause any matching cookie name to never be read or written.
+         * They may still be explicitly purged or deleted. You do not need to repeat the name in the `blockedCookies`
+         * configuration.(Since v2.8.8)
+         */
+        ignoreCookies?: string[];
+        /**
+         * Specify the cookie name(s) to never be written, this will cause any cookie name to never be created or updated,
+         * they will still be read unless also included in the ignoreCookies and may still be explicitly purged or deleted.
+         * If not provided defaults to the same list provided in ignoreCookies. (Since v2.8.8)
+         */
+        blockedCookies?: string[];
+        /**
+         * Hook function to fetch the named cookie value.
+         * @param name - The name of the cookie
+         */
+        getCookie?: (name: string) => string;
+        /**
+         * Hook function to set the named cookie with the specified value.
+         * @param name - The name of the cookie
+         * @param value - The value to set for the cookie
+         */
+        setCookie?: (name: string, value: string) => void;
+        /**
+         * Hook function to delete the named cookie with the specified value, separated from
+         * setCookie to avoid the need to parse the value to determine whether the cookie is being
+         * added or removed.
+         * @param name - The name of the cookie
+         * @param cookieValue - The value to set to expire the cookie
+         */
+        delCookie?: (name: string, cookieValue: string) => void;
+    }
+
+    interface ICustomProperties {
+        [key: string]: any;
+    }
+
+    interface IDiagnosticLogger {
+        /**
+         * 0: OFF
+         * 1: only critical (default)
+         * 2: critical + info
+         */
+        consoleLoggingLevel: () => number;
+        /**
+         * The internal logging queue
+         */
+        queue: _InternalLogMessage[];
+        /**
+         * This method will throw exceptions in debug mode or attempt to log the error as a console warning.
+         * @param severity - The severity of the log message
+         * @param message - The log message.
+         */
+        throwInternal(severity: LoggingSeverity, msgId: _InternalMessageId, msg: string, properties?: Object, isUserAct?: boolean): void;
+        /**
+         * This will write a debug message to the console if possible
+         * @param message - {string} - The debug message
+         */
+        debugToConsole?(message: string): void;
+        /**
+         * This will write a warning to the console if possible
+         * @param message - The warning message
+         */
+        warnToConsole(message: string): void;
+        /**
+         * This will write an error to the console if possible.
+         * Provided by the default DiagnosticLogger instance, and internally the SDK will fall back to warnToConsole, however,
+         * direct callers MUST check for its existence on the logger as you can provide your own IDiagnosticLogger instance.
+         * @param message - The error message
+         */
+        errorToConsole?(message: string): void;
+        /**
+         * Resets the internal message count
+         */
+        resetInternalMessageCount(): void;
+        /**
+         * Logs a message to the internal queue.
+         * @param severity - The severity of the log message
+         * @param message - The message to log.
+         */
+        logInternalMessage?(severity: LoggingSeverity, message: _InternalLogMessage): void;
+        /**
+         * Optional Callback hook to allow the diagnostic logger to update it's configuration
+         * @param updateState
+         */
+        update?(updateState: ITelemetryUpdateState): void;
+        /**
+         * Unload and remove any state that this IDiagnosticLogger may be holding, this is generally called when the
+         * owning SDK is being unloaded.
+         * @param isAsync - Can the unload be performed asynchronously (default)
+         * @return If the unload occurs synchronously then nothing should be returned, if happening asynchronously then
+         * the function should return an [IPromise](https://nevware21.github.io/ts-async/typedoc/interfaces/IPromise.html)
+         * / Promise to allow any listeners to wait for the operation to complete.
+         */
+        unload?(isAsync?: boolean): void | IPromise<void>;
+    }
+
+    interface IDistributedTraceContext {
+        /**
+         * Returns the current name of the page
+         */
+        getName(): string;
+        /**
+         * Sets the current name of the page
+         * @param pageName
+         */
+        setName(pageName: string): void;
+        /**
+         * Returns the unique identifier for a trace. All requests / spans from the same trace share the same traceId.
+         * Must be read from incoming headers or generated according to the W3C TraceContext specification,
+         * in a hex representation of 16-byte array. A.k.a. trace-id, TraceID or Distributed TraceID
+         */
+        getTraceId(): string;
+        /**
+         * Set the unique identifier for a trace. All requests / spans from the same trace share the same traceId.
+         * Must be conform to the W3C TraceContext specification, in a hex representation of 16-byte array.
+         * A.k.a. trace-id, TraceID or Distributed TraceID https://www.w3.org/TR/trace-context/#trace-id
+         */
+        setTraceId(newValue: string): void;
+        /**
+         * Self-generated 8-bytes identifier of the incoming request. Must be a hex representation of 8-byte array.
+         * Also know as the parentId, used to link requests together
+         */
+        getSpanId(): string;
+        /**
+         * Self-generated 8-bytes identifier of the incoming request. Must be a hex representation of 8-byte array.
+         * Also know as the parentId, used to link requests together
+         * https://www.w3.org/TR/trace-context/#parent-id
+         */
+        setSpanId(newValue: string): void;
+        /**
+         * An integer representation of the W3C TraceContext trace-flags.
+         */
+        getTraceFlags(): number | undefined;
+        /**
+         * https://www.w3.org/TR/trace-context/#trace-flags
+         * @param newValue
+         */
+        setTraceFlags(newValue?: number): void;
+    }
+
+    /**
+     * An interface used to create an event property value along with tagging it as PII, or customer content.
+     * <b>Caution:</b> Customer content and PII are mutually exclusive. You can use only one of them at a time.
+     * If you use both, then the property will be considered invalid, and therefore won't be sent.
+     */
+    interface IEventProperty {
+        /**
+         * The value for the property.
+         */
+        value: string | number | boolean | string[] | number[] | boolean[];
+        /**
+         * [Optional] The value kind associated with property value. The constant enum ValueKind should be used to specify the
+         * different kinds.
+         */
+        kind?: number;
+        /**
+         * [Optional] The data type for the property. Valid values accepted by onecollector are
+         * "string", "bool", "double", "int64", "datetime", "guid".
+         *  The EventPropertyType constant enum should be used to specify the different property type values.
+         */
+        propertyType?: number;
+    }
+
+    /**
+     * The IExtendedConfiguration interface holds the configuration details passed to core during initialize.
+     */
+    interface IExtendedConfiguration extends IConfiguration {
+        /**
+         * [Optional] The property storage override that should be used to store
+         * internal SDK properties, otherwise stored as cookies. It is needed where cookies are not available.
+         */
+        propertyStorageOverride?: IPropertyStorageOverride;
+        /**
+         * [Optional] A boolean that indicated whether to disable the use of cookies by the 1DS Web SDK. The cookies added by the SDK are
+         * MicrosoftApplicationsTelemetryDeviceId. If cookies are disabled, then session events are not sent unless propertyStorageOverride
+         * is provided to store the values elsewhere.
+         */
+        disableCookiesUsage?: boolean;
+        /**
+         * [Optional] Name of the Anon cookie.  The value will be set in the qsp header to collector requests.  Collector will use this value to look for specific cookie to use for anid property.
+         */
+        anonCookieName?: string;
+        /**
+         * [Optional] Disables additional internal event timings that are added during processing of events, the timings are not sent as part telemetry items to the server
+         */
+        disableEventTimings?: boolean;
+        /**
+         * [Optional] Enables support for objects with compound keys which indirectly represent an object where the "key" of the object contains a "." as part of it's name.
+         * @example
+         * ```typescript
+         * event: { "somedata.embeddedvalue": 123 }
+         * ```
+         */
+        enableCompoundKey?: boolean;
+        /**
+         * Add "&w=0" parameter to support UA Parsing when web-workers don't have access to Document.
+         * Default is false
+         */
+        enableWParam?: boolean;
+    }
+
+    interface IFeatureOptIn {
+        [feature: string]: IFeatureOptInDetails;
+    }
+
+    interface IFeatureOptInDetails {
+        /**
+         * sets feature opt-in mode
+         * @default undefined
+         */
+        mode?: FeatureOptInMode;
+        /**
+         * Identifies configuration override values when given feature is enabled
+         * NOTE: should use flat string for fields, for example, if you want to set value for extensionConfig.Ananlytics.disableAjaxTrackig in configurations,
+         * you should use "extensionConfig.Ananlytics.disableAjaxTrackig" as field name: {["extensionConfig.Analytics.disableAjaxTrackig"]:1}
+         * Default: undefined
+         */
+        onCfg?: {
+            [field: string]: any;
+        };
+        /**
+         * Identifies configuration override values when given feature is disabled
+         * NOTE: should use flat string for fields, for example, if you want to set value for extensionConfig.Ananlytics.disableAjaxTrackig in configurations,
+         * you should use "extensionConfig.Ananlytics.disableAjaxTrackig" as field name: {["extensionConfig.Analytics.disableAjaxTrackig"]:1}
+         * Default: undefined
+         */
+        offCfg?: {
+            [field: string]: any;
+        };
+        /**
+         * define if should block any changes from cdn cfg, if set to true, cfgValue will be applied under all scenarios
+         * @default false
+         */
+        blockCdnCfg?: boolean;
+    }
+
+    /**
+     * This interface defines the object that is passed to any provided FieldValueSanitizerFunc, it provides not only the value to be sanitized but also
+     * some context about the value like it's location within the envelope (serialized object), the format is defined via the
+     * [Common Schema 4.0](https://aka.ms/CommonSchema) specification.
+     */
+    interface IFieldSanitizerDetails {
+        /**
+         * The path within the event where the value is stored
+         */
+        path: string;
+        /**
+         * The name of the field with the event path that will store the value
+         */
+        name: string;
+        /**
+         * Identifies the type of the property value
+         */
+        type: FieldValueSanitizerType;
+        /**
+         * The value for the property.
+         */
+        prop: IEventProperty;
+        /**
+         * A reference to the value sanitizer that created the details
+         */
+        sanitizer: IValueSanitizer;
+    }
+
+    /**
+     * This interface is used during the serialization of individual fields when converting the events into envelope (serialized object) which is sent to the services,
+     * the format is defined via the [Common Schema 4.0](https://aka.ms/CommonSchema) specification. The path and field names used are based
+     * on how the data is serialized to the service (CS 4.0 location) and not specifically the location on the event object you pass into the track methods (unless they are the same).
+     */
+    interface IFieldValueSanitizerProvider {
+        /**
+         * Does this field value sanitizer handle this path / field combination
+         * @param path - The field path
+         * @param name - The name of the field
+         */
+        handleField(path: string, name: string): boolean;
+        /**
+         * Get the field sanitizer for this type of field based on the field type, value kind and/or event property type
+         * @param path - The field path
+         * @param name - The name of the field
+         * @param theType - The type of field
+         * @param theKind - The value kind of the field
+         * @param propType - The property type of the field
+         */
+        getSanitizer(path: string, name: string, theType: FieldValueSanitizerType, theKind?: number, propType?: number): FieldValueSanitizerFunc | null | undefined;
+    }
+
+    /**
+     * Internal Interface
+     */
+    interface IInternalOfflineSupport {
+        /**
+         * Get current endpoint url
+         * @returns endpoint
+         */
+        getUrl: () => string;
+        /**
+         * Create payload data
+         * @param data data
+         * @returns IPayloadData
+         */
+        createPayload: (data: string | Uint8Array) => IPayloadData;
+        /**
+         * Serialize an item into a string
+         * @param input telemetry item
+         * @param convertUndefined convert undefined to a custom-defined object
+         * @returns Serialized string
+         */
+        serialize?: (input: ITelemetryItem, convertUndefined?: any) => string;
+        /**
+         * Batch an array of strings into one string
+         * @param arr array of strings
+         * @returns a string represent all items in the given array
+         */
+        batch?: (arr: string[]) => string;
+        /**
+         * If the item should be processed by offline channel
+         * @param evt telemetry item
+         * @returns should process or not
+         */
+        shouldProcess?: (evt: ITelemetryItem) => boolean;
+    }
+
+    /**
+     * An alternate interface which provides automatic removal during unloading of the component
+     */
+    interface ILegacyUnloadHook {
+        /**
+         * Legacy Self remove the referenced component
+         */
+        remove: () => void;
+    }
+
+    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;
+    }
+
+    /**
+     * An interface used for the notification listener.
+     * @interface
+     */
+    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;
+        /**
+         * Unload and remove any state that this INotificationListener may be holding, this is generally called when the
+         * owning Manager is being unloaded.
+         * @param isAsync - Can the unload be performed asynchronously (default)
+         * @return If the unload occurs synchronously then nothing should be returned, if happening asynchronously then
+         * the function should return an [IPromise](https://nevware21.github.io/ts-async/typedoc/interfaces/IPromise.html)
+         * / Promise to allow any listeners to wait for the operation to complete.
+         */
+        unload?(isAsync?: boolean): void | IPromise<void>;
+    }
+
+    /**
+     * Class to manage sending notifications to all the listeners.
+     */
+    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;
+        /**
+         * Unload and remove any state that this INotificationManager may be holding, this is generally called when the
+         * owning SDK is being unloaded.
+         * @param isAsync - Can the unload be performed asynchronously (default)
+         * @return If the unload occurs synchronously then nothing should be returned, if happening asynchronously then
+         * the function should return an [IPromise](https://nevware21.github.io/ts-async/typedoc/interfaces/IPromise.html)
+         * / Promise to allow any listeners to wait for the operation to complete.
+         */
+        unload?(isAsync?: boolean): void | IPromise<void>;
+    }
+
+    class _InternalLogMessage {
+        static dataType: string;
+        message: string;
+        messageId: _InternalMessageId;
+        constructor(msgId: _InternalMessageId, msg: string, isUserAct?: boolean, properties?: Object);
+    }
+
+    type _InternalMessageId = number | _eInternalMessageId;
+
+    /** IPayloadData describes interface of payload sent via POST channel */
+    interface IPayloadData {
+        urlString: string;
+        data: Uint8Array | string;
+        headers?: {
+            [name: string]: string;
+        };
+        timeout?: number;
+        disableXhrSync?: boolean;
+        disableFetchKeepAlive?: boolean;
+        sendReason?: SendRequestReason;
+    }
+
+    /**
+     * This interface identifies the details of an internal performance event - it does not represent an outgoing reported event
+     */
+    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;
+    }
+
+    /**
+     * 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.
+     */
+    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;
+    }
+
+    /**
+     * Identifies an interface to a host that can provide an IPerfManager implementation
+     */
+    interface IPerfManagerProvider {
+        /**
+         * Get the current performance manager
+         */
+        getPerfMgr(): IPerfManager;
+        /**
+         * Set the current performance manager
+         * @param perfMgr - The performance manager
+         */
+        setPerfMgr(perfMgr: IPerfManager): void;
+    }
+
+    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;
+    }
+
+    /**
+     * Post channel interface
+     */
+    interface IPostChannel extends ITelemetryPlugin {
+        /**
+         * Diagnostic logger
+         */
+        diagLog: (itemCtx?: IProcessTelemetryContext) => IDiagnosticLogger;
+        /**
+         * Override for setTimeout
+         */
+        _setTimeoutOverride?: (callback: (...args: any[]) => void, ms: number, ...args: any[]) => any;
+        /**
+         * Backs off transmission. This exponentially increases all the timers.
+         */
+        _backOffTransmission(): void;
+        /**
+         * Clears back off for transmission.
+         */
+        _clearBackOff(): void;
+        /**
+         * Add handler to be executed with request response text.
+         */
+        addResponseHandler(responseHandler: (responseText: string) => void): IUnloadHook;
+    }
+
+    /**
+     * The current context for the current call to processTelemetry(), used to support sharing the same plugin instance
+     * between multiple AppInsights instances
+     */
+    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.
+     */
+    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.
+     */
+    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;
+    }
+
+    /**
+     * Create a Promise object that represents the eventual completion (or failure) of an asynchronous operation and its resulting value.
+     * This interface definition, closely mirrors the typescript / javascript PromiseLike<T> and Promise<T> definitions as well as providing
+     * simular functions as that provided by jQuery deferred objects.
+     *
+     * The returned Promise is a proxy for a value not necessarily known when the promise is created. It allows you to associate handlers
+     * with an asynchronous action's eventual success value or failure reason. This lets asynchronous methods return values like synchronous
+     * methods: instead of immediately returning the final value, the asynchronous method returns a promise to supply the value at some point
+     * in the future.
+     *
+     * A Promise is in one of these states:
+     * <ul>
+     * <li> pending: initial state, neither fulfilled nor rejected.
+     * <li> fulfilled: meaning that the operation was completed successfully.
+     * <li> rejected: meaning that the operation failed.
+     * </ul>
+     *
+     * A pending promise can either be fulfilled with a value or rejected with a reason (error). When either of these options happens, the
+     * associated handlers queued up by a promise's then method are called synchronously. If the promise has already been fulfilled or rejected
+     * when a corresponding handler is attached, the handler will be called synchronously, so there is no race condition between an asynchronous
+     * operation completing and its handlers being attached.
+     *
+     * As the `then()` and `catch()` methods return promises, they can be chained.
+     * @typeParam T - Identifies the expected return type from the promise
+     */
+    interface IPromise<T> extends PromiseLike<T>, Promise<T> {
+        /**
+         * Returns a string representation of the current state of the promise. The promise can be in one of four states.
+         * <ul>
+         * <li> <b>"pending"</b>: The promise is not yet in a completed state (neither "rejected"; or "resolved").</li>
+         * <li> <b>"resolved"</b>: The promise is in the resolved state.</li>
+         * <li> <b>"rejected"</b>: The promise is in the rejected state.</li>
+         * </ul>
+         * @example
+         * ```ts
+         * let doResolve;
+         * let promise: IPromise<any> = createSyncPromise((resolve) => {
+         *  doResolve = resolve;
+         * });
+         *
+         * let state: string = promise.state();
+         * console.log("State: " + state);      // State: pending
+         * doResolve(true);                     // Promise will resolve synchronously as it's a synchronous promise
+         * console.log("State: " + state);      // State: resolved
+         * ```
+         */
+        state?: string;
+        /**
+         * Attaches callbacks for the resolution and/or rejection of the Promise.
+         * @param onResolved The callback to execute when the Promise is resolved.
+         * @param onRejected The callback to execute when the Promise is rejected.
+         * @returns A Promise for the completion of which ever callback is executed.
+         * @example
+         * ```ts
+         * const promise1 = createPromise((resolve, reject) => {
+         *   resolve('Success!');
+         * });
+         *
+         * promise1.then((value) => {
+         *   console.log(value);
+         *   // expected output: "Success!"
+         * });
+         * ```
+         */
+        then<TResult1 = T, TResult2 = never>(onResolved?: ResolvedPromiseHandler<T, TResult1>, onRejected?: RejectedPromiseHandler<TResult2>): IPromise<TResult1 | TResult2>;
+        /**
+         * Attaches callbacks for the resolution and/or rejection of the Promise.
+         * @param onResolved The callback to execute when the Promise is resolved.
+         * @param onRejected The callback to execute when the Promise is rejected.
+         * @returns A Promise for the completion of which ever callback is executed.
+         * @example
+         * ```ts
+         * const promise1 = createPromise((resolve, reject) => {
+         *   resolve('Success!');
+         * });
+         *
+         * promise1.then((value) => {
+         *   console.log(value);
+         *   // expected output: "Success!"
+         * });
+         * ```
+         */
+        then<TResult1 = T, TResult2 = never>(onResolved?: ResolvedPromiseHandler<T, TResult1>, onRejected?: RejectedPromiseHandler<TResult2>): PromiseLike<TResult1 | TResult2>;
+        /**
+         * Attaches callbacks for the resolution and/or rejection of the Promise.
+         * @param onResolved The callback to execute when the Promise is resolved.
+         * @param onRejected The callback to execute when the Promise is rejected.
+         * @returns A Promise for the completion of which ever callback is executed.
+         * @example
+         * ```ts
+         * const promise1 = createPromise((resolve, reject) => {
+         *   resolve('Success!');
+         * });
+         *
+         * promise1.then((value) => {
+         *   console.log(value);
+         *   // expected output: "Success!"
+         * });
+         * ```
+         */
+        then<TResult1 = T, TResult2 = never>(onResolved?: ResolvedPromiseHandler<T, TResult1>, onRejected?: RejectedPromiseHandler<TResult2>): Promise<TResult1 | TResult2>;
+        /**
+         * Attaches a callback for only the rejection of the Promise.
+         * @param onRejected The callback to execute when the Promise is rejected.
+         * @returns A Promise for the completion of the callback.
+         * @example
+         * ```ts
+         * const promise1 = createPromise((resolve, reject) => {
+         *   throw 'Uh-oh!';
+         * });
+         *
+         * promise1.catch((error) => {
+         *   console.error(error);
+         * });
+         * // expected output: Uh-oh!
+         * ```
+         */
+        catch<TResult = never>(onRejected?: ((reason: any) => TResult | IPromise<TResult>) | undefined | null): IPromise<T | TResult>;
+        /**
+         * Attaches a callback for only the rejection of the Promise.
+         * @param onRejected The callback to execute when the Promise is rejected.
+         * @returns A Promise for the completion of the callback.
+         * @example
+         * ```ts
+         * const promise1 = createPromise((resolve, reject) => {
+         *   throw 'Uh-oh!';
+         * });
+         *
+         * promise1.catch((error) => {
+         *   console.error(error);
+         * });
+         * // expected output: Uh-oh!
+         * ```
+         */
+        catch<TResult = never>(onRejected?: ((reason: any) => TResult | IPromise<TResult>) | undefined | null): PromiseLike<T | TResult>;
+        /**
+         * Attaches a callback for only the rejection of the Promise.
+         * @param onRejected The callback to execute when the Promise is rejected.
+         * @returns A Promise for the completion of the callback.
+         * @example
+         * ```ts
+         * const promise1 = createPromise((resolve, reject) => {
+         *   throw 'Uh-oh!';
+         * });
+         *
+         * promise1.catch((error) => {
+         *   console.error(error);
+         * });
+         * // expected output: Uh-oh!
+         * ```
+         */
+        catch<TResult = never>(onRejected?: ((reason: any) => TResult | IPromise<TResult>) | undefined | null): Promise<T | TResult>;
+        /**
+         * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
+         * resolved value cannot be modified from the callback.
+         * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
+         * @returns A Promise for the completion of the callback.
+         * @example
+         * ```ts
+         * function doFunction() {
+         *   return createPromise((resolve, reject) => {
+         *     if (Math.random() > 0.5) {
+         *       resolve('Function has completed');
+         *     } else {
+         *       reject(new Error('Function failed to process'));
+         *     }
+         *   });
+         * }
+         *
+         * doFunction().then((data) => {
+         *     console.log(data);
+         * }).catch((err) => {
+         *     console.error(err);
+         * }).finally(() => {
+         *     console.log('Function processing completed');
+         * });
+         * ```
+         */
+        finally(onfinally?: FinallyPromiseHandler): IPromise<T>;
+        /**
+         * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
+         * resolved value cannot be modified from the callback.
+         * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
+         * @returns A Promise for the completion of the callback.
+         * @example
+         * ```ts
+         * function doFunction() {
+         *   return createPromise((resolve, reject) => {
+         *     if (Math.random() > 0.5) {
+         *       resolve('Function has completed');
+         *     } else {
+         *       reject(new Error('Function failed to process'));
+         *     }
+         *   });
+         * }
+         *
+         * doFunction().then((data) => {
+         *     console.log(data);
+         * }).catch((err) => {
+         *     console.error(err);
+         * }).finally(() => {
+         *     console.log('Function processing completed');
+         * });
+         * ```
+         */
+        finally(onFinally?: FinallyPromiseHandler): Promise<T>;
+    }
+
+    /**
+     * The IPropertyStorageOverride interface provides a custom interface for storing internal SDK properties - otherwise they are
+     * stored as cookies.
+     * You need this interface when you intend to run auto collection for common properties, or when you log a session in
+     * a non browser environment.
+     */
+    interface IPropertyStorageOverride {
+        /**
+         * A function for passing key value pairs to be stored.
+         * @param key   - The key for the key value pair.
+         * @param value - The value for the key value pair.
+         */
+        setProperty: (key: string, value: string) => void;
+        /**
+         * A function that gets a value for a given key.
+         * @param key - The key for which the value must be fetched.
+         */
+        getProperty: (key: string) => string;
+    }
+
+    interface ITelemetryInitializerHandler extends ILegacyUnloadHook {
+        remove(): void;
+    }
+
+    /**
+     * Telemety item supported in Core
+     */
+    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;
+        /**
+         * Custom data
+         */
+        data?: ICustomProperties;
+        /**
+         * Telemetry type used for part B
+         */
+        baseType?: string;
+        /**
+         * Based on schema for part B
+         */
+        baseData?: {
+            [key: string]: any;
+        };
+    }
+
+    /**
+     * Configuration provided to SDK core
+     */
+    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;
+    }
+
+    /**
+     * Configuration provided to SDK core
+     */
+    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;
+    }
+
+    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;
+    }
+
+    interface ITelemetryUnloadState {
+        reason: TelemetryUnloadReason;
+        isAsync: boolean;
+        flushComplete?: boolean;
+    }
+
+    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[];
+    }
+
+    /**
+     * A Timer handler which is returned from {@link scheduleTimeout} which contains functions to
+     * cancel or restart (refresh) the timeout function.
+     *
+     * @since 0.4.4
+     * @group Timer
+     */
+    interface ITimerHandler {
+        /**
+         * Cancels a timeout that was previously scheduled, after calling this function any previously
+         * scheduled timer will not execute.
+         * @example
+         * ```ts
+         * let theTimer = scheduleTimeout(...);
+         * theTimer.cancel();
+         * ```
+         */
+        cancel(): void;
+        /**
+         * Reschedules the timer to call its callback at the previously specified duration
+         * adjusted to the current time. This is useful for refreshing a timer without allocating
+         * a new JavaScript object.
+         *
+         * Using this on a timer that has already called its callback will reactivate the timer.
+         * Calling on a timer that has not yet executed will just reschedule the current timer.
+         * @example
+         * ```ts
+         * let theTimer = scheduleTimeout(...);
+         * // The timer will be restarted (if already executed) or rescheduled (if it has not yet executed)
+         * theTimer.refresh();
+         * ```
+         */
+        refresh(): ITimerHandler;
+        /**
+         * When called, requests that the event loop not exit so long when the ITimerHandler is active.
+         * Calling timer.ref() multiple times will have no effect. By default, all ITimerHandler objects
+         * will create "ref'ed" instances, making it normally unnecessary to call timer.ref() unless
+         * timer.unref() had been called previously.
+         * @since 0.7.0
+         * @returns the ITimerHandler instance
+         * @example
+         * ```ts
+         * let theTimer = createTimeout(...);
+         *
+         * // Make sure the timer is referenced (the default) so that the runtime (Node) does not terminate
+         * // if there is a waiting referenced timer.
+         * theTimer.ref();
+         * ```
+         */
+        ref(): this;
+        /**
+         * When called, the any active ITimerHandler instance will not require the event loop to remain
+         * active (Node.js). If there is no other activity keeping the event loop running, the process may
+         * exit before the ITimerHandler instance callback is invoked. Calling timer.unref() multiple times
+         * will have no effect.
+         * @since 0.7.0
+         * @returns the ITimerHandler instance
+         * @example
+         * ```ts
+         * let theTimer = createTimeout(...);
+         *
+         * // Unreference the timer so that the runtime (Node) may terminate if nothing else is running.
+         * theTimer.unref();
+         * ```
+         */
+        unref(): this;
+        /**
+         * If true, any running referenced `ITimerHandler` instance will keep the Node.js event loop active.
+         * @since 0.7.0
+         * @example
+         * ```ts
+         * let theTimer = createTimeout(...);
+         *
+         * // Unreference the timer so that the runtime (Node) may terminate if nothing else is running.
+         * theTimer.unref();
+         * let hasRef = theTimer.hasRef(); // false
+         *
+         * theTimer.ref();
+         * hasRef = theTimer.hasRef(); // true
+         * ```
+         */
+        hasRef(): boolean;
+        /**
+         * Gets or Sets a flag indicating if the underlying timer is currently enabled and running.
+         * Setting the enabled flag to the same as it's current value has no effect, setting to `true`
+         * when already `true` will not {@link ITimerHandler.refresh | refresh}() the timer.
+         * And setting to 'false` will {@link ITimerHandler.cancel | cancel}() the timer.
+         * @since 0.8.1
+         * @example
+         * ```ts
+         * let theTimer = createTimeout(...);
+         *
+         * // Check if enabled
+         * theTimer.enabled; // false
+         *
+         * // Start the timer
+         * theTimer.enabled = true;     // Same as calling refresh()
+         * theTimer.enabled; //true
+         *
+         * // Has no effect as it's already running
+         * theTimer.enabled = true;
+         *
+         * // Will refresh / restart the time
+         * theTimer.refresh()
+         *
+         * let theTimer = scheduleTimeout(...);
+         *
+         * // Check if enabled
+         * theTimer.enabled; // true
+         * ```
+         */
+        enabled: boolean;
+    }
+
+    /**
+     * An interface which provides automatic removal during unloading of the component
+     */
+    interface IUnloadHook {
+        /**
+         * Self remove the referenced component
+         */
+        rm: () => void;
+    }
+
+    /**
+     * Interface which identifiesAdd this hook so that it is automatically removed during unloading
+     * @param hooks - The single hook or an array of IInstrumentHook objects
+     */
+    interface IUnloadHookContainer {
+        add: (hooks: IUnloadHook | IUnloadHook[] | Iterator<IUnloadHook> | ILegacyUnloadHook | ILegacyUnloadHook[] | Iterator<ILegacyUnloadHook>) => void;
+        run: (logger?: IDiagnosticLogger) => void;
+    }
+
+    /**
+     * This interface is used during the serialization of events into envelope (serialized object) which is sent to the services, the format is defined via the
+     * [Common Schema 4.0](https://aka.ms/CommonSchema) specification. The path and field names used are based on how the data is serialized
+     * to the service (CS 4.0 location) and not specifically the location on the event object you pass into the track methods (unless they are the same).
+     */
+    interface IValueSanitizer {
+        /**
+         * Add a value sanitizer as a fallback sanitizer if this sanitizer can't handle the path/name.
+         */
+        addSanitizer: (sanitizer: IValueSanitizer) => void;
+        /**
+         * Adds a field sanitizer to the evaluation list
+         */
+        addFieldSanitizer: (fieldSanitizer: IFieldValueSanitizerProvider) => void;
+        /**
+         * Removes the value sanitizer as a fallback sanitizer if this sanitizer can't handle the path/name if present.
+         */
+        rmSanitizer: (theSanitizer: IValueSanitizer) => void;
+        /**
+         * Removes the field sanitizer to the evaluation list if present
+         */
+        rmFieldSanitizer: (theFieldSanitizer: IFieldValueSanitizerProvider) => void;
+        /**
+         * Does this field value sanitizer handle this path / field combination
+         * @param path - The field path
+         * @param name - The name of the field
+         */
+        handleField: (path: string, name: string) => boolean;
+        /**
+         * Sanitizes the value. It checks the that the property name and value are valid. It also
+         * checks/populates the correct type and pii of the property value.
+         * @param path - The root path of the property
+         * @param name - The property name.
+         * @param value - The property value or an IEventProperty containing value, type ,pii and customer content.
+         * @param stringifyObjects - If supplied tells the sanitizer that it should JSON stringify() objects
+         * @returns IEventProperty containing valid name, value, pii and type or null if invalid.
+         */
+        value: (path: string, name: string, value: FieldValueSanitizerTypes, stringifyObjects?: boolean) => IEventProperty | null;
+        /**
+         * Sanitizes the Property. It checks the that the property name and value are valid. It also
+         * checks/populates the correct type and pii of the property value.
+         * @param path - The root path of the property
+         * @param name - The property name.
+         * @param property - The property value or an IEventProperty containing value, type ,pii and customer content.
+         * @param stringifyObjects - If supplied tells the sanitizer that it should JSON stringify() objects
+         * @returns IEventProperty containing valid name, value, pii and type or null if invalid.
+         */
+        property: (path: string, name: string, property: IEventProperty, stringifyObjects?: boolean) => IEventProperty | null;
+    }
+
+    interface IWatchDetails<T = IConfiguration> {
+        /**
+         * The current config object
+         */
+        cfg: T;
+        /**
+         * Set the value against the provided config/name with the value, the property
+         * will be converted to be dynamic (if not already) as long as the provided config
+         * is already a tracked dynamic object.
+         * @throws TypeError if the provided config is not a monitored dynamic config
+         */
+        set: <C, V>(theConfig: C, name: string, value: V) => V;
+        /**
+         * Set default values for the config if not present.
+         * @param theConfig - The configuration object to set default on (if missing)
+         * @param defaultValues - The default values to apply to the config
+         */
+        setDf: <C>(theConfig: C, defaultValues: IConfigDefaults<C>) => C;
+        /**
+         * Set this named property of the target as referenced, which will cause any object or array instance
+         * to be updated in-place rather than being entirely replaced. All other values will continue to be replaced.
+         * @returns The referenced properties current value
+         */
+        ref: <C, V = any>(target: C, name: string) => V;
+        /**
+         * Set this named property of the target as read-only, which will block this single named property from
+         * ever being changed for the target instance.
+         * This does NOT freeze or seal the instance, it just stops the direct re-assignment of the named property,
+         * if the value is a non-primitive (ie. an object or array) it's properties will still be mutable.
+         * @returns The referenced properties current value
+         */
+        rdOnly: <C, V = any>(target: C, name: string) => V;
+    }
+
+    /**
+     * The IXHROverride interface overrides the way HTTP requests are sent.
+     */
+    interface IXHROverride {
+        sendPOST: SendPOSTFunction;
+    }
+
+    const LoggingSeverity: EnumValue<typeof eLoggingSeverity>;
+
+    type LoggingSeverity = number | eLoggingSeverity;
+
+    /**
+     * Near Real Time profile. RealTime Latency events are sent every 3 sec and
+     * Normal Latency events are sent every 6 sec.
+     */
+    const NRT_PROFILE = "NEAR_REAL_TIME";
+
+    type OnCompleteCallback = (status: number, headers: {
+        [headerName: string]: string;
+    }, response?: string) => void;
+
+    /**
+     * Defines the function signature of a payload listener, which is called after the payload has been sent to the server. The listener is passed
+     * both the initial payload object and any altered (modified) payload from a preprocessor so it can determine what payload it may want to log or send.
+     * Used by the Remove DDV extension to listen to server send events.
+     * @param orgPayload - The initially constructed payload object
+     * @param sendPayload - The alternative (possibly modified by a preprocessor) payload
+     * @param isSync - A boolean flag indicating whether this request was initiated as part of a sync response (unload / flush request), this is for informative only.
+     * @param isBeaconSend - A boolean flag indicating whether the payload was sent using the navigator.sendBeacon() API.
+     */
+    type PayloadListenerFunction = (orgPayload: IPayloadData, sendPayload?: IPayloadData, isSync?: boolean, isBeaconSend?: boolean) => void;
+
+    /**
+     * Defines the function signature for the Payload Preprocessor.
+     * @param payload - The Initial constructed payload that if not modified should be passed onto the callback function.
+     * @param callback - The preprocessor MUST call the callback function to ensure that the events are sent to the server, failing to call WILL result in dropped events.
+     * The modifiedBuffer argument can be either the original payload or may be modified by performing GZipping of the payload and adding the content header.
+     * @param isSync - A boolean flag indicating whether this request was initiated as part of a sync response (unload / flush request), this is for informative only.
+     * e.g the preprocessor may wish to not perform any GZip operations if the request was a sync request which is normally called as part of an unload request.
+     */
+    type PayloadPreprocessorFunction = (payload: IPayloadData, callback: (modifiedBuffer: IPayloadData) => void, isSync?: boolean) => void;
+
+    /**
+     * Class that manages adding events to inbound queues and batching of events
+     * into requests.
+     * @group Classes
+     * @group Entrypoint
+     */
+    class PostChannel extends BaseTelemetryPlugin implements IChannelControls, IPostChannel {
+        identifier: string;
+        priority: number;
+        version: string;
+        constructor();
+        /**
+         * Start the queue manager to batch and send events via post.
+         * @param config - The core configuration.
+         */
+        initialize(coreConfig: IExtendedConfiguration, core: IAppInsightsCore, extensions: IPlugin[]): void;
+        /**
+         * Add an event to the appropriate inbound queue based on its latency.
+         * @param ev - The event to be added to the queue.
+         * @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(ev: ITelemetryItem, itemCtx?: IProcessTelemetryContext): void;
+        /**
+         * Sets the event queue limits at runtime (after initialization), if the number of queued events is greater than the
+         * eventLimit or autoFlushLimit then a flush() operation will be scheduled.
+         * @param eventLimit The number of events that can be kept in memory before the SDK starts to drop events. If the value passed is less than or
+         * equal to zero the value will be reset to the default (10,000).
+         * @param autoFlushLimit When defined, once this number of events has been queued the system perform a flush() to send the queued events
+         * without waiting for the normal schedule timers. Passing undefined, null or a value less than or equal to zero will disable the auto flush.
+         */
+        setEventQueueLimits(eventLimit: number, autoFlushLimit?: number): void;
+        /**
+         * Pause the transmission of any requests
+         */
+        pause(): void;
+        /**
+         * Resumes transmission of events.
+         */
+        resume(): void;
+        /**
+         * Add handler to be executed with request response text.
+         */
+        addResponseHandler(responseHanlder: (responseText: string) => void): IUnloadHook;
+        /**
+         * Flush to send data immediately; channel should default to sending data asynchronously. If executing asynchronously (the default) and
+         * you DO NOT pass a callback function then a [IPromise](https://nevware21.github.io/ts-async/typedoc/interfaces/IPromise.html)
+         * will be returned which will resolve once the flush is complete. The actual implementation of the `IPromise`
+         * will be a native Promise (if supported) or the default as supplied by [ts-async library](https://github.com/nevware21/ts-async)
+         * @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 - If a callback is provided `true` to indicate that callback will be called after the flush is complete otherwise the caller
+         * should assume that any provided callback will never be called, Nothing or if occurring asynchronously a
+         * [IPromise](https://nevware21.github.io/ts-async/typedoc/interfaces/IPromise.html) which will be resolved once the unload is complete,
+         * the [IPromise](https://nevware21.github.io/ts-async/typedoc/interfaces/IPromise.html) will only be returned when no callback is provided
+         * and async is true.
+         */
+        flush(async?: boolean, callBack?: (flushComplete?: boolean) => void, sendReason?: SendRequestReason): boolean | void | IPromise<boolean>;
+        /**
+         * Set AuthMsaDeviceTicket header
+         * @param ticket - Ticket value.
+         */
+        setMsaAuthTicket(ticket: string): void;
+        /**
+         * Set setAuthPluginHeader header
+         * @param token - token value.
+         */
+        setAuthPluginHeader(token: string): void;
+        /**
+         * remove AuthPlugin Header
+         * @param token - token value.
          */
         removeAuthPluginHeader(token: string): void;
         /**
@@ -395,12 +2461,132 @@ declare namespace oneDS {
         getOfflineSupport(): IInternalOfflineSupport;
     }
 
+    /**
+     * This defines the handler function for when a promise is rejected.
+     * @param value This is the value passed as part of resolving the Promise
+     * @return This may return a value, another Promise or void. @see {@link IPromise.then} for how the value is handled.
+     */
+    type RejectedPromiseHandler<T = never> = (((reason: any) => T | IPromise<T> | PromiseLike<T>) | undefined | null);
+
+    /**
+     * This defines the handler function for when a promise is resolved.
+     * @param value This is the value passed as part of resolving the Promise
+     * @return This may return a value, another Promise or void. @see {@link IPromise.then} for how the value is handled.
+     */
+    type ResolvedPromiseHandler<T, TResult1 = T> = (((value: T) => TResult1 | IPromise<TResult1> | PromiseLike<TResult1>) | undefined | null);
+
     /**
      * Real Time profile (default profile). RealTime Latency events are sent every 1 sec and
      * Normal Latency events are sent every 2 sec.
      */
     const RT_PROFILE = "REAL_TIME";
 
-    
-    
+    /**
+     * SendPOSTFunction type defines how an HTTP POST request is sent to an ingestion server
+     * @param payload - The payload object that should be sent, contains the url, bytes/string and headers for the request
+     * @param oncomplete - The function to call once the request has completed whether a success, failure or timeout
+     * @param sync - A boolean flag indicating whether the request should be sent as a synchronous request.
+     */
+    type SendPOSTFunction = (payload: IPayloadData, oncomplete: OnCompleteCallback, sync?: boolean) => void | IPromise<boolean>;
+
+    /**
+     * The EventsDiscardedReason enumeration contains a set of values that specify the reason for discarding an event.
+     */
+    const enum SendRequestReason {
+        /**
+         * No specific reason was specified
+         */
+        Undefined = 0,
+        /**
+         * Events are being sent based on the normal event schedule / timer.
+         */
+        NormalSchedule = 1,
+        /**
+         * A manual flush request was received
+         */
+        ManualFlush = 1,
+        /**
+         * Unload event is being processed
+         */
+        Unload = 2,
+        /**
+         * The event(s) being sent are sync events
+         */
+        SyncEvent = 3,
+        /**
+         * The Channel was resumed
+         */
+        Resumed = 4,
+        /**
+         * The event(s) being sent as a retry
+         */
+        Retry = 5,
+        /**
+         * The SDK is unloading
+         */
+        SdkUnload = 6,
+        /**
+         * Maximum batch size would be exceeded
+         */
+        MaxBatchSize = 10,
+        /**
+         * The Maximum number of events have already been queued
+         */
+        MaxQueuedEvents = 20
+    }
+
+    interface Tags {
+        [key: string]: any;
+    }
+
+    type TelemetryInitializerFunction = <T extends ITelemetryItem>(item: T) => boolean | void;
+
+    /**
+     * The TelemetryUnloadReason enumeration contains the possible reasons for why a plugin is being unloaded / torndown().
+     */
+    const enum TelemetryUnloadReason {
+        /**
+         * Teardown has been called without any context.
+         */
+        ManualTeardown = 0,
+        /**
+         * Just this plugin is being removed
+         */
+        PluginUnload = 1,
+        /**
+         * This instance of the plugin is being removed and replaced
+         */
+        PluginReplace = 2,
+        /**
+         * The entire SDK is being unloaded
+         */
+        SdkUnload = 50
+    }
+
+    /**
+     * The TelemetryUpdateReason enumeration contains a set of bit-wise values that specify the reason for update request.
+     */
+    const enum TelemetryUpdateReason {
+        /**
+         * Unknown.
+         */
+        Unknown = 0,
+        /**
+         * The configuration has ben updated or changed
+         */
+        ConfigurationChanged = 1,
+        /**
+         * One or more plugins have been added
+         */
+        PluginAdded = 16,
+        /**
+         * One or more plugins have been removed
+         */
+        PluginRemoved = 32
+    }
+
+    type UnloadHandler = (itemCtx: IProcessTelemetryUnloadContext, unloadState: ITelemetryUnloadState) => void;
+
+    type WatcherFunction<T = IConfiguration> = (details: IWatchDetails<T>) => void;
+
 }