@splitsoftware/splitio-commons 1.6.2-rc.4 → 1.6.2-rc.7

package/types/storages/AbstractSegmentsCacheSync.d.ts

@@ -0,0 +1,55 @@
+import { ISegmentsCacheSync } from './types';
+/**
+ * This class provides a skeletal implementation of the ISegmentsCacheSync interface
+ * to minimize the effort required to implement this interface.
+ */
+export declare abstract class AbstractSegmentsCacheSync implements ISegmentsCacheSync {
+    /**
+     * For server-side synchronizer: add `segmentKeys` list of keys to `name` segment.
+     * For client-side synchronizer: add `name` segment to the cache. `segmentKeys` is undefined.
+     */
+    abstract addToSegment(name: string, segmentKeys?: string[]): boolean;
+    /**
+     * For server-side synchronizer: remove `segmentKeys` list of keys from `name` segment.
+     * For client-side synchronizer: remove `name` segment from the cache. `segmentKeys` is undefined.
+     */
+    abstract removeFromSegment(name: string, segmentKeys?: string[]): boolean;
+    /**
+     * For server-side synchronizer: check if `key` is in `name` segment.
+     * For client-side synchronizer: check if `name` segment is in the cache. `key` is undefined.
+     */
+    abstract isInSegment(name: string, key?: string): boolean;
+    /**
+     * clear the cache.
+     */
+    abstract clear(): void;
+    /**
+     * For server-side synchronizer: add the given list of segments to the cache, with an empty list of keys. The segments that already exist are not modified.
+     * For client-side synchronizer: the method is not used.
+     */
+    registerSegments(names: string[]): boolean;
+    /**
+     * For server-side synchronizer: get the list of segments to fetch changes.
+     * Also used for the `seC` (segment count) telemetry stat.
+     */
+    abstract getRegisteredSegments(): string[];
+    /**
+     * Only used for the `skC`(segment keys count) telemetry stat: 1 for client-side, and total count of keys in server-side.
+     */
+    abstract getKeysCount(): number;
+    /**
+     * For server-side synchronizer: set the change number of `name` segment.
+     * For client-side synchronizer: the method is not used.
+     */
+    setChangeNumber(name: string, changeNumber: number): boolean;
+    /**
+     * For server-side synchronizer: get the change number of `name` segment.
+     * For client-side synchronizer: the method is not used.
+     */
+    getChangeNumber(name: string): number;
+    /**
+     * For server-side synchronizer: the method is not used.
+     * For client-side synchronizer: reset the cache with the given list of segments.
+     */
+    resetSegments(names: string[]): boolean;
+}

package/types/storages/AbstractSplitsCacheAsync.d.ts

@@ -0,0 +1,37 @@
+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 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 kill success 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

@@ -0,0 +1,42 @@
+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;
+    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 {Promise} a promise that is resolved once the split kill is performed. The fulfillment value is a boolean: `true` if the kill success 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;
+}
+/**
+ * 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

@@ -0,0 +1,14 @@
+export declare function validatePrefix(prefix: unknown): string;
+export declare class KeyBuilder {
+    protected readonly prefix: string;
+    constructor(prefix?: string);
+    buildTrafficTypeKey(trafficType: 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;
+}

package/types/storages/KeyBuilderCS.d.ts

@@ -0,0 +1,16 @@
+import { KeyBuilder } from './KeyBuilder';
+export declare class KeyBuilderCS extends KeyBuilder {
+    protected readonly regexSplitsCacheKey: RegExp;
+    protected readonly matchingKey: string;
+    constructor(prefix: string, matchingKey: string);
+    /**
+     * @override
+     */
+    buildSegmentNameKey(segmentName: string): string;
+    extractSegmentName(builtSegmentKeyName: string): string | undefined;
+    buildOldSegmentNameKey(segmentName: string): string;
+    extractOldSegmentKey(builtSegmentKeyName: string): string | undefined;
+    buildLastUpdatedKey(): string;
+    isSplitsCacheKey(key: string): boolean;
+    buildSplitsFilterQueryKey(): string;
+}

package/types/storages/KeyBuilderSS.d.ts

@@ -0,0 +1,17 @@
+import { KeyBuilder } from './KeyBuilder';
+import { IMetadata } from '../dtos/types';
+import { Method } from '../sync/submitters/types';
+export declare class KeyBuilderSS extends KeyBuilder {
+    protected readonly metadata: IMetadata;
+    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;
+    private buildVersionablePrefix;
+}

package/types/storages/dataLoader.d.ts

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,7 @@
+/**
+ * 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

@@ -0,0 +1,25 @@
+import { ILogger } from '../../logger/types';
+import { AbstractSegmentsCacheSync } from '../AbstractSegmentsCacheSync';
+import { KeyBuilderCS } from '../KeyBuilderCS';
+export declare class MySegmentsCacheInLocal extends AbstractSegmentsCacheSync {
+    private readonly keys;
+    private readonly log;
+    constructor(log: ILogger, keys: KeyBuilderCS);
+    /**
+     * Removes list of segments from localStorage
+     * @NOTE this method is not being used at the moment.
+     */
+    clear(): void;
+    addToSegment(name: string): boolean;
+    removeFromSegment(name: string): boolean;
+    isInSegment(name: string): boolean;
+    /**
+     * Reset (update) the cached list of segments with the given list, removing and adding segments if necessary.
+     *
+     * @param {string[]} segmentNames list of segment names
+     * @returns boolean indicating if the cache was updated (i.e., given list was different from the cached one)
+     */
+    resetSegments(names: string[]): boolean;
+    getRegisteredSegments(): string[];
+    getKeysCount(): number;
+}

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

@@ -0,0 +1,51 @@
+import { ISplit, ISplitFiltersValidation } from '../../dtos/types';
+import { AbstractSplitsCacheSync } from '../AbstractSplitsCacheSync';
+import { KeyBuilderCS } from '../KeyBuilderCS';
+import { ILogger } from '../../logger/types';
+/**
+ * ISplitsCacheSync implementation that stores split definitions in browser LocalStorage.
+ */
+export declare class SplitsCacheInLocal extends AbstractSplitsCacheSync {
+    private readonly log;
+    private readonly keys;
+    private readonly splitFiltersValidation;
+    private hasSync?;
+    private cacheReadyButNeedsToFlush;
+    private updateNewFilter?;
+    /**
+     * @param {KeyBuilderCS} keys
+     * @param {number | undefined} expirationTimestamp
+     * @param {ISplitFiltersValidation} splitFiltersValidation
+     */
+    constructor(log: ILogger, keys: KeyBuilderCS, expirationTimestamp?: number, splitFiltersValidation?: ISplitFiltersValidation);
+    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`,
+     * Clean operation (clear) also updates `lastUpdated` timestamp with current time.
+     *
+     * @param {number | undefined} expirationTimestamp if the value is not a number, data will not be cleaned
+     */
+    private _checkExpiration;
+    private _checkFilterQuery;
+}

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

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

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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,43 @@
+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: Object): boolean;
+    /**
+     * Retrieves the value of a given attribute
+     *
+     * @param {string} attributeName attribute name
+     * @returns {Object?} stored attribute value
+     */
+    getAttribute(attributeName: string): Object;
+    /**
+     * 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, Object>;
+    /**
+     * 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/CountsCacheInMemory.d.ts

@@ -0,0 +1,20 @@
+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;
+}

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

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,10 @@
+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/LatenciesCacheInMemory.d.ts

@@ -0,0 +1,20 @@
+import { ILatenciesCacheSync } from '../types';
+export declare class LatenciesCacheInMemory implements ILatenciesCacheSync {
+    private counters;
+    /**
+     * Add latencies.
+     */
+    track(metricName: string, latency: number): 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;
+}

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

@@ -0,0 +1,22 @@
+import { AbstractSegmentsCacheSync } from '../AbstractSegmentsCacheSync';
+/**
+ * Default MySegmentsCacheInMemory implementation that stores MySegments in memory.
+ * Supported by all JS runtimes.
+ */
+export declare class MySegmentsCacheInMemory extends AbstractSegmentsCacheSync {
+    private segmentCache;
+    clear(): void;
+    addToSegment(name: string): boolean;
+    removeFromSegment(name: string): boolean;
+    isInSegment(name: string): boolean;
+    /**
+     * Reset (update) the cached list of segments with the given list, removing and adding segments if necessary.
+     * @NOTE based on the way we use segments in the browser, this way is the best option
+     *
+     * @param {string[]} names list of segment names
+     * @returns boolean indicating if the cache was updated (i.e., given list was different from the cached one)
+     */
+    resetSegments(names: string[]): boolean;
+    getRegisteredSegments(): string[];
+    getKeysCount(): number;
+}

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

@@ -0,0 +1,19 @@
+import { AbstractSegmentsCacheSync } from '../AbstractSegmentsCacheSync';
+/**
+ * Default ISplitsCacheSync implementation that stores split definitions in memory.
+ * Supported by all JS runtimes.
+ */
+export declare class SegmentsCacheInMemory extends AbstractSegmentsCacheSync {
+    private segmentCache;
+    private segmentChangeNumber;
+    addToSegment(name: string, segmentKeys: string[]): boolean;
+    removeFromSegment(name: string, segmentKeys: string[]): boolean;
+    isInSegment(name: string, key: string): boolean;
+    clear(): void;
+    private _registerSegment;
+    registerSegments(names: string[]): boolean;
+    getRegisteredSegments(): string[];
+    getKeysCount(): number;
+    setChangeNumber(name: string, changeNumber: number): boolean;
+    getChangeNumber(name: string): number;
+}

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

@@ -0,0 +1,21 @@
+import { ISplit } from '../../dtos/types';
+import { AbstractSplitsCacheSync } from '../AbstractSplitsCacheSync';
+/**
+ * Default ISplitsCacheSync implementation that stores split definitions in memory.
+ * Supported by all JS runtimes.
+ */
+export declare class SplitsCacheInMemory extends AbstractSplitsCacheSync {
+    private splitsCache;
+    private ttCache;
+    private changeNumber;
+    private splitsWithSegmentsCount;
+    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;
+}

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

@@ -0,0 +1,53 @@
+import { ImpressionDataType, EventDataType, LastSync, HttpErrors, HttpLatencies, StreamingEvent, Method, OperationType, MethodExceptions, MethodLatencies } from '../../sync/submitters/types';
+import { ITelemetryCacheSync } from '../types';
+/**
+ * Used on client-side. 0.1% of instances will track telemetry
+ */
+export declare function shouldRecordTelemetry(): boolean;
+export declare class TelemetryCacheInMemory implements ITelemetryCacheSync {
+    private timeUntilReady?;
+    getTimeUntilReady(): number | undefined;
+    recordTimeUntilReady(ms: number): void;
+    private timeUntilReadyFromCache?;
+    getTimeUntilReadyFromCache(): number | undefined;
+    recordTimeUntilReadyFromCache(ms: number): void;
+    private notReadyUsage;
+    getNonReadyUsage(): number;
+    recordNonReadyUsage(): void;
+    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(): LastSync;
+    recordSuccessfulSync(resource: OperationType, timeMs: number): void;
+    private httpErrors;
+    popHttpErrors(): HttpErrors;
+    recordHttpError(resource: OperationType, status: number): void;
+    private httpLatencies;
+    popHttpLatencies(): HttpLatencies;
+    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(): MethodExceptions;
+    recordException(method: Method): void;
+    private latencies;
+    popLatencies(): MethodLatencies;
+    recordLatency(method: Method, latencyMs: number): void;
+}

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

@@ -0,0 +1,35 @@
+import { IUniqueKeysCacheBase } from '../types';
+import { ISet } from '../../utils/lang/sets';
+import { UniqueKeysPayloadSs } from '../../sync/submitters/types';
+export declare class UniqueKeysCacheInMemory implements IUniqueKeysCacheBase {
+    protected onFullQueue?: () => void;
+    private readonly maxStorage;
+    private uniqueTrackerSize;
+    protected uniqueKeysTracker: {
+        [keys: string]: ISet<string>;
+    };
+    constructor(uniqueKeysQueueSize?: number);
+    setOnFullQueueCb(cb: () => void): void;
+    /**
+     * Store unique keys in sequential order
+     * key: string = feature name.
+     * value: Set<string> = set of unique keys.
+     */
+    track(key: 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;
+    /**
+     * Converts `uniqueKeys` data from cache into request payload for SS.
+     */
+    private fromUniqueKeysCollector;
+}