@splitsoftware/splitio-commons 2.0.0-rc.4 → 2.0.0-rc.5

package/src/storages/inMemory/EventsCacheInMemory.ts

@@ -1,4 +1,4 @@
-import { SplitIO } from '../../types';
+import SplitIO from '../../../types/splitio';
 import { IEventsCacheSync } from '../types';
 
 const MAX_QUEUE_BYTE_SIZE = 5 * 1024 * 1024; // 5M
@@ -12,7 +12,7 @@ export class EventsCacheInMemory implements IEventsCacheSync {
 
   /**
    *
-   * @param eventsQueueSize number of queued events to call onFullQueueCb.
+   * @param eventsQueueSize - number of queued events to call onFullQueueCb.
    * Default value is 0, that means no maximum value, in case we want to avoid this being triggered.
    */
   constructor(eventsQueueSize: number = 0) {

package/src/storages/inMemory/ImpressionsCacheInMemory.ts

@@ -1,15 +1,15 @@
 import { IImpressionsCacheSync } from '../types';
-import { ImpressionDTO } from '../../types';
+import SplitIO from '../../../types/splitio';
 
 export class ImpressionsCacheInMemory implements IImpressionsCacheSync {
 
   private onFullQueue?: () => void;
   private readonly maxQueue: number;
-  private queue: ImpressionDTO[];
+  private queue: SplitIO.ImpressionDTO[];
 
   /**
    *
-   * @param impressionsQueueSize number of queued impressions to call onFullQueueCb.
+   * @param impressionsQueueSize - number of queued impressions to call onFullQueueCb.
    * Default value is 0, that means no maximum value, in case we want to avoid this being triggered.
    */
   constructor(impressionsQueueSize: number = 0) {
@@ -24,7 +24,7 @@ export class ImpressionsCacheInMemory implements IImpressionsCacheSync {
   /**
    * Store impressions in sequential order
    */
-  track(data: ImpressionDTO[]) {
+  track(data: SplitIO.ImpressionDTO[]) {
     this.queue.push(...data);
 
     // Check if the cache queue is full and we need to flush it.
@@ -43,7 +43,7 @@ export class ImpressionsCacheInMemory implements IImpressionsCacheSync {
   /**
    * Pop the collected data, used as payload for posting.
    */
-  pop(toMerge?: ImpressionDTO[]) {
+  pop(toMerge?: SplitIO.ImpressionDTO[]) {
     const data = this.queue;
     this.clear();
     return toMerge ? toMerge.concat(data) : data;

package/src/storages/inMemory/InMemoryStorage.ts

@@ -11,7 +11,7 @@ import { UniqueKeysCacheInMemory } from './UniqueKeysCacheInMemory';
 /**
  * InMemory storage factory for standalone server-side SplitFactory
  *
- * @param params parameters required by EventsCacheSync
+ * @param params - parameters required by EventsCacheSync
  */
 export function InMemoryStorageFactory(params: IStorageFactoryParams): IStorageSync {
   const { settings: { scheduler: { impressionsQueueSize, eventsQueueSize, }, sync: { impressionsMode, __splitFiltersValidation } } } = params;

package/src/storages/inMemory/InMemoryStorageCS.ts

@@ -11,7 +11,7 @@ import { UniqueKeysCacheInMemoryCS } from './UniqueKeysCacheInMemoryCS';
 /**
  * InMemory storage factory for standalone client-side SplitFactory
  *
- * @param params parameters required by EventsCacheSync
+ * @param params - parameters required by EventsCacheSync
  */
 export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorageSync {
   const { settings: { scheduler: { impressionsQueueSize, eventsQueueSize, }, sync: { impressionsMode, __splitFiltersValidation } } } = params;

package/src/storages/inMemory/UniqueKeysCacheInMemoryCS.ts

@@ -12,7 +12,7 @@ export class UniqueKeysCacheInMemoryCS implements IUniqueKeysCacheBase {
 
   /**
    *
-   * @param impressionsQueueSize number of queued impressions to call onFullQueueCb.
+   * @param impressionsQueueSize - number of queued impressions to call onFullQueueCb.
    * Default value is 0, that means no maximum value, in case we want to avoid this being triggered.
    */
   constructor(uniqueKeysQueueSize = DEFAULT_CACHE_SIZE) {

package/src/storages/inRedis/EventsCacheInRedis.ts

@@ -1,6 +1,6 @@
 import { IEventsCacheAsync } from '../types';
 import { IMetadata } from '../../dtos/types';
-import { SplitIO } from '../../types';
+import SplitIO from '../../../types/splitio';
 import { ILogger } from '../../logger/types';
 import { LOG_PREFIX } from './constants';
 import { StoredEventWithMetadata } from '../../sync/submitters/types';

package/src/storages/inRedis/ImpressionsCacheInRedis.ts

@@ -1,6 +1,6 @@
 import { IImpressionsCacheAsync } from '../types';
 import { IMetadata } from '../../dtos/types';
-import { ImpressionDTO } from '../../types';
+import SplitIO from '../../../types/splitio';
 import { StoredImpressionWithMetadata } from '../../sync/submitters/types';
 import { ILogger } from '../../logger/types';
 import { impressionsToJSON } from '../utils';
@@ -22,7 +22,7 @@ export class ImpressionsCacheInRedis implements IImpressionsCacheAsync {
     this.metadata = metadata;
   }
 
-  track(impressions: ImpressionDTO[]): Promise<void> { // @ts-ignore
+  track(impressions: SplitIO.ImpressionDTO[]): Promise<void> { // @ts-ignore
     return this.redis.rpush(
       this.key,
       impressionsToJSON(impressions, this.metadata),

package/src/storages/inRedis/SplitsCacheInRedis.ts

@@ -186,10 +186,8 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
    * Get list of all split definitions.
    * The returned promise is resolved with the list of split definitions,
    * or rejected if redis operation fails.
-   *
-   * @TODO we need to benchmark which is the maximun number of commands we could
-   *       pipeline without kill redis performance.
    */
+  // @TODO we need to benchmark which is the maximun number of commands we could pipeline without kill redis performance.
   getAll(): Promise<ISplit[]> {
     return this.redis.keys(this.keys.searchPatternForSplitKeys())
       .then((listOfKeys) => this.redis.pipeline(listOfKeys.map(k => ['get', k])).exec())

package/src/storages/inRedis/TelemetryCacheInRedis.ts

@@ -14,9 +14,9 @@ export class TelemetryCacheInRedis implements ITelemetryCacheAsync {
 
   /**
    * Create a Telemetry cache that uses Redis as storage.
-   * @param log  Logger instance.
-   * @param keys  Key builder.
-   * @param redis  Redis client.
+   * @param log -  Logger instance.
+   * @param keys -  Key builder.
+   * @param redis -  Redis client.
    */
   constructor(private readonly log: ILogger, private readonly keys: KeyBuilderSS, private readonly redis: RedisAdapter) { }
 

package/src/storages/inRedis/UniqueKeysCacheInRedis.ts

@@ -63,7 +63,7 @@ export class UniqueKeysCacheInRedis extends UniqueKeysCacheInMemory implements I
 
   /**
    * Async consumer API, used by synchronizer.
-   * @param count number of items to pop from the queue. If not provided or equal 0, all items will be popped.
+   * @param count - number of items to pop from the queue. If not provided or equal 0, all items will be popped.
    */
   popNRaw(count = 0): Promise<UniqueKeysItemSs[]> {
     return this.redis.lrange(this.key, 0, count - 1).then(uniqueKeyItems => {

package/src/storages/pluggable/EventsCachePluggable.ts

@@ -1,6 +1,6 @@
 import { IPluggableStorageWrapper, IEventsCacheAsync } from '../types';
 import { IMetadata } from '../../dtos/types';
-import { SplitIO } from '../../types';
+import SplitIO from '../../../types/splitio';
 import { ILogger } from '../../logger/types';
 import { LOG_PREFIX } from './constants';
 import { StoredEventWithMetadata } from '../../sync/submitters/types';
@@ -21,7 +21,7 @@ export class EventsCachePluggable implements IEventsCacheAsync {
 
   /**
    * Push given event to the storage.
-   * @param eventData  Event item to push.
+   * @param eventData -  Event item to push.
    * @returns  A promise that is resolved with a boolean value indicating if the push operation succeeded or failed.
    * Unlike `impressions::track`, The promise will never be rejected.
    */

package/src/storages/pluggable/ImpressionsCachePluggable.ts

@@ -1,6 +1,6 @@
 import { IPluggableStorageWrapper, IImpressionsCacheAsync } from '../types';
 import { IMetadata } from '../../dtos/types';
-import { ImpressionDTO } from '../../types';
+import SplitIO from '../../../types/splitio';
 import { StoredImpressionWithMetadata } from '../../sync/submitters/types';
 import { ILogger } from '../../logger/types';
 import { impressionsToJSON } from '../utils';
@@ -21,11 +21,11 @@ export class ImpressionsCachePluggable implements IImpressionsCacheAsync {
 
   /**
    * Push given impressions to the storage.
-   * @param impressions  List of impresions to push.
+   * @param impressions -  List of impresions to push.
    * @returns  A promise that is resolved if the push operation succeeded
    * or rejected if the wrapper operation fails.
    */
-  track(impressions: ImpressionDTO[]): Promise<void> {
+  track(impressions: SplitIO.ImpressionDTO[]): Promise<void> {
     return this.wrapper.pushItems(
       this.key,
       impressionsToJSON(impressions, this.metadata)

package/src/storages/pluggable/SegmentsCachePluggable.ts

@@ -83,7 +83,7 @@ export class SegmentsCachePluggable implements ISegmentsCacheAsync {
     return this.wrapper.getItems(this.keys.buildRegisteredSegmentsKey());
   }
 
-  /** @TODO implement if required by DataLoader or Producer mode  */
+  // @TODO implement if required by DataLoader or Producer mode
   clear(): Promise<boolean> {
     return Promise.resolve(true);
   }

package/src/storages/pluggable/SplitsCachePluggable.ts

@@ -19,9 +19,9 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
 
   /**
    * Create a SplitsCache that uses a storage wrapper.
-   * @param log  Logger instance.
-   * @param keys  Key builder.
-   * @param wrapper  Adapted wrapper storage.
+   * @param log -  Logger instance.
+   * @param keys -  Key builder.
+   * @param wrapper -  Adapted wrapper storage.
    */
   constructor(log: ILogger, keys: KeyBuilder, wrapper: IPluggableStorageWrapper, splitFiltersValidation?: ISplitFiltersValidation) {
     super();

package/src/storages/pluggable/TelemetryCachePluggable.ts

@@ -13,9 +13,9 @@ export class TelemetryCachePluggable implements ITelemetryCacheAsync {
 
   /**
    * Create a Telemetry cache that uses a storage wrapper.
-   * @param log  Logger instance.
-   * @param keys  Key builder.
-   * @param wrapper  Adapted wrapper storage.
+   * @param log -  Logger instance.
+   * @param keys -  Key builder.
+   * @param wrapper -  Adapted wrapper storage.
    */
   constructor(private readonly log: ILogger, private readonly keys: KeyBuilderSS, private readonly wrapper: IPluggableStorageWrapper) { }
 

package/src/storages/pluggable/UniqueKeysCachePluggable.ts

@@ -56,7 +56,7 @@ export class UniqueKeysCachePluggable extends UniqueKeysCacheInMemory implements
 
   /**
    * Async consumer API, used by synchronizer.
-   * @param count number of items to pop from the queue. If not provided or equal 0, all items will be popped.
+   * @param count - number of items to pop from the queue. If not provided or equal 0, all items will be popped.
    */
   popNRaw(count = 0): Promise<UniqueKeysItemSs[]> {
     return Promise.resolve(count || this.wrapper.getItemsCount(this.key))

package/src/storages/pluggable/inMemoryWrapper.ts

@@ -7,7 +7,7 @@ import { setToArray } from '../../utils/lang/sets';
  * 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 immediately.
+ * @param connDelay - delay in millis for `connect` resolve. If not provided, `connect` resolves immediately.
  */
 export function inMemoryWrapperFactory(connDelay?: number): IPluggableStorageWrapper & { _cache: Record<string, string | string[] | Set<string>>, _setConnDelay(connDelay: number): void } {
 

package/src/storages/pluggable/index.ts

@@ -32,7 +32,7 @@ export interface PluggableStorageOptions {
 /**
  * Validate pluggable storage factory options.
  *
- * @param options user options
+ * @param options - user options
  * @throws Will throw an error if the options are invalid. Example: wrapper is not provided or doesn't have some methods.
  */
 function validatePluggableStorageOptions(options: any) {

package/src/storages/pluggable/wrapperAdapter.ts

@@ -26,8 +26,8 @@ export const METHODS_TO_PROMISE_WRAP: string[] = [
  * 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 storage wrapper to adapt
+ * @param log - logger instance
+ * @param wrapper - storage wrapper to adapt
  * @returns an adapted version of the given storage wrapper
  */
 export function wrapperAdapter(log: ILogger, wrapper: IPluggableStorageWrapper): IPluggableStorageWrapper {

package/src/storages/types.ts

@@ -1,7 +1,8 @@
+import SplitIO from '../../types/splitio';
 import { MaybeThenable, ISplit, IMySegmentsResponse } from '../dtos/types';
 import { MySegmentsData } from '../sync/polling/types';
 import { EventDataType, HttpErrors, HttpLatencies, ImpressionDataType, LastSync, Method, MethodExceptions, MethodLatencies, MultiMethodExceptions, MultiMethodLatencies, MultiConfigs, OperationType, StoredEventWithMetadata, StoredImpressionWithMetadata, StreamingEvent, UniqueKeysPayloadCs, UniqueKeysPayloadSs, TelemetryUsageStatsPayload, UpdatesFromSSEEnum } from '../sync/submitters/types';
-import { SplitIO, ImpressionDTO, ISettings } from '../types';
+import { ISettings } from '../types';
 
 /**
  * Interface of a pluggable storage wrapper.
@@ -13,56 +14,50 @@ export interface IPluggableStorageWrapper {
   /**
    * Get the value of given `key`.
    *
-   * @function get
-   * @param {string} key Item to retrieve
-   * @returns {Promise<string | null>} A promise that resolves with the element value associated with the specified `key`,
+   * @param key - Item to retrieve
+   * @returns A promise that resolves with the element value associated with the specified `key`,
    * or null if the key does not exist. The promise rejects if the operation fails.
    */
   get: (key: string) => Promise<string | null>
   /**
    * Add or update an item with a specified `key` and `value`.
    *
-   * @function set
-   * @param {string} key Item to update
-   * @param {string} value Value to set
-   * @returns {Promise<void>} A promise that resolves if the operation success, whether the key was added or updated.
+   * @param key - Item to update
+   * @param value - Value to set
+   * @returns A promise that resolves if the operation success, whether the key was added or updated.
    * The promise rejects if the operation fails.
    */
   set: (key: string, value: string) => Promise<boolean | void>
   /**
    * Add or update an item with a specified `key` and `value`.
    *
-   * @function getAndSet
-   * @param {string} key Item to update
-   * @param {string} value Value to set
-   * @returns {Promise<string | null>} A promise that resolves with the previous value associated to the given `key`, or null if not set.
+   * @param key - Item to update
+   * @param value - Value to set
+   * @returns A promise that resolves with the previous value associated to the given `key`, or null if not set.
    * The promise rejects if the operation fails.
    */
   getAndSet: (key: string, value: string) => Promise<string | null>
   /**
    * Removes the specified item by `key`.
    *
-   * @function del
-   * @param {string} key Item to delete
-   * @returns {Promise<boolean>} A promise that resolves if the operation success, whether the key existed and was removed (resolves with true) or it didn't exist (resolves with false).
+   * @param key - Item to delete
+   * @returns A promise that resolves if the operation success, whether the key existed and was removed (resolves with true) or it didn't exist (resolves with false).
    * The promise rejects if the operation fails, for example, if there is a connection error.
    */
   del: (key: string) => Promise<boolean>
   /**
    * Returns all keys matching the given prefix.
    *
-   * @function getKeysByPrefix
-   * @param {string} prefix String prefix to match
-   * @returns {Promise<string[]>} A promise that resolves with the list of keys that match the given `prefix`.
+   * @param prefix - String prefix to match
+   * @returns A promise that resolves with the list of keys that match the given `prefix`.
    * The promise rejects if the operation fails.
    */
   getKeysByPrefix: (prefix: string) => Promise<string[]>
   /**
    * Returns the values of all given `keys`.
    *
-   * @function getMany
-   * @param {string[]} keys List of keys to retrieve
-   * @returns {Promise<(string | null)[]>} A promise that resolves with the list of items associated with the specified list of `keys`.
+   * @param keys - List of keys to retrieve
+   * @returns A promise that resolves with the list of items associated with the specified list of `keys`.
    * For every key that does not hold a string value or does not exist, null is returned. The promise rejects if the operation fails.
    */
   getMany: (keys: string[]) => Promise<(string | null)[]>
@@ -72,20 +67,18 @@ export interface IPluggableStorageWrapper {
   /**
    * Increments the number stored at `key` by `increment`, or set it to `increment` if the value doesn't exist.
    *
-   * @function incr
-   * @param {string} key Key to increment
-   * @param {number} increment Value to increment by. Defaults to 1.
-   * @returns {Promise<number>} A promise that resolves with the value of key after the increment. The promise rejects if the operation fails,
+   * @param key - Key to increment
+   * @param increment - Value to increment by. Defaults to 1.
+   * @returns A promise that resolves with the value of key after the increment. The promise rejects if the operation fails,
    * for example, if there is a connection error or the key contains a string that can not be represented as integer.
    */
   incr: (key: string, increment?: number) => Promise<number>
   /**
    * Decrements the number stored at `key` by `decrement`, or set it to minus `decrement` if the value doesn't exist.
    *
-   * @function decr
-   * @param {string} key Key to decrement
-   * @param {number} decrement Value to decrement by. Defaults to 1.
-   * @returns {Promise<number>} A promise that resolves with the value of key after the decrement. The promise rejects if the operation fails,
+   * @param key - Key to decrement
+   * @param decrement - Value to decrement by. Defaults to 1.
+   * @returns A promise that resolves with the value of key after the decrement. The promise rejects if the operation fails,
    * for example, if there is a connection error or the key contains a string that can not be represented as integer.
    */
   decr: (key: string, decrement?: number) => Promise<number>
@@ -95,29 +88,26 @@ export interface IPluggableStorageWrapper {
   /**
    * Inserts given items at the tail of `key` list. If `key` does not exist, an empty list is created before pushing the items.
    *
-   * @function pushItems
-   * @param {string} key List key
-   * @param {string[]} items List of items to push
-   * @returns {Promise<void>} A promise that resolves if the operation success.
+   * @param key - List key
+   * @param items - List of items to push
+   * @returns A promise that resolves if the operation success.
    * The promise rejects if the operation fails, for example, if there is a connection error or the key holds a value that is not a list.
    */
   pushItems: (key: string, items: string[]) => Promise<void>
   /**
    * Removes and returns the first `count` items from a list. If `key` does not exist, an empty list is items is returned.
    *
-   * @function popItems
-   * @param {string} key List key
-   * @param {number} count Number of items to pop
-   * @returns {Promise<string[]>} A promise that resolves with the list of removed items from the list, or an empty array when key does not exist.
+   * @param key - List key
+   * @param count - Number of items to pop
+   * @returns A promise that resolves with the list of removed items from the list, or an empty array when key does not exist.
    * The promise rejects if the operation fails, for example, if there is a connection error or the key holds a value that is not a list.
    */
   popItems: (key: string, count: number) => Promise<string[]>
   /**
    * Returns the count of items in a list, or 0 if `key` does not exist.
    *
-   * @function getItemsCount
-   * @param {string} key List key
-   * @returns {Promise<number>} A promise that resolves with the number of items at the `key` list, or 0 when `key` does not exist.
+   * @param key - List key
+   * @returns A promise that resolves with the number of items at the `key` list, or 0 when `key` does not exist.
    * The promise rejects if the operation fails, for example, if there is a connection error or the key holds a value that is not a list.
    */
   getItemsCount: (key: string) => Promise<number>
@@ -127,10 +117,9 @@ export interface IPluggableStorageWrapper {
   /**
    * Returns if item is a member of a set.
    *
-   * @function itemContains
-   * @param {string} key Set key
-   * @param {string} item Item value
-   * @returns {Promise<boolean>} A promise that resolves with true boolean value if `item` is a member of the set stored at `key`,
+   * @param key - Set key
+   * @param item - Item value
+   * @returns A promise that resolves with true boolean value if `item` is a member of the set stored at `key`,
    * or false if it is not a member or `key` set does not exist. The promise rejects if the operation fails, for example,
    * if there is a connection error or the key holds a value that is not a set.
    */
@@ -139,29 +128,26 @@ export interface IPluggableStorageWrapper {
    * Add the specified `items` to the set stored at `key`. Those items that are already part of the set are ignored.
    * If key does not exist, an empty set is created before adding the items.
    *
-   * @function addItems
-   * @param {string} key Set key
-   * @param {string} items Items to add
-   * @returns {Promise<boolean | void>} A promise that resolves if the operation success.
+   * @param key - Set key
+   * @param items - Items to add
+   * @returns A promise that resolves if the operation success.
    * The promise rejects if the operation fails, for example, if there is a connection error or the key holds a value that is not a set.
    */
   addItems: (key: string, items: string[]) => Promise<boolean | void>
   /**
    * Remove the specified `items` from the set stored at `key`. Those items that are not part of the set are ignored.
    *
-   * @function removeItems
-   * @param {string} key Set key
-   * @param {string} items Items to remove
-   * @returns {Promise<boolean | void>} A promise that resolves if the operation success. If key does not exist, the promise also resolves.
+   * @param key - Set key
+   * @param items - Items to remove
+   * @returns A promise that resolves if the operation success. If key does not exist, the promise also resolves.
    * The promise rejects if the operation fails, for example, if there is a connection error or the key holds a value that is not a set.
    */
   removeItems: (key: string, items: string[]) => Promise<boolean | void>
   /**
    * Returns all the items of the `key` set.
    *
-   * @function getItems
-   * @param {string} key Set key
-   * @returns {Promise<string[]>} A promise that resolves with the list of items. If key does not exist, the result is an empty list.
+   * @param key - Set key
+   * @returns A promise that resolves with the list of items. If key does not exist, the result is an empty list.
    * The promise rejects if the operation fails, for example, if there is a connection error or the key holds a value that is not a set.
    */
   getItems: (key: string) => Promise<string[]>
@@ -173,8 +159,7 @@ export interface IPluggableStorageWrapper {
    * It is meant for storages that requires to be connected to some database or server. Otherwise it can just return a resolved promise.
    * Note: will be called once on SplitFactory instantiation and once per each shared client instantiation.
    *
-   * @function connect
-   * @returns {Promise<void>} A promise that resolves when the wrapper successfully connect to the underlying storage.
+   * @returns A promise that resolves when the wrapper successfully connect to the underlying storage.
    * The promise rejects with the corresponding error if the wrapper fails to connect.
    */
   connect: () => Promise<void>
@@ -183,8 +168,7 @@ export interface IPluggableStorageWrapper {
    * 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 disconnect
-   * @returns {Promise<void>} A promise that resolves when the operation ends.
+   * @returns A promise that resolves when the operation ends.
    * The promise never rejects.
    */
   disconnect: () => Promise<void>
@@ -283,7 +267,7 @@ export interface ISegmentsCacheAsync extends ISegmentsCacheBase {
 
 export interface IImpressionsCacheBase {
   // Used by impressions tracker, in DEBUG and OPTIMIZED impression modes, to push impressions into the storage.
-  track(data: ImpressionDTO[]): MaybeThenable<void>
+  track(data: SplitIO.ImpressionDTO[]): MaybeThenable<void>
 }
 
 export interface IEventsCacheBase {
@@ -314,8 +298,8 @@ export interface IRecorderCacheSync<T> {
   pop(toMerge?: T): T
 }
 
-export interface IImpressionsCacheSync extends IImpressionsCacheBase, IRecorderCacheSync<ImpressionDTO[]> {
-  track(data: ImpressionDTO[]): void
+export interface IImpressionsCacheSync extends IImpressionsCacheBase, IRecorderCacheSync<SplitIO.ImpressionDTO[]> {
+  track(data: SplitIO.ImpressionDTO[]): void
   /* Registers callback for full queue */
   setOnFullQueueCb(cb: () => void): void
 }
@@ -348,7 +332,7 @@ export interface IRecorderCacheAsync<T> {
 export interface IImpressionsCacheAsync extends IImpressionsCacheBase, IRecorderCacheAsync<StoredImpressionWithMetadata[]> {
   // Consumer API method, used by impressions tracker (in standalone and consumer modes) to push data into.
   // The result promise can reject.
-  track(data: ImpressionDTO[]): Promise<void>
+  track(data: SplitIO.ImpressionDTO[]): Promise<void>
 }
 
 export interface IEventsCacheAsync extends IEventsCacheBase, IRecorderCacheAsync<StoredEventWithMetadata[]> {
@@ -499,14 +483,13 @@ export interface IStorageFactoryParams {
   onReadyCb: (error?: any) => void,
 }
 
-export type StorageType = 'MEMORY' | 'LOCALSTORAGE' | 'REDIS' | 'PLUGGABLE';
 
-export type IStorageSyncFactory = {
-  readonly type: StorageType,
+export type IStorageSyncFactory = SplitIO.StorageSyncFactory & {
+  readonly type: SplitIO.StorageType,
   (params: IStorageFactoryParams): IStorageSync
 }
 
-export type IStorageAsyncFactory = {
-  type: StorageType,
+export type IStorageAsyncFactory = SplitIO.StorageAsyncFactory & {
+  readonly type: SplitIO.StorageType,
   (params: IStorageFactoryParams): IStorageAsync
 }

package/src/storages/utils.ts

@@ -2,7 +2,8 @@
 
 import { IMetadata } from '../dtos/types';
 import { Method, StoredImpressionWithMetadata } from '../sync/submitters/types';
-import { ImpressionDTO, ISettings } from '../types';
+import { ISettings } from '../types';
+import SplitIO from '../../types/splitio';
 import { UNKNOWN } from '../utils/constants';
 import { MAX_LATENCY_BUCKET_COUNT } from './inMemory/TelemetryCacheInMemory';
 import { METHOD_NAMES } from './KeyBuilderSS';
@@ -16,7 +17,7 @@ export function metadataBuilder(settings: Pick<ISettings, 'version' | 'runtime'>
 }
 
 // Converts impressions to be stored in Redis or pluggable storage.
-export function impressionsToJSON(impressions: ImpressionDTO[], metadata: IMetadata): string[] {
+export function impressionsToJSON(impressions: SplitIO.ImpressionDTO[], metadata: IMetadata): string[] {
   return impressions.map(impression => {
     const impressionWithMetadata: StoredImpressionWithMetadata = {
       m: metadata,

package/src/sync/offline/splitsParser/splitsParserFromSettings.ts

@@ -1,5 +1,5 @@
 import { ISplitPartial } from '../../../dtos/types';
-import { ISettings, SplitIO } from '../../../types';
+import SplitIO from '../../../../types/splitio';
 import { isObject, forOwn, merge } from '../../../utils/lang';
 import { parseCondition } from './parseCondition';
 
@@ -39,9 +39,9 @@ export function splitsParserFromSettingsFactory() {
 
   /**
    *
-   * @param settings validated object with mocked features mapping.
+   * @param settings - validated object with mocked features mapping.
    */
-  return function splitsParserFromSettings(settings: Pick<ISettings, 'features'>): false | Record<string, ISplitPartial> {
+  return function splitsParserFromSettings(settings: Pick<SplitIO.ISettings, 'features'>): false | Record<string, ISplitPartial> {
     const features = settings.features as SplitIO.MockedFeaturesMap || {};
 
     if (!mockUpdated(features)) return false;

package/src/sync/offline/syncManagerOffline.ts

@@ -14,7 +14,7 @@ function flush() {
  * Offline SyncManager factory.
  * Can be used for server-side API, and client-side API with or without multiple clients.
  *
- * @param splitsParser e.g., `splitsParserFromFile`, `splitsParserFromSettings`.
+ * @param splitsParser - e.g., `splitsParserFromFile`, `splitsParserFromSettings`.
  */
 export function syncManagerOfflineFactory(
   splitsParserFactory: () => ISplitsParser

package/src/sync/polling/updaters/mySegmentsUpdater.ts

@@ -87,12 +87,12 @@ export function mySegmentsUpdaterFactory(
    * MySegments updater returns a promise that resolves with a `false` boolean value if it fails to fetch mySegments or synchronize them with the storage.
    * Returned promise will not be rejected.
    *
-   * @param {SegmentsData | undefined} segmentsData it can be:
+   * @param segmentsData - it can be:
    *  (1) the list of mySegments names to sync in the storage,
    *  (2) an object with a segment name and action (true: add, or false: delete) to update the storage,
    *  (3) or `undefined`, for which the updater will fetch mySegments in order to sync the storage.
-   * @param {boolean | undefined} noCache true to revalidate data to fetch
-   * @param {boolean | undefined} till query param to bypass CDN requests
+   * @param noCache - true to revalidate data to fetch
+   * @param till - query param to bypass CDN requests
    */
   return function mySegmentsUpdater(segmentsData?: MySegmentsData, noCache?: boolean, till?: number) {
     return _mySegmentsUpdater(0, segmentsData, noCache, till);

package/src/sync/polling/updaters/segmentChangesUpdater.ts

@@ -13,10 +13,10 @@ type ISegmentChangesUpdater = (fetchOnlyNew?: boolean, segmentName?: string, noC
  *  - updates `segmentsCache`
  *  - uses `segmentsEventEmitter` to emit events related to segments data updates
  *
- * @param log logger instance
- * @param segmentChangesFetcher fetcher of `/segmentChanges`
- * @param segments segments storage, with sync or async methods
- * @param readiness optional readiness manager. Not required for synchronizer or producer mode.
+ * @param log - logger instance
+ * @param segmentChangesFetcher - fetcher of `/segmentChanges`
+ * @param segments - segments storage, with sync or async methods
+ * @param readiness - optional readiness manager. Not required for synchronizer or producer mode.
  */
 export function segmentChangesUpdaterFactory(
   log: ILogger,
@@ -50,11 +50,11 @@ export function segmentChangesUpdaterFactory(
    * Thus, a false result doesn't imply that SDK_SEGMENTS_ARRIVED was not emitted.
    * Returned promise will not be rejected.
    *
-   * @param {boolean | undefined} fetchOnlyNew if true, only fetch the segments that not exists, i.e., which `changeNumber` is equal to -1.
+   * @param fetchOnlyNew - if true, only fetch the segments that not exists, i.e., which `changeNumber` is equal to -1.
    * This param is used by SplitUpdateWorker on server-side SDK, to fetch new registered segments on SPLIT_UPDATE notifications.
-   * @param {string | undefined} segmentName segment name to fetch. By passing `undefined` it fetches the list of segments registered at the storage
-   * @param {boolean | undefined} noCache true to revalidate data to fetch on a SEGMENT_UPDATE notifications.
-   * @param {number | undefined} till till target for the provided segmentName, for CDN bypass.
+   * @param segmentName - segment name to fetch. By passing `undefined` it fetches the list of segments registered at the storage
+   * @param noCache - true to revalidate data to fetch on a SEGMENT_UPDATE notifications.
+   * @param till - till target for the provided segmentName, for CDN bypass.
    */
   return function segmentChangesUpdater(fetchOnlyNew?: boolean, segmentName?: string, noCache?: boolean, till?: number) {
     log.debug(`${LOG_PREFIX_SYNC_SEGMENTS}Started segments update`);