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

package/types/storages/types.d.ts

@@ -0,0 +1,414 @@
+import { MaybeThenable, IMetadata, ISplitFiltersValidation } from '../dtos/types';
+import { ILogger } from '../logger/types';
+import { EventDataType, HttpErrors, HttpLatencies, ImpressionDataType, LastSync, Method, MethodExceptions, MethodLatencies, OperationType, StoredEventWithMetadata, StoredImpressionWithMetadata, StreamingEvent, UniqueKeysPayloadCs, UniqueKeysPayloadSs } from '../sync/submitters/types';
+import { SplitIO, ImpressionDTO, SDKMode } from '../types';
+/**
+ * Interface of a pluggable storage wrapper.
+ */
+export interface IPluggableStorageWrapper {
+    /** Key-Value operations */
+    /**
+     * Get the value of given `key`.
+     *
+     * @function get
+     * @param {string} key Item to retrieve
+     * @returns {Promise<string | null>} A promise that resolves with the element value associated with the specified `key`,
+     * or null if the key does not exist. The promise rejects if the operation fails.
+     */
+    get: (key: string) => Promise<string | null>;
+    /**
+     * Add or update an item with a specified `key` and `value`.
+     *
+     * @function set
+     * @param {string} key Item to update
+     * @param {string} value Value to set
+     * @returns {Promise<void>} A promise that resolves if the operation success, whether the key was added or updated.
+     * The promise rejects if the operation fails.
+     */
+    set: (key: string, value: string) => Promise<boolean | void>;
+    /**
+     * Add or update an item with a specified `key` and `value`.
+     *
+     * @function getAndSet
+     * @param {string} key Item to update
+     * @param {string} value Value to set
+     * @returns {Promise<string | null>} A promise that resolves with the previous value associated to the given `key`, or null if not set.
+     * The promise rejects if the operation fails.
+     */
+    getAndSet: (key: string, value: string) => Promise<string | null>;
+    /**
+     * Removes the specified item by `key`.
+     *
+     * @function del
+     * @param {string} key Item to delete
+     * @returns {Promise<void>} A promise that resolves if the operation success, whether the key existed and was removed or it didn't exist.
+     * The promise rejects if the operation fails, for example, if there is a connection error.
+     */
+    del: (key: string) => Promise<boolean | void>;
+    /**
+     * Returns all keys matching the given prefix.
+     *
+     * @function getKeysByPrefix
+     * @param {string} prefix String prefix to match
+     * @returns {Promise<string[]>} A promise that resolves with the list of keys that match the given `prefix`.
+     * The promise rejects if the operation fails.
+     */
+    getKeysByPrefix: (prefix: string) => Promise<string[]>;
+    /**
+     * Returns the values of all given `keys`.
+     *
+     * @function getMany
+     * @param {string[]} keys List of keys to retrieve
+     * @returns {Promise<(string | null)[]>} A promise that resolves with the list of items associated with the specified list of `keys`.
+     * For every key that does not hold a string value or does not exist, null is returned. The promise rejects if the operation fails.
+     */
+    getMany: (keys: string[]) => Promise<(string | null)[]>;
+    /** Integer operations */
+    /**
+     * Increments in 1 the given `key` value or set it to 1 if the value doesn't exist.
+     *
+     * @function incr
+     * @param {string} key Key to increment
+     * @returns {Promise<number>} A promise that resolves with the value of key after the increment. The promise rejects if the operation fails,
+     * for example, if there is a connection error or the key contains a string that can not be represented as integer.
+     */
+    incr: (key: string) => Promise<number>;
+    /**
+     * Decrements in 1 the given `key` value or set it to -1 if the value doesn't exist.
+     *
+     * @function decr
+     * @param {string} key Key to decrement
+     * @returns {Promise<number>} A promise that resolves with the value of key after the decrement. The promise rejects if the operation fails,
+     * for example, if there is a connection error or the key contains a string that can not be represented as integer.
+     */
+    decr: (key: string) => Promise<number>;
+    /** Queue operations */
+    /**
+     * Inserts given items at the tail of `key` list. If `key` does not exist, an empty list is created before pushing the items.
+     *
+     * @function pushItems
+     * @param {string} key List key
+     * @param {string[]} items List of items to push
+     * @returns {Promise<void>} A promise that resolves if the operation success.
+     * The promise rejects if the operation fails, for example, if there is a connection error or the key holds a value that is not a list.
+     */
+    pushItems: (key: string, items: string[]) => Promise<void>;
+    /**
+     * Removes and returns the first `count` items from a list. If `key` does not exist, an empty list is items is returned.
+     *
+     * @function popItems
+     * @param {string} key List key
+     * @param {number} count Number of items to pop
+     * @returns {Promise<string[]>} A promise that resolves with the list of removed items from the list, or an empty array when key does not exist.
+     * The promise rejects if the operation fails, for example, if there is a connection error or the key holds a value that is not a list.
+     */
+    popItems: (key: string, count: number) => Promise<string[]>;
+    /**
+     * Returns the count of items in a list, or 0 if `key` does not exist.
+     *
+     * @function getItemsCount
+     * @param {string} key List key
+     * @returns {Promise<number>} A promise that resolves with the number of items at the `key` list, or 0 when `key` does not exist.
+     * The promise rejects if the operation fails, for example, if there is a connection error or the key holds a value that is not a list.
+     */
+    getItemsCount: (key: string) => Promise<number>;
+    /** Set operations */
+    /**
+     * Returns if item is a member of a set.
+     *
+     * @function itemContains
+     * @param {string} key Set key
+     * @param {string} item Item value
+     * @returns {Promise<boolean>} A promise that resolves with true boolean value if `item` is a member of the set stored at `key`,
+     * or false if it is not a member or `key` set does not exist. The promise rejects if the operation fails, for example,
+     * if there is a connection error or the key holds a value that is not a set.
+     */
+    itemContains: (key: string, item: string) => Promise<boolean>;
+    /**
+     * Add the specified `items` to the set stored at `key`. Those items that are already part of the set are ignored.
+     * If key does not exist, an empty set is created before adding the items.
+     *
+     * @function addItems
+     * @param {string} key Set key
+     * @param {string} items Items to add
+     * @returns {Promise<boolean | void>} A promise that resolves if the operation success.
+     * The promise rejects if the operation fails, for example, if there is a connection error or the key holds a value that is not a set.
+     */
+    addItems: (key: string, items: string[]) => Promise<boolean | void>;
+    /**
+     * Remove the specified `items` from the set stored at `key`. Those items that are not part of the set are ignored.
+     *
+     * @function removeItems
+     * @param {string} key Set key
+     * @param {string} items Items to remove
+     * @returns {Promise<boolean | void>} A promise that resolves if the operation success. If key does not exist, the promise also resolves.
+     * The promise rejects if the operation fails, for example, if there is a connection error or the key holds a value that is not a set.
+     */
+    removeItems: (key: string, items: string[]) => Promise<boolean | void>;
+    /**
+     * Returns all the items of the `key` set.
+     *
+     * @function getItems
+     * @param {string} key Set key
+     * @returns {Promise<string[]>} A promise that resolves with the list of items. If key does not exist, the result is an empty list.
+     * The promise rejects if the operation fails, for example, if there is a connection error or the key holds a value that is not a set.
+     */
+    getItems: (key: string) => Promise<string[]>;
+    /** Control operations */
+    /**
+     * Connects to the underlying storage.
+     * It is meant for storages that requires to be connected to some database or server. Otherwise it can just return a resolved promise.
+     * Note: will be called once on SplitFactory instantiation and once per each shared client instantiation.
+     *
+     * @function connect
+     * @returns {Promise<void>} A promise that resolves when the wrapper successfully connect to the underlying storage.
+     * The promise rejects with the corresponding error if the wrapper fails to connect.
+     */
+    connect: () => Promise<void>;
+    /**
+     * Disconnects from the underlying storage.
+     * It is meant for storages that requires to be closed, in order to release resources. Otherwise it can just return a resolved promise.
+     * Note: will be called once on SplitFactory main client destroy.
+     *
+     * @function disconnect
+     * @returns {Promise<void>} A promise that resolves when the operation ends.
+     * The promise never rejects.
+     */
+    disconnect: () => Promise<void>;
+}
+/** Splits cache */
+export interface ISplitsCacheBase {
+    addSplits(entries: [string, string][]): MaybeThenable<boolean[] | void>;
+    removeSplits(names: string[]): MaybeThenable<boolean[] | void>;
+    getSplit(name: string): MaybeThenable<string | null>;
+    getSplits(names: string[]): MaybeThenable<Record<string, string | null>>;
+    setChangeNumber(changeNumber: number): MaybeThenable<boolean | void>;
+    getChangeNumber(): MaybeThenable<number>;
+    getAll(): MaybeThenable<string[]>;
+    getSplitNames(): MaybeThenable<string[]>;
+    trafficTypeExists(trafficType: string): MaybeThenable<boolean>;
+    usesSegments(): MaybeThenable<boolean>;
+    clear(): MaybeThenable<boolean | void>;
+    checkCache(): MaybeThenable<boolean>;
+    killLocally(name: string, defaultTreatment: string, changeNumber: number): MaybeThenable<boolean>;
+}
+export interface ISplitsCacheSync extends ISplitsCacheBase {
+    addSplits(entries: [string, string][]): boolean[];
+    removeSplits(names: string[]): boolean[];
+    getSplit(name: string): string | null;
+    getSplits(names: string[]): Record<string, string | null>;
+    setChangeNumber(changeNumber: number): boolean;
+    getChangeNumber(): number;
+    getAll(): string[];
+    getSplitNames(): string[];
+    trafficTypeExists(trafficType: string): boolean;
+    usesSegments(): boolean;
+    clear(): void;
+    checkCache(): boolean;
+    killLocally(name: string, defaultTreatment: string, changeNumber: number): boolean;
+}
+export interface ISplitsCacheAsync extends ISplitsCacheBase {
+    addSplits(entries: [string, string][]): Promise<boolean[] | void>;
+    removeSplits(names: string[]): Promise<boolean[] | void>;
+    getSplit(name: string): Promise<string | null>;
+    getSplits(names: string[]): Promise<Record<string, string | null>>;
+    setChangeNumber(changeNumber: number): Promise<boolean | void>;
+    getChangeNumber(): Promise<number>;
+    getAll(): Promise<string[]>;
+    getSplitNames(): Promise<string[]>;
+    trafficTypeExists(trafficType: string): Promise<boolean>;
+    usesSegments(): Promise<boolean>;
+    clear(): Promise<boolean | void>;
+    checkCache(): Promise<boolean>;
+    killLocally(name: string, defaultTreatment: string, changeNumber: number): Promise<boolean>;
+}
+/** Segments cache */
+export interface ISegmentsCacheBase {
+    addToSegment(name: string, segmentKeys: string[]): MaybeThenable<boolean | void>;
+    removeFromSegment(name: string, segmentKeys: string[]): MaybeThenable<boolean | void>;
+    isInSegment(name: string, key?: string): MaybeThenable<boolean>;
+    registerSegments(names: string[]): MaybeThenable<boolean | void>;
+    getRegisteredSegments(): MaybeThenable<string[]>;
+    setChangeNumber(name: string, changeNumber: number): MaybeThenable<boolean | void>;
+    getChangeNumber(name: string): MaybeThenable<number>;
+    clear(): MaybeThenable<boolean | void>;
+}
+export interface ISegmentsCacheSync extends ISegmentsCacheBase {
+    addToSegment(name: string, segmentKeys?: string[]): boolean;
+    removeFromSegment(name: string, segmentKeys?: string[]): boolean;
+    isInSegment(name: string, key?: string): boolean;
+    registerSegments(names: string[]): boolean;
+    getRegisteredSegments(): string[];
+    getKeysCount(): number;
+    setChangeNumber(name: string, changeNumber: number): boolean;
+    getChangeNumber(name: string): number;
+    resetSegments(names: string[]): boolean;
+    clear(): void;
+}
+export interface ISegmentsCacheAsync extends ISegmentsCacheBase {
+    addToSegment(name: string, segmentKeys: string[]): Promise<boolean | void>;
+    removeFromSegment(name: string, segmentKeys: string[]): Promise<boolean | void>;
+    isInSegment(name: string, key: string): Promise<boolean>;
+    registerSegments(names: string[]): Promise<boolean | void>;
+    getRegisteredSegments(): Promise<string[]>;
+    setChangeNumber(name: string, changeNumber: number): Promise<boolean | void>;
+    getChangeNumber(name: string): Promise<number>;
+    clear(): Promise<boolean | void>;
+}
+/** Recorder storages (impressions, events and telemetry) */
+export interface IImpressionsCacheBase {
+    track(data: ImpressionDTO[]): MaybeThenable<void>;
+}
+export interface IEventsCacheBase {
+    track(data: SplitIO.EventData, size?: number): MaybeThenable<boolean>;
+}
+/** Impressions and events cache for standalone mode (sync) */
+export interface IRecorderCacheProducerSync<T> {
+    isEmpty(): boolean;
+    clear(): void;
+    pop(toMerge?: T): T;
+}
+export interface IImpressionsCacheSync extends IImpressionsCacheBase, IRecorderCacheProducerSync<ImpressionDTO[]> {
+    track(data: ImpressionDTO[]): void;
+    setOnFullQueueCb(cb: () => void): void;
+}
+export interface IEventsCacheSync extends IEventsCacheBase, IRecorderCacheProducerSync<SplitIO.EventData[]> {
+    track(data: SplitIO.EventData, size?: number): boolean;
+    setOnFullQueueCb(cb: () => void): void;
+}
+/** Impressions and events cache for consumer and producer mode (async) */
+export interface IRecorderCacheProducerAsync<T> {
+    count(): Promise<number>;
+    drop(count?: number): Promise<void>;
+    popNWithMetadata(count: number): Promise<T>;
+}
+export interface IImpressionsCacheAsync extends IImpressionsCacheBase, IRecorderCacheProducerAsync<StoredImpressionWithMetadata[]> {
+    track(data: ImpressionDTO[]): Promise<void>;
+}
+export interface IEventsCacheAsync extends IEventsCacheBase, IRecorderCacheProducerAsync<StoredEventWithMetadata[]> {
+    track(data: SplitIO.EventData, size?: number): Promise<boolean>;
+}
+/**
+ * Impression counts cache for impressions dedup in standalone and producer mode.
+ * Only in memory. Named `ImpressionsCounter` in spec.
+ */
+export interface IImpressionCountsCacheSync extends IRecorderCacheProducerSync<Record<string, number>> {
+    track(featureName: string, timeFrame: number, amount: number): void;
+    isEmpty(): boolean;
+    pop(toMerge?: Record<string, number>): Record<string, number>;
+}
+export interface IUniqueKeysCacheBase {
+    track(key: string, value: string): void;
+    isEmpty(): boolean;
+    pop(): UniqueKeysPayloadSs | UniqueKeysPayloadCs;
+    setOnFullQueueCb(cb: () => void): void;
+    clear(): void;
+}
+/**
+ * Telemetry storage interface for standalone and partial consumer modes.
+ * Methods are sync because data is stored in memory.
+ */
+export interface ITelemetryInitConsumerSync {
+    getTimeUntilReady(): number | undefined;
+    getTimeUntilReadyFromCache(): number | undefined;
+    getNonReadyUsage(): number;
+}
+export interface ITelemetryRuntimeConsumerSync {
+    getImpressionStats(type: ImpressionDataType): number;
+    getEventStats(type: EventDataType): number;
+    getLastSynchronization(): LastSync;
+    popHttpErrors(): HttpErrors;
+    popHttpLatencies(): HttpLatencies;
+    popAuthRejections(): number;
+    popTokenRefreshes(): number;
+    popStreamingEvents(): Array<StreamingEvent>;
+    popTags(): Array<string> | undefined;
+    getSessionLength(): number | undefined;
+}
+export interface ITelemetryEvaluationConsumerSync {
+    popExceptions(): MethodExceptions;
+    popLatencies(): MethodLatencies;
+}
+export interface ITelemetryStorageConsumerSync extends ITelemetryInitConsumerSync, ITelemetryRuntimeConsumerSync, ITelemetryEvaluationConsumerSync {
+}
+export interface ITelemetryInitProducerSync {
+    recordTimeUntilReady(ms: number): void;
+    recordTimeUntilReadyFromCache(ms: number): void;
+    recordNonReadyUsage(): void;
+}
+export interface ITelemetryRuntimeProducerSync {
+    addTag(tag: string): void;
+    recordImpressionStats(type: ImpressionDataType, count: number): void;
+    recordEventStats(type: EventDataType, count: number): void;
+    recordSuccessfulSync(resource: OperationType, timeMs: number): void;
+    recordHttpError(resource: OperationType, status: number): void;
+    recordHttpLatency(resource: OperationType, latencyMs: number): void;
+    recordAuthRejections(): void;
+    recordTokenRefreshes(): void;
+    recordStreamingEvents(streamingEvent: StreamingEvent): void;
+    recordSessionLength(ms: number): void;
+}
+export interface ITelemetryEvaluationProducerSync {
+    recordLatency(method: Method, latencyMs: number): void;
+    recordException(method: Method): void;
+}
+export interface ITelemetryStorageProducerSync extends ITelemetryInitProducerSync, ITelemetryRuntimeProducerSync, ITelemetryEvaluationProducerSync {
+}
+export interface ITelemetryCacheSync extends ITelemetryStorageConsumerSync, ITelemetryStorageProducerSync {
+}
+/**
+ * Telemetry storage interface for consumer mode.
+ * Methods are async because data is stored in Redis or a pluggable storage.
+ */
+export interface ITelemetryEvaluationConsumerAsync {
+    popExceptions(): Promise<MethodExceptions>;
+    popLatencies(): Promise<MethodLatencies>;
+}
+export interface ITelemetryEvaluationProducerAsync {
+    recordLatency(method: Method, latencyMs: number): Promise<any>;
+    recordException(method: Method): Promise<any>;
+}
+export interface ITelemetryCacheAsync extends ITelemetryEvaluationProducerAsync {
+}
+/**
+ * Storages
+ */
+export interface IStorageBase<TSplitsCache extends ISplitsCacheBase, TSegmentsCache extends ISegmentsCacheBase, TImpressionsCache extends IImpressionsCacheBase, TImpressionsCountCache extends IImpressionCountsCacheSync, TEventsCache extends IEventsCacheBase, TTelemetryCache extends ITelemetryCacheSync | ITelemetryCacheAsync, TUniqueKeysCache extends IUniqueKeysCacheBase> {
+    splits: TSplitsCache;
+    segments: TSegmentsCache;
+    impressions: TImpressionsCache;
+    impressionCounts?: TImpressionsCountCache;
+    events: TEventsCache;
+    telemetry?: TTelemetryCache;
+    uniqueKeys?: TUniqueKeysCache;
+    destroy(): void | Promise<void>;
+    shared?: (matchingKey: string, onReadyCb: (error?: any) => void) => this;
+}
+export interface IStorageSync extends IStorageBase<ISplitsCacheSync, ISegmentsCacheSync, IImpressionsCacheSync, IImpressionCountsCacheSync, IEventsCacheSync, ITelemetryCacheSync, IUniqueKeysCacheBase> {
+}
+export interface IStorageAsync extends IStorageBase<ISplitsCacheAsync, ISegmentsCacheAsync, IImpressionsCacheAsync | IImpressionsCacheSync, IImpressionCountsCacheSync, IEventsCacheAsync | IEventsCacheSync, ITelemetryCacheAsync, IUniqueKeysCacheBase> {
+}
+/** StorageFactory */
+export declare type DataLoader = (storage: IStorageSync, matchingKey: string) => void;
+export interface IStorageFactoryParams {
+    log: ILogger;
+    impressionsQueueSize?: number;
+    uniqueKeysCacheSize?: number;
+    eventsQueueSize?: number;
+    optimize?: boolean;
+    mode: SDKMode;
+    impressionsMode?: string;
+    matchingKey?: string;
+    splitFiltersValidation?: ISplitFiltersValidation;
+    onReadyCb: (error?: any) => void;
+    metadata: IMetadata;
+}
+export declare type StorageType = 'MEMORY' | 'LOCALSTORAGE' | 'REDIS' | 'PLUGGABLE';
+export declare type IStorageSyncFactory = {
+    readonly type: StorageType;
+    (params: IStorageFactoryParams): IStorageSync;
+};
+export declare type IStorageAsyncFactory = {
+    type: StorageType;
+    (params: IStorageFactoryParams): IStorageAsync;
+};

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,10 @@
+import { ISyncManagerCS } from '../types';
+import { ISplitsParser } from './splitsParser/types';
+import { ISdkFactoryContextSync } from '../../sdkFactory/types';
+/**
+ * Offline SyncManager factory.
+ * Can be used for server-side API, and client-side API with or without multiple clients.
+ *
+ * @param splitsParser e.g., `splitsParserFromFile`, `splitsParserFromSettings`.
+ */
+export declare function syncManagerOfflineFactory(splitsParserFactory: () => ISplitsParser): (params: ISdkFactoryContextSync) => ISyncManagerCS;

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,7 @@
+import { IPollingManagerCS } from './types';
+import { ISdkFactoryContextSync } from '../../sdkFactory/types';
+/**
+ * Expose start / stop mechanism for polling data from services.
+ * For client-side API with multiple clients.
+ */
+export declare function pollingManagerCSFactory(params: ISdkFactoryContextSync): IPollingManagerCS;

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

@@ -0,0 +1,6 @@
+import { IPollingManager } from './types';
+import { ISdkFactoryContextSync } from '../../sdkFactory/types';
+/**
+ * Expose start / stop mechanism for pulling data from services.
+ */
+export declare function pollingManagerSSFactory(params: ISdkFactoryContextSync): IPollingManager;

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

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

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

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

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

@@ -0,0 +1,9 @@
+import { IStorageSync } from '../../../storages/types';
+import { IReadinessManager } from '../../../readiness/types';
+import { ISplitsSyncTask } from '../types';
+import { IFetchSplitChanges } from '../../../services/types';
+import { ISettings } from '../../../types';
+/**
+ * Creates a sync task that periodically executes a `splitChangesUpdater` task
+ */
+export declare function splitsSyncTaskFactory(fetchSplitChanges: IFetchSplitChanges, storage: IStorageSync, readiness: IReadinessManager, settings: ISettings, isClientSide?: boolean): ISplitsSyncTask;

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

@@ -0,0 +1,26 @@
+import { IReadinessManager } from '../../readiness/types';
+import { IStorageSync } from '../../storages/types';
+import { ITask, ISyncTask } from '../types';
+export interface ISplitsSyncTask extends ISyncTask<[noCache?: boolean, till?: number], boolean> {
+}
+export interface ISegmentsSyncTask extends ISyncTask<[fetchOnlyNew?: boolean, segmentName?: string, noCache?: boolean, till?: number], boolean> {
+}
+export declare type MySegmentsData = string[] | {
+    name: string;
+    add: boolean;
+};
+export interface IMySegmentsSyncTask extends ISyncTask<[segmentsData?: MySegmentsData, noCache?: boolean], boolean> {
+}
+export interface IPollingManager extends ITask {
+    syncAll(): Promise<any>;
+    splitsSyncTask: ISplitsSyncTask;
+    segmentsSyncTask: ISyncTask;
+}
+/**
+ * PollingManager for client-side with support for multiple clients
+ */
+export interface IPollingManagerCS extends IPollingManager {
+    add(matchingKey: string, readiness: IReadinessManager, storage: IStorageSync): IMySegmentsSyncTask;
+    remove(matchingKey: string): void;
+    get(matchingKey: string): IMySegmentsSyncTask | undefined;
+}

package/types/sync/polling/updaters/mySegmentsUpdater.d.ts

@@ -0,0 +1,13 @@
+import { IMySegmentsFetcher } from '../fetchers/types';
+import { ISegmentsCacheSync, ISplitsCacheSync } from '../../../storages/types';
+import { ISegmentsEventEmitter } from '../../../readiness/types';
+import { ILogger } from '../../../logger/types';
+declare type IMySegmentsUpdater = (segmentList?: string[], noCache?: boolean) => Promise<boolean>;
+/**
+ * factory of MySegments updater, a task that:
+ *  - fetches mySegments using `mySegmentsFetcher`
+ *  - updates `mySegmentsCache`
+ *  - uses `segmentsEventEmitter` to emit events related to segments data updates
+ */
+export declare function mySegmentsUpdaterFactory(log: ILogger, mySegmentsFetcher: IMySegmentsFetcher, splitsCache: ISplitsCacheSync, mySegmentsCache: ISegmentsCacheSync, segmentsEventEmitter: ISegmentsEventEmitter, requestTimeoutBeforeReady: number, retriesOnFailureBeforeReady: number, matchingKey: string): IMySegmentsUpdater;
+export {};

package/types/sync/polling/updaters/segmentChangesUpdater.d.ts

@@ -0,0 +1,18 @@
+import { ISegmentChangesFetcher } from '../fetchers/types';
+import { ISegmentsCacheBase } from '../../../storages/types';
+import { IReadinessManager } from '../../../readiness/types';
+import { ILogger } from '../../../logger/types';
+declare type ISegmentChangesUpdater = (fetchOnlyNew?: boolean, segmentName?: string, noCache?: boolean, till?: number) => Promise<boolean>;
+/**
+ * Factory of SegmentChanges updater, a task that:
+ *  - fetches segment changes using `segmentChangesFetcher`
+ *  - updates `segmentsCache`
+ *  - uses `segmentsEventEmitter` to emit events related to segments data updates
+ *
+ * @param log logger instance
+ * @param segmentChangesFetcher fetcher of `/segmentChanges`
+ * @param segments segments storage, with sync or async methods
+ * @param readiness optional readiness manager. Not required for synchronizer or producer mode.
+ */
+export declare function segmentChangesUpdaterFactory(log: ILogger, segmentChangesFetcher: ISegmentChangesFetcher, segments: ISegmentsCacheBase, readiness?: IReadinessManager): ISegmentChangesUpdater;
+export {};