@splitsoftware/splitio-commons 1.17.1-rc.4 → 1.17.1

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

@@ -1,17 +1,19 @@
-import { ISegmentsCacheSync } from '../types';
+import { AbstractSegmentsCacheSync } from '../AbstractSegmentsCacheSync';
 /**
- * Default ISplitsCacheSync implementation for server-side that stores segments definitions in memory.
+ * Default ISplitsCacheSync implementation that stores split definitions in memory.
+ * Supported by all JS runtimes.
  */
-export declare class SegmentsCacheInMemory implements ISegmentsCacheSync {
+export declare class SegmentsCacheInMemory extends AbstractSegmentsCacheSync {
     private segmentCache;
     private segmentChangeNumber;
-    update(name: string, addedKeys: string[], removedKeys: string[], changeNumber: number): boolean;
+    addToSegment(name: string, segmentKeys: string[]): boolean;
+    removeFromSegment(name: string, segmentKeys: string[]): boolean;
     isInSegment(name: string, key: string): boolean;
     clear(): void;
     private _registerSegment;
     registerSegments(names: string[]): boolean;
     getRegisteredSegments(): string[];
     getKeysCount(): number;
-    getChangeNumber(name: string): number;
-    resetSegments(): boolean;
+    setChangeNumber(name: string, changeNumber: number): boolean;
+    getChangeNumber(name: string): number | undefined;
 }

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

@@ -3,13 +3,14 @@ import { AbstractSplitsCacheSync } from '../AbstractSplitsCacheSync';
 import { ISet } from '../../utils/lang/sets';
 /**
  * Default ISplitsCacheSync implementation that stores split definitions in memory.
+ * Supported by all JS runtimes.
  */
 export declare class SplitsCacheInMemory extends AbstractSplitsCacheSync {
     private flagSetsFilter;
     private splitsCache;
     private ttCache;
     private changeNumber;
-    private segmentsCount;
+    private splitsWithSegmentsCount;
     private flagSetsCache;
     constructor(splitFiltersValidation?: ISplitFiltersValidation);
     clear(): void;

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

@@ -1,4 +1,4 @@
-import { ImpressionDataType, EventDataType, StreamingEvent, Method, OperationType, TelemetryUsageStatsPayload, UpdatesFromSSEEnum, UpdatesFromSSE } from '../../sync/submitters/types';
+import { ImpressionDataType, EventDataType, StreamingEvent, Method, OperationType, TelemetryUsageStatsPayload, UpdatesFromSSEEnum } from '../../sync/submitters/types';
 import { ISegmentsCacheSync, ISplitsCacheSync, IStorageFactoryParams, ITelemetryCacheSync } from '../types';
 export declare const MAX_LATENCY_BUCKET_COUNT = 23;
 export declare function newBuckets(): number[];
@@ -10,8 +10,7 @@ export declare function shouldRecordTelemetry({ settings }: IStorageFactoryParam
 export declare class TelemetryCacheInMemory implements ITelemetryCacheSync {
     private splits?;
     private segments?;
-    private largeSegments?;
-    constructor(splits?: ISplitsCacheSync | undefined, segments?: ISegmentsCacheSync | undefined, largeSegments?: ISegmentsCacheSync | undefined);
+    constructor(splits?: ISplitsCacheSync | undefined, segments?: ISegmentsCacheSync | undefined);
     private e;
     isEmpty(): boolean;
     clear(): void;
@@ -66,6 +65,9 @@ export declare class TelemetryCacheInMemory implements ITelemetryCacheSync {
     popLatencies(): Partial<Record<Method, number[]>>;
     recordLatency(method: Method, latencyMs: number): void;
     private updatesFromSSE;
-    popUpdatesFromSSE(): UpdatesFromSSE;
+    popUpdatesFromSSE(): {
+        sp: number;
+        ms: number;
+    };
     recordUpdatesFromSSE(type: UpdatesFromSSEEnum): void;
 }

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

@@ -7,14 +7,11 @@ export declare class SegmentsCacheInRedis implements ISegmentsCacheAsync {
     private readonly redis;
     private readonly keys;
     constructor(log: ILogger, keys: KeyBuilderSS, redis: RedisAdapter);
-    /**
-     * Update the given segment `name` with the lists of `addedKeys`, `removedKeys` and `changeNumber`.
-     * The returned promise is resolved if the operation success, with `true` if the segment was updated (i.e., some key was added or removed),
-     * or rejected if it fails (e.g., Redis operation fails).
-     */
-    update(name: string, addedKeys: string[], removedKeys: string[], changeNumber: number): Promise<boolean>;
+    addToSegment(name: string, segmentKeys: string[]): Promise<boolean>;
+    removeFromSegment(name: string, segmentKeys: string[]): Promise<boolean>;
     isInSegment(name: string, key: string): Promise<boolean>;
-    getChangeNumber(name: string): Promise<number>;
+    setChangeNumber(name: string, changeNumber: number): Promise<boolean>;
+    getChangeNumber(name: string): Promise<number | undefined>;
     registerSegments(segments: string[]): Promise<boolean>;
     getRegisteredSegments(): Promise<string[]>;
     clear(): Promise<void>;

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

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

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

@@ -10,22 +10,34 @@ export declare class SegmentsCachePluggable implements ISegmentsCacheAsync {
     private readonly wrapper;
     constructor(log: ILogger, keys: KeyBuilderSS, wrapper: IPluggableStorageWrapper);
     /**
-     * Update the given segment `name` with the lists of `addedKeys`, `removedKeys` and `changeNumber`.
-     * The returned promise is resolved if the operation success, with `true` if the segment was updated (i.e., some key was added or removed),
-     * or rejected if it fails (e.g., wrapper operation fails).
+     * Add a list of `segmentKeys` to the given segment `name`.
+     * The returned promise is resolved when the operation success
+     * or rejected if wrapper operation fails.
+     */
+    addToSegment(name: string, segmentKeys: string[]): Promise<boolean | void>;
+    /**
+     * Remove a list of `segmentKeys` from the given segment `name`.
+     * The returned promise is resolved when the operation success
+     * or rejected if wrapper operation fails.
      */
-    update(name: string, addedKeys: string[], removedKeys: string[], changeNumber: number): Promise<boolean>;
+    removeFromSegment(name: string, segmentKeys: string[]): Promise<boolean | void>;
     /**
      * Returns a promise that resolves with a boolean value indicating if `key` is part of `name` segment.
      * Promise can be rejected if wrapper operation fails.
      */
     isInSegment(name: string, key: string): Promise<boolean>;
+    /**
+     * Set till number for the given segment `name`.
+     * The returned promise is resolved when the operation success,
+     * or rejected if it fails (e.g., wrapper operation fails).
+     */
+    setChangeNumber(name: string, changeNumber: number): Promise<boolean | void>;
     /**
      * Get till number or -1 if it's not defined.
      * The returned promise is resolved with the changeNumber or -1 if it doesn't exist or a wrapper operation fails.
      * The promise will never be rejected.
      */
-    getChangeNumber(name: string): Promise<number>;
+    getChangeNumber(name: string): Promise<number | undefined>;
     /**
      * Add the given segment names to the set of registered segments.
      * The returned promise is resolved when the operation success,

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

@@ -5,7 +5,7 @@ import { ISet } from '../../utils/lang/sets';
  * The `_cache` property is the object were items are stored.
  * Intended for testing purposes.
  *
- * @param connDelay delay in millis for `connect` resolve. If not provided, `connect` resolves immediately.
+ * @param connDelay delay in millis for `connect` resolve. If not provided, `connect` resolves inmediatelly.
  */
 export declare function inMemoryWrapperFactory(connDelay?: number): IPluggableStorageWrapper & {
     _cache: Record<string, string | string[] | ISet<string>>;

package/types/storages/types.d.ts

@@ -1,5 +1,4 @@
-import { MaybeThenable, ISplit, IMySegmentsResponse } from '../dtos/types';
-import { MySegmentsData } from '../sync/polling/types';
+import { MaybeThenable, ISplit } from '../dtos/types';
 import { EventDataType, HttpErrors, HttpLatencies, ImpressionDataType, LastSync, Method, MethodExceptions, MethodLatencies, MultiMethodExceptions, MultiMethodLatencies, MultiConfigs, OperationType, StoredEventWithMetadata, StoredImpressionWithMetadata, StreamingEvent, UniqueKeysPayloadCs, UniqueKeysPayloadSs, TelemetryUsageStatsPayload, UpdatesFromSSEEnum } from '../sync/submitters/types';
 import { SplitIO, ImpressionDTO, ISettings } from '../types';
 import { ISet } from '../utils/lang/sets';
@@ -201,7 +200,7 @@ export interface ISplitsCacheSync extends ISplitsCacheBase {
     removeSplits(names: string[]): boolean[];
     getSplit(name: string): ISplit | null;
     getSplits(names: string[]): Record<string, ISplit | null>;
-    setChangeNumber(changeNumber: number): boolean | void;
+    setChangeNumber(changeNumber: number): boolean;
     getChangeNumber(): number;
     getAll(): ISplit[];
     getSplitNames(): string[];
@@ -230,29 +229,35 @@ export interface ISplitsCacheAsync extends ISplitsCacheBase {
 }
 /** 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[]>;
-    getChangeNumber(name: string): MaybeThenable<number>;
-    update(name: string, addedKeys: string[], removedKeys: string[], changeNumber: number): MaybeThenable<boolean>;
+    setChangeNumber(name: string, changeNumber: number): MaybeThenable<boolean | void>;
+    getChangeNumber(name: string): MaybeThenable<number | undefined>;
     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;
-    getChangeNumber(name?: string): number;
-    update(name: string, addedKeys: string[], removedKeys: string[], changeNumber: number): boolean;
-    resetSegments(segmentsData: MySegmentsData | IMySegmentsResponse): boolean;
+    setChangeNumber(name: string, changeNumber: number): boolean;
+    getChangeNumber(name: string): number | undefined;
+    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[]>;
-    getChangeNumber(name: string): Promise<number>;
-    update(name: string, addedKeys: string[], removedKeys: string[], changeNumber: number): Promise<boolean>;
+    setChangeNumber(name: string, changeNumber: number): Promise<boolean | void>;
+    getChangeNumber(name: string): Promise<number | undefined>;
     clear(): Promise<boolean | void>;
 }
 /** Recorder storages (impressions, events and telemetry) */
@@ -383,7 +388,6 @@ export interface IStorageBase<TSplitsCache extends ISplitsCacheBase, TSegmentsCa
     shared?: (matchingKey: string, onReadyCb: (error?: any) => void) => this;
 }
 export interface IStorageSync extends IStorageBase<ISplitsCacheSync, ISegmentsCacheSync, IImpressionsCacheSync, IImpressionCountsCacheSync, IEventsCacheSync, ITelemetryCacheSync, IUniqueKeysCacheSync> {
-    largeSegments?: ISegmentsCacheSync;
 }
 export interface IStorageAsync extends IStorageBase<ISplitsCacheAsync, ISegmentsCacheAsync, IImpressionsCacheAsync | IImpressionsCacheSync, IImpressionCountsCacheBase, IEventsCacheAsync | IEventsCacheSync, ITelemetryCacheAsync | ITelemetryCacheSync, IUniqueKeysCacheBase> {
 }

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

@@ -1,7 +1,7 @@
-import { IFetchMemberships } from '../../../services/types';
+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(fetchMemberships: IFetchMemberships): IMySegmentsFetcher;
+export declare function mySegmentsFetcherFactory(fetchMySegments: IFetchMySegments): IMySegmentsFetcher;

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

@@ -1,5 +1,5 @@
-import { ISplitChangesResponse, ISegmentChangesResponse, IMembershipsResponse } from '../../../dtos/types';
+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, till?: number, decorator?: (promise: Promise<IResponse>) => Promise<IResponse>) => Promise<IMembershipsResponse>;
+export declare type IMySegmentsFetcher = (userMatchingKey: string, noCache?: boolean, decorator?: (promise: Promise<IResponse>) => Promise<IResponse>) => Promise<string[]>;

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

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

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

@@ -1,7 +1,6 @@
 import { ISplit } from '../../dtos/types';
 import { IReadinessManager } from '../../readiness/types';
 import { IStorageSync } from '../../storages/types';
-import { MEMBERSHIPS_LS_UPDATE, MEMBERSHIPS_MS_UPDATE } from '../streaming/types';
 import { ITask, ISyncTask } from '../types';
 export interface ISplitsSyncTask extends ISyncTask<[noCache?: boolean, till?: number, splitUpdateNotification?: {
     payload: ISplit;
@@ -10,13 +9,11 @@ export interface ISplitsSyncTask extends ISyncTask<[noCache?: boolean, till?: nu
 }
 export interface ISegmentsSyncTask extends ISyncTask<[fetchOnlyNew?: boolean, segmentName?: string, noCache?: boolean, till?: number], boolean> {
 }
-export declare type MySegmentsData = {
-    type: MEMBERSHIPS_MS_UPDATE | MEMBERSHIPS_LS_UPDATE;
-    cn: number;
-    added: string[];
-    removed: string[];
+export declare type MySegmentsData = string[] | {
+    name: string;
+    add: boolean;
 };
-export interface IMySegmentsSyncTask extends ISyncTask<[segmentsData?: MySegmentsData, noCache?: boolean, till?: number], boolean> {
+export interface IMySegmentsSyncTask extends ISyncTask<[segmentsData?: MySegmentsData, noCache?: boolean], boolean> {
 }
 export interface IPollingManager extends ITask {
     syncAll(): Promise<any>;

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

@@ -1,14 +1,13 @@
 import { IMySegmentsFetcher } from '../fetchers/types';
-import { IStorageSync } from '../../../storages/types';
+import { ISegmentsCacheSync, ISplitsCacheSync } from '../../../storages/types';
 import { ISegmentsEventEmitter } from '../../../readiness/types';
 import { ILogger } from '../../../logger/types';
-import { MySegmentsData } from '../types';
-declare type IMySegmentsUpdater = (segmentsData?: MySegmentsData, noCache?: boolean, till?: number) => Promise<boolean>;
+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, storage: IStorageSync, segmentsEventEmitter: ISegmentsEventEmitter, requestTimeoutBeforeReady: number, retriesOnFailureBeforeReady: number, matchingKey: string): 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/SSEHandler/types.d.ts

@@ -1,5 +1,11 @@
 import { ControlType } from '../constants';
-import { SEGMENT_UPDATE, SPLIT_UPDATE, SPLIT_KILL, CONTROL, OCCUPANCY, MEMBERSHIPS_LS_UPDATE, MEMBERSHIPS_MS_UPDATE } 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,
@@ -15,20 +21,13 @@ export interface KeyList {
     a?: string[];
     r?: string[];
 }
-interface IMembershipUpdateData<T extends string> {
-    type: T;
-    cn: number;
-    n?: string[];
-    c?: Compression;
-    d?: string;
+export interface IMySegmentsUpdateV2Data {
+    type: MY_SEGMENTS_UPDATE_V2;
+    changeNumber: number;
+    segmentName: string;
+    c: Compression;
+    d: string;
     u: UpdateStrategy;
-    i?: number;
-    h?: number;
-    s?: number;
-}
-export interface IMembershipMSUpdateData extends IMembershipUpdateData<MEMBERSHIPS_MS_UPDATE> {
-}
-export interface IMembershipLSUpdateData extends IMembershipUpdateData<MEMBERSHIPS_LS_UPDATE> {
 }
 export interface ISegmentUpdateData {
     type: SEGMENT_UPDATE;
@@ -58,7 +57,7 @@ export interface IOccupancyData {
         publishers: number;
     };
 }
-export declare type INotificationData = IMembershipMSUpdateData | IMembershipLSUpdateData | ISegmentUpdateData | ISplitUpdateData | ISplitKillData | IControlData | IOccupancyData;
+export declare type INotificationData = IMySegmentsUpdateData | IMySegmentsUpdateV2Data | ISegmentUpdateData | ISplitUpdateData | ISplitKillData | IControlData | IOccupancyData;
 export declare type INotificationMessage = {
     parsedData: INotificationData;
     channel: string;
@@ -69,4 +68,3 @@ export declare type INotificationError = Event & {
     parsedData?: any;
     message?: string;
 };
-export {};

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

@@ -1,9 +1,7 @@
-import { IMySegmentsSyncTask, MySegmentsData } from '../../polling/types';
+import { IMySegmentsSyncTask } from '../../polling/types';
 import { IUpdateWorker } from './types';
 import { ITelemetryTracker } from '../../../trackers/types';
-import { IStorageSync } from '../../../storages/types';
-import { ILogger } from '../../../logger/types';
 /**
  * MySegmentsUpdateWorker factory
  */
-export declare function MySegmentsUpdateWorker(log: ILogger, storage: Pick<IStorageSync, 'segments' | 'largeSegments'>, mySegmentsSyncTask: IMySegmentsSyncTask, telemetryTracker: ITelemetryTracker): IUpdateWorker<[mySegmentsData?: Pick<MySegmentsData, 'type' | 'cn'>, payload?: Pick<MySegmentsData, 'added' | 'removed'>, delay?: number]>;
+export declare function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask, telemetryTracker: ITelemetryTracker): IUpdateWorker;

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

@@ -1,9 +1,8 @@
 import { ILogger } from '../../../logger/types';
 import { ISegmentsCacheSync } from '../../../storages/types';
 import { ISegmentsSyncTask } from '../../polling/types';
-import { ISegmentUpdateData } from '../SSEHandler/types';
 import { IUpdateWorker } from './types';
 /**
  * SegmentsUpdateWorker factory
  */
-export declare function SegmentsUpdateWorker(log: ILogger, segmentsSyncTask: ISegmentsSyncTask, segmentsCache: ISegmentsCacheSync): IUpdateWorker<[ISegmentUpdateData]>;
+export declare function SegmentsUpdateWorker(log: ILogger, segmentsSyncTask: ISegmentsSyncTask, segmentsCache: ISegmentsCacheSync): IUpdateWorker;

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

@@ -1,14 +1,13 @@
-import { ISplit } from '../../../dtos/types';
 import { ILogger } from '../../../logger/types';
 import { ISplitsEventEmitter } from '../../../readiness/types';
 import { ISplitsCacheSync } from '../../../storages/types';
 import { ITelemetryTracker } from '../../../trackers/types';
 import { ISegmentsSyncTask, ISplitsSyncTask } from '../../polling/types';
-import { ISplitKillData, ISplitUpdateData } from '../SSEHandler/types';
+import { ISplitKillData } from '../SSEHandler/types';
 import { IUpdateWorker } from './types';
 /**
  * SplitsUpdateWorker factory
  */
-export declare function SplitsUpdateWorker(log: ILogger, splitsCache: ISplitsCacheSync, splitsSyncTask: ISplitsSyncTask, splitsEventEmitter: ISplitsEventEmitter, telemetryTracker: ITelemetryTracker, segmentsSyncTask?: ISegmentsSyncTask): IUpdateWorker<[updateData: ISplitUpdateData, payload?: ISplit]> & {
+export declare function SplitsUpdateWorker(log: ILogger, splitsCache: ISplitsCacheSync, splitsSyncTask: ISplitsSyncTask, splitsEventEmitter: ISplitsEventEmitter, telemetryTracker: ITelemetryTracker, segmentsSyncTask?: ISegmentsSyncTask): IUpdateWorker & {
     killSplit(event: ISplitKillData): void;
 };

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

@@ -1,4 +1,4 @@
-export interface IUpdateWorker<T extends any[]> {
+export interface IUpdateWorker {
     stop(): void;
-    put(...args: T): void;
+    put(...args: any[]): void;
 }

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

@@ -19,8 +19,8 @@ export declare const PUSH_SUBSYSTEM_UP = "PUSH_SUBSYSTEM_UP";
  * triggers `startPolling` and `stopWorkers` calls
  */
 export declare const PUSH_SUBSYSTEM_DOWN = "PUSH_SUBSYSTEM_DOWN";
-export declare const MEMBERSHIPS_MS_UPDATE = "MEMBERSHIPS_MS_UPDATE";
-export declare const MEMBERSHIPS_LS_UPDATE = "MEMBERSHIPS_LS_UPDATE";
+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";

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

@@ -1,5 +1,4 @@
-import { Compression, IMembershipMSUpdateData, KeyList } from './SSEHandler/types';
-import { ISplit } from '../../dtos/types';
+import { Compression, KeyList } from './SSEHandler/types';
 /**
  * Decode, decompress and parse the provided 'data' into a KeyList object
  *
@@ -29,6 +28,8 @@ export declare function parseBitmap(data: string, compression: Compression): Uin
 export declare function isInBitmap(bitmap: Uint8Array, hash64hex: string): boolean;
 /**
  * Parse feature flags notifications for instant feature flag updates
+ *
+ * @param {ISplitUpdateData} data
+ * @returns {KeyList}
  */
-export declare function parseFFUpdatePayload(compression: Compression, data: string): ISplit | undefined;
-export declare function getDelay(parsedData: Pick<IMembershipMSUpdateData, 'i' | 'h' | 's'>, matchingKey: string): number;
+export declare function parseFFUpdatePayload(compression: Compression, data: string): KeyList | undefined;

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

@@ -1,4 +1,4 @@
-import { IMembershipMSUpdateData, IMembershipLSUpdateData, ISegmentUpdateData, ISplitUpdateData, ISplitKillData, INotificationData } from './SSEHandler/types';
+import { IMySegmentsUpdateData, IMySegmentsUpdateV2Data, ISegmentUpdateData, ISplitUpdateData, ISplitKillData } from './SSEHandler/types';
 import { ITask } from '../types';
 import { IMySegmentsSyncTask } from '../polling/types';
 import { IEventEmitter } from '../../types';
@@ -7,23 +7,23 @@ 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 MEMBERSHIPS_MS_UPDATE = 'MEMBERSHIPS_MS_UPDATE';
-export declare type MEMBERSHIPS_LS_UPDATE = 'MEMBERSHIPS_LS_UPDATE';
+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 | MEMBERSHIPS_MS_UPDATE | MEMBERSHIPS_LS_UPDATE | SEGMENT_UPDATE | SPLIT_UPDATE | SPLIT_KILL | ControlType.STREAMING_RESET;
-declare type IParsedData<T extends IPushEvent> = T extends MEMBERSHIPS_MS_UPDATE ? IMembershipMSUpdateData : T extends MEMBERSHIPS_LS_UPDATE ? IMembershipLSUpdateData : T extends SEGMENT_UPDATE ? ISegmentUpdateData : T extends SPLIT_UPDATE ? ISplitUpdateData : T extends SPLIT_KILL ? ISplitKillData : INotificationData;
+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: (parsedData: IParsedData<T>) => void): this;
-    on<T extends IPushEvent>(event: T, listener: (parsedData: IParsedData<T>) => void): this;
-    emit<T extends IPushEvent>(event: T, parsedData?: IParsedData<T>): 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

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

@@ -90,7 +90,7 @@ export declare type DROPPED = 1;
 export declare type DEDUPED = 2;
 export declare type ImpressionDataType = QUEUED | DROPPED | DEDUPED;
 export declare type EventDataType = QUEUED | DROPPED;
-export declare type UpdatesFromSSEEnum = SPLITS | MEMBERSHIPS;
+export declare type UpdatesFromSSEEnum = SPLITS | MY_SEGMENT;
 export declare type SPLITS = 'sp';
 export declare type IMPRESSIONS = 'im';
 export declare type IMPRESSIONS_COUNT = 'ic';
@@ -98,8 +98,8 @@ export declare type EVENTS = 'ev';
 export declare type TELEMETRY = 'te';
 export declare type TOKEN = 'to';
 export declare type SEGMENT = 'se';
-export declare type MEMBERSHIPS = 'ms';
-export declare type OperationType = SPLITS | IMPRESSIONS | IMPRESSIONS_COUNT | EVENTS | TELEMETRY | TOKEN | SEGMENT | MEMBERSHIPS;
+export declare type MY_SEGMENT = 'ms';
+export declare type OperationType = SPLITS | IMPRESSIONS | IMPRESSIONS_COUNT | EVENTS | TELEMETRY | TOKEN | SEGMENT | MY_SEGMENT;
 export declare type LastSync = Partial<Record<OperationType, number | undefined>>;
 export declare type HttpErrors = Partial<Record<OperationType, {
     [statusCode: string]: number;
@@ -136,9 +136,8 @@ export declare type TelemetryUsageStats = {
     mE?: MethodExceptions;
 };
 export declare type UpdatesFromSSE = {
-    sp?: number;
+    sp: number;
     ms?: number;
-    mls?: number;
 };
 export declare type TelemetryUsageStatsPayload = TelemetryUsageStats & {
     lS: LastSync;
@@ -152,8 +151,6 @@ export declare type TelemetryUsageStatsPayload = TelemetryUsageStats & {
     spC?: number;
     seC?: number;
     skC?: number;
-    lsC?: number;
-    lskC?: number;
     sL?: number;
     eQ: number;
     eD: number;

package/types/sync/types.d.ts

@@ -39,5 +39,5 @@ export interface ISyncManager extends ITask {
     submitterManager?: ISubmitterManager;
 }
 export interface ISyncManagerCS extends ISyncManager {
-    shared(matchingKey: string, readinessManager: IReadinessManager, storage: IStorageSync): Pick<ISyncManager, 'stop' | 'flush'> | undefined;
+    shared(matchingKey: string, readinessManager: IReadinessManager, storage: IStorageSync): ISyncManager | undefined;
 }

package/types/trackers/eventTracker.d.ts

@@ -7,4 +7,4 @@ import { ISettings } from '../types';
  * @param eventsCache cache to save events
  * @param integrationsManager optional event handler used for integrations
  */
-export declare function eventTrackerFactory(settings: ISettings, eventsCache: IEventsCacheBase, whenInit: (cb: () => void) => void, integrationsManager?: IEventsHandler, telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync): IEventTracker;
+export declare function eventTrackerFactory(settings: ISettings, eventsCache: IEventsCacheBase, integrationsManager?: IEventsHandler, telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync): IEventTracker;

package/types/trackers/impressionsTracker.d.ts

@@ -10,4 +10,4 @@ import { ISettings } from '../types';
  * @param integrationsManager optional integrations manager
  * @param strategy strategy for impressions tracking.
  */
-export declare function impressionsTrackerFactory(settings: ISettings, impressionsCache: IImpressionsCacheBase, strategy: IStrategy, whenInit: (cb: () => void) => void, integrationsManager?: IImpressionsHandler, telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync): IImpressionsTracker;
+export declare function impressionsTrackerFactory(settings: ISettings, impressionsCache: IImpressionsCacheBase, strategy: IStrategy, integrationsManager?: IImpressionsHandler, telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync): IImpressionsTracker;

package/types/trackers/types.d.ts

@@ -54,7 +54,6 @@ export interface IImpressionSenderAdapter {
 }
 /** Unique keys tracker */
 export interface IUniqueKeysTracker {
-    start(): void;
     stop(): void;
     track(key: string, featureName: string): void;
 }

package/types/types.d.ts

@@ -422,7 +422,7 @@ export interface IStatusInterface extends IEventEmitter {
  * @interface IBasicClient
  * @extends IStatusInterface
  */
-export interface IBasicClient extends IStatusInterface {
+interface IBasicClient extends IStatusInterface {
     /**
      * Flush data
      * @function flush
@@ -452,12 +452,6 @@ interface IBasicSDK {
      * @property Logger
      */
     Logger: ILoggerAPI;
-    /**
-     * Destroy all the clients created by this factory.
-     * @function destroy
-     * @returns {Promise<void>}
-     */
-    destroy(): Promise<void>;
 }
 /****** Exposed namespace ******/
 /**

package/types/utils/constants/index.d.ts

@@ -52,7 +52,7 @@ export declare const EVENTS = "ev";
 export declare const TELEMETRY = "te";
 export declare const TOKEN = "to";
 export declare const SEGMENT = "se";
-export declare const MEMBERSHIPS = "ms";
+export declare const MY_SEGMENT = "ms";
 export declare const TREATMENT = "t";
 export declare const TREATMENTS = "ts";
 export declare const TREATMENT_WITH_CONFIG = "tc";
@@ -78,6 +78,5 @@ export declare const NON_REQUESTED = 1;
 export declare const DISABLED = 0;
 export declare const ENABLED = 1;
 export declare const PAUSED = 2;
-export declare const FLAG_SPEC_VERSION = "1.2";
+export declare const FLAG_SPEC_VERSION = "1.1";
 export declare const IN_SEGMENT = "IN_SEGMENT";
-export declare const IN_LARGE_SEGMENT = "IN_LARGE_SEGMENT";

package/types/utils/settingsValidation/types.d.ts

@@ -28,7 +28,7 @@ export interface ISettingsValidationParams {
     /** Localhost mode validator (`settings.sync.localhostMode`) */
     localhost?: (settings: ISettings) => ISettings['sync']['localhostMode'];
     /** User consent validator (`settings.userConsent`) */
-    consent?: (settings: ISettings) => ISettings['userConsent'];
+    consent: (settings: ISettings) => ISettings['userConsent'];
     /** Flag spec version validation. Configurable by the JS Synchronizer but not by the SDKs */
     flagSpec?: (settings: ISettings) => ISettings['sync']['flagSpecVersion'];
 }

package/cjs/evaluator/matchers/large_segment.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.largeSegmentMatcherContext = void 0;
-var thenable_1 = require("../../utils/promise/thenable");
-function largeSegmentMatcherContext(largeSegmentName, storage) {
-    return function largeSegmentMatcher(key) {
-        var isInLargeSegment = storage.largeSegments ? storage.largeSegments.isInSegment(largeSegmentName, key) : false;
-        if ((0, thenable_1.thenable)(isInLargeSegment)) {
-            isInLargeSegment.then(function (result) {
-                return result;
-            });
-        }
-        return isInLargeSegment;
-    };
-}
-exports.largeSegmentMatcherContext = largeSegmentMatcherContext;