@splitsoftware/splitio-commons 1.6.2-rc.1 → 1.6.2-rc.11

package/types/storages/inRedis/SplitsCacheInRedis.d.ts

@@ -1,6 +1,7 @@
 import { KeyBuilderSS } from '../KeyBuilderSS';
 import { Redis } from 'ioredis';
 import { ILogger } from '../../logger/types';
+import { ISplit } from '../../dtos/types';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
 /**
  * ISplitsCacheAsync implementation that stores split definitions in Redis.
@@ -19,13 +20,13 @@ export declare class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
      * The returned promise is resolved when the operation success
      * or rejected if it fails (e.g., redis operation fails)
      */
-    addSplit(name: string, split: string): Promise<boolean>;
+    addSplit(name: string, split: ISplit): Promise<boolean>;
     /**
      * Add a list of splits.
      * The returned promise is resolved when the operation success
      * or rejected if it fails (e.g., redis operation fails)
      */
-    addSplits(entries: [string, string][]): Promise<boolean[]>;
+    addSplits(entries: [string, ISplit][]): Promise<boolean[]>;
     /**
      * Remove a given split.
      * The returned promise is resolved when the operation success, with 1 or 0 indicating if the split existed or not.
@@ -42,7 +43,7 @@ export declare class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
      * Get split definition or null if it's not defined.
      * Returned promise is rejected if redis operation fails.
      */
-    getSplit(name: string): Promise<string | null>;
+    getSplit(name: string): Promise<ISplit | null>;
     /**
      * Set till number.
      * The returned promise is resolved when the operation success,
@@ -63,7 +64,7 @@ export declare class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
      * @TODO we need to benchmark which is the maximun number of commands we could
      *       pipeline without kill redis performance.
      */
-    getAll(): Promise<string[]>;
+    getAll(): Promise<ISplit[]>;
     /**
      * Get list of split names.
      * The returned promise is resolved with the list of split names,
@@ -87,5 +88,5 @@ export declare class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
      * Fetches multiple splits definitions.
      * Returned promise is rejected if redis operation fails.
      */
-    getSplits(names: string[]): Promise<Record<string, string | null>>;
+    getSplits(names: string[]): Promise<Record<string, ISplit | null>>;
 }

package/types/storages/inRedis/TelemetryCacheInRedis.d.ts

@@ -1,5 +1,5 @@
 import { ILogger } from '../../logger/types';
-import { Method } from '../../sync/submitters/types';
+import { Method, MultiConfigs, MultiMethodExceptions, MultiMethodLatencies } from '../../sync/submitters/types';
 import { KeyBuilderSS } from '../KeyBuilderSS';
 import { ITelemetryCacheAsync } from '../types';
 import { Redis } from 'ioredis';
@@ -17,4 +17,19 @@ export declare class TelemetryCacheInRedis implements ITelemetryCacheAsync {
     recordLatency(method: Method, latencyMs: number): Promise<number | void>;
     recordException(method: Method): Promise<number | void>;
     recordConfig(): Promise<number | void>;
+    /**
+     * Pop telemetry latencies.
+     * The returned promise rejects if redis operations fail.
+     */
+    popLatencies(): Promise<MultiMethodLatencies>;
+    /**
+     * Pop telemetry exceptions.
+     * The returned promise rejects if redis operations fail.
+     */
+    popExceptions(): Promise<MultiMethodExceptions>;
+    /**
+     * Pop telemetry configs.
+     * The returned promise rejects if redis operations fail.
+     */
+    popConfigs(): Promise<MultiConfigs>;
 }

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

@@ -1 +1,4 @@
 export declare const LOG_PREFIX = "storage:redis: ";
+export declare const DEFAULT_CACHE_SIZE = 30000;
+export declare const REFRESH_RATE = 300000;
+export declare const TTL_REFRESH = 3600;

package/types/storages/inRedis/uniqueKeysCacheInRedis.d.ts

@@ -0,0 +1,21 @@
+import { IUniqueKeysCacheBase } from '../types';
+import { Redis } from 'ioredis';
+import { UniqueKeysCacheInMemory } from '../inMemory/UniqueKeysCacheInMemory';
+import { ILogger } from '../../logger/types';
+import { UniqueKeysItemSs } from '../../sync/submitters/types';
+export declare class UniqueKeysCacheInRedis extends UniqueKeysCacheInMemory implements IUniqueKeysCacheBase {
+    private readonly log;
+    private readonly key;
+    private readonly redis;
+    private readonly refreshRate;
+    private intervalId;
+    constructor(log: ILogger, key: string, redis: Redis, uniqueKeysQueueSize?: number, refreshRate?: number);
+    private postUniqueKeysInRedis;
+    start(): void;
+    stop(): Promise<boolean | import("ioredis").BooleanResponse | undefined>;
+    /**
+     * 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.
+     */
+    popNRaw(count?: number): Promise<UniqueKeysItemSs[]>;
+}

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

@@ -0,0 +1,16 @@
+import { ILogger } from '../../logger/types';
+import { ImpressionCountsPayload } from '../../sync/submitters/types';
+import { ImpressionCountsCacheInMemory } from '../inMemory/ImpressionCountsCacheInMemory';
+import { IPluggableStorageWrapper } from '../types';
+export declare class ImpressionCountsCachePluggable extends ImpressionCountsCacheInMemory {
+    private readonly log;
+    private readonly key;
+    private readonly wrapper;
+    private readonly refreshRate;
+    private intervalId;
+    constructor(log: ILogger, key: string, wrapper: IPluggableStorageWrapper, impressionCountsCacheSize?: number, refreshRate?: number);
+    private storeImpressionCounts;
+    start(): void;
+    stop(): Promise<any>;
+    getImpressionsCount(): Promise<ImpressionCountsPayload | undefined>;
+}

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

@@ -1,6 +1,7 @@
 import { KeyBuilder } from '../KeyBuilder';
 import { IPluggableStorageWrapper } from '../types';
 import { ILogger } from '../../logger/types';
+import { ISplit } from '../../dtos/types';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
 /**
  * ISplitsCacheAsync implementation for pluggable storages.
@@ -23,13 +24,13 @@ export declare class SplitsCachePluggable extends AbstractSplitsCacheAsync {
      * The returned promise is resolved when the operation success
      * or rejected if it fails (e.g., wrapper operation fails)
      */
-    addSplit(name: string, split: string): Promise<boolean>;
+    addSplit(name: string, split: ISplit): Promise<boolean>;
     /**
      * Add a list of splits.
      * The returned promise is resolved when the operation success
      * or rejected if it fails (e.g., wrapper operation fails)
      */
-    addSplits(entries: [string, string][]): Promise<boolean[]>;
+    addSplits(entries: [string, ISplit][]): Promise<boolean[]>;
     /**
      * Remove a given split.
      * The returned promise is resolved when the operation success, with a boolean indicating if the split existed or not.
@@ -47,19 +48,19 @@ export declare class SplitsCachePluggable extends AbstractSplitsCacheAsync {
      * The returned promise is resolved with the split definition or null if it's not defined,
      * or rejected if wrapper operation fails.
      */
-    getSplit(name: string): Promise<string | null>;
+    getSplit(name: string): Promise<ISplit | null>;
     /**
      * Get list of splits.
      * The returned promise is resolved with a map of split names to their split definition or null if it's not defined,
      * or rejected if wrapper operation fails.
      */
-    getSplits(names: string[]): Promise<Record<string, string | null>>;
+    getSplits(names: string[]): Promise<Record<string, ISplit | null>>;
     /**
      * Get list of all split definitions.
      * The returned promise is resolved with the list of split definitions,
      * or rejected if wrapper operation fails.
      */
-    getAll(): Promise<string[]>;
+    getAll(): Promise<ISplit[]>;
     /**
      * Get list of split names.
      * The returned promise is resolved with the list of split names,

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

@@ -1,5 +1,5 @@
 import { ILogger } from '../../logger/types';
-import { Method } from '../../sync/submitters/types';
+import { Method, MultiConfigs, MultiMethodExceptions, MultiMethodLatencies } from '../../sync/submitters/types';
 import { KeyBuilderSS } from '../KeyBuilderSS';
 import { IPluggableStorageWrapper, ITelemetryCacheAsync } from '../types';
 export declare class TelemetryCachePluggable implements ITelemetryCacheAsync {
@@ -15,4 +15,20 @@ export declare class TelemetryCachePluggable implements ITelemetryCacheAsync {
     constructor(log: ILogger, keys: KeyBuilderSS, wrapper: IPluggableStorageWrapper);
     recordLatency(method: Method, latencyMs: number): Promise<number | void>;
     recordException(method: Method): Promise<number | void>;
+    recordConfig(): Promise<boolean | void>;
+    /**
+     * Pop telemetry latencies.
+     * The returned promise rejects if wrapper operations fail.
+     */
+    popLatencies(): Promise<MultiMethodLatencies>;
+    /**
+     * Pop telemetry exceptions.
+     * The returned promise rejects if wrapper operations fail.
+     */
+    popExceptions(): Promise<MultiMethodExceptions>;
+    /**
+     * Pop telemetry configs.
+     * The returned promise rejects if wrapper operations fail.
+     */
+    popConfigs(): Promise<MultiConfigs>;
 }

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

@@ -0,0 +1,20 @@
+import { IPluggableStorageWrapper, IUniqueKeysCacheBase } from '../types';
+import { UniqueKeysCacheInMemory } from '../inMemory/UniqueKeysCacheInMemory';
+import { ILogger } from '../../logger/types';
+import { UniqueKeysItemSs } from '../../sync/submitters/types';
+export declare class UniqueKeysCachePluggable extends UniqueKeysCacheInMemory implements IUniqueKeysCacheBase {
+    private readonly log;
+    private readonly key;
+    private readonly wrapper;
+    private readonly refreshRate;
+    private intervalId;
+    constructor(log: ILogger, key: string, wrapper: IPluggableStorageWrapper, uniqueKeysQueueSize?: number, refreshRate?: number);
+    storeUniqueKeys(): Promise<any>;
+    start(): void;
+    stop(): Promise<any>;
+    /**
+     * 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.
+     */
+    popNRaw(count?: number): Promise<UniqueKeysItemSs[]>;
+}

package/types/storages/types.d.ts

@@ -1,8 +1,7 @@
-import { MaybeThenable, IMetadata, ISplitFiltersValidation } from '../dtos/types';
+import { MaybeThenable, IMetadata, ISplitFiltersValidation, ISplit } from '../dtos/types';
 import { ILogger } from '../logger/types';
-import { EventDataType, HttpErrors, HttpLatencies, ImpressionDataType, LastSync, Method, MethodExceptions, MethodLatencies, OperationType, StoredEventWithMetadata, StoredImpressionWithMetadata, StreamingEvent } from '../sync/submitters/types';
+import { EventDataType, HttpErrors, HttpLatencies, ImpressionDataType, LastSync, Method, MethodExceptions, MethodLatencies, MultiMethodExceptions, MultiMethodLatencies, MultiConfigs, OperationType, StoredEventWithMetadata, StoredImpressionWithMetadata, StreamingEvent, UniqueKeysPayloadCs, UniqueKeysPayloadSs } from '../sync/submitters/types';
 import { SplitIO, ImpressionDTO, SDKMode } from '../types';
-import { ISet } from '../utils/lang/sets';
 /**
  * Interface of a pluggable storage wrapper.
  */
@@ -66,23 +65,25 @@ export interface IPluggableStorageWrapper {
     getMany: (keys: string[]) => Promise<(string | null)[]>;
     /** Integer operations */
     /**
-     * Increments in 1 the given `key` value or set it to 1 if the value doesn't exist.
+     * Increments the number stored at `key` by `increment` (or 1 if `increment` is not provided), or set it to `increment` (or 1) if the value doesn't exist.
      *
      * @function incr
      * @param {string} key Key to increment
+     * @param {number} increment Value to increment by
      * @returns {Promise<number>} 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) => Promise<number>;
+    incr: (key: string, increment?: number) => Promise<number>;
     /**
-     * Decrements in 1 the given `key` value or set it to -1 if the value doesn't exist.
+     * Decrements the number stored at `key` by `decrement` (or 1 if `decrement` is not provided), or set it to minus `decrement` (or minus 1) if the value doesn't exist.
      *
      * @function decr
      * @param {string} key Key to decrement
+     * @param {number} decrement Value to decrement by
      * @returns {Promise<number>} 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) => Promise<number>;
+    decr: (key: string, decrement?: number) => Promise<number>;
     /** Queue operations */
     /**
      * Inserts given items at the tail of `key` list. If `key` does not exist, an empty list is created before pushing the items.
@@ -179,13 +180,13 @@ export interface IPluggableStorageWrapper {
 }
 /** Splits cache */
 export interface ISplitsCacheBase {
-    addSplits(entries: [string, string][]): MaybeThenable<boolean[] | void>;
+    addSplits(entries: [string, ISplit][]): MaybeThenable<boolean[] | void>;
     removeSplits(names: string[]): MaybeThenable<boolean[] | void>;
-    getSplit(name: string): MaybeThenable<string | null>;
-    getSplits(names: string[]): MaybeThenable<Record<string, string | null>>;
+    getSplit(name: string): MaybeThenable<ISplit | null>;
+    getSplits(names: string[]): MaybeThenable<Record<string, ISplit | null>>;
     setChangeNumber(changeNumber: number): MaybeThenable<boolean | void>;
     getChangeNumber(): MaybeThenable<number>;
-    getAll(): MaybeThenable<string[]>;
+    getAll(): MaybeThenable<ISplit[]>;
     getSplitNames(): MaybeThenable<string[]>;
     trafficTypeExists(trafficType: string): MaybeThenable<boolean>;
     usesSegments(): MaybeThenable<boolean>;
@@ -194,13 +195,13 @@ export interface ISplitsCacheBase {
     killLocally(name: string, defaultTreatment: string, changeNumber: number): MaybeThenable<boolean>;
 }
 export interface ISplitsCacheSync extends ISplitsCacheBase {
-    addSplits(entries: [string, string][]): boolean[];
+    addSplits(entries: [string, ISplit][]): boolean[];
     removeSplits(names: string[]): boolean[];
-    getSplit(name: string): string | null;
-    getSplits(names: string[]): Record<string, string | null>;
+    getSplit(name: string): ISplit | null;
+    getSplits(names: string[]): Record<string, ISplit | null>;
     setChangeNumber(changeNumber: number): boolean;
     getChangeNumber(): number;
-    getAll(): string[];
+    getAll(): ISplit[];
     getSplitNames(): string[];
     trafficTypeExists(trafficType: string): boolean;
     usesSegments(): boolean;
@@ -209,13 +210,13 @@ export interface ISplitsCacheSync extends ISplitsCacheBase {
     killLocally(name: string, defaultTreatment: string, changeNumber: number): boolean;
 }
 export interface ISplitsCacheAsync extends ISplitsCacheBase {
-    addSplits(entries: [string, string][]): Promise<boolean[] | void>;
+    addSplits(entries: [string, ISplit][]): Promise<boolean[] | void>;
     removeSplits(names: string[]): Promise<boolean[] | void>;
-    getSplit(name: string): Promise<string | null>;
-    getSplits(names: string[]): Promise<Record<string, string | null>>;
+    getSplit(name: string): Promise<ISplit | null>;
+    getSplits(names: string[]): Promise<Record<string, ISplit | null>>;
     setChangeNumber(changeNumber: number): Promise<boolean | void>;
     getChangeNumber(): Promise<number>;
-    getAll(): Promise<string[]>;
+    getAll(): Promise<ISplit[]>;
     getSplitNames(): Promise<string[]>;
     trafficTypeExists(trafficType: string): Promise<boolean>;
     usesSegments(): Promise<boolean>;
@@ -298,16 +299,12 @@ export interface IImpressionCountsCacheSync extends IRecorderCacheProducerSync<R
     isEmpty(): boolean;
     pop(toMerge?: Record<string, number>): Record<string, number>;
 }
-export interface IUniqueKeysCacheBase extends IRecorderCacheProducerSync<{
-    [featureName: string]: ISet<string>;
-}> {
-    track(featureName: string, timeFrame: number, amount: number): void;
+export interface IUniqueKeysCacheBase {
+    track(key: string, value: string): void;
     isEmpty(): boolean;
-    pop(toMerge?: {
-        [featureName: string]: ISet<string>;
-    }): {
-        [featureName: string]: ISet<string>;
-    };
+    pop(): UniqueKeysPayloadSs | UniqueKeysPayloadCs;
+    setOnFullQueueCb(cb: () => void): void;
+    clear(): void;
 }
 /**
  * Telemetry storage interface for standalone and partial consumer modes.
@@ -366,32 +363,34 @@ export interface ITelemetryCacheSync extends ITelemetryStorageConsumerSync, ITel
  * Methods are async because data is stored in Redis or a pluggable storage.
  */
 export interface ITelemetryEvaluationConsumerAsync {
-    popExceptions(): Promise<MethodExceptions>;
-    popLatencies(): Promise<MethodLatencies>;
+    popLatencies(): Promise<MultiMethodLatencies>;
+    popExceptions(): Promise<MultiMethodExceptions>;
+    popConfigs(): Promise<MultiConfigs>;
 }
 export interface ITelemetryEvaluationProducerAsync {
     recordLatency(method: Method, latencyMs: number): Promise<any>;
     recordException(method: Method): Promise<any>;
+    recordConfig(): Promise<any>;
 }
-export interface ITelemetryCacheAsync extends ITelemetryEvaluationProducerAsync {
+export interface ITelemetryCacheAsync extends ITelemetryEvaluationProducerAsync, ITelemetryEvaluationConsumerAsync {
 }
 /**
  * Storages
  */
-export interface IStorageBase<TSplitsCache extends ISplitsCacheBase, TSegmentsCache extends ISegmentsCacheBase, TImpressionsCache extends IImpressionsCacheBase, TEventsCache extends IEventsCacheBase, TTelemetryCache extends ITelemetryCacheSync | ITelemetryCacheAsync, TUniqueKeysCache extends IUniqueKeysCacheBase> {
+export interface IStorageBase<TSplitsCache extends ISplitsCacheBase, TSegmentsCache extends ISegmentsCacheBase, TImpressionsCache extends IImpressionsCacheBase, TImpressionsCountCache extends IImpressionCountsCacheSync, TEventsCache extends IEventsCacheBase, TTelemetryCache extends ITelemetryCacheSync | ITelemetryCacheAsync, TUniqueKeysCache extends IUniqueKeysCacheBase> {
     splits: TSplitsCache;
     segments: TSegmentsCache;
     impressions: TImpressionsCache;
-    impressionCounts?: IImpressionCountsCacheSync;
+    impressionCounts?: TImpressionsCountCache;
     events: TEventsCache;
     telemetry?: TTelemetryCache;
     uniqueKeys?: TUniqueKeysCache;
     destroy(): void | Promise<void>;
     shared?: (matchingKey: string, onReadyCb: (error?: any) => void) => this;
 }
-export interface IStorageSync extends IStorageBase<ISplitsCacheSync, ISegmentsCacheSync, IImpressionsCacheSync, IEventsCacheSync, ITelemetryCacheSync, IUniqueKeysCacheBase> {
+export interface IStorageSync extends IStorageBase<ISplitsCacheSync, ISegmentsCacheSync, IImpressionsCacheSync, IImpressionCountsCacheSync, IEventsCacheSync, ITelemetryCacheSync, IUniqueKeysCacheBase> {
 }
-export interface IStorageAsync extends IStorageBase<ISplitsCacheAsync, ISegmentsCacheAsync, IImpressionsCacheAsync | IImpressionsCacheSync, IEventsCacheAsync | IEventsCacheSync, ITelemetryCacheAsync, IUniqueKeysCacheBase> {
+export interface IStorageAsync extends IStorageBase<ISplitsCacheAsync, ISegmentsCacheAsync, IImpressionsCacheAsync | IImpressionsCacheSync, IImpressionCountsCacheSync, IEventsCacheAsync | IEventsCacheSync, ITelemetryCacheAsync | ITelemetryCacheSync, IUniqueKeysCacheBase> {
 }
 /** StorageFactory */
 export declare type DataLoader = (storage: IStorageSync, matchingKey: string) => void;
@@ -401,6 +400,7 @@ export interface IStorageFactoryParams {
     eventsQueueSize?: number;
     optimize?: boolean;
     mode: SDKMode;
+    impressionsMode?: string;
     matchingKey?: string;
     splitFiltersValidation?: ISplitFiltersValidation;
     onReadyCb: (error?: any) => void;

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

@@ -11,7 +11,7 @@ declare type ISplitChangesUpdater = (noCache?: boolean, till?: number) => Promis
  */
 export declare function parseSegments({ conditions }: ISplit): ISet<string>;
 interface ISplitMutations {
-    added: [string, string][];
+    added: [string, ISplit][];
     removed: string[];
     segments: string[];
 }

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

@@ -5,7 +5,7 @@ import { ISdkFactoryContextSync } from '../../sdkFactory/types';
 /**
  * Converts data from telemetry cache into /metrics/usage request payload.
  */
-export declare function telemetryCacheStatsAdapter(telemetry: ITelemetryCacheSync, splits: ISplitsCacheSync, segments: ISegmentsCacheSync): {
+export declare function telemetryCacheStatsAdapter(telemetry: ITelemetryCacheSync, splits?: ISplitsCacheSync, segments?: ISegmentsCacheSync): {
     isEmpty(): boolean;
     clear(): void;
     pop(): TelemetryUsageStatsPayload;

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

@@ -1,5 +1,6 @@
 import { IMetadata } from '../../dtos/types';
 import { SplitIO } from '../../types';
+import { IMap } from '../../utils/lang/maps';
 import { ISyncTask } from '../types';
 export declare type ImpressionsPayload = {
     /** Split name */
@@ -32,13 +33,14 @@ export declare type ImpressionCountsPayload = {
         rc: number;
     }[];
 };
+export declare type UniqueKeysItemSs = {
+    /** Split name */
+    f: string;
+    /** keyNames */
+    ks: string[];
+};
 export declare type UniqueKeysPayloadSs = {
-    keys: {
-        /** Split name */
-        f: string;
-        /** keyNames */
-        ks: string[];
-    }[];
+    keys: UniqueKeysItemSs[];
 };
 export declare type UniqueKeysPayloadCs = {
     keys: {
@@ -75,6 +77,9 @@ export declare type StoredEventWithMetadata = {
     /** Stored event */
     e: SplitIO.EventData;
 };
+export declare type MultiMethodLatencies = IMap<string, MethodLatencies>;
+export declare type MultiMethodExceptions = IMap<string, MethodExceptions>;
+export declare type MultiConfigs = IMap<string, TelemetryConfigStats>;
 /**
  * Telemetry usage stats
  */
@@ -119,10 +124,12 @@ export declare type StreamingEvent = {
     d?: number;
     t: number;
 };
-export declare type TelemetryUsageStatsPayload = {
+export declare type TelemetryUsageStats = {
+    mL?: MethodLatencies;
+    mE?: MethodExceptions;
+};
+export declare type TelemetryUsageStatsPayload = TelemetryUsageStats & {
     lS: LastSync;
-    mL: MethodLatencies;
-    mE: MethodExceptions;
     hE: HttpErrors;
     hL: HttpLatencies;
     tR: number;
@@ -130,9 +137,9 @@ export declare type TelemetryUsageStatsPayload = {
     iQ: number;
     iDe: number;
     iDr: number;
-    spC: number;
-    seC: number;
-    skC: number;
+    spC?: number;
+    seC?: number;
+    skC?: number;
     sL?: number;
     eQ: number;
     eD: number;

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

@@ -1,18 +1,4 @@
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
-import { ISet } from '../../utils/lang/sets';
-import { UniqueKeysPayloadCs, UniqueKeysPayloadSs } from './types';
-/**
- * Converts `uniqueKeys` data from cache into request payload for CS.
- */
-export declare function fromUniqueKeysCollectorCs(uniqueKeys: {
-    [featureName: string]: ISet<string>;
-}): UniqueKeysPayloadCs;
-/**
- * Converts `uniqueKeys` data from cache into request payload for SS.
- */
-export declare function fromUniqueKeysCollectorSs(uniqueKeys: {
-    [featureName: string]: ISet<string>;
-}): UniqueKeysPayloadSs;
 /**
  * Submitter that periodically posts impression counts
  */

package/types/trackers/types.d.ts

@@ -2,7 +2,6 @@ import { SplitIO, ImpressionDTO } from '../types';
 import { StreamingEventType, Method, OperationType } from '../sync/submitters/types';
 import { IEventsCacheBase } from '../storages/types';
 import { NetworkError } from '../services/types';
-import { ISet } from '../utils/lang/sets';
 /** Events tracker */
 export interface IEventsHandler {
     handleEvent(eventData: SplitIO.EventData): any;
@@ -34,11 +33,16 @@ export interface ITelemetryTracker {
      * Records streaming event
      */
     streamingEvent(e: StreamingEventType | AUTH_REJECTION, d?: number): void;
+    /**
+     * Records tag
+     */
+    addTag(tag: string): void;
 }
 export interface IFilterAdapter {
-    add(featureName: string, key: string): boolean;
-    contains(featureName: string, key: string): boolean;
+    add(key: string, featureName: string): boolean;
+    contains(key: string, featureName: string): boolean;
     clear(): void;
+    refreshRate?: number;
 }
 export interface IImpressionSenderAdapter {
     recordUniqueKeys(data: Object): void;
@@ -46,14 +50,8 @@ export interface IImpressionSenderAdapter {
 }
 /** Unique keys tracker */
 export interface IUniqueKeysTracker {
-    track(featureName: string, key: string): void;
-    pop(toMerge?: {
-        [featureName: string]: ISet<string>;
-    }): {
-        [featureName: string]: ISet<string>;
-    };
-    clear(): void;
-    isEmpty(): boolean;
+    stop(): void;
+    track(key: string, featureName: string): void;
 }
 export interface IStrategyResult {
     impressionsToStore: ImpressionDTO[];

package/types/trackers/uniqueKeysTracker.d.ts

@@ -1,4 +1,5 @@
 import { ILogger } from '../logger/types';
+import { IUniqueKeysCacheBase } from '../storages/types';
 import { IFilterAdapter, IUniqueKeysTracker } from './types';
 /**
  * Trackes uniques keys
@@ -6,8 +7,7 @@ import { IFilterAdapter, IUniqueKeysTracker } from './types';
  *  or schedule to be sent; if not it will be added in an internal cache and sent in the next post.
  *
  * @param log Logger instance
+ * @param uniqueKeysCache cache to save unique keys
  * @param filterAdapter filter adapter
- * @param cacheSize optional internal cache size
- * @param maxBulkSize optional max MTKs bulk size
  */
-export declare function uniqueKeysTrackerFactory(log: ILogger, filterAdapter?: IFilterAdapter, cacheSize?: number): IUniqueKeysTracker;
+export declare function uniqueKeysTrackerFactory(log: ILogger, uniqueKeysCache: IUniqueKeysCacheBase, filterAdapter?: IFilterAdapter): IUniqueKeysTracker;

package/types/types.d.ts

@@ -74,7 +74,6 @@ export interface ISettings {
         featuresRefreshRate: number;
         impressionsRefreshRate: number;
         impressionsQueueSize: number;
-        uniqueKeysRefreshRate: number;
         /**
          * @deprecated
          */

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

@@ -32,6 +32,7 @@ export declare const CONSUMER_ENUM = 1;
 export declare const CONSUMER_PARTIAL_ENUM = 2;
 export declare const OPTIMIZED_ENUM = 0;
 export declare const DEBUG_ENUM = 1;
+export declare const NONE_ENUM = 2;
 export declare const SPLITS = "sp";
 export declare const IMPRESSIONS = "im";
 export declare const IMPRESSIONS_COUNT = "ic";

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

@@ -23,10 +23,12 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 **/
 export interface IMap<K, V> {
-    set(key: K, value: V): this;
     clear(): void;
     delete(key: K): boolean;
+    forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any): void;
     get(key: K): V | undefined;
+    has(key: K): boolean;
+    set(key: K, value: V): this;
     readonly size: number;
 }
 export declare class MapPoly<K, V> implements IMap<K, V> {
@@ -34,9 +36,11 @@ export declare class MapPoly<K, V> implements IMap<K, V> {
     private __mapValuesData__;
     constructor(entries?: readonly (readonly [K, V])[] | null);
     clear(): void;
-    set(key: K, value: V): this;
     delete(key: K): boolean;
+    forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any): void;
     get(key: K): V | undefined;
+    has(key: K): boolean;
+    set(key: K, value: V): this;
     get size(): number;
 }
 interface IMapConstructor {

package/types/utils/redis/RedisMock.d.ts

@@ -0,0 +1,4 @@
+export declare class RedisMock {
+    private pipelineMethods;
+    constructor();
+}

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

@@ -14,7 +14,6 @@ export declare const base: {
         segmentsRefreshRate: number;
         telemetryRefreshRate: number;
         impressionsRefreshRate: number;
-        uniqueKeysRefreshRate: number;
         offlineRefreshRate: number;
         eventsPushRate: number;
         eventsQueueSize: number;

package/types/sdkClient/types.d.ts

@@ -1,18 +0,0 @@
-import { ISignalListener } from '../listeners/types';
-import { ISdkReadinessManager } from '../readiness/types';
-import { IStorageAsync, IStorageSync } from '../storages/types';
-import { ISyncManager } from '../sync/types';
-import { IEventTracker, IImpressionsTracker } from '../trackers/types';
-import { ISettings } from '../types';
-export interface IClientFactoryParams {
-    storage: IStorageSync | IStorageAsync;
-    sdkReadinessManager: ISdkReadinessManager;
-    settings: ISettings;
-    impressionsTracker: IImpressionsTracker;
-    eventTracker: IEventTracker;
-}
-export interface ISdkClientFactoryParams extends IClientFactoryParams {
-    signalListener?: ISignalListener;
-    syncManager?: ISyncManager;
-    sharedClient?: boolean;
-}

package/types/storages/inMemory/CountsCacheInMemory.d.ts

@@ -1,20 +0,0 @@
-import { ICountsCacheSync } from '../types';
-export declare class CountsCacheInMemory implements ICountsCacheSync {
-    private counters;
-    /**
-     * Add counts.
-     */
-    track(metricName: string): boolean;
-    /**
-     * Clear the collector
-     */
-    clear(): void;
-    /**
-     * Get the collected data, used as payload for posting.
-     */
-    state(): Record<string, number>;
-    /**
-     * Check if the cache is empty.
-     */
-    isEmpty(): boolean;
-}