@microsoft/1ds-post-js 3.2.0 → 3.2.3

package/dist-esm/src/BatchNotificationActions.js

@@ -1,5 +1,5 @@
 /*
- * 1DS JS SDK POST plugin, 3.2.0
+ * 1DS JS SDK POST plugin, 3.2.3
  * Copyright (c) Microsoft and contributors. All rights reserved.
  * (Microsoft Internal Only)
  */

package/dist-esm/src/ClockSkewManager.js

@@ -1,5 +1,5 @@
 /*
- * 1DS JS SDK POST plugin, 3.2.0
+ * 1DS JS SDK POST plugin, 3.2.3
  * Copyright (c) Microsoft and contributors. All rights reserved.
  * (Microsoft Internal Only)
  */

package/dist-esm/src/Constants.js

@@ -1,5 +1,5 @@
 /*
- * 1DS JS SDK POST plugin, 3.2.0
+ * 1DS JS SDK POST plugin, 3.2.3
  * Copyright (c) Microsoft and contributors. All rights reserved.
  * (Microsoft Internal Only)
  */

package/dist-esm/src/DataModels.js

@@ -1,5 +1,5 @@
 /*
- * 1DS JS SDK POST plugin, 3.2.0
+ * 1DS JS SDK POST plugin, 3.2.3
  * Copyright (c) Microsoft and contributors. All rights reserved.
  * (Microsoft Internal Only)
  */

package/dist-esm/src/EventBatch.js

@@ -1,5 +1,5 @@
 /*
- * 1DS JS SDK POST plugin, 3.2.0
+ * 1DS JS SDK POST plugin, 3.2.3
  * Copyright (c) Microsoft and contributors. All rights reserved.
  * (Microsoft Internal Only)
  */

package/dist-esm/src/HttpManager.d.ts

@@ -8,6 +8,7 @@ import { IXHROverride, IPostChannel, PayloadPreprocessorFunction, PayloadListene
 import { BatchNotificationActions } from "./BatchNotificationActions";
 import { EventBatch } from "./EventBatch";
 import { IChannelConfiguration } from "./Index";
+import { ITimeoutOverrideWrapper } from "./TimeoutOverrideWrapper";
 /**
  * Class managing the sending of requests.
  */
@@ -19,7 +20,7 @@ export declare class HttpManager {
      * @constructor
      * @param requestQueue   - The queue that contains the requests to be sent.
      */
-    constructor(maxEventsPerBatch: number, maxConnections: number, maxRequestRetriesBeforeBackoff: number, actions: BatchNotificationActions);
+    constructor(maxEventsPerBatch: number, maxConnections: number, maxRequestRetriesBeforeBackoff: number, actions: BatchNotificationActions, timeoutOverride: ITimeoutOverrideWrapper);
     /**
      * @constructor
      * @param requestQueue   - The queue that contains the requests to be sent.

package/dist-esm/src/HttpManager.js

@@ -1,5 +1,5 @@
 /*
- * 1DS JS SDK POST plugin, 3.2.0
+ * 1DS JS SDK POST plugin, 3.2.3
  * Copyright (c) Microsoft and contributors. All rights reserved.
  * (Microsoft Internal Only)
  */
@@ -22,11 +22,11 @@ var _noResponseQs = "&" + strNoResponseBody + "=true";
  * Identifies the default notification reason to the action names
  */
 var _eventActionMap = (_a = {},
-    _a[1 /* Paused */] = strRequeue,
-    _a[100 /* RequeueEvents */] = strRequeue,
-    _a[200 /* Complete */] = "sent",
-    _a[8004 /* KillSwitch */] = strDropped,
-    _a[8003 /* SizeLimitExceeded */] = strDropped,
+    _a[1 /* EventBatchNotificationReason.Paused */] = strRequeue,
+    _a[100 /* EventBatchNotificationReason.RequeueEvents */] = strRequeue,
+    _a[200 /* EventBatchNotificationReason.Complete */] = "sent",
+    _a[8004 /* EventBatchNotificationReason.KillSwitch */] = strDropped,
+    _a[8003 /* EventBatchNotificationReason.SizeLimitExceeded */] = strDropped,
     _a);
 var _collectorQsHeaders = {};
 var _collectorHeaderToQs = {};
@@ -89,7 +89,7 @@ var HttpManager = /** @class */ (function () {
      * @constructor
      * @param requestQueue   - The queue that contains the requests to be sent.
      */
-    function HttpManager(maxEventsPerBatch, maxConnections, maxRequestRetriesBeforeBackoff, actions) {
+    function HttpManager(maxEventsPerBatch, maxConnections, maxRequestRetriesBeforeBackoff, actions, timeoutOverride) {
         this._responseHandlers = [];
         var _urlString = "?cors=true&" + strContentTypeHeader.toLowerCase() + "=" + defaultContentType;
         var _killSwitch = new EVTKillSwitch();
@@ -147,11 +147,11 @@ var HttpManager = /** @class */ (function () {
                     var theTransports = [];
                     if (isReactNative()) {
                         // Use Fetch or XDR/XHR
-                        theTransports = [2 /* Fetch */, 1 /* Xhr */];
+                        theTransports = [2 /* TransportType.Fetch */, 1 /* TransportType.Xhr */];
                     }
                     else {
                         // Use XDR/XHR, Fetch or beacons
-                        theTransports = [1 /* Xhr */, 2 /* Fetch */, 3 /* Beacon */];
+                        theTransports = [1 /* TransportType.Xhr */, 2 /* TransportType.Fetch */, 3 /* TransportType.Beacon */];
                     }
                     // Prefix any user requested transport(s) values
                     var configTransports = channelConfig.transports;
@@ -170,20 +170,20 @@ var HttpManager = /** @class */ (function () {
                     }
                 }
                 _sendInterfaces = (_a = {},
-                    _a[0 /* Batched */] = httpInterface,
-                    _a[1 /* Synchronous */] = syncHttpInterface || _getSenderInterface([1 /* Xhr */, 2 /* Fetch */, 3 /* Beacon */], true),
-                    _a[2 /* SendBeacon */] = beaconHttpInterface || _getSenderInterface([3 /* Beacon */, 2 /* Fetch */], true) || syncHttpInterface || _getSenderInterface([1 /* Xhr */], true),
-                    _a[3 /* SyncFetch */] = fetchSyncHttpInterface || _getSenderInterface([2 /* Fetch */, 3 /* Beacon */], true) || syncHttpInterface || _getSenderInterface([1 /* Xhr */], true),
+                    _a[0 /* EventSendType.Batched */] = httpInterface,
+                    _a[1 /* EventSendType.Synchronous */] = syncHttpInterface || _getSenderInterface([1 /* TransportType.Xhr */, 2 /* TransportType.Fetch */, 3 /* TransportType.Beacon */], true),
+                    _a[2 /* EventSendType.SendBeacon */] = beaconHttpInterface || _getSenderInterface([3 /* TransportType.Beacon */, 2 /* TransportType.Fetch */], true) || syncHttpInterface || _getSenderInterface([1 /* TransportType.Xhr */], true),
+                    _a[3 /* EventSendType.SyncFetch */] = fetchSyncHttpInterface || _getSenderInterface([2 /* TransportType.Fetch */, 3 /* TransportType.Beacon */], true) || syncHttpInterface || _getSenderInterface([1 /* TransportType.Xhr */], true),
                     _a);
             };
             // Special internal method to allow the DebugPlugin to hook embedded objects
             function _getSenderInterface(transports, syncSupport) {
-                var transportType = 0 /* NotSet */;
+                var transportType = 0 /* TransportType.NotSet */;
                 var sendPostFunc = null;
                 var lp = 0;
                 while (sendPostFunc == null && lp < transports.length) {
                     transportType = transports[lp];
-                    if (transportType === 1 /* Xhr */) {
+                    if (transportType === 1 /* TransportType.Xhr */) {
                         if (useXDomainRequest()) {
                             sendPostFunc = _xdrSendPost;
                         }
@@ -191,10 +191,10 @@ var HttpManager = /** @class */ (function () {
                             sendPostFunc = _xhrSendPost;
                         }
                     }
-                    else if (transportType === 2 /* Fetch */ && isFetchSupported(syncSupport)) {
+                    else if (transportType === 2 /* TransportType.Fetch */ && isFetchSupported(syncSupport)) {
                         sendPostFunc = _fetchSendPost;
                     }
-                    else if (_useBeacons && transportType === 3 /* Beacon */ && isBeaconsSupported()) {
+                    else if (_useBeacons && transportType === 3 /* TransportType.Beacon */ && isBeaconsSupported()) {
                         sendPostFunc = _beaconSendPost;
                     }
                     lp++;
@@ -209,7 +209,7 @@ var HttpManager = /** @class */ (function () {
                 return null;
             }
             _self["_getDbgPlgTargets"] = function () {
-                return [_sendInterfaces[0 /* Batched */], _killSwitch, _serializer, _sendInterfaces];
+                return [_sendInterfaces[0 /* EventSendType.Batched */], _killSwitch, _serializer, _sendInterfaces];
             };
             function _xdrSendPost(payload, oncomplete, sync) {
                 // It doesn't support custom headers, so no action is taken with current requestHeaders
@@ -240,7 +240,7 @@ var HttpManager = /** @class */ (function () {
                     xdr.send(payload.data);
                 }
                 else {
-                    _postManager._setTimeoutOverride(function () {
+                    timeoutOverride.set(function () {
                         xdr.send(payload.data);
                     }, 0);
                 }
@@ -258,7 +258,7 @@ var HttpManager = /** @class */ (function () {
                     _a);
                 if (sync) {
                     requestInit.keepalive = true;
-                    if (payload._sendReason === 2 /* Unload */) {
+                    if (payload._sendReason === 2 /* SendRequestReason.Unload */) {
                         // As a sync request (during unload), it is unlikely that we will get a chance to process the response so
                         // just like beacon send assume that the events have been accepted and processed
                         ignoreResponse = true;
@@ -306,7 +306,7 @@ var HttpManager = /** @class */ (function () {
                 }
                 if (!responseHandled && payload.timeout > 0) {
                     // Simulate timeout
-                    _postManager._setTimeoutOverride(function () {
+                    timeoutOverride.set(function () {
                         if (!responseHandled) {
                             // Assume a 500 response (which will cause a retry)
                             responseHandled = true;
@@ -370,7 +370,7 @@ var HttpManager = /** @class */ (function () {
                     oncomplete(status, headers, response);
                 }
                 catch (e) {
-                    _throwInternal(_postManager.diagLog(), 2 /* WARNING */, 518 /* SendPostOnCompleteFailure */, dumpObj(e));
+                    _throwInternal(_postManager.diagLog(), 2 /* eLoggingSeverity.WARNING */, 518 /* _eExtendedInternalMessageId.SendPostOnCompleteFailure */, dumpObj(e));
                 }
             }
             function _beaconSendPost(payload, oncomplete, sync) {
@@ -401,7 +401,7 @@ var HttpManager = /** @class */ (function () {
                                     droppedBatches_1.push(theBatch.split(0));
                                 }
                             });
-                            _sendBatchesNotification(droppedBatches_1, 8003 /* SizeLimitExceeded */, thePayload.sendType, true);
+                            _sendBatchesNotification(droppedBatches_1, 8003 /* EventBatchNotificationReason.SizeLimitExceeded */, thePayload.sendType, true);
                         }
                         else {
                             status = 0;
@@ -418,11 +418,11 @@ var HttpManager = /** @class */ (function () {
             }
             function _isBeaconPayload(sendType) {
                 // Sync Fetch has the same payload limitation as sendBeacon -- 64kb limit, so treat both as a beacon send
-                return sendType === 2 /* SendBeacon */ || sendType === 3 /* SyncFetch */;
+                return sendType === 2 /* EventSendType.SendBeacon */ || sendType === 3 /* EventSendType.SyncFetch */;
             }
             function _adjustSendType(sendType) {
                 if (_isUnloading && _isBeaconPayload(sendType)) {
-                    sendType = 2 /* SendBeacon */;
+                    sendType = 2 /* EventSendType.SendBeacon */;
                 }
                 return sendType;
             }
@@ -443,14 +443,14 @@ var HttpManager = /** @class */ (function () {
             };
             _self.sendQueuedRequests = function (sendType, sendReason) {
                 if (isUndefined(sendType)) {
-                    sendType = 0 /* Batched */;
+                    sendType = 0 /* EventSendType.Batched */;
                 }
                 if (_isUnloading) {
                     sendType = _adjustSendType(sendType);
-                    sendReason = 2 /* Unload */;
+                    sendReason = 2 /* SendRequestReason.Unload */;
                 }
                 if (_canSendPayload(_batchQueue, sendType, 0)) {
-                    _sendBatches(_clearQueue(), 0, false, sendType, sendReason || 0 /* Undefined */);
+                    _sendBatches(_clearQueue(), 0, false, sendType, sendReason || 0 /* SendRequestReason.Undefined */);
                 }
             };
             _self.isCompletelyIdle = function () {
@@ -475,7 +475,7 @@ var HttpManager = /** @class */ (function () {
              */
             _self.teardown = function () {
                 if (_batchQueue.length > 0) {
-                    _sendBatches(_clearQueue(), 0, true, 2 /* SendBeacon */, 2 /* Unload */);
+                    _sendBatches(_clearQueue(), 0, true, 2 /* EventSendType.SendBeacon */, 2 /* SendRequestReason.Unload */);
                 }
             };
             /**
@@ -489,7 +489,7 @@ var HttpManager = /** @class */ (function () {
              */
             _self.resume = function () {
                 _paused = false;
-                _self.sendQueuedRequests(0 /* Batched */, 4 /* Resumed */);
+                _self.sendQueuedRequests(0 /* EventSendType.Batched */, 4 /* SendRequestReason.Resumed */);
             };
             /**
              * Sends a request synchronously to the Aria collector. This api is used to send
@@ -505,14 +505,14 @@ var HttpManager = /** @class */ (function () {
                 // Increment active connection since we are still going to use a connection to send the request.
                 if (batch && batch.count() > 0) {
                     if (isNullOrUndefined(sendType)) {
-                        sendType = 1 /* Synchronous */;
+                        sendType = 1 /* EventSendType.Synchronous */;
                     }
                     if (_isUnloading) {
                         sendType = _adjustSendType(sendType);
-                        sendReason = 2 /* Unload */;
+                        sendReason = 2 /* SendRequestReason.Unload */;
                     }
                     // For sync requests we will not wait for the clock skew.
-                    _sendBatches([batch], 0, false, sendType, sendReason || 0 /* Undefined */);
+                    _sendBatches([batch], 0, false, sendType, sendReason || 0 /* SendRequestReason.Undefined */);
                 }
             };
             function _hasIdleConnection() {
@@ -528,7 +528,7 @@ var HttpManager = /** @class */ (function () {
                 if (theBatches && theBatches.length > 0 && !_paused && _sendInterfaces[sendType] && _serializer) {
                     // Always attempt to send synchronous events don't wait for idle or clockSkew
                     // and don't block retry requests if clockSkew is not yet set
-                    result = (sendType !== 0 /* Batched */) || (_hasIdleConnection() && (retryCnt > 0 || _clockSkewManager.allowRequestSending()));
+                    result = (sendType !== 0 /* EventSendType.Batched */) || (_hasIdleConnection() && (retryCnt > 0 || _clockSkewManager.allowRequestSending()));
                 }
                 return result;
             }
@@ -550,14 +550,14 @@ var HttpManager = /** @class */ (function () {
                     return;
                 }
                 if (_paused) {
-                    _sendBatchesNotification(theBatches, 1 /* Paused */, sendType);
+                    _sendBatchesNotification(theBatches, 1 /* EventBatchNotificationReason.Paused */, sendType);
                     return;
                 }
                 // Make sure that if we are unloading the sendType is a supported version
                 sendType = _adjustSendType(sendType);
                 try {
                     var orgBatches_1 = theBatches;
-                    var isSynchronous_1 = sendType !== 0 /* Batched */;
+                    var isSynchronous_1 = sendType !== 0 /* EventSendType.Batched */;
                     doPerf(_core, function () { return "HttpManager:_sendBatches"; }, function (perfEvt) {
                         if (perfEvt) {
                             // Perf Monitoring is enabled, so create a "Quick" copy of the original batches so we still report
@@ -569,9 +569,9 @@ var HttpManager = /** @class */ (function () {
                         var droppedBatches = [];
                         var thePayload = null;
                         var serializationStart = getTime();
-                        var sendInterface = _sendInterfaces[sendType] || (isSynchronous_1 ? _sendInterfaces[1 /* Synchronous */] : _sendInterfaces[0 /* Batched */]);
+                        var sendInterface = _sendInterfaces[sendType] || (isSynchronous_1 ? _sendInterfaces[1 /* EventSendType.Synchronous */] : _sendInterfaces[0 /* EventSendType.Batched */]);
                         // Sync Fetch has the same payload limitation as sendBeacon -- 64kb limit
-                        var isBeaconTransport = (_isUnloading || _isBeaconPayload(sendType) || (sendInterface && sendInterface._transport === 3 /* Beacon */)) && _canUseSendBeaconApi();
+                        var isBeaconTransport = (_isUnloading || _isBeaconPayload(sendType) || (sendInterface && sendInterface._transport === 3 /* TransportType.Beacon */)) && _canUseSendBeaconApi();
                         while (_canSendPayload(theBatches, sendType, retryCount)) {
                             var theBatch = theBatches.shift();
                             if (theBatch && theBatch.count() > 0) {
@@ -609,11 +609,11 @@ var HttpManager = /** @class */ (function () {
                             _batchQueue = theBatches.concat(_batchQueue);
                         }
                         // Now send notification about any dropped events
-                        _sendBatchesNotification(droppedBatches, 8004 /* KillSwitch */, sendType);
+                        _sendBatchesNotification(droppedBatches, 8004 /* EventBatchNotificationReason.KillSwitch */, sendType);
                     }, function () { return ({ batches: _createDebugBatches(orgBatches_1), retryCount: retryCount, isTeardown: isTeardown, isSynchronous: isSynchronous_1, sendReason: sendReason, useSendBeacon: _isBeaconPayload(sendType), sendType: sendType }); }, !isSynchronous_1);
                 }
                 catch (ex) {
-                    _throwInternal(_postManager.diagLog(), 2 /* WARNING */, 48 /* CannotSerializeObject */, "Unexpected Exception sending batch: " + dumpObj(ex));
+                    _throwInternal(_postManager.diagLog(), 2 /* eLoggingSeverity.WARNING */, 48 /* _eInternalMessageId.CannotSerializeObject */, "Unexpected Exception sending batch: " + dumpObj(ex));
                 }
             }
             function _buildRequestDetails(thePayload, useHeaders) {
@@ -681,12 +681,12 @@ var HttpManager = /** @class */ (function () {
                     var useSendHook_1 = !!_self.sendHook;
                     var sendInterface_1 = _sendInterfaces[thePayload.sendType];
                     // Send all data using a beacon style transport if closing mode is on or channel was teared down
-                    if (!_isBeaconPayload(thePayload.sendType) && thePayload.isBeacon && thePayload.sendReason === 2 /* Unload */) {
-                        sendInterface_1 = _sendInterfaces[2 /* SendBeacon */] || _sendInterfaces[3 /* SyncFetch */] || sendInterface_1;
+                    if (!_isBeaconPayload(thePayload.sendType) && thePayload.isBeacon && thePayload.sendReason === 2 /* SendRequestReason.Unload */) {
+                        sendInterface_1 = _sendInterfaces[2 /* EventSendType.SendBeacon */] || _sendInterfaces[3 /* EventSendType.SyncFetch */] || sendInterface_1;
                     }
                     var useHeaders_1 = _useHeaders;
                     // Disable header usage if we know we are using sendBeacon as additional headers are not supported
-                    if (thePayload.isBeacon || sendInterface_1._transport === 3 /* Beacon */) {
+                    if (thePayload.isBeacon || sendInterface_1._transport === 3 /* TransportType.Beacon */) {
                         useHeaders_1 = false;
                     }
                     var requestDetails_1 = _buildRequestDetails(thePayload, useHeaders_1);
@@ -709,7 +709,7 @@ var HttpManager = /** @class */ (function () {
                             }
                         }
                         // Note: always sending this notification in a synchronous manner.
-                        _sendBatchesNotification(thePayload.batches, (1000 /* SendingUndefined */ + (sendReason || 0 /* Undefined */)), thePayload.sendType, true);
+                        _sendBatchesNotification(thePayload.batches, (1000 /* EventBatchNotificationReason.SendingUndefined */ + (sendReason || 0 /* SendRequestReason.Undefined */)), thePayload.sendType, true);
                         // Disabling the use of const because of Issue: 
                         // - Task 9227844: [1DS] Some environments and packagers automatically "freeze" objects which are defined as const which causes any mutations to throw
                         // eslint-disable-next-line prefer-const
@@ -758,11 +758,11 @@ var HttpManager = /** @class */ (function () {
                         }
                         doPerf(_core, function () { return "HttpManager:_doPayloadSend.sender"; }, function () {
                             if (sender) {
-                                if (thePayload.sendType === 0 /* Batched */) {
+                                if (thePayload.sendType === 0 /* EventSendType.Batched */) {
                                     _outstandingRequests++;
                                 }
                                 // Only call the hook if it's defined and we are not using sendBeacon as additional headers are not supported
-                                if (useSendHook_1 && !thePayload.isBeacon && sendInterface_1._transport !== 3 /* Beacon */) {
+                                if (useSendHook_1 && !thePayload.isBeacon && sendInterface_1._transport !== 3 /* TransportType.Beacon */) {
                                     // Create a new IPayloadData that is sent into the hook method, so that the hook method
                                     // can't change the object references to the orgPayloadData (it can still change the content -- mainly the headers)
                                     // Disabling the use of const because of Issue: 
@@ -805,11 +805,11 @@ var HttpManager = /** @class */ (function () {
                 }
                 if (thePayload.sizeExceed && thePayload.sizeExceed.length > 0) {
                     // Ensure that we send any discard events for oversize events even when there was no payload to send
-                    _sendBatchesNotification(thePayload.sizeExceed, 8003 /* SizeLimitExceeded */, thePayload.sendType);
+                    _sendBatchesNotification(thePayload.sizeExceed, 8003 /* EventBatchNotificationReason.SizeLimitExceeded */, thePayload.sendType);
                 }
                 if (thePayload.failedEvts && thePayload.failedEvts.length > 0) {
                     // Ensure that we send any discard events for events that could not be serialized even when there was no payload to send
-                    _sendBatchesNotification(thePayload.failedEvts, 8002 /* InvalidEvent */, thePayload.sendType);
+                    _sendBatchesNotification(thePayload.failedEvts, 8002 /* EventBatchNotificationReason.InvalidEvent */, thePayload.sendType);
                 }
             }
             function _addEventCompletedTimings(theEvents, sendEventCompleted) {
@@ -821,7 +821,7 @@ var HttpManager = /** @class */ (function () {
                 }
             }
             function _retryRequestIfNeeded(status, headers, thePayload, sendReason) {
-                var reason = 9000 /* ResponseFailure */;
+                var reason = 9000 /* EventBatchNotificationReason.ResponseFailure */;
                 var droppedBatches = null;
                 var isRetrying = false;
                 var backOffTrans = false;
@@ -849,7 +849,7 @@ var HttpManager = /** @class */ (function () {
                         // tslint:disable-next-line:triple-equals
                         if (status == 200 || status == 204) {
                             // Response was successfully sent
-                            reason = 200 /* Complete */;
+                            reason = 200 /* EventBatchNotificationReason.Complete */;
                             return;
                         }
                         if (!retryPolicyShouldRetryForStatus(status) || thePayload.numEvents <= 0) {
@@ -857,25 +857,25 @@ var HttpManager = /** @class */ (function () {
                             shouldRetry = false;
                         }
                         // Derive the notification response from the HttpStatus Code
-                        reason = 9000 /* ResponseFailure */ + (status % 1000);
+                        reason = 9000 /* EventBatchNotificationReason.ResponseFailure */ + (status % 1000);
                     }
                     if (shouldRetry) {
                         // The events should be retried -- so change notification to requeue them
-                        reason = 100 /* RequeueEvents */;
+                        reason = 100 /* EventBatchNotificationReason.RequeueEvents */;
                         var retryCount_1 = thePayload.retryCnt;
-                        if (thePayload.sendType === 0 /* Batched */) {
+                        if (thePayload.sendType === 0 /* EventSendType.Batched */) {
                             // attempt to resend the entire batch
                             if (retryCount_1 < maxRequestRetriesBeforeBackoff) {
                                 isRetrying = true;
                                 _doAction(function () {
                                     // try to resend the same batches
-                                    if (thePayload.sendType === 0 /* Batched */) {
+                                    if (thePayload.sendType === 0 /* EventSendType.Batched */) {
                                         // Reduce the outstanding request count (if this was an async request) as we didn't reduce the count
                                         // previously and we are about to reschedule our retry attempt and we want an attempt to send
                                         // to occur, it's also required to ensure that a follow up handleRequestFinished() call occurs
                                         _outstandingRequests--;
                                     }
-                                    _sendBatches(thePayload.batches, retryCount_1 + 1, thePayload.isTeardown, _isUnloading ? 2 /* SendBeacon */ : thePayload.sendType, 5 /* Retry */);
+                                    _sendBatches(thePayload.batches, retryCount_1 + 1, thePayload.isTeardown, _isUnloading ? 2 /* EventSendType.SendBeacon */ : thePayload.sendType, 5 /* SendRequestReason.Retry */);
                                 }, _isUnloading, retryPolicyGetMillisToBackoffForRetry(retryCount_1));
                             }
                             else {
@@ -883,7 +883,7 @@ var HttpManager = /** @class */ (function () {
                                 if (_isUnloading) {
                                     // we are unloading so don't try and requeue the events otherwise let the events get requeued and resent during the backoff sending
                                     // This will also cause the events to be purged based on the priority (if necessary)
-                                    reason = 8001 /* NonRetryableStatus */;
+                                    reason = 8001 /* EventBatchNotificationReason.NonRetryableStatus */;
                                 }
                             }
                         }
@@ -896,7 +896,7 @@ var HttpManager = /** @class */ (function () {
                         _clockSkewManager.setClockSkew();
                         _handleRequestFinished(thePayload, reason, sendReason, backOffTrans);
                     }
-                    _sendBatchesNotification(droppedBatches, 8004 /* KillSwitch */, thePayload.sendType);
+                    _sendBatchesNotification(droppedBatches, 8004 /* EventBatchNotificationReason.KillSwitch */, thePayload.sendType);
                 }
             }
             function _handleRequestFinished(thePayload, batchReason, sendReason, backOffTrans) {
@@ -905,7 +905,7 @@ var HttpManager = /** @class */ (function () {
                         // Slow down the transmission requests
                         _postManager._backOffTransmission();
                     }
-                    if (batchReason === 200 /* Complete */) {
+                    if (batchReason === 200 /* EventBatchNotificationReason.Complete */) {
                         if (!backOffTrans && !thePayload.isSync) {
                             // We have a successful async response, so the lets open the floodgates
                             // The reason for checking isSync is to avoid unblocking if beacon send occurred as it
@@ -918,12 +918,12 @@ var HttpManager = /** @class */ (function () {
                     _sendBatchesNotification(thePayload.batches, batchReason, thePayload.sendType, true);
                 }
                 finally {
-                    if (thePayload.sendType === 0 /* Batched */) {
+                    if (thePayload.sendType === 0 /* EventSendType.Batched */) {
                         // we always need to decrement this value otherwise the httpmanager locks up and won't send any more events
                         _outstandingRequests--;
                         // Don't try to send additional queued events if this is a retry operation as the retried
                         // response will eventually call _handleRequestFinished for the retried event
-                        if (sendReason !== 5 /* Retry */) {
+                        if (sendReason !== 5 /* SendRequestReason.Retry */) {
                             // Try and send any other queued batched events
                             _self.sendQueuedRequests(thePayload.sendType, sendReason);
                         }
@@ -945,7 +945,7 @@ var HttpManager = /** @class */ (function () {
                     cb();
                 }
                 else {
-                    _postManager._setTimeoutOverride(cb, interval);
+                    timeoutOverride.set(cb, interval);
                 }
             }
             /**
@@ -990,7 +990,7 @@ var HttpManager = /** @class */ (function () {
                             responseHandlers[i](responseText);
                         }
                         catch (e) {
-                            _throwInternal(_postManager.diagLog(), 1 /* CRITICAL */, 519 /* PostResponseHandler */, "Response handler failed: " + e);
+                            _throwInternal(_postManager.diagLog(), 1 /* eLoggingSeverity.CRITICAL */, 519 /* _eExtendedInternalMessageId.PostResponseHandler */, "Response handler failed: " + e);
                         }
                     }
                     if (responseText) {
@@ -1009,14 +1009,14 @@ var HttpManager = /** @class */ (function () {
                 if (theBatches && theBatches.length > 0 && actions) {
                     var theAction_1 = actions[_getNotificationAction(batchReason)];
                     if (theAction_1) {
-                        var isSyncRequest_1 = sendType !== 0 /* Batched */;
+                        var isSyncRequest_1 = sendType !== 0 /* EventSendType.Batched */;
                         doPerf(_core, function () { return "HttpManager:_sendBatchesNotification"; }, function () {
                             _doAction(function () {
                                 try {
                                     theAction_1.call(actions, theBatches, batchReason, isSyncRequest_1, sendType);
                                 }
                                 catch (e) {
-                                    _throwInternal(_postManager.diagLog(), 1 /* CRITICAL */, 74 /* NotificationException */, "send request notification failed: " + e);
+                                    _throwInternal(_postManager.diagLog(), 1 /* eLoggingSeverity.CRITICAL */, 74 /* _eInternalMessageId.NotificationException */, "send request notification failed: " + e);
                                 }
                             }, sendSync || isSyncRequest_1, 0);
                         }, function () { return ({ batches: _createDebugBatches(theBatches), reason: batchReason, isSync: isSyncRequest_1, sendSync: sendSync, sendType: sendType }); }, !isSyncRequest_1);
@@ -1027,13 +1027,13 @@ var HttpManager = /** @class */ (function () {
                 var action = _eventActionMap[reason];
                 if (!isValueAssigned(action)) {
                     action = strOther;
-                    if (reason >= 9000 /* ResponseFailure */ && reason <= 9999 /* ResponseFailureMax */) {
+                    if (reason >= 9000 /* EventBatchNotificationReason.ResponseFailure */ && reason <= 9999 /* EventBatchNotificationReason.ResponseFailureMax */) {
                         action = strResponseFail;
                     }
-                    else if (reason >= 8000 /* EventsDropped */ && reason <= 8999 /* EventsDroppedMax */) {
+                    else if (reason >= 8000 /* EventBatchNotificationReason.EventsDropped */ && reason <= 8999 /* EventBatchNotificationReason.EventsDroppedMax */) {
                         action = strDropped;
                     }
-                    else if (reason >= 1000 /* SendingUndefined */ && reason <= 1999 /* SendingEventMax */) {
+                    else if (reason >= 1000 /* EventBatchNotificationReason.SendingUndefined */ && reason <= 1999 /* EventBatchNotificationReason.SendingEventMax */) {
                         action = strSending;
                     }
                 }