@splitsoftware/splitio-commons 0.1.1-canary.9 → 0.1.1-rc.18

package/types/logger/constants.d.ts

@@ -91,6 +91,7 @@ export declare const WARN_SPLITS_FILTER_INVALID = 220;
 export declare const WARN_SPLITS_FILTER_EMPTY = 221;
 export declare const WARN_STORAGE_INVALID = 222;
 export declare const WARN_API_KEY = 223;
+export declare const STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2 = 224;
 export declare const ERROR_ENGINE_COMBINER_IFELSEIF = 300;
 export declare const ERROR_LOGLEVEL_INVALID = 301;
 export declare const ERROR_CLIENT_LISTENER = 302;
@@ -114,6 +115,7 @@ export declare const ERROR_EMPTY = 319;
 export declare const ERROR_EMPTY_ARRAY = 320;
 export declare const ERROR_INVALID_IMPRESSIONS_MODE = 321;
 export declare const ERROR_HTTP = 322;
+export declare const ERROR_LOCALHOST_MODULE_REQUIRED = 323;
 export declare const LOG_PREFIX_SETTINGS = "settings";
 export declare const LOG_PREFIX_INSTANTIATION = "Factory instantiation";
 export declare const LOG_PREFIX_ENGINE = "engine";

package/types/sdkFactory/types.d.ts

@@ -8,9 +8,9 @@ import { IStorageAsync, IStorageSync, ISplitsCacheSync, ISplitsCacheAsync, IStor
 import { ISyncManager, ISyncManagerFactoryParams } from '../sync/types';
 import { IImpressionObserver } from '../trackers/impressionObserver/types';
 import { SplitIO, ISettings, IEventEmitter } from '../types';
-import { ISettingsInternal } from '../utils/settingsValidation/types';
 /**
- * Environment related dependencies
+ * Environment related dependencies.
+ * These getters are called a fixed number of times per factory instantiation.
  */
 export interface IPlatform {
     getOptions?: () => object;
@@ -22,7 +22,7 @@ export interface IPlatform {
  * Object parameter with the modules required to create an SDK factory instance
  */
 export interface ISdkFactoryParams {
-    settings: ISettingsInternal;
+    settings: ISettings;
     platform: IPlatform;
     storageFactory: (params: IStorageFactoryParams) => IStorageSync | IStorageAsync;
     splitApiFactory?: (settings: ISettings, platform: IPlatform) => ISplitApi;

package/types/services/types.d.ts

@@ -7,6 +7,7 @@ export declare type IResponse = {
     ok: boolean;
     status: number;
     json: () => Promise<any>;
+    text: () => Promise<string>;
 };
 export declare type IFetch = (url: string, options?: IRequestOptions) => Promise<IResponse>;
 export declare type IHealthCheckAPI = () => Promise<boolean>;

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

@@ -1,8 +1,8 @@
-import { IStorageFactoryParams, IStorageSyncCS } from '../types';
+import { IStorageSyncFactory } from '../types';
 export interface InLocalStorageOptions {
     prefix?: string;
 }
 /**
  * InLocal storage factory for standalone client-side SplitFactory
  */
-export declare function InLocalStorage(options?: InLocalStorageOptions): (params: IStorageFactoryParams) => IStorageSyncCS;
+export declare function InLocalStorage(options?: InLocalStorageOptions): IStorageSyncFactory;

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

@@ -5,3 +5,6 @@ import { IStorageFactoryParams, IStorageSync } from '../types';
  * @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/inMemory/InMemoryStorageCS.d.ts

@@ -5,3 +5,6 @@ import { IStorageSyncCS, IStorageFactoryParams } from '../types';
  * @param params parameters required by EventsCacheSync
  */
 export declare function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorageSyncCS;
+export declare namespace InMemoryStorageCSFactory {
+    var type: import("../types").StorageType;
+}

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

@@ -1,4 +1,4 @@
-import { IStorageAsync, IStorageFactoryParams } from '../types';
+import { IStorageAsyncFactory } from '../types';
 export interface InRedisStorageOptions {
     prefix?: string;
     options?: Record<string, any>;
@@ -7,4 +7,4 @@ export interface InRedisStorageOptions {
  * InRedis storage factory for consumer server-side SplitFactory, that uses `Ioredis` Redis client for Node.
  * @see {@link https://www.npmjs.com/package/ioredis}
  */
-export declare function InRedisStorage(options?: InRedisStorageOptions): ({ log, metadata, onReadyCb }: IStorageFactoryParams) => IStorageAsync;
+export declare function InRedisStorage(options?: InRedisStorageOptions): IStorageAsyncFactory;

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

@@ -1,4 +1,4 @@
-import { ICustomStorageWrapper, IStorageAsync, IStorageFactoryParams } from '../types';
+import { ICustomStorageWrapper, IStorageAsyncFactory } from '../types';
 export interface PluggableStorageOptions {
     prefix?: string;
     wrapper: ICustomStorageWrapper;
@@ -6,4 +6,4 @@ export interface PluggableStorageOptions {
 /**
  * Pluggable storage factory for consumer server-side & client-side SplitFactory.
  */
-export declare function PluggableStorage(options: PluggableStorageOptions): ({ log, metadata, onReadyCb }: IStorageFactoryParams) => IStorageAsync;
+export declare function PluggableStorage(options: PluggableStorageOptions): IStorageAsyncFactory;

package/types/storages/types.d.ts

@@ -54,15 +54,6 @@ export interface ICustomStorageWrapper {
      * The promise rejects if the operation fails.
      */
     getKeysByPrefix: (prefix: string) => Promise<string[]>;
-    /**
-     * Returns all values which keys match the given prefix.
-     *
-     * @function getByPrefix
-     * @param {string} prefix String prefix to match
-     * @returns {Promise<string[]>} A promise that resolves with the list of values which keys match the given `prefix`.
-     * The promise rejects if the operation fails.
-     */
-    getByPrefix: (prefix: string) => Promise<string[]>;
     /**
      * Returns the values of all given `keys`.
      *
@@ -78,19 +69,19 @@ export interface ICustomStorageWrapper {
      *
      * @function incr
      * @param {string} key Key to increment
-     * @returns {Promise<void>} A promise that resolves if the operation success. The promise rejects if the operation fails,
+     * @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<void | boolean>;
+    incr: (key: string) => Promise<number>;
     /**
      * Decrements in 1 the given `key` value or set it in -1 if the value doesn't exist.
      *
      * @function decr
      * @param {string} key Key to decrement
-     * @returns {Promise<void>} A promise that resolves if the operation success. The promise rejects if the operation fails,
+     * @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<void | boolean>;
+    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.
@@ -243,8 +234,8 @@ export interface ISegmentsCacheBase {
     clear(): MaybeThenable<boolean | void>;
 }
 export interface ISegmentsCacheSync extends ISegmentsCacheBase {
-    addToSegment(name: string, segmentKeys: string[]): boolean;
-    removeFromSegment(name: string, segmentKeys: string[]): boolean;
+    addToSegment(name: string, segmentKeys?: string[]): boolean;
+    removeFromSegment(name: string, segmentKeys?: string[]): boolean;
     isInSegment(name: string, key?: string): boolean;
     registerSegments(names: string[]): boolean;
     getRegisteredSegments(): string[];
@@ -353,3 +344,12 @@ export interface IStorageFactoryParams {
     onReadyCb?: (error?: any) => void;
     metadata: IMetadata;
 }
+export declare type StorageType = 'MEMORY' | 'LOCALSTORAGE' | 'REDIS' | 'CUSTOM';
+export declare type IStorageSyncFactory = {
+    type: StorageType;
+    (params: IStorageFactoryParams): IStorageSync;
+};
+export declare type IStorageAsyncFactory = {
+    type: StorageType;
+    (params: IStorageFactoryParams): IStorageAsync;
+};

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

@@ -1,7 +1,2 @@
-import { ISplitPartial } from '../../../dtos/types';
-import { SplitIO } from '../../../types';
-import { ILogger } from '../../../logger/types';
-export default function splitsParserFromFile({ features, log }: {
-    features?: SplitIO.MockedFeaturesFilePath;
-    log: ILogger;
-}): false | Record<string, ISplitPartial>;
+import { ISplitsParser } from './types';
+export declare function splitsParserFromFileFactory(): ISplitsParser;

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

@@ -1,7 +1,3 @@
 import { ISplitPartial } from '../../../dtos/types';
 import { ISettings } from '../../../types';
-/**
- *
- * @param features validated object with mocked features mapping.
- */
-export default function splitsParserFromSettings(settings: ISettings): false | Record<string, ISplitPartial>;
+export declare function splitsParserFromSettingsFactory(): (settings: ISettings) => false | Record<string, ISplitPartial>;

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

@@ -2,10 +2,11 @@ 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> {
 }
-export interface ISegmentsSyncTask extends ISyncTask<[segmentNames?: string[], noCache?: boolean, fetchOnlyNew?: boolean], boolean> {
+export interface ISegmentsSyncTask extends ISyncTask<[segmentNames?: SegmentsData, noCache?: boolean, fetchOnlyNew?: boolean], boolean> {
 }
 export interface IPollingManager extends ITask {
     syncAll(): Promise<any>;

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

@@ -6,6 +6,7 @@ export interface IAuthTokenPushEnabled {
     channels: {
         [channel: string]: string[];
     };
+    connDelay?: number;
 }
 export interface IAuthTokenPushDisabled {
     pushEnabled: false;
@@ -13,3 +14,4 @@ export interface IAuthTokenPushDisabled {
 }
 export declare type IAuthToken = IAuthTokenPushDisabled | IAuthTokenPushEnabled;
 export declare type IAuthenticate = (userKeys?: string[]) => Promise<IAuthToken>;
+export declare type IAuthenticateV2 = (isClientSide?: boolean) => Promise<IAuthToken>;

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

@@ -9,7 +9,6 @@ export default class SSEClient implements ISSEClient {
     streamingUrl: string;
     connection?: InstanceType<typeof EventSource>;
     handler?: ISseEventHandler;
-    authToken?: IAuthTokenPushEnabled;
     useHeaders?: boolean;
     headers: Record<string, string>;
     /**
@@ -20,7 +19,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?: () => (typeof EventSource | undefined));
     setEventHandler(handler: ISseEventHandler): void;
     /**
      * Open the connection with a given authToken
@@ -31,11 +30,4 @@ export default class SSEClient implements ISSEClient {
     open(authToken: IAuthTokenPushEnabled): void;
     /** Close connection  */
     close(): void;
-    /**
-     * Re-open the connection with the last given authToken.
-     *
-     * @throws {TypeError} if `open` has not been previously called with an authToken
-     * @TODO this method is not used currently and could be removed.
-     */
-    reopen(): void;
 }

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

@@ -6,7 +6,6 @@ export interface ISseEventHandler {
 }
 export interface ISSEClient {
     open(authToken: IAuthTokenPushEnabled): void;
-    reopen(): void;
     close(): void;
     setEventHandler(handler: ISseEventHandler): void;
 }

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

@@ -13,7 +13,8 @@ export declare function errorParser(error: Event): INotificationError;
  * Also assigns the type OCCUPANCY, if it corresponds, so that all supported messages (e.g., SPLIT_UPDATE, CONTROL) have a type.
  *
  * @param message
- * @returns parsed notification message
+ * @returns parsed notification message or undefined if the given event data is falsy (e.g, '' or undefined).
+ * For example, the EventSource implementation of React-Native for iOS emits a message event with empty data for Ably keepalive comments.
  * @throws {SyntaxError} if `message.data` or `JSON.parse(message.data).data` are invalid JSON strings
  */
-export declare function messageParser(message: MessageEvent): INotificationMessage;
+export declare function messageParser(message: MessageEvent): INotificationMessage | undefined;

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

@@ -1,11 +1,34 @@
 import { ControlType } from '../constants';
-import { MY_SEGMENTS_UPDATE, SEGMENT_UPDATE, SPLIT_UPDATE, SPLIT_KILL, CONTROL, OCCUPANCY } from '../types';
+import { MY_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V2, SEGMENT_UPDATE, SPLIT_UPDATE, SPLIT_KILL, CONTROL, OCCUPANCY } from '../types';
 export interface IMySegmentsUpdateData {
     type: MY_SEGMENTS_UPDATE;
     changeNumber: number;
     includesPayload: boolean;
     segmentList?: string[];
 }
+export declare enum Compression {
+    None = 0,
+    Gzip = 1,
+    Zlib = 2
+}
+export declare enum UpdateStrategy {
+    UnboundedFetchRequest = 0,
+    BoundedFetchRequest = 1,
+    KeyList = 2,
+    SegmentRemoval = 3
+}
+export interface KeyList {
+    a?: string[];
+    r?: string[];
+}
+export interface IMySegmentsUpdateV2Data {
+    type: MY_SEGMENTS_UPDATE_V2;
+    changeNumber: number;
+    segmentName: string;
+    c: Compression;
+    d: string;
+    u: UpdateStrategy;
+}
 export interface ISegmentUpdateData {
     type: SEGMENT_UPDATE;
     changeNumber: number;
@@ -31,7 +54,7 @@ export interface IOccupancyData {
         publishers: number;
     };
 }
-export declare type INotificationData = IMySegmentsUpdateData | ISegmentUpdateData | ISplitUpdateData | ISplitKillData | IControlData | IOccupancyData;
+export declare type INotificationData = IMySegmentsUpdateData | IMySegmentsUpdateV2Data | ISegmentUpdateData | ISplitUpdateData | ISplitKillData | IControlData | IOccupancyData;
 export declare type INotificationMessage = {
     parsedData: INotificationData;
     channel: string;
@@ -40,4 +63,9 @@ export declare type INotificationMessage = {
 };
 export declare type INotificationError = Event & {
     parsedData?: any;
+    message?: string;
+};
+export declare type SegmentsData = string[] | {
+    name: string;
+    add: boolean;
 };

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

@@ -1,6 +1,7 @@
 import { ISegmentsSyncTask } from '../../polling/types';
 import Backoff from '../../../utils/Backoff';
 import { IUpdateWorker } from './types';
+import { SegmentsData } from '../SSEHandler/types';
 /**
  * MySegmentsUpdateWorker class
  */
@@ -8,7 +9,7 @@ export default class MySegmentsUpdateWorker implements IUpdateWorker {
     private readonly mySegmentsSyncTask;
     private maxChangeNumber;
     private handleNewEvent;
-    private segmentList?;
+    private segmentsData?;
     private currentChangeNumber;
     readonly backoff: Backoff;
     /**
@@ -20,7 +21,7 @@ export default class MySegmentsUpdateWorker implements IUpdateWorker {
      * Invoked by NotificationProcessor on MY_SEGMENTS_UPDATE event
      *
      * @param {number} changeNumber change number of the MY_SEGMENTS_UPDATE notification
-     * @param {string[] | undefined} segmentList might be undefined
+     * @param {SegmentsData | undefined} segmentsData might be undefined
      */
-    put(changeNumber: number, segmentList?: string[]): void;
+    put(changeNumber: number, segmentsData?: SegmentsData): void;
 }

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

@@ -1,6 +1,7 @@
 import { ISegmentsCacheSync } from '../../../storages/types';
 import Backoff from '../../../utils/Backoff';
 import { ISegmentsSyncTask } from '../../polling/types';
+import { ISegmentUpdateData } from '../SSEHandler/types';
 import { IUpdateWorker } from './types';
 /**
  * SegmentUpdateWorker class
@@ -23,5 +24,5 @@ export default class SegmentsUpdateWorker implements IUpdateWorker {
      * @param {number} changeNumber change number of the SEGMENT_UPDATE notification
      * @param {string} segmentName segment name of the SEGMENT_UPDATE notification
      */
-    put(changeNumber: number, segmentName: string): void;
+    put({ changeNumber, segmentName }: ISegmentUpdateData): void;
 }

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

@@ -2,6 +2,7 @@ import { ISplitsEventEmitter } from '../../../readiness/types';
 import { ISplitsCacheSync } from '../../../storages/types';
 import Backoff from '../../../utils/Backoff';
 import { ISegmentsSyncTask, ISplitsSyncTask } from '../../polling/types';
+import { ISplitKillData, ISplitUpdateData } from '../SSEHandler/types';
 import { IUpdateWorker } from './types';
 /**
  * SplitsUpdateWorker class
@@ -26,7 +27,7 @@ export default class SplitsUpdateWorker implements IUpdateWorker {
      *
      * @param {number} changeNumber change number of the SPLIT_UPDATE notification
      */
-    put(changeNumber: number): void;
+    put({ changeNumber }: Pick<ISplitUpdateData, 'changeNumber'>): void;
     /**
      * Invoked by NotificationProcessor on SPLIT_KILL event
      *
@@ -34,5 +35,5 @@ export default class SplitsUpdateWorker implements IUpdateWorker {
      * @param {string} splitName name of split to kill
      * @param {string} defaultTreatment default treatment value
      */
-    killSplit(changeNumber: number, splitName: string, defaultTreatment: string): void;
+    killSplit({ changeNumber, splitName, defaultTreatment }: ISplitKillData): void;
 }

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

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

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

@@ -20,6 +20,7 @@ export declare const PUSH_SUBSYSTEM_UP = "PUSH_SUBSYSTEM_UP";
  */
 export declare const PUSH_SUBSYSTEM_DOWN = "PUSH_SUBSYSTEM_DOWN";
 export declare const MY_SEGMENTS_UPDATE = "MY_SEGMENTS_UPDATE";
+export declare const MY_SEGMENTS_UPDATE_V2 = "MY_SEGMENTS_UPDATE_V2";
 export declare const SEGMENT_UPDATE = "SEGMENT_UPDATE";
 export declare const SPLIT_KILL = "SPLIT_KILL";
 export declare const SPLIT_UPDATE = "SPLIT_UPDATE";
@@ -28,5 +29,6 @@ export declare const OCCUPANCY = "OCCUPANCY";
 export declare enum ControlType {
     STREAMING_DISABLED = "STREAMING_DISABLED",
     STREAMING_PAUSED = "STREAMING_PAUSED",
-    STREAMING_RESUMED = "STREAMING_RESUMED"
+    STREAMING_RESUMED = "STREAMING_RESUMED",
+    STREAMING_RESET = "STREAMING_RESET"
 }

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

@@ -0,0 +1,27 @@
+import { Compression, KeyList } from './SSEHandler/types';
+/**
+ * Decode, decompress and parse the provided 'data' into a KeyList object
+ *
+ * @param {string} data
+ * @param {number} compression
+ * @returns {{a?: string[], r?: string[] }}
+ * @throws if data string cannot be decoded, decompressed or parsed
+ */
+export declare function parseKeyList(data: string, compression: Compression): KeyList;
+/**
+ * Decode, decompress and parse the provided 'data' into a Bitmap object
+ *
+ * @param {string} data
+ * @param {number} compression
+ * @returns {Uint8Array}
+ * @throws if data string cannot be decoded or decompressed
+ */
+export declare function parseBitmap(data: string, compression: Compression): Uint8Array;
+/**
+ * Check if the 'bitmap' bit at 'hash64hex' position is 1
+ *
+ * @param {Uint8Array} bitmap
+ * @param {string} hash64hex 16-chars string, representing a number in hexa
+ * @returns {boolean}
+ */
+export declare function isInBitmap(bitmap: Uint8Array, hash64hex: string): boolean;

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

@@ -1,4 +1,4 @@
-import { IMySegmentsUpdateData } from './SSEHandler/types';
+import { IMySegmentsUpdateData, IMySegmentsUpdateV2Data, ISegmentUpdateData, ISplitUpdateData, ISplitKillData } from './SSEHandler/types';
 import { ITask } from '../types';
 import { IPollingManager, ISegmentsSyncTask } from '../polling/types';
 import { IReadinessManager } from '../../readiness/types';
@@ -6,25 +6,28 @@ import { IFetchAuth } from '../../services/types';
 import { IStorageSync } from '../../storages/types';
 import { IEventEmitter, ISettings } from '../../types';
 import { IPlatform } from '../../sdkFactory/types';
+import { ControlType } from './constants';
 export declare type PUSH_SUBSYSTEM_UP = 'PUSH_SUBSYSTEM_UP';
 export declare type PUSH_SUBSYSTEM_DOWN = 'PUSH_SUBSYSTEM_DOWN';
 export declare type PUSH_NONRETRYABLE_ERROR = 'PUSH_NONRETRYABLE_ERROR';
 export declare type PUSH_RETRYABLE_ERROR = 'PUSH_RETRYABLE_ERROR';
 export declare type MY_SEGMENTS_UPDATE = 'MY_SEGMENTS_UPDATE';
+export declare type MY_SEGMENTS_UPDATE_V2 = 'MY_SEGMENTS_UPDATE_V2';
 export declare type SEGMENT_UPDATE = 'SEGMENT_UPDATE';
 export declare type SPLIT_KILL = 'SPLIT_KILL';
 export declare type SPLIT_UPDATE = 'SPLIT_UPDATE';
 export declare type CONTROL = 'CONTROL';
 export declare type OCCUPANCY = 'OCCUPANCY';
-export declare type IPushEvent = PUSH_SUBSYSTEM_UP | PUSH_SUBSYSTEM_DOWN | PUSH_NONRETRYABLE_ERROR | PUSH_RETRYABLE_ERROR | MY_SEGMENTS_UPDATE | SEGMENT_UPDATE | SPLIT_UPDATE | SPLIT_KILL;
+export declare type IPushEvent = PUSH_SUBSYSTEM_UP | PUSH_SUBSYSTEM_DOWN | PUSH_NONRETRYABLE_ERROR | PUSH_RETRYABLE_ERROR | MY_SEGMENTS_UPDATE | MY_SEGMENTS_UPDATE_V2 | SEGMENT_UPDATE | SPLIT_UPDATE | SPLIT_KILL | ControlType.STREAMING_RESET;
+declare type IParsedData<T extends IPushEvent> = T extends MY_SEGMENTS_UPDATE ? IMySegmentsUpdateData : T extends MY_SEGMENTS_UPDATE_V2 ? IMySegmentsUpdateV2Data : T extends SEGMENT_UPDATE ? ISegmentUpdateData : T extends SPLIT_UPDATE ? ISplitUpdateData : T extends SPLIT_KILL ? ISplitKillData : undefined;
 /**
  * EventEmitter used as Feedback Loop between the SyncManager and PushManager,
  * where the latter pushes messages and the former consumes it
  */
 export interface IPushEventEmitter extends IEventEmitter {
-    once<T extends IPushEvent>(event: T, listener: (...args: T extends MY_SEGMENTS_UPDATE ? [parsedData: IMySegmentsUpdateData, channel: string] : T extends SEGMENT_UPDATE ? [changeNumber: number, segmentName: string] : T extends SPLIT_UPDATE ? [changeNumber: number] : T extends SPLIT_KILL ? [changeNumber: number, splitName: string, defaultTreatment: string] : any[]) => void): this;
-    on<T extends IPushEvent>(event: T, listener: (...args: T extends MY_SEGMENTS_UPDATE ? [parsedData: IMySegmentsUpdateData, channel: string] : T extends SEGMENT_UPDATE ? [changeNumber: number, segmentName: string] : T extends SPLIT_UPDATE ? [changeNumber: number] : T extends SPLIT_KILL ? [changeNumber: number, splitName: string, defaultTreatment: string] : any[]) => void): this;
-    emit<T extends IPushEvent>(event: T, ...args: T extends MY_SEGMENTS_UPDATE ? [parsedData: IMySegmentsUpdateData, channel: string] : T extends SEGMENT_UPDATE ? [changeNumber: number, segmentName: string] : T extends SPLIT_UPDATE ? [changeNumber: number] : T extends SPLIT_KILL ? [changeNumber: number, splitName: string, defaultTreatment: string] : any[]): boolean;
+    once<T extends IPushEvent>(event: T, listener: (parsedData: IParsedData<T>, channel: T extends MY_SEGMENTS_UPDATE ? string : undefined) => void): this;
+    on<T extends IPushEvent>(event: T, listener: (parsedData: IParsedData<T>, channel: T extends MY_SEGMENTS_UPDATE ? string : undefined) => void): this;
+    emit<T extends IPushEvent>(event: T, parsedData?: IParsedData<T>, channel?: T extends MY_SEGMENTS_UPDATE ? string : undefined): boolean;
 }
 /**
  * PushManager for server-side
@@ -49,3 +52,4 @@ export declare type IPushManagerFactoryParams = [
     platform: IPlatform,
     settings: ISettings
 ];
+export {};

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

@@ -7,4 +7,4 @@ import { IResponse } from '../../services/types';
  */
 export declare function submitterSyncTaskFactory<TState extends {
     length?: number;
-}>(log: ILogger, postClient: (body: string) => Promise<IResponse>, sourceCache: IRecorderCacheProducerSync<TState>, postRate: number, dataName: string, latencyTracker?: ITimeTracker, fromCacheToPayload?: (cacheData: TState) => any, maxRetries?: number): ISyncTask<[], void>;
+}>(log: ILogger, postClient: (body: string) => Promise<IResponse>, sourceCache: IRecorderCacheProducerSync<TState>, postRate: number, dataName: string, latencyTracker?: ITimeTracker, fromCacheToPayload?: (cacheData: TState) => any, maxRetries?: number, debugLogs?: boolean): ISyncTask<[], void>;

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

@@ -6,4 +6,4 @@ import { ISplitsParser } from './offline/splitsParser/types';
  *
  * @param splitsParser e.g., `splitsParserFromFile`, `splitsParserFromSettings`.
  */
-export declare function syncManagerOfflineFactory(splitsParser: ISplitsParser): (params: ISyncManagerFactoryParams) => ISyncManagerCS;
+export declare function syncManagerOfflineFactory(splitsParserFactory: () => ISplitsParser): (params: ISyncManagerFactoryParams) => ISyncManagerCS;

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

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

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

@@ -1,2 +1,2 @@
 import { ImpressionDTO } from '../../types';
-export default function buildKey(impression: ImpressionDTO): string;
+export declare function buildKey(impression: ImpressionDTO): string;

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

@@ -1,4 +1,4 @@
 import ImpressionObserver from './ImpressionObserver';
 import { ImpressionDTO } from '../../types';
-export declare function hashImpression32(impression: ImpressionDTO): string | null;
-export declare function impressionObserverCSFactory(): ImpressionObserver;
+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 { ImpressionDTO } from '../../types';
-export declare function hashImpression128(impression: ImpressionDTO): string | null;
-export declare function impressionObserverSSFactory(): ImpressionObserver;
+export declare function hashImpression128(impression: ImpressionDTO): string;
+export declare function impressionObserverSSFactory(): ImpressionObserver<string>;