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

package/types/storages/AbstractSplitsCacheAsync.d.ts

@@ -1,38 +0,0 @@
-import { ISplitsCacheAsync } from './types';
-import { ISplit } from '../dtos/types';
-/**
- * This class provides a skeletal implementation of the ISplitsCacheAsync interface
- * to minimize the effort required to implement this interface.
- */
-export declare abstract class AbstractSplitsCacheAsync implements ISplitsCacheAsync {
-    abstract addSplit(name: string, split: ISplit): Promise<boolean>;
-    abstract addSplits(entries: [string, ISplit][]): Promise<boolean[] | void>;
-    abstract removeSplits(names: string[]): Promise<boolean[] | void>;
-    abstract getSplit(name: string): Promise<ISplit | null>;
-    abstract getSplits(names: string[]): Promise<Record<string, ISplit | null>>;
-    abstract setChangeNumber(changeNumber: number): Promise<boolean | void>;
-    abstract getChangeNumber(): Promise<number>;
-    abstract getAll(): Promise<ISplit[]>;
-    abstract getSplitNames(): Promise<string[]>;
-    abstract getNamesByFlagSets(flagSets: string[]): Promise<Set<string>[]>;
-    abstract trafficTypeExists(trafficType: string): Promise<boolean>;
-    abstract clear(): Promise<boolean | void>;
-    usesSegments(): Promise<boolean>;
-    /**
-     * Check if the splits information is already stored in cache.
-     * Noop, just keeping the interface. This is used by client-side implementations only.
-     */
-    checkCache(): Promise<boolean>;
-    /**
-     * Kill `name` split and set `defaultTreatment` and `changeNumber`.
-     * Used for SPLIT_KILL push notifications.
-     *
-     * @param {string} name
-     * @param {string} defaultTreatment
-     * @param {number} changeNumber
-     * @returns {Promise} a promise that is resolved once the split kill operation is performed. The fulfillment value is a boolean: `true` if the operation successed updating the split or `false` if no split is updated,
-     * for instance, if the `changeNumber` is old, or if the split is not found (e.g., `/splitchanges` hasn't been fetched yet), or if the storage fails to apply the update.
-     * The promise will never be rejected.
-     */
-    killLocally(name: string, defaultTreatment: string, changeNumber: number): Promise<boolean>;
-}

package/types/storages/AbstractSplitsCacheSync.d.ts

@@ -1,43 +0,0 @@
-import { ISplitsCacheSync } from './types';
-import { ISplit } from '../dtos/types';
-/**
- * This class provides a skeletal implementation of the ISplitsCacheSync interface
- * to minimize the effort required to implement this interface.
- */
-export declare abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
-    abstract addSplit(name: string, split: ISplit): boolean;
-    addSplits(entries: [string, ISplit][]): boolean[];
-    abstract removeSplit(name: string): boolean;
-    removeSplits(names: string[]): boolean[];
-    abstract getSplit(name: string): ISplit | null;
-    getSplits(names: string[]): Record<string, ISplit | null>;
-    abstract setChangeNumber(changeNumber: number): boolean | void;
-    abstract getChangeNumber(): number;
-    getAll(): ISplit[];
-    abstract getSplitNames(): string[];
-    abstract trafficTypeExists(trafficType: string): boolean;
-    abstract usesSegments(): boolean;
-    abstract clear(): void;
-    /**
-     * Check if the splits information is already stored in cache. This data can be preloaded.
-     * It is used as condition to emit SDK_SPLITS_CACHE_LOADED, and then SDK_READY_FROM_CACHE.
-     */
-    checkCache(): boolean;
-    /**
-     * Kill `name` split and set `defaultTreatment` and `changeNumber`.
-     * Used for SPLIT_KILL push notifications.
-     *
-     * @param {string} name
-     * @param {string} defaultTreatment
-     * @param {number} changeNumber
-     * @returns {boolean} `true` if the operation successed updating the split, or `false` if no split is updated,
-     * for instance, if the `changeNumber` is old, or if the split is not found (e.g., `/splitchanges` hasn't been fetched yet), or if the storage fails to apply the update.
-     */
-    killLocally(name: string, defaultTreatment: string, changeNumber: number): boolean;
-    abstract getNamesByFlagSets(flagSets: string[]): Set<string>[];
-}
-/**
- * Given a parsed split, it returns a boolean flagging if its conditions use segments matchers (rules & whitelists).
- * This util is intended to simplify the implementation of `splitsCache::usesSegments` method
- */
-export declare function usesSegments(split: ISplit): boolean;

package/types/storages/KeyBuilder.d.ts

@@ -1,22 +0,0 @@
-import { ISettings } from '../types';
-export declare function validatePrefix(prefix: unknown): string;
-export declare class KeyBuilder {
-    readonly prefix: string;
-    constructor(prefix?: string);
-    buildTrafficTypeKey(trafficType: string): string;
-    buildFlagSetKey(flagSet: string): string;
-    buildSplitKey(splitName: string): string;
-    buildSplitsTillKey(): string;
-    isSplitKey(key: string): boolean;
-    buildSplitKeyPrefix(): string;
-    buildSplitsWithSegmentCountKey(): string;
-    buildSegmentNameKey(segmentName: string): string;
-    buildSegmentTillKey(segmentName: string): string;
-    extractKey(builtKey: string): string;
-    buildHashKey(): string;
-}
-/**
- * Generates a murmur32 hash based on the authorization key, the feature flags filter query, and version of SplitChanges API.
- * The hash is in hexadecimal format (8 characters max, 32 bits).
- */
-export declare function getStorageHash(settings: ISettings): string;

package/types/storages/KeyBuilderCS.d.ts

@@ -1,20 +0,0 @@
-import { KeyBuilder } from './KeyBuilder';
-export interface MySegmentsKeyBuilder {
-    buildSegmentNameKey(segmentName: string): string;
-    extractSegmentName(builtSegmentKeyName: string): string | undefined;
-    buildTillKey(): string;
-}
-export declare class KeyBuilderCS extends KeyBuilder implements MySegmentsKeyBuilder {
-    protected readonly regexSplitsCacheKey: RegExp;
-    protected readonly matchingKey: string;
-    constructor(prefix: string, matchingKey: string);
-    /**
-     * @override
-     */
-    buildSegmentNameKey(segmentName: string): string;
-    extractSegmentName(builtSegmentKeyName: string): string | undefined;
-    buildLastUpdatedKey(): string;
-    isSplitsCacheKey(key: string): boolean;
-    buildTillKey(): string;
-}
-export declare function myLargeSegmentsKeyBuilder(prefix: string, matchingKey: string): MySegmentsKeyBuilder;

package/types/storages/KeyBuilderSS.d.ts

@@ -1,20 +0,0 @@
-import { KeyBuilder } from './KeyBuilder';
-import { IMetadata } from '../dtos/types';
-import { Method } from '../sync/submitters/types';
-export declare const METHOD_NAMES: Record<Method, string>;
-export declare class KeyBuilderSS extends KeyBuilder {
-    readonly latencyPrefix: string;
-    readonly exceptionPrefix: string;
-    readonly initPrefix: string;
-    private readonly versionablePrefix;
-    constructor(prefix: string, metadata: IMetadata);
-    buildRegisteredSegmentsKey(): string;
-    buildImpressionsKey(): string;
-    buildImpressionsCountKey(): string;
-    buildUniqueKeysKey(): string;
-    buildEventsKey(): string;
-    searchPatternForSplitKeys(): string;
-    buildLatencyKey(method: Method, bucket: number): string;
-    buildExceptionKey(method: Method): string;
-    buildInitKey(): string;
-}

package/types/storages/dataLoader.d.ts

@@ -1,10 +0,0 @@
-import { SplitIO } from '../types';
-import { DataLoader } from './types';
-/**
- * Factory of client-side storage loader
- *
- * @param preloadedData validated data following the format proposed in https://github.com/godaddy/split-javascript-data-loader
- * and extended with a `mySegmentsData` property.
- * @returns function to preload the storage
- */
-export declare function dataLoaderFactory(preloadedData: SplitIO.PreloadedData): DataLoader;

package/types/storages/findLatencyIndex.d.ts

@@ -1,7 +0,0 @@
-/**
- * Calculates buckets from latency in milliseconds
- *
- * @param latencyInMs
- * @returns a bucket index from 0 to 22 inclusive
- */
-export declare function findLatencyIndex(latencyInMs: number): number;

package/types/storages/inLocalStorage/MySegmentsCacheInLocal.d.ts

@@ -1,15 +0,0 @@
-import { ILogger } from '../../logger/types';
-import { AbstractMySegmentsCacheSync } from '../AbstractMySegmentsCacheSync';
-import type { MySegmentsKeyBuilder } from '../KeyBuilderCS';
-export declare class MySegmentsCacheInLocal extends AbstractMySegmentsCacheSync {
-    private readonly keys;
-    private readonly log;
-    constructor(log: ILogger, keys: MySegmentsKeyBuilder);
-    protected addSegment(name: string): boolean;
-    protected removeSegment(name: string): boolean;
-    isInSegment(name: string): boolean;
-    getRegisteredSegments(): string[];
-    getKeysCount(): number;
-    protected setChangeNumber(changeNumber?: number): void;
-    getChangeNumber(): number;
-}

package/types/storages/inLocalStorage/SplitsCacheInLocal.d.ts

@@ -1,54 +0,0 @@
-import { ISplit } from '../../dtos/types';
-import { AbstractSplitsCacheSync } from '../AbstractSplitsCacheSync';
-import { KeyBuilderCS } from '../KeyBuilderCS';
-import { ISettings } from '../../types';
-/**
- * ISplitsCacheSync implementation that stores split definitions in browser LocalStorage.
- */
-export declare class SplitsCacheInLocal extends AbstractSplitsCacheSync {
-    private readonly keys;
-    private readonly log;
-    private readonly storageHash;
-    private readonly flagSetsFilter;
-    private hasSync?;
-    private updateNewFilter?;
-    /**
-     * @param {KeyBuilderCS} keys
-     * @param {number | undefined} expirationTimestamp
-     * @param {ISplitFiltersValidation} splitFiltersValidation
-     */
-    constructor(settings: ISettings, keys: KeyBuilderCS, expirationTimestamp?: number);
-    private _decrementCount;
-    private _decrementCounts;
-    private _incrementCounts;
-    /**
-     * Removes all splits cache related data from localStorage (splits, counters, changeNumber and lastUpdated).
-     * We cannot simply call `localStorage.clear()` since that implies removing user items from the storage.
-     */
-    clear(): void;
-    addSplit(name: string, split: ISplit): boolean;
-    removeSplit(name: string): boolean;
-    getSplit(name: string): any;
-    setChangeNumber(changeNumber: number): boolean;
-    getChangeNumber(): number;
-    getSplitNames(): string[];
-    trafficTypeExists(trafficType: string): boolean;
-    usesSegments(): boolean;
-    /**
-     * Check if the splits information is already stored in browser LocalStorage.
-     * In this function we could add more code to check if the data is valid.
-     * @override
-     */
-    checkCache(): boolean;
-    /**
-     * Clean Splits cache if its `lastUpdated` timestamp is older than the given `expirationTimestamp`,
-     *
-     * @param {number | undefined} expirationTimestamp if the value is not a number, data will not be cleaned
-     */
-    private _checkExpiration;
-    private _checkFilterQuery;
-    getNamesByFlagSets(flagSets: string[]): Set<string>[];
-    private addToFlagSets;
-    private removeFromFlagSets;
-    private removeNames;
-}

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

@@ -1,2 +0,0 @@
-export declare const LOG_PREFIX = "storage:localstorage: ";
-export declare const DEFINED = "1";

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

@@ -1,8 +0,0 @@
-import { IStorageSyncFactory } from '../types';
-export interface InLocalStorageOptions {
-    prefix?: string;
-}
-/**
- * InLocal storage factory for standalone client-side SplitFactory
- */
-export declare function InLocalStorage(options?: InLocalStorageOptions): IStorageSyncFactory;

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

@@ -1,44 +0,0 @@
-import { SplitIO } from '../../types';
-export declare class AttributesCacheInMemory {
-    private attributesCache;
-    /**
-     * Create or update the value for the given attribute
-     *
-     * @param {string} attributeName attribute name
-     * @param {Object} attributeValue attribute value
-     * @returns {boolean} the attribute was stored
-     */
-    setAttribute(attributeName: string, attributeValue: SplitIO.AttributeType): boolean;
-    /**
-     * Retrieves the value of a given attribute
-     *
-     * @param {string} attributeName attribute name
-     * @returns {Object?} stored attribute value
-     */
-    getAttribute(attributeName: string): SplitIO.AttributeType;
-    /**
-     * Create or update all the given attributes
-     *
-     * @param {[string, Object]} attributes attributes to create or update
-     * @returns {boolean} attributes were stored
-     */
-    setAttributes(attributes: Record<string, Object>): boolean;
-    /**
-     * Retrieve the full attributes map
-     *
-     * @returns {Map<string, Object>} stored attributes
-     */
-    getAll(): Record<string, SplitIO.AttributeType>;
-    /**
-     * Removes a given attribute from the map
-     *
-     * @param {string} attributeName attribute to remove
-     * @returns {boolean} attribute removed
-     */
-    removeAttribute(attributeName: string): boolean;
-    /**
-     * Clears all attributes stored in the SDK
-     *
-     */
-    clear(): boolean;
-}

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

@@ -1,35 +0,0 @@
-import { SplitIO } from '../../types';
-import { IEventsCacheSync } from '../types';
-export declare class EventsCacheInMemory implements IEventsCacheSync {
-    private onFullQueue?;
-    private readonly maxQueue;
-    private queue;
-    private queueByteSize;
-    /**
-     *
-     * @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);
-    setOnFullQueueCb(cb: () => void): void;
-    /**
-     * Add a new event object at the end of the queue.
-     */
-    track(data: SplitIO.EventData, size?: number): boolean;
-    /**
-     * Clear the data stored on the cache.
-     */
-    clear(): void;
-    /**
-     * Pop the collected data, used as payload for posting.
-     */
-    pop(toMerge?: SplitIO.EventData[]): SplitIO.EventData[];
-    /**
-     * Check if the cache is empty.
-     */
-    isEmpty(): boolean;
-    /**
-     * Check if the cache queue is full and we need to flush it.
-     */
-    private _checkForFlush;
-}

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

@@ -1,28 +0,0 @@
-import { IImpressionCountsCacheSync } from '../types';
-export declare class ImpressionCountsCacheInMemory implements IImpressionCountsCacheSync {
-    protected cache: Record<string, number>;
-    private readonly maxStorage;
-    protected onFullQueue?: () => void;
-    private cacheSize;
-    constructor(impressionCountsCacheSize?: number);
-    /**
-    * Builds key to be stored in the cache with the featureName and the timeFrame truncated.
-    */
-    private _makeKey;
-    /**
-    * Increments the quantity of impressions with the passed featureName and timeFrame.
-    */
-    track(featureName: string, timeFrame: number, amount: number): void;
-    /**
-     * Pop the collected data, used as payload for posting.
-     */
-    pop(toMerge?: Record<string, number>): Record<string, number>;
-    /**
-     * Clear the data stored on the cache.
-     */
-    clear(): void;
-    /**
-     * Check if the cache is empty.
-     */
-    isEmpty(): boolean;
-}

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

@@ -1,30 +0,0 @@
-import { IImpressionsCacheSync } from '../types';
-import { ImpressionDTO } from '../../types';
-export declare class ImpressionsCacheInMemory implements IImpressionsCacheSync {
-    private onFullQueue?;
-    private readonly maxQueue;
-    private queue;
-    /**
-     *
-     * @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);
-    setOnFullQueueCb(cb: () => void): void;
-    /**
-     * Store impressions in sequential order
-     */
-    track(data: ImpressionDTO[]): void;
-    /**
-     * Clear the data stored on the cache.
-     */
-    clear(): void;
-    /**
-     * Pop the collected data, used as payload for posting.
-     */
-    pop(toMerge?: ImpressionDTO[]): ImpressionDTO[];
-    /**
-     * Check if the cache is empty.
-     */
-    isEmpty(): boolean;
-}

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

@@ -1,10 +0,0 @@
-import { IStorageFactoryParams, IStorageSync } from '../types';
-/**
- * InMemory storage factory for standalone server-side SplitFactory
- *
- * @param params parameters required by EventsCacheSync
- */
-export declare function InMemoryStorageFactory(params: IStorageFactoryParams): IStorageSync;
-export declare namespace InMemoryStorageFactory {
-    var type: import("../types").StorageType;
-}

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

@@ -1,10 +0,0 @@
-import { IStorageSync, IStorageFactoryParams } from '../types';
-/**
- * InMemory storage factory for standalone client-side SplitFactory
- *
- * @param params parameters required by EventsCacheSync
- */
-export declare function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorageSync;
-export declare namespace InMemoryStorageCSFactory {
-    var type: import("../types").StorageType;
-}

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

@@ -1,16 +0,0 @@
-import { AbstractMySegmentsCacheSync } from '../AbstractMySegmentsCacheSync';
-/**
- * Default MySegmentsCacheInMemory implementation that stores MySegments in memory.
- * Supported by all JS runtimes.
- */
-export declare class MySegmentsCacheInMemory extends AbstractMySegmentsCacheSync {
-    private segmentCache;
-    private cn?;
-    protected addSegment(name: string): boolean;
-    protected removeSegment(name: string): boolean;
-    isInSegment(name: string): boolean;
-    protected setChangeNumber(changeNumber?: number): void;
-    getChangeNumber(): number;
-    getRegisteredSegments(): string[];
-    getKeysCount(): number;
-}

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

@@ -1,17 +0,0 @@
-import { ISegmentsCacheSync } from '../types';
-/**
- * Default ISplitsCacheSync implementation for server-side that stores segments definitions in memory.
- */
-export declare class SegmentsCacheInMemory implements ISegmentsCacheSync {
-    private segmentCache;
-    private segmentChangeNumber;
-    update(name: string, addedKeys: string[], removedKeys: string[], changeNumber: number): boolean;
-    isInSegment(name: string, key: string): boolean;
-    clear(): void;
-    private _registerSegment;
-    registerSegments(names: string[]): boolean;
-    getRegisteredSegments(): string[];
-    getKeysCount(): number;
-    getChangeNumber(name: string): number;
-    resetSegments(): boolean;
-}

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

@@ -1,27 +0,0 @@
-import { ISplit, ISplitFiltersValidation } from '../../dtos/types';
-import { AbstractSplitsCacheSync } from '../AbstractSplitsCacheSync';
-/**
- * Default ISplitsCacheSync implementation that stores split definitions in memory.
- */
-export declare class SplitsCacheInMemory extends AbstractSplitsCacheSync {
-    private flagSetsFilter;
-    private splitsCache;
-    private ttCache;
-    private changeNumber;
-    private segmentsCount;
-    private flagSetsCache;
-    constructor(splitFiltersValidation?: ISplitFiltersValidation);
-    clear(): void;
-    addSplit(name: string, split: ISplit): boolean;
-    removeSplit(name: string): boolean;
-    getSplit(name: string): ISplit | null;
-    setChangeNumber(changeNumber: number): boolean;
-    getChangeNumber(): number;
-    getSplitNames(): string[];
-    trafficTypeExists(trafficType: string): boolean;
-    usesSegments(): boolean;
-    getNamesByFlagSets(flagSets: string[]): Set<string>[];
-    private addToFlagSets;
-    private removeFromFlagSets;
-    private removeNames;
-}

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

@@ -1,71 +0,0 @@
-import { ImpressionDataType, EventDataType, StreamingEvent, Method, OperationType, TelemetryUsageStatsPayload, UpdatesFromSSEEnum, UpdatesFromSSE } from '../../sync/submitters/types';
-import { ISegmentsCacheSync, ISplitsCacheSync, IStorageFactoryParams, ITelemetryCacheSync } from '../types';
-export declare const MAX_LATENCY_BUCKET_COUNT = 23;
-export declare function newBuckets(): number[];
-/**
- * Record telemetry if mode is not localhost.
- * All factory instances track telemetry on server-side, and 0.1% on client-side.
- */
-export declare function shouldRecordTelemetry({ settings }: IStorageFactoryParams): boolean;
-export declare class TelemetryCacheInMemory implements ITelemetryCacheSync {
-    private splits?;
-    private segments?;
-    private largeSegments?;
-    constructor(splits?: ISplitsCacheSync | undefined, segments?: ISegmentsCacheSync | undefined, largeSegments?: ISegmentsCacheSync | undefined);
-    private e;
-    isEmpty(): boolean;
-    clear(): void;
-    pop(): TelemetryUsageStatsPayload;
-    /** Config stats */
-    private timeUntilReady?;
-    getTimeUntilReady(): number | undefined;
-    recordTimeUntilReady(ms: number): void;
-    private timeUntilReadyFromCache?;
-    getTimeUntilReadyFromCache(): number | undefined;
-    recordTimeUntilReadyFromCache(ms: number): void;
-    private notReadyUsage;
-    getNonReadyUsage(): number;
-    recordNonReadyUsage(): void;
-    /** Usage stats */
-    private impressionStats;
-    getImpressionStats(type: ImpressionDataType): number;
-    recordImpressionStats(type: ImpressionDataType, count: number): void;
-    private eventStats;
-    getEventStats(type: EventDataType): number;
-    recordEventStats(type: EventDataType, count: number): void;
-    private lastSync;
-    getLastSynchronization(): Partial<Record<OperationType, number | undefined>>;
-    recordSuccessfulSync(resource: OperationType, timeMs: number): void;
-    private httpErrors;
-    popHttpErrors(): Partial<Record<OperationType, {
-        [statusCode: string]: number;
-    }>>;
-    recordHttpError(resource: OperationType, status: number): void;
-    private httpLatencies;
-    popHttpLatencies(): Partial<Record<OperationType, number[]>>;
-    recordHttpLatency(resource: OperationType, latencyMs: number): void;
-    private authRejections;
-    popAuthRejections(): number;
-    recordAuthRejections(): void;
-    private tokenRefreshes;
-    popTokenRefreshes(): number;
-    recordTokenRefreshes(): void;
-    private streamingEvents;
-    popStreamingEvents(): StreamingEvent[];
-    recordStreamingEvents(streamingEvent: StreamingEvent): void;
-    private tags;
-    popTags(): string[];
-    addTag(tag: string): void;
-    private sessionLength?;
-    getSessionLength(): number | undefined;
-    recordSessionLength(ms: number): void;
-    private exceptions;
-    popExceptions(): Partial<Record<Method, number>>;
-    recordException(method: Method): void;
-    private latencies;
-    popLatencies(): Partial<Record<Method, number[]>>;
-    recordLatency(method: Method, latencyMs: number): void;
-    private updatesFromSSE;
-    popUpdatesFromSSE(): UpdatesFromSSE;
-    recordUpdatesFromSSE(type: UpdatesFromSSEEnum): void;
-}

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

@@ -1,34 +0,0 @@
-import { IUniqueKeysCacheBase } from '../types';
-import { UniqueKeysPayloadSs } from '../../sync/submitters/types';
-/**
- * Converts `uniqueKeys` data from cache into request payload for SS.
- */
-export declare function fromUniqueKeysCollector(uniqueKeys: {
-    [featureName: string]: Set<string>;
-}): UniqueKeysPayloadSs;
-export declare class UniqueKeysCacheInMemory implements IUniqueKeysCacheBase {
-    protected onFullQueue?: () => void;
-    private readonly maxStorage;
-    private uniqueTrackerSize;
-    protected uniqueKeysTracker: {
-        [featureName: string]: Set<string>;
-    };
-    constructor(uniqueKeysQueueSize?: number);
-    setOnFullQueueCb(cb: () => void): void;
-    /**
-     * Store unique keys per feature.
-     */
-    track(userKey: string, featureName: string): void;
-    /**
-     * Clear the data stored on the cache.
-     */
-    clear(): void;
-    /**
-     * Pop the collected data, used as payload for posting.
-     */
-    pop(): UniqueKeysPayloadSs;
-    /**
-     * Check if the cache is empty.
-     */
-    isEmpty(): boolean;
-}

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

@@ -1,35 +0,0 @@
-import { IUniqueKeysCacheBase } from '../types';
-import { UniqueKeysPayloadCs } from '../../sync/submitters/types';
-export declare class UniqueKeysCacheInMemoryCS implements IUniqueKeysCacheBase {
-    private onFullQueue?;
-    private readonly maxStorage;
-    private uniqueTrackerSize;
-    private uniqueKeysTracker;
-    /**
-     *
-     * @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?: number);
-    setOnFullQueueCb(cb: () => void): void;
-    /**
-     * Store unique keys per feature.
-     */
-    track(userKey: string, featureName: string): void;
-    /**
-     * Clear the data stored on the cache.
-     */
-    clear(): void;
-    /**
-     * Pop the collected data, used as payload for posting.
-     */
-    pop(): UniqueKeysPayloadCs;
-    /**
-     * Check if the cache is empty.
-     */
-    isEmpty(): boolean;
-    /**
-     * Converts `uniqueKeys` data from cache into request payload.
-     */
-    private fromUniqueKeysCollector;
-}

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

@@ -1,32 +0,0 @@
-import { IEventsCacheAsync } from '../types';
-import { IMetadata } from '../../dtos/types';
-import { SplitIO } from '../../types';
-import { ILogger } from '../../logger/types';
-import { StoredEventWithMetadata } from '../../sync/submitters/types';
-import type { RedisAdapter } from './RedisAdapter';
-export declare class EventsCacheInRedis implements IEventsCacheAsync {
-    private readonly log;
-    private readonly key;
-    private readonly redis;
-    private readonly metadata;
-    constructor(log: ILogger, key: string, redis: RedisAdapter, metadata: IMetadata);
-    /**
-     * Add a new event object into the queue.
-     * Unlike `impressions::track`, result promise is never rejected.
-     */
-    track(eventData: SplitIO.EventData): Promise<boolean>;
-    /**
-     * Generates the JSON as we'll store it on Redis.
-     */
-    private _toJSON;
-    count(): Promise<number>;
-    drop(count?: number): Promise<any>;
-    /**
-     * Pop the given number of events from the storage.
-     * The returned promise rejects if the redis operation fails.
-     *
-     * NOTE: this method doesn't take into account MAX_EVENT_SIZE or MAX_QUEUE_BYTE_SIZE limits.
-     * It is the submitter responsability to handle that.
-     */
-    popNWithMetadata(count: number): Promise<StoredEventWithMetadata[]>;
-}