@splitsoftware/splitio-commons 0.1.1-canary.6 → 0.1.1-rc.18

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

@@ -2,6 +2,7 @@ import { ISplitsEventEmitter } from '../../../readiness/types';
 import { ISplitsCacheSync } from '../../../storages/types';
 import Backoff from '../../../utils/Backoff';
 import { ISegmentsSyncTask, ISplitsSyncTask } from '../../polling/types';
+import { ISplitKillData, ISplitUpdateData } from '../SSEHandler/types';
 import { IUpdateWorker } from './types';
 /**
  * SplitsUpdateWorker class
@@ -26,7 +27,7 @@ export default class SplitsUpdateWorker implements IUpdateWorker {
      *
      * @param {number} changeNumber change number of the SPLIT_UPDATE notification
      */
-    put(changeNumber: number): void;
+    put({ changeNumber }: Pick<ISplitUpdateData, 'changeNumber'>): void;
     /**
      * Invoked by NotificationProcessor on SPLIT_KILL event
      *
@@ -34,5 +35,5 @@ export default class SplitsUpdateWorker implements IUpdateWorker {
      * @param {string} splitName name of split to kill
      * @param {string} defaultTreatment default treatment value
      */
-    killSplit(changeNumber: number, splitName: string, defaultTreatment: string): void;
+    killSplit({ changeNumber, splitName, defaultTreatment }: ISplitKillData): void;
 }

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

@@ -1,5 +1,5 @@
 import Backoff from '../../../utils/Backoff';
 export interface IUpdateWorker {
     readonly backoff: Backoff;
-    put(changeNumber: number, ...args: any[]): void;
+    put(...args: any[]): void;
 }

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

@@ -20,6 +20,7 @@ export declare const PUSH_SUBSYSTEM_UP = "PUSH_SUBSYSTEM_UP";
  */
 export declare const PUSH_SUBSYSTEM_DOWN = "PUSH_SUBSYSTEM_DOWN";
 export declare const MY_SEGMENTS_UPDATE = "MY_SEGMENTS_UPDATE";
+export declare const MY_SEGMENTS_UPDATE_V2 = "MY_SEGMENTS_UPDATE_V2";
 export declare const SEGMENT_UPDATE = "SEGMENT_UPDATE";
 export declare const SPLIT_KILL = "SPLIT_KILL";
 export declare const SPLIT_UPDATE = "SPLIT_UPDATE";
@@ -28,5 +29,6 @@ export declare const OCCUPANCY = "OCCUPANCY";
 export declare enum ControlType {
     STREAMING_DISABLED = "STREAMING_DISABLED",
     STREAMING_PAUSED = "STREAMING_PAUSED",
-    STREAMING_RESUMED = "STREAMING_RESUMED"
+    STREAMING_RESUMED = "STREAMING_RESUMED",
+    STREAMING_RESET = "STREAMING_RESET"
 }

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

@@ -0,0 +1,27 @@
+import { Compression, KeyList } from './SSEHandler/types';
+/**
+ * Decode, decompress and parse the provided 'data' into a KeyList object
+ *
+ * @param {string} data
+ * @param {number} compression
+ * @returns {{a?: string[], r?: string[] }}
+ * @throws if data string cannot be decoded, decompressed or parsed
+ */
+export declare function parseKeyList(data: string, compression: Compression): KeyList;
+/**
+ * Decode, decompress and parse the provided 'data' into a Bitmap object
+ *
+ * @param {string} data
+ * @param {number} compression
+ * @returns {Uint8Array}
+ * @throws if data string cannot be decoded or decompressed
+ */
+export declare function parseBitmap(data: string, compression: Compression): Uint8Array;
+/**
+ * Check if the 'bitmap' bit at 'hash64hex' position is 1
+ *
+ * @param {Uint8Array} bitmap
+ * @param {string} hash64hex 16-chars string, representing a number in hexa
+ * @returns {boolean}
+ */
+export declare function isInBitmap(bitmap: Uint8Array, hash64hex: string): boolean;

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

@@ -0,0 +1,13 @@
+import { IPushManagerCS } from './types';
+import { IStorageSync } from '../../storages/types';
+import { IReadinessManager } from '../../readiness/types';
+import { IPollingManager } from '../polling/types';
+import { IFetchAuthV2 } from '../../services/types';
+import { ISettings } from '../../types';
+import { IPlatform } from '../../sdkFactory/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 default function pushManagerFactory(pollingManager: IPollingManager, storage: IStorageSync, readiness: IReadinessManager, fetchAuthV2: IFetchAuthV2, platform: IPlatform, settings: ISettings): IPushManagerCS | undefined;

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

@@ -1,4 +1,4 @@
-import { IMySegmentsUpdateData } from './SSEHandler/types';
+import { IMySegmentsUpdateData, IMySegmentsUpdateV2Data, ISegmentUpdateData, ISplitUpdateData, ISplitKillData } from './SSEHandler/types';
 import { ITask } from '../types';
 import { IPollingManager, ISegmentsSyncTask } from '../polling/types';
 import { IReadinessManager } from '../../readiness/types';
@@ -6,25 +6,28 @@ import { IFetchAuth } from '../../services/types';
 import { IStorageSync } from '../../storages/types';
 import { IEventEmitter, ISettings } from '../../types';
 import { IPlatform } from '../../sdkFactory/types';
+import { ControlType } from './constants';
 export declare type PUSH_SUBSYSTEM_UP = 'PUSH_SUBSYSTEM_UP';
 export declare type PUSH_SUBSYSTEM_DOWN = 'PUSH_SUBSYSTEM_DOWN';
 export declare type PUSH_NONRETRYABLE_ERROR = 'PUSH_NONRETRYABLE_ERROR';
 export declare type PUSH_RETRYABLE_ERROR = 'PUSH_RETRYABLE_ERROR';
 export declare type MY_SEGMENTS_UPDATE = 'MY_SEGMENTS_UPDATE';
+export declare type MY_SEGMENTS_UPDATE_V2 = 'MY_SEGMENTS_UPDATE_V2';
 export declare type SEGMENT_UPDATE = 'SEGMENT_UPDATE';
 export declare type SPLIT_KILL = 'SPLIT_KILL';
 export declare type SPLIT_UPDATE = 'SPLIT_UPDATE';
 export declare type CONTROL = 'CONTROL';
 export declare type OCCUPANCY = 'OCCUPANCY';
-export declare type IPushEvent = PUSH_SUBSYSTEM_UP | PUSH_SUBSYSTEM_DOWN | PUSH_NONRETRYABLE_ERROR | PUSH_RETRYABLE_ERROR | MY_SEGMENTS_UPDATE | SEGMENT_UPDATE | SPLIT_UPDATE | SPLIT_KILL;
+export declare type IPushEvent = PUSH_SUBSYSTEM_UP | PUSH_SUBSYSTEM_DOWN | PUSH_NONRETRYABLE_ERROR | PUSH_RETRYABLE_ERROR | MY_SEGMENTS_UPDATE | MY_SEGMENTS_UPDATE_V2 | SEGMENT_UPDATE | SPLIT_UPDATE | SPLIT_KILL | ControlType.STREAMING_RESET;
+declare type IParsedData<T extends IPushEvent> = T extends MY_SEGMENTS_UPDATE ? IMySegmentsUpdateData : T extends MY_SEGMENTS_UPDATE_V2 ? IMySegmentsUpdateV2Data : T extends SEGMENT_UPDATE ? ISegmentUpdateData : T extends SPLIT_UPDATE ? ISplitUpdateData : T extends SPLIT_KILL ? ISplitKillData : undefined;
 /**
  * EventEmitter used as Feedback Loop between the SyncManager and PushManager,
  * where the latter pushes messages and the former consumes it
  */
 export interface IPushEventEmitter extends IEventEmitter {
-    once<T extends IPushEvent>(event: T, listener: (...args: T extends MY_SEGMENTS_UPDATE ? [parsedData: IMySegmentsUpdateData, channel: string] : T extends SEGMENT_UPDATE ? [changeNumber: number, segmentName: string] : T extends SPLIT_UPDATE ? [changeNumber: number] : T extends SPLIT_KILL ? [changeNumber: number, splitName: string, defaultTreatment: string] : any[]) => void): this;
-    on<T extends IPushEvent>(event: T, listener: (...args: T extends MY_SEGMENTS_UPDATE ? [parsedData: IMySegmentsUpdateData, channel: string] : T extends SEGMENT_UPDATE ? [changeNumber: number, segmentName: string] : T extends SPLIT_UPDATE ? [changeNumber: number] : T extends SPLIT_KILL ? [changeNumber: number, splitName: string, defaultTreatment: string] : any[]) => void): this;
-    emit<T extends IPushEvent>(event: T, ...args: T extends MY_SEGMENTS_UPDATE ? [parsedData: IMySegmentsUpdateData, channel: string] : T extends SEGMENT_UPDATE ? [changeNumber: number, segmentName: string] : T extends SPLIT_UPDATE ? [changeNumber: number] : T extends SPLIT_KILL ? [changeNumber: number, splitName: string, defaultTreatment: string] : any[]): boolean;
+    once<T extends IPushEvent>(event: T, listener: (parsedData: IParsedData<T>, channel: T extends MY_SEGMENTS_UPDATE ? string : undefined) => void): this;
+    on<T extends IPushEvent>(event: T, listener: (parsedData: IParsedData<T>, channel: T extends MY_SEGMENTS_UPDATE ? string : undefined) => void): this;
+    emit<T extends IPushEvent>(event: T, parsedData?: IParsedData<T>, channel?: T extends MY_SEGMENTS_UPDATE ? string : undefined): boolean;
 }
 /**
  * PushManager for server-side
@@ -49,3 +52,4 @@ export declare type IPushManagerFactoryParams = [
     platform: IPlatform,
     settings: ISettings
 ];
+export {};

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

@@ -7,4 +7,4 @@ import { IResponse } from '../../services/types';
  */
 export declare function submitterSyncTaskFactory<TState extends {
     length?: number;
-}>(log: ILogger, postClient: (body: string) => Promise<IResponse>, sourceCache: IRecorderCacheProducerSync<TState>, postRate: number, dataName: string, latencyTracker?: ITimeTracker, fromCacheToPayload?: (cacheData: TState) => any, maxRetries?: number): ISyncTask<[], void>;
+}>(log: ILogger, postClient: (body: string) => Promise<IResponse>, sourceCache: IRecorderCacheProducerSync<TState>, postRate: number, dataName: string, latencyTracker?: ITimeTracker, fromCacheToPayload?: (cacheData: TState) => any, maxRetries?: number, debugLogs?: boolean): ISyncTask<[], void>;

package/types/sync/syncManagerFromFile.d.ts

@@ -0,0 +1,2 @@
+import { SplitIO } from '../types';
+export declare function LocalhostFromFile(): SplitIO.LocalhostFactory;

package/types/sync/syncManagerFromObject.d.ts

@@ -0,0 +1,2 @@
+import { SplitIO } from '../types';
+export declare function LocalhostFromObject(): SplitIO.LocalhostFactory;

package/types/sync/syncManagerOffline.d.ts

@@ -6,4 +6,4 @@ import { ISplitsParser } from './offline/splitsParser/types';
  *
  * @param splitsParser e.g., `splitsParserFromFile`, `splitsParserFromSettings`.
  */
-export declare function syncManagerOfflineFactory(splitsParser: ISplitsParser): (params: ISyncManagerFactoryParams) => ISyncManagerCS;
+export declare function syncManagerOfflineFactory(splitsParserFactory: () => ISplitsParser): (params: ISyncManagerFactoryParams) => ISyncManagerCS;

package/types/sync/syncTask.d.ts

@@ -1,7 +1,7 @@
 import { ILogger } from '../logger/types';
 import { ISyncTask } from './types';
 /**
- * Creates a syncTask that handles the periodic execution of a givan task ("start" and "stop" methods).
+ * Creates a syncTask that handles the periodic execution of a given task ("start" and "stop" methods).
  * The task can be executed once calling the "execute" method.
  * NOTE: Multiple calls to "execute" are not queued. Use "isExecuting" method to handle synchronization.
  *

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 { IPushManager } from './streaming/types';
 export interface ITask<Input extends any[] = []> {
     /**
      * Start periodic execution of the task
@@ -37,6 +38,7 @@ export interface ITimeTracker {
 /** SyncManager */
 export interface ISyncManager extends ITask {
     flush(): Promise<any>;
+    pushManager?: IPushManager;
 }
 export interface ISyncManagerCS extends ISyncManager {
     shared(matchingKey: string, readinessManager: IReadinessManager, storage: IStorageSync): ISyncManager;

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

@@ -1,8 +1,8 @@
 import { ImpressionDTO } from '../../types';
 import { IImpressionObserver } from './types';
-export default class ImpressionObserver implements IImpressionObserver {
+export default class ImpressionObserver<K extends string | number> implements IImpressionObserver {
     private cache;
     private hasher;
-    constructor(size: number, hasher: (impression: ImpressionDTO) => string | null);
+    constructor(size: number, hasher: (impression: ImpressionDTO) => K);
     testAndSet(impression: ImpressionDTO): number | undefined;
 }

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

@@ -1,2 +1,2 @@
 import { ImpressionDTO } from '../../types';
-export default function buildKey(impression: ImpressionDTO): string;
+export declare function buildKey(impression: ImpressionDTO): string;

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

@@ -1,4 +1,4 @@
 import ImpressionObserver from './ImpressionObserver';
 import { ImpressionDTO } from '../../types';
-export declare function hashImpression32(impression: ImpressionDTO): string | null;
-export declare function impressionObserverCSFactory(): ImpressionObserver;
+export declare function hashImpression32(impression: ImpressionDTO): number;
+export declare function impressionObserverCSFactory(): ImpressionObserver<number>;

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

@@ -1,4 +1,4 @@
 import ImpressionObserver from './ImpressionObserver';
 import { ImpressionDTO } from '../../types';
-export declare function hashImpression128(impression: ImpressionDTO): string | null;
-export declare function impressionObserverSSFactory(): ImpressionObserver;
+export declare function hashImpression128(impression: ImpressionDTO): string;
+export declare function impressionObserverSSFactory(): ImpressionObserver<string>;

package/types/types.d.ts

@@ -1,7 +1,9 @@
 /// <reference types="node" />
+import { ISplitFiltersValidation } from './dtos/types';
 import { IIntegration, IIntegrationFactoryParams } from './integrations/types';
 import { ILogger } from './logger/types';
-import { IStorageFactoryParams, IStorageSyncCS, IStorageSync, IStorageAsync } from './storages/types';
+import { IStorageFactoryParams, IStorageSyncCS, IStorageSync, IStorageAsync, IStorageSyncFactory } from './storages/types';
+import { ISyncManagerFactoryParams, ISyncManagerCS } from './sync/types';
 /**
  * EventEmitter interface with the minimal methods used by the SDK
  */
@@ -50,6 +52,8 @@ export declare type SDKMode = 'standalone' | 'consumer' | 'localhost';
  * 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.
  * @interface ISettings
+ *
+ * NOTE: same ISettings interface from public type declarations extended with private properties.
  */
 export interface ISettings {
     readonly core: {
@@ -76,7 +80,7 @@ export interface ISettings {
         retriesOnFailureBeforeReady: number;
         eventsFirstPushWindow: number;
     };
-    readonly storage: (params: IStorageFactoryParams) => IStorageSyncCS;
+    readonly storage: IStorageSyncFactory;
     readonly integrations?: Array<(params: IIntegrationFactoryParams) => IIntegration | void>;
     readonly urls: {
         events: string;
@@ -91,12 +95,15 @@ export interface ISettings {
     readonly sync: {
         splitFilters: SplitIO.SplitFilter[];
         impressionsMode: SplitIO.ImpressionsMode;
+        __splitFiltersValidation: ISplitFiltersValidation;
+        localhostMode: SplitIO.LocalhostFactory;
     };
     readonly runtime: {
         ip: string | false;
         hostname: string | false;
     };
     readonly log: ILogger;
+    readonly impressionListener?: unknown;
 }
 /**
  * Log levels.
@@ -571,6 +578,13 @@ export declare namespace SplitIO {
      * @typedef {Promise<SplitNames>} SplitNamesAsync
      */
     type SplitNamesAsync = Promise<SplitNames>;
+    /**
+     * Localhost mode factory.
+     */
+    type LocalhostFactory = {
+        type?: 'localhost';
+        (params: ISyncManagerFactoryParams): ISyncManagerCS;
+    };
     /**
      * Impression listener interface. This is the interface that needs to be implemented
      * by the element you provide to the SDK as impression listener.

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

@@ -1,3 +1,4 @@
+import { StorageType } from '../../storages/types';
 export declare const CONTROL = "control";
 export declare const CONTROL_WITH_CONFIG: {
     treatment: string;
@@ -13,4 +14,7 @@ export declare const LOCALHOST_MODE = "localhost";
 export declare const STANDALONE_MODE = "standalone";
 export declare const PRODUCER_MODE = "producer";
 export declare const CONSUMER_MODE = "consumer";
-export declare const STORAGE_MEMORY = "MEMORY";
+export declare const STORAGE_MEMORY: StorageType;
+export declare const STORAGE_LOCALSTORAGE: StorageType;
+export declare const STORAGE_REDIS: StorageType;
+export declare const STORAGE_CUSTOM: StorageType;

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

@@ -0,0 +1,16 @@
+export declare const algorithms: string | {
+    /**
+     * Expands GZIP data
+     * @param data The data to decompress
+     * @param out Where to write the data. GZIP already encodes the output size, so providing this doesn't save memory.
+     * @returns The decompressed version of the data
+     */
+    gunzipSync(data: Uint8Array, out?: Uint8Array | undefined): Uint8Array;
+    /**
+     * Expands Zlib data
+     * @param data The data to decompress
+     * @param out Where to write the data. Saves memory if you know the decompressed size and provide an output buffer of that length.
+     * @returns The decompressed version of the data
+     */
+    unzlibSync(data: Uint8Array, out?: Uint8Array | undefined): Uint8Array;
+};

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

@@ -32,7 +32,7 @@ export declare function get(obj: any, prop: any, val: any): any;
 /**
  * Parses an array into a map of different arrays, grouping by the specified prop value.
  */
-export declare function groupBy(source: any, prop: string): Record<string, any[]>;
+export declare function groupBy<T extends Record<string, any>>(source: T[], prop: string): Record<string, T[]>;
 /**
  * Checks if a given value is a boolean.
  */

package/types/utils/murmur3/common.d.ts

@@ -0,0 +1,12 @@
+export declare function UTF16ToUTF8(key: string): string | undefined;
+/*!
+ * +----------------------------------------------------------------------------------+
+ * | murmurHash3.js v3.0.0 (http://github.com/karanlyons/murmurHash3.js)              |
+ * | A TypeScript/JavaScript implementation of MurmurHash3's hashing algorithms.      |
+ * |----------------------------------------------------------------------------------|
+ * | Copyright (c) 2012-2020 Karan Lyons. Freely distributable under the MIT license. |
+ * +----------------------------------------------------------------------------------+
+ */
+export declare function x86Multiply(m: number, n: number): number;
+export declare function x86Rotl(m: number, n: number): number;
+export declare function x86Fmix(h: number): number;

package/types/utils/murmur3/murmur3.d.ts

@@ -1,2 +1,2 @@
-export declare function hash(str?: string, seed?: number): number;
-export declare function bucket(str?: string, seed?: number): number;
+export declare function hash(str: string, seed?: number): number;
+export declare function bucket(str: string, seed?: number): number;

package/types/utils/murmur3/murmur3_128.d.ts

@@ -1 +1,6 @@
+/**
+ * x64 version of Murmur3 for 128bits.
+ *
+ * @param {string} str
+ */
 export declare function hash128(str: string, seed?: number): string;

package/types/utils/murmur3/murmur3_128_x86.d.ts

@@ -0,0 +1,7 @@
+/**
+ * x86 version of Murmur3 for 128bits.
+ * Used by hashImpression128 because in JS it is more efficient than the x64 version, no matter the underlying OS/CPU arch.
+ *
+ * @param {string} str
+ */
+export declare function hash128(str: string, seed?: number): string;

package/types/utils/murmur3/murmur3_64.d.ts

@@ -0,0 +1,10 @@
+export declare type Hash64 = {
+    hex: string;
+    dec: string;
+};
+/**
+ * Gets the higher 64 bits of the x64 version of Murmur3 for 128bits, as decimal and hexadecimal number strings.
+ * Used for MySegments channel V2 notifications.
+ * @param {string} str
+ */
+export declare function hash64(str: string): Hash64;

package/types/utils/murmur3/utfx.d.ts

@@ -1,9 +1,27 @@
 export interface utfx {
-    stringSource(key: string): () => number | null;
-    stringDestination(): (...args: number[]) => string | undefined;
     encodeUTF16toUTF8(src: () => number | null, dst: (...args: number[]) => string | undefined): void;
-    UTF16toUTF8(src: () => number | null, dst: (cp: number) => void): void;
-    encodeUTF8(src: (() => number | null) | number, dst: (cp: number) => void): void;
 }
-declare const _default: utfx;
-export default _default;
+/**
+ * Converts and encodes UTF16 characters to UTF8 bytes.
+ * @param {!function():number|null} src Characters source as a function returning the next char code respectively `null`
+ *  if there are no more characters left.
+ * @param {!function(number)} dst Bytes destination as a function successively called with the next byte.
+ * @expose
+ */
+export declare function encodeUTF16toUTF8(src: () => number | null, dst: (...args: number[]) => string | undefined): void;
+/**
+ * Creates a source function for a string.
+ * @param {string} s String to read from
+ * @returns {!function():number|null} Source function returning the next char code respectively `null` if there are
+ *  no more characters left.
+ * @throws {TypeError} If the argument is invalid
+ * @expose
+ */
+export declare function stringSource(s: string): () => number | null;
+/**
+ * Creates a destination function for a string.
+ * @returns {function(number=):undefined|string} Destination function successively called with the next char code.
+ *  Returns the final string when called without arguments.
+ * @expose
+ */
+export declare function stringDestination(): (...args: number[]) => string | undefined;

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

@@ -1,4 +1,5 @@
-import { ISettingsInternal, ISettingsValidationParams } from './types';
+import { ISettingsValidationParams } from './types';
+import { ISettings } from '../../types';
 /**
  * Validates the given config and use it to build a settings object.
  * NOTE: it doesn't validate the Api Key. Call `validateApikey` or `validateAndTrackApiKey` for that after settings validation.
@@ -6,4 +7,4 @@ import { ISettingsInternal, ISettingsValidationParams } from './types';
  * @param config user defined configuration
  * @param validationParams defaults and fields validators used to validate and creates a settings object from a given config
  */
-export declare function settingsValidation(config: unknown, validationParams: ISettingsValidationParams): ISettingsInternal;
+export declare function settingsValidation(config: unknown, validationParams: ISettingsValidationParams): ISettings;

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

@@ -0,0 +1,9 @@
+import { ISettings } from '../../../types';
+/**
+ * This function validates `settings.storage` object
+ *
+ * @param {any} settings config object provided by the user to initialize the sdk
+ *
+ * @returns {Object} valid storage factory. It might be the default `InMemoryStorageCSFactory` if the provided storage is invalid.
+ */
+export declare function validateLocalhost(settings: ISettings): import("../../../types").SplitIO.LocalhostFactory;

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

@@ -1,5 +1,10 @@
-import { ISettings } from '../../../types';
+import { ISettings, SDKMode } from '../../../types';
 import { ILogger } from '../../../logger/types';
+import { IStorageFactoryParams, IStorageSyncCS } from '../../../storages/types';
+export declare function __InLocalStorageMockFactory(params: IStorageFactoryParams): IStorageSyncCS;
+export declare namespace __InLocalStorageMockFactory {
+    var type: import("../../../storages/types").StorageType;
+}
 /**
  * This function validates `settings.storage` object
  *
@@ -10,4 +15,5 @@ import { ILogger } from '../../../logger/types';
 export declare function validateStorageCS(settings: {
     log: ILogger;
     storage?: any;
+    mode?: SDKMode;
 }): ISettings['storage'];

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

@@ -1,4 +1,3 @@
-import { ISplitFiltersValidation } from '../../dtos/types';
 import { ISettings } from '../../types';
 /**
  * Parameters used to specialize the settings validation for each API variant
@@ -22,13 +21,6 @@ export interface ISettingsValidationParams {
     integrations?: (settings: ISettings) => ISettings['integrations'];
     /** Logger validator */
     logger: (settings: ISettings) => ISettings['log'];
-}
-/**
- * Settings interface extended with private properties used for internal purposes.
- */
-export interface ISettingsInternal extends ISettings {
-    readonly sync: ISettings['sync'] & {
-        __splitFiltersValidation: ISplitFiltersValidation;
-    };
-    readonly impressionListener?: unknown;
+    /** Localhost mode validator */
+    localhost?: (settings: ISettings) => ISettings['sync']['localhostMode'];
 }