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

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

@@ -1,17 +0,0 @@
-/// <reference types="ioredis" />
-import { ILogger } from '../../logger/types';
-import { ImpressionCountsPayload } from '../../sync/submitters/types';
-import { ImpressionCountsCacheInMemory } from '../inMemory/ImpressionCountsCacheInMemory';
-import type { RedisAdapter } from './RedisAdapter';
-export declare class ImpressionCountsCacheInRedis extends ImpressionCountsCacheInMemory {
-    private readonly log;
-    private readonly key;
-    private readonly redis;
-    private readonly refreshRate;
-    private intervalId;
-    constructor(log: ILogger, key: string, redis: RedisAdapter, impressionCountsCacheSize?: number, refreshRate?: number);
-    private postImpressionCountsInRedis;
-    start(): void;
-    stop(): Promise<boolean | import("ioredis").BooleanResponse | undefined>;
-    getImpressionsCount(): Promise<ImpressionCountsPayload | undefined>;
-}

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

@@ -1,17 +0,0 @@
-import { IImpressionsCacheAsync } from '../types';
-import { IMetadata } from '../../dtos/types';
-import { ImpressionDTO } from '../../types';
-import { StoredImpressionWithMetadata } from '../../sync/submitters/types';
-import { ILogger } from '../../logger/types';
-import type { RedisAdapter } from './RedisAdapter';
-export declare class ImpressionsCacheInRedis implements IImpressionsCacheAsync {
-    private readonly log;
-    private readonly key;
-    private readonly redis;
-    private readonly metadata;
-    constructor(log: ILogger, key: string, redis: RedisAdapter, metadata: IMetadata);
-    track(impressions: ImpressionDTO[]): Promise<void>;
-    count(): Promise<number>;
-    drop(count?: number): Promise<any>;
-    popNWithMetadata(count: number): Promise<StoredImpressionWithMetadata[]>;
-}

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

@@ -1,24 +0,0 @@
-import ioredis from 'ioredis';
-import { ILogger } from '../../logger/types';
-/**
- * Redis adapter on top of the library of choice (written with ioredis) for some extra control.
- */
-export declare class RedisAdapter extends ioredis {
-    private readonly log;
-    private _options;
-    private _notReadyCommandsQueue?;
-    private _runningCommands;
-    constructor(log: ILogger, storageSettings?: Record<string, any>);
-    _listenToEvents(): void;
-    _setTimeoutWrappers(): void;
-    _setDisconnectWrapper(): void;
-    /**
-     * Receives the options and returns an array of parameters for the ioredis constructor.
-     * Keeping both redis setup options for backwards compatibility.
-     */
-    static _defineLibrarySettings(options: Record<string, any>): any[];
-    /**
-     * Parses the options into what we care about.
-     */
-    static _defineOptions({ connectionTimeout, operationTimeout, url, host, port, db, pass, tls }: Record<string, any>): object;
-}

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

@@ -1,21 +0,0 @@
-import { ILogger } from '../../logger/types';
-import { KeyBuilderSS } from '../KeyBuilderSS';
-import { ISegmentsCacheAsync } from '../types';
-import type { RedisAdapter } from './RedisAdapter';
-export declare class SegmentsCacheInRedis implements ISegmentsCacheAsync {
-    private readonly log;
-    private readonly redis;
-    private readonly keys;
-    constructor(log: ILogger, keys: KeyBuilderSS, redis: RedisAdapter);
-    /**
-     * Update the given segment `name` with the lists of `addedKeys`, `removedKeys` and `changeNumber`.
-     * The returned promise is resolved if the operation success, with `true` if the segment was updated (i.e., some key was added or removed),
-     * or rejected if it fails (e.g., Redis operation fails).
-     */
-    update(name: string, addedKeys: string[], removedKeys: string[], changeNumber: number): Promise<boolean>;
-    isInSegment(name: string, key: string): Promise<boolean>;
-    getChangeNumber(name: string): Promise<number>;
-    registerSegments(segments: string[]): Promise<boolean>;
-    getRegisteredSegments(): Promise<string[]>;
-    clear(): Promise<void>;
-}

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

@@ -1,95 +0,0 @@
-import { KeyBuilderSS } from '../KeyBuilderSS';
-import { ILogger } from '../../logger/types';
-import { ISplit, ISplitFiltersValidation } from '../../dtos/types';
-import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
-import type { RedisAdapter } from './RedisAdapter';
-/**
- * ISplitsCacheAsync implementation that stores split definitions in Redis.
- * Supported by Node.
- */
-export declare class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
-    private readonly log;
-    private readonly redis;
-    private readonly keys;
-    private redisError?;
-    private readonly flagSetsFilter;
-    constructor(log: ILogger, keys: KeyBuilderSS, redis: RedisAdapter, splitFiltersValidation?: ISplitFiltersValidation);
-    private _decrementCounts;
-    private _incrementCounts;
-    private _updateFlagSets;
-    /**
-     * Add a given split.
-     * The returned promise is resolved when the operation success
-     * or rejected if it fails (e.g., redis operation fails)
-     */
-    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, 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.
-     * or rejected if it fails (e.g., redis operation fails).
-     */
-    removeSplit(name: string): Promise<number>;
-    /**
-     * Remove a list of splits.
-     * The returned promise is resolved when the operation success,
-     * or rejected if it fails (e.g., redis operation fails).
-     */
-    removeSplits(names: string[]): Promise<any>;
-    /**
-     * Get split definition or null if it's not defined.
-     * Returned promise is rejected if redis operation fails.
-     */
-    getSplit(name: string): Promise<ISplit | null>;
-    /**
-     * Set till number.
-     * The returned promise is resolved when the operation success,
-     * or rejected if it fails.
-     */
-    setChangeNumber(changeNumber: number): Promise<boolean>;
-    /**
-     * 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 redis operation fails.
-     * The promise will never be rejected.
-     */
-    getChangeNumber(): Promise<number>;
-    /**
-     * Get list of all split definitions.
-     * The returned promise is resolved with the list of split definitions,
-     * or rejected if redis operation fails.
-     *
-     * @TODO we need to benchmark which is the maximun number of commands we could
-     *       pipeline without kill redis performance.
-     */
-    getAll(): Promise<ISplit[]>;
-    /**
-     * Get list of split names.
-     * The returned promise is resolved with the list of split names,
-     * or rejected if redis operation fails.
-     */
-    getSplitNames(): Promise<string[]>;
-    /**
-     * Get list of feature flag names related to a given list of flag set names.
-     * The returned promise is resolved with the list of feature flag names per flag set,
-     * or rejected if the pipelined redis operation fails (e.g., timeout).
-    */
-    getNamesByFlagSets(flagSets: string[]): Promise<Set<string>[]>;
-    /**
-     * Check traffic type existence.
-     * The returned promise is resolved with a boolean indicating whether the TT exist or not.
-     * In case of redis operation failure, the promise resolves with a true value, assuming that the TT might exist.
-     * It will never be rejected.
-     */
-    trafficTypeExists(trafficType: string): Promise<boolean>;
-    clear(): Promise<void>;
-    /**
-     * Fetches multiple splits definitions.
-     * Returned promise is rejected if redis operation fails.
-     */
-    getSplits(names: string[]): Promise<Record<string, ISplit | null>>;
-}

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

@@ -1,35 +0,0 @@
-import { ILogger } from '../../logger/types';
-import { Method, MultiConfigs, MultiMethodExceptions, MultiMethodLatencies } from '../../sync/submitters/types';
-import { KeyBuilderSS } from '../KeyBuilderSS';
-import { ITelemetryCacheAsync } from '../types';
-import type { RedisAdapter } from './RedisAdapter';
-export declare class TelemetryCacheInRedis implements ITelemetryCacheAsync {
-    private readonly log;
-    private readonly keys;
-    private readonly redis;
-    /**
-     * Create a Telemetry cache that uses Redis as storage.
-     * @param log  Logger instance.
-     * @param keys  Key builder.
-     * @param redis  Redis client.
-     */
-    constructor(log: ILogger, keys: KeyBuilderSS, redis: RedisAdapter);
-    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/UniqueKeysCacheInRedis.d.ts

@@ -1,22 +0,0 @@
-/// <reference types="ioredis" />
-import { IUniqueKeysCacheBase } from '../types';
-import { UniqueKeysCacheInMemory } from '../inMemory/UniqueKeysCacheInMemory';
-import { ILogger } from '../../logger/types';
-import { UniqueKeysItemSs } from '../../sync/submitters/types';
-import type { RedisAdapter } from './RedisAdapter';
-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: RedisAdapter, 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/inRedis/constants.d.ts

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

@@ -1,10 +0,0 @@
-import { IStorageAsyncFactory } from '../types';
-export interface InRedisStorageOptions {
-    prefix?: string;
-    options?: Record<string, any>;
-}
-/**
- * InRedis storage factory for consumer server-side SplitFactory, that uses `Ioredis` Redis client for Node.
- * @see {@link https://www.npmjs.com/package/ioredis}
- */
-export declare function InRedisStorage(options?: InRedisStorageOptions): IStorageAsyncFactory;

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

@@ -1,38 +0,0 @@
-import { IPluggableStorageWrapper, IEventsCacheAsync } from '../types';
-import { IMetadata } from '../../dtos/types';
-import { SplitIO } from '../../types';
-import { ILogger } from '../../logger/types';
-import { StoredEventWithMetadata } from '../../sync/submitters/types';
-export declare class EventsCachePluggable implements IEventsCacheAsync {
-    private readonly log;
-    private readonly wrapper;
-    private readonly key;
-    private readonly metadata;
-    constructor(log: ILogger, key: string, wrapper: IPluggableStorageWrapper, metadata: IMetadata);
-    /**
-     * Push given event to the storage.
-     * @param eventData  Event item to push.
-     * @returns  A promise that is resolved with a boolean value indicating if the push operation succeeded or failed.
-     * Unlike `impressions::track`, The promise will never be rejected.
-     */
-    track(eventData: SplitIO.EventData): Promise<boolean>;
-    private _toJSON;
-    /**
-     * Returns a promise that resolves with the count of stored events, or 0 if there was some error.
-     * The promise will never be rejected.
-     */
-    count(): Promise<number>;
-    /**
-     * Removes the given number of events from the store. If a number is not provided, it deletes all items.
-     * The returned promise rejects if the wrapper operation fails.
-     */
-    drop(count?: number): Promise<any>;
-    /**
-     * Pop the given number of events from the storage.
-     * The returned promise rejects if the wrapper 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[]>;
-}

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

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

@@ -1,34 +0,0 @@
-import { IPluggableStorageWrapper, IImpressionsCacheAsync } from '../types';
-import { IMetadata } from '../../dtos/types';
-import { ImpressionDTO } from '../../types';
-import { StoredImpressionWithMetadata } from '../../sync/submitters/types';
-import { ILogger } from '../../logger/types';
-export declare class ImpressionsCachePluggable implements IImpressionsCacheAsync {
-    private readonly log;
-    private readonly key;
-    private readonly wrapper;
-    private readonly metadata;
-    constructor(log: ILogger, key: string, wrapper: IPluggableStorageWrapper, metadata: IMetadata);
-    /**
-     * Push given impressions to the storage.
-     * @param impressions  List of impresions to push.
-     * @returns  A promise that is resolved if the push operation succeeded
-     * or rejected if the wrapper operation fails.
-     */
-    track(impressions: ImpressionDTO[]): Promise<void>;
-    /**
-     * Returns a promise that resolves with the count of stored impressions, or 0 if there was some error.
-     * The promise will never be rejected.
-     */
-    count(): Promise<number>;
-    /**
-     * Removes the given number of impressions from the store. If a number is not provided, it deletes all items.
-     * The returned promise rejects if the wrapper operation fails.
-     */
-    drop(count?: number): Promise<void>;
-    /**
-     * Pop the given number of impressions from the store.
-     * The returned promise rejects if the wrapper operation fails.
-     */
-    popNWithMetadata(count: number): Promise<StoredImpressionWithMetadata[]>;
-}

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

@@ -1,42 +0,0 @@
-import { KeyBuilderSS } from '../KeyBuilderSS';
-import { IPluggableStorageWrapper, ISegmentsCacheAsync } from '../types';
-import { ILogger } from '../../logger/types';
-/**
- * ISegmentsCacheAsync implementation for pluggable storages.
- */
-export declare class SegmentsCachePluggable implements ISegmentsCacheAsync {
-    private readonly log;
-    private readonly keys;
-    private readonly wrapper;
-    constructor(log: ILogger, keys: KeyBuilderSS, wrapper: IPluggableStorageWrapper);
-    /**
-     * Update the given segment `name` with the lists of `addedKeys`, `removedKeys` and `changeNumber`.
-     * The returned promise is resolved if the operation success, with `true` if the segment was updated (i.e., some key was added or removed),
-     * or rejected if it fails (e.g., wrapper operation fails).
-     */
-    update(name: string, addedKeys: string[], removedKeys: string[], changeNumber: number): Promise<boolean>;
-    /**
-     * Returns a promise that resolves with a boolean value indicating if `key` is part of `name` segment.
-     * Promise can be rejected if wrapper operation fails.
-     */
-    isInSegment(name: string, key: string): Promise<boolean>;
-    /**
-     * 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(name: string): Promise<number>;
-    /**
-     * Add the given segment names to the set of registered segments.
-     * The returned promise is resolved when the operation success,
-     * or rejected if it fails (e.g., wrapper operation fails).
-     */
-    registerSegments(segments: string[]): Promise<boolean | void>;
-    /**
-     * Returns a promise that resolves with the set of registered segments in a list,
-     * or rejected if it fails (e.g., wrapper operation fails).
-     */
-    getRegisteredSegments(): Promise<string[]>;
-    /** @TODO implement if required by DataLoader or Producer mode  */
-    clear(): Promise<boolean>;
-}

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

@@ -1,98 +0,0 @@
-import { KeyBuilder } from '../KeyBuilder';
-import { IPluggableStorageWrapper } from '../types';
-import { ILogger } from '../../logger/types';
-import { ISplit, ISplitFiltersValidation } from '../../dtos/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;
-    private readonly flagSetsFilter;
-    /**
-     * 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, splitFiltersValidation?: ISplitFiltersValidation);
-    private _decrementCounts;
-    private _incrementCounts;
-    private _updateFlagSets;
-    /**
-     * 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: 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, 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.
-     * or rejected if it fails (e.g., wrapper operation fails).
-     */
-    removeSplit(name: string): Promise<boolean>;
-    /**
-     * 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<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, 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<ISplit[]>;
-    /**
-     * 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[]>;
-    /**
-     * Get list of feature flag names related to a given list of flag set names.
-     * The returned promise is resolved with the list of feature flag names per flag set.
-     * It never rejects (If there is a wrapper error for some flag set, an empty set is returned for it).
-     */
-    getNamesByFlagSets(flagSets: string[]): Promise<Set<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,34 +0,0 @@
-import { ILogger } from '../../logger/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 {
-    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>;
-    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

@@ -1,20 +0,0 @@
-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<boolean | void>;
-    start(): void;
-    stop(): Promise<boolean | void>;
-    /**
-     * 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/constants.d.ts

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

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

@@ -1,12 +0,0 @@
-import { IPluggableStorageWrapper } from '../types';
-/**
- * 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 immediately.
- */
-export declare function inMemoryWrapperFactory(connDelay?: number): IPluggableStorageWrapper & {
-    _cache: Record<string, string | string[] | Set<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;