@splitsoftware/splitio-commons 1.0.1-rc.2 → 1.0.1-rc.6

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/clientCS.d.ts

@@ -6,4 +6,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(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/sdkFactory/types.d.ts

@@ -3,7 +3,7 @@ import { ISignalListener } from '../listeners/types';
 import { ILogger } from '../logger/types';
 import { ISdkReadinessManager } from '../readiness/types';
 import { ISdkClientFactoryParams } from '../sdkClient/types';
-import { IFetch, ISplitApi } from '../services/types';
+import { IFetch, ISplitApi, IEventSourceConstructor } from '../services/types';
 import { IStorageAsync, IStorageSync, ISplitsCacheSync, ISplitsCacheAsync, IStorageFactoryParams } from '../storages/types';
 import { ISyncManager, ISyncManagerFactoryParams } from '../sync/types';
 import { IImpressionObserver } from '../trackers/impressionObserver/types';
@@ -15,7 +15,7 @@ import { SplitIO, ISettings, IEventEmitter } from '../types';
 export interface IPlatform {
     getOptions?: () => object;
     getFetch?: () => (IFetch | undefined);
-    getEventSource?: () => (typeof EventSource | undefined);
+    getEventSource?: () => (IEventSourceConstructor | undefined);
     EventEmitter: new () => IEventEmitter;
 }
 /**

package/types/services/types.d.ts

@@ -34,3 +34,14 @@ export interface ISplitApi {
     postMetricsCounters: IPostMetricsCounters;
     postMetricsTimes: IPostMetricsTimes;
 }
+interface EventSourceEventMap {
+    'error': Event;
+    'message': MessageEvent;
+    'open': Event;
+}
+interface IEventSource {
+    addEventListener<K extends keyof EventSourceEventMap>(type: K, listener: (this: IEventSource, ev: EventSourceEventMap[K]) => any): void;
+    close(): void;
+}
+export declare type IEventSourceConstructor = new (url: string, eventSourceInitDict?: any) => IEventSource;
+export {};

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/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/pluggable/constants.d.ts

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

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

@@ -1,13 +1,14 @@
+import { IEventSourceConstructor } from '../../../services/types';
 import { ISettings } from '../../../types';
 import { IAuthTokenPushEnabled } from '../AuthClient/types';
 import { ISSEClient, ISseEventHandler } from './types';
 /**
  * Handles streaming connections with EventSource API
  */
-export default class SSEClient implements ISSEClient {
-    eventSource: typeof EventSource;
+export declare class SSEClient implements ISSEClient {
+    eventSource?: IEventSourceConstructor;
     streamingUrl: string;
-    connection?: InstanceType<typeof EventSource>;
+    connection?: InstanceType<IEventSourceConstructor>;
     handler?: ISseEventHandler;
     useHeaders?: boolean;
     headers: Record<string, string>;
@@ -19,7 +20,7 @@ export default class SSEClient implements ISSEClient {
      * @param getEventSource Function to get the EventSource constructor.
      * @throws 'EventSource API is not available. ' if EventSource is not available.
      */
-    constructor(settings: ISettings, useHeaders?: boolean, getEventSource?: () => (typeof EventSource | undefined));
+    constructor(settings: ISettings, useHeaders?: boolean, getEventSource?: () => (IEventSourceConstructor | undefined));
     setEventHandler(handler: ISseEventHandler): void;
     /**
      * Open the connection with a given authToken

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>;

package/types/trackers/impressionsTracker.d.ts

@@ -13,4 +13,4 @@ import { ILogger } from '../logger/types';
  * @param observer optional impression observer. If provided, previous time (pt property) is included in impression instances
  * @param countsCache optional cache to save impressions count. If provided, impressions will be deduped (OPTIMIZED mode)
  */
-export default function impressionsTrackerFactory(log: ILogger, impressionsCache: IImpressionsCacheBase, { runtime: { ip, hostname }, version }: Pick<ISettings, 'version' | 'runtime'>, impressionListener?: SplitIO.IImpressionListener, integrationsManager?: IImpressionsHandler, observer?: IImpressionObserver, countsCache?: IImpressionCountsCacheSync): IImpressionsTracker;
+export declare function impressionsTrackerFactory(log: ILogger, impressionsCache: IImpressionsCacheBase, { runtime: { ip, hostname }, version }: Pick<ISettings, 'version' | 'runtime'>, impressionListener?: SplitIO.IImpressionListener, integrationsManager?: IImpressionsHandler, observer?: IImpressionObserver, countsCache?: IImpressionCountsCacheSync): IImpressionsTracker;