@splitsoftware/splitio-commons 1.16.1-rc.0 → 1.16.1-rc.10

package/src/sync/streaming/types.ts

@@ -1,4 +1,4 @@
-import { IMySegmentsUpdateData, IMySegmentsUpdateV2Data, ISegmentUpdateData, ISplitUpdateData, ISplitKillData, IMyLargeSegmentsUpdateData } from './SSEHandler/types';
+import { IMySegmentsUpdateV3Data, ISegmentUpdateData, ISplitUpdateData, ISplitKillData, IMyLargeSegmentsUpdateData, INotificationData } from './SSEHandler/types';
 import { ITask } from '../types';
 import { IMySegmentsSyncTask } from '../polling/types';
 import { IEventEmitter } from '../../types';
@@ -11,8 +11,7 @@ export type PUSH_NONRETRYABLE_ERROR = 'PUSH_NONRETRYABLE_ERROR'
 export type PUSH_RETRYABLE_ERROR = 'PUSH_RETRYABLE_ERROR'
 
 // Update-type push notifications, handled by NotificationProcessor
-export type MY_SEGMENTS_UPDATE = 'MY_SEGMENTS_UPDATE';
-export type MY_SEGMENTS_UPDATE_V2 = 'MY_SEGMENTS_UPDATE_V2';
+export type MY_SEGMENTS_UPDATE_V3 = 'MY_SEGMENTS_UPDATE_V3';
 export type SEGMENT_UPDATE = 'SEGMENT_UPDATE';
 export type SPLIT_KILL = 'SPLIT_KILL';
 export type SPLIT_UPDATE = 'SPLIT_UPDATE';
@@ -22,24 +21,23 @@ export type MY_LARGE_SEGMENTS_UPDATE = 'MY_LARGE_SEGMENTS_UPDATE';
 export type CONTROL = 'CONTROL';
 export type OCCUPANCY = 'OCCUPANCY';
 
-export 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 | MY_LARGE_SEGMENTS_UPDATE | ControlType.STREAMING_RESET
+export type IPushEvent = PUSH_SUBSYSTEM_UP | PUSH_SUBSYSTEM_DOWN | PUSH_NONRETRYABLE_ERROR | PUSH_RETRYABLE_ERROR | MY_SEGMENTS_UPDATE_V3 | SEGMENT_UPDATE | SPLIT_UPDATE | SPLIT_KILL | MY_LARGE_SEGMENTS_UPDATE | ControlType.STREAMING_RESET
 
 type IParsedData<T extends IPushEvent> =
-  T extends MY_SEGMENTS_UPDATE ? IMySegmentsUpdateData :
-  T extends MY_SEGMENTS_UPDATE_V2 ? IMySegmentsUpdateV2Data :
+  T extends MY_SEGMENTS_UPDATE_V3 ? IMySegmentsUpdateV3Data :
   T extends MY_LARGE_SEGMENTS_UPDATE ? IMyLargeSegmentsUpdateData :
   T extends SEGMENT_UPDATE ? ISegmentUpdateData :
   T extends SPLIT_UPDATE ? ISplitUpdateData :
-  T extends SPLIT_KILL ? ISplitKillData : undefined;
+  T extends SPLIT_KILL ? ISplitKillData : INotificationData;
 
 /**
  * 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>, 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;
+  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;
 }
 
 /**
@@ -47,6 +45,6 @@ export interface IPushEventEmitter extends IEventEmitter {
  */
 export interface IPushManager extends ITask, IPushEventEmitter {
   // Methods used in client-side, to support multiple clients
-  add(userKey: string, mySegmentsSyncTask: IMySegmentsSyncTask, myLargeSegmentsSyncTask?: IMySegmentsSyncTask): void,
+  add(userKey: string, mySegmentsSyncTask: IMySegmentsSyncTask): void,
   remove(userKey: string): void
 }

package/src/sync/submitters/telemetrySubmitter.ts

@@ -76,12 +76,10 @@ export function telemetryCacheConfigAdapter(telemetry: ITelemetryCacheSync, sett
 
       return objectAssign(getTelemetryConfigStats(settings.mode, settings.storage.type), {
         sE: settings.streamingEnabled,
-        lE: isClientSide ? settings.sync.largeSegmentsEnabled : undefined,
         rR: {
           sp: scheduler.featuresRefreshRate / 1000,
           se: isClientSide ? undefined : scheduler.segmentsRefreshRate / 1000,
           ms: isClientSide ? scheduler.segmentsRefreshRate / 1000 : undefined,
-          mls: isClientSide && settings.sync.largeSegmentsEnabled ? scheduler.largeSegmentsRefreshRate / 1000 : undefined,
           im: scheduler.impressionsRefreshRate / 1000,
           ev: scheduler.eventsPushRate / 1000,
           te: scheduler.telemetryRefreshRate / 1000,

package/src/sync/submitters/types.ts

@@ -114,7 +114,7 @@ export type TOKEN = 'to';
 export type SEGMENT = 'se';
 export type MY_SEGMENT = 'ms';
 export type MY_LARGE_SEGMENT = 'mls';
-export type OperationType = SPLITS | IMPRESSIONS | IMPRESSIONS_COUNT | EVENTS | TELEMETRY | TOKEN | SEGMENT | MY_SEGMENT | MY_LARGE_SEGMENT;
+export type OperationType = SPLITS | IMPRESSIONS | IMPRESSIONS_COUNT | EVENTS | TELEMETRY | TOKEN | SEGMENT | MY_SEGMENT;
 
 export type LastSync = Partial<Record<OperationType, number | undefined>>
 export type HttpErrors = Partial<Record<OperationType, { [statusCode: string]: number }>>
@@ -205,7 +205,6 @@ export type RefreshRates = {
   sp: number, // splits
   se?: number, // segments
   ms?: number, // mySegments
-  mls?: number, // myLargeSegments
   im: number, // impressions
   ev: number, // events
   te: number, // telemetry
@@ -231,7 +230,6 @@ export type TelemetryConfigStats = {
 // 'metrics/config' JSON request body
 export type TelemetryConfigStatsPayload = TelemetryConfigStats & {
   sE: boolean, // streamingEnabled
-  lE?: boolean, // largeSegmentsEnabled
   rR: RefreshRates, // refreshRates
   uO: UrlOverrides, // urlOverrides
   iQ: number, // impressionsQueueSize

package/src/sync/syncManagerOnline.ts

@@ -7,7 +7,7 @@ import { IPollingManager, IPollingManagerCS } from './polling/types';
 import { PUSH_SUBSYSTEM_UP, PUSH_SUBSYSTEM_DOWN } from './streaming/constants';
 import { SYNC_START_POLLING, SYNC_CONTINUE_POLLING, SYNC_STOP_POLLING } from '../logger/constants';
 import { isConsentGranted } from '../consent';
-import { IN_LARGE_SEGMENT, IN_SEGMENT, POLLING, STREAMING, SYNC_MODE_UPDATE } from '../utils/constants';
+import { POLLING, STREAMING, SYNC_MODE_UPDATE } from '../utils/constants';
 import { ISdkFactoryContextSync } from '../sdkFactory/types';
 
 /**
@@ -141,44 +141,36 @@ export function syncManagerOnlineFactory(
       shared(matchingKey: string, readinessManager: IReadinessManager, storage: IStorageSync) {
         if (!pollingManager) return;
 
-        const { msSyncTask, mlsSyncTask } = (pollingManager as IPollingManagerCS).add(matchingKey, readinessManager, storage);
+        const mySegmentsSyncTask = (pollingManager as IPollingManagerCS).add(matchingKey, readinessManager, storage);
 
         return {
-          isRunning: msSyncTask.isRunning,
+          isRunning: mySegmentsSyncTask.isRunning,
           start() {
             if (syncEnabled) {
               if (pushManager) {
                 if (pollingManager!.isRunning()) {
                   // if doing polling, we must start the periodic fetch of data
-                  if (storage.splits.usesMatcher(IN_SEGMENT)) msSyncTask.start();
-                  if (mlsSyncTask && storage.splits.usesMatcher(IN_LARGE_SEGMENT)) mlsSyncTask.start();
+                  if (storage.splits.usesSegments()) mySegmentsSyncTask.start();
                 } else {
                   // if not polling, we must execute the sync task for the initial fetch
                   // of segments since `syncAll` was already executed when starting the main client
-                  msSyncTask.execute();
-                  mlsSyncTask && mlsSyncTask.execute();
+                  mySegmentsSyncTask.execute();
                 }
-                pushManager.add(matchingKey, msSyncTask, mlsSyncTask);
+                pushManager.add(matchingKey, mySegmentsSyncTask);
               } else {
-                if (storage.splits.usesMatcher(IN_SEGMENT)) msSyncTask.start();
-                if (mlsSyncTask && storage.splits.usesMatcher(IN_LARGE_SEGMENT)) mlsSyncTask.start();
+                if (storage.splits.usesSegments()) mySegmentsSyncTask.start();
               }
             } else {
-              if (!readinessManager.isReady()) {
-                msSyncTask.execute();
-                mlsSyncTask && mlsSyncTask.execute();
-              }
+              if (!readinessManager.isReady()) mySegmentsSyncTask.execute();
             }
           },
           stop() {
             // check in case `client.destroy()` has been invoked more than once for the same client
-            const syncTasks = (pollingManager as IPollingManagerCS).get(matchingKey);
-            if (syncTasks) {
-              const { msSyncTask, mlsSyncTask } = syncTasks;
+            const mySegmentsSyncTask = (pollingManager as IPollingManagerCS).get(matchingKey);
+            if (mySegmentsSyncTask) {
               // stop syncing
               if (pushManager) pushManager.remove(matchingKey);
-              if (msSyncTask.isRunning()) msSyncTask.stop();
-              if (mlsSyncTask && mlsSyncTask.isRunning()) mlsSyncTask.stop();
+              if (mySegmentsSyncTask.isRunning()) mySegmentsSyncTask.stop();
 
               (pollingManager as IPollingManagerCS).remove(matchingKey);
             }

package/src/types.ts

@@ -86,7 +86,6 @@ export interface ISettings {
     metricsRefreshRate?: number,
     telemetryRefreshRate: number,
     segmentsRefreshRate: number,
-    largeSegmentsRefreshRate: number,
     offlineRefreshRate: number,
     eventsPushRate: number,
     eventsQueueSize: number,
@@ -96,8 +95,7 @@ export interface ISettings {
     readyTimeout: number,
     requestTimeoutBeforeReady: number,
     retriesOnFailureBeforeReady: number,
-    eventsFirstPushWindow: number,
-    waitForLargeSegments: boolean
+    eventsFirstPushWindow: number
   },
   readonly storage: IStorageSyncFactory | IStorageAsyncFactory,
   readonly integrations: Array<{
@@ -121,7 +119,6 @@ export interface ISettings {
     __splitFiltersValidation: ISplitFiltersValidation,
     localhostMode?: SplitIO.LocalhostFactory,
     enabled: boolean,
-    largeSegmentsEnabled: boolean,
     flagSpecVersion: string
   },
   readonly runtime: {
@@ -816,13 +813,6 @@ export namespace SplitIO {
        * @default 10
        */
       eventsFirstPushWindow?: number,
-      /**
-       * Whether the SDK should wait for large segments to be ready before emitting SDK_READY event.
-       * It only applies if largeSegmentsEnabled is true.
-       * @property {number} waitForLargeSegments
-       * @default true
-       */
-      waitForLargeSegments?: boolean
     },
     /**
      * SDK scheduler settings.
@@ -867,13 +857,6 @@ export namespace SplitIO {
        * @default 60
        */
       segmentsRefreshRate?: number,
-      /**
-       * The SDK polls Split servers for changes to large segment definitions. This parameter controls this polling period in seconds.
-       * It only applies if largeSegmentsEnabled is true.
-       * @property {number} largeSegmentsRefreshRate
-       * @default 60
-       */
-      largeSegmentsRefreshRate?: number,
       /**
        * The SDK posts the queued events data in bulks. This parameter controls the posting rate in seconds.
        * @property {number} eventsPushRate
@@ -946,14 +929,6 @@ export namespace SplitIO {
      * @property {Object} urls
      */
     urls?: UrlSettings,
-    sync?: ISharedSettings['sync'] & {
-      /**
-       * Enables synchronization of large segments.
-       * @property {boolean} largeSegmentsEnabled
-       * @default false
-       */
-      largeSegmentsEnabled?: boolean
-    }
   }
   /**
    * Settings interface for SDK instances created on NodeJS.

package/src/utils/constants/index.ts

@@ -106,7 +106,7 @@ export const DISABLED = 0;
 export const ENABLED = 1;
 export const PAUSED = 2;
 
-export const FLAG_SPEC_VERSION = '1.1';
+export const FLAG_SPEC_VERSION = '1.2';
 
 // Matcher types
 export const IN_SEGMENT = 'IN_SEGMENT';

package/src/utils/settingsValidation/index.ts

@@ -32,8 +32,6 @@ export const base = {
     featuresRefreshRate: 60,
     // fetch segments updates each 60 sec
     segmentsRefreshRate: 60,
-    // fetch large segments updates each 60 sec
-    largeSegmentsRefreshRate: 60,
     // publish telemetry stats each 3600 secs (1 hour)
     telemetryRefreshRate: 3600,
     // publish evaluations each 300 sec (default value for OPTIMIZED impressions mode)
@@ -87,8 +85,7 @@ export const base = {
     impressionsMode: OPTIMIZED,
     localhostMode: undefined,
     enabled: true,
-    flagSpecVersion: FLAG_SPEC_VERSION,
-    largeSegmentsEnabled: false
+    flagSpecVersion: FLAG_SPEC_VERSION
   },
 
   // Logger
@@ -135,7 +132,6 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
   const { scheduler, startup } = withDefaults;
   scheduler.featuresRefreshRate = fromSecondsToMillis(scheduler.featuresRefreshRate);
   scheduler.segmentsRefreshRate = fromSecondsToMillis(scheduler.segmentsRefreshRate);
-  scheduler.largeSegmentsRefreshRate = fromSecondsToMillis(scheduler.largeSegmentsRefreshRate);
   scheduler.offlineRefreshRate = fromSecondsToMillis(scheduler.offlineRefreshRate);
   scheduler.eventsPushRate = fromSecondsToMillis(scheduler.eventsPushRate);
   scheduler.telemetryRefreshRate = fromSecondsToMillis(validateMinValue('telemetryRefreshRate', scheduler.telemetryRefreshRate, 60));

package/types/dtos/types.d.ts

@@ -177,13 +177,20 @@ export interface ISegmentChangesResponse {
     since: number;
     till: number;
 }
-export interface IMySegmentsResponseItem {
-    id: string;
-    name: string;
-}
-/** Interface of the parsed JSON response of `/mySegments/{userKey}` */
-export interface IMySegmentsResponse {
-    mySegments: IMySegmentsResponseItem[];
+/** Interface of the parsed JSON response of `/memberships/{userKey}` */
+export interface IMembershipsResponse {
+    ms?: {
+        cn?: number;
+        k?: Array<{
+            n: string;
+        }>;
+    };
+    ls?: {
+        cn?: number;
+        k?: Array<{
+            n: string;
+        }>;
+    };
 }
 /** Metadata internal type for storages */
 export interface IMetadata {

package/types/logger/constants.d.ts

@@ -35,6 +35,7 @@ export declare const IMPRESSION = 102;
 export declare const IMPRESSION_QUEUEING = 103;
 export declare const NEW_SHARED_CLIENT = 104;
 export declare const NEW_FACTORY = 105;
+export declare const POLLING_SMART_PAUSING = 106;
 export declare const POLLING_START = 107;
 export declare const POLLING_STOP = 108;
 export declare const SYNC_SPLITS_FETCH_RETRY = 109;
@@ -76,7 +77,7 @@ export declare const WARN_SPLITS_FILTER_IGNORED = 219;
 export declare const WARN_SPLITS_FILTER_INVALID = 220;
 export declare const WARN_SPLITS_FILTER_EMPTY = 221;
 export declare const WARN_SDK_KEY = 222;
-export declare const STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2 = 223;
+export declare const STREAMING_PARSING_MY_SEGMENTS_UPDATE = 223;
 export declare const STREAMING_PARSING_SPLIT_UPDATE = 224;
 export declare const WARN_INVALID_FLAGSET = 225;
 export declare const WARN_LOWERCASE_FLAGSET = 226;

package/types/readiness/types.d.ts

@@ -34,7 +34,6 @@ export interface IReadinessManager {
     /** Event emitters */
     splits: ISplitsEventEmitter;
     segments: ISegmentsEventEmitter;
-    largeSegments?: ISegmentsEventEmitter;
     gate: IReadinessEventEmitter;
     /** Readiness status */
     isReady(): boolean;

package/types/services/decorateHeaders.d.ts

@@ -0,0 +1,2 @@
+import { ISettings } from '../types';
+export declare function decorateHeaders(settings: ISettings, headers: Record<string, string>): Record<string, string>;

package/types/services/splitApi.d.ts

@@ -9,4 +9,4 @@ import { ITelemetryTracker } from '../trackers/types';
  * @param platform object containing environment-specific dependencies
  * @param telemetryTracker telemetry tracker
  */
-export declare function splitApiFactory(settings: ISettings, platform: IPlatform, telemetryTracker: ITelemetryTracker): ISplitApi;
+export declare function splitApiFactory(settings: ISettings, platform: Pick<IPlatform, 'getOptions' | 'getFetch'>, telemetryTracker: ITelemetryTracker): ISplitApi;

package/types/services/splitHttpClient.d.ts

@@ -7,4 +7,4 @@ import { IPlatform } from '../sdkFactory/types';
  * @param settings SDK settings, used to access authorizationKey, logger instance and metadata (SDK version, ip and hostname) to set additional headers
  * @param platform object containing environment-specific dependencies
  */
-export declare function splitHttpClientFactory(settings: ISettings, { getOptions, getFetch }: IPlatform): ISplitHttpClient;
+export declare function splitHttpClientFactory(settings: ISettings, { getOptions, getFetch }: Pick<IPlatform, 'getOptions' | 'getFetch'>): ISplitHttpClient;

package/types/services/types.d.ts

@@ -18,7 +18,7 @@ export declare type ISplitHttpClient = (url: string, options?: IRequestOptions,
 export declare type IFetchAuth = (userKeys?: string[]) => Promise<IResponse>;
 export declare type IFetchSplitChanges = (since: number, noCache?: boolean, till?: number) => Promise<IResponse>;
 export declare type IFetchSegmentChanges = (since: number, segmentName: string, noCache?: boolean, till?: number) => Promise<IResponse>;
-export declare type IFetchMySegments = (userMatchingKey: string, noCache?: boolean) => Promise<IResponse>;
+export declare type IFetchMemberships = (userMatchingKey: string, noCache?: boolean) => Promise<IResponse>;
 export declare type IPostEventsBulk = (body: string, headers?: Record<string, string>) => Promise<IResponse>;
 export declare type IPostUniqueKeysBulkCs = (body: string, headers?: Record<string, string>) => Promise<IResponse>;
 export declare type IPostUniqueKeysBulkSs = (body: string, headers?: Record<string, string>) => Promise<IResponse>;
@@ -32,8 +32,7 @@ export interface ISplitApi {
     fetchAuth: IFetchAuth;
     fetchSplitChanges: IFetchSplitChanges;
     fetchSegmentChanges: IFetchSegmentChanges;
-    fetchMySegments: IFetchMySegments;
-    fetchMyLargeSegments: IFetchMySegments;
+    fetchMemberships: IFetchMemberships;
     postEventsBulk: IPostEventsBulk;
     postUniqueKeysBulkCs: IPostUniqueKeysBulkCs;
     postUniqueKeysBulkSs: IPostUniqueKeysBulkSs;

package/types/storages/AbstractSegmentsCacheSync.d.ts

@@ -43,14 +43,10 @@ export declare abstract class AbstractSegmentsCacheSync implements ISegmentsCach
      * For client-side synchronizer: the method is not used.
      */
     setChangeNumber(name: string, changeNumber: number): boolean;
-    /**
-     * For server-side synchronizer: get the change number of `name` segment.
-     * For client-side synchronizer: the method is not used.
-     */
-    getChangeNumber(name: string): number;
+    abstract getChangeNumber(name: string): number;
     /**
      * For server-side synchronizer: the method is not used.
      * For client-side synchronizer: reset the cache with the given list of segments.
      */
-    resetSegments(names: string[]): boolean;
+    resetSegments(names: string[], changeNumber?: number): boolean;
 }

package/types/storages/AbstractSplitsCacheAsync.d.ts

@@ -18,7 +18,7 @@ export declare abstract class AbstractSplitsCacheAsync implements ISplitsCacheAs
     abstract getNamesByFlagSets(flagSets: string[]): Promise<ISet<string>[]>;
     abstract trafficTypeExists(trafficType: string): Promise<boolean>;
     abstract clear(): Promise<boolean | void>;
-    usesMatcher(): Promise<boolean>;
+    usesSegments(): Promise<boolean>;
     /**
      * Check if the splits information is already stored in cache.
      * Noop, just keeping the interface. This is used by client-side implementations only.

package/types/storages/AbstractSplitsCacheSync.d.ts

@@ -17,7 +17,7 @@ export declare abstract class AbstractSplitsCacheSync implements ISplitsCacheSyn
     getAll(): ISplit[];
     abstract getSplitNames(): string[];
     abstract trafficTypeExists(trafficType: string): boolean;
-    abstract usesMatcher(matcherType: string): boolean;
+    abstract usesSegments(): boolean;
     abstract clear(): void;
     /**
      * Check if the splits information is already stored in cache. This data can be preloaded.
@@ -39,6 +39,6 @@ export declare abstract class AbstractSplitsCacheSync implements ISplitsCacheSyn
 }
 /**
  * Given a parsed split, it returns a boolean flagging if its conditions use segments matchers (rules & whitelists).
- * This util is intended to simplify the implementation of `splitsCache::usesMatcher` method
+ * This util is intended to simplify the implementation of `splitsCache::usesSegments` method
  */
-export declare function usesMatcher(split: ISplit, matcherType: string): boolean;
+export declare function usesSegments(split: ISplit): boolean;

package/types/storages/KeyBuilder.d.ts

@@ -10,7 +10,6 @@ export declare class KeyBuilder {
     isSplitKey(key: string): boolean;
     buildSplitKeyPrefix(): string;
     buildSplitsWithSegmentCountKey(): string;
-    buildSplitsWithLargeSegmentCountKey(): string;
     buildSegmentNameKey(segmentName: string): string;
     buildSegmentTillKey(segmentName: string): string;
     extractKey(builtKey: string): string;

package/types/storages/KeyBuilderCS.d.ts

@@ -3,6 +3,7 @@ export interface MySegmentsKeyBuilder {
     buildSegmentNameKey(segmentName: string): string;
     extractSegmentName(builtSegmentKeyName: string): string | undefined;
     extractOldSegmentKey(builtSegmentKeyName: string): string | undefined;
+    buildTillKey(): string;
 }
 export declare class KeyBuilderCS extends KeyBuilder implements MySegmentsKeyBuilder {
     protected readonly regexSplitsCacheKey: RegExp;
@@ -16,5 +17,6 @@ export declare class KeyBuilderCS extends KeyBuilder implements MySegmentsKeyBui
     extractOldSegmentKey(builtSegmentKeyName: string): string | undefined;
     buildLastUpdatedKey(): string;
     isSplitsCacheKey(key: string): boolean;
+    buildTillKey(): string;
 }
 export declare function myLargeSegmentsKeyBuilder(prefix: string, matchingKey: string): MySegmentsKeyBuilder;

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

@@ -16,10 +16,11 @@ export declare class MySegmentsCacheInLocal extends AbstractSegmentsCacheSync {
     /**
      * Reset (update) the cached list of segments with the given list, removing and adding segments if necessary.
      *
-     * @param {string[]} segmentNames list of segment names
+     * @param {string[]} names list of segment names
      * @returns boolean indicating if the cache was updated (i.e., given list was different from the cached one)
      */
-    resetSegments(names: string[]): boolean;
+    resetSegments(names: string[], changeNumber?: number): boolean;
     getRegisteredSegments(): string[];
     getKeysCount(): number;
+    getChangeNumber(): number;
 }

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

@@ -34,7 +34,7 @@ export declare class SplitsCacheInLocal extends AbstractSplitsCacheSync {
     getChangeNumber(): number;
     getSplitNames(): string[];
     trafficTypeExists(trafficType: string): boolean;
-    usesMatcher(matcherType: string): boolean;
+    usesSegments(): boolean;
     /**
      * Check if the splits information is already stored in browser LocalStorage.
      * In this function we could add more code to check if the data is valid.

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

@@ -5,6 +5,7 @@ import { AbstractSegmentsCacheSync } from '../AbstractSegmentsCacheSync';
  */
 export declare class MySegmentsCacheInMemory extends AbstractSegmentsCacheSync {
     private segmentCache;
+    private cn?;
     clear(): void;
     addToSegment(name: string): boolean;
     removeFromSegment(name: string): boolean;
@@ -16,7 +17,8 @@ export declare class MySegmentsCacheInMemory extends AbstractSegmentsCacheSync {
      * @param {string[]} names list of segment names
      * @returns boolean indicating if the cache was updated (i.e., given list was different from the cached one)
      */
-    resetSegments(names: string[]): boolean;
+    resetSegments(names: string[], changeNumber?: number): boolean;
+    getChangeNumber(): number;
     getRegisteredSegments(): string[];
     getKeysCount(): number;
 }

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

@@ -11,7 +11,6 @@ export declare class SplitsCacheInMemory extends AbstractSplitsCacheSync {
     private ttCache;
     private changeNumber;
     private segmentsCount;
-    private largeSegmentsCount;
     private flagSetsCache;
     constructor(splitFiltersValidation?: ISplitFiltersValidation);
     clear(): void;
@@ -22,7 +21,7 @@ export declare class SplitsCacheInMemory extends AbstractSplitsCacheSync {
     getChangeNumber(): number;
     getSplitNames(): string[];
     trafficTypeExists(trafficType: string): boolean;
-    usesMatcher(matcherType: string): boolean;
+    usesSegments(): boolean;
     getNamesByFlagSets(flagSets: string[]): ISet<string>[];
     private addToFlagSets;
     private removeFromFlagSets;

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 inmediatelly.
+ * @param connDelay delay in millis for `connect` resolve. If not provided, `connect` resolves immediately.
  */
 export declare function inMemoryWrapperFactory(connDelay?: number): IPluggableStorageWrapper & {
     _cache: Record<string, string | string[] | ISet<string>>;

package/types/storages/types.d.ts

@@ -189,7 +189,7 @@ export interface ISplitsCacheBase {
     getAll(): MaybeThenable<ISplit[]>;
     getSplitNames(): MaybeThenable<string[]>;
     trafficTypeExists(trafficType: string): MaybeThenable<boolean>;
-    usesMatcher(matcherType: string): MaybeThenable<boolean>;
+    usesSegments(): MaybeThenable<boolean>;
     clear(): MaybeThenable<boolean | void>;
     checkCache(): MaybeThenable<boolean>;
     killLocally(name: string, defaultTreatment: string, changeNumber: number): MaybeThenable<boolean>;
@@ -205,7 +205,7 @@ export interface ISplitsCacheSync extends ISplitsCacheBase {
     getAll(): ISplit[];
     getSplitNames(): string[];
     trafficTypeExists(trafficType: string): boolean;
-    usesMatcher(matcherType: string): boolean;
+    usesSegments(): boolean;
     clear(): void;
     checkCache(): boolean;
     killLocally(name: string, defaultTreatment: string, changeNumber: number): boolean;
@@ -221,7 +221,7 @@ export interface ISplitsCacheAsync extends ISplitsCacheBase {
     getAll(): Promise<ISplit[]>;
     getSplitNames(): Promise<string[]>;
     trafficTypeExists(trafficType: string): Promise<boolean>;
-    usesMatcher(matcherType: string): Promise<boolean>;
+    usesSegments(): Promise<boolean>;
     clear(): Promise<boolean | void>;
     checkCache(): Promise<boolean>;
     killLocally(name: string, defaultTreatment: string, changeNumber: number): Promise<boolean>;
@@ -247,7 +247,7 @@ export interface ISegmentsCacheSync extends ISegmentsCacheBase {
     getKeysCount(): number;
     setChangeNumber(name: string, changeNumber: number): boolean;
     getChangeNumber(name: string): number;
-    resetSegments(names: string[]): boolean;
+    resetSegments(names: string[], changeNumber?: number): boolean;
     clear(): void;
 }
 export interface ISegmentsCacheAsync extends ISegmentsCacheBase {

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

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

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

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

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

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

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

@@ -1,4 +1,4 @@
-import { ISplit } from '../../dtos/types';
+import { IMembershipsResponse, ISplit } from '../../dtos/types';
 import { IReadinessManager } from '../../readiness/types';
 import { IStorageSync } from '../../storages/types';
 import { ITask, ISyncTask } from '../types';
@@ -9,29 +9,23 @@ 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 = string[] | {
+export declare type MySegmentsData = IMembershipsResponse | {
+    isLS?: boolean;
     name: string;
     add: boolean;
-};
-export interface IMySegmentsSyncTask extends ISyncTask<[segmentsData?: MySegmentsData, noCache?: boolean, delay?: number], boolean> {
+}[];
+export interface IMySegmentsSyncTask extends ISyncTask<[segmentsData?: MySegmentsData, noCache?: boolean], boolean> {
 }
 export interface IPollingManager extends ITask {
     syncAll(): Promise<any>;
     splitsSyncTask: ISplitsSyncTask;
     segmentsSyncTask: ISyncTask;
-    largeSegmentsSyncTask?: ISyncTask;
 }
 /**
  * PollingManager for client-side with support for multiple clients
  */
 export interface IPollingManagerCS extends IPollingManager {
-    add(matchingKey: string, readiness: IReadinessManager, storage: IStorageSync): {
-        msSyncTask: IMySegmentsSyncTask;
-        mlsSyncTask?: IMySegmentsSyncTask;
-    };
+    add(matchingKey: string, readiness: IReadinessManager, storage: IStorageSync): IMySegmentsSyncTask;
     remove(matchingKey: string): void;
-    get(matchingKey: string): {
-        msSyncTask: IMySegmentsSyncTask;
-        mlsSyncTask?: IMySegmentsSyncTask;
-    } | undefined;
+    get(matchingKey: string): IMySegmentsSyncTask | undefined;
 }

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

@@ -1,5 +1,6 @@
 import { IMySegmentsFetcher } from '../fetchers/types';
-import { ISegmentsCacheSync } from '../../../storages/types';
+import { IStorageSync } from '../../../storages/types';
+import { ISegmentsEventEmitter } from '../../../readiness/types';
 import { ILogger } from '../../../logger/types';
 import { MySegmentsData } from '../types';
 declare type IMySegmentsUpdater = (segmentList?: MySegmentsData, noCache?: boolean) => Promise<boolean>;
@@ -9,5 +10,5 @@ declare type IMySegmentsUpdater = (segmentList?: MySegmentsData, noCache?: boole
  *  - updates `mySegmentsCache`
  *  - uses `segmentsEventEmitter` to emit events related to segments data updates
  */
-export declare function mySegmentsUpdaterFactory(log: ILogger, mySegmentsFetcher: IMySegmentsFetcher, mySegmentsCache: ISegmentsCacheSync, notifyUpdate: () => void, requestTimeoutBeforeReady: number, retriesOnFailureBeforeReady: number, matchingKey: string): IMySegmentsUpdater;
+export declare function mySegmentsUpdaterFactory(log: ILogger, mySegmentsFetcher: IMySegmentsFetcher, storage: IStorageSync, segmentsEventEmitter: ISegmentsEventEmitter, requestTimeoutBeforeReady: number, retriesOnFailureBeforeReady: number, matchingKey: string): IMySegmentsUpdater;
 export {};