@splitsoftware/splitio-commons 1.0.1-rc.4 → 1.1.1-rc.0

package/types/evaluator/matchers/sw.d.ts

@@ -1,2 +1,2 @@
 import { ILogger } from '../../logger/types';
-export default function startsWithMatcherContext(log: ILogger, ruleAttr: string[]): (runtimeAttr: string) => boolean;
+export declare function startsWithMatcherContext(log: ILogger, ruleAttr: string[]): (runtimeAttr: string) => boolean;

package/types/evaluator/matchers/whitelist.d.ts

@@ -1,3 +1,3 @@
 import { ISet } from '../../utils/lang/sets';
 import { ILogger } from '../../logger/types';
-export default function whitelistMatcherContext(log: ILogger, ruleAttr: ISet<string>): (runtimeAttr: string) => boolean;
+export declare function whitelistMatcherContext(log: ILogger, ruleAttr: ISet<string>): (runtimeAttr: string) => boolean;

package/types/evaluator/matchersTransform/index.d.ts

@@ -3,4 +3,4 @@ import { IMatcherDto } from '../types';
 /**
  * Flat the complex matcherGroup structure into something handy.
  */
-export default function matchersTransform(matchers: ISplitMatcher[]): IMatcherDto[];
+export declare function matchersTransform(matchers: ISplitMatcher[]): IMatcherDto[];

package/types/evaluator/matchersTransform/segment.d.ts

@@ -2,4 +2,4 @@ import { IInSegmentMatcherData } from '../../dtos/types';
 /**
  * Extract segment name as a plain string.
  */
-export default function transform(segment?: IInSegmentMatcherData): string | undefined;
+export declare function segmentTransform(segment?: IInSegmentMatcherData): string | undefined;

package/types/evaluator/matchersTransform/set.d.ts

@@ -2,4 +2,4 @@ import { IWhitelistMatcherData } from '../../dtos/types';
 /**
  * Extract whitelist array. Used by set and string matchers
  */
-export default function transform(whitelistObject: IWhitelistMatcherData): string[];
+export declare function setTransform(whitelistObject: IWhitelistMatcherData): string[];

package/types/evaluator/matchersTransform/unaryNumeric.d.ts

@@ -2,4 +2,4 @@ import { IUnaryNumericMatcherData } from '../../dtos/types';
 /**
  * Extract value from unary matcher data.
  */
-export default function transform(unaryNumericObject: IUnaryNumericMatcherData): number;
+export declare function numericTransform(unaryNumericObject: IUnaryNumericMatcherData): number;

package/types/evaluator/matchersTransform/whitelist.d.ts

@@ -2,4 +2,4 @@ import { IWhitelistMatcherData } from '../../dtos/types';
 /**
  * Extract whitelist as a set. Used by 'WHITELIST' matcher.
  */
-export default function transform(whitelistObject: IWhitelistMatcherData): import("../../utils/lang/sets").ISet<string>;
+export declare function whitelistTransform(whitelistObject: IWhitelistMatcherData): import("../../utils/lang/sets").ISet<string>;

package/types/evaluator/parser/index.d.ts

@@ -2,4 +2,4 @@ import { IEvaluator } from '../types';
 import { ISplitCondition } from '../../dtos/types';
 import { IStorageAsync, IStorageSync } from '../../storages/types';
 import { ILogger } from '../../logger/types';
-export default function parser(log: ILogger, conditions: ISplitCondition[], storage: IStorageSync | IStorageAsync): IEvaluator;
+export declare function parser(log: ILogger, conditions: ISplitCondition[], storage: IStorageSync | IStorageAsync): IEvaluator;

package/types/evaluator/treatments/index.d.ts

@@ -1,5 +1,5 @@
 import { ISplitPartition } from '../../dtos/types';
-export default class Treatments {
+export declare class Treatments {
     private _ranges;
     private _treatments;
     constructor(ranges: number[], treatments: string[]);

package/types/evaluator/value/index.d.ts

@@ -4,4 +4,4 @@ import { ILogger } from '../../logger/types';
 /**
  * Defines value to be matched (key / attribute).
  */
-export default function value(log: ILogger, key: string, matcherDto: IMatcherDto, attributes: SplitIO.Attributes): string | number | boolean | (string | number)[] | import("../types").IDependencyMatcherValue | undefined;
+export declare function sanitizeValue(log: ILogger, key: string, matcherDto: IMatcherDto, attributes: SplitIO.Attributes): string | number | boolean | (string | number)[] | import("../types").IDependencyMatcherValue | undefined;

package/types/evaluator/value/sanitize.d.ts

@@ -4,4 +4,4 @@ import { ILogger } from '../../logger/types';
 /**
  * Sanitize matcher value
  */
-export default function sanitize(log: ILogger, matcherTypeID: number, value: string | number | boolean | Array<string | number> | undefined, dataType: string, attributes: SplitIO.Attributes): string | number | boolean | (string | number)[] | IDependencyMatcherValue | undefined;
+export declare function sanitize(log: ILogger, matcherTypeID: number, value: string | number | boolean | Array<string | number> | undefined, dataType: string, attributes: SplitIO.Attributes): string | number | boolean | (string | number)[] | IDependencyMatcherValue | undefined;

package/types/integrations/browser.d.ts

@@ -9,4 +9,4 @@ import { BrowserIntegration } from './ga/types';
  *
  * @returns integration manager or undefined if `integrations` are not present in settings.
  */
-export default function integrationsManagerFactory(integrations: BrowserIntegration[], params: IIntegrationFactoryParams): IIntegrationManager | undefined;
+export declare function integrationsManagerFactory(integrations: BrowserIntegration[], params: IIntegrationFactoryParams): IIntegrationManager | undefined;

package/types/integrations/pluggable.d.ts

@@ -8,4 +8,4 @@ import { IIntegration, IIntegrationManager, IIntegrationFactoryParams } from './
  *
  * @returns integration manager or undefined if `integrations` are not present in settings.
  */
-export default function integrationsManagerFactory(integrations: Array<(params: IIntegrationFactoryParams) => IIntegration | void>, params: IIntegrationFactoryParams): IIntegrationManager | undefined;
+export declare function pluggableIntegrationsManagerFactory(integrations: Array<(params: IIntegrationFactoryParams) => IIntegration | void>, params: IIntegrationFactoryParams): IIntegrationManager | undefined;

package/types/listeners/browser.d.ts

@@ -6,7 +6,7 @@ import { ISyncManager } from '../sync/types';
 /**
  * We'll listen for 'unload' event over the window object, since it's the standard way to listen page reload and close.
  */
-export default class BrowserSignalListener implements ISignalListener {
+export declare class BrowserSignalListener implements ISignalListener {
     private syncManager;
     private settings;
     private storage;

package/types/listeners/node.d.ts

@@ -8,7 +8,7 @@ import { ISyncManager } from '../sync/types';
  * you should call the cleanup logic yourself, since we cannot ensure the data is sent after
  * the process is already exiting.
  */
-export default class NodeSignalListener implements ISignalListener {
+export declare class NodeSignalListener implements ISignalListener {
     private handler;
     private settings;
     constructor(syncManager: ISyncManager | undefined, // private handler: () => MaybeThenable<void>,

package/types/readiness/sdkReadinessManager.d.ts

@@ -10,4 +10,4 @@ import { ILogger } from '../logger/types';
  * by the SDK. It is required to properly log the warning 'No listeners for SDK Readiness detected'
  * @param readinessManager optional readinessManager to use. only used internally for `shared` method
  */
-export default function sdkReadinessManagerFactory(log: ILogger, EventEmitter: new () => IEventEmitter, readyTimeout?: number, internalReadyCbCount?: number, readinessManager?: import("./types").IReadinessManager): ISdkReadinessManager;
+export declare function sdkReadinessManagerFactory(log: ILogger, EventEmitter: new () => IEventEmitter, readyTimeout?: number, internalReadyCbCount?: number, readinessManager?: import("./types").IReadinessManager): ISdkReadinessManager;

package/types/sdkClient/client.d.ts

@@ -3,4 +3,4 @@ import { SplitIO } from '../types';
 /**
  * Creator of base client with getTreatments and track methods.
  */
-export default function clientFactory(params: IClientFactoryParams): SplitIO.IClient | SplitIO.IAsyncClient;
+export declare function clientFactory(params: IClientFactoryParams): SplitIO.IClient | SplitIO.IAsyncClient;

package/types/sdkClient/clientAttributesDecoration.d.ts

@@ -0,0 +1,51 @@
+import { SplitIO } from '../types';
+import { ILogger } from '../logger/types';
+/**
+ * Add in memory attributes storage methods and combine them with any attribute received from the getTreatment/s call
+ */
+export declare function clientAttributesDecoration<TClient extends SplitIO.IClient | SplitIO.IAsyncClient>(log: ILogger, client: TClient): TClient & {
+    getTreatment: (maybeKey: SplitIO.SplitKey, maybeSplit: string, maybeAttributes?: SplitIO.Attributes | undefined) => string | SplitIO.AsyncTreatment;
+    getTreatmentWithConfig: (maybeKey: SplitIO.SplitKey, maybeSplit: string, maybeAttributes?: SplitIO.Attributes | undefined) => SplitIO.TreatmentWithConfig | SplitIO.AsyncTreatmentWithConfig;
+    getTreatments: (maybeKey: SplitIO.SplitKey, maybeSplits: string[], maybeAttributes?: SplitIO.Attributes | undefined) => SplitIO.Treatments | SplitIO.AsyncTreatments;
+    getTreatmentsWithConfig: (maybeKey: SplitIO.SplitKey, maybeSplits: string[], maybeAttributes?: SplitIO.Attributes | undefined) => SplitIO.TreatmentsWithConfig | SplitIO.AsyncTreatmentsWithConfig;
+    track: (maybeKey: SplitIO.SplitKey, maybeTT: string, maybeEvent: string, maybeEventValue?: number | undefined, maybeProperties?: SplitIO.Properties | undefined) => import("../dtos/types").MaybeThenable<boolean>;
+    /**
+     * Add an attribute to client's in memory attributes storage
+     *
+     * @param {string} attributeName Attrinute name
+     * @param {string, number, boolean, list} attributeValue Attribute value
+     * @returns {boolean} true if the attribute was stored and false otherways
+     */
+    setAttribute(attributeName: string, attributeValue: Object): boolean;
+    /**
+     * Returns the attribute with the given key
+     *
+     * @param {string} attributeName Attribute name
+     * @returns {Object} Attribute with the given key
+     */
+    getAttribute(attributeName: string): Object;
+    /**
+     * Add to client's in memory attributes storage the attributes in 'attributes'
+     *
+     * @param {Object} attributes Object with attributes to store
+     * @returns true if attributes were stored an false otherways
+     */
+    setAttributes(attributes: Record<string, Object>): boolean;
+    /**
+     * Return all the attributes stored in client's in memory attributes storage
+     *
+     * @returns {Object} returns all the stored attributes
+     */
+    getAttributes(): Record<string, Object>;
+    /**
+     * Removes from client's in memory attributes storage the attribute with the given key
+     *
+     * @param {string} attributeName
+     * @returns {boolean} true if attribute was removed and false otherways
+     */
+    removeAttribute(attributeName: string): boolean;
+    /**
+     * Remove all the stored attributes in the client's in memory attribute storage
+     */
+    clearAttributes(): boolean;
+};

package/types/sdkClient/clientCS.d.ts

@@ -1,3 +1,4 @@
+import { ILogger } from '../logger/types';
 import { SplitIO } from '../types';
 /**
  * Decorator that binds a key and (optionally) a traffic type to client methods
@@ -6,4 +7,4 @@ import { SplitIO } from '../types';
  * @param key validated split key
  * @param trafficType validated traffic type
  */
-export default function clientCSDecorator(client: SplitIO.IClient, key: SplitIO.SplitKey, trafficType?: string): SplitIO.ICsClient;
+export declare function clientCSDecorator(log: ILogger, client: SplitIO.IClient, key: SplitIO.SplitKey, trafficType?: string): SplitIO.ICsClient;

package/types/sdkClient/clientInputValidation.d.ts

@@ -5,4 +5,4 @@ import { ILogger } from '../logger/types';
  * Decorator that validates the input before actually executing the client methods.
  * We should "guard" the client here, while not polluting the "real" implementation of those methods.
  */
-export default function clientInputValidationDecorator<TClient extends SplitIO.IClient | SplitIO.IAsyncClient>(log: ILogger, client: TClient, readinessManager: IReadinessManager, isStorageSync?: boolean): TClient;
+export declare function clientInputValidationDecorator<TClient extends SplitIO.IClient | SplitIO.IAsyncClient>(log: ILogger, client: TClient, readinessManager: IReadinessManager, isStorageSync?: boolean): TClient;

package/types/storages/AbstractSegmentsCacheSync.d.ts

@@ -3,7 +3,7 @@ import { ISegmentsCacheSync } from './types';
  * This class provides a skeletal implementation of the ISegmentsCacheSync interface
  * to minimize the effort required to implement this interface.
  */
-export default abstract class AbstractSegmentsCacheSync implements ISegmentsCacheSync {
+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.

package/types/storages/AbstractSplitsCacheAsync.d.ts

@@ -3,7 +3,7 @@ import { ISplitsCacheAsync } from './types';
  * This class provides a skeletal implementation of the ISplitsCacheAsync interface
  * to minimize the effort required to implement this interface.
  */
-export default abstract class AbstractSplitsCacheAsync implements ISplitsCacheAsync {
+export declare abstract class AbstractSplitsCacheAsync implements ISplitsCacheAsync {
     abstract addSplit(name: string, split: string): Promise<boolean>;
     abstract addSplits(entries: [string, string][]): Promise<boolean[] | void>;
     abstract removeSplits(names: string[]): Promise<boolean[] | void>;

package/types/storages/AbstractSplitsCacheSync.d.ts

@@ -4,7 +4,7 @@ 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 default abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
+export declare abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
     abstract addSplit(name: string, split: string): boolean;
     addSplits(entries: [string, string][]): boolean[];
     abstract removeSplit(name: string): boolean;

package/types/storages/KeyBuilder.d.ts

@@ -1,5 +1,5 @@
 export declare function validatePrefix(prefix: unknown): string;
-export default class KeyBuilder {
+export declare class KeyBuilder {
     protected readonly prefix: string;
     constructor(prefix?: string);
     buildTrafficTypeKey(trafficType: string): string;

package/types/storages/KeyBuilderCS.d.ts

@@ -1,5 +1,5 @@
-import KeyBuilder from './KeyBuilder';
-export default class KeyBuilderCS extends KeyBuilder {
+import { KeyBuilder } from './KeyBuilder';
+export declare class KeyBuilderCS extends KeyBuilder {
     protected readonly regexSplitsCacheKey: RegExp;
     protected readonly matchingKey: string;
     constructor(prefix: string, matchingKey: string);

package/types/storages/KeyBuilderSS.d.ts

@@ -1,6 +1,6 @@
-import KeyBuilder from './KeyBuilder';
+import { KeyBuilder } from './KeyBuilder';
 import { IMetadata } from '../dtos/types';
-export default class KeyBuilderSS extends KeyBuilder {
+export declare class KeyBuilderSS extends KeyBuilder {
     protected readonly metadata: IMetadata;
     constructor(prefix: string, metadata: IMetadata);
     buildRegisteredSegmentsKey(): string;

package/types/storages/findLatencyIndex.d.ts

@@ -1 +1 @@
-export default function findLatencyIndex(latency: number, min?: number, max?: number, base?: number): number;
+export declare function findLatencyIndex(latency: number, min?: number, max?: number, base?: number): number;

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

@@ -1,7 +1,7 @@
 import { ILogger } from '../../logger/types';
-import AbstractSegmentsCacheSync from '../AbstractSegmentsCacheSync';
-import KeyBuilderCS from '../KeyBuilderCS';
-export default class MySegmentsCacheInLocal extends AbstractSegmentsCacheSync {
+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);

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

@@ -1,11 +1,11 @@
 import { ISplitFiltersValidation } from '../../dtos/types';
-import AbstractSplitsCacheSync from '../AbstractSplitsCacheSync';
-import KeyBuilderCS from '../KeyBuilderCS';
+import { AbstractSplitsCacheSync } from '../AbstractSplitsCacheSync';
+import { KeyBuilderCS } from '../KeyBuilderCS';
 import { ILogger } from '../../logger/types';
 /**
  * ISplitsCacheSync implementation that stores split definitions in browser LocalStorage.
  */
-export default class SplitsCacheInLocal extends AbstractSplitsCacheSync {
+export declare class SplitsCacheInLocal extends AbstractSplitsCacheSync {
     private readonly log;
     private readonly keys;
     private readonly splitFiltersValidation;

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

@@ -1,5 +1,5 @@
 import { ICountsCacheSync } from '../types';
-export default class CountsCacheInMemory implements ICountsCacheSync {
+export declare class CountsCacheInMemory implements ICountsCacheSync {
     private counters;
     /**
      * Add counts.

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

@@ -1,6 +1,6 @@
 import { SplitIO } from '../../types';
 import { IEventsCacheSync } from '../types';
-export default class EventsCacheInMemory implements IEventsCacheSync {
+export declare class EventsCacheInMemory implements IEventsCacheSync {
     private onFullQueue?;
     private readonly maxQueue;
     private queue;

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

@@ -1,5 +1,5 @@
 import { IImpressionCountsCacheSync } from '../types';
-export default class ImpressionCountsCacheInMemory implements IImpressionCountsCacheSync {
+export declare class ImpressionCountsCacheInMemory implements IImpressionCountsCacheSync {
     private cache;
     /**
     * Builds key to be stored in the cache with the featureName and the timeFrame truncated.

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

@@ -1,6 +1,6 @@
 import { IImpressionsCacheSync } from '../types';
 import { ImpressionDTO } from '../../types';
-export default class ImpressionsCacheInMemory implements IImpressionsCacheSync {
+export declare class ImpressionsCacheInMemory implements IImpressionsCacheSync {
     private queue;
     /**
      * Store impressions in sequential order

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

@@ -1,5 +1,5 @@
 import { ILatenciesCacheSync } from '../types';
-export default class LatenciesCacheInMemory implements ILatenciesCacheSync {
+export declare class LatenciesCacheInMemory implements ILatenciesCacheSync {
     private counters;
     /**
      * Add latencies.

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

@@ -1,9 +1,9 @@
-import AbstractSegmentsCacheSync from '../AbstractSegmentsCacheSync';
+import { AbstractSegmentsCacheSync } from '../AbstractSegmentsCacheSync';
 /**
  * Default MySegmentsCacheInMemory implementation that stores MySegments in memory.
  * Supported by all JS runtimes.
  */
-export default class MySegmentsCacheInMemory extends AbstractSegmentsCacheSync {
+export declare class MySegmentsCacheInMemory extends AbstractSegmentsCacheSync {
     private segmentCache;
     clear(): void;
     addToSegment(name: string): boolean;

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

@@ -1,9 +1,9 @@
-import AbstractSegmentsCacheSync from '../AbstractSegmentsCacheSync';
+import { AbstractSegmentsCacheSync } from '../AbstractSegmentsCacheSync';
 /**
  * Default ISplitsCacheSync implementation that stores split definitions in memory.
  * Supported by all JS runtimes.
  */
-export default class SegmentsCacheInMemory extends AbstractSegmentsCacheSync {
+export declare class SegmentsCacheInMemory extends AbstractSegmentsCacheSync {
     private segmentCache;
     private segmentChangeNumber;
     addToSegment(name: string, segmentKeys: string[]): boolean;

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

@@ -1,9 +1,9 @@
-import AbstractSplitsCacheSync from '../AbstractSplitsCacheSync';
+import { AbstractSplitsCacheSync } from '../AbstractSplitsCacheSync';
 /**
  * Default ISplitsCacheSync implementation that stores split definitions in memory.
  * Supported by all JS runtimes.
  */
-export default class SplitsCacheInMemory extends AbstractSplitsCacheSync {
+export declare class SplitsCacheInMemory extends AbstractSplitsCacheSync {
     private splitsCache;
     private ttCache;
     private changeNumber;

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

@@ -1,7 +1,7 @@
 import { ICountsCacheAsync } from '../types';
-import KeyBuilderSS from '../KeyBuilderSS';
+import { KeyBuilderSS } from '../KeyBuilderSS';
 import { Redis } from 'ioredis';
-export default class CountsCacheInRedis implements ICountsCacheAsync {
+export declare class CountsCacheInRedis implements ICountsCacheAsync {
     private readonly redis;
     private readonly keys;
     constructor(keys: KeyBuilderSS, redis: Redis);

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

@@ -4,7 +4,7 @@ import { Redis } from 'ioredis';
 import { SplitIO } from '../../types';
 import { ILogger } from '../../logger/types';
 import { StoredEventWithMetadata } from '../../sync/submitters/types';
-export default class EventsCacheInRedis implements IEventsCacheAsync {
+export declare class EventsCacheInRedis implements IEventsCacheAsync {
     private readonly log;
     private readonly key;
     private readonly redis;

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

@@ -4,7 +4,7 @@ import { ImpressionDTO } from '../../types';
 import { Redis } from 'ioredis';
 import { StoredImpressionWithMetadata } from '../../sync/submitters/types';
 import { ILogger } from '../../logger/types';
-export default class ImpressionsCacheInRedis implements IImpressionsCacheAsync {
+export declare class ImpressionsCacheInRedis implements IImpressionsCacheAsync {
     private readonly log;
     private readonly key;
     private readonly redis;

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

@@ -1,7 +1,7 @@
 import { ILatenciesCacheAsync } from '../types';
-import KeyBuilderSS from '../KeyBuilderSS';
+import { KeyBuilderSS } from '../KeyBuilderSS';
 import { Redis } from 'ioredis';
-export default class LatenciesCacheInRedis implements ILatenciesCacheAsync {
+export declare class LatenciesCacheInRedis implements ILatenciesCacheAsync {
     private readonly redis;
     private readonly keys;
     constructor(keys: KeyBuilderSS, redis: Redis);

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

@@ -3,7 +3,7 @@ import { ILogger } from '../../logger/types';
 /**
  * Redis adapter on top of the library of choice (written with ioredis) for some extra control.
  */
-export default class RedisAdapter extends ioredis {
+export declare class RedisAdapter extends ioredis {
     private readonly log;
     private _options;
     private _notReadyCommandsQueue?;

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

@@ -1,8 +1,8 @@
 import { Redis } from 'ioredis';
 import { ILogger } from '../../logger/types';
-import KeyBuilderSS from '../KeyBuilderSS';
+import { KeyBuilderSS } from '../KeyBuilderSS';
 import { ISegmentsCacheAsync } from '../types';
-export default class SegmentsCacheInRedis implements ISegmentsCacheAsync {
+export declare class SegmentsCacheInRedis implements ISegmentsCacheAsync {
     private readonly log;
     private readonly redis;
     private readonly keys;

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

@@ -1,12 +1,12 @@
-import KeyBuilderSS from '../KeyBuilderSS';
+import { KeyBuilderSS } from '../KeyBuilderSS';
 import { Redis } from 'ioredis';
 import { ILogger } from '../../logger/types';
-import AbstractSplitsCacheAsync from '../AbstractSplitsCacheAsync';
+import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
 /**
  * ISplitsCacheAsync implementation that stores split definitions in Redis.
  * Supported by Node.
  */
-export default class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
+export declare class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
     private readonly log;
     private readonly redis;
     private readonly keys;

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

@@ -1,4 +1,4 @@
-import KeyBuilderSS from '../KeyBuilderSS';
+import { KeyBuilderSS } from '../KeyBuilderSS';
 import { IPluggableStorageWrapper, ISegmentsCacheAsync } from '../types';
 import { ILogger } from '../../logger/types';
 /**

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

@@ -1,7 +1,7 @@
-import KeyBuilder from '../KeyBuilder';
+import { KeyBuilder } from '../KeyBuilder';
 import { IPluggableStorageWrapper } from '../types';
 import { ILogger } from '../../logger/types';
-import AbstractSplitsCacheAsync from '../AbstractSplitsCacheAsync';
+import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
 /**
  * ISplitsCacheAsync implementation for pluggable storages.
  */

package/types/storages/types.d.ts

@@ -65,7 +65,7 @@ export interface IPluggableStorageWrapper {
     getMany: (keys: string[]) => Promise<(string | null)[]>;
     /** Integer operations */
     /**
-     * Increments in 1 the given `key` value or set it in 1 if the value doesn't exist.
+     * 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
@@ -74,7 +74,7 @@ export interface IPluggableStorageWrapper {
      */
     incr: (key: string) => Promise<number>;
     /**
-     * Decrements in 1 the given `key` value or set it in -1 if the value doesn't exist.
+     * 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

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

@@ -4,4 +4,4 @@ export interface IMockSplitEntry {
     keys?: string[];
     config?: string;
 }
-export default function parseCondition(data: IMockSplitEntry): ISplitCondition;
+export declare function parseCondition(data: IMockSplitEntry): ISplitCondition;

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

@@ -12,6 +12,6 @@ export declare function fromObjectUpdaterFactory(splitsParser: ISplitsParser, st
 /**
  * PollingManager in Offline mode
  */
-export default function fromObjectSyncTaskFactory(splitsParser: ISplitsParser, storage: {
+export declare function fromObjectSyncTaskFactory(splitsParser: ISplitsParser, storage: {
     splits: ISplitsCacheSync;
 }, readiness: IReadinessManager, settings: ISettings): ISyncTask<[], boolean>;

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

@@ -4,4 +4,4 @@ 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 default function mySegmentsFetcherFactory(fetchMySegments: IFetchMySegments, userMatchingKey: string): IMySegmentsFetcher;
+export declare function mySegmentsFetcherFactory(fetchMySegments: IFetchMySegments, userMatchingKey: string): IMySegmentsFetcher;

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

@@ -4,4 +4,4 @@ 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 default function segmentChangesFetcherFactory(fetchSegmentChanges: IFetchSegmentChanges): ISegmentChangesFetcher;
+export declare function segmentChangesFetcherFactory(fetchSegmentChanges: IFetchSegmentChanges): ISegmentChangesFetcher;

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

@@ -4,4 +4,4 @@ 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 default function splitChangesFetcherFactory(fetchSplitChanges: IFetchSplitChanges): ISplitChangesFetcher;
+export declare function splitChangesFetcherFactory(fetchSplitChanges: IFetchSplitChanges): ISplitChangesFetcher;

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

@@ -7,4 +7,4 @@ import { ISettings } from '../../types';
  * Expose start / stop mechanism for polling data from services.
  * For client-side API with multiple clients.
  */
-export default function pollingManagerCSFactory(splitApi: ISplitApi, storage: IStorageSync, readiness: IReadinessManager, settings: ISettings): IPollingManagerCS;
+export declare function pollingManagerCSFactory(splitApi: ISplitApi, storage: IStorageSync, readiness: IReadinessManager, settings: ISettings): IPollingManagerCS;

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

@@ -6,4 +6,4 @@ import { IPollingManager } from './types';
 /**
  * Expose start / stop mechanism for pulling data from services.
  */
-export default function pollingManagerSSFactory(splitApi: ISplitApi, storage: IStorageSync, readiness: IReadinessManager, settings: ISettings): IPollingManager;
+export declare function pollingManagerSSFactory(splitApi: ISplitApi, storage: IStorageSync, readiness: IReadinessManager, settings: ISettings): IPollingManager;

package/types/sync/polling/syncTasks/mySegmentsSyncTask.d.ts

@@ -6,4 +6,4 @@ import { ISettings } from '../../../types';
 /**
  * Creates a sync task that periodically executes a `mySegmentsUpdater` task
  */
-export default function mySegmentsSyncTaskFactory(fetchMySegments: IFetchMySegments, storage: IStorageSync, readiness: IReadinessManager, settings: ISettings, matchingKey: string): ISegmentsSyncTask;
+export declare function mySegmentsSyncTaskFactory(fetchMySegments: IFetchMySegments, storage: IStorageSync, readiness: IReadinessManager, settings: ISettings, matchingKey: string): ISegmentsSyncTask;