@splitsoftware/splitio-commons 1.0.1-rc.5 → 1.2.0

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;

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

@@ -6,4 +6,4 @@ import { ISettings } from '../../../types';
 /**
  * Creates a sync task that periodically executes a `segmentChangesUpdater` task
  */
-export default function segmentsSyncTaskFactory(fetchSegmentChanges: IFetchSegmentChanges, storage: IStorageSync, readiness: IReadinessManager, settings: ISettings): ISegmentsSyncTask;
+export declare function segmentsSyncTaskFactory(fetchSegmentChanges: IFetchSegmentChanges, storage: IStorageSync, readiness: IReadinessManager, settings: ISettings): ISegmentsSyncTask;

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

@@ -6,4 +6,4 @@ import { ISettings } from '../../../types';
 /**
  * Creates a sync task that periodically executes a `splitChangesUpdater` task
  */
-export default function splitsSyncTaskFactory(fetchSplitChanges: IFetchSplitChanges, storage: IStorageSync, readiness: IReadinessManager, settings: ISettings): ISplitsSyncTask;
+export declare function splitsSyncTaskFactory(fetchSplitChanges: IFetchSplitChanges, storage: IStorageSync, readiness: IReadinessManager, settings: ISettings): ISplitsSyncTask;

package/types/sync/streaming/SSEClient/index.d.ts

@@ -5,7 +5,7 @@ import { ISSEClient, ISseEventHandler } from './types';
 /**
  * Handles streaming connections with EventSource API
  */
-export default class SSEClient implements ISSEClient {
+export declare class SSEClient implements ISSEClient {
     eventSource?: IEventSourceConstructor;
     streamingUrl: string;
     connection?: InstanceType<IEventSourceConstructor>;

package/types/sync/streaming/SSEHandler/NotificationKeeper.d.ts

@@ -5,7 +5,7 @@ import { IPushEventEmitter } from '../types';
  *
  * @param pushEmitter emitter for events related to streaming support
  */
-export default function notificationKeeperFactory(pushEmitter: IPushEventEmitter): {
+export declare function notificationKeeperFactory(pushEmitter: IPushEventEmitter): {
     handleOpen(): void;
     isStreamingUp(): boolean;
     handleOccupancyEvent(publishers: number, channel: string, timestamp: number): void;

package/types/sync/streaming/SSEHandler/index.d.ts

@@ -7,4 +7,4 @@ import { ILogger } from '../../../logger/types';
  * @param log factory logger
  * @param pushEmitter emitter for events related to streaming support
  */
-export default function SSEHandlerFactory(log: ILogger, pushEmitter: IPushEventEmitter): ISseEventHandler;
+export declare function SSEHandlerFactory(log: ILogger, pushEmitter: IPushEventEmitter): ISseEventHandler;

package/types/sync/streaming/UpdateWorkers/MySegmentsUpdateWorker.d.ts

@@ -1,11 +1,11 @@
 import { ISegmentsSyncTask } from '../../polling/types';
-import Backoff from '../../../utils/Backoff';
+import { Backoff } from '../../../utils/Backoff';
 import { IUpdateWorker } from './types';
 import { SegmentsData } from '../SSEHandler/types';
 /**
  * MySegmentsUpdateWorker class
  */
-export default class MySegmentsUpdateWorker implements IUpdateWorker {
+export declare class MySegmentsUpdateWorker implements IUpdateWorker {
     private readonly mySegmentsSyncTask;
     private maxChangeNumber;
     private handleNewEvent;

package/types/sync/streaming/UpdateWorkers/SegmentsUpdateWorker.d.ts

@@ -1,12 +1,12 @@
 import { ISegmentsCacheSync } from '../../../storages/types';
-import Backoff from '../../../utils/Backoff';
+import { Backoff } from '../../../utils/Backoff';
 import { ISegmentsSyncTask } from '../../polling/types';
 import { ISegmentUpdateData } from '../SSEHandler/types';
 import { IUpdateWorker } from './types';
 /**
  * SegmentUpdateWorker class
  */
-export default class SegmentsUpdateWorker implements IUpdateWorker {
+export declare class SegmentsUpdateWorker implements IUpdateWorker {
     private readonly segmentsCache;
     private readonly segmentsSyncTask;
     private readonly maxChangeNumbers;

package/types/sync/streaming/UpdateWorkers/SplitsUpdateWorker.d.ts

@@ -1,13 +1,13 @@
 import { ISplitsEventEmitter } from '../../../readiness/types';
 import { ISplitsCacheSync } from '../../../storages/types';
-import Backoff from '../../../utils/Backoff';
+import { Backoff } from '../../../utils/Backoff';
 import { ISegmentsSyncTask, ISplitsSyncTask } from '../../polling/types';
 import { ISplitKillData, ISplitUpdateData } from '../SSEHandler/types';
 import { IUpdateWorker } from './types';
 /**
  * SplitsUpdateWorker class
  */
-export default class SplitsUpdateWorker implements IUpdateWorker {
+export declare class SplitsUpdateWorker implements IUpdateWorker {
     private readonly splitsCache;
     private readonly splitsSyncTask;
     private readonly splitsEventEmitter;

package/types/sync/streaming/UpdateWorkers/types.d.ts

@@ -1,4 +1,4 @@
-import Backoff from '../../../utils/Backoff';
+import { Backoff } from '../../../utils/Backoff';
 export interface IUpdateWorker {
     readonly backoff: Backoff;
     put(...args: any[]): void;

package/types/sync/streaming/pushManager.d.ts

@@ -10,4 +10,4 @@ import { IPlatform } from '../../sdkFactory/types';
  * - for server-side if key is not provided in settings.
  * - for client-side, with support for multiple clients, if key is provided in settings
  */
-export default function pushManagerFactory(pollingManager: IPollingManager, storage: IStorageSync, readiness: IReadinessManager, fetchAuth: IFetchAuth, platform: IPlatform, settings: ISettings): IPushManagerCS | undefined;
+export declare function pushManagerFactory(pollingManager: IPollingManager, storage: IStorageSync, readiness: IReadinessManager, fetchAuth: IFetchAuth, platform: IPlatform, settings: ISettings): IPushManagerCS | undefined;

package/types/sync/syncTask.d.ts

@@ -11,4 +11,4 @@ import { ISyncTask } from './types';
  * @param taskName  Optional task name for logging.
  * @returns A sync task that wraps the given task.
  */
-export default function syncTaskFactory<Input extends any[], Output = any>(log: ILogger, task: (...args: Input) => Promise<Output>, period: number, taskName?: string): ISyncTask<Input, Output>;
+export declare function syncTaskFactory<Input extends any[], Output = any>(log: ILogger, task: (...args: Input) => Promise<Output>, period: number, taskName?: string): ISyncTask<Input, Output>;

package/types/trackers/eventTracker.d.ts

@@ -7,4 +7,4 @@ import { ILogger } from '../logger/types';
  * @param eventsCache cache to save events
  * @param integrationsManager optional event handler used for integrations
  */
-export default function eventTrackerFactory(log: ILogger, eventsCache: IEventsCacheBase, integrationsManager?: IEventsHandler): IEventTracker;
+export declare function eventTrackerFactory(log: ILogger, eventsCache: IEventsCacheBase, integrationsManager?: IEventsHandler): IEventTracker;

package/types/trackers/impressionObserver/ImpressionObserver.d.ts

@@ -1,6 +1,6 @@
 import { ImpressionDTO } from '../../types';
 import { IImpressionObserver } from './types';
-export default class ImpressionObserver<K extends string | number = string> implements IImpressionObserver {
+export declare class ImpressionObserver<K extends string | number = string> implements IImpressionObserver {
     private cache;
     private hasher;
     constructor(size: number, hasher: (impression: ImpressionDTO) => K);

package/types/trackers/impressionObserver/impressionObserverCS.d.ts

@@ -1,4 +1,4 @@
-import ImpressionObserver from './ImpressionObserver';
+import { ImpressionObserver } from './ImpressionObserver';
 import { ImpressionDTO } from '../../types';
 export declare function hashImpression32(impression: ImpressionDTO): number;
 export declare function impressionObserverCSFactory(): ImpressionObserver<number>;

package/types/trackers/impressionObserver/impressionObserverSS.d.ts

@@ -1,4 +1,4 @@
-import ImpressionObserver from './ImpressionObserver';
+import { ImpressionObserver } from './ImpressionObserver';
 import { ImpressionDTO } from '../../types';
 export declare function hashImpression128(impression: ImpressionDTO): string;
 export declare function impressionObserverSSFactory(): ImpressionObserver<string>;