@splitsoftware/splitio-commons 1.2.0 → 1.2.1-rc.10

package/types/logger/messages/errorNode.d.ts

@@ -0,0 +1 @@
+export declare const codesErrorNode: [number, string][];

package/types/logger/messages/warnNode.d.ts

@@ -0,0 +1 @@
+export declare const codesWarnNode: [number, string][];

package/types/logger/noopLogger.d.ts

@@ -0,0 +1,2 @@
+import { ILogger } from './types';
+export declare const noopLogger: ILogger;

package/types/logger/types.d.ts

@@ -6,8 +6,12 @@ export interface ILoggerOptions {
 }
 export interface ILogger {
     setLogLevel(logLevel: LogLevel): void;
+    debug(msg: any): void;
     debug(msg: string | number, args?: any[]): void;
+    info(msg: any): void;
     info(msg: string | number, args?: any[]): void;
+    warn(msg: any): void;
     warn(msg: string | number, args?: any[]): void;
+    error(msg: any): void;
     error(msg: string | number, args?: any[]): void;
 }

package/types/logger/warnLogger.d.ts

@@ -0,0 +1,2 @@
+import { Logger } from '.';
+export declare const warnLogger: Logger;

package/types/sdkClient/clientAttributesDecoration.d.ts

@@ -8,7 +8,7 @@ export declare function clientAttributesDecoration<TClient extends SplitIO.IClie
     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>;
+    track: (maybeKey: SplitIO.SplitKey, maybeTT: string, maybeEvent: string, maybeEventValue?: number | undefined, maybeProperties?: SplitIO.Properties | undefined) => boolean | Promise<boolean>;
     /**
      * Add an attribute to client's in memory attributes storage
      *

package/types/sdkClient/clientInputValidation.d.ts

@@ -1,8 +1,7 @@
 import { IReadinessManager } from '../readiness/types';
-import { SplitIO } from '../types';
-import { ILogger } from '../logger/types';
+import { ISettings, SplitIO } from '../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 declare 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>(settings: ISettings, client: TClient, readinessManager: IReadinessManager): TClient;

package/types/sdkFactory/types.d.ts

@@ -36,7 +36,7 @@ export interface ISdkFactoryParams {
     settings: ISettings, // Used by BrowserSignalListener
     storage: IStorageSync | IStorageAsync, // Used by BrowserSignalListener
     serviceApi: ISplitApi | undefined) => ISignalListener;
-    impressionListener?: SplitIO.IImpressionListener;
     integrationsManagerFactory?: (params: IIntegrationFactoryParams) => IIntegrationManager | undefined;
     impressionsObserverFactory?: () => IImpressionObserver;
+    extraProps?: (settings: ISettings, syncManager?: ISyncManager) => object;
 }

package/types/sdkFactory/userConsentProps.d.ts

@@ -0,0 +1,6 @@
+import { ISyncManager } from '../sync/types';
+import { ISettings } from '../types';
+export declare function userConsentProps(settings: ISettings, syncManager?: ISyncManager): {
+    setUserConsent(consent: unknown): boolean;
+    getUserConsent(): import("../types").ConsentStatus | undefined;
+};

package/types/sdkManager/sdkManagerMethod.d.ts

@@ -0,0 +1,6 @@
+import { ISdkClientFactoryParams } from '../sdkClient/types';
+import { SplitIO } from '../types';
+/**
+ * Factory of client method for server-side SDKs (ISDK and IAsyncSDK)
+ */
+export declare function sdkManagerMethodFactory(params: ISdkClientFactoryParams): () => SplitIO.IManager | SplitIO.IAsyncManager;

package/types/storages/KeyBuilderCS.d.ts

@@ -8,6 +8,8 @@ export declare class KeyBuilderCS extends KeyBuilder {
      */
     buildSegmentNameKey(segmentName: string): string;
     extractSegmentName(builtSegmentKeyName: string): string | undefined;
+    buildOldSegmentNameKey(segmentName: string): string;
+    extractOldSegmentKey(builtSegmentKeyName: string): string | undefined;
     buildLastUpdatedKey(): string;
     isSplitsCacheKey(key: string): boolean;
     buildSplitsFilterQueryKey(): string;

package/types/storages/getRegisteredSegments.d.ts

@@ -0,0 +1,10 @@
+import { ISplit } from '../dtos/types';
+/**
+ * Collect segments from a raw split definition.
+ * Exported for testing purposes.
+ */
+export declare function _parseSegments({ conditions }: ISplit): import("../utils/lang/sets").ISet<string>;
+/**
+ * Computes the set of segments used by splits.
+ */
+export declare function getRegisteredSegments(splitDefs: string[]): string[];

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

@@ -1,7 +1,16 @@
 import { IImpressionsCacheSync } from '../types';
 import { ImpressionDTO } from '../../types';
 export declare class ImpressionsCacheInMemory implements IImpressionsCacheSync {
+    private onFullQueue?;
+    private readonly maxQueue;
     private queue;
+    /**
+     *
+     * @param impressionsQueueSize number of queued impressions to call onFullQueueCb.
+     * Default value is 0, that means no maximum value, in case we want to avoid this being triggered.
+     */
+    constructor(impressionsQueueSize?: number);
+    setOnFullQueueCb(cb: () => void): void;
     /**
      * Store impressions in sequential order
      */

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

@@ -0,0 +1,51 @@
+import { ImpressionDataType, EventDataType, StreamingEvent, Method, OperationType } from '../../sync/submitters/types';
+import { TelemetryCacheSync } from '../types';
+export declare class TelemetryCacheInMemory implements TelemetryCacheSync {
+    private timeUntilReady?;
+    getTimeUntilReady(): number | undefined;
+    recordTimeUntilReady(ms: number): void;
+    private timeUntilReadyFromCache?;
+    getTimeUntilReadyFromCache(): number | undefined;
+    recordTimeUntilReadyFromCache(ms: number): void;
+    private notReadyUsage;
+    getNonReadyUsage(): number;
+    recordNonReadyUsage(): void;
+    private impressionStats;
+    getImpressionStats(type: ImpressionDataType): number;
+    recordImpressionStats(type: ImpressionDataType, count: number): void;
+    private eventStats;
+    getEventStats(type: EventDataType): number;
+    recordEventStats(type: EventDataType, count: number): void;
+    private lastSync;
+    getLastSynchronization(): Record<OperationType, number | undefined>;
+    recordSuccessfulSync(resource: OperationType, timeMs: number): void;
+    private httpErrors;
+    popHttpErrors(): Record<OperationType, {
+        [statusCode: string]: number;
+    }>;
+    recordSyncError(resource: OperationType, status: number): void;
+    private httpLatencies;
+    popHttpLatencies(): Record<OperationType, number[]>;
+    recordSyncLatency(resource: OperationType, latencyMs: number): void;
+    private authRejections;
+    popAuthRejections(): number;
+    recordAuthRejections(): void;
+    private tokenRefreshes;
+    popTokenRefreshes(): number;
+    recordTokenRefreshes(): void;
+    private streamingEvents;
+    popStreamingEvents(): StreamingEvent[];
+    recordStreamingEvents(streamingEvent: StreamingEvent): void;
+    private tags;
+    popTags(): string[];
+    addTag(tag: string): void;
+    private sessionLength?;
+    getSessionLength(): number | undefined;
+    recordSessionLength(ms: number): void;
+    private exceptions;
+    popExceptions(): Record<Method, number>;
+    recordException(method: Method): void;
+    private latencies;
+    popLatencies(): Record<Method, number[]>;
+    recordLatency(method: Method, latencyMs: number): void;
+}

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

@@ -0,0 +1,10 @@
+import { IStorageFactoryParams, IStorageSync } from '../types';
+/**
+ * InMemory storage factory for standalone server-side SplitFactory
+ *
+ * @param params parameters required by EventsCacheSync
+ */
+export declare function InMemoryStorageFactory(params: IStorageFactoryParams): IStorageSync;
+export declare namespace InMemoryStorageFactory {
+    var type: import("../types").StorageType;
+}

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

@@ -20,5 +20,5 @@ export declare class RedisAdapter extends ioredis {
     /**
      * Parses the options into what we care about.
      */
-    static _defineOptions({ connectionTimeout, operationTimeout, url, host, port, db, pass }: Record<string, any>): object;
+    static _defineOptions({ connectionTimeout, operationTimeout, url, host, port, db, pass, tls }: Record<string, any>): object;
 }

package/types/storages/parseSegments.d.ts

@@ -0,0 +1,6 @@
+import { ISplit } from '../dtos/types';
+import { ISet } from '../utils/lang/sets';
+/**
+ * Collect segments from a list of splits.
+ */
+export declare function parseSegments(splits: ISplit[]): ISet<string>;

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

@@ -0,0 +1,2 @@
+export declare class TelemetryCachePluggable {
+}

package/types/storages/types.d.ts

@@ -269,6 +269,7 @@ export interface IRecorderCacheProducerSync<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;
@@ -335,6 +336,7 @@ export declare type IStorageAsync = IStorageBase<ISplitsCacheAsync, ISegmentsCac
 export declare type DataLoader = (storage: IStorageSync, matchingKey: string) => void;
 export interface IStorageFactoryParams {
     log: ILogger;
+    impressionsQueueSize?: number;
     eventsQueueSize?: number;
     optimize?: boolean;
     matchingKey?: string;
@@ -345,7 +347,7 @@ export interface IStorageFactoryParams {
 }
 export declare type StorageType = 'MEMORY' | 'LOCALSTORAGE' | 'REDIS' | 'PLUGGABLE';
 export declare type IStorageSyncFactory = {
-    type: StorageType;
+    readonly type: StorageType;
     (params: IStorageFactoryParams): IStorageSync;
 };
 export declare type IStorageAsyncFactory = {

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

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

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

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

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

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

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

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

@@ -0,0 +1,35 @@
+import { ISet } from '../../../utils/lang/sets';
+import { ISegmentsCacheSync, ISplitsCacheSync, IStorageSync } from '../../../storages/types';
+import { ISplitChangesFetcher } from '../fetchers/types';
+import { ISplit } from '../../../dtos/types';
+import { IReadinessManager, ISplitsEventEmitter } from '../../../readiness/types';
+import { ISplitsSyncTask } from '../types';
+import { IFetchSplitChanges } from '../../../services/types';
+import { ISettings } from '../../../types';
+declare type ISplitChangesUpdater = (noCache?: boolean) => Promise<boolean>;
+/**
+ * Collect segments from a raw split definition.
+ * Exported for testing purposes.
+ */
+export declare function parseSegments({ conditions }: ISplit): ISet<string>;
+interface ISplitMutations {
+    added: [string, string][];
+    removed: string[];
+    segments: string[];
+}
+/**
+ * Given the list of splits from /splitChanges endpoint, it returns the mutations,
+ * i.e., an object with added splits, removed splits and used segments.
+ * Exported for testing purposes.
+ */
+export declare function computeSplitsMutation(entries: ISplit[]): ISplitMutations;
+/**
+ * factory of SplitChanges updater (a.k.a, SplitsSyncTask), a task that:
+ *  - fetches split changes using `splitChangesFetcher`
+ *  - updates `splitsCache`
+ *  - uses `splitsEventEmitter` to emit events related to split data updates
+ * Exported for testing purposes.
+ */
+export declare function splitChangesUpdaterFactory(splitChangesFetcher: ISplitChangesFetcher, splitsCache: ISplitsCacheSync, segmentsCache: ISegmentsCacheSync, splitsEventEmitter: ISplitsEventEmitter, requestTimeoutBeforeReady: number, retriesOnFailureBeforeReady: number): ISplitChangesUpdater;
+export default function splitsSyncTaskFactory(fetchSplitChanges: IFetchSplitChanges, storage: IStorageSync, readiness: IReadinessManager, settings: ISettings): ISplitsSyncTask;
+export {};

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

@@ -0,0 +1,35 @@
+import { ISet } from '../../../utils/lang/sets';
+import { ISegmentsCacheSync, ISplitsCacheSync, IStorageSync } from '../../../storages/types';
+import { ISplitChangesFetcher } from '../fetchers/types';
+import { ISplit } from '../../../dtos/types';
+import { IReadinessManager, ISplitsEventEmitter } from '../../../readiness/types';
+import { ISplitsSyncTask } from '../types';
+import { IFetchSplitChanges } from '../../../services/types';
+import { ISettings } from '../../../types';
+declare type ISplitChangesUpdater = (noCache?: boolean) => Promise<boolean>;
+/**
+ * Collect segments from a raw split definition.
+ * Exported for testing purposes.
+ */
+export declare function parseSegments({ conditions }: ISplit): ISet<string>;
+interface ISplitMutations {
+    added: [string, string][];
+    removed: string[];
+    segments: string[];
+}
+/**
+ * Given the list of splits from /splitChanges endpoint, it returns the mutations,
+ * i.e., an object with added splits, removed splits and used segments.
+ * Exported for testing purposes.
+ */
+export declare function computeSplitsMutation(entries: ISplit[]): ISplitMutations;
+/**
+ * factory of SplitChanges updater (a.k.a, SplitsSyncTask), a task that:
+ *  - fetches split changes using `splitChangesFetcher`
+ *  - updates `splitsCache`
+ *  - uses `splitsEventEmitter` to emit events related to split data updates
+ * Exported for testing purposes.
+ */
+export declare function splitChangesUpdaterFactory(splitChangesFetcher: ISplitChangesFetcher, splitsCache: ISplitsCacheSync, segmentsCache: ISegmentsCacheSync, splitsEventEmitter: ISplitsEventEmitter, requestTimeoutBeforeReady: number, retriesOnFailureBeforeReady: number): ISplitChangesUpdater;
+export default function splitsSyncTaskFactory(fetchSplitChanges: IFetchSplitChanges, storage: IStorageSync, readiness: IReadinessManager, settings: ISettings): ISplitsSyncTask;
+export {};

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

@@ -1,7 +1,5 @@
 import { IReadinessManager } from '../../readiness/types';
-import { ISplitApi } from '../../services/types';
 import { IStorageSync } from '../../storages/types';
-import { ISettings } from '../../types';
 import { SegmentsData } from '../streaming/SSEHandler/types';
 import { ITask, ISyncTask } from '../types';
 export interface ISplitsSyncTask extends ISyncTask<[noCache?: boolean], boolean> {
@@ -21,12 +19,3 @@ export interface IPollingManagerCS extends IPollingManager {
     remove(matchingKey: string): void;
     get(matchingKey: string): ISegmentsSyncTask | undefined;
 }
-/**
- * Signature of polling manager factory/constructor
- */
-export declare type IPollingManagerFactoryParams = [
-    splitApi: ISplitApi,
-    storage: IStorageSync,
-    readiness: IReadinessManager,
-    settings: ISettings
-];

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

@@ -9,5 +9,5 @@ declare type IMySegmentsUpdater = (segmentList?: string[], noCache?: boolean) =>
  *  - 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): IMySegmentsUpdater;
+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/streaming/AuthClient/indexV1.d.ts

@@ -0,0 +1,12 @@
+import { IFetchAuth } from '../../../services/types';
+import { IAuthenticate } from './types';
+/**
+ * Factory of authentication function.
+ *
+ * @param fetchAuth `SplitAPI.fetchAuth` endpoint
+ */
+export declare function authenticateFactory(fetchAuth: IFetchAuth): IAuthenticate;
+/**
+ * Returns the hash of a given user key
+ */
+export declare function hashUserKey(userKey: string): string;

package/types/sync/streaming/AuthClient/indexV2.d.ts

@@ -0,0 +1,8 @@
+import { IFetchAuthV2 } from '../../../services/types';
+import { IAuthenticateV2 } from './types';
+/**
+ * Factory of authentication function.
+ *
+ * @param fetchAuth `SplitAPI.fetchAuth` endpoint
+ */
+export declare function authenticateFactory(fetchAuthV2: IFetchAuthV2): IAuthenticateV2;

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

@@ -16,7 +16,7 @@ export declare class SegmentsUpdateWorker implements IUpdateWorker {
      * @param {Object} segmentsCache segments data cache
      * @param {Object} segmentsSyncTask task for syncing segments data
      */
-    constructor(segmentsCache: ISegmentsCacheSync, segmentsSyncTask: ISegmentsSyncTask);
+    constructor(segmentsSyncTask: ISegmentsSyncTask, segmentsCache: ISegmentsCacheSync);
     __handleSegmentUpdateCall(): void;
     /**
      * Invoked by NotificationProcessor on SEGMENT_UPDATE event

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

@@ -1,13 +1,9 @@
-import { IPushManagerCS } from './types';
-import { IStorageSync } from '../../storages/types';
-import { IReadinessManager } from '../../readiness/types';
+import { IPushManager } from './types';
 import { IPollingManager } from '../polling/types';
-import { IFetchAuth } from '../../services/types';
-import { ISettings } from '../../types';
-import { IPlatform } from '../../sdkFactory/types';
+import { ISyncManagerFactoryParams } from '../types';
 /**
  * PushManager factory:
  * - 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 declare function pushManagerFactory(pollingManager: IPollingManager, storage: IStorageSync, readiness: IReadinessManager, fetchAuth: IFetchAuth, platform: IPlatform, settings: ISettings): IPushManagerCS | undefined;
+export declare function pushManagerFactory(params: ISyncManagerFactoryParams, pollingManager: IPollingManager): IPushManager | undefined;

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

@@ -0,0 +1 @@
+export declare const pushManagerCSFactory: (params: import("../types").ISyncManagerFactoryParams, pollingManager: import("../polling/types").IPollingManager) => import("./types").IPushManager | undefined;

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

@@ -0,0 +1,13 @@
+import { IPushManagerCS } from './types';
+import { IStorageSync } from '../../storages/types';
+import { IReadinessManager } from '../../readiness/types';
+import { IPollingManager } from '../polling/types';
+import { IFetchAuthV2 } from '../../services/types';
+import { ISettings } from '../../types';
+import { IPlatform } from '../../sdkFactory/types';
+/**
+ * PushManager factory:
+ * - 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, fetchAuthV2: IFetchAuthV2, platform: IPlatform, settings: ISettings): IPushManagerCS | undefined;

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

@@ -0,0 +1 @@
+export declare const pushManagerSSFactory: (params: import("../types").ISyncManagerFactoryParams, pollingManager: import("../polling/types").IPollingManager) => import("./types").IPushManager | undefined;

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

@@ -1,11 +1,7 @@
 import { IMySegmentsUpdateData, IMySegmentsUpdateV2Data, ISegmentUpdateData, ISplitUpdateData, ISplitKillData } from './SSEHandler/types';
 import { ITask } from '../types';
-import { IPollingManager, ISegmentsSyncTask } from '../polling/types';
-import { IReadinessManager } from '../../readiness/types';
-import { IFetchAuth } from '../../services/types';
-import { IStorageSync } from '../../storages/types';
-import { IEventEmitter, ISettings } from '../../types';
-import { IPlatform } from '../../sdkFactory/types';
+import { ISegmentsSyncTask } from '../polling/types';
+import { IEventEmitter } from '../../types';
 import { ControlType } from './constants';
 export declare type PUSH_SUBSYSTEM_UP = 'PUSH_SUBSYSTEM_UP';
 export declare type PUSH_SUBSYSTEM_DOWN = 'PUSH_SUBSYSTEM_DOWN';
@@ -30,26 +26,10 @@ export interface IPushEventEmitter extends IEventEmitter {
     emit<T extends IPushEvent>(event: T, parsedData?: IParsedData<T>, channel?: T extends MY_SEGMENTS_UPDATE ? string : undefined): boolean;
 }
 /**
- * PushManager for server-side
+ * PushManager
  */
 export interface IPushManager extends ITask, IPushEventEmitter {
-}
-/**
- * PushManager for client-side with support for multiple clients
- */
-export interface IPushManagerCS extends IPushManager {
     add(userKey: string, mySegmentsSyncTask: ISegmentsSyncTask): void;
     remove(userKey: string): void;
 }
-/**
- * Signature of push manager factory/constructor
- */
-export declare type IPushManagerFactoryParams = [
-    pollingManager: IPollingManager,
-    storage: IStorageSync,
-    readiness: IReadinessManager,
-    fetchAuth: IFetchAuth,
-    platform: IPlatform,
-    settings: ISettings
-];
 export {};

package/types/sync/submitters/submitterManager.d.ts

@@ -1,4 +1,2 @@
-import { ISplitApi } from '../../services/types';
-import { IStorageSync } from '../../storages/types';
-import { ISettings } from '../../types';
-export declare function submitterManagerFactory(settings: ISettings, storage: IStorageSync, splitApi: ISplitApi): import("../types").ISyncTask<[], any>;
+import { ISyncManagerFactoryParams } from '../types';
+export declare function submitterManagerFactory(params: ISyncManagerFactoryParams): import("../types").ISyncTask<[], any>;

package/types/sync/submitters/telemetrySyncTask.d.ts

@@ -0,0 +1,17 @@
+import { ISyncTask, ITimeTracker } from '../types';
+import { IPostMetricsUsage } from '../../services/types';
+import { IStorageSync, TelemetryCacheSync } from '../../storages/types';
+import { TelemetryStatsPayload } from './types';
+import { ILogger } from '../../logger/types';
+/**
+ * Converts `impressions` data from cache into request payload.
+ */
+export declare function telemetryCacheAdapter(telemetryCache: TelemetryCacheSync, storage: IStorageSync): {
+    isEmpty(): boolean;
+    clear(): void;
+    state(): TelemetryStatsPayload;
+};
+/**
+ * Sync task that periodically posts impressions data
+ */
+export declare function telemetrySyncTaskFactory(log: ILogger, postMetricsUsage: IPostMetricsUsage, telemetryCache: TelemetryCacheSync, telemetryRefreshRate: number, latencyTracker: ITimeTracker, storage: IStorageSync): ISyncTask;

package/types/sync/syncManagerFromFile.d.ts

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

package/types/sync/syncManagerFromObject.d.ts

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

package/types/sync/syncManagerOffline.d.ts

@@ -0,0 +1,9 @@
+import { ISyncManagerCS, ISyncManagerFactoryParams } from './types';
+import { ISplitsParser } from './offline/splitsParser/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: ISyncManagerFactoryParams) => ISyncManagerCS;

package/types/sync/syncManagerOnline.d.ts

@@ -1,6 +1,6 @@
 import { ISyncManagerCS, ISyncManagerFactoryParams } from './types';
-import { IPushManagerFactoryParams, IPushManager } from './streaming/types';
-import { IPollingManager, IPollingManagerFactoryParams } from './polling/types';
+import { IPushManager } from './streaming/types';
+import { IPollingManager } from './polling/types';
 /**
  * Online SyncManager factory.
  * Can be used for server-side API, and client-side API with or without multiple clients.
@@ -9,4 +9,4 @@ import { IPollingManager, IPollingManagerFactoryParams } from './polling/types';
  * `pollingManagerSSFactory` or `pollingManagerCSFactory` respectively.
  * @param pushManagerFactory optional to build a SyncManager with or without streaming support
  */
-export declare function syncManagerOnlineFactory(pollingManagerFactory?: (...args: IPollingManagerFactoryParams) => IPollingManager, pushManagerFactory?: (...args: IPushManagerFactoryParams) => IPushManager | undefined): (params: ISyncManagerFactoryParams) => ISyncManagerCS;
+export declare function syncManagerOnlineFactory(pollingManagerFactory?: (params: ISyncManagerFactoryParams) => IPollingManager, pushManagerFactory?: (params: ISyncManagerFactoryParams, pollingManager: IPollingManager) => IPushManager | undefined): (params: ISyncManagerFactoryParams) => ISyncManagerCS;

package/types/sync/types.d.ts

@@ -3,6 +3,7 @@ import { IPlatform } from '../sdkFactory/types';
 import { ISplitApi } from '../services/types';
 import { IStorageSync } from '../storages/types';
 import { ISettings } from '../types';
+import { IPollingManager } from './polling/types';
 import { IPushManager } from './streaming/types';
 export interface ITask<Input extends any[] = []> {
     /**
@@ -39,6 +40,8 @@ export interface ITimeTracker {
 export interface ISyncManager extends ITask {
     flush(): Promise<any>;
     pushManager?: IPushManager;
+    pollingManager?: IPollingManager;
+    submitter?: ISyncTask;
 }
 export interface ISyncManagerCS extends ISyncManager {
     shared(matchingKey: string, readinessManager: IReadinessManager, storage: IStorageSync): ISyncManager | undefined;

package/types/trackers/eventTracker.d.ts

@@ -1,10 +1,10 @@
 import { IEventsCacheBase } from '../storages/types';
 import { IEventsHandler, IEventTracker } from './types';
-import { ILogger } from '../logger/types';
+import { ISettings } from '../types';
 /**
  * Event tracker stores events in cache and pass them to the integrations manager if provided.
  *
  * @param eventsCache cache to save events
  * @param integrationsManager optional event handler used for integrations
  */
-export declare function eventTrackerFactory(log: ILogger, eventsCache: IEventsCacheBase, integrationsManager?: IEventsHandler): IEventTracker;
+export declare function eventTrackerFactory(settings: ISettings, eventsCache: IEventsCacheBase, integrationsManager?: IEventsHandler): IEventTracker;

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

@@ -7,3 +7,7 @@ export declare function shouldAddPt(settings: ISettings): boolean;
  * Checks if it should dedupe impressions or not.
  */
 export declare function shouldBeOptimized(settings: ISettings): boolean;
+/**
+ * Storage is async if mode is consumer or partial consumer
+ */
+export declare function isStorageSync(settings: ISettings): boolean;

package/types/trackers/impressionsTracker.d.ts

@@ -1,8 +1,7 @@
 import { IImpressionCountsCacheSync, IImpressionsCacheBase } from '../storages/types';
 import { IImpressionsHandler, IImpressionsTracker } from './types';
-import { SplitIO, ISettings } from '../types';
+import { ISettings } from '../types';
 import { IImpressionObserver } from './impressionObserver/types';
-import { ILogger } from '../logger/types';
 /**
  * Impressions tracker stores impressions in cache and pass them to the listener and integrations manager if provided.
  *
@@ -13,4 +12,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 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;
+export declare function impressionsTrackerFactory(settings: ISettings, impressionsCache: IImpressionsCacheBase, integrationsManager?: IImpressionsHandler, observer?: IImpressionObserver, countsCache?: IImpressionCountsCacheSync): IImpressionsTracker;