@splitsoftware/splitio-commons 1.16.1-rc.8 → 1.17.0-rc.1

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,8 +119,10 @@ export interface ISettings {
     __splitFiltersValidation: ISplitFiltersValidation,
     localhostMode?: SplitIO.LocalhostFactory,
     enabled: boolean,
-    largeSegmentsEnabled: boolean,
-    flagSpecVersion: string
+    flagSpecVersion: string,
+    requestOptions?: {
+      getHeaderOverrides?: (context: { headers: Record<string, string> }) => Record<string, string>
+    }
   },
   readonly runtime: {
     ip: string | false
@@ -221,7 +221,10 @@ interface ISharedSettings {
      * Enables synchronization.
      * @property {boolean} enabled
      */
-    enabled: boolean
+    enabled?: boolean,
+    requestOptions?: {
+      getHeaderOverrides?: (context: { headers: Record<string, string> }) => Record<string, string>
+    },
   }
 }
 /**
@@ -816,13 +819,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 +863,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 +935,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

@@ -76,7 +76,6 @@ export const TELEMETRY = 'te';
 export const TOKEN = 'to';
 export const SEGMENT = 'se';
 export const MY_SEGMENT = 'ms';
-export const MY_LARGE_SEGMENT = 'mls';
 
 export const TREATMENT = 't';
 export const TREATMENTS = 'ts';
@@ -106,8 +105,7 @@ export const DISABLED = 0;
 export const ENABLED = 1;
 export const PAUSED = 2;
 
-export const FLAG_SPEC_VERSION = '1.2';
+export const FLAG_SPEC_VERSION = '1.1';
 
 // Matcher types
 export const IN_SEGMENT = 'IN_SEGMENT';
-export const IN_LARGE_SEGMENT = 'IN_LARGE_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));
@@ -213,12 +209,11 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
   const splitFiltersValidation = validateSplitFilters(log, sync.splitFilters, withDefaults.mode);
   sync.splitFilters = splitFiltersValidation.validFilters;
   sync.__splitFiltersValidation = splitFiltersValidation;
-
-  // ensure a valid flag spec version
   sync.flagSpecVersion = flagSpec ? flagSpec(withDefaults) : FLAG_SPEC_VERSION;
+
   // ensure a valid user consent value
   // @ts-ignore, modify readonly prop
-  withDefaults.userConsent = consent ? consent(withDefaults) : undefined;
+  withDefaults.userConsent = consent(withDefaults);
 
   return withDefaults;
 }

package/src/utils/settingsValidation/types.ts

@@ -25,7 +25,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/types/dtos/types.d.ts

@@ -48,10 +48,6 @@ interface IInSegmentMatcher extends ISplitMatcherBase {
     matcherType: 'IN_SEGMENT';
     userDefinedSegmentMatcherData: IInSegmentMatcherData;
 }
-interface IInLargeSegmentMatcher extends ISplitMatcherBase {
-    matcherType: 'IN_LARGE_SEGMENT';
-    userDefinedSegmentMatcherData: IInSegmentMatcherData;
-}
 interface IWhitelistMatcher extends ISplitMatcherBase {
     matcherType: 'WHITELIST';
     whitelistMatcherData: IWhitelistMatcherData;
@@ -132,7 +128,7 @@ interface IInListSemverMatcher extends ISplitMatcherBase {
     matcherType: 'IN_LIST_SEMVER';
     whitelistMatcherData: IWhitelistMatcherData;
 }
-export declare type ISplitMatcher = IAllKeysMatcher | IInSegmentMatcher | IWhitelistMatcher | IEqualToMatcher | IGreaterThanOrEqualToMatcher | ILessThanOrEqualToMatcher | IBetweenMatcher | IEqualToSetMatcher | IContainsAnyOfSetMatcher | IContainsAllOfSetMatcher | IPartOfSetMatcher | IStartsWithMatcher | IEndsWithMatcher | IContainsStringMatcher | IInSplitTreatmentMatcher | IEqualToBooleanMatcher | IMatchesStringMatcher | IEqualToSemverMatcher | IGreaterThanOrEqualToSemverMatcher | ILessThanOrEqualToSemverMatcher | IBetweenSemverMatcher | IInListSemverMatcher | IInLargeSegmentMatcher;
+export declare type ISplitMatcher = IAllKeysMatcher | IInSegmentMatcher | IWhitelistMatcher | IEqualToMatcher | IGreaterThanOrEqualToMatcher | ILessThanOrEqualToMatcher | IBetweenMatcher | IEqualToSetMatcher | IContainsAnyOfSetMatcher | IContainsAllOfSetMatcher | IPartOfSetMatcher | IStartsWithMatcher | IEndsWithMatcher | IContainsStringMatcher | IInSplitTreatmentMatcher | IEqualToBooleanMatcher | IMatchesStringMatcher | IEqualToSemverMatcher | IGreaterThanOrEqualToSemverMatcher | ILessThanOrEqualToSemverMatcher | IBetweenSemverMatcher | IInListSemverMatcher;
 /** Split object */
 export interface ISplitPartition {
     treatment: string;
@@ -177,17 +173,13 @@ 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: {
-        id: string;
-        name: string;
-    }[];
-}
-/** Interface of the parsed JSON response of `/myLargeSegments/{userKey}` */
-export interface IMyLargeSegmentsResponse {
-    myLargeSegments: string[];
-    changeNumber: number;
+    mySegments: IMySegmentsResponseItem[];
 }
 /** 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;

package/types/readiness/readinessManager.d.ts

@@ -1,6 +1,6 @@
-import { IEventEmitter, ISettings } from '../types';
+import { IEventEmitter } from '../types';
 import { IReadinessManager, ISplitsEventEmitter } from './types';
 /**
  * Factory of readiness manager, which handles the ready / update event propagation.
  */
-export declare function readinessManagerFactory(EventEmitter: new () => IEventEmitter, settings: ISettings, splits?: ISplitsEventEmitter): IReadinessManager;
+export declare function readinessManagerFactory(EventEmitter: new () => IEventEmitter, readyTimeout?: number, splits?: ISplitsEventEmitter): IReadinessManager;

package/types/readiness/sdkReadinessManager.d.ts

@@ -1,5 +1,6 @@
 import { ISdkReadinessManager } from './types';
-import { IEventEmitter, ISettings } from '../types';
+import { IEventEmitter } from '../types';
+import { ILogger } from '../logger/types';
 /**
  * SdkReadinessManager factory, which provides the public status API of SDK clients and manager: ready promise, readiness event emitter and constants (SDK_READY, etc).
  * It also updates logs related warnings and errors.
@@ -7,4 +8,4 @@ import { IEventEmitter, ISettings } from '../types';
  * @param readyTimeout time in millis to emit SDK_READY_TIME_OUT event
  * @param readinessManager optional readinessManager to use. only used internally for `shared` method
  */
-export declare function sdkReadinessManagerFactory(EventEmitter: new () => IEventEmitter, settings: ISettings, readinessManager?: import("./types").IReadinessManager): ISdkReadinessManager;
+export declare function sdkReadinessManagerFactory(log: ILogger, EventEmitter: new () => IEventEmitter, readyTimeout?: number, readinessManager?: import("./types").IReadinessManager): ISdkReadinessManager;

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;
@@ -46,7 +45,7 @@ export interface IReadinessManager {
     setDestroyed(): void;
     destroy(): void;
     /** for client-side */
-    shared(): IReadinessManager;
+    shared(readyTimeout?: number): IReadinessManager;
 }
 /** SDK readiness manager */
 export interface ISdkReadinessManager {
@@ -58,6 +57,6 @@ export interface ISdkReadinessManager {
      */
     incInternalReadyCbCount(): void;
     /** for client-side */
-    shared(): ISdkReadinessManager;
+    shared(readyTimeout?: number): ISdkReadinessManager;
 }
 export {};

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: Pick<IPlatform, 'getOptions' | 'getFetch'>, telemetryTracker: ITelemetryTracker): ISplitApi;
+export declare function splitApiFactory(settings: ISettings, platform: IPlatform, 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 }: Pick<IPlatform, 'getOptions' | 'getFetch'>): ISplitHttpClient;
+export declare function splitHttpClientFactory(settings: ISettings, { getOptions, getFetch }: IPlatform): ISplitHttpClient;

package/types/services/types.d.ts

@@ -33,7 +33,6 @@ export interface ISplitApi {
     fetchSplitChanges: IFetchSplitChanges;
     fetchSegmentChanges: IFetchSegmentChanges;
     fetchMySegments: IFetchMySegments;
-    fetchMyLargeSegments: IFetchMySegments;
     postEventsBulk: IPostEventsBulk;
     postUniqueKeysBulkCs: IPostUniqueKeysBulkCs;
     postUniqueKeysBulkSs: IPostUniqueKeysBulkSs;

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

@@ -1,10 +1,5 @@
 import { KeyBuilder } from './KeyBuilder';
-export interface MySegmentsKeyBuilder {
-    buildSegmentNameKey(segmentName: string): string;
-    extractSegmentName(builtSegmentKeyName: string): string | undefined;
-    extractOldSegmentKey(builtSegmentKeyName: string): string | undefined;
-}
-export declare class KeyBuilderCS extends KeyBuilder implements MySegmentsKeyBuilder {
+export declare class KeyBuilderCS extends KeyBuilder {
     protected readonly regexSplitsCacheKey: RegExp;
     protected readonly matchingKey: string;
     constructor(prefix: string, matchingKey: string);
@@ -13,8 +8,8 @@ export declare class KeyBuilderCS extends KeyBuilder implements MySegmentsKeyBui
      */
     buildSegmentNameKey(segmentName: string): string;
     extractSegmentName(builtSegmentKeyName: string): string | undefined;
+    buildOldSegmentNameKey(segmentName: string): string;
     extractOldSegmentKey(builtSegmentKeyName: string): string | undefined;
     buildLastUpdatedKey(): string;
     isSplitsCacheKey(key: string): boolean;
 }
-export declare function myLargeSegmentsKeyBuilder(prefix: string, matchingKey: string): MySegmentsKeyBuilder;

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

@@ -1,10 +1,10 @@
 import { ILogger } from '../../logger/types';
 import { AbstractSegmentsCacheSync } from '../AbstractSegmentsCacheSync';
-import type { MySegmentsKeyBuilder } from '../KeyBuilderCS';
+import { KeyBuilderCS } from '../KeyBuilderCS';
 export declare class MySegmentsCacheInLocal extends AbstractSegmentsCacheSync {
     private readonly keys;
     private readonly log;
-    constructor(log: ILogger, keys: MySegmentsKeyBuilder);
+    constructor(log: ILogger, keys: KeyBuilderCS);
     /**
      * Removes list of segments from localStorage
      * @NOTE this method is not being used at the moment.

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

@@ -10,8 +10,7 @@ export declare class SplitsCacheInMemory extends AbstractSplitsCacheSync {
     private splitsCache;
     private ttCache;
     private changeNumber;
-    private segmentsCount;
-    private largeSegmentsCount;
+    private splitsWithSegmentsCount;
     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/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/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

@@ -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>;
@@ -388,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/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 { 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, NAME: string): IMySegmentsSyncTask;
+export declare function mySegmentsSyncTaskFactory(fetchMySegments: IFetchMySegments, storage: IStorageSync, readiness: IReadinessManager, settings: ISettings, matchingKey: string): IMySegmentsSyncTask;

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

@@ -12,26 +12,19 @@ export interface ISegmentsSyncTask extends ISyncTask<[fetchOnlyNew?: boolean, se
 export declare type MySegmentsData = string[] | {
     name: string;
     add: boolean;
-}[];
+};
 export interface IMySegmentsSyncTask extends ISyncTask<[segmentsData?: MySegmentsData, noCache?: boolean], boolean> {
 }
 export interface IPollingManager extends ITask {
     syncAll(): Promise<any>;
     splitsSyncTask: ISplitsSyncTask;
     segmentsSyncTask: ISyncTask;
-    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,13 +1,13 @@
 import { IMySegmentsFetcher } from '../fetchers/types';
-import { ISegmentsCacheSync } 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 = (segmentList?: MySegmentsData, noCache?: boolean) => 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, mySegmentsCache: ISegmentsCacheSync, notifyUpdate: () => void, 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/SSEClient/index.d.ts

@@ -7,23 +7,20 @@ import { ISSEClient, ISseEventHandler } from './types';
  * Handles streaming connections with EventSource API
  */
 export declare class SSEClient implements ISSEClient {
+    private settings;
     eventSource?: IEventSourceConstructor;
-    streamingUrl: string;
     connection?: InstanceType<IEventSourceConstructor>;
     handler?: ISseEventHandler;
-    useHeaders?: boolean;
     headers: Record<string, string>;
     options?: object;
-    lse?: boolean;
     /**
      * SSEClient constructor.
      *
      * @param settings Validated settings.
-     * @param useHeaders True to send metadata as headers or false to send as query params. If `true`, the provided EventSource must support headers.
      * @param platform object containing environment-specific dependencies
      * @throws 'EventSource API is not available.' if EventSource is not available.
      */
-    constructor(settings: ISettings, useHeaders: boolean, { getEventSource, getOptions }: IPlatform);
+    constructor(settings: ISettings, { getEventSource, getOptions }: IPlatform);
     setEventHandler(handler: ISseEventHandler): void;
     /**
      * Open the connection with a given authToken

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

@@ -1,5 +1,5 @@
 import { ControlType } from '../constants';
-import { MY_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V2, SEGMENT_UPDATE, SPLIT_UPDATE, SPLIT_KILL, CONTROL, OCCUPANCY, MY_LARGE_SEGMENTS_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;
@@ -29,17 +29,6 @@ export interface IMySegmentsUpdateV2Data {
     d: string;
     u: UpdateStrategy;
 }
-export interface IMyLargeSegmentsUpdateData {
-    type: MY_LARGE_SEGMENTS_UPDATE;
-    changeNumber: number;
-    largeSegments: string[];
-    c: Compression;
-    d: string;
-    u: UpdateStrategy;
-    i?: number;
-    h?: number;
-    s?: number;
-}
 export interface ISegmentUpdateData {
     type: SEGMENT_UPDATE;
     changeNumber: number;
@@ -68,7 +57,7 @@ export interface IOccupancyData {
         publishers: number;
     };
 }
-export declare type INotificationData = IMySegmentsUpdateData | IMySegmentsUpdateV2Data | IMyLargeSegmentsUpdateData | ISegmentUpdateData | ISplitUpdateData | ISplitKillData | IControlData | IOccupancyData;
+export declare type INotificationData = IMySegmentsUpdateData | IMySegmentsUpdateV2Data | ISegmentUpdateData | ISplitUpdateData | ISplitKillData | IControlData | IOccupancyData;
 export declare type INotificationMessage = {
     parsedData: INotificationData;
     channel: string;

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

@@ -1,8 +1,7 @@
-import { IMySegmentsSyncTask, MySegmentsData } from '../../polling/types';
+import { IMySegmentsSyncTask } from '../../polling/types';
 import { IUpdateWorker } from './types';
 import { ITelemetryTracker } from '../../../trackers/types';
-import { UpdatesFromSSEEnum } from '../../submitters/types';
 /**
  * MySegmentsUpdateWorker factory
  */
-export declare function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask, telemetryTracker: ITelemetryTracker, updateType: UpdatesFromSSEEnum): IUpdateWorker<[changeNumber: number, segmentsData?: MySegmentsData, 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;
 }