@splitsoftware/splitio-commons 1.0.1-rc.0 → 1.0.1-rc.4

package/src/utils/MinEventEmitter.ts

@@ -18,7 +18,7 @@ export default class EventEmitter implements IEventEmitter {
     boolean // whether it is a one-time listener or not
   ]>> = {};
 
-  private registerListener(type: string, listener: (...args: any[]) => void, oneTime: boolean): EventEmitter {
+  private registerListener(type: string, listener: (...args: any[]) => void, oneTime: boolean) {
     checkListener(listener);
 
     // To avoid recursion in the case that type === "newListener" before
@@ -33,27 +33,27 @@ export default class EventEmitter implements IEventEmitter {
     return this;
   }
 
-  addListener(type: string, listener: (...args: any[]) => void): EventEmitter {
+  addListener(type: string, listener: (...args: any[]) => void) {
     return this.registerListener(type, listener, false);
   }
 
   // alias of addListener
-  on(type: string, listener: (...args: any[]) => void): EventEmitter {
+  on(type: string, listener: (...args: any[]) => void) {
     return this.addListener(type, listener);
   }
 
-  once(type: string, listener: (...args: any[]) => void): EventEmitter {
+  once(type: string, listener: (...args: any[]) => void) {
     return this.registerListener(type, listener, true);
   }
 
-  // eslint-disable-next-line
-  removeListener(type: string, listener: (...args: any[]) => void): EventEmitter {
+  // @ts-ignore
+  removeListener(/* type: string, listener: (...args: any[]) => void */) {
     throw new Error('Method not implemented.');
   }
 
-  // alias of removeListener
-  off(type: string, listener: (...args: any[]) => void): EventEmitter {
-    return this.removeListener(type, listener);
+  // @ts-ignore alias of removeListener
+  off(/* type: string, listener: (...args: any[]) => void */) {
+    return this.removeListener(/* type, listener */);
   }
 
   emit(type: string, ...args: any[]): boolean {
@@ -68,7 +68,7 @@ export default class EventEmitter implements IEventEmitter {
     return true;
   }
 
-  removeAllListeners(type?: string): EventEmitter {
+  removeAllListeners(type?: string) {
     if (!this.listeners[REMOVE_LISTENER_EVENT]) {
       // if not listening for `removeListener`, no need to emit
       if (type) {

package/src/utils/constants/index.ts

@@ -31,4 +31,4 @@ export const CONSUMER_PARTIAL_MODE: SDKMode = 'consumer_partial';
 export const STORAGE_MEMORY: StorageType = 'MEMORY';
 export const STORAGE_LOCALSTORAGE: StorageType = 'LOCALSTORAGE';
 export const STORAGE_REDIS: StorageType = 'REDIS';
-export const STORAGE_CUSTOM: StorageType = 'CUSTOM';
+export const STORAGE_PLUGGABLE: StorageType = 'PLUGGABLE';

package/src/utils/env/isNode.ts

@@ -1,3 +1,6 @@
-// We check for version truthiness since most shims will have that as empty string.
+/**
+ * 'true' if running in Node.js, or 'false' otherwise.
+ * We check for version truthiness since most shims will have that as empty string.
+ */
 // eslint-disable-next-line no-undef
 export const isNode: boolean = typeof process !== 'undefined' && typeof process.version !== 'undefined' && !!process.version ? true : false;

package/src/utils/settingsValidation/storage/storageCS.ts

@@ -1,8 +1,8 @@
 import { InMemoryStorageCSFactory } from '../../../storages/inMemory/InMemoryStorageCS';
 import { ISettings, SDKMode } from '../../../types';
 import { ILogger } from '../../../logger/types';
-import { WARN_STORAGE_INVALID } from '../../../logger/constants';
-import { LOCALHOST_MODE, STANDALONE_MODE, STORAGE_CUSTOM, STORAGE_LOCALSTORAGE, STORAGE_MEMORY } from '../../../utils/constants';
+import { ERROR_STORAGE_INVALID } from '../../../logger/constants';
+import { LOCALHOST_MODE, STANDALONE_MODE, STORAGE_PLUGGABLE, STORAGE_LOCALSTORAGE, STORAGE_MEMORY } from '../../../utils/constants';
 import { IStorageFactoryParams, IStorageSync } from '../../../storages/types';
 
 export function __InLocalStorageMockFactory(params: IStorageFactoryParams): IStorageSync {
@@ -17,15 +17,17 @@ __InLocalStorageMockFactory.type = STORAGE_MEMORY;
  *
  * @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.
+ * @returns {Object} valid storage factory. Default to `InMemoryStorageCSFactory` if the provided storage is invalid or not compatible with the sdk mode if mode is standalone or localhost
+ *
+ * @throws error if mode is consumer and the provided storage is not compatible
  */
 export function validateStorageCS(settings: { log: ILogger, storage?: any, mode: SDKMode }): ISettings['storage'] {
   let { storage = InMemoryStorageCSFactory, log, mode } = settings;
 
   // If an invalid storage is provided, fallback into MEMORY
-  if (typeof storage !== 'function' || [STORAGE_MEMORY, STORAGE_LOCALSTORAGE, STORAGE_CUSTOM].indexOf(storage.type) === -1) {
+  if (typeof storage !== 'function' || [STORAGE_MEMORY, STORAGE_LOCALSTORAGE, STORAGE_PLUGGABLE].indexOf(storage.type) === -1) {
     storage = InMemoryStorageCSFactory;
-    log.warn(WARN_STORAGE_INVALID);
+    log.error(ERROR_STORAGE_INVALID);
   }
 
   // In localhost mode with InLocalStorage, fallback to a mock InLocalStorage to emit SDK_READY_FROM_CACHE
@@ -33,13 +35,15 @@ export function validateStorageCS(settings: { log: ILogger, storage?: any, mode:
     return __InLocalStorageMockFactory;
   }
 
-  // @TODO check behaviour
   if ([LOCALHOST_MODE, STANDALONE_MODE].indexOf(mode) === -1) {
     // Consumer modes require an async storage
-    if (storage.type !== STORAGE_CUSTOM) throw new Error('A CustomStorage instance is required on consumer modes');
+    if (storage.type !== STORAGE_PLUGGABLE) throw new Error('A PluggableStorage instance is required on consumer mode');
   } else {
     // Standalone and localhost modes require a sync storage
-    if (storage.type === STORAGE_CUSTOM) throw new Error('A CustomStorage instance cannot be used on standalone and localhost modes');
+    if (storage.type === STORAGE_PLUGGABLE) {
+      storage = InMemoryStorageCSFactory;
+      log.error(ERROR_STORAGE_INVALID, [' It requires consumer mode.']);
+    }
   }
 
   // return default InMemory storage if provided one is not valid

package/types/logger/constants.d.ts

@@ -89,9 +89,8 @@ export declare const WARN_INTEGRATION_INVALID = 218;
 export declare const WARN_SPLITS_FILTER_IGNORED = 219;
 export declare const WARN_SPLITS_FILTER_INVALID = 220;
 export declare const WARN_SPLITS_FILTER_EMPTY = 221;
-export declare const WARN_STORAGE_INVALID = 222;
-export declare const WARN_API_KEY = 223;
-export declare const STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2 = 224;
+export declare const WARN_API_KEY = 222;
+export declare const STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2 = 223;
 export declare const ERROR_ENGINE_COMBINER_IFELSEIF = 300;
 export declare const ERROR_LOGLEVEL_INVALID = 301;
 export declare const ERROR_CLIENT_LISTENER = 302;
@@ -116,6 +115,7 @@ export declare const ERROR_EMPTY_ARRAY = 320;
 export declare const ERROR_INVALID_IMPRESSIONS_MODE = 321;
 export declare const ERROR_HTTP = 322;
 export declare const ERROR_LOCALHOST_MODULE_REQUIRED = 323;
+export declare const ERROR_STORAGE_INVALID = 324;
 export declare const LOG_PREFIX_SETTINGS = "settings";
 export declare const LOG_PREFIX_INSTANTIATION = "Factory instantiation";
 export declare const LOG_PREFIX_ENGINE = "engine";

package/types/sdkFactory/types.d.ts

@@ -3,7 +3,7 @@ import { ISignalListener } from '../listeners/types';
 import { ILogger } from '../logger/types';
 import { ISdkReadinessManager } from '../readiness/types';
 import { ISdkClientFactoryParams } from '../sdkClient/types';
-import { IFetch, ISplitApi } from '../services/types';
+import { IFetch, ISplitApi, IEventSourceConstructor } from '../services/types';
 import { IStorageAsync, IStorageSync, ISplitsCacheSync, ISplitsCacheAsync, IStorageFactoryParams } from '../storages/types';
 import { ISyncManager, ISyncManagerFactoryParams } from '../sync/types';
 import { IImpressionObserver } from '../trackers/impressionObserver/types';
@@ -15,7 +15,7 @@ import { SplitIO, ISettings, IEventEmitter } from '../types';
 export interface IPlatform {
     getOptions?: () => object;
     getFetch?: () => (IFetch | undefined);
-    getEventSource?: () => (typeof EventSource | undefined);
+    getEventSource?: () => (IEventSourceConstructor | undefined);
     EventEmitter: new () => IEventEmitter;
 }
 /**

package/types/services/splitApi.d.ts

@@ -7,4 +7,4 @@ import { ISplitApi } from './types';
  * @param settings validated settings object
  * @param platform object containing environment-specific `getFetch` and `getOptions` dependencies
  */
-export declare function splitApiFactory(settings: ISettings, platform: Pick<IPlatform, 'getFetch' | 'getOptions'>): ISplitApi;
+export declare function splitApiFactory(settings: Pick<ISettings, 'urls' | 'sync' | 'log' | 'version' | 'runtime' | 'core'>, platform: Pick<IPlatform, 'getFetch' | 'getOptions'>): ISplitApi;

package/types/services/types.d.ts

@@ -34,3 +34,14 @@ export interface ISplitApi {
     postMetricsCounters: IPostMetricsCounters;
     postMetricsTimes: IPostMetricsTimes;
 }
+interface EventSourceEventMap {
+    'error': Event;
+    'message': MessageEvent;
+    'open': Event;
+}
+interface IEventSource {
+    addEventListener<K extends keyof EventSourceEventMap>(type: K, listener: (this: IEventSource, ev: EventSourceEventMap[K]) => any): void;
+    close(): void;
+}
+export declare type IEventSourceConstructor = new (url: string, eventSourceInitDict?: any) => IEventSource;
+export {};

package/types/storages/pluggable/EventsCachePluggable.d.ts

@@ -1,4 +1,4 @@
-import { ICustomStorageWrapper, IEventsCacheAsync } from '../types';
+import { IPluggableStorageWrapper, IEventsCacheAsync } from '../types';
 import { IMetadata } from '../../dtos/types';
 import { SplitIO } from '../../types';
 import { ILogger } from '../../logger/types';
@@ -8,7 +8,7 @@ export declare class EventsCachePluggable implements IEventsCacheAsync {
     private readonly wrapper;
     private readonly key;
     private readonly metadata;
-    constructor(log: ILogger, key: string, wrapper: ICustomStorageWrapper, metadata: IMetadata);
+    constructor(log: ILogger, key: string, wrapper: IPluggableStorageWrapper, metadata: IMetadata);
     /**
      * Push given event to the storage.
      * @param eventData  Event item to push.

package/types/storages/pluggable/ImpressionsCachePluggable.d.ts

@@ -1,4 +1,4 @@
-import { ICustomStorageWrapper, IImpressionsCacheAsync } from '../types';
+import { IPluggableStorageWrapper, IImpressionsCacheAsync } from '../types';
 import { IMetadata } from '../../dtos/types';
 import { ImpressionDTO } from '../../types';
 import { ILogger } from '../../logger/types';
@@ -8,7 +8,7 @@ export declare class ImpressionsCachePluggable implements IImpressionsCacheAsync
     private readonly key;
     private readonly wrapper;
     private readonly metadata;
-    constructor(log: ILogger, key: string, wrapper: ICustomStorageWrapper, metadata: IMetadata);
+    constructor(log: ILogger, key: string, wrapper: IPluggableStorageWrapper, metadata: IMetadata);
     /**
      * Push given impressions to the storage.
      * @param impressions  List of impresions to push.

package/types/storages/pluggable/SegmentsCachePluggable.d.ts

@@ -1,5 +1,5 @@
 import KeyBuilderSS from '../KeyBuilderSS';
-import { ICustomStorageWrapper, ISegmentsCacheAsync } from '../types';
+import { IPluggableStorageWrapper, ISegmentsCacheAsync } from '../types';
 import { ILogger } from '../../logger/types';
 /**
  * ISegmentsCacheAsync implementation for pluggable storages.
@@ -8,7 +8,7 @@ export declare class SegmentsCachePluggable implements ISegmentsCacheAsync {
     private readonly log;
     private readonly keys;
     private readonly wrapper;
-    constructor(log: ILogger, keys: KeyBuilderSS, wrapper: ICustomStorageWrapper);
+    constructor(log: ILogger, keys: KeyBuilderSS, wrapper: IPluggableStorageWrapper);
     /**
      * Add a list of `segmentKeys` to the given segment `name`.
      * The returned promise is resolved when the operation success

package/types/storages/pluggable/SplitsCachePluggable.d.ts

@@ -1,5 +1,5 @@
 import KeyBuilder from '../KeyBuilder';
-import { ICustomStorageWrapper } from '../types';
+import { IPluggableStorageWrapper } from '../types';
 import { ILogger } from '../../logger/types';
 import AbstractSplitsCacheAsync from '../AbstractSplitsCacheAsync';
 /**
@@ -10,12 +10,12 @@ export declare class SplitsCachePluggable extends AbstractSplitsCacheAsync {
     private readonly keys;
     private readonly wrapper;
     /**
-     * Create a SplitsCache that uses a custom storage wrapper.
+     * Create a SplitsCache that uses a storage wrapper.
      * @param log  Logger instance.
      * @param keys  Key builder.
      * @param wrapper  Adapted wrapper storage.
      */
-    constructor(log: ILogger, keys: KeyBuilder, wrapper: ICustomStorageWrapper);
+    constructor(log: ILogger, keys: KeyBuilder, wrapper: IPluggableStorageWrapper);
     private _decrementCounts;
     private _incrementCounts;
     /**

package/types/storages/pluggable/constants.d.ts

@@ -1 +1 @@
-export declare const LOG_PREFIX = "storage:pluggable:";
+export declare const LOG_PREFIX = "storage:pluggable: ";

package/types/storages/pluggable/inMemoryWrapper.d.ts

@@ -1,13 +1,13 @@
-import { ICustomStorageWrapper } from '../types';
+import { IPluggableStorageWrapper } from '../types';
 import { ISet } from '../../utils/lang/sets';
 /**
- * Creates a ICustomStorageWrapper implementation that stores items in memory.
+ * Creates a IPluggableStorageWrapper implementation that stores items in memory.
  * The `_cache` property is the object were items are stored.
  * Intended for testing purposes.
  *
  * @param connDelay delay in millis for `connect` resolve. If not provided, `connect` resolves inmediatelly.
  */
-export declare function inMemoryWrapperFactory(connDelay?: number): ICustomStorageWrapper & {
+export declare function inMemoryWrapperFactory(connDelay?: number): IPluggableStorageWrapper & {
     _cache: Record<string, string | string[] | ISet<string>>;
     _setConnDelay(connDelay: number): void;
 };

package/types/storages/pluggable/index.d.ts

@@ -1,7 +1,7 @@
-import { ICustomStorageWrapper, IStorageAsyncFactory } from '../types';
+import { IPluggableStorageWrapper, IStorageAsyncFactory } from '../types';
 export interface PluggableStorageOptions {
     prefix?: string;
-    wrapper: ICustomStorageWrapper;
+    wrapper: IPluggableStorageWrapper;
 }
 /**
  * Pluggable storage factory for consumer server-side & client-side SplitFactory.

package/types/storages/pluggable/wrapperAdapter.d.ts

@@ -1,12 +1,12 @@
 import { ILogger } from '../../logger/types';
-import { ICustomStorageWrapper } from '../types';
+import { IPluggableStorageWrapper } from '../types';
 export declare const METHODS_TO_PROMISE_WRAP: string[];
 /**
- * Adapter of the Custom Storage Wrapper.
+ * Adapter of the Pluggable Storage Wrapper.
  * Used to handle exceptions as rejected promises, in order to simplify the error handling on storages.
  *
  * @param log logger instance
- * @param wrapper custom storage wrapper to adapt
+ * @param wrapper storage wrapper to adapt
  * @returns an adapted version of the given storage wrapper
  */
-export declare function wrapperAdapter(log: ILogger, wrapper: ICustomStorageWrapper): ICustomStorageWrapper;
+export declare function wrapperAdapter(log: ILogger, wrapper: IPluggableStorageWrapper): IPluggableStorageWrapper;

package/types/storages/types.d.ts

@@ -3,9 +3,9 @@ import { ILogger } from '../logger/types';
 import { StoredEventWithMetadata, StoredImpressionWithMetadata } from '../sync/submitters/types';
 import { SplitIO, ImpressionDTO, SDKMode } from '../types';
 /**
- * Interface of a custom storage wrapper.
+ * Interface of a pluggable storage wrapper.
  */
-export interface ICustomStorageWrapper {
+export interface IPluggableStorageWrapper {
     /** Key-Value operations */
     /**
      * Get the value of given `key`.
@@ -166,15 +166,15 @@ export interface ICustomStorageWrapper {
      */
     connect: () => Promise<void>;
     /**
-     * Disconnects the underlying storage.
+     * Disconnects from the underlying storage.
      * It is meant for storages that requires to be closed, in order to release resources. Otherwise it can just return a resolved promise.
      * Note: will be called once on SplitFactory main client destroy.
      *
-     * @function close
+     * @function disconnect
      * @returns {Promise<void>} A promise that resolves when the operation ends.
      * The promise never rejects.
      */
-    close: () => Promise<void>;
+    disconnect: () => Promise<void>;
 }
 /** Splits cache */
 export interface ISplitsCacheBase {
@@ -343,7 +343,7 @@ export interface IStorageFactoryParams {
     onReadyCb: (error?: any) => void;
     metadata: IMetadata;
 }
-export declare type StorageType = 'MEMORY' | 'LOCALSTORAGE' | 'REDIS' | 'CUSTOM';
+export declare type StorageType = 'MEMORY' | 'LOCALSTORAGE' | 'REDIS' | 'PLUGGABLE';
 export declare type IStorageSyncFactory = {
     type: StorageType;
     (params: IStorageFactoryParams): IStorageSync;

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

@@ -1,3 +1,4 @@
+import { IEventSourceConstructor } from '../../../services/types';
 import { ISettings } from '../../../types';
 import { IAuthTokenPushEnabled } from '../AuthClient/types';
 import { ISSEClient, ISseEventHandler } from './types';
@@ -5,9 +6,9 @@ import { ISSEClient, ISseEventHandler } from './types';
  * Handles streaming connections with EventSource API
  */
 export default class SSEClient implements ISSEClient {
-    eventSource: typeof EventSource;
+    eventSource?: IEventSourceConstructor;
     streamingUrl: string;
-    connection?: InstanceType<typeof EventSource>;
+    connection?: InstanceType<IEventSourceConstructor>;
     handler?: ISseEventHandler;
     useHeaders?: boolean;
     headers: Record<string, string>;
@@ -19,7 +20,7 @@ export default class SSEClient implements ISSEClient {
      * @param getEventSource Function to get the EventSource constructor.
      * @throws 'EventSource API is not available. ' if EventSource is not available.
      */
-    constructor(settings: ISettings, useHeaders?: boolean, getEventSource?: () => (typeof EventSource | undefined));
+    constructor(settings: ISettings, useHeaders?: boolean, getEventSource?: () => (IEventSourceConstructor | undefined));
     setEventHandler(handler: ISseEventHandler): void;
     /**
      * Open the connection with a given authToken

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

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

package/types/types.d.ts

@@ -1,19 +1,19 @@
-/// <reference types="node" />
 import { ISplitFiltersValidation } from './dtos/types';
 import { IIntegration, IIntegrationFactoryParams } from './integrations/types';
 import { ILogger } from './logger/types';
 import { IStorageFactoryParams, IStorageSync, IStorageAsync, IStorageSyncFactory, IStorageAsyncFactory } from './storages/types';
 import { ISyncManagerFactoryParams, ISyncManagerCS } from './sync/types';
 /**
- * EventEmitter interface with the minimal methods used by the SDK
+ * Reduced version of NodeJS.EventEmitter interface with the minimal methods used by the SDK
+ * @see {@link https://nodejs.org/api/events.html}
  */
-export interface IEventEmitter extends Pick<NodeJS.EventEmitter, 'addListener' | 'on' | 'once' | 'removeListener' | 'off' | 'removeAllListeners' | 'emit'> {
-    addListener(event: string, listener: (...args: any[]) => void): any;
-    on(event: string, listener: (...args: any[]) => void): any;
-    once(event: string, listener: (...args: any[]) => void): any;
-    removeListener(event: string, listener: (...args: any[]) => void): any;
-    off(event: string, listener: (...args: any[]) => void): any;
-    removeAllListeners(event?: string): any;
+export interface IEventEmitter {
+    addListener(event: string, listener: (...args: any[]) => void): this;
+    on(event: string, listener: (...args: any[]) => void): this;
+    once(event: string, listener: (...args: any[]) => void): this;
+    removeListener(event: string, listener: (...args: any[]) => void): this;
+    off(event: string, listener: (...args: any[]) => void): this;
+    removeAllListeners(event?: string): this;
     emit(event: string, ...args: any[]): boolean;
 }
 /**
@@ -88,7 +88,7 @@ export interface ISettings {
         auth: string;
         streaming: string;
     };
-    readonly debug: boolean | LogLevel;
+    readonly debug: boolean | LogLevel | ILogger;
     readonly version: string;
     features: SplitIO.MockedFeaturesFilePath | SplitIO.MockedFeaturesMap;
     readonly streamingEnabled: boolean;

package/types/utils/MinEventEmitter.d.ts

@@ -2,11 +2,11 @@ import { IEventEmitter } from '../types';
 export default class EventEmitter implements IEventEmitter {
     private listeners;
     private registerListener;
-    addListener(type: string, listener: (...args: any[]) => void): EventEmitter;
-    on(type: string, listener: (...args: any[]) => void): EventEmitter;
-    once(type: string, listener: (...args: any[]) => void): EventEmitter;
-    removeListener(type: string, listener: (...args: any[]) => void): EventEmitter;
-    off(type: string, listener: (...args: any[]) => void): EventEmitter;
+    addListener(type: string, listener: (...args: any[]) => void): this;
+    on(type: string, listener: (...args: any[]) => void): this;
+    once(type: string, listener: (...args: any[]) => void): this;
+    removeListener(): void;
+    off(): void;
     emit(type: string, ...args: any[]): boolean;
-    removeAllListeners(type?: string): EventEmitter;
+    removeAllListeners(type?: string): this;
 }

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

@@ -19,4 +19,4 @@ export declare const CONSUMER_PARTIAL_MODE: SDKMode;
 export declare const STORAGE_MEMORY: StorageType;
 export declare const STORAGE_LOCALSTORAGE: StorageType;
 export declare const STORAGE_REDIS: StorageType;
-export declare const STORAGE_CUSTOM: StorageType;
+export declare const STORAGE_PLUGGABLE: StorageType;

package/types/utils/env/isNode.d.ts

@@ -1 +1,5 @@
+/**
+ * 'true' if running in Node.js, or 'false' otherwise.
+ * We check for version truthiness since most shims will have that as empty string.
+ */
 export declare const isNode: boolean;

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

@@ -10,7 +10,9 @@ export declare namespace __InLocalStorageMockFactory {
  *
  * @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.
+ * @returns {Object} valid storage factory. Default to `InMemoryStorageCSFactory` if the provided storage is invalid or not compatible with the sdk mode if mode is standalone or localhost
+ *
+ * @throws error if mode is consumer and the provided storage is not compatible
  */
 export declare function validateStorageCS(settings: {
     log: ILogger;