coveo.analytics 2.28.16 → 2.28.17

package/dist/browser.mjs

@@ -0,0 +1,3141 @@
+/******************************************************************************
+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.
+***************************************************************************** */
+
+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());
+    });
+}
+
+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;
+}
+
+const eventTypesForDefaultValues = [EventType.click, EventType.custom, EventType.search, EventType.view];
+const addDefaultValues = (eventType, payload) => {
+    return eventTypesForDefaultValues.indexOf(eventType) !== -1
+        ? Object.assign({ language: hasDocument() ? document.documentElement.lang : 'unknown', userAgent: hasNavigator() ? navigator.userAgent : 'unknown' }, payload) : payload;
+};
+
+class Cookie {
+    static set(name, value, expire) {
+        var domain, expirationDate, domainParts, host;
+        if (expire) {
+            expirationDate = new Date();
+            expirationDate.setTime(expirationDate.getTime() + expire);
+        }
+        host = window.location.hostname;
+        if (host.indexOf('.') === -1) {
+            writeCookie(name, value, expirationDate);
+        }
+        else {
+            domainParts = host.split('.');
+            domain = domainParts[domainParts.length - 2] + '.' + domainParts[domainParts.length - 1];
+            writeCookie(name, value, expirationDate, domain);
+        }
+    }
+    static get(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.lastIndexOf(cookiePrefix, 0) === 0) {
+                return cookie.substring(cookiePrefix.length, cookie.length);
+            }
+        }
+        return null;
+    }
+    static erase(name) {
+        Cookie.set(name, '', -1);
+    }
+}
+function writeCookie(name, value, expirationDate, domain) {
+    document.cookie =
+        `${name}=${value}` +
+            (expirationDate ? `;expires=${expirationDate.toUTCString()}` : '') +
+            (domain ? `;domain=${domain}` : '') +
+            ';path=/;SameSite=Lax';
+}
+
+function getAvailableStorage() {
+    if (hasLocalStorage()) {
+        return localStorage;
+    }
+    if (hasCookieStorage()) {
+        return new CookieStorage();
+    }
+    if (hasSessionStorage()) {
+        return sessionStorage;
+    }
+    return new NullStorage();
+}
+class CookieStorage {
+    getItem(key) {
+        return Cookie.get(`${CookieStorage.prefix}${key}`);
+    }
+    removeItem(key) {
+        Cookie.erase(`${CookieStorage.prefix}${key}`);
+    }
+    setItem(key, data, expire) {
+        Cookie.set(`${CookieStorage.prefix}${key}`, data, expire);
+    }
+}
+CookieStorage.prefix = 'coveo_';
+class CookieAndLocalStorage {
+    constructor() {
+        this.cookieStorage = new CookieStorage();
+    }
+    getItem(key) {
+        return localStorage.getItem(key) || this.cookieStorage.getItem(key);
+    }
+    removeItem(key) {
+        this.cookieStorage.removeItem(key);
+        localStorage.removeItem(key);
+    }
+    setItem(key, data) {
+        localStorage.setItem(key, data);
+        this.cookieStorage.setItem(key, data, 31556926000);
+    }
+}
+class NullStorage {
+    getItem(key) {
+        return null;
+    }
+    removeItem(key) {
+    }
+    setItem(key, data) {
+    }
+}
+
+const STORE_KEY = '__coveo.analytics.history';
+const MAX_NUMBER_OF_HISTORY_ELEMENTS = 20;
+const MIN_THRESHOLD_FOR_DUPLICATE_VALUE = 1000 * 60;
+const MAX_VALUE_SIZE = 75;
+class HistoryStore {
+    constructor(store) {
+        this.store = store || getAvailableStorage();
+    }
+    addElement(elem) {
+        elem.internalTime = new Date().getTime();
+        elem = this.cropQueryElement(this.stripEmptyQuery(elem));
+        let currentHistory = this.getHistoryWithInternalTime();
+        if (currentHistory != null) {
+            if (this.isValidEntry(elem)) {
+                this.setHistory([elem].concat(currentHistory));
+            }
+        }
+        else {
+            this.setHistory([elem]);
+        }
+    }
+    addElementAsync(elem) {
+        return __awaiter(this, void 0, void 0, function* () {
+            elem.internalTime = new Date().getTime();
+            elem = this.cropQueryElement(this.stripEmptyQuery(elem));
+            let currentHistory = yield this.getHistoryWithInternalTimeAsync();
+            if (currentHistory != null) {
+                if (this.isValidEntry(elem)) {
+                    this.setHistory([elem].concat(currentHistory));
+                }
+            }
+            else {
+                this.setHistory([elem]);
+            }
+        });
+    }
+    getHistory() {
+        const history = this.getHistoryWithInternalTime();
+        return this.stripEmptyQueries(this.stripInternalTime(history));
+    }
+    getHistoryAsync() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const history = yield this.getHistoryWithInternalTimeAsync();
+            return this.stripEmptyQueries(this.stripInternalTime(history));
+        });
+    }
+    getHistoryWithInternalTime() {
+        try {
+            const elements = this.store.getItem(STORE_KEY);
+            if (elements && typeof elements === 'string') {
+                return JSON.parse(elements);
+            }
+            else {
+                return [];
+            }
+        }
+        catch (e) {
+            return [];
+        }
+    }
+    getHistoryWithInternalTimeAsync() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const elements = yield this.store.getItem(STORE_KEY);
+                if (elements) {
+                    return JSON.parse(elements);
+                }
+                else {
+                    return [];
+                }
+            }
+            catch (e) {
+                return [];
+            }
+        });
+    }
+    setHistory(history) {
+        try {
+            this.store.setItem(STORE_KEY, JSON.stringify(history.slice(0, MAX_NUMBER_OF_HISTORY_ELEMENTS)));
+        }
+        catch (e) {
+        }
+    }
+    clear() {
+        try {
+            this.store.removeItem(STORE_KEY);
+        }
+        catch (e) {
+        }
+    }
+    getMostRecentElement() {
+        let currentHistory = this.getHistoryWithInternalTime();
+        if (Array.isArray(currentHistory)) {
+            const sorted = currentHistory.sort((first, second) => {
+                return (second.internalTime || 0) - (first.internalTime || 0);
+            });
+            return sorted[0];
+        }
+        return null;
+    }
+    cropQueryElement(part) {
+        if (part.name && part.value && part.name.toLowerCase() === 'query') {
+            part.value = part.value.slice(0, MAX_VALUE_SIZE);
+        }
+        return part;
+    }
+    isValidEntry(elem) {
+        let lastEntry = this.getMostRecentElement();
+        if (lastEntry && lastEntry.value == elem.value) {
+            return (elem.internalTime || 0) - (lastEntry.internalTime || 0) > MIN_THRESHOLD_FOR_DUPLICATE_VALUE;
+        }
+        return true;
+    }
+    stripInternalTime(history) {
+        if (Array.isArray(history)) {
+            return history.map((part) => {
+                const { name, time, value } = part;
+                return { name, time, value };
+            });
+        }
+        return [];
+    }
+    stripEmptyQuery(part) {
+        const { name, time, value } = part;
+        if (name && typeof value === 'string' && name.toLowerCase() === 'query' && value.trim() === '') {
+            return { name, time };
+        }
+        return part;
+    }
+    stripEmptyQueries(history) {
+        return history.map((part) => this.stripEmptyQuery(part));
+    }
+}
+
+var history = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    HistoryStore: HistoryStore,
+    MAX_NUMBER_OF_HISTORY_ELEMENTS: MAX_NUMBER_OF_HISTORY_ELEMENTS,
+    MAX_VALUE_SIZE: MAX_VALUE_SIZE,
+    MIN_THRESHOLD_FOR_DUPLICATE_VALUE: MIN_THRESHOLD_FOR_DUPLICATE_VALUE,
+    STORE_KEY: STORE_KEY,
+    default: HistoryStore
+});
+
+const enhanceViewEvent = (eventType, payload) => __awaiter(void 0, void 0, void 0, function* () {
+    if (eventType === EventType.view) {
+        yield addPageViewToHistory(payload.contentIdValue);
+        return Object.assign({ location: window.location.toString(), referrer: document.referrer, title: document.title }, payload);
+    }
+    return payload;
+});
+const addPageViewToHistory = (pageViewValue) => __awaiter(void 0, void 0, void 0, function* () {
+    const store = new HistoryStore();
+    const historyElement = {
+        name: 'PageView',
+        value: pageViewValue,
+        time: new Date().toISOString(),
+    };
+    yield store.addElementAsync(historyElement);
+});
+
+// Unique ID creation requires a high quality random # generator. In the browser we therefore
+// require the crypto API and do not support built-in fallback to lower quality random number
+// generators (like Math.random()).
+let getRandomValues;
+const rnds8 = new Uint8Array(16);
+function rng() {
+  // lazy load so that environments that need to polyfill have a chance to do so
+  if (!getRandomValues) {
+    // getRandomValues needs to be invoked in a context where "this" is a Crypto implementation.
+    getRandomValues = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto);
+
+    if (!getRandomValues) {
+      throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');
+    }
+  }
+
+  return getRandomValues(rnds8);
+}
+
+var REGEX = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;
+
+function validate(uuid) {
+  return typeof uuid === 'string' && REGEX.test(uuid);
+}
+
+/**
+ * Convert array of 16 byte values to UUID string format of the form:
+ * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
+ */
+
+const byteToHex = [];
+
+for (let i = 0; i < 256; ++i) {
+  byteToHex.push((i + 0x100).toString(16).slice(1));
+}
+
+function unsafeStringify(arr, offset = 0) {
+  // Note: Be careful editing this code!  It's been tuned for performance
+  // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434
+  return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
+}
+
+function parse(uuid) {
+  if (!validate(uuid)) {
+    throw TypeError('Invalid UUID');
+  }
+
+  let v;
+  const arr = new Uint8Array(16); // Parse ########-....-....-....-............
+
+  arr[0] = (v = parseInt(uuid.slice(0, 8), 16)) >>> 24;
+  arr[1] = v >>> 16 & 0xff;
+  arr[2] = v >>> 8 & 0xff;
+  arr[3] = v & 0xff; // Parse ........-####-....-....-............
+
+  arr[4] = (v = parseInt(uuid.slice(9, 13), 16)) >>> 8;
+  arr[5] = v & 0xff; // Parse ........-....-####-....-............
+
+  arr[6] = (v = parseInt(uuid.slice(14, 18), 16)) >>> 8;
+  arr[7] = v & 0xff; // Parse ........-....-....-####-............
+
+  arr[8] = (v = parseInt(uuid.slice(19, 23), 16)) >>> 8;
+  arr[9] = v & 0xff; // Parse ........-....-....-....-############
+  // (Use "/" to avoid 32-bit truncation when bit-shifting high-order bytes)
+
+  arr[10] = (v = parseInt(uuid.slice(24, 36), 16)) / 0x10000000000 & 0xff;
+  arr[11] = v / 0x100000000 & 0xff;
+  arr[12] = v >>> 24 & 0xff;
+  arr[13] = v >>> 16 & 0xff;
+  arr[14] = v >>> 8 & 0xff;
+  arr[15] = v & 0xff;
+  return arr;
+}
+
+function stringToBytes(str) {
+  str = unescape(encodeURIComponent(str)); // UTF8 escape
+
+  const bytes = [];
+
+  for (let i = 0; i < str.length; ++i) {
+    bytes.push(str.charCodeAt(i));
+  }
+
+  return bytes;
+}
+
+const DNS = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
+const URL$1 = '6ba7b811-9dad-11d1-80b4-00c04fd430c8';
+function v35(name, version, hashfunc) {
+  function generateUUID(value, namespace, buf, offset) {
+    var _namespace;
+
+    if (typeof value === 'string') {
+      value = stringToBytes(value);
+    }
+
+    if (typeof namespace === 'string') {
+      namespace = parse(namespace);
+    }
+
+    if (((_namespace = namespace) === null || _namespace === void 0 ? void 0 : _namespace.length) !== 16) {
+      throw TypeError('Namespace must be array-like (16 iterable integer values, 0-255)');
+    } // Compute hash of namespace and value, Per 4.3
+    // Future: Use spread syntax when supported on all platforms, e.g. `bytes =
+    // hashfunc([...namespace, ... value])`
+
+
+    let bytes = new Uint8Array(16 + value.length);
+    bytes.set(namespace);
+    bytes.set(value, namespace.length);
+    bytes = hashfunc(bytes);
+    bytes[6] = bytes[6] & 0x0f | version;
+    bytes[8] = bytes[8] & 0x3f | 0x80;
+
+    if (buf) {
+      offset = offset || 0;
+
+      for (let i = 0; i < 16; ++i) {
+        buf[offset + i] = bytes[i];
+      }
+
+      return buf;
+    }
+
+    return unsafeStringify(bytes);
+  } // Function#name is not settable on some platforms (#270)
+
+
+  try {
+    generateUUID.name = name; // eslint-disable-next-line no-empty
+  } catch (err) {} // For CommonJS default export support
+
+
+  generateUUID.DNS = DNS;
+  generateUUID.URL = URL$1;
+  return generateUUID;
+}
+
+const randomUUID = typeof crypto !== 'undefined' && crypto.randomUUID && crypto.randomUUID.bind(crypto);
+var native = {
+  randomUUID
+};
+
+function v4(options, buf, offset) {
+  if (native.randomUUID && !buf && !options) {
+    return native.randomUUID();
+  }
+
+  options = options || {};
+  const rnds = options.random || (options.rng || rng)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
+
+  rnds[6] = rnds[6] & 0x0f | 0x40;
+  rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided
+
+  if (buf) {
+    offset = offset || 0;
+
+    for (let i = 0; i < 16; ++i) {
+      buf[offset + i] = rnds[i];
+    }
+
+    return buf;
+  }
+
+  return unsafeStringify(rnds);
+}
+
+// Adapted from Chris Veness' SHA1 code at
+// http://www.movable-type.co.uk/scripts/sha1.html
+function f(s, x, y, z) {
+  switch (s) {
+    case 0:
+      return x & y ^ ~x & z;
+
+    case 1:
+      return x ^ y ^ z;
+
+    case 2:
+      return x & y ^ x & z ^ y & z;
+
+    case 3:
+      return x ^ y ^ z;
+  }
+}
+
+function ROTL(x, n) {
+  return x << n | x >>> 32 - n;
+}
+
+function sha1(bytes) {
+  const K = [0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xca62c1d6];
+  const H = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0];
+
+  if (typeof bytes === 'string') {
+    const msg = unescape(encodeURIComponent(bytes)); // UTF8 escape
+
+    bytes = [];
+
+    for (let i = 0; i < msg.length; ++i) {
+      bytes.push(msg.charCodeAt(i));
+    }
+  } else if (!Array.isArray(bytes)) {
+    // Convert Array-like to Array
+    bytes = Array.prototype.slice.call(bytes);
+  }
+
+  bytes.push(0x80);
+  const l = bytes.length / 4 + 2;
+  const N = Math.ceil(l / 16);
+  const M = new Array(N);
+
+  for (let i = 0; i < N; ++i) {
+    const arr = new Uint32Array(16);
+
+    for (let j = 0; j < 16; ++j) {
+      arr[j] = bytes[i * 64 + j * 4] << 24 | bytes[i * 64 + j * 4 + 1] << 16 | bytes[i * 64 + j * 4 + 2] << 8 | bytes[i * 64 + j * 4 + 3];
+    }
+
+    M[i] = arr;
+  }
+
+  M[N - 1][14] = (bytes.length - 1) * 8 / Math.pow(2, 32);
+  M[N - 1][14] = Math.floor(M[N - 1][14]);
+  M[N - 1][15] = (bytes.length - 1) * 8 & 0xffffffff;
+
+  for (let i = 0; i < N; ++i) {
+    const W = new Uint32Array(80);
+
+    for (let t = 0; t < 16; ++t) {
+      W[t] = M[i][t];
+    }
+
+    for (let t = 16; t < 80; ++t) {
+      W[t] = ROTL(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1);
+    }
+
+    let a = H[0];
+    let b = H[1];
+    let c = H[2];
+    let d = H[3];
+    let e = H[4];
+
+    for (let t = 0; t < 80; ++t) {
+      const s = Math.floor(t / 20);
+      const T = ROTL(a, 5) + f(s, b, c, d) + e + K[s] + W[t] >>> 0;
+      e = d;
+      d = c;
+      c = ROTL(b, 30) >>> 0;
+      b = a;
+      a = T;
+    }
+
+    H[0] = H[0] + a >>> 0;
+    H[1] = H[1] + b >>> 0;
+    H[2] = H[2] + c >>> 0;
+    H[3] = H[3] + d >>> 0;
+    H[4] = H[4] + e >>> 0;
+  }
+
+  return [H[0] >> 24 & 0xff, H[0] >> 16 & 0xff, H[0] >> 8 & 0xff, H[0] & 0xff, H[1] >> 24 & 0xff, H[1] >> 16 & 0xff, H[1] >> 8 & 0xff, H[1] & 0xff, H[2] >> 24 & 0xff, H[2] >> 16 & 0xff, H[2] >> 8 & 0xff, H[2] & 0xff, H[3] >> 24 & 0xff, H[3] >> 16 & 0xff, H[3] >> 8 & 0xff, H[3] & 0xff, H[4] >> 24 & 0xff, H[4] >> 16 & 0xff, H[4] >> 8 & 0xff, H[4] & 0xff];
+}
+
+const v5 = v35('v5', 0x50, sha1);
+var uuidv5 = v5;
+
+const libVersion = "2.28.17" ;
+
+const getFormattedLocation = (location) => `${location.protocol}//${location.hostname}${location.pathname.indexOf('/') === 0 ? location.pathname : `/${location.pathname}`}${location.search}`;
+
+const BasePluginEventTypes = {
+    pageview: 'pageview',
+    event: 'event',
+};
+class Plugin {
+    constructor({ client, uuidGenerator = v4 }) {
+        this.client = client;
+        this.uuidGenerator = uuidGenerator;
+    }
+}
+class BasePlugin extends Plugin {
+    constructor({ client, uuidGenerator = v4 }) {
+        super({ client, uuidGenerator });
+        this.actionData = {};
+        this.pageViewId = uuidGenerator();
+        this.nextPageViewId = this.pageViewId;
+        this.currentLocation = getFormattedLocation(window.location);
+        this.lastReferrer = hasDocument() ? document.referrer : '';
+        this.addHooks();
+    }
+    getApi(name) {
+        switch (name) {
+            case 'setAction':
+                return this.setAction;
+            default:
+                return null;
+        }
+    }
+    setAction(action, options) {
+        this.action = action;
+        this.actionData = options;
+    }
+    clearData() {
+        this.clearPluginData();
+        this.action = undefined;
+        this.actionData = {};
+    }
+    getLocationInformation(eventType, payload) {
+        return Object.assign({ hitType: eventType }, this.getNextValues(eventType, payload));
+    }
+    updateLocationInformation(eventType, payload) {
+        this.updateLocationForNextPageView(eventType, payload);
+    }
+    getDefaultContextInformation(eventType) {
+        const documentContext = {
+            title: hasDocument() ? document.title : '',
+            encoding: hasDocument() ? document.characterSet : 'UTF-8',
+        };
+        const screenContext = {
+            screenResolution: `${screen.width}x${screen.height}`,
+            screenColor: `${screen.colorDepth}-bit`,
+        };
+        const navigatorContext = {
+            language: navigator.language,
+            userAgent: navigator.userAgent,
+        };
+        const eventContext = {
+            time: Date.now(),
+            eventId: this.uuidGenerator(),
+        };
+        return Object.assign(Object.assign(Object.assign(Object.assign({}, eventContext), screenContext), navigatorContext), documentContext);
+    }
+    updateLocationForNextPageView(eventType, payload) {
+        const { pageViewId, referrer, location } = this.getNextValues(eventType, payload);
+        this.lastReferrer = referrer;
+        this.pageViewId = pageViewId;
+        this.currentLocation = location;
+        if (eventType === BasePluginEventTypes.pageview) {
+            this.nextPageViewId = this.uuidGenerator();
+            this.hasSentFirstPageView = true;
+        }
+    }
+    getNextValues(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,
+        };
+    }
+    getCurrentLocationFromPayload(payload) {
+        if (!!payload.page) {
+            const removeStartingSlash = (page) => page.replace(/^\/?(.*)$/, '/$1');
+            const extractHostnamePart = (location) => location.split('/').slice(0, 3).join('/');
+            return `${extractHostnamePart(this.currentLocation)}${removeStartingSlash(payload.page)}`;
+        }
+        else {
+            return getFormattedLocation(window.location);
+        }
+    }
+}
+
+class CoveoLinkParam {
+    constructor(clientId, timestamp) {
+        if (!validate(clientId))
+            throw Error('Not a valid uuid');
+        this.clientId = clientId;
+        this.creationDate = Math.floor(timestamp / 1000);
+    }
+    toString() {
+        return this.clientId.replace(/-/g, '') + '.' + this.creationDate.toString();
+    }
+    get expired() {
+        const age = Math.floor(Date.now() / 1000) - this.creationDate;
+        return age < 0 || age > CoveoLinkParam.expirationTime;
+    }
+    validate(referrerString, referrerList) {
+        return !this.expired && this.matchReferrer(referrerString, referrerList);
+    }
+    matchReferrer(referrerString, referrerList) {
+        try {
+            const url = new URL(referrerString);
+            return referrerList.some((value) => {
+                const hostRegExp = new RegExp(value.replace(/\\/g, '\\\\').replace(/\./g, '\\.').replace(/\*/g, '.*') + '$');
+                return hostRegExp.test(url.host);
+            });
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    static fromString(input) {
+        const parts = input.split('.');
+        if (parts.length !== 2) {
+            return null;
+        }
+        const [clientIdPart, creationDate] = parts;
+        if (clientIdPart.length !== 32 || isNaN(parseInt(creationDate))) {
+            return null;
+        }
+        const clientId = clientIdPart.substring(0, 8) +
+            '-' +
+            clientIdPart.substring(8, 12) +
+            '-' +
+            clientIdPart.substring(12, 16) +
+            '-' +
+            clientIdPart.substring(16, 20) +
+            '-' +
+            clientIdPart.substring(20, 32);
+        if (validate(clientId)) {
+            return new CoveoLinkParam(clientId, Number.parseInt(creationDate) * 1000);
+        }
+        else {
+            return null;
+        }
+    }
+}
+CoveoLinkParam.cvo_cid = 'cvo_cid';
+CoveoLinkParam.expirationTime = 120;
+class LinkPlugin extends Plugin {
+    constructor({ client, uuidGenerator = v4 }) {
+        super({ client, uuidGenerator });
+    }
+    getApi(name) {
+        switch (name) {
+            case 'decorate':
+                return this.decorate;
+            case 'acceptFrom':
+                return this.acceptFrom;
+            default:
+                return null;
+        }
+    }
+    decorate(urlString) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.client.getCurrentVisitorId) {
+                throw new Error('Could not retrieve current clientId');
+            }
+            try {
+                const url = new URL(urlString);
+                const clientId = yield this.client.getCurrentVisitorId();
+                url.searchParams.set(CoveoLinkParam.cvo_cid, new CoveoLinkParam(clientId, Date.now()).toString());
+                return url.toString();
+            }
+            catch (error) {
+                throw new Error('Invalid URL provided');
+            }
+        });
+    }
+    acceptFrom(acceptedReferrers) {
+        this.client.setAcceptedLinkReferrers(acceptedReferrers);
+    }
+}
+LinkPlugin.Id = 'link';
+
+const keysOf = Object.keys;
+function isObject(o) {
+    return o !== null && typeof o === 'object' && !Array.isArray(o);
+}
+
+const 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',
+};
+const ticketKeysMappingValues = keysOf(ticketKeysMapping).map((key) => ticketKeysMapping[key]);
+const ticketSubKeysMatchGroup = [...ticketKeysMappingValues].join('|');
+const ticketKeyRegex = new RegExp(`^(${ticketSubKeysMatchGroup}$)`);
+const serviceActionsKeysMapping = {
+    svcAction: 'svc_action',
+    svcActionData: 'svc_action_data',
+};
+const convertTicketToMeasurementProtocol = (ticket) => {
+    return keysOf(ticket)
+        .filter((key) => ticket[key] !== undefined)
+        .reduce((mappedTicket, key) => {
+        const newKey = ticketKeysMapping[key] || key;
+        return Object.assign(Object.assign({}, mappedTicket), { [newKey]: ticket[key] });
+    }, {});
+};
+const isTicketKey = (key) => ticketKeyRegex.test(key);
+const isServiceKey = [isTicketKey];
+
+const productKeysMapping = {
+    id: 'id',
+    name: 'nm',
+    brand: 'br',
+    category: 'ca',
+    variant: 'va',
+    price: 'pr',
+    quantity: 'qt',
+    coupon: 'cc',
+    position: 'ps',
+    group: 'group',
+};
+const impressionKeysMapping = {
+    id: 'id',
+    name: 'nm',
+    brand: 'br',
+    category: 'ca',
+    variant: 'va',
+    position: 'ps',
+    price: 'pr',
+    group: 'group',
+};
+const productActionsKeysMapping = {
+    action: 'pa',
+    list: 'pal',
+    listSource: 'pls',
+};
+const transactionActionsKeysMapping = {
+    id: 'ti',
+    revenue: 'tr',
+    tax: 'tt',
+    shipping: 'ts',
+    coupon: 'tcc',
+    affiliation: 'ta',
+    step: 'cos',
+    option: 'col',
+};
+const coveoCommerceExtensionKeys = [
+    'loyaltyCardId',
+    'loyaltyTier',
+    'thirdPartyPersona',
+    'companyName',
+    'favoriteStore',
+    'storeName',
+    'userIndustry',
+    'userRole',
+    'userDepartment',
+    'businessUnit',
+];
+const quoteActionsKeysMapping = {
+    id: 'quoteId',
+    affiliation: 'quoteAffiliation',
+};
+const reviewActionsKeysMapping = {
+    id: 'reviewId',
+    rating: 'reviewRating',
+    comment: 'reviewComment',
+};
+const commerceActionKeysMappingPerAction = {
+    add: productActionsKeysMapping,
+    bookmark_add: productActionsKeysMapping,
+    bookmark_remove: productActionsKeysMapping,
+    click: productActionsKeysMapping,
+    checkout: productActionsKeysMapping,
+    checkout_option: productActionsKeysMapping,
+    detail: productActionsKeysMapping,
+    impression: productActionsKeysMapping,
+    remove: productActionsKeysMapping,
+    refund: Object.assign(Object.assign({}, productActionsKeysMapping), transactionActionsKeysMapping),
+    purchase: Object.assign(Object.assign({}, productActionsKeysMapping), transactionActionsKeysMapping),
+    quickview: productActionsKeysMapping,
+    quote: Object.assign(Object.assign({}, productActionsKeysMapping), quoteActionsKeysMapping),
+    review: Object.assign(Object.assign({}, productActionsKeysMapping), reviewActionsKeysMapping),
+};
+const productKeysMappingValues = keysOf(productKeysMapping).map((key) => productKeysMapping[key]);
+const impressionKeysMappingValues = keysOf(impressionKeysMapping).map((key) => impressionKeysMapping[key]);
+const productActionsKeysMappingValues = keysOf(productActionsKeysMapping).map((key) => productActionsKeysMapping[key]);
+const transactionActionsKeysMappingValues = keysOf(transactionActionsKeysMapping).map((key) => transactionActionsKeysMapping[key]);
+const reviewKeysMappingValues = keysOf(reviewActionsKeysMapping).map((key) => reviewActionsKeysMapping[key]);
+const quoteKeysMappingValues = keysOf(quoteActionsKeysMapping).map((key) => quoteActionsKeysMapping[key]);
+const productSubKeysMatchGroup = [...productKeysMappingValues, 'custom'].join('|');
+const impressionSubKeysMatchGroup = [...impressionKeysMappingValues, 'custom'].join('|');
+const productPrefixMatchGroup = '(pr[0-9]+)';
+const impressionPrefixMatchGroup = '(il[0-9]+pi[0-9]+)';
+const productKeyRegex = new RegExp(`^${productPrefixMatchGroup}(${productSubKeysMatchGroup})$`);
+const impressionKeyRegex = new RegExp(`^(${impressionPrefixMatchGroup}(${impressionSubKeysMatchGroup}))|(il[0-9]+nm)$`);
+const productActionsKeyRegex = new RegExp(`^(${productActionsKeysMappingValues.join('|')})$`);
+const transactionActionsKeyRegex = new RegExp(`^(${transactionActionsKeysMappingValues.join('|')})$`);
+const customProductKeyRegex = new RegExp(`^${productPrefixMatchGroup}custom$`);
+const customImpressionKeyRegex = new RegExp(`^${impressionPrefixMatchGroup}custom$`);
+const coveoCommerceExtensionKeysRegex = new RegExp(`^(${[...coveoCommerceExtensionKeys, ...reviewKeysMappingValues, ...quoteKeysMappingValues].join('|')})$`);
+const isProductKey = (key) => productKeyRegex.test(key);
+const isImpressionKey = (key) => impressionKeyRegex.test(key);
+const isProductActionsKey = (key) => productActionsKeyRegex.test(key);
+const isTransactionActionsKeyRegex = (key) => transactionActionsKeyRegex.test(key);
+const isCoveoCommerceExtensionKey = (key) => coveoCommerceExtensionKeysRegex.test(key);
+const isCommerceKey = [
+    isImpressionKey,
+    isProductKey,
+    isProductActionsKey,
+    isTransactionActionsKeyRegex,
+    isCoveoCommerceExtensionKey,
+];
+const isCustomCommerceKey = [customProductKeyRegex, customImpressionKeyRegex];
+
+const globalParamKeysMapping = {
+    anonymizeIp: 'aip',
+};
+const eventKeysMapping = {
+    eventCategory: 'ec',
+    eventAction: 'ea',
+    eventLabel: 'el',
+    eventValue: 'ev',
+    page: 'dp',
+    visitorId: 'cid',
+    clientId: 'cid',
+    userId: 'uid',
+    currencyCode: 'cu',
+};
+const 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',
+};
+const coveoExtensionsKeys = [
+    'contentId',
+    'contentIdKey',
+    'contentType',
+    'searchHub',
+    'tab',
+    'searchUid',
+    'permanentId',
+    'contentLocale',
+    'trackingId',
+];
+const baseMeasurementProtocolKeysMapping = Object.assign(Object.assign(Object.assign(Object.assign({}, globalParamKeysMapping), eventKeysMapping), contextInformationMapping), coveoExtensionsKeys.reduce((all, key) => (Object.assign(Object.assign({}, all), { [key]: key })), {}));
+
+const measurementProtocolKeysMapping = Object.assign(Object.assign({}, baseMeasurementProtocolKeysMapping), serviceActionsKeysMapping);
+const convertKeysToMeasurementProtocol = (params) => {
+    const keysMappingForAction = (!!params.action && commerceActionKeysMappingPerAction[params.action]) || {};
+    return keysOf(params).reduce((mappedKeys, key) => {
+        const newKey = keysMappingForAction[key] || measurementProtocolKeysMapping[key] || key;
+        return Object.assign(Object.assign({}, mappedKeys), { [newKey]: params[key] });
+    }, {});
+};
+const measurementProtocolKeysMappingValues = keysOf(measurementProtocolKeysMapping).map((key) => measurementProtocolKeysMapping[key]);
+const isKnownMeasurementProtocolKey = (key) => measurementProtocolKeysMappingValues.indexOf(key) !== -1;
+const isCustomKey = (key) => key === 'custom';
+const isMeasurementProtocolKey = (key) => {
+    return [...isCommerceKey, ...isServiceKey, isKnownMeasurementProtocolKey, isCustomKey].some((test) => test(key));
+};
+const convertCustomMeasurementProtocolKeys = (data) => {
+    return keysOf(data).reduce((all, current) => {
+        const match = getFirstCustomMeasurementProtocolKeyMatch(current);
+        if (match) {
+            return Object.assign(Object.assign({}, all), convertCustomObject(match, data[current]));
+        }
+        else {
+            return Object.assign(Object.assign({}, all), { [current]: data[current] });
+        }
+    }, {});
+};
+const getFirstCustomMeasurementProtocolKeyMatch = (key) => {
+    let matchedKey = undefined;
+    [...isCustomCommerceKey].every((regex) => {
+        var _a;
+        matchedKey = (_a = regex.exec(key)) === null || _a === void 0 ? void 0 : _a[1];
+        return !Boolean(matchedKey);
+    });
+    return matchedKey;
+};
+const convertCustomObject = (prefix, customData) => {
+    return keysOf(customData).reduce((allCustom, currentCustomKey) => (Object.assign(Object.assign({}, allCustom), { [`${prefix}${currentCustomKey}`]: customData[currentCustomKey] })), {});
+};
+
+class AnalyticsBeaconClient {
+    constructor(opts) {
+        this.opts = opts;
+    }
+    sendEvent(eventType, originalPayload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isAvailable()) {
+                throw new Error(`navigator.sendBeacon is not supported in this browser. Consider adding a polyfill like "sendbeacon-polyfill".`);
+            }
+            const { baseUrl, preprocessRequest } = this.opts;
+            const paramsFragments = yield this.getQueryParamsForEventType(eventType);
+            const { url, payload } = yield this.preProcessRequestAsPotentialJSONString(`${baseUrl}/analytics/${eventType}?${paramsFragments}`, originalPayload, preprocessRequest);
+            const parsedRequestData = this.encodeForEventType(eventType, payload);
+            const body = new Blob([parsedRequestData], {
+                type: 'application/x-www-form-urlencoded',
+            });
+            navigator.sendBeacon(url, body);
+            return;
+        });
+    }
+    isAvailable() {
+        return 'sendBeacon' in navigator;
+    }
+    deleteHttpCookieVisitorId() {
+        return Promise.resolve();
+    }
+    preProcessRequestAsPotentialJSONString(originalURL, originalPayload, preprocessRequest) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let returnedUrl = originalURL;
+            let returnedPayload = originalPayload;
+            if (preprocessRequest) {
+                const processedRequest = yield preprocessRequest({ url: originalURL, body: JSON.stringify(originalPayload) }, 'analyticsBeacon');
+                const { url: processedURL, body: processedBody } = processedRequest;
+                returnedUrl = processedURL || originalURL;
+                try {
+                    returnedPayload = JSON.parse(processedBody);
+                }
+                catch (e) {
+                    console.error('Unable to process the request body as a JSON string', e);
+                }
+            }
+            return {
+                payload: returnedPayload,
+                url: returnedUrl,
+            };
+        });
+    }
+    encodeForEventType(eventType, payload) {
+        return this.isEventTypeLegacy(eventType)
+            ? this.encodeForLegacyType(eventType, payload)
+            : this.encodeForFormUrlEncoded(Object.assign({ access_token: this.opts.token }, payload));
+    }
+    getQueryParamsForEventType(eventType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { token, visitorIdProvider } = this.opts;
+            const visitorId = yield visitorIdProvider.getCurrentVisitorId();
+            return [
+                token && this.isEventTypeLegacy(eventType) ? `access_token=${token}` : '',
+                visitorId ? `visitorId=${visitorId}` : '',
+                'discardVisitInfo=true',
+            ]
+                .filter((p) => !!p)
+                .join('&');
+        });
+    }
+    isEventTypeLegacy(eventType) {
+        return [EventType.click, EventType.custom, EventType.search, EventType.view].indexOf(eventType) !== -1;
+    }
+    encodeForLegacyType(eventType, payload) {
+        return `${eventType}Event=${encodeURIComponent(JSON.stringify(payload))}`;
+    }
+    encodeForFormUrlEncoded(payload) {
+        return Object.keys(payload)
+            .filter((key) => !!payload[key])
+            .map((key) => `${encodeURIComponent(key)}=${encodeURIComponent(this.encodeValue(payload[key]))}`)
+            .join('&');
+    }
+    encodeValue(value) {
+        return typeof value === 'number' || typeof value === 'string' || typeof value === 'boolean'
+            ? value
+            : JSON.stringify(value);
+    }
+}
+
+class NoopAnalyticsClient {
+    sendEvent(_, __) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Promise.resolve();
+        });
+    }
+    deleteHttpCookieVisitorId() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Promise.resolve();
+        });
+    }
+}
+
+const fetch$1 = window.fetch;
+
+class AnalyticsFetchClient {
+    constructor(opts) {
+        this.opts = opts;
+    }
+    sendEvent(eventType, payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { baseUrl, visitorIdProvider, preprocessRequest } = this.opts;
+            const visitorIdParam = this.shouldAppendVisitorId(eventType) ? yield this.getVisitorIdParam() : '';
+            const defaultOptions = {
+                url: `${baseUrl}/analytics/${eventType}${visitorIdParam}`,
+                credentials: 'include',
+                mode: 'cors',
+                headers: this.getHeaders(),
+                method: 'POST',
+                body: JSON.stringify(payload),
+            };
+            const _a = Object.assign(Object.assign({}, defaultOptions), (preprocessRequest ? yield preprocessRequest(defaultOptions, 'analyticsFetch') : {})), { url } = _a, fetchData = __rest(_a, ["url"]);
+            const response = yield fetch$1(url, fetchData);
+            if (response.ok) {
+                const visit = (yield response.json());
+                if (visit.visitorId) {
+                    visitorIdProvider.setCurrentVisitorId(visit.visitorId);
+                }
+                return visit;
+            }
+            else {
+                try {
+                    response.json();
+                }
+                catch (_b) {
+                }
+                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.`);
+            }
+        });
+    }
+    deleteHttpCookieVisitorId() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { baseUrl } = this.opts;
+            const url = `${baseUrl}/analytics/visit`;
+            yield fetch$1(url, { headers: this.getHeaders(), method: 'DELETE' });
+        });
+    }
+    shouldAppendVisitorId(eventType) {
+        return [EventType.click, EventType.custom, EventType.search, EventType.view].indexOf(eventType) !== -1;
+    }
+    getVisitorIdParam() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { visitorIdProvider } = this.opts;
+            const visitorId = yield visitorIdProvider.getCurrentVisitorId();
+            return visitorId ? `?visitor=${visitorId}` : '';
+        });
+    }
+    getHeaders() {
+        const { token } = this.opts;
+        return Object.assign(Object.assign({}, (token ? { Authorization: `Bearer ${token}` } : {})), { 'Content-Type': `application/json` });
+    }
+}
+
+class BrowserRuntime {
+    constructor(clientOptions, getUnprocessedRequests) {
+        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', () => {
+            const requests = getUnprocessedRequests();
+            for (let { eventType, payload } of requests) {
+                this.beaconClient.sendEvent(eventType, payload);
+            }
+        });
+    }
+    getClientDependingOnEventType(eventType) {
+        return eventType === 'click' && this.beaconClient.isAvailable() ? this.beaconClient : this.client;
+    }
+}
+class NodeJSRuntime {
+    constructor(clientOptions, storage) {
+        this.storage = storage || new NullStorage();
+        this.client = new AnalyticsFetchClient(clientOptions);
+    }
+    getClientDependingOnEventType(eventType) {
+        return this.client;
+    }
+}
+class NoopRuntime {
+    constructor() {
+        this.storage = new NullStorage();
+        this.client = new NoopAnalyticsClient();
+    }
+    getClientDependingOnEventType(eventType) {
+        return this.client;
+    }
+}
+
+const API_KEY_PREFIX = 'xx';
+const isApiKey = (token) => (token === null || token === void 0 ? void 0 : token.startsWith(API_KEY_PREFIX)) || false;
+
+const ReactNativeRuntimeWarning = `
+        We've detected you're using React Native but have not provided the corresponding runtime, 
+        for an optimal experience please use the "coveo.analytics/react-native" subpackage.
+        Follow the Readme on how to set it up: https://github.com/coveo/coveo.analytics.js#using-react-native
+    `;
+function isReactNative() {
+    return typeof navigator != 'undefined' && navigator.product == 'ReactNative';
+}
+
+const doNotTrackValues = ['1', 1, 'yes', true];
+function doNotTrack() {
+    return (hasNavigator() &&
+        [
+            navigator.globalPrivacyControl,
+            navigator.doNotTrack,
+            navigator.msDoNotTrack,
+            window.doNotTrack,
+        ].some((value) => doNotTrackValues.indexOf(value) !== -1));
+}
+
+const Version = 'v15';
+const 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 = Endpoints.default, apiVersion = Version, isCustomEndpoint = false) {
+    endpoint = endpoint.replace(/\/$/, '');
+    if (isCustomEndpoint) {
+        return `${endpoint}/${apiVersion}`;
+    }
+    const hasUARestEndpoint = endpoint.endsWith('/rest') || endpoint.endsWith('/rest/ua');
+    return `${endpoint}${hasUARestEndpoint ? '' : '/rest'}/${apiVersion}`;
+}
+const COVEO_NAMESPACE = '38824e1f-37f5-42d3-8372-a4b8fa9df946';
+class CoveoAnalyticsClient {
+    get defaultOptions() {
+        return {
+            endpoint: Endpoints.default,
+            isCustomEndpoint: false,
+            token: '',
+            version: Version,
+            beforeSendHooks: [],
+            afterSendHooks: [],
+        };
+    }
+    get version() {
+        return libVersion;
+    }
+    constructor(opts) {
+        this.acceptedLinkReferrers = [];
+        if (!opts) {
+            throw new Error('You have to pass options to this constructor');
+        }
+        this.options = Object.assign(Object.assign({}, this.defaultOptions), opts);
+        this.visitorId = '';
+        this.bufferedRequests = [];
+        this.beforeSendHooks = [enhanceViewEvent, addDefaultValues].concat(this.options.beforeSendHooks);
+        this.afterSendHooks = this.options.afterSendHooks;
+        this.eventTypeMapping = {};
+        const 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();
+        }
+    }
+    initRuntime(clientsOptions) {
+        if (hasWindow() && hasDocument()) {
+            return new BrowserRuntime(clientsOptions, () => {
+                const copy = [...this.bufferedRequests];
+                this.bufferedRequests = [];
+                return copy;
+            });
+        }
+        else if (isReactNative()) {
+            console.warn(ReactNativeRuntimeWarning);
+        }
+        return new NodeJSRuntime(clientsOptions);
+    }
+    get storage() {
+        return this.runtime.storage;
+    }
+    determineVisitorId() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return (this.extractClientIdFromLink(window.location.href) ||
+                    (yield this.storage.getItem('visitorId')) ||
+                    v4());
+            }
+            catch (err) {
+                console.log('Could not get visitor ID from the current runtime environment storage. Using a random ID instead.', err);
+                return v4();
+            }
+        });
+    }
+    getCurrentVisitorId() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.visitorId) {
+                const id = yield this.determineVisitorId();
+                yield this.setCurrentVisitorId(id);
+            }
+            return this.visitorId;
+        });
+    }
+    setCurrentVisitorId(visitorId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.visitorId = visitorId;
+            yield this.storage.setItem('visitorId', visitorId);
+        });
+    }
+    setClientId(value, namespace) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (validate(value)) {
+                this.setCurrentVisitorId(value.toLowerCase());
+            }
+            else {
+                if (!namespace) {
+                    throw Error('Cannot generate uuid client id without a specific namespace string.');
+                }
+                this.setCurrentVisitorId(uuidv5(value, uuidv5(namespace, COVEO_NAMESPACE)));
+            }
+        });
+    }
+    getParameters(eventType, ...payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.resolveParameters(eventType, ...payload);
+        });
+    }
+    getPayload(eventType, ...payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const parametersToSend = yield this.resolveParameters(eventType, ...payload);
+            return yield this.resolvePayloadForParameters(eventType, parametersToSend);
+        });
+    }
+    get currentVisitorId() {
+        const visitorId = this.visitorId || this.storage.getItem('visitorId');
+        if (typeof visitorId !== 'string') {
+            this.setCurrentVisitorId(v4());
+        }
+        return this.visitorId;
+    }
+    set currentVisitorId(visitorId) {
+        this.visitorId = visitorId;
+        this.storage.setItem('visitorId', visitorId);
+    }
+    extractClientIdFromLink(urlString) {
+        if (doNotTrack()) {
+            return null;
+        }
+        try {
+            const linkParam = new URL(urlString).searchParams.get(CoveoLinkParam.cvo_cid);
+            if (linkParam == null) {
+                return null;
+            }
+            const linker = CoveoLinkParam.fromString(linkParam);
+            if (!linker || !hasDocument() || !linker.validate(document.referrer, this.acceptedLinkReferrers)) {
+                return null;
+            }
+            return linker.clientId;
+        }
+        catch (error) {
+        }
+        return null;
+    }
+    resolveParameters(eventType, ...payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { variableLengthArgumentsNames = [], addVisitorIdParameter = false, usesMeasurementProtocol = false, addClientIdParameter = false, } = this.eventTypeMapping[eventType] || {};
+            const processVariableArgumentNamesStep = (currentPayload) => variableLengthArgumentsNames.length > 0
+                ? this.parseVariableArgumentsPayload(variableLengthArgumentsNames, currentPayload)
+                : currentPayload[0];
+            const addVisitorIdStep = (currentPayload) => __awaiter(this, void 0, void 0, function* () {
+                return (Object.assign(Object.assign({}, currentPayload), { visitorId: addVisitorIdParameter ? yield this.getCurrentVisitorId() : '' }));
+            });
+            const addClientIdStep = (currentPayload) => __awaiter(this, void 0, void 0, function* () {
+                if (addClientIdParameter) {
+                    return Object.assign(Object.assign({}, currentPayload), { clientId: yield this.getCurrentVisitorId() });
+                }
+                return currentPayload;
+            });
+            const setAnonymousUserStep = (currentPayload) => usesMeasurementProtocol ? this.ensureAnonymousUserWhenUsingApiKey(currentPayload) : currentPayload;
+            const processBeforeSendHooksStep = (currentPayload) => this.beforeSendHooks.reduce((promisePayload, current) => __awaiter(this, void 0, void 0, function* () {
+                const payload = yield promisePayload;
+                return yield current(eventType, payload);
+            }), currentPayload);
+            const parametersToSend = yield [
+                processVariableArgumentNamesStep,
+                addVisitorIdStep,
+                addClientIdStep,
+                setAnonymousUserStep,
+                processBeforeSendHooksStep,
+            ].reduce((payloadPromise, step) => __awaiter(this, void 0, void 0, function* () {
+                const payload = yield payloadPromise;
+                return yield step(payload);
+            }), Promise.resolve(payload));
+            return parametersToSend;
+        });
+    }
+    resolvePayloadForParameters(eventType, parameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { usesMeasurementProtocol = false } = this.eventTypeMapping[eventType] || {};
+            const addTrackingIdStep = (currentPayload) => this.setTrackingIdIfTrackingIdNotPresent(currentPayload);
+            const cleanPayloadStep = (currentPayload) => this.removeEmptyPayloadValues(currentPayload, eventType);
+            const validateParams = (currentPayload) => this.validateParams(currentPayload, eventType);
+            const processMeasurementProtocolConversionStep = (currentPayload) => usesMeasurementProtocol ? convertKeysToMeasurementProtocol(currentPayload) : currentPayload;
+            const removeUnknownParameters = (currentPayload) => usesMeasurementProtocol ? this.removeUnknownParameters(currentPayload) : currentPayload;
+            const processCustomParameters = (currentPayload) => usesMeasurementProtocol
+                ? this.processCustomParameters(currentPayload)
+                : this.mapCustomParametersToCustomData(currentPayload);
+            const payloadToSend = yield [
+                addTrackingIdStep,
+                cleanPayloadStep,
+                validateParams,
+                processMeasurementProtocolConversionStep,
+                removeUnknownParameters,
+                processCustomParameters,
+            ].reduce((payloadPromise, step) => __awaiter(this, void 0, void 0, function* () {
+                const payload = yield payloadPromise;
+                return yield step(payload);
+            }), Promise.resolve(parameters));
+            return payloadToSend;
+        });
+    }
+    makeEvent(eventType, ...payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { newEventType: eventTypeToSend = eventType } = this.eventTypeMapping[eventType] || {};
+            const parametersToSend = yield this.resolveParameters(eventType, ...payload);
+            const payloadToSend = yield this.resolvePayloadForParameters(eventType, parametersToSend);
+            return {
+                eventType: eventTypeToSend,
+                payload: payloadToSend,
+                log: (remainingPayload) => __awaiter(this, void 0, void 0, function* () {
+                    this.bufferedRequests.push({
+                        eventType: eventTypeToSend,
+                        payload: Object.assign(Object.assign({}, payloadToSend), remainingPayload),
+                    });
+                    yield Promise.all(this.afterSendHooks.map((hook) => hook(eventType, Object.assign(Object.assign({}, parametersToSend), remainingPayload))));
+                    yield this.deferExecution();
+                    return (yield this.sendFromBuffer());
+                }),
+            };
+        });
+    }
+    sendEvent(eventType, ...payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeEvent(eventType, ...payload)).log({});
+        });
+    }
+    deferExecution() {
+        return new Promise((resolve) => setTimeout(resolve, 0));
+    }
+    sendFromBuffer() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const popped = this.bufferedRequests.shift();
+            if (popped) {
+                const { eventType, payload } = popped;
+                return this.runtime.getClientDependingOnEventType(eventType).sendEvent(eventType, payload);
+            }
+        });
+    }
+    clear() {
+        this.storage.removeItem('visitorId');
+        const store = new HistoryStore();
+        store.clear();
+    }
+    deleteHttpOnlyVisitorId() {
+        this.runtime.client.deleteHttpCookieVisitorId();
+    }
+    makeSearchEvent(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.makeEvent(EventType.search, request);
+        });
+    }
+    sendSearchEvent(_a) {
+        var { searchQueryUid } = _a, preparedRequest = __rest(_a, ["searchQueryUid"]);
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeSearchEvent(preparedRequest)).log({ searchQueryUid });
+        });
+    }
+    makeClickEvent(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.makeEvent(EventType.click, request);
+        });
+    }
+    sendClickEvent(_a) {
+        var { searchQueryUid } = _a, preparedRequest = __rest(_a, ["searchQueryUid"]);
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeClickEvent(preparedRequest)).log({ searchQueryUid });
+        });
+    }
+    makeCustomEvent(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.makeEvent(EventType.custom, request);
+        });
+    }
+    sendCustomEvent(_a) {
+        var { lastSearchQueryUid } = _a, preparedRequest = __rest(_a, ["lastSearchQueryUid"]);
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeCustomEvent(preparedRequest)).log({ lastSearchQueryUid });
+        });
+    }
+    makeViewEvent(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.makeEvent(EventType.view, request);
+        });
+    }
+    sendViewEvent(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeViewEvent(request)).log({});
+        });
+    }
+    getVisit() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield fetch(`${this.baseUrl}/analytics/visit`);
+            const visit = (yield response.json());
+            this.visitorId = visit.visitorId;
+            return visit;
+        });
+    }
+    getHealth() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield fetch(`${this.baseUrl}/analytics/monitoring/health`);
+            return (yield response.json());
+        });
+    }
+    registerBeforeSendEventHook(hook) {
+        this.beforeSendHooks.push(hook);
+    }
+    registerAfterSendEventHook(hook) {
+        this.afterSendHooks.push(hook);
+    }
+    addEventTypeMapping(eventType, eventConfig) {
+        this.eventTypeMapping[eventType] = eventConfig;
+    }
+    setAcceptedLinkReferrers(hosts) {
+        if (Array.isArray(hosts) && hosts.every((host) => typeof host == 'string'))
+            this.acceptedLinkReferrers = hosts;
+        else
+            throw Error('Parameter should be an array of domain strings');
+    }
+    parseVariableArgumentsPayload(fieldsOrder, payload) {
+        const parsedArguments = {};
+        for (let i = 0, length = payload.length; i < length; i++) {
+            const currentArgument = payload[i];
+            if (typeof currentArgument === 'string') {
+                parsedArguments[fieldsOrder[i]] = currentArgument;
+            }
+            else if (typeof currentArgument === 'object') {
+                return Object.assign(Object.assign({}, parsedArguments), currentArgument);
+            }
+        }
+        return parsedArguments;
+    }
+    isKeyAllowedEmpty(evtType, key) {
+        const keysThatCanBeEmpty = {
+            [EventType.search]: ['queryText'],
+        };
+        const match = keysThatCanBeEmpty[evtType] || [];
+        return match.indexOf(key) !== -1;
+    }
+    removeEmptyPayloadValues(payload, eventType) {
+        const isNotEmptyValue = (value) => typeof value !== 'undefined' && value !== null && value !== '';
+        return Object.keys(payload)
+            .filter((key) => this.isKeyAllowedEmpty(eventType, key) || isNotEmptyValue(payload[key]))
+            .reduce((newPayload, key) => (Object.assign(Object.assign({}, newPayload), { [key]: payload[key] })), {});
+    }
+    removeUnknownParameters(payload) {
+        const newPayload = Object.keys(payload)
+            .filter((key) => {
+            if (isMeasurementProtocolKey(key)) {
+                return true;
+            }
+            else {
+                console.log(key, 'is not processed by coveoua');
+            }
+        })
+            .reduce((newPayload, key) => (Object.assign(Object.assign({}, newPayload), { [key]: payload[key] })), {});
+        return newPayload;
+    }
+    processCustomParameters(payload) {
+        const { custom } = payload, rest = __rest(payload, ["custom"]);
+        let lowercasedCustom = {};
+        if (custom && isObject(custom)) {
+            lowercasedCustom = this.lowercaseKeys(custom);
+        }
+        const newPayload = convertCustomMeasurementProtocolKeys(rest);
+        return Object.assign(Object.assign({}, lowercasedCustom), newPayload);
+    }
+    mapCustomParametersToCustomData(payload) {
+        const { custom } = payload, rest = __rest(payload, ["custom"]);
+        if (custom && isObject(custom)) {
+            const lowercasedCustom = this.lowercaseKeys(custom);
+            return Object.assign(Object.assign({}, rest), { customData: Object.assign(Object.assign({}, lowercasedCustom), payload.customData) });
+        }
+        else {
+            return payload;
+        }
+    }
+    lowercaseKeys(custom) {
+        const keys = Object.keys(custom);
+        let result = {};
+        keys.forEach((key) => {
+            result[key.toLowerCase()] = custom[key];
+        });
+        return result;
+    }
+    validateParams(payload, eventType) {
+        const { anonymizeIp } = payload, rest = __rest(payload, ["anonymizeIp"]);
+        if (anonymizeIp !== undefined) {
+            if (['0', 'false', 'undefined', 'null', '{}', '[]', ''].indexOf(`${anonymizeIp}`.toLowerCase()) == -1) {
+                rest.anonymizeIp = 1;
+            }
+        }
+        if (eventType == EventType.view ||
+            eventType == EventType.click ||
+            eventType == EventType.search ||
+            eventType == EventType.custom) {
+            rest.originLevel3 = this.limit(rest.originLevel3, 128);
+        }
+        if (eventType == EventType.view) {
+            rest.location = this.limit(rest.location, 128);
+        }
+        if (eventType == 'pageview' || eventType == 'event') {
+            rest.referrer = this.limit(rest.referrer, 2048);
+            rest.location = this.limit(rest.location, 2048);
+            rest.page = this.limit(rest.page, 2048);
+        }
+        return rest;
+    }
+    ensureAnonymousUserWhenUsingApiKey(payload) {
+        const { userId } = payload, rest = __rest(payload, ["userId"]);
+        if (isApiKey(this.options.token) && !userId) {
+            rest['userId'] = 'anonymous';
+            return rest;
+        }
+        else {
+            return payload;
+        }
+    }
+    setTrackingIdIfTrackingIdNotPresent(payload) {
+        const { trackingId } = payload, rest = __rest(payload, ["trackingId"]);
+        if (trackingId) {
+            return payload;
+        }
+        if (rest.hasOwnProperty('custom') && isObject(rest.custom)) {
+            if (rest.custom.hasOwnProperty('context_website') || rest.custom.hasOwnProperty('siteName')) {
+                rest['trackingId'] = rest.custom.context_website || rest.custom.siteName;
+            }
+        }
+        if (rest.hasOwnProperty('customData') && isObject(rest.customData)) {
+            if (rest.customData.hasOwnProperty('context_website') || rest.customData.hasOwnProperty('siteName')) {
+                rest['trackingId'] = rest.customData.context_website || rest.customData.siteName;
+            }
+        }
+        return rest;
+    }
+    limit(input, length) {
+        if (typeof input !== 'string') {
+            return input;
+        }
+        return input.substring(0, length);
+    }
+    get baseUrl() {
+        return buildBaseUrl(this.options.endpoint, this.options.version, this.options.isCustomEndpoint);
+    }
+}
+
+var InsightEvents;
+(function (InsightEvents) {
+    InsightEvents["contextChanged"] = "contextChanged";
+    InsightEvents["expandToFullUI"] = "expandToFullUI";
+    InsightEvents["openUserActions"] = "openUserActions";
+    InsightEvents["showPrecedingSessions"] = "showPrecedingSessions";
+    InsightEvents["showFollowingSessions"] = "showFollowingSessions";
+    InsightEvents["clickViewedDocument"] = "clickViewedDocument";
+    InsightEvents["clickPageView"] = "clickPageView";
+})(InsightEvents || (InsightEvents = {}));
+
+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["caseSendEmail"] = "Case.SendEmail";
+    SearchPageEvents["feedItemTextPost"] = "FeedItem.TextPost";
+    SearchPageEvents["caseAttach"] = "caseAttach";
+    SearchPageEvents["caseDetach"] = "caseDetach";
+    SearchPageEvents["retryGeneratedAnswer"] = "retryGeneratedAnswer";
+    SearchPageEvents["likeGeneratedAnswer"] = "likeGeneratedAnswer";
+    SearchPageEvents["dislikeGeneratedAnswer"] = "dislikeGeneratedAnswer";
+    SearchPageEvents["openGeneratedAnswerSource"] = "openGeneratedAnswerSource";
+    SearchPageEvents["generatedAnswerStreamEnd"] = "generatedAnswerStreamEnd";
+})(SearchPageEvents || (SearchPageEvents = {}));
+const CustomEventsTypes = {
+    [SearchPageEvents.triggerNotify]: 'queryPipelineTriggers',
+    [SearchPageEvents.triggerExecute]: 'queryPipelineTriggers',
+    [SearchPageEvents.triggerQuery]: 'queryPipelineTriggers',
+    [SearchPageEvents.triggerRedirect]: 'queryPipelineTriggers',
+    [SearchPageEvents.queryError]: 'errors',
+    [SearchPageEvents.queryErrorBack]: 'errors',
+    [SearchPageEvents.queryErrorClear]: 'errors',
+    [SearchPageEvents.queryErrorRetry]: 'errors',
+    [SearchPageEvents.pagerNext]: 'getMoreResults',
+    [SearchPageEvents.pagerPrevious]: 'getMoreResults',
+    [SearchPageEvents.pagerNumber]: 'getMoreResults',
+    [SearchPageEvents.pagerResize]: 'getMoreResults',
+    [SearchPageEvents.pagerScrolling]: 'getMoreResults',
+    [SearchPageEvents.facetSearch]: 'facet',
+    [SearchPageEvents.facetShowLess]: 'facet',
+    [SearchPageEvents.facetShowMore]: 'facet',
+    [SearchPageEvents.recommendation]: 'recommendation',
+    [SearchPageEvents.likeSmartSnippet]: 'smartSnippet',
+    [SearchPageEvents.dislikeSmartSnippet]: 'smartSnippet',
+    [SearchPageEvents.expandSmartSnippet]: 'smartSnippet',
+    [SearchPageEvents.collapseSmartSnippet]: 'smartSnippet',
+    [SearchPageEvents.openSmartSnippetFeedbackModal]: 'smartSnippet',
+    [SearchPageEvents.closeSmartSnippetFeedbackModal]: 'smartSnippet',
+    [SearchPageEvents.sendSmartSnippetReason]: 'smartSnippet',
+    [SearchPageEvents.expandSmartSnippetSuggestion]: 'smartSnippetSuggestions',
+    [SearchPageEvents.collapseSmartSnippetSuggestion]: 'smartSnippetSuggestions',
+    [SearchPageEvents.showMoreSmartSnippetSuggestion]: 'smartSnippetSuggestions',
+    [SearchPageEvents.showLessSmartSnippetSuggestion]: 'smartSnippetSuggestions',
+    [SearchPageEvents.clearRecentQueries]: 'recentQueries',
+    [SearchPageEvents.recentResultClick]: 'recentlyClickedDocuments',
+    [SearchPageEvents.clearRecentResults]: 'recentlyClickedDocuments',
+    [SearchPageEvents.showLessFoldedResults]: 'folding',
+    [InsightEvents.expandToFullUI]: 'interface',
+    [InsightEvents.openUserActions]: 'User Actions',
+    [InsightEvents.showPrecedingSessions]: 'User Actions',
+    [InsightEvents.showFollowingSessions]: 'User Actions',
+    [InsightEvents.clickViewedDocument]: 'User Actions',
+    [InsightEvents.clickPageView]: 'User Actions',
+    [SearchPageEvents.caseDetach]: 'case',
+    [SearchPageEvents.likeGeneratedAnswer]: 'generatedAnswer',
+    [SearchPageEvents.dislikeGeneratedAnswer]: 'generatedAnswer',
+    [SearchPageEvents.openGeneratedAnswerSource]: 'generatedAnswer',
+    [SearchPageEvents.generatedAnswerStreamEnd]: 'generatedAnswer',
+};
+
+class NoopAnalytics {
+    constructor() {
+        this.runtime = new NoopRuntime();
+        this.currentVisitorId = '';
+    }
+    getPayload() {
+        return Promise.resolve();
+    }
+    getParameters() {
+        return Promise.resolve();
+    }
+    makeEvent(eventType) {
+        return Promise.resolve({ eventType: eventType, payload: null, log: () => Promise.resolve() });
+    }
+    sendEvent() {
+        return Promise.resolve();
+    }
+    makeSearchEvent() {
+        return this.makeEvent(EventType.search);
+    }
+    sendSearchEvent() {
+        return Promise.resolve();
+    }
+    makeClickEvent() {
+        return this.makeEvent(EventType.click);
+    }
+    sendClickEvent() {
+        return Promise.resolve();
+    }
+    makeCustomEvent() {
+        return this.makeEvent(EventType.custom);
+    }
+    sendCustomEvent() {
+        return Promise.resolve();
+    }
+    makeViewEvent() {
+        return this.makeEvent(EventType.view);
+    }
+    sendViewEvent() {
+        return Promise.resolve();
+    }
+    getVisit() {
+        return Promise.resolve({ id: '', visitorId: '' });
+    }
+    getHealth() {
+        return Promise.resolve({ status: '' });
+    }
+    registerBeforeSendEventHook() { }
+    registerAfterSendEventHook() { }
+    addEventTypeMapping() { }
+    get version() {
+        return libVersion;
+    }
+}
+
+function filterConsecutiveRepeatedValues(rawData) {
+    let prev = '';
+    return rawData.filter((value) => {
+        const isDifferent = value !== prev;
+        prev = value;
+        return isDifferent;
+    });
+}
+function removeSemicolons(rawData) {
+    return rawData.map((value) => {
+        return value.replace(/;/g, '');
+    });
+}
+function getDataString(data) {
+    const ANALYTICS_LENGTH_LIMIT = 256;
+    const formattedData = data.join(';');
+    if (formattedData.length <= ANALYTICS_LENGTH_LIMIT) {
+        return formattedData;
+    }
+    return getDataString(data.slice(1));
+}
+const formatArrayForCoveoCustomData = (rawData) => {
+    const dataWithoutSemicolons = removeSemicolons(rawData);
+    const dataWithoutRepeatedValues = filterConsecutiveRepeatedValues(dataWithoutSemicolons);
+    return getDataString(dataWithoutRepeatedValues);
+};
+
+function formatOmniboxMetadata(meta) {
+    const partialQueries = typeof meta.partialQueries === 'string'
+        ? meta.partialQueries
+        : formatArrayForCoveoCustomData(meta.partialQueries);
+    const suggestions = typeof meta.suggestions === 'string' ? meta.suggestions : formatArrayForCoveoCustomData(meta.suggestions);
+    return Object.assign(Object.assign({}, meta), { partialQueries,
+        suggestions });
+}
+
+class CoveoSearchPageClient {
+    constructor(opts, provider) {
+        this.opts = opts;
+        this.provider = provider;
+        const shouldDisableAnalytics = opts.enableAnalytics === false || doNotTrack();
+        this.coveoAnalyticsClient = shouldDisableAnalytics ? new NoopAnalytics() : new CoveoAnalyticsClient(opts);
+    }
+    disable() {
+        if (this.coveoAnalyticsClient instanceof CoveoAnalyticsClient) {
+            this.coveoAnalyticsClient.clear();
+        }
+        this.coveoAnalyticsClient = new NoopAnalytics();
+    }
+    enable() {
+        this.coveoAnalyticsClient = new CoveoAnalyticsClient(this.opts);
+    }
+    makeInterfaceLoad() {
+        return this.makeSearchEvent(SearchPageEvents.interfaceLoad);
+    }
+    logInterfaceLoad() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeInterfaceLoad()).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeRecommendationInterfaceLoad() {
+        return this.makeSearchEvent(SearchPageEvents.recommendationInterfaceLoad);
+    }
+    logRecommendationInterfaceLoad() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeRecommendationInterfaceLoad()).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeRecommendation() {
+        return this.makeCustomEvent(SearchPageEvents.recommendation);
+    }
+    logRecommendation() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeRecommendation()).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeRecommendationOpen(info, identifier) {
+        return this.makeClickEvent(SearchPageEvents.recommendationOpen, info, identifier);
+    }
+    logRecommendationOpen(info, identifier) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeRecommendationOpen(info, identifier)).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeStaticFilterClearAll(meta) {
+        return this.makeSearchEvent(SearchPageEvents.staticFilterClearAll, meta);
+    }
+    logStaticFilterClearAll(meta) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeStaticFilterClearAll(meta)).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeStaticFilterSelect(meta) {
+        return this.makeSearchEvent(SearchPageEvents.staticFilterSelect, meta);
+    }
+    logStaticFilterSelect(meta) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeStaticFilterSelect(meta)).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeStaticFilterDeselect(meta) {
+        return this.makeSearchEvent(SearchPageEvents.staticFilterDeselect, meta);
+    }
+    logStaticFilterDeselect(meta) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeStaticFilterDeselect(meta)).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeFetchMoreResults() {
+        return this.makeCustomEvent(SearchPageEvents.pagerScrolling, { type: 'getMoreResults' });
+    }
+    logFetchMoreResults() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeFetchMoreResults()).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeInterfaceChange(metadata) {
+        return this.makeSearchEvent(SearchPageEvents.interfaceChange, metadata);
+    }
+    logInterfaceChange(metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeInterfaceChange(metadata)).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeDidYouMeanAutomatic() {
+        return this.makeSearchEvent(SearchPageEvents.didyoumeanAutomatic);
+    }
+    logDidYouMeanAutomatic() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeDidYouMeanAutomatic()).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeDidYouMeanClick() {
+        return this.makeSearchEvent(SearchPageEvents.didyoumeanClick);
+    }
+    logDidYouMeanClick() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeDidYouMeanClick()).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeResultsSort(metadata) {
+        return this.makeSearchEvent(SearchPageEvents.resultsSort, metadata);
+    }
+    logResultsSort(metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeResultsSort(metadata)).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeSearchboxSubmit() {
+        return this.makeSearchEvent(SearchPageEvents.searchboxSubmit);
+    }
+    logSearchboxSubmit() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeSearchboxSubmit()).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeSearchboxClear() {
+        return this.makeSearchEvent(SearchPageEvents.searchboxClear);
+    }
+    logSearchboxClear() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeSearchboxClear()).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeSearchboxAsYouType() {
+        return this.makeSearchEvent(SearchPageEvents.searchboxAsYouType);
+    }
+    logSearchboxAsYouType() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeSearchboxAsYouType()).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeBreadcrumbFacet(metadata) {
+        return this.makeSearchEvent(SearchPageEvents.breadcrumbFacet, metadata);
+    }
+    logBreadcrumbFacet(metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeBreadcrumbFacet(metadata)).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeBreadcrumbResetAll() {
+        return this.makeSearchEvent(SearchPageEvents.breadcrumbResetAll);
+    }
+    logBreadcrumbResetAll() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeBreadcrumbResetAll()).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeDocumentQuickview(info, identifier) {
+        return this.makeClickEvent(SearchPageEvents.documentQuickview, info, identifier);
+    }
+    logDocumentQuickview(info, identifier) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeDocumentQuickview(info, identifier)).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeDocumentOpen(info, identifier) {
+        return this.makeClickEvent(SearchPageEvents.documentOpen, info, identifier);
+    }
+    logDocumentOpen(info, identifier) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeDocumentOpen(info, identifier)).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeOmniboxAnalytics(meta) {
+        return this.makeSearchEvent(SearchPageEvents.omniboxAnalytics, formatOmniboxMetadata(meta));
+    }
+    logOmniboxAnalytics(meta) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeOmniboxAnalytics(meta)).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeOmniboxFromLink(meta) {
+        return this.makeSearchEvent(SearchPageEvents.omniboxFromLink, formatOmniboxMetadata(meta));
+    }
+    logOmniboxFromLink(meta) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeOmniboxFromLink(meta)).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeSearchFromLink() {
+        return this.makeSearchEvent(SearchPageEvents.searchFromLink);
+    }
+    logSearchFromLink() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeSearchFromLink()).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeTriggerNotify(meta) {
+        return this.makeCustomEvent(SearchPageEvents.triggerNotify, meta);
+    }
+    logTriggerNotify(meta) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeTriggerNotify(meta)).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeTriggerExecute(meta) {
+        return this.makeCustomEvent(SearchPageEvents.triggerExecute, meta);
+    }
+    logTriggerExecute(meta) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeTriggerExecute(meta)).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeTriggerQuery() {
+        return this.makeCustomEvent(SearchPageEvents.triggerQuery, { query: this.provider.getSearchEventRequestPayload().queryText }, 'queryPipelineTriggers');
+    }
+    logTriggerQuery() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeTriggerQuery()).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeUndoTriggerQuery(meta) {
+        return this.makeSearchEvent(SearchPageEvents.undoTriggerQuery, meta);
+    }
+    logUndoTriggerQuery(meta) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeUndoTriggerQuery(meta)).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeTriggerRedirect(meta) {
+        return this.makeCustomEvent(SearchPageEvents.triggerRedirect, Object.assign(Object.assign({}, meta), { query: this.provider.getSearchEventRequestPayload().queryText }));
+    }
+    logTriggerRedirect(meta) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeTriggerRedirect(meta)).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makePagerResize(meta) {
+        return this.makeCustomEvent(SearchPageEvents.pagerResize, meta);
+    }
+    logPagerResize(meta) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makePagerResize(meta)).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makePagerNumber(meta) {
+        return this.makeCustomEvent(SearchPageEvents.pagerNumber, meta);
+    }
+    logPagerNumber(meta) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makePagerNumber(meta)).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makePagerNext(meta) {
+        return this.makeCustomEvent(SearchPageEvents.pagerNext, meta);
+    }
+    logPagerNext(meta) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makePagerNext(meta)).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makePagerPrevious(meta) {
+        return this.makeCustomEvent(SearchPageEvents.pagerPrevious, meta);
+    }
+    logPagerPrevious(meta) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makePagerPrevious(meta)).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makePagerScrolling() {
+        return this.makeCustomEvent(SearchPageEvents.pagerScrolling);
+    }
+    logPagerScrolling() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makePagerScrolling()).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeFacetClearAll(meta) {
+        return this.makeSearchEvent(SearchPageEvents.facetClearAll, meta);
+    }
+    logFacetClearAll(meta) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeFacetClearAll(meta)).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeFacetSearch(meta) {
+        return this.makeSearchEvent(SearchPageEvents.facetSearch, meta);
+    }
+    logFacetSearch(meta) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeFacetSearch(meta)).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeFacetSelect(meta) {
+        return this.makeSearchEvent(SearchPageEvents.facetSelect, meta);
+    }
+    logFacetSelect(meta) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeFacetSelect(meta)).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeFacetDeselect(meta) {
+        return this.makeSearchEvent(SearchPageEvents.facetDeselect, meta);
+    }
+    logFacetDeselect(meta) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeFacetDeselect(meta)).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeFacetExclude(meta) {
+        return this.makeSearchEvent(SearchPageEvents.facetExclude, meta);
+    }
+    logFacetExclude(meta) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeFacetExclude(meta)).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeFacetUnexclude(meta) {
+        return this.makeSearchEvent(SearchPageEvents.facetUnexclude, meta);
+    }
+    logFacetUnexclude(meta) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeFacetUnexclude(meta)).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeFacetSelectAll(meta) {
+        return this.makeSearchEvent(SearchPageEvents.facetSelectAll, meta);
+    }
+    logFacetSelectAll(meta) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeFacetSelectAll(meta)).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeFacetUpdateSort(meta) {
+        return this.makeSearchEvent(SearchPageEvents.facetUpdateSort, meta);
+    }
+    logFacetUpdateSort(meta) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeFacetUpdateSort(meta)).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeFacetShowMore(meta) {
+        return this.makeCustomEvent(SearchPageEvents.facetShowMore, meta);
+    }
+    logFacetShowMore(meta) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeFacetShowMore(meta)).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeFacetShowLess(meta) {
+        return this.makeCustomEvent(SearchPageEvents.facetShowLess, meta);
+    }
+    logFacetShowLess(meta) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeFacetShowLess(meta)).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeQueryError(meta) {
+        return this.makeCustomEvent(SearchPageEvents.queryError, meta);
+    }
+    logQueryError(meta) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeQueryError(meta)).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeQueryErrorBack() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const customEventBuilder = yield this.makeCustomEvent(SearchPageEvents.queryErrorBack);
+            return {
+                description: customEventBuilder.description,
+                log: () => __awaiter(this, void 0, void 0, function* () {
+                    yield customEventBuilder.log({ searchUID: this.provider.getSearchUID() });
+                    return this.logSearchEvent(SearchPageEvents.queryErrorBack);
+                }),
+            };
+        });
+    }
+    logQueryErrorBack() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeQueryErrorBack()).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeQueryErrorRetry() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const customEventBuilder = yield this.makeCustomEvent(SearchPageEvents.queryErrorRetry);
+            return {
+                description: customEventBuilder.description,
+                log: () => __awaiter(this, void 0, void 0, function* () {
+                    yield customEventBuilder.log({ searchUID: this.provider.getSearchUID() });
+                    return this.logSearchEvent(SearchPageEvents.queryErrorRetry);
+                }),
+            };
+        });
+    }
+    logQueryErrorRetry() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeQueryErrorRetry()).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeQueryErrorClear() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const customEventBuilder = yield this.makeCustomEvent(SearchPageEvents.queryErrorClear);
+            return {
+                description: customEventBuilder.description,
+                log: () => __awaiter(this, void 0, void 0, function* () {
+                    yield customEventBuilder.log({ searchUID: this.provider.getSearchUID() });
+                    return this.logSearchEvent(SearchPageEvents.queryErrorClear);
+                }),
+            };
+        });
+    }
+    logQueryErrorClear() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeQueryErrorClear()).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeLikeSmartSnippet() {
+        return this.makeCustomEvent(SearchPageEvents.likeSmartSnippet);
+    }
+    logLikeSmartSnippet() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeLikeSmartSnippet()).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeDislikeSmartSnippet() {
+        return this.makeCustomEvent(SearchPageEvents.dislikeSmartSnippet);
+    }
+    logDislikeSmartSnippet() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeDislikeSmartSnippet()).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeExpandSmartSnippet() {
+        return this.makeCustomEvent(SearchPageEvents.expandSmartSnippet);
+    }
+    logExpandSmartSnippet() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeExpandSmartSnippet()).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeCollapseSmartSnippet() {
+        return this.makeCustomEvent(SearchPageEvents.collapseSmartSnippet);
+    }
+    logCollapseSmartSnippet() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeCollapseSmartSnippet()).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeOpenSmartSnippetFeedbackModal() {
+        return this.makeCustomEvent(SearchPageEvents.openSmartSnippetFeedbackModal);
+    }
+    logOpenSmartSnippetFeedbackModal() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeOpenSmartSnippetFeedbackModal()).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeCloseSmartSnippetFeedbackModal() {
+        return this.makeCustomEvent(SearchPageEvents.closeSmartSnippetFeedbackModal);
+    }
+    logCloseSmartSnippetFeedbackModal() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeCloseSmartSnippetFeedbackModal()).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeSmartSnippetFeedbackReason(reason, details) {
+        return this.makeCustomEvent(SearchPageEvents.sendSmartSnippetReason, { reason, details });
+    }
+    logSmartSnippetFeedbackReason(reason, details) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeSmartSnippetFeedbackReason(reason, details)).log({
+                searchUID: this.provider.getSearchUID(),
+            });
+        });
+    }
+    makeExpandSmartSnippetSuggestion(snippet) {
+        return this.makeCustomEvent(SearchPageEvents.expandSmartSnippetSuggestion, 'documentId' in snippet ? snippet : { documentId: snippet });
+    }
+    logExpandSmartSnippetSuggestion(snippet) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeExpandSmartSnippetSuggestion(snippet)).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeCollapseSmartSnippetSuggestion(snippet) {
+        return this.makeCustomEvent(SearchPageEvents.collapseSmartSnippetSuggestion, 'documentId' in snippet ? snippet : { documentId: snippet });
+    }
+    logCollapseSmartSnippetSuggestion(snippet) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeCollapseSmartSnippetSuggestion(snippet)).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeShowMoreSmartSnippetSuggestion(snippet) {
+        return this.makeCustomEvent(SearchPageEvents.showMoreSmartSnippetSuggestion, snippet);
+    }
+    logShowMoreSmartSnippetSuggestion(snippet) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeShowMoreSmartSnippetSuggestion(snippet)).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeShowLessSmartSnippetSuggestion(snippet) {
+        return this.makeCustomEvent(SearchPageEvents.showLessSmartSnippetSuggestion, snippet);
+    }
+    logShowLessSmartSnippetSuggestion(snippet) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeShowLessSmartSnippetSuggestion(snippet)).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeOpenSmartSnippetSource(info, identifier) {
+        return this.makeClickEvent(SearchPageEvents.openSmartSnippetSource, info, identifier);
+    }
+    logOpenSmartSnippetSource(info, identifier) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeOpenSmartSnippetSource(info, identifier)).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeOpenSmartSnippetSuggestionSource(info, snippet) {
+        return this.makeClickEvent(SearchPageEvents.openSmartSnippetSuggestionSource, info, { contentIDKey: snippet.documentId.contentIdKey, contentIDValue: snippet.documentId.contentIdValue }, snippet);
+    }
+    makeCopyToClipboard(info, identifier) {
+        return this.makeClickEvent(SearchPageEvents.copyToClipboard, info, identifier);
+    }
+    logCopyToClipboard(info, identifier) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeCopyToClipboard(info, identifier)).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    logOpenSmartSnippetSuggestionSource(info, snippet) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeOpenSmartSnippetSuggestionSource(info, snippet)).log({
+                searchUID: this.provider.getSearchUID(),
+            });
+        });
+    }
+    makeOpenSmartSnippetInlineLink(info, identifierAndLink) {
+        return this.makeClickEvent(SearchPageEvents.openSmartSnippetInlineLink, info, { contentIDKey: identifierAndLink.contentIDKey, contentIDValue: identifierAndLink.contentIDValue }, identifierAndLink);
+    }
+    logOpenSmartSnippetInlineLink(info, identifierAndLink) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeOpenSmartSnippetInlineLink(info, identifierAndLink)).log({
+                searchUID: this.provider.getSearchUID(),
+            });
+        });
+    }
+    makeOpenSmartSnippetSuggestionInlineLink(info, snippetAndLink) {
+        return this.makeClickEvent(SearchPageEvents.openSmartSnippetSuggestionInlineLink, info, {
+            contentIDKey: snippetAndLink.documentId.contentIdKey,
+            contentIDValue: snippetAndLink.documentId.contentIdValue,
+        }, snippetAndLink);
+    }
+    logOpenSmartSnippetSuggestionInlineLink(info, snippetAndLink) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeOpenSmartSnippetSuggestionInlineLink(info, snippetAndLink)).log({
+                searchUID: this.provider.getSearchUID(),
+            });
+        });
+    }
+    makeRecentQueryClick() {
+        return this.makeSearchEvent(SearchPageEvents.recentQueryClick);
+    }
+    logRecentQueryClick() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeRecentQueryClick()).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeClearRecentQueries() {
+        return this.makeCustomEvent(SearchPageEvents.clearRecentQueries);
+    }
+    logClearRecentQueries() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeClearRecentQueries()).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeRecentResultClick(info, identifier) {
+        return this.makeCustomEvent(SearchPageEvents.recentResultClick, { info, identifier });
+    }
+    logRecentResultClick(info, identifier) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeRecentResultClick(info, identifier)).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeClearRecentResults() {
+        return this.makeCustomEvent(SearchPageEvents.clearRecentResults);
+    }
+    logClearRecentResults() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeClearRecentResults()).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeNoResultsBack() {
+        return this.makeSearchEvent(SearchPageEvents.noResultsBack);
+    }
+    logNoResultsBack() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeNoResultsBack()).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeShowMoreFoldedResults(info, identifier) {
+        return this.makeClickEvent(SearchPageEvents.showMoreFoldedResults, info, identifier);
+    }
+    logShowMoreFoldedResults(info, identifier) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeShowMoreFoldedResults(info, identifier)).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeShowLessFoldedResults() {
+        return this.makeCustomEvent(SearchPageEvents.showLessFoldedResults);
+    }
+    logShowLessFoldedResults() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeShowLessFoldedResults()).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeEventDescription(preparedEvent, actionCause) {
+        var _a;
+        return { actionCause, customData: (_a = preparedEvent.payload) === null || _a === void 0 ? void 0 : _a.customData };
+    }
+    makeCustomEvent(event, metadata, eventType = CustomEventsTypes[event]) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.coveoAnalyticsClient.getParameters;
+            const customData = Object.assign(Object.assign({}, this.provider.getBaseMetadata()), metadata);
+            const request = Object.assign(Object.assign({}, (yield this.getBaseEventRequest(customData))), { eventType, eventValue: event });
+            const preparedEvent = yield this.coveoAnalyticsClient.makeCustomEvent(request);
+            return {
+                description: this.makeEventDescription(preparedEvent, event),
+                log: ({ searchUID }) => preparedEvent.log({ lastSearchQueryUid: searchUID }),
+            };
+        });
+    }
+    logCustomEvent(event, metadata, eventType = CustomEventsTypes[event]) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeCustomEvent(event, metadata, eventType)).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeCustomEventWithType(eventValue, eventType, metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const customData = Object.assign(Object.assign({}, this.provider.getBaseMetadata()), metadata);
+            const payload = Object.assign(Object.assign({}, (yield this.getBaseEventRequest(customData))), { eventType,
+                eventValue });
+            const preparedEvent = yield this.coveoAnalyticsClient.makeCustomEvent(payload);
+            return {
+                description: this.makeEventDescription(preparedEvent, eventValue),
+                log: ({ searchUID }) => preparedEvent.log({ lastSearchQueryUid: searchUID }),
+            };
+        });
+    }
+    logCustomEventWithType(eventValue, eventType, metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeCustomEventWithType(eventValue, eventType, metadata)).log({
+                searchUID: this.provider.getSearchUID(),
+            });
+        });
+    }
+    logSearchEvent(event, metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeSearchEvent(event, metadata)).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeSearchEvent(event, metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const request = yield this.getBaseSearchEventRequest(event, metadata);
+            const preparedEvent = yield this.coveoAnalyticsClient.makeSearchEvent(request);
+            return {
+                description: this.makeEventDescription(preparedEvent, event),
+                log: ({ searchUID }) => preparedEvent.log({ searchQueryUid: searchUID }),
+            };
+        });
+    }
+    makeClickEvent(event, info, identifier, metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const request = Object.assign(Object.assign(Object.assign({}, info), (yield this.getBaseEventRequest(Object.assign(Object.assign({}, identifier), metadata)))), { queryPipeline: this.provider.getPipeline(), actionCause: event });
+            const preparedEvent = yield this.coveoAnalyticsClient.makeClickEvent(request);
+            return {
+                description: this.makeEventDescription(preparedEvent, event),
+                log: ({ searchUID }) => preparedEvent.log({ searchQueryUid: searchUID }),
+            };
+        });
+    }
+    logClickEvent(event, info, identifier, metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeClickEvent(event, info, identifier, metadata)).log({
+                searchUID: this.provider.getSearchUID(),
+            });
+        });
+    }
+    getBaseSearchEventRequest(event, metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Object.assign(Object.assign(Object.assign({}, (yield this.getBaseEventRequest(metadata))), this.provider.getSearchEventRequestPayload()), { queryPipeline: this.provider.getPipeline(), actionCause: event });
+        });
+    }
+    getBaseEventRequest(metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const customData = Object.assign(Object.assign({}, this.provider.getBaseMetadata()), metadata);
+            return Object.assign(Object.assign(Object.assign({}, this.getOrigins()), this.getSplitTestRun()), { customData, language: this.provider.getLanguage(), facetState: this.provider.getFacetState ? this.provider.getFacetState() : [], anonymous: this.provider.getIsAnonymous(), clientId: yield this.getClientId() });
+        });
+    }
+    getOrigins() {
+        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(),
+        };
+    }
+    getClientId() {
+        return this.coveoAnalyticsClient instanceof CoveoAnalyticsClient
+            ? this.coveoAnalyticsClient.getCurrentVisitorId()
+            : undefined;
+    }
+    getSplitTestRun() {
+        const splitTestRunName = this.provider.getSplitTestRunName ? this.provider.getSplitTestRunName() : '';
+        const splitTestRunVersion = this.provider.getSplitTestRunVersion ? this.provider.getSplitTestRunVersion() : '';
+        return Object.assign(Object.assign({}, (splitTestRunName && { splitTestRunName })), (splitTestRunVersion && { splitTestRunVersion }));
+    }
+    makeLikeGeneratedAnswer(metadata) {
+        return this.makeCustomEvent(SearchPageEvents.likeGeneratedAnswer, metadata);
+    }
+    logLikeGeneratedAnswer(metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeLikeGeneratedAnswer(metadata)).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeDislikeGeneratedAnswer(metadata) {
+        return this.makeCustomEvent(SearchPageEvents.dislikeGeneratedAnswer, metadata);
+    }
+    logDislikeGeneratedAnswer(metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeDislikeGeneratedAnswer(metadata)).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeOpenGeneratedAnswerSource(metadata) {
+        return this.makeCustomEvent(SearchPageEvents.openGeneratedAnswerSource, metadata);
+    }
+    logOpenGeneratedAnswerSource(metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeOpenGeneratedAnswerSource(metadata)).log({
+                searchUID: this.provider.getSearchUID(),
+            });
+        });
+    }
+    makeRetryGeneratedAnswer() {
+        return this.makeSearchEvent(SearchPageEvents.retryGeneratedAnswer);
+    }
+    logRetryGeneratedAnswer() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeRetryGeneratedAnswer()).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+    makeGeneratedAnswerStreamEnd(metadata) {
+        return this.makeCustomEvent(SearchPageEvents.generatedAnswerStreamEnd, metadata);
+    }
+    logGeneratedAnswerStreamEnd(metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.makeGeneratedAnswerStreamEnd(metadata)).log({ searchUID: this.provider.getSearchUID() });
+        });
+    }
+}
+
+const SVCPluginEventTypes = Object.assign({}, BasePluginEventTypes);
+const allSVCEventTypes = Object.keys(SVCPluginEventTypes).map((key) => SVCPluginEventTypes[key]);
+class SVCPlugin extends BasePlugin {
+    constructor({ client, uuidGenerator = v4 }) {
+        super({ client, uuidGenerator });
+        this.ticket = {};
+    }
+    getApi(name) {
+        const superCall = super.getApi(name);
+        if (superCall !== null)
+            return superCall;
+        switch (name) {
+            case 'setTicket':
+                return this.setTicket;
+            default:
+                return null;
+        }
+    }
+    addHooks() {
+        this.addHooksForEvent();
+        this.addHooksForPageView();
+        this.addHooksForSVCEvents();
+    }
+    setTicket(ticket) {
+        this.ticket = ticket;
+    }
+    clearPluginData() {
+        this.ticket = {};
+    }
+    addHooksForSVCEvents() {
+        this.client.registerBeforeSendEventHook((eventType, ...[payload]) => {
+            return allSVCEventTypes.indexOf(eventType) !== -1 ? this.addSVCDataToPayload(eventType, payload) : payload;
+        });
+        this.client.registerAfterSendEventHook((eventType, ...[payload]) => {
+            if (allSVCEventTypes.indexOf(eventType) !== -1) {
+                this.updateLocationInformation(eventType, payload);
+            }
+            return payload;
+        });
+    }
+    addHooksForPageView() {
+        this.client.addEventTypeMapping(SVCPluginEventTypes.pageview, {
+            newEventType: EventType.collect,
+            variableLengthArgumentsNames: ['page'],
+            addVisitorIdParameter: true,
+            usesMeasurementProtocol: true,
+        });
+    }
+    addHooksForEvent() {
+        this.client.addEventTypeMapping(SVCPluginEventTypes.event, {
+            newEventType: EventType.collect,
+            variableLengthArgumentsNames: ['eventCategory', 'eventAction', 'eventLabel', 'eventValue'],
+            addVisitorIdParameter: true,
+            usesMeasurementProtocol: true,
+        });
+    }
+    addSVCDataToPayload(eventType, payload) {
+        var _a;
+        const svcPayload = Object.assign(Object.assign(Object.assign(Object.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 } : {}));
+        const ticketPayload = this.getTicketPayload();
+        this.clearData();
+        return Object.assign(Object.assign(Object.assign({}, ticketPayload), svcPayload), payload);
+    }
+    getTicketPayload() {
+        return convertTicketToMeasurementProtocol(this.ticket);
+    }
+}
+SVCPlugin.Id = 'svc';
+
+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 = {}));
+
+class CaseAssistClient {
+    constructor(options, provider) {
+        var _a;
+        this.options = options;
+        this.provider = provider;
+        const 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 });
+    }
+    disable() {
+        if (this.coveoAnalyticsClient instanceof CoveoAnalyticsClient) {
+            this.coveoAnalyticsClient.clear();
+        }
+        this.coveoAnalyticsClient = new NoopAnalytics();
+        this.svc = new SVCPlugin({ client: this.coveoAnalyticsClient });
+    }
+    enable() {
+        this.coveoAnalyticsClient = new CoveoAnalyticsClient(this.options);
+        this.svc = new SVCPlugin({ client: this.coveoAnalyticsClient });
+    }
+    logEnterInterface(meta) {
+        this.svc.setAction(CaseAssistActions.enterInterface);
+        this.svc.setTicket(meta.ticket);
+        return this.sendFlowStartEvent();
+    }
+    logUpdateCaseField(meta) {
+        this.svc.setAction(CaseAssistActions.fieldUpdate, {
+            fieldName: meta.fieldName,
+        });
+        this.svc.setTicket(meta.ticket);
+        return this.sendClickEvent();
+    }
+    logSelectFieldSuggestion(meta) {
+        this.svc.setAction(CaseAssistActions.fieldSuggestionClick, meta.suggestion);
+        this.svc.setTicket(meta.ticket);
+        return this.sendClickEvent();
+    }
+    logSelectDocumentSuggestion(meta) {
+        this.svc.setAction(CaseAssistActions.suggestionClick, meta.suggestion);
+        this.svc.setTicket(meta.ticket);
+        return this.sendClickEvent();
+    }
+    logRateDocumentSuggestion(meta) {
+        this.svc.setAction(CaseAssistActions.suggestionRate, Object.assign({ rate: meta.rating }, meta.suggestion));
+        this.svc.setTicket(meta.ticket);
+        return this.sendClickEvent();
+    }
+    logMoveToNextCaseStep(meta) {
+        this.svc.setAction(CaseAssistActions.nextCaseStep, {
+            stage: meta === null || meta === void 0 ? void 0 : meta.stage,
+        });
+        this.svc.setTicket(meta.ticket);
+        return this.sendClickEvent();
+    }
+    logCaseCancelled(meta) {
+        this.svc.setAction(CaseAssistActions.caseCancelled, {
+            reason: CaseCancelledReasons.quit,
+        });
+        this.svc.setTicket(meta.ticket);
+        return this.sendClickEvent();
+    }
+    logCaseSolved(meta) {
+        this.svc.setAction(CaseAssistActions.caseSolved, {
+            reason: CaseCancelledReasons.solved,
+        });
+        this.svc.setTicket(meta.ticket);
+        return this.sendClickEvent();
+    }
+    logCaseCreated(meta) {
+        this.svc.setAction(CaseAssistActions.caseCreated);
+        this.svc.setTicket(meta.ticket);
+        return this.sendClickEvent();
+    }
+    sendFlowStartEvent() {
+        return this.coveoAnalyticsClient.sendEvent('event', 'svc', CaseAssistEvents.flowStart, this.provider
+            ? {
+                searchHub: this.provider.getOriginLevel1(),
+            }
+            : null);
+    }
+    sendClickEvent() {
+        return this.coveoAnalyticsClient.sendEvent('event', 'svc', CaseAssistEvents.click, this.provider
+            ? {
+                searchHub: this.provider.getOriginLevel1(),
+            }
+            : null);
+    }
+}
+
+const extractContextFromMetadata = (meta) => {
+    const context = {};
+    if (meta.caseContext) {
+        Object.keys(meta.caseContext).forEach((contextKey) => {
+            var _a;
+            const value = (_a = meta.caseContext) === null || _a === void 0 ? void 0 : _a[contextKey];
+            if (value) {
+                const keyToBeSent = `context_${contextKey}`;
+                context[keyToBeSent] = value;
+            }
+        });
+    }
+    return context;
+};
+const generateMetadataToSend = (metadata, includeContext = true) => {
+    const { caseContext, caseId, caseNumber } = metadata, metadataWithoutContext = __rest(metadata, ["caseContext", "caseId", "caseNumber"]);
+    const context = extractContextFromMetadata(metadata);
+    return Object.assign(Object.assign(Object.assign({ CaseId: caseId, CaseNumber: caseNumber }, metadataWithoutContext), (!!context.context_Case_Subject && { CaseSubject: context.context_Case_Subject })), (includeContext && context));
+};
+class CoveoInsightClient {
+    constructor(opts, provider) {
+        this.opts = opts;
+        this.provider = provider;
+        const shouldDisableAnalytics = opts.enableAnalytics === false || doNotTrack();
+        this.coveoAnalyticsClient = shouldDisableAnalytics ? new NoopAnalytics() : new CoveoAnalyticsClient(opts);
+    }
+    disable() {
+        if (this.coveoAnalyticsClient instanceof CoveoAnalyticsClient) {
+            this.coveoAnalyticsClient.clear();
+        }
+        this.coveoAnalyticsClient = new NoopAnalytics();
+    }
+    enable() {
+        this.coveoAnalyticsClient = new CoveoAnalyticsClient(this.opts);
+    }
+    logInterfaceLoad(metadata) {
+        if (metadata) {
+            const metadataToSend = generateMetadataToSend(metadata);
+            return this.logSearchEvent(SearchPageEvents.interfaceLoad, metadataToSend);
+        }
+        return this.logSearchEvent(SearchPageEvents.interfaceLoad);
+    }
+    logInterfaceChange(metadata) {
+        const metadataToSend = generateMetadataToSend(metadata);
+        return this.logSearchEvent(SearchPageEvents.interfaceChange, metadataToSend);
+    }
+    logStaticFilterDeselect(metadata) {
+        const metadataToSend = generateMetadataToSend(metadata);
+        return this.logSearchEvent(SearchPageEvents.staticFilterDeselect, metadataToSend);
+    }
+    logFetchMoreResults(metadata) {
+        if (metadata) {
+            const metadataToSend = generateMetadataToSend(metadata);
+            return this.logCustomEvent(SearchPageEvents.pagerScrolling, Object.assign(Object.assign({}, metadataToSend), { type: 'getMoreResults' }));
+        }
+        return this.logCustomEvent(SearchPageEvents.pagerScrolling, { type: 'getMoreResults' });
+    }
+    logBreadcrumbFacet(metadata) {
+        const metadataToSend = generateMetadataToSend(metadata);
+        return this.logSearchEvent(SearchPageEvents.breadcrumbFacet, metadataToSend);
+    }
+    logBreadcrumbResetAll(metadata) {
+        if (metadata) {
+            const metadataToSend = generateMetadataToSend(metadata);
+            return this.logSearchEvent(SearchPageEvents.breadcrumbResetAll, metadataToSend);
+        }
+        return this.logSearchEvent(SearchPageEvents.breadcrumbResetAll);
+    }
+    logFacetSelect(metadata) {
+        const metadataToSend = generateMetadataToSend(metadata);
+        return this.logSearchEvent(SearchPageEvents.facetSelect, metadataToSend);
+    }
+    logFacetExclude(metadata) {
+        const metadataToSend = generateMetadataToSend(metadata);
+        return this.logSearchEvent(SearchPageEvents.facetExclude, metadataToSend);
+    }
+    logFacetDeselect(metadata) {
+        const metadataToSend = generateMetadataToSend(metadata);
+        return this.logSearchEvent(SearchPageEvents.facetDeselect, metadataToSend);
+    }
+    logFacetUpdateSort(metadata) {
+        const metadataToSend = generateMetadataToSend(metadata);
+        return this.logSearchEvent(SearchPageEvents.facetUpdateSort, metadataToSend);
+    }
+    logFacetClearAll(metadata) {
+        const metadataToSend = generateMetadataToSend(metadata);
+        return this.logSearchEvent(SearchPageEvents.facetClearAll, metadataToSend);
+    }
+    logFacetShowMore(metadata) {
+        const metadataToSend = generateMetadataToSend(metadata, false);
+        return this.logCustomEvent(SearchPageEvents.facetShowMore, metadataToSend);
+    }
+    logFacetShowLess(metadata) {
+        const metadataToSend = generateMetadataToSend(metadata, false);
+        return this.logCustomEvent(SearchPageEvents.facetShowLess, metadataToSend);
+    }
+    logQueryError(metadata) {
+        const metadataToSend = generateMetadataToSend(metadata, false);
+        return this.logCustomEvent(SearchPageEvents.queryError, metadataToSend);
+    }
+    logPagerNumber(metadata) {
+        const metadataToSend = generateMetadataToSend(metadata, false);
+        return this.logCustomEvent(SearchPageEvents.pagerNumber, metadataToSend);
+    }
+    logPagerNext(metadata) {
+        const metadataToSend = generateMetadataToSend(metadata, false);
+        return this.logCustomEvent(SearchPageEvents.pagerNext, metadataToSend);
+    }
+    logPagerPrevious(metadata) {
+        const metadataToSend = generateMetadataToSend(metadata, false);
+        return this.logCustomEvent(SearchPageEvents.pagerPrevious, metadataToSend);
+    }
+    logDidYouMeanAutomatic(metadata) {
+        if (metadata) {
+            const metadataToSend = generateMetadataToSend(metadata);
+            return this.logSearchEvent(SearchPageEvents.didyoumeanAutomatic, metadataToSend);
+        }
+        return this.logSearchEvent(SearchPageEvents.didyoumeanAutomatic);
+    }
+    logDidYouMeanClick(metadata) {
+        if (metadata) {
+            const metadataToSend = generateMetadataToSend(metadata);
+            return this.logSearchEvent(SearchPageEvents.didyoumeanClick, metadataToSend);
+        }
+        return this.logSearchEvent(SearchPageEvents.didyoumeanClick);
+    }
+    logResultsSort(metadata) {
+        const metadataToSend = generateMetadataToSend(metadata);
+        return this.logSearchEvent(SearchPageEvents.resultsSort, metadataToSend);
+    }
+    logSearchboxSubmit(metadata) {
+        if (metadata) {
+            const metadataToSend = generateMetadataToSend(metadata);
+            return this.logSearchEvent(SearchPageEvents.searchboxSubmit, metadataToSend);
+        }
+        return this.logSearchEvent(SearchPageEvents.searchboxSubmit);
+    }
+    logContextChanged(metadata) {
+        const metadataToSend = generateMetadataToSend(metadata);
+        return this.logSearchEvent(InsightEvents.contextChanged, metadataToSend);
+    }
+    logExpandToFullUI(metadata) {
+        const metadataToSend = generateMetadataToSend(metadata);
+        return this.logCustomEvent(InsightEvents.expandToFullUI, metadataToSend);
+    }
+    logOpenUserActions(metadata) {
+        const metadataToSend = generateMetadataToSend(metadata, false);
+        return this.logCustomEvent(InsightEvents.openUserActions, metadataToSend);
+    }
+    logShowPrecedingSessions(metadata) {
+        const metadataToSend = generateMetadataToSend(metadata, false);
+        return this.logCustomEvent(InsightEvents.showPrecedingSessions, metadataToSend);
+    }
+    logShowFollowingSessions(metadata) {
+        const metadataToSend = generateMetadataToSend(metadata, false);
+        return this.logCustomEvent(InsightEvents.showFollowingSessions, metadataToSend);
+    }
+    logViewedDocumentClick(document, metadata) {
+        return this.logCustomEvent(InsightEvents.clickViewedDocument, Object.assign(Object.assign({}, generateMetadataToSend(metadata, false)), { document }));
+    }
+    logPageViewClick(pageView, metadata) {
+        return this.logCustomEvent(InsightEvents.clickPageView, Object.assign(Object.assign({}, generateMetadataToSend(metadata, false)), { pageView }));
+    }
+    logDocumentOpen(info, identifier, metadata) {
+        return this.logClickEvent(SearchPageEvents.documentOpen, info, identifier, metadata ? generateMetadataToSend(metadata, false) : undefined);
+    }
+    logCopyToClipboard(info, identifier, metadata) {
+        return this.logClickEvent(SearchPageEvents.copyToClipboard, info, identifier, metadata ? generateMetadataToSend(metadata, false) : undefined);
+    }
+    logCaseSendEmail(info, identifier, metadata) {
+        return this.logClickEvent(SearchPageEvents.caseSendEmail, info, identifier, metadata ? generateMetadataToSend(metadata, false) : undefined);
+    }
+    logFeedItemTextPost(info, identifier, metadata) {
+        return this.logClickEvent(SearchPageEvents.feedItemTextPost, info, identifier, metadata ? generateMetadataToSend(metadata, false) : undefined);
+    }
+    logDocumentQuickview(info, identifier, caseMetadata) {
+        const metadata = {
+            documentTitle: info.documentTitle,
+            documentURL: info.documentUrl,
+        };
+        return this.logClickEvent(SearchPageEvents.documentQuickview, info, identifier, caseMetadata ? Object.assign(Object.assign({}, generateMetadataToSend(caseMetadata, false)), metadata) : metadata);
+    }
+    logCaseAttach(info, identifier, caseMetadata) {
+        const metadata = {
+            documentTitle: info.documentTitle,
+            documentURL: info.documentUrl,
+            resultUriHash: info.documentUriHash,
+        };
+        return this.logClickEvent(SearchPageEvents.caseAttach, info, identifier, caseMetadata ? Object.assign(Object.assign({}, generateMetadataToSend(caseMetadata, false)), metadata) : metadata);
+    }
+    logCaseDetach(resultUriHash, metadata) {
+        return this.logCustomEvent(SearchPageEvents.caseDetach, metadata ? Object.assign(Object.assign({}, generateMetadataToSend(metadata, false)), { resultUriHash }) : { resultUriHash });
+    }
+    logLikeSmartSnippet(metadata) {
+        return this.logCustomEvent(SearchPageEvents.likeSmartSnippet, metadata ? generateMetadataToSend(metadata, false) : undefined);
+    }
+    logDislikeSmartSnippet(metadata) {
+        return this.logCustomEvent(SearchPageEvents.dislikeSmartSnippet, metadata ? generateMetadataToSend(metadata, false) : undefined);
+    }
+    logExpandSmartSnippet(metadata) {
+        return this.logCustomEvent(SearchPageEvents.expandSmartSnippet, metadata ? generateMetadataToSend(metadata, false) : undefined);
+    }
+    logCollapseSmartSnippet(metadata) {
+        return this.logCustomEvent(SearchPageEvents.collapseSmartSnippet, metadata ? generateMetadataToSend(metadata, false) : undefined);
+    }
+    logOpenSmartSnippetFeedbackModal(metadata) {
+        return this.logCustomEvent(SearchPageEvents.openSmartSnippetFeedbackModal, metadata ? generateMetadataToSend(metadata, false) : undefined);
+    }
+    logCloseSmartSnippetFeedbackModal(metadata) {
+        return this.logCustomEvent(SearchPageEvents.closeSmartSnippetFeedbackModal, metadata ? generateMetadataToSend(metadata, false) : undefined);
+    }
+    logSmartSnippetFeedbackReason(reason, details, metadata) {
+        return this.logCustomEvent(SearchPageEvents.sendSmartSnippetReason, metadata ? Object.assign(Object.assign({}, generateMetadataToSend(metadata, false)), { reason, details }) : { reason, details });
+    }
+    logExpandSmartSnippetSuggestion(snippet, metadata) {
+        const snippetMetadata = 'documentId' in snippet ? snippet : { documentId: snippet };
+        return this.logCustomEvent(SearchPageEvents.expandSmartSnippetSuggestion, metadata ? Object.assign(Object.assign({}, generateMetadataToSend(metadata, false)), snippetMetadata) : snippetMetadata);
+    }
+    logCollapseSmartSnippetSuggestion(snippet, metadata) {
+        const snippetMetadata = 'documentId' in snippet ? snippet : { documentId: snippet };
+        return this.logCustomEvent(SearchPageEvents.collapseSmartSnippetSuggestion, metadata ? Object.assign(Object.assign({}, generateMetadataToSend(metadata, false)), snippetMetadata) : snippetMetadata);
+    }
+    logOpenSmartSnippetSource(info, identifier, metadata) {
+        return this.logClickEvent(SearchPageEvents.openSmartSnippetSource, info, identifier, metadata ? generateMetadataToSend(metadata, false) : undefined);
+    }
+    logOpenSmartSnippetSuggestionSource(info, snippet, metadata) {
+        return this.logClickEvent(SearchPageEvents.openSmartSnippetSuggestionSource, info, { contentIDKey: snippet.documentId.contentIdKey, contentIDValue: snippet.documentId.contentIdValue }, metadata ? Object.assign(Object.assign({}, generateMetadataToSend(metadata, false)), snippet) : snippet);
+    }
+    logOpenSmartSnippetInlineLink(info, identifierAndLink, metadata) {
+        return this.logClickEvent(SearchPageEvents.openSmartSnippetInlineLink, info, { contentIDKey: identifierAndLink.contentIDKey, contentIDValue: identifierAndLink.contentIDValue }, metadata ? Object.assign(Object.assign({}, generateMetadataToSend(metadata, false)), identifierAndLink) : identifierAndLink);
+    }
+    logOpenSmartSnippetSuggestionInlineLink(info, snippetAndLink, metadata) {
+        return this.logClickEvent(SearchPageEvents.openSmartSnippetSuggestionInlineLink, info, {
+            contentIDKey: snippetAndLink.documentId.contentIdKey,
+            contentIDValue: snippetAndLink.documentId.contentIdValue,
+        }, metadata ? Object.assign(Object.assign({}, generateMetadataToSend(metadata, false)), snippetAndLink) : snippetAndLink);
+    }
+    logCustomEvent(event, metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const customData = Object.assign(Object.assign({}, this.provider.getBaseMetadata()), metadata);
+            const payload = Object.assign(Object.assign({}, (yield this.getBaseCustomEventRequest(customData))), { eventType: CustomEventsTypes[event], eventValue: event });
+            return this.coveoAnalyticsClient.sendCustomEvent(payload);
+        });
+    }
+    logSearchEvent(event, metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.coveoAnalyticsClient.sendSearchEvent(yield this.getBaseSearchEventRequest(event, metadata));
+        });
+    }
+    logClickEvent(event, info, identifier, metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const payload = Object.assign(Object.assign(Object.assign({}, info), (yield this.getBaseEventRequest(Object.assign(Object.assign({}, identifier), metadata)))), { searchQueryUid: this.provider.getSearchUID(), queryPipeline: this.provider.getPipeline(), actionCause: event });
+            return this.coveoAnalyticsClient.sendClickEvent(payload);
+        });
+    }
+    logShowMoreFoldedResults(info, identifier, metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.logClickEvent(SearchPageEvents.showMoreFoldedResults, info, identifier, metadata ? generateMetadataToSend(metadata, false) : undefined);
+        });
+    }
+    logShowLessFoldedResults(metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.logCustomEvent(SearchPageEvents.showLessFoldedResults, metadata ? generateMetadataToSend(metadata, false) : undefined);
+        });
+    }
+    getBaseCustomEventRequest(metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Object.assign(Object.assign({}, (yield this.getBaseEventRequest(metadata))), { lastSearchQueryUid: this.provider.getSearchUID() });
+        });
+    }
+    getBaseSearchEventRequest(event, metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Object.assign(Object.assign(Object.assign({}, (yield this.getBaseEventRequest(metadata))), this.provider.getSearchEventRequestPayload()), { searchQueryUid: this.provider.getSearchUID(), queryPipeline: this.provider.getPipeline(), actionCause: event });
+        });
+    }
+    getBaseEventRequest(metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const customData = Object.assign(Object.assign({}, this.provider.getBaseMetadata()), metadata);
+            return Object.assign(Object.assign({}, this.getOrigins()), { customData, language: this.provider.getLanguage(), facetState: this.provider.getFacetState ? this.provider.getFacetState() : [], anonymous: this.provider.getIsAnonymous(), clientId: yield this.getClientId() });
+        });
+    }
+    getOrigins() {
+        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(),
+        };
+    }
+    getClientId() {
+        return this.coveoAnalyticsClient instanceof CoveoAnalyticsClient
+            ? this.coveoAnalyticsClient.getCurrentVisitorId()
+            : undefined;
+    }
+}
+
+export { CaseAssistClient, CoveoAnalyticsClient, CoveoInsightClient, CoveoSearchPageClient, history };