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

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

@@ -1,89 +0,0 @@
-import { KeyBuilder } from '../KeyBuilder';
-import { IPluggableStorageWrapper } from '../types';
-import { ILogger } from '../../logger/types';
-import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
-/**
- * ISplitsCacheAsync implementation for pluggable storages.
- */
-export declare class SplitsCachePluggable extends AbstractSplitsCacheAsync {
-    private readonly log;
-    private readonly keys;
-    private readonly wrapper;
-    /**
-     * Create a SplitsCache that uses a storage wrapper.
-     * @param log  Logger instance.
-     * @param keys  Key builder.
-     * @param wrapper  Adapted wrapper storage.
-     */
-    constructor(log: ILogger, keys: KeyBuilder, wrapper: IPluggableStorageWrapper);
-    private _decrementCounts;
-    private _incrementCounts;
-    /**
-     * Add a given split.
-     * 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>;
-    /**
-     * 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[]>;
-    /**
-     * Remove a given split.
-     * The returned promise is resolved when the operation success, with a boolean indicating if the split existed or not.
-     * or rejected if it fails (e.g., wrapper operation fails).
-     */
-    removeSplit(name: string): Promise<boolean | void>;
-    /**
-     * Remove a list of splits.
-     * The returned promise is resolved when the operation success, with a boolean array indicating if the splits existed or not.
-     * or rejected if it fails (e.g., wrapper operation fails).
-     */
-    removeSplits(names: string[]): Promise<void>;
-    /**
-     * Get split.
-     * 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>;
-    /**
-     * 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>>;
-    /**
-     * 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[]>;
-    /**
-     * Get list of split names.
-     * The returned promise is resolved with the list of split names,
-     * or rejected if wrapper operation fails.
-     */
-    getSplitNames(): Promise<string[]>;
-    /**
-     * Check traffic type existence.
-     * The returned promise is resolved with a boolean indicating whether the TT exist or not.
-     * In case of wrapper operation failures, the promise resolves with a true value, assuming that the TT might exist.
-     * It will never be rejected.
-     */
-    trafficTypeExists(trafficType: string): Promise<boolean>;
-    /**
-     * Set till number.
-     * The returned promise is resolved when the operation success,
-     * or rejected if it fails (e.g., wrapper operation fails).
-     */
-    setChangeNumber(changeNumber: number): Promise<boolean | void>;
-    /**
-     * Get till number or -1 if it's not defined.
-     * The returned promise is resolved with the changeNumber or -1 if it doesn't exist or a wrapper operation fails.
-     * The promise will never be rejected.
-     */
-    getChangeNumber(): Promise<number>;
-    clear(): Promise<boolean>;
-}

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

@@ -1,18 +0,0 @@
-import { ILogger } from '../../logger/types';
-import { Method } from '../../sync/submitters/types';
-import { KeyBuilderSS } from '../KeyBuilderSS';
-import { IPluggableStorageWrapper, ITelemetryCacheAsync } from '../types';
-export declare class TelemetryCachePluggable implements ITelemetryCacheAsync {
-    private readonly log;
-    private readonly keys;
-    private readonly wrapper;
-    /**
-     * Create a Telemetry cache that uses a storage wrapper.
-     * @param log  Logger instance.
-     * @param keys  Key builder.
-     * @param wrapper  Adapted wrapper storage.
-     */
-    constructor(log: ILogger, keys: KeyBuilderSS, wrapper: IPluggableStorageWrapper);
-    recordLatency(method: Method, latencyMs: number): Promise<number | void>;
-    recordException(method: Method): Promise<number | void>;
-}

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

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

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

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

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

@@ -1,9 +0,0 @@
-import { IPluggableStorageWrapper, IStorageAsyncFactory } from '../types';
-export interface PluggableStorageOptions {
-    prefix?: string;
-    wrapper: IPluggableStorageWrapper;
-}
-/**
- * Pluggable storage factory for consumer server-side & client-side SplitFactory.
- */
-export declare function PluggableStorage(options: PluggableStorageOptions): IStorageAsyncFactory;

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

@@ -1,12 +0,0 @@
-import { ILogger } from '../../logger/types';
-import { IPluggableStorageWrapper } from '../types';
-export declare 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
- * @returns an adapted version of the given storage wrapper
- */
-export declare function wrapperAdapter(log: ILogger, wrapper: IPluggableStorageWrapper): IPluggableStorageWrapper;

package/types/storages/types.d.ts

@@ -1,417 +0,0 @@
-import { MaybeThenable, IMetadata, ISplitFiltersValidation } 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 { SplitIO, ImpressionDTO, SDKMode } from '../types';
-import { ISet } from '../utils/lang/sets';
-/**
- * Interface of a pluggable storage wrapper.
- */
-export interface IPluggableStorageWrapper {
-    /** Key-Value operations */
-    /**
-     * 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`,
-     * 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.
-     * 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.
-     * 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<void>} A promise that resolves if the operation success, whether the key existed and was removed or it didn't exist.
-     * The promise rejects if the operation fails, for example, if there is a connection error.
-     */
-    del: (key: string) => Promise<boolean | void>;
-    /**
-     * 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`.
-     * 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`.
-     * 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)[]>;
-    /** Integer operations */
-    /**
-     * Increments in 1 the given `key` value or set it to 1 if the value doesn't exist.
-     *
-     * @function incr
-     * @param {string} key Key to increment
-     * @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>;
-    /**
-     * Decrements in 1 the given `key` value or set it to -1 if the value doesn't exist.
-     *
-     * @function decr
-     * @param {string} key Key to decrement
-     * @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>;
-    /** 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.
-     *
-     * @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.
-     * 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.
-     * 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.
-     * 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>;
-    /** Set operations */
-    /**
-     * 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`,
-     * 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.
-     */
-    itemContains: (key: string, item: string) => Promise<boolean>;
-    /**
-     * 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.
-     * 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.
-     * 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.
-     * 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[]>;
-    /** Control operations */
-    /**
-     * Connects to the underlying storage.
-     * 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.
-     * The promise rejects with the corresponding error if the wrapper fails to connect.
-     */
-    connect: () => Promise<void>;
-    /**
-     * Disconnects from the underlying storage.
-     * It is meant for storages that requires to be closed, in order to release resources. Otherwise it can just return a resolved promise.
-     * Note: will be called once on SplitFactory main client destroy.
-     *
-     * @function disconnect
-     * @returns {Promise<void>} A promise that resolves when the operation ends.
-     * The promise never rejects.
-     */
-    disconnect: () => Promise<void>;
-}
-/** Splits cache */
-export interface ISplitsCacheBase {
-    addSplits(entries: [string, string][]): MaybeThenable<boolean[] | void>;
-    removeSplits(names: string[]): MaybeThenable<boolean[] | void>;
-    getSplit(name: string): MaybeThenable<string | null>;
-    getSplits(names: string[]): MaybeThenable<Record<string, string | null>>;
-    setChangeNumber(changeNumber: number): MaybeThenable<boolean | void>;
-    getChangeNumber(): MaybeThenable<number>;
-    getAll(): MaybeThenable<string[]>;
-    getSplitNames(): MaybeThenable<string[]>;
-    trafficTypeExists(trafficType: string): MaybeThenable<boolean>;
-    usesSegments(): MaybeThenable<boolean>;
-    clear(): MaybeThenable<boolean | void>;
-    checkCache(): MaybeThenable<boolean>;
-    killLocally(name: string, defaultTreatment: string, changeNumber: number): MaybeThenable<boolean>;
-}
-export interface ISplitsCacheSync extends ISplitsCacheBase {
-    addSplits(entries: [string, string][]): boolean[];
-    removeSplits(names: string[]): boolean[];
-    getSplit(name: string): string | null;
-    getSplits(names: string[]): Record<string, string | null>;
-    setChangeNumber(changeNumber: number): boolean;
-    getChangeNumber(): number;
-    getAll(): string[];
-    getSplitNames(): string[];
-    trafficTypeExists(trafficType: string): boolean;
-    usesSegments(): boolean;
-    clear(): void;
-    checkCache(): boolean;
-    killLocally(name: string, defaultTreatment: string, changeNumber: number): boolean;
-}
-export interface ISplitsCacheAsync extends ISplitsCacheBase {
-    addSplits(entries: [string, string][]): Promise<boolean[] | void>;
-    removeSplits(names: string[]): Promise<boolean[] | void>;
-    getSplit(name: string): Promise<string | null>;
-    getSplits(names: string[]): Promise<Record<string, string | null>>;
-    setChangeNumber(changeNumber: number): Promise<boolean | void>;
-    getChangeNumber(): Promise<number>;
-    getAll(): Promise<string[]>;
-    getSplitNames(): Promise<string[]>;
-    trafficTypeExists(trafficType: string): Promise<boolean>;
-    usesSegments(): Promise<boolean>;
-    clear(): Promise<boolean | void>;
-    checkCache(): Promise<boolean>;
-    killLocally(name: string, defaultTreatment: string, changeNumber: number): Promise<boolean>;
-}
-/** Segments cache */
-export interface ISegmentsCacheBase {
-    addToSegment(name: string, segmentKeys: string[]): MaybeThenable<boolean | void>;
-    removeFromSegment(name: string, segmentKeys: string[]): MaybeThenable<boolean | void>;
-    isInSegment(name: string, key?: string): MaybeThenable<boolean>;
-    registerSegments(names: string[]): MaybeThenable<boolean | void>;
-    getRegisteredSegments(): MaybeThenable<string[]>;
-    setChangeNumber(name: string, changeNumber: number): MaybeThenable<boolean | void>;
-    getChangeNumber(name: string): MaybeThenable<number>;
-    clear(): MaybeThenable<boolean | void>;
-}
-export interface ISegmentsCacheSync extends ISegmentsCacheBase {
-    addToSegment(name: string, segmentKeys?: string[]): boolean;
-    removeFromSegment(name: string, segmentKeys?: string[]): boolean;
-    isInSegment(name: string, key?: string): boolean;
-    registerSegments(names: string[]): boolean;
-    getRegisteredSegments(): string[];
-    getKeysCount(): number;
-    setChangeNumber(name: string, changeNumber: number): boolean;
-    getChangeNumber(name: string): number;
-    resetSegments(names: string[]): boolean;
-    clear(): void;
-}
-export interface ISegmentsCacheAsync extends ISegmentsCacheBase {
-    addToSegment(name: string, segmentKeys: string[]): Promise<boolean | void>;
-    removeFromSegment(name: string, segmentKeys: string[]): Promise<boolean | void>;
-    isInSegment(name: string, key: string): Promise<boolean>;
-    registerSegments(names: string[]): Promise<boolean | void>;
-    getRegisteredSegments(): Promise<string[]>;
-    setChangeNumber(name: string, changeNumber: number): Promise<boolean | void>;
-    getChangeNumber(name: string): Promise<number>;
-    clear(): Promise<boolean | void>;
-}
-/** Recorder storages (impressions, events and telemetry) */
-export interface IImpressionsCacheBase {
-    track(data: ImpressionDTO[]): MaybeThenable<void>;
-}
-export interface IEventsCacheBase {
-    track(data: SplitIO.EventData, size?: number): MaybeThenable<boolean>;
-}
-/** Impressions and events cache for standalone mode (sync) */
-export interface IRecorderCacheProducerSync<T> {
-    isEmpty(): boolean;
-    clear(): void;
-    pop(toMerge?: T): T;
-}
-export interface IImpressionsCacheSync extends IImpressionsCacheBase, IRecorderCacheProducerSync<ImpressionDTO[]> {
-    track(data: ImpressionDTO[]): void;
-    setOnFullQueueCb(cb: () => void): void;
-}
-export interface IEventsCacheSync extends IEventsCacheBase, IRecorderCacheProducerSync<SplitIO.EventData[]> {
-    track(data: SplitIO.EventData, size?: number): boolean;
-    setOnFullQueueCb(cb: () => void): void;
-}
-/** Impressions and events cache for consumer and producer mode (async) */
-export interface IRecorderCacheProducerAsync<T> {
-    count(): Promise<number>;
-    drop(count?: number): Promise<void>;
-    popNWithMetadata(count: number): Promise<T>;
-}
-export interface IImpressionsCacheAsync extends IImpressionsCacheBase, IRecorderCacheProducerAsync<StoredImpressionWithMetadata[]> {
-    track(data: ImpressionDTO[]): Promise<void>;
-}
-export interface IEventsCacheAsync extends IEventsCacheBase, IRecorderCacheProducerAsync<StoredEventWithMetadata[]> {
-    track(data: SplitIO.EventData, size?: number): Promise<boolean>;
-}
-/**
- * Impression counts cache for impressions dedup in standalone and producer mode.
- * Only in memory. Named `ImpressionsCounter` in spec.
- */
-export interface IImpressionCountsCacheSync extends IRecorderCacheProducerSync<Record<string, number>> {
-    track(featureName: string, timeFrame: number, amount: number): void;
-    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;
-    isEmpty(): boolean;
-    pop(toMerge?: {
-        [featureName: string]: ISet<string>;
-    }): {
-        [featureName: string]: ISet<string>;
-    };
-}
-/**
- * Telemetry storage interface for standalone and partial consumer modes.
- * Methods are sync because data is stored in memory.
- */
-export interface ITelemetryInitConsumerSync {
-    getTimeUntilReady(): number | undefined;
-    getTimeUntilReadyFromCache(): number | undefined;
-    getNonReadyUsage(): number;
-}
-export interface ITelemetryRuntimeConsumerSync {
-    getImpressionStats(type: ImpressionDataType): number;
-    getEventStats(type: EventDataType): number;
-    getLastSynchronization(): LastSync;
-    popHttpErrors(): HttpErrors;
-    popHttpLatencies(): HttpLatencies;
-    popAuthRejections(): number;
-    popTokenRefreshes(): number;
-    popStreamingEvents(): Array<StreamingEvent>;
-    popTags(): Array<string> | undefined;
-    getSessionLength(): number | undefined;
-}
-export interface ITelemetryEvaluationConsumerSync {
-    popExceptions(): MethodExceptions;
-    popLatencies(): MethodLatencies;
-}
-export interface ITelemetryStorageConsumerSync extends ITelemetryInitConsumerSync, ITelemetryRuntimeConsumerSync, ITelemetryEvaluationConsumerSync {
-}
-export interface ITelemetryInitProducerSync {
-    recordTimeUntilReady(ms: number): void;
-    recordTimeUntilReadyFromCache(ms: number): void;
-    recordNonReadyUsage(): void;
-}
-export interface ITelemetryRuntimeProducerSync {
-    addTag(tag: string): void;
-    recordImpressionStats(type: ImpressionDataType, count: number): void;
-    recordEventStats(type: EventDataType, count: number): void;
-    recordSuccessfulSync(resource: OperationType, timeMs: number): void;
-    recordHttpError(resource: OperationType, status: number): void;
-    recordHttpLatency(resource: OperationType, latencyMs: number): void;
-    recordAuthRejections(): void;
-    recordTokenRefreshes(): void;
-    recordStreamingEvents(streamingEvent: StreamingEvent): void;
-    recordSessionLength(ms: number): void;
-}
-export interface ITelemetryEvaluationProducerSync {
-    recordLatency(method: Method, latencyMs: number): void;
-    recordException(method: Method): void;
-}
-export interface ITelemetryStorageProducerSync extends ITelemetryInitProducerSync, ITelemetryRuntimeProducerSync, ITelemetryEvaluationProducerSync {
-}
-export interface ITelemetryCacheSync extends ITelemetryStorageConsumerSync, ITelemetryStorageProducerSync {
-}
-/**
- * Telemetry storage interface for consumer mode.
- * Methods are async because data is stored in Redis or a pluggable storage.
- */
-export interface ITelemetryEvaluationConsumerAsync {
-    popExceptions(): Promise<MethodExceptions>;
-    popLatencies(): Promise<MethodLatencies>;
-}
-export interface ITelemetryEvaluationProducerAsync {
-    recordLatency(method: Method, latencyMs: number): Promise<any>;
-    recordException(method: Method): Promise<any>;
-}
-export interface ITelemetryCacheAsync extends ITelemetryEvaluationProducerAsync {
-}
-/**
- * Storages
- */
-export interface IStorageBase<TSplitsCache extends ISplitsCacheBase, TSegmentsCache extends ISegmentsCacheBase, TImpressionsCache extends IImpressionsCacheBase, TEventsCache extends IEventsCacheBase, TTelemetryCache extends ITelemetryCacheSync | ITelemetryCacheAsync, TUniqueKeysCache extends IUniqueKeysCacheBase> {
-    splits: TSplitsCache;
-    segments: TSegmentsCache;
-    impressions: TImpressionsCache;
-    impressionCounts?: IImpressionCountsCacheSync;
-    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 IStorageAsync extends IStorageBase<ISplitsCacheAsync, ISegmentsCacheAsync, IImpressionsCacheAsync | IImpressionsCacheSync, IEventsCacheAsync | IEventsCacheSync, ITelemetryCacheAsync, IUniqueKeysCacheBase> {
-}
-/** StorageFactory */
-export declare type DataLoader = (storage: IStorageSync, matchingKey: string) => void;
-export interface IStorageFactoryParams {
-    log: ILogger;
-    impressionsQueueSize?: number;
-    eventsQueueSize?: number;
-    optimize?: boolean;
-    mode: SDKMode;
-    matchingKey?: string;
-    splitFiltersValidation?: ISplitFiltersValidation;
-    onReadyCb: (error?: any) => void;
-    metadata: IMetadata;
-}
-export declare type StorageType = 'MEMORY' | 'LOCALSTORAGE' | 'REDIS' | 'PLUGGABLE';
-export declare type IStorageSyncFactory = {
-    readonly type: StorageType;
-    (params: IStorageFactoryParams): IStorageSync;
-};
-export declare type IStorageAsyncFactory = {
-    type: StorageType;
-    (params: IStorageFactoryParams): IStorageAsync;
-};

package/types/sync/offline/LocalhostFromFile.d.ts

@@ -1,2 +0,0 @@
-import { SplitIO } from '../../types';
-export declare function LocalhostFromFile(): SplitIO.LocalhostFactory;

package/types/sync/offline/LocalhostFromObject.d.ts

@@ -1,2 +0,0 @@
-import { SplitIO } from '../../types';
-export declare function LocalhostFromObject(): SplitIO.LocalhostFactory;

package/types/sync/offline/splitsParser/parseCondition.d.ts

@@ -1,7 +0,0 @@
-import { ISplitCondition } from '../../../dtos/types';
-export interface IMockSplitEntry {
-    treatment: string;
-    keys?: string[];
-    config?: string;
-}
-export declare function parseCondition(data: IMockSplitEntry): ISplitCondition;

package/types/sync/offline/splitsParser/splitsParserFromFile.d.ts

@@ -1,2 +0,0 @@
-import { ISplitsParser } from './types';
-export declare function splitsParserFromFileFactory(): ISplitsParser;

package/types/sync/offline/splitsParser/splitsParserFromSettings.d.ts

@@ -1,3 +0,0 @@
-import { ISplitPartial } from '../../../dtos/types';
-import { ISettings } from '../../../types';
-export declare function splitsParserFromSettingsFactory(): (settings: ISettings) => false | Record<string, ISplitPartial>;

package/types/sync/offline/splitsParser/types.d.ts

@@ -1,3 +0,0 @@
-import { ISplitPartial } from '../../../dtos/types';
-import { ISettings } from '../../../types';
-export declare type ISplitsParser = (settings: ISettings) => false | Record<string, ISplitPartial>;

package/types/sync/offline/syncManagerOffline.d.ts

@@ -1,10 +0,0 @@
-import { ISyncManagerCS } from '../types';
-import { ISplitsParser } from './splitsParser/types';
-import { ISdkFactoryContextSync } from '../../sdkFactory/types';
-/**
- * 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`.
- */
-export declare function syncManagerOfflineFactory(splitsParserFactory: () => ISplitsParser): (params: ISdkFactoryContextSync) => ISyncManagerCS;

package/types/sync/offline/syncTasks/fromObjectSyncTask.d.ts

@@ -1,17 +0,0 @@
-import { IReadinessManager } from '../../../readiness/types';
-import { ISplitsCacheSync } from '../../../storages/types';
-import { ISplitsParser } from '../splitsParser/types';
-import { ISyncTask } from '../../types';
-import { ISettings } from '../../../types';
-/**
- * Offline equivalent of `splitChangesUpdaterFactory`
- */
-export declare function fromObjectUpdaterFactory(splitsParser: ISplitsParser, storage: {
-    splits: ISplitsCacheSync;
-}, readiness: IReadinessManager, settings: ISettings): () => Promise<boolean>;
-/**
- * PollingManager in Offline mode
- */
-export declare function fromObjectSyncTaskFactory(splitsParser: ISplitsParser, storage: {
-    splits: ISplitsCacheSync;
-}, readiness: IReadinessManager, settings: ISettings): ISyncTask<[], boolean>;

package/types/sync/polling/fetchers/mySegmentsFetcher.d.ts

@@ -1,7 +0,0 @@
-import { IFetchMySegments } from '../../../services/types';
-import { IMySegmentsFetcher } from './types';
-/**
- * Factory of MySegments fetcher.
- * MySegments fetcher is a wrapper around `mySegments` API service that parses the response and handle errors.
- */
-export declare function mySegmentsFetcherFactory(fetchMySegments: IFetchMySegments): IMySegmentsFetcher;

package/types/sync/polling/fetchers/segmentChangesFetcher.d.ts

@@ -1,7 +0,0 @@
-import { IFetchSegmentChanges } from '../../../services/types';
-import { ISegmentChangesFetcher } from './types';
-/**
- * Factory of SegmentChanges fetcher.
- * SegmentChanges fetcher is a wrapper around `segmentChanges` API service that parses the response and handle errors and retries.
- */
-export declare function segmentChangesFetcherFactory(fetchSegmentChanges: IFetchSegmentChanges): ISegmentChangesFetcher;

package/types/sync/polling/fetchers/splitChangesFetcher.d.ts

@@ -1,7 +0,0 @@
-import { IFetchSplitChanges } from '../../../services/types';
-import { ISplitChangesFetcher } from './types';
-/**
- * Factory of SplitChanges fetcher.
- * SplitChanges fetcher is a wrapper around `splitChanges` API service that parses the response and handle errors.
- */
-export declare function splitChangesFetcherFactory(fetchSplitChanges: IFetchSplitChanges): ISplitChangesFetcher;

package/types/sync/polling/fetchers/types.d.ts

@@ -1,5 +0,0 @@
-import { ISplitChangesResponse, ISegmentChangesResponse } from '../../../dtos/types';
-import { IResponse } from '../../../services/types';
-export declare type ISplitChangesFetcher = (since: number, noCache?: boolean, till?: number, decorator?: (promise: Promise<IResponse>) => Promise<IResponse>) => Promise<ISplitChangesResponse>;
-export declare type ISegmentChangesFetcher = (since: number, segmentName: string, noCache?: boolean, till?: number, decorator?: (promise: Promise<ISegmentChangesResponse[]>) => Promise<ISegmentChangesResponse[]>) => Promise<ISegmentChangesResponse[]>;
-export declare type IMySegmentsFetcher = (userMatchingKey: string, noCache?: boolean, decorator?: (promise: Promise<IResponse>) => Promise<IResponse>) => Promise<string[]>;