coveo.analytics 2.23.5 → 2.23.6

package/dist/coveoua.debug.js

@@ -0,0 +1,3259 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+    typeof define === 'function' && define.amd ? define(factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.coveoua = factory());
+})(this, (function () { 'use strict';
+
+    /*! *****************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */
+    /* global Reflect, Promise */
+
+    var extendStatics = function(d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+
+    function __extends(d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    }
+
+    var __assign = function() {
+        __assign = Object.assign || function __assign(t) {
+            for (var s, i = 1, n = arguments.length; i < n; i++) {
+                s = arguments[i];
+                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+            }
+            return t;
+        };
+        return __assign.apply(this, arguments);
+    };
+
+    function __rest(s, e) {
+        var t = {};
+        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+            t[p] = s[p];
+        if (s != null && typeof Object.getOwnPropertySymbols === "function")
+            for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+                if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                    t[p[i]] = s[p[i]];
+            }
+        return t;
+    }
+
+    function __awaiter(thisArg, _arguments, P, generator) {
+        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+        return new (P || (P = Promise))(function (resolve, reject) {
+            function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+            function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+            step((generator = generator.apply(thisArg, _arguments || [])).next());
+        });
+    }
+
+    function __generator(thisArg, body) {
+        var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+        function verb(n) { return function (v) { return step([n, v]); }; }
+        function step(op) {
+            if (f) throw new TypeError("Generator is already executing.");
+            while (_) try {
+                if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+                if (y = 0, t) op = [op[0] & 2, t.value];
+                switch (op[0]) {
+                    case 0: case 1: t = op; break;
+                    case 4: _.label++; return { value: op[1], done: false };
+                    case 5: _.label++; y = op[1]; op = [0]; continue;
+                    case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                    default:
+                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                        if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                        if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                        if (t[2]) _.ops.pop();
+                        _.trys.pop(); continue;
+                }
+                op = body.call(thisArg, _);
+            } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+            if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+        }
+    }
+
+    function __spreadArrays() {
+        for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+        for (var r = Array(s), k = 0, i = 0; i < il; i++)
+            for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+                r[k] = a[j];
+        return r;
+    }
+
+    var EventType;
+    (function (EventType) {
+        EventType["search"] = "search";
+        EventType["click"] = "click";
+        EventType["custom"] = "custom";
+        EventType["view"] = "view";
+        EventType["collect"] = "collect";
+    })(EventType || (EventType = {}));
+
+    function hasWindow() {
+        return typeof window !== 'undefined';
+    }
+    function hasNavigator() {
+        return typeof navigator !== 'undefined';
+    }
+    function hasDocument() {
+        return typeof document !== 'undefined';
+    }
+    function hasLocalStorage() {
+        try {
+            return typeof localStorage !== 'undefined';
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    function hasSessionStorage() {
+        try {
+            return typeof sessionStorage !== 'undefined';
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    function hasCookieStorage() {
+        return hasNavigator() && navigator.cookieEnabled;
+    }
+    function hasCrypto() {
+        return typeof crypto !== 'undefined';
+    }
+    function hasCryptoRandomValues() {
+        return hasCrypto() && typeof crypto.getRandomValues !== 'undefined';
+    }
+
+    var eventTypesForDefaultValues = [EventType.click, EventType.custom, EventType.search, EventType.view];
+    var addDefaultValues = function (eventType, payload) {
+        return eventTypesForDefaultValues.indexOf(eventType) !== -1
+            ? __assign({ language: hasDocument() ? document.documentElement.lang : 'unknown', userAgent: hasNavigator() ? navigator.userAgent : 'unknown' }, payload) : payload;
+    };
+
+    var Cookie = (function () {
+        function Cookie() {
+        }
+        Cookie.set = function (name, value, expiration) {
+            var domain, domainParts, date, expires, host;
+            if (expiration) {
+                date = new Date();
+                date.setTime(date.getTime() + expiration);
+                expires = '; expires=' + date.toGMTString();
+            }
+            else {
+                expires = '';
+            }
+            host = window.location.hostname;
+            if (host.indexOf('.') === -1) {
+                document.cookie = name + '=' + value + expires + '; path=/';
+            }
+            else {
+                domainParts = host.split('.');
+                domainParts.shift();
+                domain = '.' + domainParts.join('.');
+                writeCookie({ name: name, value: value, expires: expires, domain: domain });
+                if (Cookie.get(name) == null || Cookie.get(name) != value) {
+                    domain = '.' + host;
+                    writeCookie({ name: name, value: value, expires: expires, domain: domain });
+                }
+            }
+        };
+        Cookie.get = function (name) {
+            var cookiePrefix = name + '=';
+            var cookieArray = document.cookie.split(';');
+            for (var i = 0; i < cookieArray.length; i++) {
+                var cookie = cookieArray[i];
+                cookie = cookie.replace(/^\s+/, '');
+                if (cookie.indexOf(cookiePrefix) == 0) {
+                    return cookie.substring(cookiePrefix.length, cookie.length);
+                }
+            }
+            return null;
+        };
+        Cookie.erase = function (name) {
+            Cookie.set(name, '', -1);
+        };
+        return Cookie;
+    }());
+    function writeCookie(details) {
+        var name = details.name, value = details.value, expires = details.expires, domain = details.domain;
+        document.cookie = name + "=" + value + expires + "; path=/; domain=" + domain + "; SameSite=Lax";
+    }
+
+    var preferredStorage = null;
+    function getAvailableStorage() {
+        if (hasLocalStorage()) {
+            return localStorage;
+        }
+        if (hasCookieStorage()) {
+            return new CookieStorage();
+        }
+        if (hasSessionStorage()) {
+            return sessionStorage;
+        }
+        return new NullStorage();
+    }
+    var CookieStorage = (function () {
+        function CookieStorage() {
+        }
+        CookieStorage.prototype.getItem = function (key) {
+            return Cookie.get("" + CookieStorage.prefix + key);
+        };
+        CookieStorage.prototype.removeItem = function (key) {
+            Cookie.erase("" + CookieStorage.prefix + key);
+        };
+        CookieStorage.prototype.setItem = function (key, data) {
+            Cookie.set("" + CookieStorage.prefix + key, data);
+        };
+        CookieStorage.prefix = 'coveo_';
+        return CookieStorage;
+    }());
+    var CookieAndLocalStorage = (function () {
+        function CookieAndLocalStorage() {
+            this.cookieStorage = new CookieStorage();
+        }
+        CookieAndLocalStorage.prototype.getItem = function (key) {
+            return localStorage.getItem(key) || this.cookieStorage.getItem(key);
+        };
+        CookieAndLocalStorage.prototype.removeItem = function (key) {
+            this.cookieStorage.removeItem(key);
+            localStorage.removeItem(key);
+        };
+        CookieAndLocalStorage.prototype.setItem = function (key, data) {
+            localStorage.setItem(key, data);
+            this.cookieStorage.setItem(key, data);
+        };
+        return CookieAndLocalStorage;
+    }());
+    var NullStorage = (function () {
+        function NullStorage() {
+        }
+        NullStorage.prototype.getItem = function (key) {
+            return null;
+        };
+        NullStorage.prototype.removeItem = function (key) {
+        };
+        NullStorage.prototype.setItem = function (key, data) {
+        };
+        return NullStorage;
+    }());
+
+    var storage = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        preferredStorage: preferredStorage,
+        getAvailableStorage: getAvailableStorage,
+        CookieStorage: CookieStorage,
+        CookieAndLocalStorage: CookieAndLocalStorage,
+        NullStorage: NullStorage
+    });
+
+    var STORE_KEY = '__coveo.analytics.history';
+    var MAX_NUMBER_OF_HISTORY_ELEMENTS = 20;
+    var MIN_THRESHOLD_FOR_DUPLICATE_VALUE = 1000 * 60;
+    var MAX_VALUE_SIZE = 75;
+    var HistoryStore = (function () {
+        function HistoryStore(store) {
+            this.store = store || getAvailableStorage();
+        }
+        HistoryStore.prototype.addElement = function (elem) {
+            elem.internalTime = new Date().getTime();
+            elem = this.cropQueryElement(this.stripEmptyQuery(elem));
+            var currentHistory = this.getHistoryWithInternalTime();
+            if (currentHistory != null) {
+                if (this.isValidEntry(elem)) {
+                    this.setHistory([elem].concat(currentHistory));
+                }
+            }
+            else {
+                this.setHistory([elem]);
+            }
+        };
+        HistoryStore.prototype.addElementAsync = function (elem) {
+            return __awaiter(this, void 0, void 0, function () {
+                var currentHistory;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            elem.internalTime = new Date().getTime();
+                            elem = this.cropQueryElement(this.stripEmptyQuery(elem));
+                            return [4, this.getHistoryWithInternalTimeAsync()];
+                        case 1:
+                            currentHistory = _a.sent();
+                            if (currentHistory != null) {
+                                if (this.isValidEntry(elem)) {
+                                    this.setHistory([elem].concat(currentHistory));
+                                }
+                            }
+                            else {
+                                this.setHistory([elem]);
+                            }
+                            return [2];
+                    }
+                });
+            });
+        };
+        HistoryStore.prototype.getHistory = function () {
+            var history = this.getHistoryWithInternalTime();
+            return this.stripEmptyQueries(this.stripInternalTime(history));
+        };
+        HistoryStore.prototype.getHistoryAsync = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var history;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4, this.getHistoryWithInternalTimeAsync()];
+                        case 1:
+                            history = _a.sent();
+                            return [2, this.stripEmptyQueries(this.stripInternalTime(history))];
+                    }
+                });
+            });
+        };
+        HistoryStore.prototype.getHistoryWithInternalTime = function () {
+            try {
+                var elements = this.store.getItem(STORE_KEY);
+                if (elements && typeof elements === 'string') {
+                    return JSON.parse(elements);
+                }
+                else {
+                    return [];
+                }
+            }
+            catch (e) {
+                return [];
+            }
+        };
+        HistoryStore.prototype.getHistoryWithInternalTimeAsync = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var elements;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            _a.trys.push([0, 2, , 3]);
+                            return [4, this.store.getItem(STORE_KEY)];
+                        case 1:
+                            elements = _a.sent();
+                            if (elements) {
+                                return [2, JSON.parse(elements)];
+                            }
+                            else {
+                                return [2, []];
+                            }
+                        case 2:
+                            _a.sent();
+                            return [2, []];
+                        case 3: return [2];
+                    }
+                });
+            });
+        };
+        HistoryStore.prototype.setHistory = function (history) {
+            try {
+                this.store.setItem(STORE_KEY, JSON.stringify(history.slice(0, MAX_NUMBER_OF_HISTORY_ELEMENTS)));
+            }
+            catch (e) {
+            }
+        };
+        HistoryStore.prototype.clear = function () {
+            try {
+                this.store.removeItem(STORE_KEY);
+            }
+            catch (e) {
+            }
+        };
+        HistoryStore.prototype.getMostRecentElement = function () {
+            var currentHistory = this.getHistoryWithInternalTime();
+            if (currentHistory != null) {
+                var sorted = currentHistory.sort(function (first, second) {
+                    return (second.internalTime || 0) - (first.internalTime || 0);
+                });
+                return sorted[0];
+            }
+            return null;
+        };
+        HistoryStore.prototype.cropQueryElement = function (part) {
+            if (part.name && part.value && part.name.toLowerCase() === 'query') {
+                part.value = part.value.slice(0, MAX_VALUE_SIZE);
+            }
+            return part;
+        };
+        HistoryStore.prototype.isValidEntry = function (elem) {
+            var lastEntry = this.getMostRecentElement();
+            if (lastEntry && lastEntry.value == elem.value) {
+                return (elem.internalTime || 0) - (lastEntry.internalTime || 0) > MIN_THRESHOLD_FOR_DUPLICATE_VALUE;
+            }
+            return true;
+        };
+        HistoryStore.prototype.stripInternalTime = function (history) {
+            return history.map(function (part) {
+                var name = part.name, time = part.time, value = part.value;
+                return { name: name, time: time, value: value };
+            });
+        };
+        HistoryStore.prototype.stripEmptyQuery = function (part) {
+            var name = part.name, time = part.time, value = part.value;
+            if (name && typeof value === 'string' && name.toLowerCase() === 'query' && value.trim() === '') {
+                return { name: name, time: time };
+            }
+            return part;
+        };
+        HistoryStore.prototype.stripEmptyQueries = function (history) {
+            var _this = this;
+            return history.map(function (part) { return _this.stripEmptyQuery(part); });
+        };
+        return HistoryStore;
+    }());
+
+    var history = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        STORE_KEY: STORE_KEY,
+        MAX_NUMBER_OF_HISTORY_ELEMENTS: MAX_NUMBER_OF_HISTORY_ELEMENTS,
+        MIN_THRESHOLD_FOR_DUPLICATE_VALUE: MIN_THRESHOLD_FOR_DUPLICATE_VALUE,
+        MAX_VALUE_SIZE: MAX_VALUE_SIZE,
+        HistoryStore: HistoryStore,
+        'default': HistoryStore
+    });
+
+    var enhanceViewEvent = function (eventType, payload) { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!(eventType === EventType.view)) return [3, 2];
+                    return [4, addPageViewToHistory(payload.contentIdValue)];
+                case 1:
+                    _a.sent();
+                    return [2, __assign({ location: window.location.toString(), referrer: document.referrer, title: document.title }, payload)];
+                case 2: return [2, payload];
+            }
+        });
+    }); };
+    var addPageViewToHistory = function (pageViewValue) { return __awaiter(void 0, void 0, void 0, function () {
+        var store, historyElement;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    store = new HistoryStore();
+                    historyElement = {
+                        name: 'PageView',
+                        value: pageViewValue,
+                        time: JSON.stringify(new Date()),
+                    };
+                    return [4, store.addElementAsync(historyElement)];
+                case 1:
+                    _a.sent();
+                    return [2];
+            }
+        });
+    }); };
+
+    var uuidv4 = function (a) {
+        if (!!a) {
+            return (Number(a) ^ (getRandomValues(new Uint8Array(1))[0] % 16 >> (Number(a) / 4))).toString(16);
+        }
+        return ("" + 1e7 + -1e3 + -4e3 + -8e3 + -1e11).replace(/[018]/g, uuidv4);
+    };
+    var getRandomValues = function (rnds) {
+        if (hasCryptoRandomValues()) {
+            return crypto.getRandomValues(rnds);
+        }
+        for (var i = 0, r = 0; i < rnds.length; i++) {
+            if ((i & 0x03) === 0) {
+                r = Math.random() * 0x100000000;
+            }
+            rnds[i] = (r >>> ((i & 0x03) << 3)) & 0xff;
+        }
+        return rnds;
+    };
+
+    var keysOf = Object.keys;
+
+    var ticketKeysMapping = {
+        id: 'svc_ticket_id',
+        subject: 'svc_ticket_subject',
+        description: 'svc_ticket_description',
+        category: 'svc_ticket_category',
+        productId: 'svc_ticket_product_id',
+        custom: 'svc_ticket_custom',
+    };
+    var ticketKeysMappingValues = keysOf(ticketKeysMapping).map(function (key) { return ticketKeysMapping[key]; });
+    var ticketSubKeysMatchGroup = __spreadArrays(ticketKeysMappingValues).join('|');
+    var ticketKeyRegex = new RegExp("^(" + ticketSubKeysMatchGroup + "$)");
+    var serviceActionsKeysMapping = {
+        svcAction: 'svc_action',
+        svcActionData: 'svc_action_data',
+    };
+    var convertTicketToMeasurementProtocol = function (ticket) {
+        return keysOf(ticket)
+            .filter(function (key) { return ticket[key] !== undefined; })
+            .reduce(function (mappedTicket, key) {
+            var _a;
+            var newKey = ticketKeysMapping[key] || key;
+            return __assign(__assign({}, mappedTicket), (_a = {}, _a[newKey] = ticket[key], _a));
+        }, {});
+    };
+    var isTicketKey = function (key) { return ticketKeyRegex.test(key); };
+    var isServiceKey = [isTicketKey];
+
+    var productKeysMapping = {
+        id: 'id',
+        name: 'nm',
+        brand: 'br',
+        category: 'ca',
+        variant: 'va',
+        price: 'pr',
+        quantity: 'qt',
+        coupon: 'cc',
+        position: 'ps',
+        group: 'group',
+    };
+    var impressionKeysMapping = {
+        id: 'id',
+        name: 'nm',
+        brand: 'br',
+        category: 'ca',
+        variant: 'va',
+        position: 'ps',
+        price: 'pr',
+        group: 'group',
+    };
+    var productActionsKeysMapping = {
+        action: 'pa',
+        list: 'pal',
+        listSource: 'pls',
+    };
+    var transactionActionsKeysMapping = {
+        id: 'ti',
+        revenue: 'tr',
+        tax: 'tt',
+        shipping: 'ts',
+        coupon: 'tcc',
+        affiliation: 'ta',
+        step: 'cos',
+        option: 'col',
+    };
+    var coveoCommerceExtensionKeys = [
+        'loyaltyCardId',
+        'loyaltyTier',
+        'thirdPartyPersona',
+        'companyName',
+        'favoriteStore',
+        'storeName',
+        'userIndustry',
+        'userRole',
+        'userDepartment',
+        'businessUnit',
+    ];
+    var quoteActionsKeysMapping = {
+        id: 'quoteId',
+        affiliation: 'quoteAffiliation',
+    };
+    var reviewActionsKeysMapping = {
+        id: 'reviewId',
+        rating: 'reviewRating',
+        comment: 'reviewComment',
+    };
+    var commerceActionKeysMappingPerAction = {
+        add: productActionsKeysMapping,
+        bookmark_add: productActionsKeysMapping,
+        bookmark_remove: productActionsKeysMapping,
+        click: productActionsKeysMapping,
+        checkout: productActionsKeysMapping,
+        checkout_option: productActionsKeysMapping,
+        detail: productActionsKeysMapping,
+        impression: productActionsKeysMapping,
+        remove: productActionsKeysMapping,
+        refund: __assign(__assign({}, productActionsKeysMapping), transactionActionsKeysMapping),
+        purchase: __assign(__assign({}, productActionsKeysMapping), transactionActionsKeysMapping),
+        quickview: productActionsKeysMapping,
+        quote: __assign(__assign({}, productActionsKeysMapping), quoteActionsKeysMapping),
+        review: __assign(__assign({}, productActionsKeysMapping), reviewActionsKeysMapping),
+    };
+    var convertProductToMeasurementProtocol = function (product, index) {
+        return keysOf(product).reduce(function (mappedProduct, key) {
+            var _a;
+            var newKey = "pr" + (index + 1) + (productKeysMapping[key] || key);
+            return __assign(__assign({}, mappedProduct), (_a = {}, _a[newKey] = product[key], _a));
+        }, {});
+    };
+    var convertImpressionListToMeasurementProtocol = function (impressionList, listIndex, prefix) {
+        var payload = impressionList.impressions.reduce(function (mappedImpressions, impression, productIndex) {
+            return __assign(__assign({}, mappedImpressions), convertImpressionToMeasurementProtocol(impression, listIndex, productIndex, prefix));
+        }, {});
+        if (impressionList.listName) {
+            var listNameKey = "il" + (listIndex + 1) + "nm";
+            payload[listNameKey] = impressionList.listName;
+        }
+        return payload;
+    };
+    var convertImpressionToMeasurementProtocol = function (impression, listIndex, productIndex, prefix) {
+        return keysOf(impression).reduce(function (mappedImpression, key) {
+            var _a;
+            var newKey = "il" + (listIndex + 1) + prefix + (productIndex + 1) + (impressionKeysMapping[key] || key);
+            return __assign(__assign({}, mappedImpression), (_a = {}, _a[newKey] = impression[key], _a));
+        }, {});
+    };
+    var productKeysMappingValues = keysOf(productKeysMapping).map(function (key) { return productKeysMapping[key]; });
+    var impressionKeysMappingValues = keysOf(impressionKeysMapping).map(function (key) { return impressionKeysMapping[key]; });
+    var productActionsKeysMappingValues = keysOf(productActionsKeysMapping).map(function (key) { return productActionsKeysMapping[key]; });
+    var transactionActionsKeysMappingValues = keysOf(transactionActionsKeysMapping).map(function (key) { return transactionActionsKeysMapping[key]; });
+    var reviewKeysMappingValues = keysOf(reviewActionsKeysMapping).map(function (key) { return reviewActionsKeysMapping[key]; });
+    var quoteKeysMappingValues = keysOf(quoteActionsKeysMapping).map(function (key) { return quoteActionsKeysMapping[key]; });
+    var productSubKeysMatchGroup = __spreadArrays(productKeysMappingValues, ['custom']).join('|');
+    var impressionSubKeysMatchGroup = __spreadArrays(impressionKeysMappingValues, ['custom']).join('|');
+    var productPrefixMatchGroup = '(pr[0-9]+)';
+    var impressionPrefixMatchGroup = '(il[0-9]+pi[0-9]+)';
+    var productKeyRegex = new RegExp("^" + productPrefixMatchGroup + "(" + productSubKeysMatchGroup + ")$");
+    var impressionKeyRegex = new RegExp("^(" + impressionPrefixMatchGroup + "(" + impressionSubKeysMatchGroup + "))|(il[0-9]+nm)$");
+    var productActionsKeyRegex = new RegExp("^(" + productActionsKeysMappingValues.join('|') + ")$");
+    var transactionActionsKeyRegex = new RegExp("^(" + transactionActionsKeysMappingValues.join('|') + ")$");
+    var customProductKeyRegex = new RegExp("^" + productPrefixMatchGroup + "custom$");
+    var customImpressionKeyRegex = new RegExp("^" + impressionPrefixMatchGroup + "custom$");
+    var coveoCommerceExtensionKeysRegex = new RegExp("^(" + __spreadArrays(coveoCommerceExtensionKeys, reviewKeysMappingValues, quoteKeysMappingValues).join('|') + ")$");
+    var isProductKey = function (key) { return productKeyRegex.test(key); };
+    var isImpressionKey = function (key) { return impressionKeyRegex.test(key); };
+    var isProductActionsKey = function (key) { return productActionsKeyRegex.test(key); };
+    var isTransactionActionsKeyRegex = function (key) { return transactionActionsKeyRegex.test(key); };
+    var isCoveoCommerceExtensionKey = function (key) { return coveoCommerceExtensionKeysRegex.test(key); };
+    var isCommerceKey = [
+        isImpressionKey,
+        isProductKey,
+        isProductActionsKey,
+        isTransactionActionsKeyRegex,
+        isCoveoCommerceExtensionKey,
+    ];
+    var isCustomCommerceKey = [customProductKeyRegex, customImpressionKeyRegex];
+
+    var globalParamKeysMapping = {
+        anonymizeIp: 'aip',
+    };
+    var eventKeysMapping = {
+        eventCategory: 'ec',
+        eventAction: 'ea',
+        eventLabel: 'el',
+        eventValue: 'ev',
+        page: 'dp',
+        visitorId: 'cid',
+        clientId: 'cid',
+        userId: 'uid',
+        currencyCode: 'cu',
+    };
+    var contextInformationMapping = {
+        hitType: 't',
+        pageViewId: 'pid',
+        encoding: 'de',
+        location: 'dl',
+        referrer: 'dr',
+        screenColor: 'sd',
+        screenResolution: 'sr',
+        title: 'dt',
+        userAgent: 'ua',
+        language: 'ul',
+        eventId: 'z',
+        time: 'tm',
+    };
+    var coveoExtensionsKeys = [
+        'contentId',
+        'contentIdKey',
+        'contentType',
+        'searchHub',
+        'tab',
+        'searchUid',
+        'permanentId',
+        'contentLocale',
+    ];
+    var baseMeasurementProtocolKeysMapping = __assign(__assign(__assign(__assign({}, globalParamKeysMapping), eventKeysMapping), contextInformationMapping), coveoExtensionsKeys.reduce(function (all, key) {
+        var _a;
+        return (__assign(__assign({}, all), (_a = {}, _a[key] = key, _a)));
+    }, {}));
+
+    var measurementProtocolKeysMapping = __assign(__assign({}, baseMeasurementProtocolKeysMapping), serviceActionsKeysMapping);
+    var convertKeysToMeasurementProtocol = function (params) {
+        var keysMappingForAction = (!!params.action && commerceActionKeysMappingPerAction[params.action]) || {};
+        return keysOf(params).reduce(function (mappedKeys, key) {
+            var _a;
+            var newKey = keysMappingForAction[key] || measurementProtocolKeysMapping[key] || key;
+            return __assign(__assign({}, mappedKeys), (_a = {}, _a[newKey] = params[key], _a));
+        }, {});
+    };
+    var measurementProtocolKeysMappingValues = keysOf(measurementProtocolKeysMapping).map(function (key) { return measurementProtocolKeysMapping[key]; });
+    var isKnownMeasurementProtocolKey = function (key) { return measurementProtocolKeysMappingValues.indexOf(key) !== -1; };
+    var isCustomKey = function (key) { return key === 'custom'; };
+    var isMeasurementProtocolKey = function (key) {
+        return __spreadArrays(isCommerceKey, isServiceKey, [isKnownMeasurementProtocolKey, isCustomKey]).some(function (test) { return test(key); });
+    };
+    var convertCustomMeasurementProtocolKeys = function (data) {
+        return keysOf(data).reduce(function (all, current) {
+            var _a;
+            var match = getFirstCustomMeasurementProtocolKeyMatch(current);
+            if (match) {
+                return __assign(__assign({}, all), convertCustomObject(match, data[current]));
+            }
+            else {
+                return __assign(__assign({}, all), (_a = {}, _a[current] = data[current], _a));
+            }
+        }, {});
+    };
+    var getFirstCustomMeasurementProtocolKeyMatch = function (key) {
+        var matchedKey = undefined;
+        __spreadArrays(isCustomCommerceKey).every(function (regex) {
+            var _a;
+            matchedKey = (_a = regex.exec(key)) === null || _a === void 0 ? void 0 : _a[1];
+            return !Boolean(matchedKey);
+        });
+        return matchedKey;
+    };
+    var convertCustomObject = function (prefix, customData) {
+        return keysOf(customData).reduce(function (allCustom, currentCustomKey) {
+            var _a;
+            return (__assign(__assign({}, allCustom), (_a = {}, _a["" + prefix + currentCustomKey] = customData[currentCustomKey], _a)));
+        }, {});
+    };
+
+    var AnalyticsBeaconClient = (function () {
+        function AnalyticsBeaconClient(opts) {
+            this.opts = opts;
+        }
+        AnalyticsBeaconClient.prototype.sendEvent = function (eventType, payload) {
+            return __awaiter(this, void 0, void 0, function () {
+                var _a, baseUrl, preprocessRequest, parsedRequestData, paramsFragments, defaultOptions, _b, url, body, _c, _d;
+                return __generator(this, function (_e) {
+                    switch (_e.label) {
+                        case 0:
+                            if (!navigator.sendBeacon) {
+                                throw new Error("navigator.sendBeacon is not supported in this browser. Consider adding a polyfill like \"sendbeacon-polyfill\".");
+                            }
+                            _a = this.opts, baseUrl = _a.baseUrl, preprocessRequest = _a.preprocessRequest;
+                            parsedRequestData = this.encodeForEventType(eventType, payload);
+                            return [4, this.getQueryParamsForEventType(eventType)];
+                        case 1:
+                            paramsFragments = _e.sent();
+                            defaultOptions = {
+                                url: baseUrl + "/analytics/" + eventType + "?" + paramsFragments,
+                                body: new Blob([parsedRequestData], {
+                                    type: 'application/x-www-form-urlencoded',
+                                }),
+                            };
+                            _c = [__assign({}, defaultOptions)];
+                            if (!preprocessRequest) return [3, 3];
+                            return [4, preprocessRequest(defaultOptions, 'analyticsBeacon')];
+                        case 2:
+                            _d = _e.sent();
+                            return [3, 4];
+                        case 3:
+                            _d = {};
+                            _e.label = 4;
+                        case 4:
+                            _b = __assign.apply(void 0, _c.concat([(_d)])), url = _b.url, body = _b.body;
+                            console.log("Sending beacon for \"" + eventType + "\" with: ", JSON.stringify(payload));
+                            navigator.sendBeacon(url, body);
+                            return [2];
+                    }
+                });
+            });
+        };
+        AnalyticsBeaconClient.prototype.deleteHttpCookieVisitorId = function () {
+            return Promise.resolve();
+        };
+        AnalyticsBeaconClient.prototype.encodeForEventType = function (eventType, payload) {
+            return this.isEventTypeLegacy(eventType)
+                ? this.encodeForLegacyType(eventType, payload)
+                : this.encodeForFormUrlEncoded(__assign({ access_token: this.opts.token }, payload));
+        };
+        AnalyticsBeaconClient.prototype.getQueryParamsForEventType = function (eventType) {
+            return __awaiter(this, void 0, void 0, function () {
+                var _a, token, visitorIdProvider, visitorId;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            _a = this.opts, token = _a.token, visitorIdProvider = _a.visitorIdProvider;
+                            return [4, visitorIdProvider.getCurrentVisitorId()];
+                        case 1:
+                            visitorId = _b.sent();
+                            return [2, [
+                                    token && this.isEventTypeLegacy(eventType) ? "access_token=" + token : '',
+                                    visitorId ? "visitorId=" + visitorId : '',
+                                    'discardVisitInfo=true',
+                                ]
+                                    .filter(function (p) { return !!p; })
+                                    .join('&')];
+                    }
+                });
+            });
+        };
+        AnalyticsBeaconClient.prototype.isEventTypeLegacy = function (eventType) {
+            return [EventType.click, EventType.custom, EventType.search, EventType.view].indexOf(eventType) !== -1;
+        };
+        AnalyticsBeaconClient.prototype.encodeForLegacyType = function (eventType, payload) {
+            return eventType + "Event=" + encodeURIComponent(JSON.stringify(payload));
+        };
+        AnalyticsBeaconClient.prototype.encodeForFormUrlEncoded = function (payload) {
+            var _this = this;
+            return Object.keys(payload)
+                .filter(function (key) { return !!payload[key]; })
+                .map(function (key) { return encodeURIComponent(key) + "=" + encodeURIComponent(_this.encodeValue(payload[key])); })
+                .join('&');
+        };
+        AnalyticsBeaconClient.prototype.encodeValue = function (value) {
+            return typeof value === 'number' || typeof value === 'string' || typeof value === 'boolean'
+                ? value
+                : JSON.stringify(value);
+        };
+        return AnalyticsBeaconClient;
+    }());
+
+    var NoopAnalyticsClient = (function () {
+        function NoopAnalyticsClient() {
+        }
+        NoopAnalyticsClient.prototype.sendEvent = function (_, __) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2, Promise.resolve()];
+                });
+            });
+        };
+        NoopAnalyticsClient.prototype.deleteHttpCookieVisitorId = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2, Promise.resolve()];
+                });
+            });
+        };
+        return NoopAnalyticsClient;
+    }());
+
+    var fetch$2 = window.fetch;
+
+    var AnalyticsFetchClient = (function () {
+        function AnalyticsFetchClient(opts) {
+            this.opts = opts;
+        }
+        AnalyticsFetchClient.prototype.sendEvent = function (eventType, payload) {
+            return __awaiter(this, void 0, void 0, function () {
+                var _a, baseUrl, visitorIdProvider, preprocessRequest, visitorIdParam, _b, defaultOptions, _c, url, fetchData, _d, _e, response, visit;
+                return __generator(this, function (_f) {
+                    switch (_f.label) {
+                        case 0:
+                            _a = this.opts, baseUrl = _a.baseUrl, visitorIdProvider = _a.visitorIdProvider, preprocessRequest = _a.preprocessRequest;
+                            if (!this.shouldAppendVisitorId(eventType)) return [3, 2];
+                            return [4, this.getVisitorIdParam()];
+                        case 1:
+                            _b = _f.sent();
+                            return [3, 3];
+                        case 2:
+                            _b = '';
+                            _f.label = 3;
+                        case 3:
+                            visitorIdParam = _b;
+                            defaultOptions = {
+                                url: baseUrl + "/analytics/" + eventType + visitorIdParam,
+                                credentials: 'include',
+                                mode: 'cors',
+                                headers: this.getHeaders(),
+                                method: 'POST',
+                                body: JSON.stringify(payload),
+                            };
+                            _d = [__assign({}, defaultOptions)];
+                            if (!preprocessRequest) return [3, 5];
+                            return [4, preprocessRequest(defaultOptions, 'analyticsFetch')];
+                        case 4:
+                            _e = _f.sent();
+                            return [3, 6];
+                        case 5:
+                            _e = {};
+                            _f.label = 6;
+                        case 6:
+                            _c = __assign.apply(void 0, _d.concat([(_e)])), url = _c.url, fetchData = __rest(_c, ["url"]);
+                            return [4, fetch$2(url, fetchData)];
+                        case 7:
+                            response = _f.sent();
+                            if (!response.ok) return [3, 9];
+                            return [4, response.json()];
+                        case 8:
+                            visit = (_f.sent());
+                            if (visit.visitorId) {
+                                visitorIdProvider.setCurrentVisitorId(visit.visitorId);
+                            }
+                            return [2, visit];
+                        case 9:
+                            try {
+                                response.json();
+                            }
+                            catch (_g) {
+                            }
+                            console.error("An error has occured when sending the \"" + eventType + "\" event.", response, payload);
+                            throw new Error("An error has occurred when sending the \"" + eventType + "\" event. Check the console logs for more details.");
+                    }
+                });
+            });
+        };
+        AnalyticsFetchClient.prototype.deleteHttpCookieVisitorId = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var baseUrl, url;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            baseUrl = this.opts.baseUrl;
+                            url = baseUrl + "/analytics/visit";
+                            return [4, fetch$2(url, { headers: this.getHeaders(), method: 'DELETE' })];
+                        case 1:
+                            _a.sent();
+                            return [2];
+                    }
+                });
+            });
+        };
+        AnalyticsFetchClient.prototype.shouldAppendVisitorId = function (eventType) {
+            return [EventType.click, EventType.custom, EventType.search, EventType.view].indexOf(eventType) !== -1;
+        };
+        AnalyticsFetchClient.prototype.getVisitorIdParam = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var visitorIdProvider, visitorId;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            visitorIdProvider = this.opts.visitorIdProvider;
+                            return [4, visitorIdProvider.getCurrentVisitorId()];
+                        case 1:
+                            visitorId = _a.sent();
+                            return [2, visitorId ? "?visitor=" + visitorId : ''];
+                    }
+                });
+            });
+        };
+        AnalyticsFetchClient.prototype.getHeaders = function () {
+            var token = this.opts.token;
+            return __assign(__assign({}, (token ? { Authorization: "Bearer " + token } : {})), { 'Content-Type': "application/json" });
+        };
+        return AnalyticsFetchClient;
+    }());
+
+    var BrowserRuntime = (function () {
+        function BrowserRuntime(clientOptions, getUnprocessedRequests) {
+            var _this = this;
+            if (hasLocalStorage() && hasCookieStorage()) {
+                this.storage = new CookieAndLocalStorage();
+            }
+            else if (hasLocalStorage()) {
+                this.storage = localStorage;
+            }
+            else {
+                console.warn('BrowserRuntime detected no valid storage available.', this);
+                this.storage = new NullStorage();
+            }
+            this.client = new AnalyticsFetchClient(clientOptions);
+            this.beaconClient = new AnalyticsBeaconClient(clientOptions);
+            window.addEventListener('beforeunload', function () {
+                var requests = getUnprocessedRequests();
+                for (var _i = 0, requests_1 = requests; _i < requests_1.length; _i++) {
+                    var _a = requests_1[_i], eventType = _a.eventType, payload = _a.payload;
+                    _this.beaconClient.sendEvent(eventType, payload);
+                }
+            });
+        }
+        return BrowserRuntime;
+    }());
+    var NodeJSRuntime = (function () {
+        function NodeJSRuntime(clientOptions, storage) {
+            this.storage = storage || new NullStorage();
+            this.client = new AnalyticsFetchClient(clientOptions);
+        }
+        return NodeJSRuntime;
+    }());
+    var NoopRuntime = (function () {
+        function NoopRuntime() {
+            this.storage = new NullStorage();
+            this.client = new NoopAnalyticsClient();
+        }
+        return NoopRuntime;
+    }());
+
+    var API_KEY_PREFIX = 'xx';
+    var isApiKey = function (token) { return (token === null || token === void 0 ? void 0 : token.startsWith(API_KEY_PREFIX)) || false; };
+
+    var ReactNativeRuntimeWarning = "\n        We've detected you're using React Native but have not provided the corresponding runtime, \n        for an optimal experience please use the \"coveo.analytics/react-native\" subpackage.\n        Follow the Readme on how to set it up: https://github.com/coveo/coveo.analytics.js#using-react-native\n    ";
+    function isReactNative() {
+        return typeof navigator != 'undefined' && navigator.product == 'ReactNative';
+    }
+
+    var doNotTrackValues = ['1', 1, 'yes', true];
+    function doNotTrack() {
+        return (hasNavigator() &&
+            [
+                navigator.globalPrivacyControl,
+                navigator.doNotTrack,
+                navigator.msDoNotTrack,
+                window.doNotTrack,
+            ].some(function (value) { return doNotTrackValues.indexOf(value) !== -1; }));
+    }
+
+    var donottrack = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        doNotTrack: doNotTrack,
+        'default': doNotTrack
+    });
+
+    var Version = 'v15';
+    var Endpoints = {
+        default: 'https://analytics.cloud.coveo.com/rest/ua',
+        production: 'https://analytics.cloud.coveo.com/rest/ua',
+        hipaa: 'https://analyticshipaa.cloud.coveo.com/rest/ua',
+    };
+    function buildBaseUrl(endpoint, apiVersion) {
+        if (endpoint === void 0) { endpoint = Endpoints.default; }
+        if (apiVersion === void 0) { apiVersion = Version; }
+        var endpointIsCoveoProxy = endpoint.indexOf('.cloud.coveo.com') !== -1;
+        return "" + endpoint + (endpointIsCoveoProxy ? '' : '/rest') + "/" + apiVersion;
+    }
+    var CoveoAnalyticsClient = (function () {
+        function CoveoAnalyticsClient(opts) {
+            if (!opts) {
+                throw new Error('You have to pass options to this constructor');
+            }
+            this.options = __assign(__assign({}, this.defaultOptions), opts);
+            this.visitorId = '';
+            this.bufferedRequests = [];
+            this.beforeSendHooks = [enhanceViewEvent, addDefaultValues].concat(this.options.beforeSendHooks);
+            this.afterSendHooks = this.options.afterSendHooks;
+            this.eventTypeMapping = {};
+            var clientsOptions = {
+                baseUrl: this.baseUrl,
+                token: this.options.token,
+                visitorIdProvider: this,
+                preprocessRequest: this.options.preprocessRequest,
+            };
+            this.runtime = this.options.runtimeEnvironment || this.initRuntime(clientsOptions);
+            if (doNotTrack()) {
+                this.clear();
+                this.runtime.storage = new NullStorage();
+            }
+        }
+        Object.defineProperty(CoveoAnalyticsClient.prototype, "defaultOptions", {
+            get: function () {
+                return {
+                    endpoint: Endpoints.default,
+                    token: '',
+                    version: Version,
+                    beforeSendHooks: [],
+                    afterSendHooks: [],
+                };
+            },
+            enumerable: false,
+            configurable: true
+        });
+        CoveoAnalyticsClient.prototype.initRuntime = function (clientsOptions) {
+            var _this = this;
+            if (hasWindow() && hasDocument()) {
+                return new BrowserRuntime(clientsOptions, function () {
+                    var copy = __spreadArrays(_this.bufferedRequests);
+                    _this.bufferedRequests = [];
+                    return copy;
+                });
+            }
+            else if (isReactNative()) {
+                console.warn(ReactNativeRuntimeWarning);
+            }
+            return new NodeJSRuntime(clientsOptions);
+        };
+        Object.defineProperty(CoveoAnalyticsClient.prototype, "storage", {
+            get: function () {
+                return this.runtime.storage;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        CoveoAnalyticsClient.prototype.determineVisitorId = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var err_1;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            _a.trys.push([0, 2, , 3]);
+                            return [4, this.storage.getItem('visitorId')];
+                        case 1: return [2, (_a.sent()) || uuidv4()];
+                        case 2:
+                            err_1 = _a.sent();
+                            console.log('Could not get visitor ID from the current runtime environment storage. Using a random ID instead.', err_1);
+                            return [2, uuidv4()];
+                        case 3: return [2];
+                    }
+                });
+            });
+        };
+        CoveoAnalyticsClient.prototype.getCurrentVisitorId = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var id;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            if (!!this.visitorId) return [3, 3];
+                            return [4, this.determineVisitorId()];
+                        case 1:
+                            id = _a.sent();
+                            return [4, this.setCurrentVisitorId(id)];
+                        case 2:
+                            _a.sent();
+                            _a.label = 3;
+                        case 3: return [2, this.visitorId];
+                    }
+                });
+            });
+        };
+        CoveoAnalyticsClient.prototype.setCurrentVisitorId = function (visitorId) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            this.visitorId = visitorId;
+                            return [4, this.storage.setItem('visitorId', visitorId)];
+                        case 1:
+                            _a.sent();
+                            return [2];
+                    }
+                });
+            });
+        };
+        CoveoAnalyticsClient.prototype.getParameters = function (eventType) {
+            var payload = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                payload[_i - 1] = arguments[_i];
+            }
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4, this.resolveParameters.apply(this, __spreadArrays([eventType], payload))];
+                        case 1: return [2, _a.sent()];
+                    }
+                });
+            });
+        };
+        CoveoAnalyticsClient.prototype.getPayload = function (eventType) {
+            var payload = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                payload[_i - 1] = arguments[_i];
+            }
+            return __awaiter(this, void 0, void 0, function () {
+                var parametersToSend;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4, this.resolveParameters.apply(this, __spreadArrays([eventType], payload))];
+                        case 1:
+                            parametersToSend = _a.sent();
+                            return [4, this.resolvePayloadForParameters(eventType, parametersToSend)];
+                        case 2: return [2, _a.sent()];
+                    }
+                });
+            });
+        };
+        Object.defineProperty(CoveoAnalyticsClient.prototype, "currentVisitorId", {
+            get: function () {
+                var visitorId = this.visitorId || this.storage.getItem('visitorId');
+                if (typeof visitorId !== 'string') {
+                    this.setCurrentVisitorId(uuidv4());
+                }
+                return this.visitorId;
+            },
+            set: function (visitorId) {
+                this.visitorId = visitorId;
+                this.storage.setItem('visitorId', visitorId);
+            },
+            enumerable: false,
+            configurable: true
+        });
+        CoveoAnalyticsClient.prototype.resolveParameters = function (eventType) {
+            var payload = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                payload[_i - 1] = arguments[_i];
+            }
+            return __awaiter(this, void 0, void 0, function () {
+                var _a, _b, variableLengthArgumentsNames, _c, addVisitorIdParameter, _d, usesMeasurementProtocol, _e, addClientIdParameter, processVariableArgumentNamesStep, addVisitorIdStep, addClientIdStep, setAnonymousUserStep, processBeforeSendHooksStep, parametersToSend;
+                var _this = this;
+                return __generator(this, function (_f) {
+                    switch (_f.label) {
+                        case 0:
+                            _a = this.eventTypeMapping[eventType] || {}, _b = _a.variableLengthArgumentsNames, variableLengthArgumentsNames = _b === void 0 ? [] : _b, _c = _a.addVisitorIdParameter, addVisitorIdParameter = _c === void 0 ? false : _c, _d = _a.usesMeasurementProtocol, usesMeasurementProtocol = _d === void 0 ? false : _d, _e = _a.addClientIdParameter, addClientIdParameter = _e === void 0 ? false : _e;
+                            processVariableArgumentNamesStep = function (currentPayload) {
+                                return variableLengthArgumentsNames.length > 0
+                                    ? _this.parseVariableArgumentsPayload(variableLengthArgumentsNames, currentPayload)
+                                    : currentPayload[0];
+                            };
+                            addVisitorIdStep = function (currentPayload) { return __awaiter(_this, void 0, void 0, function () {
+                                var _a, _b, _c;
+                                return __generator(this, function (_d) {
+                                    switch (_d.label) {
+                                        case 0:
+                                            _a = [__assign({}, currentPayload)];
+                                            _b = {};
+                                            if (!addVisitorIdParameter) return [3, 2];
+                                            return [4, this.getCurrentVisitorId()];
+                                        case 1:
+                                            _c = _d.sent();
+                                            return [3, 3];
+                                        case 2:
+                                            _c = '';
+                                            _d.label = 3;
+                                        case 3: return [2, (__assign.apply(void 0, _a.concat([(_b.visitorId = _c, _b)])))];
+                                    }
+                                });
+                            }); };
+                            addClientIdStep = function (currentPayload) { return __awaiter(_this, void 0, void 0, function () {
+                                var _a, _b;
+                                return __generator(this, function (_c) {
+                                    switch (_c.label) {
+                                        case 0:
+                                            if (!addClientIdParameter) return [3, 2];
+                                            _a = [__assign({}, currentPayload)];
+                                            _b = {};
+                                            return [4, this.getCurrentVisitorId()];
+                                        case 1: return [2, __assign.apply(void 0, _a.concat([(_b.clientId = _c.sent(), _b)]))];
+                                        case 2: return [2, currentPayload];
+                                    }
+                                });
+                            }); };
+                            setAnonymousUserStep = function (currentPayload) {
+                                return usesMeasurementProtocol ? _this.ensureAnonymousUserWhenUsingApiKey(currentPayload) : currentPayload;
+                            };
+                            processBeforeSendHooksStep = function (currentPayload) {
+                                return _this.beforeSendHooks.reduce(function (promisePayload, current) { return __awaiter(_this, void 0, void 0, function () {
+                                    var payload;
+                                    return __generator(this, function (_a) {
+                                        switch (_a.label) {
+                                            case 0: return [4, promisePayload];
+                                            case 1:
+                                                payload = _a.sent();
+                                                return [4, current(eventType, payload)];
+                                            case 2: return [2, _a.sent()];
+                                        }
+                                    });
+                                }); }, currentPayload);
+                            };
+                            return [4, [
+                                    processVariableArgumentNamesStep,
+                                    addVisitorIdStep,
+                                    addClientIdStep,
+                                    setAnonymousUserStep,
+                                    processBeforeSendHooksStep,
+                                ].reduce(function (payloadPromise, step) { return __awaiter(_this, void 0, void 0, function () {
+                                    var payload;
+                                    return __generator(this, function (_a) {
+                                        switch (_a.label) {
+                                            case 0: return [4, payloadPromise];
+                                            case 1:
+                                                payload = _a.sent();
+                                                return [4, step(payload)];
+                                            case 2: return [2, _a.sent()];
+                                        }
+                                    });
+                                }); }, Promise.resolve(payload))];
+                        case 1:
+                            parametersToSend = _f.sent();
+                            return [2, parametersToSend];
+                    }
+                });
+            });
+        };
+        CoveoAnalyticsClient.prototype.resolvePayloadForParameters = function (eventType, parameters) {
+            return __awaiter(this, void 0, void 0, function () {
+                var _a, usesMeasurementProtocol, cleanPayloadStep, validateParams, processMeasurementProtocolConversionStep, removeUnknownParameters, processCustomParameters, payloadToSend;
+                var _this = this;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            _a = (this.eventTypeMapping[eventType] || {}).usesMeasurementProtocol, usesMeasurementProtocol = _a === void 0 ? false : _a;
+                            cleanPayloadStep = function (currentPayload) {
+                                return _this.removeEmptyPayloadValues(currentPayload, eventType);
+                            };
+                            validateParams = function (currentPayload) { return _this.validateParams(currentPayload); };
+                            processMeasurementProtocolConversionStep = function (currentPayload) {
+                                return usesMeasurementProtocol ? convertKeysToMeasurementProtocol(currentPayload) : currentPayload;
+                            };
+                            removeUnknownParameters = function (currentPayload) {
+                                return usesMeasurementProtocol ? _this.removeUnknownParameters(currentPayload) : currentPayload;
+                            };
+                            processCustomParameters = function (currentPayload) {
+                                return usesMeasurementProtocol ? _this.processCustomParameters(currentPayload) : currentPayload;
+                            };
+                            return [4, [
+                                    cleanPayloadStep,
+                                    validateParams,
+                                    processMeasurementProtocolConversionStep,
+                                    removeUnknownParameters,
+                                    processCustomParameters,
+                                ].reduce(function (payloadPromise, step) { return __awaiter(_this, void 0, void 0, function () {
+                                    var payload;
+                                    return __generator(this, function (_a) {
+                                        switch (_a.label) {
+                                            case 0: return [4, payloadPromise];
+                                            case 1:
+                                                payload = _a.sent();
+                                                return [4, step(payload)];
+                                            case 2: return [2, _a.sent()];
+                                        }
+                                    });
+                                }); }, Promise.resolve(parameters))];
+                        case 1:
+                            payloadToSend = _b.sent();
+                            return [2, payloadToSend];
+                    }
+                });
+            });
+        };
+        CoveoAnalyticsClient.prototype.sendEvent = function (eventType) {
+            var payload = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                payload[_i - 1] = arguments[_i];
+            }
+            return __awaiter(this, void 0, void 0, function () {
+                var _a, eventTypeToSend, parametersToSend, payloadToSend;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            _a = (this.eventTypeMapping[eventType] || {}).newEventType, eventTypeToSend = _a === void 0 ? eventType : _a;
+                            return [4, this.resolveParameters.apply(this, __spreadArrays([eventType], payload))];
+                        case 1:
+                            parametersToSend = _b.sent();
+                            return [4, this.resolvePayloadForParameters(eventType, parametersToSend)];
+                        case 2:
+                            payloadToSend = _b.sent();
+                            this.bufferedRequests.push({
+                                eventType: eventTypeToSend,
+                                payload: payloadToSend,
+                            });
+                            return [4, Promise.all(this.afterSendHooks.map(function (hook) { return hook(eventType, parametersToSend); }))];
+                        case 3:
+                            _b.sent();
+                            return [4, this.deferExecution()];
+                        case 4:
+                            _b.sent();
+                            return [4, this.sendFromBufferWithFetch()];
+                        case 5: return [2, _b.sent()];
+                    }
+                });
+            });
+        };
+        CoveoAnalyticsClient.prototype.deferExecution = function () {
+            return new Promise(function (resolve) { return setTimeout(resolve, 0); });
+        };
+        CoveoAnalyticsClient.prototype.sendFromBufferWithFetch = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var popped, eventType, payload;
+                return __generator(this, function (_a) {
+                    popped = this.bufferedRequests.shift();
+                    if (popped) {
+                        eventType = popped.eventType, payload = popped.payload;
+                        return [2, this.runtime.client.sendEvent(eventType, payload)];
+                    }
+                    return [2];
+                });
+            });
+        };
+        CoveoAnalyticsClient.prototype.clear = function () {
+            this.storage.removeItem('visitorId');
+            var store = new HistoryStore();
+            store.clear();
+        };
+        CoveoAnalyticsClient.prototype.deleteHttpOnlyVisitorId = function () {
+            this.runtime.client.deleteHttpCookieVisitorId();
+        };
+        CoveoAnalyticsClient.prototype.sendSearchEvent = function (request) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2, this.sendEvent(EventType.search, request)];
+                });
+            });
+        };
+        CoveoAnalyticsClient.prototype.sendClickEvent = function (request) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2, this.sendEvent(EventType.click, request)];
+                });
+            });
+        };
+        CoveoAnalyticsClient.prototype.sendCustomEvent = function (request) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2, this.sendEvent(EventType.custom, request)];
+                });
+            });
+        };
+        CoveoAnalyticsClient.prototype.sendViewEvent = function (request) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2, this.sendEvent(EventType.view, request)];
+                });
+            });
+        };
+        CoveoAnalyticsClient.prototype.getVisit = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var response, visit;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4, fetch(this.baseUrl + "/analytics/visit")];
+                        case 1:
+                            response = _a.sent();
+                            return [4, response.json()];
+                        case 2:
+                            visit = (_a.sent());
+                            this.visitorId = visit.visitorId;
+                            return [2, visit];
+                    }
+                });
+            });
+        };
+        CoveoAnalyticsClient.prototype.getHealth = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var response;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4, fetch(this.baseUrl + "/analytics/monitoring/health")];
+                        case 1:
+                            response = _a.sent();
+                            return [4, response.json()];
+                        case 2: return [2, (_a.sent())];
+                    }
+                });
+            });
+        };
+        CoveoAnalyticsClient.prototype.registerBeforeSendEventHook = function (hook) {
+            this.beforeSendHooks.push(hook);
+        };
+        CoveoAnalyticsClient.prototype.registerAfterSendEventHook = function (hook) {
+            this.afterSendHooks.push(hook);
+        };
+        CoveoAnalyticsClient.prototype.addEventTypeMapping = function (eventType, eventConfig) {
+            this.eventTypeMapping[eventType] = eventConfig;
+        };
+        CoveoAnalyticsClient.prototype.parseVariableArgumentsPayload = function (fieldsOrder, payload) {
+            var parsedArguments = {};
+            for (var i = 0, length_1 = payload.length; i < length_1; i++) {
+                var currentArgument = payload[i];
+                if (typeof currentArgument === 'string') {
+                    parsedArguments[fieldsOrder[i]] = currentArgument;
+                }
+                else if (typeof currentArgument === 'object') {
+                    return __assign(__assign({}, parsedArguments), currentArgument);
+                }
+            }
+            return parsedArguments;
+        };
+        CoveoAnalyticsClient.prototype.isKeyAllowedEmpty = function (evtType, key) {
+            var _a;
+            var keysThatCanBeEmpty = (_a = {},
+                _a[EventType.search] = ['queryText'],
+                _a);
+            var match = keysThatCanBeEmpty[evtType] || [];
+            return match.indexOf(key) !== -1;
+        };
+        CoveoAnalyticsClient.prototype.removeEmptyPayloadValues = function (payload, eventType) {
+            var _this = this;
+            var isNotEmptyValue = function (value) { return typeof value !== 'undefined' && value !== null && value !== ''; };
+            return Object.keys(payload)
+                .filter(function (key) { return _this.isKeyAllowedEmpty(eventType, key) || isNotEmptyValue(payload[key]); })
+                .reduce(function (newPayload, key) {
+                var _a;
+                return (__assign(__assign({}, newPayload), (_a = {}, _a[key] = payload[key], _a)));
+            }, {});
+        };
+        CoveoAnalyticsClient.prototype.removeUnknownParameters = function (payload) {
+            var newPayload = Object.keys(payload)
+                .filter(function (key) {
+                if (isMeasurementProtocolKey(key)) {
+                    return true;
+                }
+                else {
+                    console.log(key, 'is not processed by coveoua');
+                }
+            })
+                .reduce(function (newPayload, key) {
+                var _a;
+                return (__assign(__assign({}, newPayload), (_a = {}, _a[key] = payload[key], _a)));
+            }, {});
+            return newPayload;
+        };
+        CoveoAnalyticsClient.prototype.processCustomParameters = function (payload) {
+            var custom = payload.custom, rest = __rest(payload, ["custom"]);
+            var lowercasedCustom = this.lowercaseKeys(custom);
+            var newPayload = convertCustomMeasurementProtocolKeys(rest);
+            return __assign(__assign({}, lowercasedCustom), newPayload);
+        };
+        CoveoAnalyticsClient.prototype.lowercaseKeys = function (custom) {
+            var keys = Object.keys(custom || {});
+            return keys.reduce(function (all, key) {
+                var _a;
+                return (__assign(__assign({}, all), (_a = {}, _a[key.toLowerCase()] = custom[key], _a)));
+            }, {});
+        };
+        CoveoAnalyticsClient.prototype.validateParams = function (payload) {
+            var anonymizeIp = payload.anonymizeIp, rest = __rest(payload, ["anonymizeIp"]);
+            if (anonymizeIp !== undefined) {
+                if (['0', 'false', 'undefined', 'null', '{}', '[]', ''].indexOf(("" + anonymizeIp).toLowerCase()) == -1) {
+                    rest['anonymizeIp'] = 1;
+                }
+            }
+            return rest;
+        };
+        CoveoAnalyticsClient.prototype.ensureAnonymousUserWhenUsingApiKey = function (payload) {
+            var userId = payload.userId, rest = __rest(payload, ["userId"]);
+            if (isApiKey(this.options.token) && !userId) {
+                rest['userId'] = 'anonymous';
+                return rest;
+            }
+            else {
+                return payload;
+            }
+        };
+        Object.defineProperty(CoveoAnalyticsClient.prototype, "baseUrl", {
+            get: function () {
+                return buildBaseUrl(this.options.endpoint, this.options.version);
+            },
+            enumerable: false,
+            configurable: true
+        });
+        return CoveoAnalyticsClient;
+    }());
+
+    var analytics$1 = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        Version: Version,
+        Endpoints: Endpoints,
+        buildBaseUrl: buildBaseUrl,
+        CoveoAnalyticsClient: CoveoAnalyticsClient,
+        'default': CoveoAnalyticsClient
+    });
+
+    var getFormattedLocation = function (location) {
+        return location.protocol + "//" + location.hostname + (location.pathname.indexOf('/') === 0 ? location.pathname : "/" + location.pathname) + location.search;
+    };
+
+    var BasePluginEventTypes = {
+        pageview: 'pageview',
+        event: 'event',
+    };
+    var BasePlugin = (function () {
+        function BasePlugin(_a) {
+            var client = _a.client, _b = _a.uuidGenerator, uuidGenerator = _b === void 0 ? uuidv4 : _b;
+            this.actionData = {};
+            this.client = client;
+            this.uuidGenerator = uuidGenerator;
+            this.pageViewId = uuidGenerator();
+            this.nextPageViewId = this.pageViewId;
+            this.currentLocation = getFormattedLocation(window.location);
+            this.lastReferrer = hasDocument() ? document.referrer : '';
+            this.addHooks();
+        }
+        BasePlugin.prototype.setAction = function (action, options) {
+            this.action = action;
+            this.actionData = options;
+        };
+        BasePlugin.prototype.clearData = function () {
+            this.clearPluginData();
+            this.action = undefined;
+            this.actionData = {};
+        };
+        BasePlugin.prototype.getLocationInformation = function (eventType, payload) {
+            return __assign({ hitType: eventType }, this.getNextValues(eventType, payload));
+        };
+        BasePlugin.prototype.updateLocationInformation = function (eventType, payload) {
+            this.updateLocationForNextPageView(eventType, payload);
+        };
+        BasePlugin.prototype.getDefaultContextInformation = function (eventType) {
+            var documentContext = {
+                title: hasDocument() ? document.title : '',
+                encoding: hasDocument() ? document.characterSet : 'UTF-8',
+            };
+            var screenContext = {
+                screenResolution: screen.width + "x" + screen.height,
+                screenColor: screen.colorDepth + "-bit",
+            };
+            var navigatorContext = {
+                language: navigator.language,
+                userAgent: navigator.userAgent,
+            };
+            var eventContext = {
+                time: Date.now().toString(),
+                eventId: this.uuidGenerator(),
+            };
+            return __assign(__assign(__assign(__assign({}, eventContext), screenContext), navigatorContext), documentContext);
+        };
+        BasePlugin.prototype.updateLocationForNextPageView = function (eventType, payload) {
+            var _a = this.getNextValues(eventType, payload), pageViewId = _a.pageViewId, referrer = _a.referrer, location = _a.location;
+            this.lastReferrer = referrer;
+            this.pageViewId = pageViewId;
+            this.currentLocation = location;
+            if (eventType === BasePluginEventTypes.pageview) {
+                this.nextPageViewId = this.uuidGenerator();
+                this.hasSentFirstPageView = true;
+            }
+        };
+        BasePlugin.prototype.getNextValues = function (eventType, payload) {
+            return {
+                pageViewId: eventType === BasePluginEventTypes.pageview ? this.nextPageViewId : this.pageViewId,
+                referrer: eventType === BasePluginEventTypes.pageview && this.hasSentFirstPageView
+                    ? this.currentLocation
+                    : this.lastReferrer,
+                location: eventType === BasePluginEventTypes.pageview
+                    ? this.getCurrentLocationFromPayload(payload)
+                    : this.currentLocation,
+            };
+        };
+        BasePlugin.prototype.getCurrentLocationFromPayload = function (payload) {
+            if (!!payload.page) {
+                var removeStartingSlash = function (page) { return page.replace(/^\/?(.*)$/, '/$1'); };
+                var extractHostnamePart = function (location) { return location.split('/').slice(0, 3).join('/'); };
+                return "" + extractHostnamePart(this.currentLocation) + removeStartingSlash(payload.page);
+            }
+            else {
+                return getFormattedLocation(window.location);
+            }
+        };
+        return BasePlugin;
+    }());
+
+    var ECPluginEventTypes = __assign({}, BasePluginEventTypes);
+    var allECEventTypes = Object.keys(ECPluginEventTypes).map(function (key) { return ECPluginEventTypes[key]; });
+    var ECPlugin = (function (_super) {
+        __extends(ECPlugin, _super);
+        function ECPlugin(_a) {
+            var client = _a.client, _b = _a.uuidGenerator, uuidGenerator = _b === void 0 ? uuidv4 : _b;
+            var _this = _super.call(this, { client: client, uuidGenerator: uuidGenerator }) || this;
+            _this.products = [];
+            _this.impressions = [];
+            return _this;
+        }
+        ECPlugin.prototype.addHooks = function () {
+            this.addHooksForPageView();
+            this.addHooksForEvent();
+            this.addHooksForECEvents();
+        };
+        ECPlugin.prototype.addProduct = function (product) {
+            this.products.push(product);
+        };
+        ECPlugin.prototype.addImpression = function (impression) {
+            this.impressions.push(impression);
+        };
+        ECPlugin.prototype.clearPluginData = function () {
+            this.products = [];
+            this.impressions = [];
+        };
+        ECPlugin.prototype.addHooksForECEvents = function () {
+            var _this = this;
+            this.client.registerBeforeSendEventHook(function (eventType) {
+                var _a = [];
+                for (var _i = 1; _i < arguments.length; _i++) {
+                    _a[_i - 1] = arguments[_i];
+                }
+                var payload = _a[0];
+                return allECEventTypes.indexOf(eventType) !== -1 ? _this.addECDataToPayload(eventType, payload) : payload;
+            });
+            this.client.registerAfterSendEventHook(function (eventType) {
+                var _a = [];
+                for (var _i = 1; _i < arguments.length; _i++) {
+                    _a[_i - 1] = arguments[_i];
+                }
+                var payload = _a[0];
+                if (allECEventTypes.indexOf(eventType) !== -1) {
+                    _this.updateLocationInformation(eventType, payload);
+                }
+                return payload;
+            });
+        };
+        ECPlugin.prototype.addHooksForPageView = function () {
+            this.client.addEventTypeMapping(ECPluginEventTypes.pageview, {
+                newEventType: EventType.collect,
+                variableLengthArgumentsNames: ['page'],
+                addVisitorIdParameter: true,
+                usesMeasurementProtocol: true,
+            });
+        };
+        ECPlugin.prototype.addHooksForEvent = function () {
+            this.client.addEventTypeMapping(ECPluginEventTypes.event, {
+                newEventType: EventType.collect,
+                variableLengthArgumentsNames: ['eventCategory', 'eventAction', 'eventLabel', 'eventValue'],
+                addVisitorIdParameter: true,
+                usesMeasurementProtocol: true,
+            });
+        };
+        ECPlugin.prototype.addECDataToPayload = function (eventType, payload) {
+            var ecPayload = __assign(__assign(__assign(__assign({}, this.getLocationInformation(eventType, payload)), this.getDefaultContextInformation(eventType)), (this.action ? { action: this.action } : {})), (this.actionData || {}));
+            var productPayload = this.getProductPayload();
+            var impressionPayload = this.getImpressionPayload();
+            this.clearData();
+            return __assign(__assign(__assign(__assign({}, impressionPayload), productPayload), ecPayload), payload);
+        };
+        ECPlugin.prototype.getProductPayload = function () {
+            var _this = this;
+            return this.products
+                .map(function (product) { return _this.assureProductValidity(product); })
+                .reduce(function (newPayload, product, index) {
+                return __assign(__assign({}, newPayload), convertProductToMeasurementProtocol(product, index));
+            }, {});
+        };
+        ECPlugin.prototype.getImpressionPayload = function () {
+            var _this = this;
+            var impressionsByList = this.getImpressionsByList();
+            return impressionsByList
+                .map(function (_a) {
+                var impressions = _a.impressions, rest = __rest(_a, ["impressions"]);
+                return (__assign(__assign({}, rest), { impressions: impressions.map(function (baseImpression) {
+                        return _this.assureBaseImpressionValidity(baseImpression);
+                    }) }));
+            })
+                .reduce(function (newPayload, impressionList, index) {
+                return __assign(__assign({}, newPayload), convertImpressionListToMeasurementProtocol(impressionList, index, 'pi'));
+            }, {});
+        };
+        ECPlugin.prototype.assureProductValidity = function (product) {
+            var position = product.position, productRest = __rest(product, ["position"]);
+            if (position !== undefined && position < 1) {
+                console.warn("The position for product '" + (product.name || product.id) + "' must be greater " + "than 0 when provided.");
+                return productRest;
+            }
+            return product;
+        };
+        ECPlugin.prototype.assureBaseImpressionValidity = function (baseImpression) {
+            var position = baseImpression.position, baseImpressionRest = __rest(baseImpression, ["position"]);
+            if (position !== undefined && position < 1) {
+                console.warn("The position for impression '" + (baseImpression.name || baseImpression.id) + "'" +
+                    " must be greater than 0 when provided.");
+                return baseImpressionRest;
+            }
+            return baseImpression;
+        };
+        ECPlugin.prototype.getImpressionsByList = function () {
+            return this.impressions.reduce(function (lists, impression) {
+                var listName = impression.list, baseImpression = __rest(impression, ["list"]);
+                var list = lists.find(function (list) { return list.listName === listName; });
+                if (list) {
+                    list.impressions.push(baseImpression);
+                }
+                else {
+                    lists.push({ listName: listName, impressions: [baseImpression] });
+                }
+                return lists;
+            }, []);
+        };
+        ECPlugin.Id = 'ec';
+        return ECPlugin;
+    }(BasePlugin));
+    var EC = ECPlugin;
+
+    var SVCPluginEventTypes = __assign({}, BasePluginEventTypes);
+    var allSVCEventTypes = Object.keys(SVCPluginEventTypes).map(function (key) { return SVCPluginEventTypes[key]; });
+    var SVCPlugin = (function (_super) {
+        __extends(SVCPlugin, _super);
+        function SVCPlugin(_a) {
+            var client = _a.client, _b = _a.uuidGenerator, uuidGenerator = _b === void 0 ? uuidv4 : _b;
+            var _this = _super.call(this, { client: client, uuidGenerator: uuidGenerator }) || this;
+            _this.ticket = {};
+            return _this;
+        }
+        SVCPlugin.prototype.addHooks = function () {
+            this.addHooksForEvent();
+            this.addHooksForPageView();
+            this.addHooksForSVCEvents();
+        };
+        SVCPlugin.prototype.setTicket = function (ticket) {
+            this.ticket = ticket;
+        };
+        SVCPlugin.prototype.clearPluginData = function () {
+            this.ticket = {};
+        };
+        SVCPlugin.prototype.addHooksForSVCEvents = function () {
+            var _this = this;
+            this.client.registerBeforeSendEventHook(function (eventType) {
+                var _a = [];
+                for (var _i = 1; _i < arguments.length; _i++) {
+                    _a[_i - 1] = arguments[_i];
+                }
+                var payload = _a[0];
+                return allSVCEventTypes.indexOf(eventType) !== -1 ? _this.addSVCDataToPayload(eventType, payload) : payload;
+            });
+            this.client.registerAfterSendEventHook(function (eventType) {
+                var _a = [];
+                for (var _i = 1; _i < arguments.length; _i++) {
+                    _a[_i - 1] = arguments[_i];
+                }
+                var payload = _a[0];
+                if (allSVCEventTypes.indexOf(eventType) !== -1) {
+                    _this.updateLocationInformation(eventType, payload);
+                }
+                return payload;
+            });
+        };
+        SVCPlugin.prototype.addHooksForPageView = function () {
+            this.client.addEventTypeMapping(SVCPluginEventTypes.pageview, {
+                newEventType: EventType.collect,
+                variableLengthArgumentsNames: ['page'],
+                addVisitorIdParameter: true,
+                usesMeasurementProtocol: true,
+            });
+        };
+        SVCPlugin.prototype.addHooksForEvent = function () {
+            this.client.addEventTypeMapping(SVCPluginEventTypes.event, {
+                newEventType: EventType.collect,
+                variableLengthArgumentsNames: ['eventCategory', 'eventAction', 'eventLabel', 'eventValue'],
+                addVisitorIdParameter: true,
+                usesMeasurementProtocol: true,
+            });
+        };
+        SVCPlugin.prototype.addSVCDataToPayload = function (eventType, payload) {
+            var _a;
+            var svcPayload = __assign(__assign(__assign(__assign({}, this.getLocationInformation(eventType, payload)), this.getDefaultContextInformation(eventType)), (this.action ? { svcAction: this.action } : {})), (Object.keys((_a = this.actionData) !== null && _a !== void 0 ? _a : {}).length > 0 ? { svcActionData: this.actionData } : {}));
+            var ticketPayload = this.getTicketPayload();
+            this.clearData();
+            return __assign(__assign(__assign({}, ticketPayload), svcPayload), payload);
+        };
+        SVCPlugin.prototype.getTicketPayload = function () {
+            return convertTicketToMeasurementProtocol(this.ticket);
+        };
+        SVCPlugin.Id = 'svc';
+        return SVCPlugin;
+    }(BasePlugin));
+    var SVC = SVCPlugin;
+
+    var Plugins = (function () {
+        function Plugins() {
+            var _a;
+            this.registeredPluginsMap = (_a = {},
+                _a[EC.Id] = EC,
+                _a[SVC.Id] = SVC,
+                _a);
+            this.requiredPlugins = {};
+        }
+        Plugins.prototype.require = function (name, options) {
+            var pluginClass = this.registeredPluginsMap[name];
+            if (!pluginClass) {
+                throw new Error("No plugin named \"" + name + "\" is currently registered. If you use a custom plugin, use 'provide' first.");
+            }
+            this.requiredPlugins[name] = new pluginClass(options);
+        };
+        Plugins.prototype.provide = function (name, plugin) {
+            this.registeredPluginsMap[name] = plugin;
+        };
+        Plugins.prototype.clearRequired = function () {
+            this.requiredPlugins = {};
+        };
+        Plugins.prototype.execute = function (name, fn) {
+            var pluginOptions = [];
+            for (var _i = 2; _i < arguments.length; _i++) {
+                pluginOptions[_i - 2] = arguments[_i];
+            }
+            var plugin = this.requiredPlugins[name];
+            if (!plugin) {
+                throw new Error("The plugin \"" + name + "\" is not required. Check that you required it on initialization.");
+            }
+            var actionFunction = plugin[fn];
+            if (!actionFunction) {
+                throw new Error("The function \"" + fn + "\" does not exists on the plugin \"" + name + "\".");
+            }
+            if (typeof actionFunction !== 'function') {
+                throw new Error("\"" + fn + "\" of the plugin \"" + name + "\" is not a function.");
+            }
+            return actionFunction.apply(plugin, pluginOptions);
+        };
+        Plugins.DefaultPlugins = [EC.Id, SVC.Id];
+        return Plugins;
+    }());
+
+    var CoveoUA = (function () {
+        function CoveoUA() {
+            this.plugins = new Plugins();
+            this.params = {};
+        }
+        CoveoUA.prototype.init = function (token, optionsOrEndpoint) {
+            var _this = this;
+            if (!token) {
+                throw new Error("You must pass your token when you call 'init'");
+            }
+            if (typeof token === 'string') {
+                this.client = new CoveoAnalyticsClient({
+                    token: token,
+                    endpoint: this.getEndpoint(optionsOrEndpoint),
+                });
+            }
+            else if (this.isAnalyticsClient(token)) {
+                this.client = token;
+            }
+            if (this.client) {
+                var pluginOptions_1 = { client: this.client };
+                this.plugins.clearRequired();
+                this.getPluginKeys(optionsOrEndpoint).forEach(function (pluginKey) {
+                    return _this.plugins.require(pluginKey, pluginOptions_1);
+                });
+                this.client.registerBeforeSendEventHook(function (eventType, payload) { return (__assign(__assign({}, payload), _this.params)); });
+                this.client.addEventTypeMapping(EventType.view, { newEventType: EventType.view, addClientIdParameter: true });
+            }
+            else {
+                throw new Error("You must pass either your token or a valid object when you call 'init'");
+            }
+        };
+        CoveoUA.prototype.isAnalyticsClient = function (token) {
+            return typeof token === 'object' && typeof token.sendEvent !== 'undefined';
+        };
+        CoveoUA.prototype.getPluginKeys = function (optionsOrEndpoint) {
+            if (typeof optionsOrEndpoint === 'string') {
+                return Plugins.DefaultPlugins;
+            }
+            return Array.isArray(optionsOrEndpoint === null || optionsOrEndpoint === void 0 ? void 0 : optionsOrEndpoint.plugins) ? optionsOrEndpoint.plugins : Plugins.DefaultPlugins;
+        };
+        CoveoUA.prototype.getEndpoint = function (optionsOrEndpoint) {
+            if (typeof optionsOrEndpoint === 'string') {
+                return optionsOrEndpoint || Endpoints.default;
+            }
+            else if (optionsOrEndpoint === null || optionsOrEndpoint === void 0 ? void 0 : optionsOrEndpoint.endpoint) {
+                return optionsOrEndpoint.endpoint;
+            }
+            return Endpoints.default;
+        };
+        CoveoUA.prototype.initForProxy = function (endpoint) {
+            if (!endpoint) {
+                throw new Error("You must pass your endpoint when you call 'initForProxy'");
+            }
+            if (typeof endpoint !== 'string') {
+                throw new Error("You must pass a string as the endpoint parameter when you call 'initForProxy'");
+            }
+            this.client = new CoveoAnalyticsClient({
+                endpoint: endpoint,
+            });
+        };
+        CoveoUA.prototype.set = function (keyOrObject, value) {
+            var _this = this;
+            if (typeof keyOrObject === 'string') {
+                this.params[keyOrObject] = value;
+            }
+            else {
+                Object.keys(keyOrObject).map(function (key) {
+                    _this.params[key] = keyOrObject[key];
+                });
+            }
+        };
+        CoveoUA.prototype.send = function () {
+            var _a;
+            var _b = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                _b[_i] = arguments[_i];
+            }
+            var event = _b[0], payload = _b.slice(1);
+            if (typeof this.client == 'undefined') {
+                throw new Error("You must call init before sending an event");
+            }
+            if (!event) {
+                throw new Error("You must provide an event type when calling \"send\".");
+            }
+            return (_a = this.client).sendEvent.apply(_a, __spreadArrays([event.toLowerCase()], payload));
+        };
+        CoveoUA.prototype.onLoad = function (callback) {
+            if (typeof callback == 'undefined') {
+                throw new Error("You must pass a function when you call 'onLoad'");
+            }
+            callback();
+        };
+        CoveoUA.prototype.provide = function (name, plugin) {
+            this.plugins.provide(name, plugin);
+        };
+        CoveoUA.prototype.require = function (name, options) {
+            if (!this.client) {
+                throw new Error("You must call init before requiring a plugin");
+            }
+            this.plugins.require(name, __assign(__assign({}, options), { client: this.client }));
+        };
+        CoveoUA.prototype.callPlugin = function (pluginName, fn) {
+            var _a;
+            var args = [];
+            for (var _i = 2; _i < arguments.length; _i++) {
+                args[_i - 2] = arguments[_i];
+            }
+            (_a = this.plugins).execute.apply(_a, __spreadArrays([pluginName, fn], args));
+        };
+        CoveoUA.prototype.reset = function () {
+            this.client = undefined;
+            this.plugins = new Plugins();
+            this.params = {};
+        };
+        return CoveoUA;
+    }());
+    var coveoua$1 = new CoveoUA();
+    var getCurrentClient = function () { return coveoua$1.client; };
+    var handleOneAnalyticsEvent = function (command) {
+        var params = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            params[_i - 1] = arguments[_i];
+        }
+        var _a = /^(?:(\w+)\.)?(?:(\w+):)?(\w+)$/.exec(command); _a[1]; var pluginName = _a[2], fn = _a[3];
+        var actionFunction = coveoua$1[fn];
+        if (pluginName && fn) {
+            return coveoua$1.callPlugin.apply(coveoua$1, __spreadArrays([pluginName, fn], params));
+        }
+        else if (actionFunction) {
+            return actionFunction.apply(coveoua$1, params);
+        }
+        else {
+            var actions = [
+                'init',
+                'set',
+                'send',
+                'onLoad',
+                'callPlugin',
+                'reset',
+                'require',
+                'provide',
+            ];
+            throw new Error("The action \"" + command + "\" does not exist. Available actions: " + actions.join(', ') + ".");
+        }
+    };
+
+    var simpleanalytics = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        CoveoUA: CoveoUA,
+        coveoua: coveoua$1,
+        getCurrentClient: getCurrentClient,
+        handleOneAnalyticsEvent: handleOneAnalyticsEvent,
+        'default': handleOneAnalyticsEvent
+    });
+
+    var InsightEvents;
+    (function (InsightEvents) {
+        InsightEvents["contextChanged"] = "contextChanged";
+        InsightEvents["expandToFullUI"] = "expandToFullUI";
+    })(InsightEvents || (InsightEvents = {}));
+
+    var _a;
+    var SearchPageEvents;
+    (function (SearchPageEvents) {
+        SearchPageEvents["interfaceLoad"] = "interfaceLoad";
+        SearchPageEvents["interfaceChange"] = "interfaceChange";
+        SearchPageEvents["didyoumeanAutomatic"] = "didyoumeanAutomatic";
+        SearchPageEvents["didyoumeanClick"] = "didyoumeanClick";
+        SearchPageEvents["resultsSort"] = "resultsSort";
+        SearchPageEvents["searchboxSubmit"] = "searchboxSubmit";
+        SearchPageEvents["searchboxClear"] = "searchboxClear";
+        SearchPageEvents["searchboxAsYouType"] = "searchboxAsYouType";
+        SearchPageEvents["breadcrumbFacet"] = "breadcrumbFacet";
+        SearchPageEvents["breadcrumbResetAll"] = "breadcrumbResetAll";
+        SearchPageEvents["documentQuickview"] = "documentQuickview";
+        SearchPageEvents["documentOpen"] = "documentOpen";
+        SearchPageEvents["omniboxAnalytics"] = "omniboxAnalytics";
+        SearchPageEvents["omniboxFromLink"] = "omniboxFromLink";
+        SearchPageEvents["searchFromLink"] = "searchFromLink";
+        SearchPageEvents["triggerNotify"] = "notify";
+        SearchPageEvents["triggerExecute"] = "execute";
+        SearchPageEvents["triggerQuery"] = "query";
+        SearchPageEvents["undoTriggerQuery"] = "undoQuery";
+        SearchPageEvents["triggerRedirect"] = "redirect";
+        SearchPageEvents["pagerResize"] = "pagerResize";
+        SearchPageEvents["pagerNumber"] = "pagerNumber";
+        SearchPageEvents["pagerNext"] = "pagerNext";
+        SearchPageEvents["pagerPrevious"] = "pagerPrevious";
+        SearchPageEvents["pagerScrolling"] = "pagerScrolling";
+        SearchPageEvents["staticFilterClearAll"] = "staticFilterClearAll";
+        SearchPageEvents["staticFilterSelect"] = "staticFilterSelect";
+        SearchPageEvents["staticFilterDeselect"] = "staticFilterDeselect";
+        SearchPageEvents["facetClearAll"] = "facetClearAll";
+        SearchPageEvents["facetSearch"] = "facetSearch";
+        SearchPageEvents["facetSelect"] = "facetSelect";
+        SearchPageEvents["facetSelectAll"] = "facetSelectAll";
+        SearchPageEvents["facetDeselect"] = "facetDeselect";
+        SearchPageEvents["facetExclude"] = "facetExclude";
+        SearchPageEvents["facetUnexclude"] = "facetUnexclude";
+        SearchPageEvents["facetUpdateSort"] = "facetUpdateSort";
+        SearchPageEvents["facetShowMore"] = "showMoreFacetResults";
+        SearchPageEvents["facetShowLess"] = "showLessFacetResults";
+        SearchPageEvents["queryError"] = "query";
+        SearchPageEvents["queryErrorBack"] = "errorBack";
+        SearchPageEvents["queryErrorClear"] = "errorClearQuery";
+        SearchPageEvents["queryErrorRetry"] = "errorRetry";
+        SearchPageEvents["recommendation"] = "recommendation";
+        SearchPageEvents["recommendationInterfaceLoad"] = "recommendationInterfaceLoad";
+        SearchPageEvents["recommendationOpen"] = "recommendationOpen";
+        SearchPageEvents["likeSmartSnippet"] = "likeSmartSnippet";
+        SearchPageEvents["dislikeSmartSnippet"] = "dislikeSmartSnippet";
+        SearchPageEvents["expandSmartSnippet"] = "expandSmartSnippet";
+        SearchPageEvents["collapseSmartSnippet"] = "collapseSmartSnippet";
+        SearchPageEvents["openSmartSnippetFeedbackModal"] = "openSmartSnippetFeedbackModal";
+        SearchPageEvents["closeSmartSnippetFeedbackModal"] = "closeSmartSnippetFeedbackModal";
+        SearchPageEvents["sendSmartSnippetReason"] = "sendSmartSnippetReason";
+        SearchPageEvents["expandSmartSnippetSuggestion"] = "expandSmartSnippetSuggestion";
+        SearchPageEvents["collapseSmartSnippetSuggestion"] = "collapseSmartSnippetSuggestion";
+        SearchPageEvents["showMoreSmartSnippetSuggestion"] = "showMoreSmartSnippetSuggestion";
+        SearchPageEvents["showLessSmartSnippetSuggestion"] = "showLessSmartSnippetSuggestion";
+        SearchPageEvents["openSmartSnippetSource"] = "openSmartSnippetSource";
+        SearchPageEvents["openSmartSnippetSuggestionSource"] = "openSmartSnippetSuggestionSource";
+        SearchPageEvents["openSmartSnippetInlineLink"] = "openSmartSnippetInlineLink";
+        SearchPageEvents["openSmartSnippetSuggestionInlineLink"] = "openSmartSnippetSuggestionInlineLink";
+        SearchPageEvents["recentQueryClick"] = "recentQueriesClick";
+        SearchPageEvents["clearRecentQueries"] = "clearRecentQueries";
+        SearchPageEvents["recentResultClick"] = "recentResultClick";
+        SearchPageEvents["clearRecentResults"] = "clearRecentResults";
+        SearchPageEvents["noResultsBack"] = "noResultsBack";
+        SearchPageEvents["showMoreFoldedResults"] = "showMoreFoldedResults";
+        SearchPageEvents["showLessFoldedResults"] = "showLessFoldedResults";
+        SearchPageEvents["copyToClipboard"] = "copyToClipboard";
+    })(SearchPageEvents || (SearchPageEvents = {}));
+    var CustomEventsTypes = (_a = {},
+        _a[SearchPageEvents.triggerNotify] = 'queryPipelineTriggers',
+        _a[SearchPageEvents.triggerExecute] = 'queryPipelineTriggers',
+        _a[SearchPageEvents.triggerQuery] = 'queryPipelineTriggers',
+        _a[SearchPageEvents.triggerRedirect] = 'queryPipelineTriggers',
+        _a[SearchPageEvents.queryError] = 'errors',
+        _a[SearchPageEvents.queryErrorBack] = 'errors',
+        _a[SearchPageEvents.queryErrorClear] = 'errors',
+        _a[SearchPageEvents.queryErrorRetry] = 'errors',
+        _a[SearchPageEvents.pagerNext] = 'getMoreResults',
+        _a[SearchPageEvents.pagerPrevious] = 'getMoreResults',
+        _a[SearchPageEvents.pagerNumber] = 'getMoreResults',
+        _a[SearchPageEvents.pagerResize] = 'getMoreResults',
+        _a[SearchPageEvents.pagerScrolling] = 'getMoreResults',
+        _a[SearchPageEvents.facetSearch] = 'facet',
+        _a[SearchPageEvents.facetShowLess] = 'facet',
+        _a[SearchPageEvents.facetShowMore] = 'facet',
+        _a[SearchPageEvents.recommendation] = 'recommendation',
+        _a[SearchPageEvents.likeSmartSnippet] = 'smartSnippet',
+        _a[SearchPageEvents.dislikeSmartSnippet] = 'smartSnippet',
+        _a[SearchPageEvents.expandSmartSnippet] = 'smartSnippet',
+        _a[SearchPageEvents.collapseSmartSnippet] = 'smartSnippet',
+        _a[SearchPageEvents.openSmartSnippetFeedbackModal] = 'smartSnippet',
+        _a[SearchPageEvents.closeSmartSnippetFeedbackModal] = 'smartSnippet',
+        _a[SearchPageEvents.sendSmartSnippetReason] = 'smartSnippet',
+        _a[SearchPageEvents.expandSmartSnippetSuggestion] = 'smartSnippetSuggestions',
+        _a[SearchPageEvents.collapseSmartSnippetSuggestion] = 'smartSnippetSuggestions',
+        _a[SearchPageEvents.showMoreSmartSnippetSuggestion] = 'smartSnippetSuggestions',
+        _a[SearchPageEvents.showLessSmartSnippetSuggestion] = 'smartSnippetSuggestions',
+        _a[SearchPageEvents.clearRecentQueries] = 'recentQueries',
+        _a[SearchPageEvents.recentResultClick] = 'recentlyClickedDocuments',
+        _a[SearchPageEvents.clearRecentResults] = 'recentlyClickedDocuments',
+        _a[SearchPageEvents.showLessFoldedResults] = 'folding',
+        _a[InsightEvents.expandToFullUI] = 'interface',
+        _a);
+
+    var NoopAnalytics = (function () {
+        function NoopAnalytics() {
+            this.runtime = new NoopRuntime();
+            this.currentVisitorId = '';
+        }
+        NoopAnalytics.prototype.getPayload = function () {
+            return Promise.resolve();
+        };
+        NoopAnalytics.prototype.getParameters = function () {
+            return Promise.resolve();
+        };
+        NoopAnalytics.prototype.sendEvent = function () {
+            return Promise.resolve();
+        };
+        NoopAnalytics.prototype.sendSearchEvent = function () {
+            return Promise.resolve();
+        };
+        NoopAnalytics.prototype.sendClickEvent = function () {
+            return Promise.resolve();
+        };
+        NoopAnalytics.prototype.sendCustomEvent = function () {
+            return Promise.resolve();
+        };
+        NoopAnalytics.prototype.sendViewEvent = function () {
+            return Promise.resolve();
+        };
+        NoopAnalytics.prototype.getVisit = function () {
+            return Promise.resolve({ id: '', visitorId: '' });
+        };
+        NoopAnalytics.prototype.getHealth = function () {
+            return Promise.resolve({ status: '' });
+        };
+        NoopAnalytics.prototype.registerBeforeSendEventHook = function () { };
+        NoopAnalytics.prototype.registerAfterSendEventHook = function () { };
+        NoopAnalytics.prototype.addEventTypeMapping = function () { };
+        return NoopAnalytics;
+    }());
+
+    function filterConsecutiveRepeatedValues(rawData) {
+        var prev = '';
+        return rawData.filter(function (value) {
+            var isDifferent = value !== prev;
+            prev = value;
+            return isDifferent;
+        });
+    }
+    function removeSemicolons(rawData) {
+        return rawData.map(function (value) {
+            return value.replace(/;/g, '');
+        });
+    }
+    function getDataString(data) {
+        var ANALYTICS_LENGTH_LIMIT = 256;
+        var formattedData = data.join(';');
+        if (formattedData.length <= ANALYTICS_LENGTH_LIMIT) {
+            return formattedData;
+        }
+        return getDataString(data.slice(1));
+    }
+    var formatArrayForCoveoCustomData = function (rawData) {
+        var dataWithoutSemicolons = removeSemicolons(rawData);
+        var dataWithoutRepeatedValues = filterConsecutiveRepeatedValues(dataWithoutSemicolons);
+        return getDataString(dataWithoutRepeatedValues);
+    };
+
+    function formatOmniboxMetadata(meta) {
+        var partialQueries = typeof meta.partialQueries === 'string'
+            ? meta.partialQueries
+            : formatArrayForCoveoCustomData(meta.partialQueries);
+        var suggestions = typeof meta.suggestions === 'string' ? meta.suggestions : formatArrayForCoveoCustomData(meta.suggestions);
+        return __assign(__assign({}, meta), { partialQueries: partialQueries,
+            suggestions: suggestions });
+    }
+
+    var CoveoSearchPageClient = (function () {
+        function CoveoSearchPageClient(opts, provider) {
+            this.opts = opts;
+            this.provider = provider;
+            var shouldDisableAnalytics = opts.enableAnalytics === false || doNotTrack();
+            this.coveoAnalyticsClient = shouldDisableAnalytics ? new NoopAnalytics() : new CoveoAnalyticsClient(opts);
+        }
+        CoveoSearchPageClient.prototype.disable = function () {
+            if (this.coveoAnalyticsClient instanceof CoveoAnalyticsClient) {
+                this.coveoAnalyticsClient.clear();
+            }
+            this.coveoAnalyticsClient = new NoopAnalytics();
+        };
+        CoveoSearchPageClient.prototype.enable = function () {
+            this.coveoAnalyticsClient = new CoveoAnalyticsClient(this.opts);
+        };
+        CoveoSearchPageClient.prototype.makeInterfaceLoad = function () {
+            return this.makeSearchEvent(SearchPageEvents.interfaceLoad);
+        };
+        CoveoSearchPageClient.prototype.logInterfaceLoad = function () {
+            return this.makeInterfaceLoad().log();
+        };
+        CoveoSearchPageClient.prototype.makeRecommendationInterfaceLoad = function () {
+            return this.makeSearchEvent(SearchPageEvents.recommendationInterfaceLoad);
+        };
+        CoveoSearchPageClient.prototype.logRecommendationInterfaceLoad = function () {
+            return this.makeRecommendationInterfaceLoad().log();
+        };
+        CoveoSearchPageClient.prototype.makeRecommendation = function () {
+            return this.makeCustomEvent(SearchPageEvents.recommendation);
+        };
+        CoveoSearchPageClient.prototype.logRecommendation = function () {
+            return this.makeRecommendation().log();
+        };
+        CoveoSearchPageClient.prototype.makeRecommendationOpen = function (info, identifier) {
+            return this.makeClickEvent(SearchPageEvents.recommendationOpen, info, identifier);
+        };
+        CoveoSearchPageClient.prototype.logRecommendationOpen = function (info, identifier) {
+            return this.makeRecommendationOpen(info, identifier).log();
+        };
+        CoveoSearchPageClient.prototype.makeStaticFilterClearAll = function (meta) {
+            return this.makeSearchEvent(SearchPageEvents.staticFilterClearAll, meta);
+        };
+        CoveoSearchPageClient.prototype.logStaticFilterClearAll = function (meta) {
+            return this.makeStaticFilterClearAll(meta).log();
+        };
+        CoveoSearchPageClient.prototype.makeStaticFilterSelect = function (meta) {
+            return this.makeSearchEvent(SearchPageEvents.staticFilterSelect, meta);
+        };
+        CoveoSearchPageClient.prototype.logStaticFilterSelect = function (meta) {
+            return this.makeStaticFilterSelect(meta).log();
+        };
+        CoveoSearchPageClient.prototype.makeStaticFilterDeselect = function (meta) {
+            return this.makeSearchEvent(SearchPageEvents.staticFilterDeselect, meta);
+        };
+        CoveoSearchPageClient.prototype.logStaticFilterDeselect = function (meta) {
+            return this.makeStaticFilterDeselect(meta).log();
+        };
+        CoveoSearchPageClient.prototype.makeFetchMoreResults = function () {
+            return this.makeCustomEvent(SearchPageEvents.pagerScrolling, { type: 'getMoreResults' });
+        };
+        CoveoSearchPageClient.prototype.logFetchMoreResults = function () {
+            return this.makeFetchMoreResults().log();
+        };
+        CoveoSearchPageClient.prototype.makeInterfaceChange = function (metadata) {
+            return this.makeSearchEvent(SearchPageEvents.interfaceChange, metadata);
+        };
+        CoveoSearchPageClient.prototype.logInterfaceChange = function (metadata) {
+            return this.makeInterfaceChange(metadata).log();
+        };
+        CoveoSearchPageClient.prototype.makeDidYouMeanAutomatic = function () {
+            return this.makeSearchEvent(SearchPageEvents.didyoumeanAutomatic);
+        };
+        CoveoSearchPageClient.prototype.logDidYouMeanAutomatic = function () {
+            return this.makeDidYouMeanAutomatic().log();
+        };
+        CoveoSearchPageClient.prototype.makeDidYouMeanClick = function () {
+            return this.makeSearchEvent(SearchPageEvents.didyoumeanClick);
+        };
+        CoveoSearchPageClient.prototype.logDidYouMeanClick = function () {
+            return this.makeDidYouMeanClick().log();
+        };
+        CoveoSearchPageClient.prototype.makeResultsSort = function (metadata) {
+            return this.makeSearchEvent(SearchPageEvents.resultsSort, metadata);
+        };
+        CoveoSearchPageClient.prototype.logResultsSort = function (metadata) {
+            return this.makeResultsSort(metadata).log();
+        };
+        CoveoSearchPageClient.prototype.makeSearchboxSubmit = function () {
+            return this.makeSearchEvent(SearchPageEvents.searchboxSubmit);
+        };
+        CoveoSearchPageClient.prototype.logSearchboxSubmit = function () {
+            return this.makeSearchboxSubmit().log();
+        };
+        CoveoSearchPageClient.prototype.makeSearchboxClear = function () {
+            return this.makeSearchEvent(SearchPageEvents.searchboxClear);
+        };
+        CoveoSearchPageClient.prototype.logSearchboxClear = function () {
+            return this.makeSearchboxClear().log();
+        };
+        CoveoSearchPageClient.prototype.makeSearchboxAsYouType = function () {
+            return this.makeSearchEvent(SearchPageEvents.searchboxAsYouType);
+        };
+        CoveoSearchPageClient.prototype.logSearchboxAsYouType = function () {
+            return this.makeSearchboxAsYouType().log();
+        };
+        CoveoSearchPageClient.prototype.makeBreadcrumbFacet = function (metadata) {
+            return this.makeSearchEvent(SearchPageEvents.breadcrumbFacet, metadata);
+        };
+        CoveoSearchPageClient.prototype.logBreadcrumbFacet = function (metadata) {
+            return this.makeBreadcrumbFacet(metadata).log();
+        };
+        CoveoSearchPageClient.prototype.makeBreadcrumbResetAll = function () {
+            return this.makeSearchEvent(SearchPageEvents.breadcrumbResetAll);
+        };
+        CoveoSearchPageClient.prototype.logBreadcrumbResetAll = function () {
+            return this.makeBreadcrumbResetAll().log();
+        };
+        CoveoSearchPageClient.prototype.makeDocumentQuickview = function (info, identifier) {
+            return this.makeClickEvent(SearchPageEvents.documentQuickview, info, identifier);
+        };
+        CoveoSearchPageClient.prototype.logDocumentQuickview = function (info, identifier) {
+            return this.makeDocumentQuickview(info, identifier).log();
+        };
+        CoveoSearchPageClient.prototype.makeDocumentOpen = function (info, identifier) {
+            return this.makeClickEvent(SearchPageEvents.documentOpen, info, identifier);
+        };
+        CoveoSearchPageClient.prototype.logDocumentOpen = function (info, identifier) {
+            return this.makeDocumentOpen(info, identifier).log();
+        };
+        CoveoSearchPageClient.prototype.makeOmniboxAnalytics = function (meta) {
+            return this.makeSearchEvent(SearchPageEvents.omniboxAnalytics, formatOmniboxMetadata(meta));
+        };
+        CoveoSearchPageClient.prototype.logOmniboxAnalytics = function (meta) {
+            return this.makeOmniboxAnalytics(meta).log();
+        };
+        CoveoSearchPageClient.prototype.makeOmniboxFromLink = function (meta) {
+            return this.makeSearchEvent(SearchPageEvents.omniboxFromLink, formatOmniboxMetadata(meta));
+        };
+        CoveoSearchPageClient.prototype.logOmniboxFromLink = function (meta) {
+            return this.makeOmniboxFromLink(meta).log();
+        };
+        CoveoSearchPageClient.prototype.makeSearchFromLink = function () {
+            return this.makeSearchEvent(SearchPageEvents.searchFromLink);
+        };
+        CoveoSearchPageClient.prototype.logSearchFromLink = function () {
+            return this.makeSearchFromLink().log();
+        };
+        CoveoSearchPageClient.prototype.makeTriggerNotify = function (meta) {
+            return this.makeCustomEvent(SearchPageEvents.triggerNotify, meta);
+        };
+        CoveoSearchPageClient.prototype.logTriggerNotify = function (meta) {
+            return this.makeTriggerNotify(meta).log();
+        };
+        CoveoSearchPageClient.prototype.makeTriggerExecute = function (meta) {
+            return this.makeCustomEvent(SearchPageEvents.triggerExecute, meta);
+        };
+        CoveoSearchPageClient.prototype.logTriggerExecute = function (meta) {
+            return this.makeTriggerExecute(meta).log();
+        };
+        CoveoSearchPageClient.prototype.makeTriggerQuery = function () {
+            return this.makeCustomEvent(SearchPageEvents.triggerQuery, { query: this.provider.getSearchEventRequestPayload().queryText }, 'queryPipelineTriggers');
+        };
+        CoveoSearchPageClient.prototype.logTriggerQuery = function () {
+            return this.makeTriggerQuery().log();
+        };
+        CoveoSearchPageClient.prototype.makeUndoTriggerQuery = function (meta) {
+            return this.makeSearchEvent(SearchPageEvents.undoTriggerQuery, meta);
+        };
+        CoveoSearchPageClient.prototype.logUndoTriggerQuery = function (meta) {
+            return this.makeUndoTriggerQuery(meta).log();
+        };
+        CoveoSearchPageClient.prototype.makeTriggerRedirect = function (meta) {
+            return this.makeCustomEvent(SearchPageEvents.triggerRedirect, __assign(__assign({}, meta), { query: this.provider.getSearchEventRequestPayload().queryText }));
+        };
+        CoveoSearchPageClient.prototype.logTriggerRedirect = function (meta) {
+            return this.makeTriggerRedirect(meta).log();
+        };
+        CoveoSearchPageClient.prototype.makePagerResize = function (meta) {
+            return this.makeCustomEvent(SearchPageEvents.pagerResize, meta);
+        };
+        CoveoSearchPageClient.prototype.logPagerResize = function (meta) {
+            return this.makePagerResize(meta).log();
+        };
+        CoveoSearchPageClient.prototype.makePagerNumber = function (meta) {
+            return this.makeCustomEvent(SearchPageEvents.pagerNumber, meta);
+        };
+        CoveoSearchPageClient.prototype.logPagerNumber = function (meta) {
+            return this.makePagerNumber(meta).log();
+        };
+        CoveoSearchPageClient.prototype.makePagerNext = function (meta) {
+            return this.makeCustomEvent(SearchPageEvents.pagerNext, meta);
+        };
+        CoveoSearchPageClient.prototype.logPagerNext = function (meta) {
+            return this.makePagerNext(meta).log();
+        };
+        CoveoSearchPageClient.prototype.makePagerPrevious = function (meta) {
+            return this.makeCustomEvent(SearchPageEvents.pagerPrevious, meta);
+        };
+        CoveoSearchPageClient.prototype.logPagerPrevious = function (meta) {
+            return this.makePagerPrevious(meta).log();
+        };
+        CoveoSearchPageClient.prototype.makePagerScrolling = function () {
+            return this.makeCustomEvent(SearchPageEvents.pagerScrolling);
+        };
+        CoveoSearchPageClient.prototype.logPagerScrolling = function () {
+            return this.makePagerScrolling().log();
+        };
+        CoveoSearchPageClient.prototype.makeFacetClearAll = function (meta) {
+            return this.makeSearchEvent(SearchPageEvents.facetClearAll, meta);
+        };
+        CoveoSearchPageClient.prototype.logFacetClearAll = function (meta) {
+            return this.makeFacetClearAll(meta).log();
+        };
+        CoveoSearchPageClient.prototype.makeFacetSearch = function (meta) {
+            return this.makeSearchEvent(SearchPageEvents.facetSearch, meta);
+        };
+        CoveoSearchPageClient.prototype.logFacetSearch = function (meta) {
+            return this.makeFacetSearch(meta).log();
+        };
+        CoveoSearchPageClient.prototype.makeFacetSelect = function (meta) {
+            return this.makeSearchEvent(SearchPageEvents.facetSelect, meta);
+        };
+        CoveoSearchPageClient.prototype.logFacetSelect = function (meta) {
+            return this.makeFacetSelect(meta).log();
+        };
+        CoveoSearchPageClient.prototype.makeFacetDeselect = function (meta) {
+            return this.makeSearchEvent(SearchPageEvents.facetDeselect, meta);
+        };
+        CoveoSearchPageClient.prototype.logFacetDeselect = function (meta) {
+            return this.makeFacetDeselect(meta).log();
+        };
+        CoveoSearchPageClient.prototype.makeFacetExclude = function (meta) {
+            return this.makeSearchEvent(SearchPageEvents.facetExclude, meta);
+        };
+        CoveoSearchPageClient.prototype.logFacetExclude = function (meta) {
+            return this.makeFacetExclude(meta).log();
+        };
+        CoveoSearchPageClient.prototype.makeFacetUnexclude = function (meta) {
+            return this.makeSearchEvent(SearchPageEvents.facetUnexclude, meta);
+        };
+        CoveoSearchPageClient.prototype.logFacetUnexclude = function (meta) {
+            return this.makeFacetUnexclude(meta).log();
+        };
+        CoveoSearchPageClient.prototype.makeFacetSelectAll = function (meta) {
+            return this.makeSearchEvent(SearchPageEvents.facetSelectAll, meta);
+        };
+        CoveoSearchPageClient.prototype.logFacetSelectAll = function (meta) {
+            return this.makeFacetSelectAll(meta).log();
+        };
+        CoveoSearchPageClient.prototype.makeFacetUpdateSort = function (meta) {
+            return this.makeSearchEvent(SearchPageEvents.facetUpdateSort, meta);
+        };
+        CoveoSearchPageClient.prototype.logFacetUpdateSort = function (meta) {
+            return this.makeFacetUpdateSort(meta).log();
+        };
+        CoveoSearchPageClient.prototype.makeFacetShowMore = function (meta) {
+            return this.makeCustomEvent(SearchPageEvents.facetShowMore, meta);
+        };
+        CoveoSearchPageClient.prototype.logFacetShowMore = function (meta) {
+            return this.makeFacetShowMore(meta).log();
+        };
+        CoveoSearchPageClient.prototype.makeFacetShowLess = function (meta) {
+            return this.makeCustomEvent(SearchPageEvents.facetShowLess, meta);
+        };
+        CoveoSearchPageClient.prototype.logFacetShowLess = function (meta) {
+            return this.makeFacetShowLess(meta).log();
+        };
+        CoveoSearchPageClient.prototype.makeQueryError = function (meta) {
+            return this.makeCustomEvent(SearchPageEvents.queryError, meta);
+        };
+        CoveoSearchPageClient.prototype.logQueryError = function (meta) {
+            return this.makeQueryError(meta).log();
+        };
+        CoveoSearchPageClient.prototype.makeQueryErrorBack = function () {
+            var _this = this;
+            return {
+                description: this.makeDescription(SearchPageEvents.queryErrorBack),
+                log: function () { return __awaiter(_this, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4, this.logCustomEvent(SearchPageEvents.queryErrorBack)];
+                            case 1:
+                                _a.sent();
+                                return [2, this.logSearchEvent(SearchPageEvents.queryErrorBack)];
+                        }
+                    });
+                }); },
+            };
+        };
+        CoveoSearchPageClient.prototype.logQueryErrorBack = function () {
+            return this.makeQueryErrorBack().log();
+        };
+        CoveoSearchPageClient.prototype.makeQueryErrorRetry = function () {
+            var _this = this;
+            return {
+                description: this.makeDescription(SearchPageEvents.queryErrorRetry),
+                log: function () { return __awaiter(_this, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4, this.logCustomEvent(SearchPageEvents.queryErrorRetry)];
+                            case 1:
+                                _a.sent();
+                                return [2, this.logSearchEvent(SearchPageEvents.queryErrorRetry)];
+                        }
+                    });
+                }); },
+            };
+        };
+        CoveoSearchPageClient.prototype.logQueryErrorRetry = function () {
+            return this.makeQueryErrorRetry().log();
+        };
+        CoveoSearchPageClient.prototype.makeQueryErrorClear = function () {
+            var _this = this;
+            return {
+                description: this.makeDescription(SearchPageEvents.queryErrorClear),
+                log: function () { return __awaiter(_this, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4, this.logCustomEvent(SearchPageEvents.queryErrorClear)];
+                            case 1:
+                                _a.sent();
+                                return [2, this.logSearchEvent(SearchPageEvents.queryErrorClear)];
+                        }
+                    });
+                }); },
+            };
+        };
+        CoveoSearchPageClient.prototype.logQueryErrorClear = function () {
+            return this.makeQueryErrorClear().log();
+        };
+        CoveoSearchPageClient.prototype.makeLikeSmartSnippet = function () {
+            return this.makeCustomEvent(SearchPageEvents.likeSmartSnippet);
+        };
+        CoveoSearchPageClient.prototype.logLikeSmartSnippet = function () {
+            return this.makeLikeSmartSnippet().log();
+        };
+        CoveoSearchPageClient.prototype.makeDislikeSmartSnippet = function () {
+            return this.makeCustomEvent(SearchPageEvents.dislikeSmartSnippet);
+        };
+        CoveoSearchPageClient.prototype.logDislikeSmartSnippet = function () {
+            return this.makeDislikeSmartSnippet().log();
+        };
+        CoveoSearchPageClient.prototype.makeExpandSmartSnippet = function () {
+            return this.makeCustomEvent(SearchPageEvents.expandSmartSnippet);
+        };
+        CoveoSearchPageClient.prototype.logExpandSmartSnippet = function () {
+            return this.makeExpandSmartSnippet().log();
+        };
+        CoveoSearchPageClient.prototype.makeCollapseSmartSnippet = function () {
+            return this.makeCustomEvent(SearchPageEvents.collapseSmartSnippet);
+        };
+        CoveoSearchPageClient.prototype.logCollapseSmartSnippet = function () {
+            return this.makeCollapseSmartSnippet().log();
+        };
+        CoveoSearchPageClient.prototype.makeOpenSmartSnippetFeedbackModal = function () {
+            return this.makeCustomEvent(SearchPageEvents.openSmartSnippetFeedbackModal);
+        };
+        CoveoSearchPageClient.prototype.logOpenSmartSnippetFeedbackModal = function () {
+            return this.makeOpenSmartSnippetFeedbackModal().log();
+        };
+        CoveoSearchPageClient.prototype.makeCloseSmartSnippetFeedbackModal = function () {
+            return this.makeCustomEvent(SearchPageEvents.closeSmartSnippetFeedbackModal);
+        };
+        CoveoSearchPageClient.prototype.logCloseSmartSnippetFeedbackModal = function () {
+            return this.makeCloseSmartSnippetFeedbackModal().log();
+        };
+        CoveoSearchPageClient.prototype.makeSmartSnippetFeedbackReason = function (reason, details) {
+            return this.makeCustomEvent(SearchPageEvents.sendSmartSnippetReason, { reason: reason, details: details });
+        };
+        CoveoSearchPageClient.prototype.logSmartSnippetFeedbackReason = function (reason, details) {
+            return this.makeSmartSnippetFeedbackReason(reason, details).log();
+        };
+        CoveoSearchPageClient.prototype.makeExpandSmartSnippetSuggestion = function (snippet) {
+            return this.makeCustomEvent(SearchPageEvents.expandSmartSnippetSuggestion, 'documentId' in snippet ? snippet : { documentId: snippet });
+        };
+        CoveoSearchPageClient.prototype.logExpandSmartSnippetSuggestion = function (snippet) {
+            return this.makeExpandSmartSnippetSuggestion(snippet).log();
+        };
+        CoveoSearchPageClient.prototype.makeCollapseSmartSnippetSuggestion = function (snippet) {
+            return this.makeCustomEvent(SearchPageEvents.collapseSmartSnippetSuggestion, 'documentId' in snippet ? snippet : { documentId: snippet });
+        };
+        CoveoSearchPageClient.prototype.logCollapseSmartSnippetSuggestion = function (snippet) {
+            return this.makeCollapseSmartSnippetSuggestion(snippet).log();
+        };
+        CoveoSearchPageClient.prototype.makeShowMoreSmartSnippetSuggestion = function (snippet) {
+            return this.makeCustomEvent(SearchPageEvents.showMoreSmartSnippetSuggestion, snippet);
+        };
+        CoveoSearchPageClient.prototype.logShowMoreSmartSnippetSuggestion = function (snippet) {
+            return this.makeShowMoreSmartSnippetSuggestion(snippet).log();
+        };
+        CoveoSearchPageClient.prototype.makeShowLessSmartSnippetSuggestion = function (snippet) {
+            return this.makeCustomEvent(SearchPageEvents.showLessSmartSnippetSuggestion, snippet);
+        };
+        CoveoSearchPageClient.prototype.logShowLessSmartSnippetSuggestion = function (snippet) {
+            return this.makeShowLessSmartSnippetSuggestion(snippet).log();
+        };
+        CoveoSearchPageClient.prototype.makeOpenSmartSnippetSource = function (info, identifier) {
+            return this.makeClickEvent(SearchPageEvents.openSmartSnippetSource, info, identifier);
+        };
+        CoveoSearchPageClient.prototype.logOpenSmartSnippetSource = function (info, identifier) {
+            return this.makeOpenSmartSnippetSource(info, identifier).log();
+        };
+        CoveoSearchPageClient.prototype.makeOpenSmartSnippetSuggestionSource = function (info, snippet) {
+            return this.makeClickEvent(SearchPageEvents.openSmartSnippetSuggestionSource, info, { contentIDKey: snippet.documentId.contentIdKey, contentIDValue: snippet.documentId.contentIdValue }, snippet);
+        };
+        CoveoSearchPageClient.prototype.makeCopyToClipboard = function (info, identifier) {
+            return this.makeClickEvent(SearchPageEvents.copyToClipboard, info, identifier);
+        };
+        CoveoSearchPageClient.prototype.logCopyToClipboard = function (info, identifier) {
+            return this.makeCopyToClipboard(info, identifier).log();
+        };
+        CoveoSearchPageClient.prototype.logOpenSmartSnippetSuggestionSource = function (info, snippet) {
+            return this.makeOpenSmartSnippetSuggestionSource(info, snippet).log();
+        };
+        CoveoSearchPageClient.prototype.makeOpenSmartSnippetInlineLink = function (info, identifierAndLink) {
+            return this.makeClickEvent(SearchPageEvents.openSmartSnippetInlineLink, info, { contentIDKey: identifierAndLink.contentIDKey, contentIDValue: identifierAndLink.contentIDValue }, identifierAndLink);
+        };
+        CoveoSearchPageClient.prototype.logOpenSmartSnippetInlineLink = function (info, identifierAndLink) {
+            return this.makeOpenSmartSnippetInlineLink(info, identifierAndLink).log();
+        };
+        CoveoSearchPageClient.prototype.makeOpenSmartSnippetSuggestionInlineLink = function (info, snippetAndLink) {
+            return this.makeClickEvent(SearchPageEvents.openSmartSnippetSuggestionInlineLink, info, {
+                contentIDKey: snippetAndLink.documentId.contentIdKey,
+                contentIDValue: snippetAndLink.documentId.contentIdValue,
+            }, snippetAndLink);
+        };
+        CoveoSearchPageClient.prototype.logOpenSmartSnippetSuggestionInlineLink = function (info, snippetAndLink) {
+            return this.makeOpenSmartSnippetSuggestionInlineLink(info, snippetAndLink).log();
+        };
+        CoveoSearchPageClient.prototype.makeRecentQueryClick = function () {
+            return this.makeSearchEvent(SearchPageEvents.recentQueryClick);
+        };
+        CoveoSearchPageClient.prototype.logRecentQueryClick = function () {
+            return this.makeRecentQueryClick().log();
+        };
+        CoveoSearchPageClient.prototype.makeClearRecentQueries = function () {
+            return this.makeCustomEvent(SearchPageEvents.clearRecentQueries);
+        };
+        CoveoSearchPageClient.prototype.logClearRecentQueries = function () {
+            return this.makeClearRecentQueries().log();
+        };
+        CoveoSearchPageClient.prototype.makeRecentResultClick = function (info, identifier) {
+            return this.makeCustomEvent(SearchPageEvents.recentResultClick, { info: info, identifier: identifier });
+        };
+        CoveoSearchPageClient.prototype.logRecentResultClick = function (info, identifier) {
+            return this.makeRecentResultClick(info, identifier).log();
+        };
+        CoveoSearchPageClient.prototype.makeClearRecentResults = function () {
+            return this.makeCustomEvent(SearchPageEvents.clearRecentResults);
+        };
+        CoveoSearchPageClient.prototype.logClearRecentResults = function () {
+            return this.makeClearRecentResults().log();
+        };
+        CoveoSearchPageClient.prototype.makeNoResultsBack = function () {
+            return this.makeSearchEvent(SearchPageEvents.noResultsBack);
+        };
+        CoveoSearchPageClient.prototype.logNoResultsBack = function () {
+            return this.makeNoResultsBack().log();
+        };
+        CoveoSearchPageClient.prototype.makeShowMoreFoldedResults = function (info, identifier) {
+            return this.makeClickEvent(SearchPageEvents.showMoreFoldedResults, info, identifier);
+        };
+        CoveoSearchPageClient.prototype.logShowMoreFoldedResults = function (info, identifier) {
+            return this.makeShowMoreFoldedResults(info, identifier).log();
+        };
+        CoveoSearchPageClient.prototype.makeShowLessFoldedResults = function () {
+            return this.makeCustomEvent(SearchPageEvents.showLessFoldedResults);
+        };
+        CoveoSearchPageClient.prototype.logShowLessFoldedResults = function () {
+            return this.makeShowLessFoldedResults().log();
+        };
+        CoveoSearchPageClient.prototype.makeCustomEvent = function (event, metadata, eventType) {
+            var _this = this;
+            if (eventType === void 0) { eventType = CustomEventsTypes[event]; }
+            var customData = __assign(__assign({}, this.provider.getBaseMetadata()), metadata);
+            return {
+                description: this.makeDescription(event, metadata),
+                log: function () { return __awaiter(_this, void 0, void 0, function () {
+                    var payload, _a;
+                    return __generator(this, function (_b) {
+                        switch (_b.label) {
+                            case 0:
+                                _a = [{}];
+                                return [4, this.getBaseCustomEventRequest(customData)];
+                            case 1:
+                                payload = __assign.apply(void 0, [__assign.apply(void 0, _a.concat([(_b.sent())])), { eventType: eventType, eventValue: event }]);
+                                return [2, this.coveoAnalyticsClient.sendCustomEvent(payload)];
+                        }
+                    });
+                }); },
+            };
+        };
+        CoveoSearchPageClient.prototype.logCustomEvent = function (event, metadata, eventType) {
+            if (eventType === void 0) { eventType = CustomEventsTypes[event]; }
+            return this.makeCustomEvent(event, metadata, eventType).log();
+        };
+        CoveoSearchPageClient.prototype.makeCustomEventWithType = function (eventValue, eventType, metadata) {
+            var _this = this;
+            var customData = __assign(__assign({}, this.provider.getBaseMetadata()), metadata);
+            return {
+                description: { actionCause: eventValue, customData: customData },
+                log: function () { return __awaiter(_this, void 0, void 0, function () {
+                    var payload, _a;
+                    return __generator(this, function (_b) {
+                        switch (_b.label) {
+                            case 0:
+                                _a = [{}];
+                                return [4, this.getBaseCustomEventRequest(customData)];
+                            case 1:
+                                payload = __assign.apply(void 0, [__assign.apply(void 0, _a.concat([(_b.sent())])), { eventType: eventType,
+                                        eventValue: eventValue }]);
+                                return [2, this.coveoAnalyticsClient.sendCustomEvent(payload)];
+                        }
+                    });
+                }); },
+            };
+        };
+        CoveoSearchPageClient.prototype.logCustomEventWithType = function (eventValue, eventType, metadata) {
+            return this.makeCustomEventWithType(eventValue, eventType, metadata).log();
+        };
+        CoveoSearchPageClient.prototype.logSearchEvent = function (event, metadata) {
+            return __awaiter(this, void 0, void 0, function () {
+                var _a, _b;
+                return __generator(this, function (_c) {
+                    switch (_c.label) {
+                        case 0:
+                            _b = (_a = this.coveoAnalyticsClient).sendSearchEvent;
+                            return [4, this.getBaseSearchEventRequest(event, metadata)];
+                        case 1: return [2, _b.apply(_a, [_c.sent()])];
+                    }
+                });
+            });
+        };
+        CoveoSearchPageClient.prototype.makeDescription = function (actionCause, metadata) {
+            return { actionCause: actionCause, customData: __assign(__assign({}, this.provider.getBaseMetadata()), metadata) };
+        };
+        CoveoSearchPageClient.prototype.makeSearchEvent = function (event, metadata) {
+            var _this = this;
+            return {
+                description: this.makeDescription(event, metadata),
+                log: function () { return _this.logSearchEvent(event, metadata); },
+            };
+        };
+        CoveoSearchPageClient.prototype.logClickEvent = function (event, info, identifier, metadata) {
+            return __awaiter(this, void 0, void 0, function () {
+                var payload, _a;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            _a = [__assign({}, info)];
+                            return [4, this.getBaseEventRequest(__assign(__assign({}, identifier), metadata))];
+                        case 1:
+                            payload = __assign.apply(void 0, [__assign.apply(void 0, _a.concat([(_b.sent())])), { searchQueryUid: this.provider.getSearchUID(), queryPipeline: this.provider.getPipeline(), actionCause: event }]);
+                            return [2, this.coveoAnalyticsClient.sendClickEvent(payload)];
+                    }
+                });
+            });
+        };
+        CoveoSearchPageClient.prototype.makeClickEvent = function (event, info, identifier, metadata) {
+            var _this = this;
+            return {
+                description: this.makeDescription(event, __assign(__assign({}, identifier), metadata)),
+                log: function () { return _this.logClickEvent(event, info, identifier, metadata); },
+            };
+        };
+        CoveoSearchPageClient.prototype.getBaseSearchEventRequest = function (event, metadata) {
+            return __awaiter(this, void 0, void 0, function () {
+                var _a;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            _a = [{}];
+                            return [4, this.getBaseEventRequest(metadata)];
+                        case 1: return [2, __assign.apply(void 0, [__assign.apply(void 0, [__assign.apply(void 0, _a.concat([(_b.sent())])), this.provider.getSearchEventRequestPayload()]), { searchQueryUid: this.provider.getSearchUID(), queryPipeline: this.provider.getPipeline(), actionCause: event }])];
+                    }
+                });
+            });
+        };
+        CoveoSearchPageClient.prototype.getBaseCustomEventRequest = function (metadata) {
+            return __awaiter(this, void 0, void 0, function () {
+                var _a;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            _a = [{}];
+                            return [4, this.getBaseEventRequest(metadata)];
+                        case 1: return [2, __assign.apply(void 0, [__assign.apply(void 0, _a.concat([(_b.sent())])), { lastSearchQueryUid: this.provider.getSearchUID() }])];
+                    }
+                });
+            });
+        };
+        CoveoSearchPageClient.prototype.getBaseEventRequest = function (metadata) {
+            return __awaiter(this, void 0, void 0, function () {
+                var customData, _a, _b;
+                return __generator(this, function (_c) {
+                    switch (_c.label) {
+                        case 0:
+                            customData = __assign(__assign({}, this.provider.getBaseMetadata()), metadata);
+                            _a = [__assign(__assign({}, this.getOrigins()), this.getSplitTestRun())];
+                            _b = { customData: customData, language: this.provider.getLanguage(), facetState: this.provider.getFacetState ? this.provider.getFacetState() : [], anonymous: this.provider.getIsAnonymous() };
+                            return [4, this.getClientId()];
+                        case 1: return [2, __assign.apply(void 0, _a.concat([(_b.clientId = _c.sent(), _b)]))];
+                    }
+                });
+            });
+        };
+        CoveoSearchPageClient.prototype.getOrigins = function () {
+            var _a, _b;
+            return {
+                originContext: (_b = (_a = this.provider).getOriginContext) === null || _b === void 0 ? void 0 : _b.call(_a),
+                originLevel1: this.provider.getOriginLevel1(),
+                originLevel2: this.provider.getOriginLevel2(),
+                originLevel3: this.provider.getOriginLevel3(),
+            };
+        };
+        CoveoSearchPageClient.prototype.getClientId = function () {
+            return this.coveoAnalyticsClient instanceof CoveoAnalyticsClient
+                ? this.coveoAnalyticsClient.getCurrentVisitorId()
+                : undefined;
+        };
+        CoveoSearchPageClient.prototype.getSplitTestRun = function () {
+            var splitTestRunName = this.provider.getSplitTestRunName ? this.provider.getSplitTestRunName() : '';
+            var splitTestRunVersion = this.provider.getSplitTestRunVersion ? this.provider.getSplitTestRunVersion() : '';
+            return __assign(__assign({}, (splitTestRunName && { splitTestRunName: splitTestRunName })), (splitTestRunVersion && { splitTestRunVersion: splitTestRunVersion }));
+        };
+        return CoveoSearchPageClient;
+    }());
+
+    var CaseAssistEvents;
+    (function (CaseAssistEvents) {
+        CaseAssistEvents["click"] = "click";
+        CaseAssistEvents["flowStart"] = "flowStart";
+    })(CaseAssistEvents || (CaseAssistEvents = {}));
+    var CaseAssistActions;
+    (function (CaseAssistActions) {
+        CaseAssistActions["enterInterface"] = "ticket_create_start";
+        CaseAssistActions["fieldUpdate"] = "ticket_field_update";
+        CaseAssistActions["fieldSuggestionClick"] = "ticket_classification_click";
+        CaseAssistActions["suggestionClick"] = "suggestion_click";
+        CaseAssistActions["suggestionRate"] = "suggestion_rate";
+        CaseAssistActions["nextCaseStep"] = "ticket_next_stage";
+        CaseAssistActions["caseCancelled"] = "ticket_cancel";
+        CaseAssistActions["caseSolved"] = "ticket_cancel";
+        CaseAssistActions["caseCreated"] = "ticket_create";
+    })(CaseAssistActions || (CaseAssistActions = {}));
+    var CaseCancelledReasons;
+    (function (CaseCancelledReasons) {
+        CaseCancelledReasons["quit"] = "Quit";
+        CaseCancelledReasons["solved"] = "Solved";
+    })(CaseCancelledReasons || (CaseCancelledReasons = {}));
+
+    var CaseAssistClient = (function () {
+        function CaseAssistClient(options, provider) {
+            var _a;
+            this.options = options;
+            this.provider = provider;
+            var analyticsEnabled = ((_a = options.enableAnalytics) !== null && _a !== void 0 ? _a : true) && !doNotTrack();
+            this.coveoAnalyticsClient = analyticsEnabled ? new CoveoAnalyticsClient(options) : new NoopAnalytics();
+            this.svc = new SVCPlugin({ client: this.coveoAnalyticsClient });
+        }
+        CaseAssistClient.prototype.disable = function () {
+            if (this.coveoAnalyticsClient instanceof CoveoAnalyticsClient) {
+                this.coveoAnalyticsClient.clear();
+            }
+            this.coveoAnalyticsClient = new NoopAnalytics();
+            this.svc = new SVCPlugin({ client: this.coveoAnalyticsClient });
+        };
+        CaseAssistClient.prototype.enable = function () {
+            this.coveoAnalyticsClient = new CoveoAnalyticsClient(this.options);
+            this.svc = new SVCPlugin({ client: this.coveoAnalyticsClient });
+        };
+        CaseAssistClient.prototype.logEnterInterface = function (meta) {
+            this.svc.setAction(CaseAssistActions.enterInterface);
+            this.svc.setTicket(meta.ticket);
+            return this.sendFlowStartEvent();
+        };
+        CaseAssistClient.prototype.logUpdateCaseField = function (meta) {
+            this.svc.setAction(CaseAssistActions.fieldUpdate, {
+                fieldName: meta.fieldName,
+            });
+            this.svc.setTicket(meta.ticket);
+            return this.sendClickEvent();
+        };
+        CaseAssistClient.prototype.logSelectFieldSuggestion = function (meta) {
+            this.svc.setAction(CaseAssistActions.fieldSuggestionClick, meta.suggestion);
+            this.svc.setTicket(meta.ticket);
+            return this.sendClickEvent();
+        };
+        CaseAssistClient.prototype.logSelectDocumentSuggestion = function (meta) {
+            this.svc.setAction(CaseAssistActions.suggestionClick, meta.suggestion);
+            this.svc.setTicket(meta.ticket);
+            return this.sendClickEvent();
+        };
+        CaseAssistClient.prototype.logRateDocumentSuggestion = function (meta) {
+            this.svc.setAction(CaseAssistActions.suggestionRate, __assign({ rate: meta.rating }, meta.suggestion));
+            this.svc.setTicket(meta.ticket);
+            return this.sendClickEvent();
+        };
+        CaseAssistClient.prototype.logMoveToNextCaseStep = function (meta) {
+            this.svc.setAction(CaseAssistActions.nextCaseStep, {
+                stage: meta === null || meta === void 0 ? void 0 : meta.stage,
+            });
+            this.svc.setTicket(meta.ticket);
+            return this.sendClickEvent();
+        };
+        CaseAssistClient.prototype.logCaseCancelled = function (meta) {
+            this.svc.setAction(CaseAssistActions.caseCancelled, {
+                reason: CaseCancelledReasons.quit,
+            });
+            this.svc.setTicket(meta.ticket);
+            return this.sendClickEvent();
+        };
+        CaseAssistClient.prototype.logCaseSolved = function (meta) {
+            this.svc.setAction(CaseAssistActions.caseSolved, {
+                reason: CaseCancelledReasons.solved,
+            });
+            this.svc.setTicket(meta.ticket);
+            return this.sendClickEvent();
+        };
+        CaseAssistClient.prototype.logCaseCreated = function (meta) {
+            this.svc.setAction(CaseAssistActions.caseCreated);
+            this.svc.setTicket(meta.ticket);
+            return this.sendClickEvent();
+        };
+        CaseAssistClient.prototype.sendFlowStartEvent = function () {
+            return this.coveoAnalyticsClient.sendEvent('event', 'svc', CaseAssistEvents.flowStart, this.provider
+                ? {
+                    searchHub: this.provider.getOriginLevel1(),
+                }
+                : null);
+        };
+        CaseAssistClient.prototype.sendClickEvent = function () {
+            return this.coveoAnalyticsClient.sendEvent('event', 'svc', CaseAssistEvents.click, this.provider
+                ? {
+                    searchHub: this.provider.getOriginLevel1(),
+                }
+                : null);
+        };
+        return CaseAssistClient;
+    }());
+
+    var extractContextFromMetadata = function (meta) {
+        var context = {};
+        if (meta.caseContext) {
+            Object.keys(meta.caseContext).forEach(function (contextKey) {
+                var _a;
+                var value = (_a = meta.caseContext) === null || _a === void 0 ? void 0 : _a[contextKey];
+                if (value) {
+                    var keyToBeSent = "context_" + contextKey;
+                    context[keyToBeSent] = value;
+                }
+            });
+        }
+        return context;
+    };
+    var generateMetadataToSend = function (metadata, includeContext) {
+        if (includeContext === void 0) { includeContext = true; }
+        metadata.caseContext; var caseId = metadata.caseId, caseNumber = metadata.caseNumber, metadataWithoutContext = __rest(metadata, ["caseContext", "caseId", "caseNumber"]);
+        var context = extractContextFromMetadata(metadata);
+        return __assign(__assign(__assign({ CaseId: caseId, CaseNumber: caseNumber }, metadataWithoutContext), (!!context.context_Case_Subject && { CaseSubject: context.context_Case_Subject })), (includeContext && context));
+    };
+    var CoveoInsightClient = (function () {
+        function CoveoInsightClient(opts, provider) {
+            this.opts = opts;
+            this.provider = provider;
+            var shouldDisableAnalytics = opts.enableAnalytics === false || doNotTrack();
+            this.coveoAnalyticsClient = shouldDisableAnalytics ? new NoopAnalytics() : new CoveoAnalyticsClient(opts);
+        }
+        CoveoInsightClient.prototype.disable = function () {
+            if (this.coveoAnalyticsClient instanceof CoveoAnalyticsClient) {
+                this.coveoAnalyticsClient.clear();
+            }
+            this.coveoAnalyticsClient = new NoopAnalytics();
+        };
+        CoveoInsightClient.prototype.enable = function () {
+            this.coveoAnalyticsClient = new CoveoAnalyticsClient(this.opts);
+        };
+        CoveoInsightClient.prototype.logInterfaceLoad = function (metadata) {
+            if (metadata) {
+                var metadataToSend = generateMetadataToSend(metadata);
+                return this.logSearchEvent(SearchPageEvents.interfaceLoad, metadataToSend);
+            }
+            return this.logSearchEvent(SearchPageEvents.interfaceLoad);
+        };
+        CoveoInsightClient.prototype.logInterfaceChange = function (metadata) {
+            var metadataToSend = generateMetadataToSend(metadata);
+            return this.logSearchEvent(SearchPageEvents.interfaceChange, metadataToSend);
+        };
+        CoveoInsightClient.prototype.logStaticFilterDeselect = function (metadata) {
+            var metadataToSend = generateMetadataToSend(metadata);
+            return this.logSearchEvent(SearchPageEvents.staticFilterDeselect, metadataToSend);
+        };
+        CoveoInsightClient.prototype.logFetchMoreResults = function (metadata) {
+            if (metadata) {
+                var metadataToSend = generateMetadataToSend(metadata);
+                return this.logCustomEvent(SearchPageEvents.pagerScrolling, __assign(__assign({}, metadataToSend), { type: 'getMoreResults' }));
+            }
+            return this.logCustomEvent(SearchPageEvents.pagerScrolling, { type: 'getMoreResults' });
+        };
+        CoveoInsightClient.prototype.logBreadcrumbFacet = function (metadata) {
+            var metadataToSend = generateMetadataToSend(metadata);
+            return this.logSearchEvent(SearchPageEvents.breadcrumbFacet, metadataToSend);
+        };
+        CoveoInsightClient.prototype.logBreadcrumbResetAll = function (metadata) {
+            if (metadata) {
+                var metadataToSend = generateMetadataToSend(metadata);
+                return this.logSearchEvent(SearchPageEvents.breadcrumbResetAll, metadataToSend);
+            }
+            return this.logSearchEvent(SearchPageEvents.breadcrumbResetAll);
+        };
+        CoveoInsightClient.prototype.logFacetSelect = function (metadata) {
+            var metadataToSend = generateMetadataToSend(metadata);
+            return this.logSearchEvent(SearchPageEvents.facetSelect, metadataToSend);
+        };
+        CoveoInsightClient.prototype.logFacetDeselect = function (metadata) {
+            var metadataToSend = generateMetadataToSend(metadata);
+            return this.logSearchEvent(SearchPageEvents.facetDeselect, metadataToSend);
+        };
+        CoveoInsightClient.prototype.logFacetUpdateSort = function (metadata) {
+            var metadataToSend = generateMetadataToSend(metadata);
+            return this.logSearchEvent(SearchPageEvents.facetUpdateSort, metadataToSend);
+        };
+        CoveoInsightClient.prototype.logFacetClearAll = function (metadata) {
+            var metadataToSend = generateMetadataToSend(metadata);
+            return this.logSearchEvent(SearchPageEvents.facetClearAll, metadataToSend);
+        };
+        CoveoInsightClient.prototype.logFacetShowMore = function (metadata) {
+            var metadataToSend = generateMetadataToSend(metadata, false);
+            return this.logCustomEvent(SearchPageEvents.facetShowMore, metadataToSend);
+        };
+        CoveoInsightClient.prototype.logFacetShowLess = function (metadata) {
+            var metadataToSend = generateMetadataToSend(metadata, false);
+            return this.logCustomEvent(SearchPageEvents.facetShowLess, metadataToSend);
+        };
+        CoveoInsightClient.prototype.logQueryError = function (metadata) {
+            var metadataToSend = generateMetadataToSend(metadata, false);
+            return this.logCustomEvent(SearchPageEvents.queryError, metadataToSend);
+        };
+        CoveoInsightClient.prototype.logPagerNumber = function (metadata) {
+            var metadataToSend = generateMetadataToSend(metadata, false);
+            return this.logCustomEvent(SearchPageEvents.pagerNumber, metadataToSend);
+        };
+        CoveoInsightClient.prototype.logPagerNext = function (metadata) {
+            var metadataToSend = generateMetadataToSend(metadata, false);
+            return this.logCustomEvent(SearchPageEvents.pagerNext, metadataToSend);
+        };
+        CoveoInsightClient.prototype.logPagerPrevious = function (metadata) {
+            var metadataToSend = generateMetadataToSend(metadata, false);
+            return this.logCustomEvent(SearchPageEvents.pagerPrevious, metadataToSend);
+        };
+        CoveoInsightClient.prototype.logDidYouMeanAutomatic = function (metadata) {
+            if (metadata) {
+                var metadataToSend = generateMetadataToSend(metadata);
+                return this.logSearchEvent(SearchPageEvents.didyoumeanAutomatic, metadataToSend);
+            }
+            return this.logSearchEvent(SearchPageEvents.didyoumeanAutomatic);
+        };
+        CoveoInsightClient.prototype.logDidYouMeanClick = function (metadata) {
+            if (metadata) {
+                var metadataToSend = generateMetadataToSend(metadata);
+                return this.logSearchEvent(SearchPageEvents.didyoumeanClick, metadataToSend);
+            }
+            return this.logSearchEvent(SearchPageEvents.didyoumeanClick);
+        };
+        CoveoInsightClient.prototype.logResultsSort = function (metadata) {
+            var metadataToSend = generateMetadataToSend(metadata);
+            return this.logSearchEvent(SearchPageEvents.resultsSort, metadataToSend);
+        };
+        CoveoInsightClient.prototype.logSearchboxSubmit = function (metadata) {
+            if (metadata) {
+                var metadataToSend = generateMetadataToSend(metadata);
+                return this.logSearchEvent(SearchPageEvents.searchboxSubmit, metadataToSend);
+            }
+            return this.logSearchEvent(SearchPageEvents.searchboxSubmit);
+        };
+        CoveoInsightClient.prototype.logContextChanged = function (metadata) {
+            var metadataToSend = generateMetadataToSend(metadata);
+            return this.logSearchEvent(InsightEvents.contextChanged, metadataToSend);
+        };
+        CoveoInsightClient.prototype.logExpandToFullUI = function (metadata) {
+            var metadataToSend = generateMetadataToSend(metadata);
+            return this.logCustomEvent(InsightEvents.expandToFullUI, metadataToSend);
+        };
+        CoveoInsightClient.prototype.logDocumentOpen = function (info, identifier, metadata) {
+            return this.logClickEvent(SearchPageEvents.documentOpen, info, identifier, metadata ? generateMetadataToSend(metadata, false) : undefined);
+        };
+        CoveoInsightClient.prototype.logCopyToClipboard = function (info, identifier, metadata) {
+            return this.logClickEvent(SearchPageEvents.copyToClipboard, info, identifier, metadata ? generateMetadataToSend(metadata, false) : undefined);
+        };
+        CoveoInsightClient.prototype.logDocumentQuickview = function (info, identifier, caseMetadata) {
+            var metadata = {
+                documentTitle: info.documentTitle,
+                documentURL: info.documentUrl,
+            };
+            return this.logClickEvent(SearchPageEvents.documentQuickview, info, identifier, caseMetadata ? __assign(__assign({}, generateMetadataToSend(caseMetadata, false)), metadata) : metadata);
+        };
+        CoveoInsightClient.prototype.logCustomEvent = function (event, metadata) {
+            return __awaiter(this, void 0, void 0, function () {
+                var customData, payload, _a;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            customData = __assign(__assign({}, this.provider.getBaseMetadata()), metadata);
+                            _a = [{}];
+                            return [4, this.getBaseCustomEventRequest(customData)];
+                        case 1:
+                            payload = __assign.apply(void 0, [__assign.apply(void 0, _a.concat([(_b.sent())])), { eventType: CustomEventsTypes[event], eventValue: event }]);
+                            return [2, this.coveoAnalyticsClient.sendCustomEvent(payload)];
+                    }
+                });
+            });
+        };
+        CoveoInsightClient.prototype.logSearchEvent = function (event, metadata) {
+            return __awaiter(this, void 0, void 0, function () {
+                var _a, _b;
+                return __generator(this, function (_c) {
+                    switch (_c.label) {
+                        case 0:
+                            _b = (_a = this.coveoAnalyticsClient).sendSearchEvent;
+                            return [4, this.getBaseSearchEventRequest(event, metadata)];
+                        case 1: return [2, _b.apply(_a, [_c.sent()])];
+                    }
+                });
+            });
+        };
+        CoveoInsightClient.prototype.logClickEvent = function (event, info, identifier, metadata) {
+            return __awaiter(this, void 0, void 0, function () {
+                var payload, _a;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            _a = [__assign({}, info)];
+                            return [4, this.getBaseEventRequest(__assign(__assign({}, identifier), metadata))];
+                        case 1:
+                            payload = __assign.apply(void 0, [__assign.apply(void 0, _a.concat([(_b.sent())])), { searchQueryUid: this.provider.getSearchUID(), queryPipeline: this.provider.getPipeline(), actionCause: event }]);
+                            return [2, this.coveoAnalyticsClient.sendClickEvent(payload)];
+                    }
+                });
+            });
+        };
+        CoveoInsightClient.prototype.getBaseCustomEventRequest = function (metadata) {
+            return __awaiter(this, void 0, void 0, function () {
+                var _a;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            _a = [{}];
+                            return [4, this.getBaseEventRequest(metadata)];
+                        case 1: return [2, __assign.apply(void 0, [__assign.apply(void 0, _a.concat([(_b.sent())])), { lastSearchQueryUid: this.provider.getSearchUID() }])];
+                    }
+                });
+            });
+        };
+        CoveoInsightClient.prototype.getBaseSearchEventRequest = function (event, metadata) {
+            return __awaiter(this, void 0, void 0, function () {
+                var _a;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            _a = [{}];
+                            return [4, this.getBaseEventRequest(metadata)];
+                        case 1: return [2, __assign.apply(void 0, [__assign.apply(void 0, [__assign.apply(void 0, _a.concat([(_b.sent())])), this.provider.getSearchEventRequestPayload()]), { searchQueryUid: this.provider.getSearchUID(), queryPipeline: this.provider.getPipeline(), actionCause: event }])];
+                    }
+                });
+            });
+        };
+        CoveoInsightClient.prototype.getBaseEventRequest = function (metadata) {
+            return __awaiter(this, void 0, void 0, function () {
+                var customData, _a, _b;
+                return __generator(this, function (_c) {
+                    switch (_c.label) {
+                        case 0:
+                            customData = __assign(__assign({}, this.provider.getBaseMetadata()), metadata);
+                            _a = [__assign({}, this.getOrigins())];
+                            _b = { customData: customData, language: this.provider.getLanguage(), facetState: this.provider.getFacetState ? this.provider.getFacetState() : [], anonymous: this.provider.getIsAnonymous() };
+                            return [4, this.getClientId()];
+                        case 1: return [2, __assign.apply(void 0, _a.concat([(_b.clientId = _c.sent(), _b)]))];
+                    }
+                });
+            });
+        };
+        CoveoInsightClient.prototype.getOrigins = function () {
+            var _a, _b;
+            return {
+                originContext: (_b = (_a = this.provider).getOriginContext) === null || _b === void 0 ? void 0 : _b.call(_a),
+                originLevel1: this.provider.getOriginLevel1(),
+                originLevel2: this.provider.getOriginLevel2(),
+                originLevel3: this.provider.getOriginLevel3(),
+            };
+        };
+        CoveoInsightClient.prototype.getClientId = function () {
+            return this.coveoAnalyticsClient instanceof CoveoAnalyticsClient
+                ? this.coveoAnalyticsClient.getCurrentVisitorId()
+                : undefined;
+        };
+        return CoveoInsightClient;
+    }());
+
+    var analytics = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        analytics: analytics$1,
+        donottrack: donottrack,
+        history: history,
+        SimpleAnalytics: simpleanalytics,
+        storage: storage,
+        CoveoAnalyticsClient: CoveoAnalyticsClient,
+        CoveoUA: CoveoUA,
+        getCurrentClient: getCurrentClient,
+        handleOneAnalyticsEvent: handleOneAnalyticsEvent,
+        CoveoSearchPageClient: CoveoSearchPageClient,
+        CaseAssistClient: CaseAssistClient,
+        CoveoInsightClient: CoveoInsightClient
+    });
+
+    var promise = window['Promise'];
+    if (!(promise instanceof Function)) {
+        console.error("This script uses window.Promise which is not supported in your browser. Consider adding a polyfill like \"es6-promise\".");
+    }
+    var fetch$1 = window['fetch'];
+    if (!(fetch$1 instanceof Function)) {
+        console.error("This script uses window.fetch which is not supported in your browser. Consider adding a polyfill like \"fetch\".");
+    }
+    var coveoua = self.coveoua || handleOneAnalyticsEvent;
+    self.coveoua = handleOneAnalyticsEvent;
+    self.coveoanalytics = analytics;
+    if (coveoua.q) {
+        var initEvents = coveoua.q.filter(function (args) { return args[0] === 'init'; });
+        var otherEvents = coveoua.q.filter(function (args) { return args[0] !== 'init'; });
+        __spreadArrays(initEvents, otherEvents).forEach(function (args) { return handleOneAnalyticsEvent.apply(void 0, args); });
+    }
+    var browser = self.coveoua;
+
+    return browser;
+
+}));
+//# sourceMappingURL=coveoua.debug.js.map