@splitsoftware/splitio-commons 1.2.1-rc.0 → 1.2.1-rc.11

package/types/storages/types.d.ts

@@ -269,6 +269,7 @@ export interface IRecorderCacheProducerSync<T> {
 }
 export interface IImpressionsCacheSync extends IImpressionsCacheBase, IRecorderCacheProducerSync<ImpressionDTO[]> {
     track(data: ImpressionDTO[]): void;
+    setOnFullQueueCb(cb: () => void): void;
 }
 export interface IEventsCacheSync extends IEventsCacheBase, IRecorderCacheProducerSync<SplitIO.EventData[]> {
     track(data: SplitIO.EventData, size?: number): boolean;
@@ -335,6 +336,7 @@ export declare type IStorageAsync = IStorageBase<ISplitsCacheAsync, ISegmentsCac
 export declare type DataLoader = (storage: IStorageSync, matchingKey: string) => void;
 export interface IStorageFactoryParams {
     log: ILogger;
+    impressionsQueueSize?: number;
     eventsQueueSize?: number;
     optimize?: boolean;
     matchingKey?: string;
@@ -345,7 +347,7 @@ export interface IStorageFactoryParams {
 }
 export declare type StorageType = 'MEMORY' | 'LOCALSTORAGE' | 'REDIS' | 'PLUGGABLE';
 export declare type IStorageSyncFactory = {
-    type: StorageType;
+    readonly type: StorageType;
     (params: IStorageFactoryParams): IStorageSync;
 };
 export declare type IStorageAsyncFactory = {

package/types/sync/polling/fetchers/mySegmentsFetcher.d.ts

@@ -4,4 +4,4 @@ import { IMySegmentsFetcher } from './types';
  * Factory of MySegments fetcher.
  * MySegments fetcher is a wrapper around `mySegments` API service that parses the response and handle errors.
  */
-export declare function mySegmentsFetcherFactory(fetchMySegments: IFetchMySegments, userMatchingKey: string): IMySegmentsFetcher;
+export declare function mySegmentsFetcherFactory(fetchMySegments: IFetchMySegments): IMySegmentsFetcher;

package/types/sync/polling/fetchers/types.d.ts

@@ -2,4 +2,4 @@ import { ISplitChangesResponse, ISegmentChangesResponse } from '../../../dtos/ty
 import { IResponse } from '../../../services/types';
 export declare type ISplitChangesFetcher = (since: number, noCache?: boolean, decorator?: (promise: Promise<IResponse>) => Promise<IResponse>) => Promise<ISplitChangesResponse>;
 export declare type ISegmentChangesFetcher = (since: number, segmentName: string, noCache?: boolean, decorator?: (promise: Promise<ISegmentChangesResponse[]>) => Promise<ISegmentChangesResponse[]>) => Promise<ISegmentChangesResponse[]>;
-export declare type IMySegmentsFetcher = (noCache?: boolean, decorator?: (promise: Promise<IResponse>) => Promise<IResponse>) => Promise<string[]>;
+export declare type IMySegmentsFetcher = (userMatchingKey: string, noCache?: boolean, decorator?: (promise: Promise<IResponse>) => Promise<IResponse>) => Promise<string[]>;

package/types/sync/polling/pollingManagerCS.d.ts

@@ -1,10 +1,7 @@
 import { IPollingManagerCS } from './types';
-import { IReadinessManager } from '../../readiness/types';
-import { ISplitApi } from '../../services/types';
-import { IStorageSync } from '../../storages/types';
-import { ISettings } from '../../types';
+import { ISyncManagerFactoryParams } from '../types';
 /**
  * Expose start / stop mechanism for polling data from services.
  * For client-side API with multiple clients.
  */
-export declare function pollingManagerCSFactory(splitApi: ISplitApi, storage: IStorageSync, readiness: IReadinessManager, settings: ISettings): IPollingManagerCS;
+export declare function pollingManagerCSFactory(params: ISyncManagerFactoryParams): IPollingManagerCS;

package/types/sync/polling/pollingManagerSS.d.ts

@@ -1,9 +1,6 @@
-import { IStorageSync } from '../../storages/types';
-import { IReadinessManager } from '../../readiness/types';
-import { ISplitApi } from '../../services/types';
-import { ISettings } from '../../types';
 import { IPollingManager } from './types';
+import { ISyncManagerFactoryParams } from '../types';
 /**
  * Expose start / stop mechanism for pulling data from services.
  */
-export declare function pollingManagerSSFactory(splitApi: ISplitApi, storage: IStorageSync, readiness: IReadinessManager, settings: ISettings): IPollingManager;
+export declare function pollingManagerSSFactory(params: ISyncManagerFactoryParams): IPollingManager;

package/types/sync/polling/types.d.ts

@@ -1,7 +1,5 @@
 import { IReadinessManager } from '../../readiness/types';
-import { ISplitApi } from '../../services/types';
 import { IStorageSync } from '../../storages/types';
-import { ISettings } from '../../types';
 import { SegmentsData } from '../streaming/SSEHandler/types';
 import { ITask, ISyncTask } from '../types';
 export interface ISplitsSyncTask extends ISyncTask<[noCache?: boolean], boolean> {
@@ -21,12 +19,3 @@ export interface IPollingManagerCS extends IPollingManager {
     remove(matchingKey: string): void;
     get(matchingKey: string): ISegmentsSyncTask | undefined;
 }
-/**
- * Signature of polling manager factory/constructor
- */
-export declare type IPollingManagerFactoryParams = [
-    splitApi: ISplitApi,
-    storage: IStorageSync,
-    readiness: IReadinessManager,
-    settings: ISettings
-];

package/types/sync/polling/updaters/mySegmentsUpdater.d.ts

@@ -9,5 +9,5 @@ declare type IMySegmentsUpdater = (segmentList?: string[], noCache?: boolean) =>
  *  - updates `mySegmentsCache`
  *  - uses `segmentsEventEmitter` to emit events related to segments data updates
  */
-export declare function mySegmentsUpdaterFactory(log: ILogger, mySegmentsFetcher: IMySegmentsFetcher, splitsCache: ISplitsCacheSync, mySegmentsCache: ISegmentsCacheSync, segmentsEventEmitter: ISegmentsEventEmitter, requestTimeoutBeforeReady: number, retriesOnFailureBeforeReady: number): IMySegmentsUpdater;
+export declare function mySegmentsUpdaterFactory(log: ILogger, mySegmentsFetcher: IMySegmentsFetcher, splitsCache: ISplitsCacheSync, mySegmentsCache: ISegmentsCacheSync, segmentsEventEmitter: ISegmentsEventEmitter, requestTimeoutBeforeReady: number, retriesOnFailureBeforeReady: number, matchingKey: string): IMySegmentsUpdater;
 export {};

package/types/sync/streaming/UpdateWorkers/SegmentsUpdateWorker.d.ts

@@ -16,7 +16,7 @@ export declare class SegmentsUpdateWorker implements IUpdateWorker {
      * @param {Object} segmentsCache segments data cache
      * @param {Object} segmentsSyncTask task for syncing segments data
      */
-    constructor(segmentsCache: ISegmentsCacheSync, segmentsSyncTask: ISegmentsSyncTask);
+    constructor(segmentsSyncTask: ISegmentsSyncTask, segmentsCache: ISegmentsCacheSync);
     __handleSegmentUpdateCall(): void;
     /**
      * Invoked by NotificationProcessor on SEGMENT_UPDATE event

package/types/sync/streaming/pushManager.d.ts

@@ -1,13 +1,9 @@
-import { IPushManagerCS } from './types';
-import { IStorageSync } from '../../storages/types';
-import { IReadinessManager } from '../../readiness/types';
+import { IPushManager } from './types';
 import { IPollingManager } from '../polling/types';
-import { IFetchAuth } from '../../services/types';
-import { ISettings } from '../../types';
-import { IPlatform } from '../../sdkFactory/types';
+import { ISyncManagerFactoryParams } from '../types';
 /**
  * PushManager factory:
  * - for server-side if key is not provided in settings.
  * - for client-side, with support for multiple clients, if key is provided in settings
  */
-export declare function pushManagerFactory(pollingManager: IPollingManager, storage: IStorageSync, readiness: IReadinessManager, fetchAuth: IFetchAuth, platform: IPlatform, settings: ISettings): IPushManagerCS | undefined;
+export declare function pushManagerFactory(params: ISyncManagerFactoryParams, pollingManager: IPollingManager): IPushManager | undefined;

package/types/sync/streaming/pushManagerCS.d.ts

@@ -1,12 +1 @@
-import { IPushManagerCS } from './types';
-import { IStorageSync } from '../../storages/types';
-import { IReadinessManager } from '../../readiness/types';
-import { IPollingManager } from '../polling/types';
-import { IFetchAuth } from '../../services/types';
-import { ISettings } from '../../types';
-import { IPlatform } from '../../sdkFactory/types';
-/**
- * PushManager factory for client-side, with support for multiple clients.
- * It assumes settings contains a key.
- */
-export default function pushManagerCSFactory(pollingManager: IPollingManager, storage: IStorageSync, readiness: IReadinessManager, fetchAuth: IFetchAuth, platform: IPlatform, settings: ISettings): IPushManagerCS | undefined;
+export declare const pushManagerCSFactory: (params: import("../types").ISyncManagerFactoryParams, pollingManager: import("../polling/types").IPollingManager) => import("./types").IPushManager | undefined;

package/types/sync/streaming/pushManagerSS.d.ts

@@ -1,11 +1 @@
-import { IPushManager } from './types';
-import { IStorageSync } from '../../storages/types';
-import { IPollingManager } from '../polling/types';
-import { IReadinessManager } from '../../readiness/types';
-import { IFetchAuth } from '../../services/types';
-import { ISettings } from '../../types';
-import { IPlatform } from '../../sdkFactory/types';
-/**
- * PushManager factory for server-side
- */
-export default function pushManagerSSFactory(pollingManager: IPollingManager, storage: IStorageSync, readiness: IReadinessManager, fetchAuth: IFetchAuth, platform: IPlatform, settings: ISettings): IPushManager | undefined;
+export declare const pushManagerSSFactory: (params: import("../types").ISyncManagerFactoryParams, pollingManager: import("../polling/types").IPollingManager) => import("./types").IPushManager | undefined;

package/types/sync/streaming/types.d.ts

@@ -1,11 +1,7 @@
 import { IMySegmentsUpdateData, IMySegmentsUpdateV2Data, ISegmentUpdateData, ISplitUpdateData, ISplitKillData } from './SSEHandler/types';
 import { ITask } from '../types';
-import { IPollingManager, ISegmentsSyncTask } from '../polling/types';
-import { IReadinessManager } from '../../readiness/types';
-import { IFetchAuth } from '../../services/types';
-import { IStorageSync } from '../../storages/types';
-import { IEventEmitter, ISettings } from '../../types';
-import { IPlatform } from '../../sdkFactory/types';
+import { ISegmentsSyncTask } from '../polling/types';
+import { IEventEmitter } from '../../types';
 import { ControlType } from './constants';
 export declare type PUSH_SUBSYSTEM_UP = 'PUSH_SUBSYSTEM_UP';
 export declare type PUSH_SUBSYSTEM_DOWN = 'PUSH_SUBSYSTEM_DOWN';
@@ -30,26 +26,10 @@ export interface IPushEventEmitter extends IEventEmitter {
     emit<T extends IPushEvent>(event: T, parsedData?: IParsedData<T>, channel?: T extends MY_SEGMENTS_UPDATE ? string : undefined): boolean;
 }
 /**
- * PushManager for server-side
+ * PushManager
  */
 export interface IPushManager extends ITask, IPushEventEmitter {
-}
-/**
- * PushManager for client-side with support for multiple clients
- */
-export interface IPushManagerCS extends IPushManager {
     add(userKey: string, mySegmentsSyncTask: ISegmentsSyncTask): void;
     remove(userKey: string): void;
 }
-/**
- * Signature of push manager factory/constructor
- */
-export declare type IPushManagerFactoryParams = [
-    pollingManager: IPollingManager,
-    storage: IStorageSync,
-    readiness: IReadinessManager,
-    fetchAuth: IFetchAuth,
-    platform: IPlatform,
-    settings: ISettings
-];
 export {};

package/types/sync/submitters/submitterManager.d.ts

@@ -1,4 +1,2 @@
-import { ISplitApi } from '../../services/types';
-import { IStorageSync } from '../../storages/types';
-import { ISettings } from '../../types';
-export declare function submitterManagerFactory(settings: ISettings, storage: IStorageSync, splitApi: ISplitApi): import("../types").ISyncTask<[], any>;
+import { ISyncManagerFactoryParams } from '../types';
+export declare function submitterManagerFactory(params: ISyncManagerFactoryParams): import("../types").ISyncTask<[], any>;

package/types/sync/syncManagerOnline.d.ts

@@ -1,6 +1,6 @@
 import { ISyncManagerCS, ISyncManagerFactoryParams } from './types';
-import { IPushManagerFactoryParams, IPushManager } from './streaming/types';
-import { IPollingManager, IPollingManagerFactoryParams } from './polling/types';
+import { IPushManager } from './streaming/types';
+import { IPollingManager } from './polling/types';
 /**
  * Online SyncManager factory.
  * Can be used for server-side API, and client-side API with or without multiple clients.
@@ -9,4 +9,4 @@ import { IPollingManager, IPollingManagerFactoryParams } from './polling/types';
  * `pollingManagerSSFactory` or `pollingManagerCSFactory` respectively.
  * @param pushManagerFactory optional to build a SyncManager with or without streaming support
  */
-export declare function syncManagerOnlineFactory(pollingManagerFactory?: (...args: IPollingManagerFactoryParams) => IPollingManager, pushManagerFactory?: (...args: IPushManagerFactoryParams) => IPushManager | undefined): (params: ISyncManagerFactoryParams) => ISyncManagerCS;
+export declare function syncManagerOnlineFactory(pollingManagerFactory?: (params: ISyncManagerFactoryParams) => IPollingManager, pushManagerFactory?: (params: ISyncManagerFactoryParams, pollingManager: IPollingManager) => IPushManager | undefined): (params: ISyncManagerFactoryParams) => ISyncManagerCS;

package/types/sync/types.d.ts

@@ -3,6 +3,7 @@ import { IPlatform } from '../sdkFactory/types';
 import { ISplitApi } from '../services/types';
 import { IStorageSync } from '../storages/types';
 import { ISettings } from '../types';
+import { IPollingManager } from './polling/types';
 import { IPushManager } from './streaming/types';
 export interface ITask<Input extends any[] = []> {
     /**
@@ -39,6 +40,8 @@ export interface ITimeTracker {
 export interface ISyncManager extends ITask {
     flush(): Promise<any>;
     pushManager?: IPushManager;
+    pollingManager?: IPollingManager;
+    submitter?: ISyncTask;
 }
 export interface ISyncManagerCS extends ISyncManager {
     shared(matchingKey: string, readinessManager: IReadinessManager, storage: IStorageSync): ISyncManager | undefined;

package/types/trackers/eventTracker.d.ts

@@ -1,10 +1,10 @@
 import { IEventsCacheBase } from '../storages/types';
 import { IEventsHandler, IEventTracker } from './types';
-import { ILogger } from '../logger/types';
+import { ISettings } from '../types';
 /**
  * Event tracker stores events in cache and pass them to the integrations manager if provided.
  *
  * @param eventsCache cache to save events
  * @param integrationsManager optional event handler used for integrations
  */
-export declare function eventTrackerFactory(log: ILogger, eventsCache: IEventsCacheBase, integrationsManager?: IEventsHandler): IEventTracker;
+export declare function eventTrackerFactory(settings: ISettings, eventsCache: IEventsCacheBase, integrationsManager?: IEventsHandler): IEventTracker;

package/types/trackers/impressionObserver/utils.d.ts

@@ -7,3 +7,7 @@ export declare function shouldAddPt(settings: ISettings): boolean;
  * Checks if it should dedupe impressions or not.
  */
 export declare function shouldBeOptimized(settings: ISettings): boolean;
+/**
+ * Storage is async if mode is consumer or partial consumer
+ */
+export declare function isStorageSync(settings: ISettings): boolean;

package/types/trackers/impressionsTracker.d.ts

@@ -1,8 +1,7 @@
 import { IImpressionCountsCacheSync, IImpressionsCacheBase } from '../storages/types';
 import { IImpressionsHandler, IImpressionsTracker } from './types';
-import { SplitIO, ISettings } from '../types';
+import { ISettings } from '../types';
 import { IImpressionObserver } from './impressionObserver/types';
-import { ILogger } from '../logger/types';
 /**
  * Impressions tracker stores impressions in cache and pass them to the listener and integrations manager if provided.
  *
@@ -13,4 +12,4 @@ import { ILogger } from '../logger/types';
  * @param observer optional impression observer. If provided, previous time (pt property) is included in impression instances
  * @param countsCache optional cache to save impressions count. If provided, impressions will be deduped (OPTIMIZED mode)
  */
-export declare function impressionsTrackerFactory(log: ILogger, impressionsCache: IImpressionsCacheBase, { runtime: { ip, hostname }, version }: Pick<ISettings, 'version' | 'runtime'>, impressionListener?: SplitIO.IImpressionListener, integrationsManager?: IImpressionsHandler, observer?: IImpressionObserver, countsCache?: IImpressionCountsCacheSync): IImpressionsTracker;
+export declare function impressionsTrackerFactory(settings: ISettings, impressionsCache: IImpressionsCacheBase, integrationsManager?: IImpressionsHandler, observer?: IImpressionObserver, countsCache?: IImpressionCountsCacheSync): IImpressionsTracker;

package/types/types.d.ts

@@ -48,6 +48,11 @@ declare type EventConsts = {
  * @typedef {string} SDKMode
  */
 export declare type SDKMode = 'standalone' | 'consumer' | 'localhost' | 'consumer_partial';
+/**
+ * User consent status.
+ * @typedef {string} ConsentStatus
+ */
+export declare type ConsentStatus = 'GRANTED' | 'DECLINED' | 'UNKNOWN';
 /**
  * Settings interface. This is a representation of the settings the SDK expose, that's why
  * most of it's props are readonly. Only features should be rewritten when localhost mode is active.
@@ -67,6 +72,7 @@ export interface ISettings {
     readonly scheduler: {
         featuresRefreshRate: number;
         impressionsRefreshRate: number;
+        impressionsQueueSize: number;
         metricsRefreshRate: number;
         segmentsRefreshRate: number;
         offlineRefreshRate: number;
@@ -104,6 +110,7 @@ export interface ISettings {
     };
     readonly log: ILogger;
     readonly impressionListener?: unknown;
+    readonly userConsent?: ConsentStatus;
 }
 /**
  * Log levels.
@@ -249,6 +256,13 @@ interface INodeBasicSettings extends ISharedSettings {
          * @default 300
          */
         impressionsRefreshRate?: number;
+        /**
+         * The maximum number of impression items we want to queue. If we queue more values, it will trigger a flush and reset the timer.
+         * If you use a 0 here, the queue will have no maximum size.
+         * @property {number} impressionsQueueSize
+         * @default 30000
+         */
+        impressionsQueueSize?: number;
         /**
          * The SDK sends diagnostic metrics to Split servers. This parameters controls this metric flush period in seconds.
          * @property {number} metricsRefreshRate
@@ -375,7 +389,7 @@ interface IBasicClient extends IStatusInterface {
      * @returns {Promise<void>}
      */
     destroy(): Promise<void>;
-    isBrowserClient: boolean;
+    isClientSide: boolean;
 }
 /**
  * Common definitions between SDK instances for different environments interface.
@@ -766,6 +780,13 @@ export declare namespace SplitIO {
              * @default 60
              */
             impressionsRefreshRate?: number;
+            /**
+             * The maximum number of impression items we want to queue. If we queue more values, it will trigger a flush and reset the timer.
+             * If you use a 0 here, the queue will have no maximum size.
+             * @property {number} impressionsQueueSize
+             * @default 30000
+             */
+            impressionsQueueSize?: number;
             /**
              * The SDK sends diagnostic metrics to Split servers. This parameters controls this metric flush period in seconds.
              * @property {number} metricsRefreshRate

package/types/utils/consent.d.ts

@@ -0,0 +1,2 @@
+import { ISettings } from '../types';
+export declare function isConsentGranted(settings: ISettings): boolean;

package/types/utils/constants/index.d.ts

@@ -20,3 +20,6 @@ export declare const STORAGE_MEMORY: StorageType;
 export declare const STORAGE_LOCALSTORAGE: StorageType;
 export declare const STORAGE_REDIS: StorageType;
 export declare const STORAGE_PLUGGABLE: StorageType;
+export declare const CONSENT_GRANTED = "GRANTED";
+export declare const CONSENT_DECLINED = "DECLINED";
+export declare const CONSENT_UNKNOWN = "UNKNOWN";

package/types/utils/lang/index.d.ts

@@ -55,13 +55,18 @@ export declare function isIntegerNumber(val: any): boolean;
  */
 export declare function isNaNNumber(val: any): boolean;
 /**
- * Validates if a value is an object with the Object prototype (map object).
+ * Validates if a value is an object created by the Object constructor (plain object).
+ * It checks `constructor.name` to avoid false negatives when validating values on a separate VM context, which has its own global built-ins.
  */
 export declare function isObject(obj: any): boolean;
 /**
  * Checks if a given value is a string.
  */
 export declare function isString(val: any): val is string;
+/**
+ * String sanitizer. Returns the provided value converted to uppercase if it is a string.
+ */
+export declare function stringToUpperCase(val: any): any;
 /**
  * Deep copy version of Object.assign using recursion.
  * There are some assumptions here. It's for internal use and we don't need verbose errors
@@ -72,10 +77,6 @@ export declare function merge(target: {
 }, source: {
     [key: string]: any;
 }, ...rest: any[]): object;
-/**
- * Shallow clone an object
- */
-export declare function shallowClone(obj: any): any;
 /**
  * Checks if the target string starts with the sub string.
  */

package/types/utils/lang/maps.d.ts

@@ -44,5 +44,12 @@ interface IMapConstructor {
     new <K, V>(entries?: readonly (readonly [K, V])[] | null): IMap<K, V>;
     readonly prototype: IMap<any, any>;
 }
+/**
+ * return the Map constructor to use. If native Map is not available or it doesn't support the required features (e.g., IE11),
+ * a ponyfill with minimal features is returned instead.
+ *
+ * Exported for testing purposes only.
+ */
+export declare function __getMapConstructor(): IMapConstructor;
 export declare const _Map: IMapConstructor;
 export {};

package/types/utils/settingsValidation/consent.d.ts

@@ -0,0 +1,6 @@
+import { ILogger } from '../../logger/types';
+import { ConsentStatus } from '../../types';
+export declare function validateConsent({ userConsent, log }: {
+    userConsent?: any;
+    log: ILogger;
+}): ConsentStatus;

package/types/utils/settingsValidation/impressionsMode.d.ts

@@ -1,3 +1,3 @@
 import { ILogger } from '../../logger/types';
 import { SplitIO } from '../../types';
-export declare function validImpressionsMode(log: ILogger, impressionsMode: string): SplitIO.ImpressionsMode;
+export declare function validImpressionsMode(log: ILogger, impressionsMode: any): SplitIO.ImpressionsMode;

package/types/utils/settingsValidation/runtime/browser.d.ts

@@ -0,0 +1,2 @@
+import { ISettings } from '../../../types';
+export declare function validateRuntime(): ISettings['runtime'];

package/types/utils/settingsValidation/runtime/node.d.ts

@@ -0,0 +1,2 @@
+import { ISettings } from '../../../types';
+export declare function validateRuntime(settings: ISettings): ISettings['runtime'];

package/types/utils/settingsValidation/runtime.d.ts

@@ -0,0 +1,2 @@
+import { ISettings } from '../../types';
+export declare function validateRuntime(): ISettings['runtime'];

package/types/utils/settingsValidation/types.d.ts

@@ -5,22 +5,28 @@ import { ISettings } from '../../types';
  */
 export interface ISettingsValidationParams {
     /**
-     * Object of values to overwrite default settings.
-     * Version and startup properties are mandatory, because these values are not part of the base setting.
+     * Object of values to overwrite base settings.
+     * Version and startup properties are required, because they are not defined in the base settings.
      */
     defaults: Partial<ISettings> & {
         version: string;
     } & {
         startup: ISettings['startup'];
     };
-    /** Function to overwrite runtime values (ip and hostname) which are false by default */
-    runtime?: (settings: ISettings) => ISettings['runtime'];
-    /** Storage validator */
+    /** If true, validates core.key */
+    acceptKey?: boolean;
+    /** If true, validates core.trafficType */
+    acceptTT?: boolean;
+    /** Define runtime values (`settings.runtime`) */
+    runtime: (settings: ISettings) => ISettings['runtime'];
+    /** Storage validator (`settings.storage`) */
     storage?: (settings: ISettings) => ISettings['storage'];
-    /** Integrations validator */
+    /** Integrations validator (`settings.integrations`) */
     integrations?: (settings: ISettings) => ISettings['integrations'];
     /** Logger validator (`settings.debug`) */
     logger: (settings: ISettings) => ISettings['log'];
     /** Localhost mode validator (`settings.sync.localhostMode`) */
     localhost?: (settings: ISettings) => ISettings['sync']['localhostMode'];
+    /** User consent validator (`settings.userConsent`) */
+    consent: (settings: ISettings) => ISettings['userConsent'];
 }

package/types/utils/settingsValidation/userConsent.d.ts

@@ -0,0 +1,5 @@
+import { ILogger } from '../../logger/types';
+export declare function validateUserConsent({ userConsent, log }: {
+    userConsent: any;
+    log: ILogger;
+}): any;