coveo.analytics 2.30.56 → 2.32.0

package/src/client/analytics.ts

@@ -1,24 +1,28 @@
 import {
-    AnyEventResponse,
-    ClickEventRequest,
-    ClickEventResponse,
-    CustomEventRequest,
-    CustomEventResponse,
-    EventType,
-    HealthResponse,
-    SearchEventRequest,
-    SearchEventResponse,
-    ViewEventRequest,
-    ViewEventResponse,
-    VisitResponse,
-    IRequestPayload,
-    VariableArgumentsPayload,
-    PreparedClickEventRequest,
-    PreparedCustomEventRequest,
-    PreparedViewEventRequest,
-    PreparedSearchEventRequest,
+  AnyEventResponse,
+  ClickEventRequest,
+  ClickEventResponse,
+  CustomEventRequest,
+  CustomEventResponse,
+  EventType,
+  HealthResponse,
+  SearchEventRequest,
+  SearchEventResponse,
+  ViewEventRequest,
+  ViewEventResponse,
+  VisitResponse,
+  IRequestPayload,
+  VariableArgumentsPayload,
+  PreparedClickEventRequest,
+  PreparedCustomEventRequest,
+  PreparedViewEventRequest,
+  PreparedSearchEventRequest,
 } from '../events';
-import {IAnalyticsClientOptions, PreprocessAnalyticsRequest, VisitorIdProvider} from './analyticsRequestClient';
+import {
+  IAnalyticsClientOptions,
+  PreprocessAnalyticsRequest,
+  VisitorIdProvider,
+} from './analyticsRequestClient';
 import {hasWindow, hasDocument} from '../detector';
 import {addDefaultValues} from '../hook/addDefaultValues';
 import {enhanceViewEvent} from '../hook/enhanceViewEvent';
@@ -26,107 +30,131 @@ import {v4 as uuidv4, v5 as uuidv5, validate as uuidValidate} from 'uuid';
 import {libVersion} from '../version';
 import {CoveoLinkParam} from '../plugins/link';
 import {
-    convertKeysToMeasurementProtocol,
-    isMeasurementProtocolKey,
-    convertCustomMeasurementProtocolKeys,
+  convertKeysToMeasurementProtocol,
+  isMeasurementProtocolKey,
+  convertCustomMeasurementProtocolKeys,
 } from './measurementProtocolMapper';
-import {IRuntimeEnvironment, BrowserRuntime, NodeJSRuntime, NoopRuntime} from './runtimeEnvironment';
+import {
+  IRuntimeEnvironment,
+  BrowserRuntime,
+  NodeJSRuntime,
+  NoopRuntime,
+} from './runtimeEnvironment';
 import HistoryStore from '../history';
 import {isApiKey} from './token';
 import {isReactNative, ReactNativeRuntimeWarning} from '../react-native/react-native-utils';
-import {doNotTrack} from '../donottrack';
+import {shouldDisableAnalyticsForPrivacy} from '../donottrack';
 import {isObject, truncateUrl} from './utils';
 
 export const Version = 'v15';
 
 export 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',
+  default: 'https://analytics.cloud.coveo.com/rest/ua',
+  production: 'https://analytics.cloud.coveo.com/rest/ua',
+  hipaa: 'https://analyticshipaa.cloud.coveo.com/rest/ua',
 };
 
 export interface ClientOptions {
-    token?: string;
-    endpoint: string;
-    isCustomEndpoint?: boolean;
-    version: string;
-    runtimeEnvironment?: IRuntimeEnvironment;
-    beforeSendHooks: AnalyticsClientSendEventHook[];
-    afterSendHooks: AnalyticsClientSendEventHook[];
-    preprocessRequest?: PreprocessAnalyticsRequest;
+  token?: string;
+  endpoint: string;
+  isCustomEndpoint?: boolean;
+  version: string;
+  runtimeEnvironment?: IRuntimeEnvironment;
+  beforeSendHooks: AnalyticsClientSendEventHook[];
+  afterSendHooks: AnalyticsClientSendEventHook[];
+  preprocessRequest?: PreprocessAnalyticsRequest;
+  /**
+   * When `true`, browser privacy signals (Do Not Track and Global Privacy Control)
+   * are not honored and analytics is sent regardless of them. Defaults to `false`,
+   * which preserves the privacy-friendly behavior of honoring these signals.
+   */
+  disableBrowserPrivacySignals?: boolean;
 }
 
-export type AnalyticsClientSendEventHook = <TResult>(eventType: string, payload: any) => TResult | Promise<TResult>;
+export type AnalyticsClientSendEventHook = <TResult>(
+  eventType: string,
+  payload: any
+) => TResult | Promise<TResult>;
 export type EventTypeConfig = {
-    newEventType: EventType;
-    variableLengthArgumentsNames?: string[];
-    addVisitorIdParameter?: boolean;
-    addClientIdParameter?: boolean;
-    usesMeasurementProtocol?: boolean;
+  newEventType: EventType;
+  variableLengthArgumentsNames?: string[];
+  addVisitorIdParameter?: boolean;
+  addClientIdParameter?: boolean;
+  usesMeasurementProtocol?: boolean;
 };
 
-export interface PreparedEvent<TPreparedRequest, TCompleteRequest, TResponse extends AnyEventResponse>
-    extends BufferedRequest {
-    log(remainingPayload: Omit<TCompleteRequest, keyof TPreparedRequest>): Promise<TResponse | void>;
+export interface PreparedEvent<
+  TPreparedRequest,
+  TCompleteRequest,
+  TResponse extends AnyEventResponse,
+> extends BufferedRequest {
+  log(remainingPayload: Omit<TCompleteRequest, keyof TPreparedRequest>): Promise<TResponse | void>;
 }
 
 export interface AnalyticsClient {
-    getPayload(eventType: string, ...payload: VariableArgumentsPayload): Promise<any>;
-    getParameters(eventType: string, ...payload: VariableArgumentsPayload): Promise<any>;
-    makeEvent<TPreparedRequest, TCompleteRequest, TResponse extends AnyEventResponse>(
-        eventType: string,
-        ...payload: VariableArgumentsPayload
-    ): Promise<PreparedEvent<TPreparedRequest, TCompleteRequest, TResponse>>;
-    sendEvent(eventType: string, ...payload: VariableArgumentsPayload): Promise<AnyEventResponse | void>;
-    makeSearchEvent(
-        request: PreparedSearchEventRequest,
-    ): Promise<PreparedEvent<PreparedSearchEventRequest, SearchEventRequest, SearchEventResponse>>;
-    sendSearchEvent(request: SearchEventRequest): Promise<SearchEventResponse | void>;
-    makeClickEvent(
-        request: PreparedClickEventRequest,
-    ): Promise<PreparedEvent<PreparedClickEventRequest, ClickEventRequest, ClickEventResponse>>;
-    sendClickEvent(request: ClickEventRequest): Promise<ClickEventResponse | void>;
-    makeCustomEvent(
-        request: PreparedCustomEventRequest,
-    ): Promise<PreparedEvent<PreparedCustomEventRequest, CustomEventRequest, CustomEventResponse>>;
-    sendCustomEvent(request: CustomEventRequest): Promise<CustomEventResponse | void>;
-    makeViewEvent(
-        request: PreparedViewEventRequest,
-    ): Promise<PreparedEvent<PreparedViewEventRequest, ViewEventRequest, ViewEventResponse>>;
-    sendViewEvent(request: ViewEventRequest): Promise<ViewEventResponse | void>;
-    getVisit(): Promise<VisitResponse>;
-    getHealth(): Promise<HealthResponse>;
-    registerBeforeSendEventHook(hook: AnalyticsClientSendEventHook): void;
-    registerAfterSendEventHook(hook: AnalyticsClientSendEventHook): void;
-    addEventTypeMapping(eventType: string, eventConfig: EventTypeConfig): void;
-    runtime: IRuntimeEnvironment;
-    version: string;
-    /**
-     * @deprecated
-     */
-    readonly currentVisitorId: string;
-    getCurrentVisitorId?(): Promise<string>; // TODO: v3 make required
-    setAcceptedLinkReferrers?(hosts: string[]): void;
+  getPayload(eventType: string, ...payload: VariableArgumentsPayload): Promise<any>;
+  getParameters(eventType: string, ...payload: VariableArgumentsPayload): Promise<any>;
+  makeEvent<TPreparedRequest, TCompleteRequest, TResponse extends AnyEventResponse>(
+    eventType: string,
+    ...payload: VariableArgumentsPayload
+  ): Promise<PreparedEvent<TPreparedRequest, TCompleteRequest, TResponse>>;
+  sendEvent(
+    eventType: string,
+    ...payload: VariableArgumentsPayload
+  ): Promise<AnyEventResponse | void>;
+  makeSearchEvent(
+    request: PreparedSearchEventRequest
+  ): Promise<PreparedEvent<PreparedSearchEventRequest, SearchEventRequest, SearchEventResponse>>;
+  sendSearchEvent(request: SearchEventRequest): Promise<SearchEventResponse | void>;
+  makeClickEvent(
+    request: PreparedClickEventRequest
+  ): Promise<PreparedEvent<PreparedClickEventRequest, ClickEventRequest, ClickEventResponse>>;
+  sendClickEvent(request: ClickEventRequest): Promise<ClickEventResponse | void>;
+  makeCustomEvent(
+    request: PreparedCustomEventRequest
+  ): Promise<PreparedEvent<PreparedCustomEventRequest, CustomEventRequest, CustomEventResponse>>;
+  sendCustomEvent(request: CustomEventRequest): Promise<CustomEventResponse | void>;
+  makeViewEvent(
+    request: PreparedViewEventRequest
+  ): Promise<PreparedEvent<PreparedViewEventRequest, ViewEventRequest, ViewEventResponse>>;
+  sendViewEvent(request: ViewEventRequest): Promise<ViewEventResponse | void>;
+  getVisit(): Promise<VisitResponse>;
+  getHealth(): Promise<HealthResponse>;
+  registerBeforeSendEventHook(hook: AnalyticsClientSendEventHook): void;
+  registerAfterSendEventHook(hook: AnalyticsClientSendEventHook): void;
+  addEventTypeMapping(eventType: string, eventConfig: EventTypeConfig): void;
+  runtime: IRuntimeEnvironment;
+  version: string;
+  /**
+   * @deprecated
+   */
+  readonly currentVisitorId: string;
+  getCurrentVisitorId?(): Promise<string>; // TODO: v3 make required
+  setAcceptedLinkReferrers?(hosts: string[]): void;
 }
 
 export interface BufferedRequest {
-    eventType: EventType;
-    payload: any;
+  eventType: EventType;
+  payload: any;
 }
 
 type ProcessPayloadStep = (currentPayload: any) => any;
 type AsyncProcessPayloadStep = (currentPayload: any) => Promise<any>;
 
-export function buildBaseUrl(endpoint = Endpoints.default, apiVersion = Version, isCustomEndpoint = false) {
-    endpoint = endpoint.replace(/\/$/, ''); // Remove trailing slash in endpoint.
+export function buildBaseUrl(
+  endpoint = Endpoints.default,
+  apiVersion = Version,
+  isCustomEndpoint = false
+) {
+  endpoint = endpoint.replace(/\/$/, ''); // Remove trailing slash in endpoint.
 
-    if (isCustomEndpoint) {
-        return `${endpoint}/${apiVersion}`;
-    }
+  if (isCustomEndpoint) {
+    return `${endpoint}/${apiVersion}`;
+  }
 
-    const hasUARestEndpoint = endpoint.endsWith('/rest') || endpoint.endsWith('/rest/ua');
+  const hasUARestEndpoint = endpoint.endsWith('/rest') || endpoint.endsWith('/rest/ua');
 
-    return `${endpoint}${hasUARestEndpoint ? '' : '/rest'}/${apiVersion}`;
+  return `${endpoint}${hasUARestEndpoint ? '' : '/rest'}/${apiVersion}`;
 }
 
 // Note: Changing this value will destroy the mapping from tracking string to clientId for all customers
@@ -135,528 +163,575 @@ export function buildBaseUrl(endpoint = Endpoints.default, apiVersion = Version,
 const COVEO_NAMESPACE = '38824e1f-37f5-42d3-8372-a4b8fa9df946';
 
 export class CoveoAnalyticsClient implements AnalyticsClient, VisitorIdProvider {
-    private get defaultOptions(): ClientOptions {
-        return {
-            endpoint: Endpoints.default,
-            isCustomEndpoint: false,
-            token: '',
-            version: Version,
-            beforeSendHooks: [],
-            afterSendHooks: [],
-        };
-    }
-
-    public runtime: IRuntimeEnvironment;
-    public get version(): string {
-        return libVersion;
-    }
-    private visitorId: string;
-    private bufferedRequests: BufferedRequest[];
-    private beforeSendHooks: AnalyticsClientSendEventHook[];
-    private afterSendHooks: AnalyticsClientSendEventHook[];
-    private eventTypeMapping: {[name: string]: EventTypeConfig};
-    private options: ClientOptions;
-    private acceptedLinkReferrers: string[] = [];
-
-    constructor(opts: Partial<ClientOptions>) {
-        if (!opts) {
-            throw new Error('You have to pass options to this constructor');
-        }
-
-        this.options = {
-            ...this.defaultOptions,
-            ...opts,
-        };
-
-        this.visitorId = '';
+  private get defaultOptions(): ClientOptions {
+    return {
+      endpoint: Endpoints.default,
+      isCustomEndpoint: false,
+      token: '',
+      version: Version,
+      beforeSendHooks: [],
+      afterSendHooks: [],
+    };
+  }
+
+  public runtime: IRuntimeEnvironment;
+  public get version(): string {
+    return libVersion;
+  }
+  private visitorId: string;
+  private bufferedRequests: BufferedRequest[];
+  private beforeSendHooks: AnalyticsClientSendEventHook[];
+  private afterSendHooks: AnalyticsClientSendEventHook[];
+  private eventTypeMapping: {[name: string]: EventTypeConfig};
+  private options: ClientOptions;
+  private acceptedLinkReferrers: string[] = [];
+
+  constructor(opts: Partial<ClientOptions>) {
+    if (!opts) {
+      throw new Error('You have to pass options to this constructor');
+    }
+
+    this.options = {
+      ...this.defaultOptions,
+      ...opts,
+    };
+
+    this.visitorId = '';
+    this.bufferedRequests = [];
+    this.beforeSendHooks = [enhanceViewEvent, addDefaultValues].concat(
+      this.options.beforeSendHooks
+    );
+    this.afterSendHooks = this.options.afterSendHooks;
+    this.eventTypeMapping = {};
+
+    const clientsOptions: IAnalyticsClientOptions = {
+      baseUrl: this.baseUrl,
+      token: this.options.token,
+      visitorIdProvider: this,
+      preprocessRequest: this.options.preprocessRequest,
+    };
+
+    if (shouldDisableAnalyticsForPrivacy(this.options.disableBrowserPrivacySignals)) {
+      this.runtime = new NoopRuntime();
+    } else {
+      this.runtime = this.options.runtimeEnvironment || this.initRuntime(clientsOptions);
+    }
+
+    this.addEventTypeMapping(EventType.view, {
+      newEventType: EventType.view,
+      addClientIdParameter: true,
+    });
+    this.addEventTypeMapping(EventType.click, {
+      newEventType: EventType.click,
+      addClientIdParameter: true,
+    });
+    this.addEventTypeMapping(EventType.custom, {
+      newEventType: EventType.custom,
+      addClientIdParameter: true,
+    });
+    this.addEventTypeMapping(EventType.search, {
+      newEventType: EventType.search,
+      addClientIdParameter: true,
+    });
+  }
+
+  private initRuntime(clientsOptions: IAnalyticsClientOptions) {
+    if (hasWindow() && hasDocument()) {
+      return new BrowserRuntime(clientsOptions, () => {
+        const copy = [...this.bufferedRequests];
         this.bufferedRequests = [];
-        this.beforeSendHooks = [enhanceViewEvent, addDefaultValues].concat(this.options.beforeSendHooks);
-        this.afterSendHooks = this.options.afterSendHooks;
-        this.eventTypeMapping = {};
-
-        const clientsOptions: IAnalyticsClientOptions = {
-            baseUrl: this.baseUrl,
-            token: this.options.token,
-            visitorIdProvider: this,
-            preprocessRequest: this.options.preprocessRequest,
-        };
-
-        if (doNotTrack()) {
-            this.runtime = new NoopRuntime();
-        } else {
-            this.runtime = this.options.runtimeEnvironment || this.initRuntime(clientsOptions);
-        }
-
-        this.addEventTypeMapping(EventType.view, {newEventType: EventType.view, addClientIdParameter: true});
-        this.addEventTypeMapping(EventType.click, {newEventType: EventType.click, addClientIdParameter: true});
-        this.addEventTypeMapping(EventType.custom, {newEventType: EventType.custom, addClientIdParameter: true});
-        this.addEventTypeMapping(EventType.search, {newEventType: EventType.search, addClientIdParameter: true});
-    }
-
-    private initRuntime(clientsOptions: IAnalyticsClientOptions) {
-        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);
-    }
-
-    private get storage() {
-        return this.runtime.storage;
-    }
-
-    private async determineVisitorId() {
-        try {
-            return (
-                (hasWindow() && this.extractClientIdFromLink(window.location.href)) ||
-                (await this.storage.getItem('visitorId')) ||
-                uuidv4()
-            );
-        } catch (err) {
-            console.log(
-                'Could not get visitor ID from the current runtime environment storage. Using a random ID instead.',
-                err,
-            );
-            return uuidv4();
-        }
-    }
-
-    async getCurrentVisitorId() {
-        if (!this.visitorId) {
-            const id = await this.determineVisitorId();
-            await this.setCurrentVisitorId(id);
-        }
-        return this.visitorId;
-    }
-
-    async setCurrentVisitorId(visitorId: string) {
-        this.visitorId = visitorId;
-        await this.storage.setItem('visitorId', visitorId);
-    }
-
-    async setClientId(value: string, namespace?: string) {
-        if (uuidValidate(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)));
-        }
-    }
-
-    async getParameters(eventType: EventType | string, ...payload: VariableArgumentsPayload) {
-        return await this.resolveParameters(eventType, ...payload);
-    }
-
-    async getPayload(eventType: EventType | string, ...payload: VariableArgumentsPayload) {
-        const parametersToSend = await this.resolveParameters(eventType, ...payload);
-        return await this.resolvePayloadForParameters(eventType, parametersToSend);
-    }
-
-    /**
-     * @deprecated Synchronous method is deprecated, use getCurrentVisitorId instead. This method will NOT work with react-native.
-     */
-    get currentVisitorId() {
-        const visitorId = this.visitorId || this.storage.getItem('visitorId');
-        if (typeof visitorId !== 'string') {
-            this.setCurrentVisitorId(uuidv4());
-        }
-        return this.visitorId;
-    }
-
-    /**
-     * @deprecated Synchronous method is deprecated, use setCurrentVisitorId instead. This method will NOT work with react-native.
-     */
-    set currentVisitorId(visitorId: string) {
-        this.visitorId = visitorId;
-        this.storage.setItem('visitorId', visitorId);
-    }
-
-    private extractClientIdFromLink(urlString: string): string | null {
-        if (doNotTrack()) {
-            return null;
-        }
-        try {
-            const linkParam: string | null = new URL(urlString).searchParams.get(CoveoLinkParam.cvo_cid);
-            if (linkParam == null) {
-                return null;
-            }
-            const linker: CoveoLinkParam | null = CoveoLinkParam.fromString(linkParam);
-            if (!linker || !hasDocument() || !linker.validate(document.referrer, this.acceptedLinkReferrers)) {
-                return null;
-            }
-            return linker.clientId;
-        } catch (error) {
-            // Ignore any parsing errors
-        }
+        return copy;
+      });
+    } else if (isReactNative()) {
+      console.warn(ReactNativeRuntimeWarning);
+    }
+    return new NodeJSRuntime(clientsOptions);
+  }
+
+  private get storage() {
+    return this.runtime.storage;
+  }
+
+  private async determineVisitorId() {
+    try {
+      return (
+        (hasWindow() && this.extractClientIdFromLink(window.location.href)) ||
+        (await this.storage.getItem('visitorId')) ||
+        uuidv4()
+      );
+    } catch (err) {
+      console.log(
+        'Could not get visitor ID from the current runtime environment storage. Using a random ID instead.',
+        err
+      );
+      return uuidv4();
+    }
+  }
+
+  async getCurrentVisitorId() {
+    if (!this.visitorId) {
+      const id = await this.determineVisitorId();
+      await this.setCurrentVisitorId(id);
+    }
+    return this.visitorId;
+  }
+
+  async setCurrentVisitorId(visitorId: string) {
+    this.visitorId = visitorId;
+    await this.storage.setItem('visitorId', visitorId);
+  }
+
+  async setClientId(value: string, namespace?: string) {
+    if (uuidValidate(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)));
+    }
+  }
+
+  async getParameters(
+    eventType: EventType | string,
+    ...payload: VariableArgumentsPayload
+  ): Promise<VariableArgumentsPayload> {
+    return await this.resolveParameters(eventType, ...payload);
+  }
+
+  async getPayload(eventType: EventType | string, ...payload: VariableArgumentsPayload) {
+    const parametersToSend = await this.resolveParameters(eventType, ...payload);
+    return await this.resolvePayloadForParameters(eventType, parametersToSend);
+  }
+
+  /**
+   * @deprecated Synchronous method is deprecated, use getCurrentVisitorId instead. This method will NOT work with react-native.
+   */
+  get currentVisitorId() {
+    const visitorId = this.visitorId || this.storage.getItem('visitorId');
+    if (typeof visitorId !== 'string') {
+      this.setCurrentVisitorId(uuidv4());
+    }
+    return this.visitorId;
+  }
+
+  /**
+   * @deprecated Synchronous method is deprecated, use setCurrentVisitorId instead. This method will NOT work with react-native.
+   */
+  set currentVisitorId(visitorId: string) {
+    this.visitorId = visitorId;
+    this.storage.setItem('visitorId', visitorId);
+  }
+
+  private extractClientIdFromLink(urlString: string): string | null {
+    if (shouldDisableAnalyticsForPrivacy(this.options.disableBrowserPrivacySignals)) {
+      return null;
+    }
+    try {
+      const linkParam: string | null = new URL(urlString).searchParams.get(CoveoLinkParam.cvo_cid);
+      if (linkParam == null) {
         return null;
-    }
-
-    async resolveParameters(eventType: EventType | string, ...payload: VariableArgumentsPayload) {
-        const {
-            variableLengthArgumentsNames = [],
-            addVisitorIdParameter = false,
-            usesMeasurementProtocol = false,
-            addClientIdParameter = false,
-        } = this.eventTypeMapping[eventType] || {};
-
-        const processVariableArgumentNamesStep: ProcessPayloadStep = (currentPayload) =>
-            variableLengthArgumentsNames.length > 0
-                ? this.parseVariableArgumentsPayload(variableLengthArgumentsNames, currentPayload)
-                : currentPayload[0];
-        const addVisitorIdStep: AsyncProcessPayloadStep = async (currentPayload) => ({
-            ...currentPayload,
-            visitorId: addVisitorIdParameter ? await this.getCurrentVisitorId() : '',
-        });
-        const addClientIdStep: AsyncProcessPayloadStep = async (currentPayload) => {
-            if (addClientIdParameter) {
-                return {
-                    ...currentPayload,
-                    clientId: await this.getCurrentVisitorId(),
-                };
-            }
-            return currentPayload;
-        };
-        const setAnonymousUserStep: ProcessPayloadStep = (currentPayload) =>
-            usesMeasurementProtocol ? this.ensureAnonymousUserWhenUsingApiKey(currentPayload) : currentPayload;
-        const processBeforeSendHooksStep: AsyncProcessPayloadStep = (currentPayload) =>
-            this.beforeSendHooks.reduce(async (promisePayload, current) => {
-                const payload = await promisePayload;
-                return await current(eventType, payload);
-            }, currentPayload);
-
-        const parametersToSend = await [
-            processVariableArgumentNamesStep,
-            addVisitorIdStep,
-            addClientIdStep,
-            setAnonymousUserStep,
-            processBeforeSendHooksStep,
-        ].reduce(async (payloadPromise, step) => {
-            const payload = await payloadPromise;
-            return await step(payload);
-        }, Promise.resolve(payload));
-
-        return parametersToSend;
-    }
-
-    async resolvePayloadForParameters(eventType: EventType | string, parameters: any) {
-        const {usesMeasurementProtocol = false} = this.eventTypeMapping[eventType] || {};
-
-        const addTrackingIdStep: ProcessPayloadStep = (currentPayload) =>
-            this.setTrackingIdIfTrackingIdNotPresent(currentPayload);
-        const cleanPayloadStep: ProcessPayloadStep = (currentPayload) =>
-            this.removeEmptyPayloadValues(currentPayload, eventType);
-        const validateParams: ProcessPayloadStep = (currentPayload) => this.validateParams(currentPayload, eventType);
-        const processMeasurementProtocolConversionStep: ProcessPayloadStep = (currentPayload) =>
-            usesMeasurementProtocol ? convertKeysToMeasurementProtocol(currentPayload) : currentPayload;
-        const removeUnknownParameters: ProcessPayloadStep = (currentPayload) =>
-            usesMeasurementProtocol ? this.removeUnknownParameters(currentPayload) : currentPayload;
-        const processCustomParameters: ProcessPayloadStep = (currentPayload) =>
-            usesMeasurementProtocol
-                ? this.processCustomParameters(currentPayload)
-                : this.mapCustomParametersToCustomData(currentPayload);
-
-        const payloadToSend = await [
-            addTrackingIdStep,
-            cleanPayloadStep,
-            validateParams,
-            processMeasurementProtocolConversionStep,
-            removeUnknownParameters,
-            processCustomParameters,
-        ].reduce(async (payloadPromise, step) => {
-            const payload = await payloadPromise;
-            return await step(payload);
-        }, Promise.resolve(parameters));
-
-        return payloadToSend;
-    }
-
-    async makeEvent<TPreparedRequest, TCompleteRequest, TResponse extends AnyEventResponse>(
-        eventType: EventType | string,
-        ...payload: VariableArgumentsPayload
-    ): Promise<PreparedEvent<TPreparedRequest, TCompleteRequest, TResponse>> {
-        const {newEventType: eventTypeToSend = eventType as EventType} = this.eventTypeMapping[eventType] || {};
-
-        const parametersToSend = await this.resolveParameters(eventType, ...payload);
-        const payloadToSend = await this.resolvePayloadForParameters(eventType, parametersToSend);
+      }
+      const linker: CoveoLinkParam | null = CoveoLinkParam.fromString(linkParam);
+      if (
+        !linker ||
+        !hasDocument() ||
+        !linker.validate(document.referrer, this.acceptedLinkReferrers)
+      ) {
+        return null;
+      }
+      return linker.clientId;
+    } catch (error) {
+      // Ignore any parsing errors
+    }
+    return null;
+  }
+
+  async resolveParameters(
+    eventType: EventType | string,
+    ...payload: VariableArgumentsPayload
+  ): Promise<VariableArgumentsPayload> {
+    const {
+      variableLengthArgumentsNames = [],
+      addVisitorIdParameter = false,
+      usesMeasurementProtocol = false,
+      addClientIdParameter = false,
+    } = this.eventTypeMapping[eventType] || {};
+
+    const processVariableArgumentNamesStep: ProcessPayloadStep = (currentPayload) =>
+      variableLengthArgumentsNames.length > 0
+        ? this.parseVariableArgumentsPayload(variableLengthArgumentsNames, currentPayload)
+        : currentPayload[0];
+    const addVisitorIdStep: AsyncProcessPayloadStep = async (currentPayload) => ({
+      ...currentPayload,
+      visitorId: addVisitorIdParameter ? await this.getCurrentVisitorId() : '',
+    });
+    const addClientIdStep: AsyncProcessPayloadStep = async (currentPayload) => {
+      if (addClientIdParameter) {
         return {
-            eventType: eventTypeToSend,
-            payload: payloadToSend,
-            log: async (remainingPayload) => {
-                this.bufferedRequests.push(<BufferedRequest>{
-                    eventType: eventTypeToSend,
-                    payload: {...payloadToSend, ...remainingPayload},
-                });
-                await Promise.all(
-                    this.afterSendHooks.map((hook) => hook(eventType, {...parametersToSend, ...remainingPayload})),
-                );
-                await this.deferExecution();
-                return (await this.sendFromBuffer()) as TResponse | void;
-            },
+          ...currentPayload,
+          clientId: await this.getCurrentVisitorId(),
         };
-    }
-
-    async sendEvent(eventType: EventType | string, ...payload: VariableArgumentsPayload) {
-        return (await this.makeEvent<any, any, AnyEventResponse>(eventType, ...payload)).log({});
-    }
-
-    private deferExecution(): Promise<void> {
-        return new Promise((resolve) => setTimeout(resolve, 0));
-    }
-
-    private async sendFromBuffer(): Promise<AnyEventResponse | void> {
-        const popped = this.bufferedRequests.shift();
-        if (popped) {
-            const {eventType, payload} = popped;
-            return this.runtime.getClientDependingOnEventType(eventType).sendEvent(eventType, payload);
-        }
-    }
-
-    public clear() {
-        this.storage.removeItem('visitorId');
-        const store = new HistoryStore();
-        store.clear();
-    }
-
-    public deleteHttpOnlyVisitorId() {
-        this.runtime.client.deleteHttpCookieVisitorId();
-    }
-
-    async makeSearchEvent(request: PreparedSearchEventRequest) {
-        return this.makeEvent<PreparedSearchEventRequest, SearchEventRequest, SearchEventResponse>(
-            EventType.search,
-            request,
-        );
-    }
-
-    async sendSearchEvent({searchQueryUid, ...preparedRequest}: SearchEventRequest) {
-        return (await this.makeSearchEvent(preparedRequest)).log({searchQueryUid});
-    }
-
-    async makeClickEvent(request: PreparedClickEventRequest) {
-        return this.makeEvent<PreparedClickEventRequest, ClickEventRequest, ClickEventResponse>(
-            EventType.click,
-            request,
-        );
-    }
-
-    async sendClickEvent({searchQueryUid, ...preparedRequest}: ClickEventRequest) {
-        return (await this.makeClickEvent(preparedRequest)).log({searchQueryUid});
-    }
-
-    async makeCustomEvent(request: PreparedCustomEventRequest) {
-        return this.makeEvent<PreparedCustomEventRequest, CustomEventRequest, CustomEventResponse>(
-            EventType.custom,
-            request,
+      }
+      return currentPayload;
+    };
+    const setAnonymousUserStep: ProcessPayloadStep = (currentPayload) =>
+      usesMeasurementProtocol
+        ? this.ensureAnonymousUserWhenUsingApiKey(currentPayload)
+        : currentPayload;
+    const processBeforeSendHooksStep: AsyncProcessPayloadStep = (currentPayload) =>
+      this.beforeSendHooks.reduce(async (promisePayload, current) => {
+        const payload = await promisePayload;
+        return await current(eventType, payload);
+      }, currentPayload);
+
+    const parametersToSend = await [
+      processVariableArgumentNamesStep,
+      addVisitorIdStep,
+      addClientIdStep,
+      setAnonymousUserStep,
+      processBeforeSendHooksStep,
+    ].reduce(async (payloadPromise, step) => {
+      const payload = await payloadPromise;
+      return await step(payload);
+    }, Promise.resolve(payload));
+
+    return parametersToSend;
+  }
+
+  async resolvePayloadForParameters(eventType: EventType | string, parameters: any) {
+    const {usesMeasurementProtocol = false} = this.eventTypeMapping[eventType] || {};
+
+    const addTrackingIdStep: ProcessPayloadStep = (currentPayload) =>
+      this.setTrackingIdIfTrackingIdNotPresent(currentPayload);
+    const cleanPayloadStep: ProcessPayloadStep = (currentPayload) =>
+      this.removeEmptyPayloadValues(currentPayload, eventType);
+    const validateParams: ProcessPayloadStep = (currentPayload) =>
+      this.validateParams(currentPayload, eventType);
+    const processMeasurementProtocolConversionStep: ProcessPayloadStep = (currentPayload) =>
+      usesMeasurementProtocol ? convertKeysToMeasurementProtocol(currentPayload) : currentPayload;
+    const removeUnknownParameters: ProcessPayloadStep = (currentPayload) =>
+      usesMeasurementProtocol ? this.removeUnknownParameters(currentPayload) : currentPayload;
+    const processCustomParameters: ProcessPayloadStep = (currentPayload) =>
+      usesMeasurementProtocol
+        ? this.processCustomParameters(currentPayload)
+        : this.mapCustomParametersToCustomData(currentPayload);
+
+    const payloadToSend = await [
+      addTrackingIdStep,
+      cleanPayloadStep,
+      validateParams,
+      processMeasurementProtocolConversionStep,
+      removeUnknownParameters,
+      processCustomParameters,
+    ].reduce(async (payloadPromise, step) => {
+      const payload = await payloadPromise;
+      return await step(payload);
+    }, Promise.resolve(parameters));
+
+    return payloadToSend;
+  }
+
+  async makeEvent<TPreparedRequest, TCompleteRequest, TResponse extends AnyEventResponse>(
+    eventType: EventType | string,
+    ...payload: VariableArgumentsPayload
+  ): Promise<PreparedEvent<TPreparedRequest, TCompleteRequest, TResponse>> {
+    const {newEventType: eventTypeToSend = eventType as EventType} =
+      this.eventTypeMapping[eventType] || {};
+
+    const parametersToSend = await this.resolveParameters(eventType, ...payload);
+    const payloadToSend = await this.resolvePayloadForParameters(eventType, parametersToSend);
+    return {
+      eventType: eventTypeToSend,
+      payload: payloadToSend,
+      log: async (remainingPayload) => {
+        this.bufferedRequests.push(<BufferedRequest>{
+          eventType: eventTypeToSend,
+          payload: {...payloadToSend, ...remainingPayload},
+        });
+        await Promise.all(
+          this.afterSendHooks.map((hook) =>
+            hook(eventType, {...parametersToSend, ...remainingPayload})
+          )
         );
-    }
-
-    async sendCustomEvent({lastSearchQueryUid, ...preparedRequest}: CustomEventRequest) {
-        return (await this.makeCustomEvent(preparedRequest)).log({lastSearchQueryUid});
-    }
-
-    async makeViewEvent(request: PreparedViewEventRequest) {
-        return this.makeEvent<PreparedViewEventRequest, ViewEventRequest, ViewEventResponse>(EventType.view, request);
-    }
-
-    async sendViewEvent(request: ViewEventRequest): Promise<ViewEventResponse | void> {
-        return (await this.makeViewEvent(request)).log({});
-    }
-
-    async getVisit(): Promise<VisitResponse> {
-        // deepcode ignore Ssrf: url is supplied by script owner
-        const response = await fetch(`${this.baseUrl}/analytics/visit`);
-        const visit = (await response.json()) as VisitResponse;
-        this.visitorId = visit.visitorId;
-        return visit;
-    }
-
-    async getHealth(): Promise<HealthResponse> {
-        // deepcode ignore Ssrf: url is supplied by script owner
-        const response = await fetch(`${this.baseUrl}/analytics/monitoring/health`);
-        return (await response.json()) as HealthResponse;
-    }
-
-    registerBeforeSendEventHook(hook: AnalyticsClientSendEventHook): void {
-        this.beforeSendHooks.push(hook);
-    }
-
-    registerAfterSendEventHook(hook: AnalyticsClientSendEventHook): void {
-        this.afterSendHooks.push(hook);
-    }
-
-    addEventTypeMapping(eventType: string, eventConfig: EventTypeConfig): void {
-        this.eventTypeMapping[eventType] = eventConfig;
-    }
-
-    setAcceptedLinkReferrers(hosts: string[]): void {
-        if (Array.isArray(hosts) && hosts.every((host) => typeof host == 'string')) this.acceptedLinkReferrers = hosts;
-        else throw Error('Parameter should be an array of domain strings');
-    }
-
-    private parseVariableArgumentsPayload(fieldsOrder: string[], payload: VariableArgumentsPayload) {
-        const parsedArguments: {[name: string]: any} = {};
-        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') {
-                // If the argument is an object, it is considered the last argument of the chain. Its values should be returned as-is.
-                return {
-                    ...parsedArguments,
-                    ...currentArgument,
-                };
-            }
-        }
-        return parsedArguments;
-    }
-
-    private isKeyAllowedEmpty(evtType: string, key: string) {
-        const keysThatCanBeEmpty: Record<string, string[]> = {
-            [EventType.search]: ['queryText'],
-        };
-
-        const match = keysThatCanBeEmpty[evtType] || [];
-        return match.indexOf(key) !== -1;
-    }
-
-    private removeEmptyPayloadValues(payload: IRequestPayload, eventType: string): IRequestPayload {
-        const isNotEmptyValue = (value: any) => typeof value !== 'undefined' && value !== null && value !== '';
-        return Object.keys(payload)
-            .filter((key) => this.isKeyAllowedEmpty(eventType, key) || isNotEmptyValue(payload[key]))
-            .reduce(
-                (newPayload, key) => ({
-                    ...newPayload,
-                    [key]: payload[key],
-                }),
-                {},
-            );
-    }
-
-    private removeUnknownParameters(payload: IRequestPayload): IRequestPayload {
-        const newPayload = Object.keys(payload)
-            .filter((key) => {
-                if (isMeasurementProtocolKey(key)) {
-                    return true;
-                } else {
-                    console.log(key, 'is not processed by coveoua');
-                }
-            })
-            .reduce(
-                (newPayload, key) => ({
-                    ...newPayload,
-                    [key]: payload[key],
-                }),
-                {},
-            );
-        return newPayload;
-    }
-
-    private processCustomParameters(payload: IRequestPayload): IRequestPayload {
-        const {custom, ...rest} = payload;
-        let lowercasedCustom = {};
-        if (custom && isObject(custom)) {
-            lowercasedCustom = this.lowercaseKeys(custom);
-        }
-
-        const newPayload = convertCustomMeasurementProtocolKeys(rest);
-
+        await this.deferExecution();
+        return (await this.sendFromBuffer()) as TResponse | void;
+      },
+    };
+  }
+
+  async sendEvent(eventType: EventType | string, ...payload: VariableArgumentsPayload) {
+    return (await this.makeEvent<any, any, AnyEventResponse>(eventType, ...payload)).log({});
+  }
+
+  private deferExecution(): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, 0));
+  }
+
+  private async sendFromBuffer(): Promise<AnyEventResponse | void> {
+    const popped = this.bufferedRequests.shift();
+    if (popped) {
+      const {eventType, payload} = popped;
+      return this.runtime.getClientDependingOnEventType(eventType).sendEvent(eventType, payload);
+    }
+  }
+
+  public clear() {
+    this.storage.removeItem('visitorId');
+    const store = new HistoryStore();
+    store.clear();
+  }
+
+  public deleteHttpOnlyVisitorId() {
+    this.runtime.client.deleteHttpCookieVisitorId();
+  }
+
+  async makeSearchEvent(request: PreparedSearchEventRequest) {
+    return this.makeEvent<PreparedSearchEventRequest, SearchEventRequest, SearchEventResponse>(
+      EventType.search,
+      request
+    );
+  }
+
+  async sendSearchEvent({searchQueryUid, ...preparedRequest}: SearchEventRequest) {
+    return (await this.makeSearchEvent(preparedRequest)).log({searchQueryUid});
+  }
+
+  async makeClickEvent(request: PreparedClickEventRequest) {
+    return this.makeEvent<PreparedClickEventRequest, ClickEventRequest, ClickEventResponse>(
+      EventType.click,
+      request
+    );
+  }
+
+  async sendClickEvent({searchQueryUid, ...preparedRequest}: ClickEventRequest) {
+    return (await this.makeClickEvent(preparedRequest)).log({searchQueryUid});
+  }
+
+  async makeCustomEvent(request: PreparedCustomEventRequest) {
+    return this.makeEvent<PreparedCustomEventRequest, CustomEventRequest, CustomEventResponse>(
+      EventType.custom,
+      request
+    );
+  }
+
+  async sendCustomEvent({lastSearchQueryUid, ...preparedRequest}: CustomEventRequest) {
+    return (await this.makeCustomEvent(preparedRequest)).log({
+      lastSearchQueryUid,
+    });
+  }
+
+  async makeViewEvent(request: PreparedViewEventRequest) {
+    return this.makeEvent<PreparedViewEventRequest, ViewEventRequest, ViewEventResponse>(
+      EventType.view,
+      request
+    );
+  }
+
+  async sendViewEvent(request: ViewEventRequest): Promise<ViewEventResponse | void> {
+    return (await this.makeViewEvent(request)).log({});
+  }
+
+  async getVisit(): Promise<VisitResponse> {
+    // deepcode ignore Ssrf: url is supplied by script owner
+    const response = await fetch(`${this.baseUrl}/analytics/visit`);
+    const visit = (await response.json()) as VisitResponse;
+    this.visitorId = visit.visitorId;
+    return visit;
+  }
+
+  async getHealth(): Promise<HealthResponse> {
+    // deepcode ignore Ssrf: url is supplied by script owner
+    const response = await fetch(`${this.baseUrl}/analytics/monitoring/health`);
+    return (await response.json()) as HealthResponse;
+  }
+
+  registerBeforeSendEventHook(hook: AnalyticsClientSendEventHook): void {
+    this.beforeSendHooks.push(hook);
+  }
+
+  registerAfterSendEventHook(hook: AnalyticsClientSendEventHook): void {
+    this.afterSendHooks.push(hook);
+  }
+
+  addEventTypeMapping(eventType: string, eventConfig: EventTypeConfig): void {
+    this.eventTypeMapping[eventType] = eventConfig;
+  }
+
+  setAcceptedLinkReferrers(hosts: string[]): void {
+    if (Array.isArray(hosts) && hosts.every((host) => typeof host == 'string'))
+      this.acceptedLinkReferrers = hosts;
+    else throw Error('Parameter should be an array of domain strings');
+  }
+
+  private parseVariableArgumentsPayload(fieldsOrder: string[], payload: VariableArgumentsPayload) {
+    const parsedArguments: {[name: string]: any} = {};
+    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') {
+        // If the argument is an object, it is considered the last argument of the chain. Its values should be returned as-is.
         return {
-            ...lowercasedCustom,
-            ...newPayload,
+          ...parsedArguments,
+          ...currentArgument,
         };
-    }
-
-    private mapCustomParametersToCustomData(payload: IRequestPayload): IRequestPayload {
-        const {custom, ...rest} = payload;
-        if (custom && isObject(custom)) {
-            const lowercasedCustom = this.lowercaseKeys(custom);
-            return {...rest, customData: {...lowercasedCustom, ...payload.customData}};
-        } else {
-            return payload;
-        }
-    }
-
-    private lowercaseKeys(custom: Record<string, unknown>) {
-        const keys = Object.keys(custom);
-        let result: Record<string, unknown> = {};
-        keys.forEach((key) => {
-            result[key.toLowerCase() as string] = custom[key];
-        });
-        return result;
-    }
-
-    private validateParams(payload: IRequestPayload, eventType: EventType | string): IRequestPayload {
-        const {anonymizeIp, ...rest} = payload;
-        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, 1024);
-        }
-        if (eventType == EventType.view) {
-            rest.location = this.limit(rest.location, 1024);
-        }
-        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;
-    }
-
-    private ensureAnonymousUserWhenUsingApiKey(payload: IRequestPayload): IRequestPayload {
-        const {userId, ...rest} = payload;
-        if (isApiKey(this.options.token) && !userId) {
-            rest['userId'] = 'anonymous';
-            return rest;
+      }
+    }
+    return parsedArguments;
+  }
+
+  private isKeyAllowedEmpty(evtType: string, key: string) {
+    const keysThatCanBeEmpty: Record<string, string[]> = {
+      [EventType.search]: ['queryText'],
+    };
+
+    const match = keysThatCanBeEmpty[evtType] || [];
+    return match.indexOf(key) !== -1;
+  }
+
+  private removeEmptyPayloadValues(payload: IRequestPayload, eventType: string): IRequestPayload {
+    const isNotEmptyValue = (value: any) =>
+      typeof value !== 'undefined' && value !== null && value !== '';
+    return Object.keys(payload)
+      .filter((key) => this.isKeyAllowedEmpty(eventType, key) || isNotEmptyValue(payload[key]))
+      .reduce(
+        (newPayload, key) => ({
+          ...newPayload,
+          [key]: payload[key],
+        }),
+        {}
+      );
+  }
+
+  private removeUnknownParameters(payload: IRequestPayload): IRequestPayload {
+    const newPayload = Object.keys(payload)
+      .filter((key) => {
+        if (isMeasurementProtocolKey(key)) {
+          return true;
         } else {
-            return payload;
-        }
-    }
-
-    private setTrackingIdIfTrackingIdNotPresent(payload: IRequestPayload): IRequestPayload {
-        const {trackingId, ...rest} = payload;
-        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;
-            }
+          console.log(key, 'is not processed by coveoua');
         }
-
-        return rest;
-    }
-
-    private limit<T>(input: T, length: number): T {
-        return typeof input === 'string' ? (truncateUrl(input, length) as T) : input;
-    }
-
-    private get baseUrl(): string {
-        return buildBaseUrl(this.options.endpoint, this.options.version, this.options.isCustomEndpoint);
-    }
+      })
+      .reduce(
+        (newPayload, key) => ({
+          ...newPayload,
+          [key]: payload[key],
+        }),
+        {}
+      );
+    return newPayload;
+  }
+
+  private processCustomParameters(payload: IRequestPayload): IRequestPayload {
+    const {custom, ...rest} = payload;
+    let lowercasedCustom = {};
+    if (custom && isObject(custom)) {
+      lowercasedCustom = this.lowercaseKeys(custom);
+    }
+
+    const newPayload = convertCustomMeasurementProtocolKeys(rest);
+
+    return {
+      ...lowercasedCustom,
+      ...newPayload,
+    };
+  }
+
+  private mapCustomParametersToCustomData(payload: IRequestPayload): IRequestPayload {
+    const {custom, ...rest} = payload;
+    if (custom && isObject(custom)) {
+      const lowercasedCustom = this.lowercaseKeys(custom);
+      return {
+        ...rest,
+        customData: {...lowercasedCustom, ...payload.customData},
+      };
+    } else {
+      return payload;
+    }
+  }
+
+  private lowercaseKeys(custom: Record<string, unknown>) {
+    const keys = Object.keys(custom);
+    let result: Record<string, unknown> = {};
+    keys.forEach((key) => {
+      result[key.toLowerCase() as string] = custom[key];
+    });
+    return result;
+  }
+
+  private validateParams(payload: IRequestPayload, eventType: EventType | string): IRequestPayload {
+    const {anonymizeIp, ...rest} = payload;
+    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, 1024);
+    }
+    if (eventType == EventType.view) {
+      rest.location = this.limit(rest.location, 1024);
+    }
+    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;
+  }
+
+  private ensureAnonymousUserWhenUsingApiKey(payload: IRequestPayload): IRequestPayload {
+    const {userId, ...rest} = payload;
+    if (isApiKey(this.options.token) && !userId) {
+      rest['userId'] = 'anonymous';
+      return rest;
+    } else {
+      return payload;
+    }
+  }
+
+  private setTrackingIdIfTrackingIdNotPresent(payload: IRequestPayload): IRequestPayload {
+    const {trackingId, ...rest} = payload;
+    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;
+  }
+
+  private limit<T>(input: T, length: number): T {
+    return typeof input === 'string' ? (truncateUrl(input, length) as T) : input;
+  }
+
+  private get baseUrl(): string {
+    return buildBaseUrl(this.options.endpoint, this.options.version, this.options.isCustomEndpoint);
+  }
 }
 
 export default CoveoAnalyticsClient;