@splitsoftware/splitio-commons 1.6.2-rc.0 → 1.6.2-rc.3

package/src/sdkFactory/types.ts

@@ -1,13 +1,13 @@
 import { IIntegrationManager, IIntegrationFactoryParams } from '../integrations/types';
 import { ISignalListener } from '../listeners/types';
-import { ILogger } from '../logger/types';
+import { IAsyncClientSS, IAsyncManager, IClientSS, IClientWithKey, ILogger, IManager, SplitKey } from '../types';
 import { IReadinessManager, ISdkReadinessManager } from '../readiness/types';
 import { IFetch, ISplitApi, IEventSourceConstructor } from '../services/types';
 import { IStorageAsync, IStorageSync, ISplitsCacheSync, ISplitsCacheAsync, IStorageFactoryParams } from '../storages/types';
 import { ISyncManager } from '../sync/types';
 import { IImpressionObserver } from '../trackers/impressionObserver/types';
 import { IImpressionsTracker, IEventTracker, ITelemetryTracker } from '../trackers/types';
-import { SplitIO, ISettings, IEventEmitter } from '../types';
+import { ISettings, IEventEmitter } from '../types';
 
 /**
  * Environment related dependencies.
@@ -90,11 +90,11 @@ export interface ISdkFactoryParams {
     log: ILogger,
     splits: ISplitsCacheSync | ISplitsCacheAsync,
     sdkReadinessManager: ISdkReadinessManager
-  ) => SplitIO.IManager | SplitIO.IAsyncManager,
+  ) => IManager | IAsyncManager,
 
   // Sdk client method factory (ISDK::client method).
   // It Allows to distinguish SDK clients with the client-side API (`ICsSDK`) or server-side API (`ISDK` or `IAsyncSDK`).
-  sdkClientMethodFactory: (params: ISdkFactoryContext) => ({ (): SplitIO.ICsClient; (key: SplitIO.SplitKey, trafficType?: string | undefined): SplitIO.ICsClient; } | (() => SplitIO.IClient) | (() => SplitIO.IAsyncClient))
+  sdkClientMethodFactory: (params: ISdkFactoryContext) => ({ (): IClientWithKey; (key: SplitKey, trafficType?: string | undefined): IClientWithKey; } | (() => IClientSS) | (() => IAsyncClientSS))
 
   // Optional signal listener constructor. Used to handle special app states, like shutdown, app paused or resumed.
   // Pass only if `syncManager` (used by Node listener) and `splitApi` (used by Browser listener) are passed.

package/src/sdkManager/index.ts

@@ -5,8 +5,8 @@ import { validateSplit, validateSplitExistance, validateIfNotDestroyed, validate
 import { ISplitsCacheAsync, ISplitsCacheSync } from '../storages/types';
 import { ISdkReadinessManager } from '../readiness/types';
 import { ISplit } from '../dtos/types';
-import { SplitIO } from '../types';
-import { ILogger } from '../logger/types';
+import { IAsyncManager, IManager, SplitView } from '../types';
+import { ILogger } from '../types';
 
 function collectTreatments(splitObject: ISplit) {
   const conditions = splitObject.conditions;
@@ -18,7 +18,7 @@ function collectTreatments(splitObject: ISplit) {
   return allTreatmentsCondition ? allTreatmentsCondition.partitions.map(v => v.treatment) : [];
 }
 
-function objectToView(json: string | null): SplitIO.SplitView | null {
+function objectToView(json: string | null): SplitView | null {
   let splitObject: ISplit | null;
 
   try {
@@ -41,7 +41,7 @@ function objectToView(json: string | null): SplitIO.SplitView | null {
 }
 
 function objectsToViews(jsons: string[]) {
-  let views: SplitIO.SplitView[] = [];
+  let views: SplitView[] = [];
 
   jsons.forEach(split => {
     const view = objectToView(split);
@@ -55,7 +55,7 @@ export function sdkManagerFactory<TSplitCache extends ISplitsCacheSync | ISplits
   log: ILogger,
   splits: TSplitCache,
   { readinessManager, sdkStatus }: ISdkReadinessManager
-): TSplitCache extends ISplitsCacheAsync ? SplitIO.IAsyncManager : SplitIO.IManager {
+): TSplitCache extends ISplitsCacheAsync ? IAsyncManager : IManager {
   const SPLIT_FN_LABEL = 'split';
 
   return objectAssign(

package/src/services/splitApi.ts

@@ -25,6 +25,7 @@ export function splitApiFactory(
 ): ISplitApi {
 
   const urls = settings.urls;
+  // @ts-ignore
   const filterQueryString = settings.sync.__splitFiltersValidation && settings.sync.__splitFiltersValidation.queryString;
   const SplitSDKImpressionsMode = settings.sync.impressionsMode;
   const splitHttpClient = splitHttpClientFactory(settings, platform.getFetch, platform.getOptions);

package/src/storages/dataLoader.ts

@@ -1,4 +1,4 @@
-import { SplitIO } from '../types';
+import { PreloadedData } from './types';
 import { DEFAULT_CACHE_EXPIRATION_IN_MILLIS } from '../utils/constants/browser';
 import { DataLoader, ISegmentsCacheSync, ISplitsCacheSync } from './types';
 
@@ -9,7 +9,7 @@ import { DataLoader, ISegmentsCacheSync, ISplitsCacheSync } from './types';
  * and extended with a `mySegmentsData` property.
  * @returns function to preload the storage
  */
-export function dataLoaderFactory(preloadedData: SplitIO.PreloadedData): DataLoader {
+export function dataLoaderFactory(preloadedData: PreloadedData): DataLoader {
 
   /**
    * Storage-agnostic adaptation of `loadDataIntoLocalStorage` function

package/src/storages/inLocalStorage/MySegmentsCacheInLocal.ts

@@ -1,4 +1,4 @@
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 import { AbstractSegmentsCacheSync } from '../AbstractSegmentsCacheSync';
 import { KeyBuilderCS } from '../KeyBuilderCS';
 import { LOG_PREFIX, DEFINED } from './constants';

package/src/storages/inLocalStorage/SplitsCacheInLocal.ts

@@ -1,8 +1,8 @@
-import { ISplit, ISplitFiltersValidation } from '../../dtos/types';
+import { ISplit } from '../../dtos/types';
 import { AbstractSplitsCacheSync, usesSegments } from '../AbstractSplitsCacheSync';
 import { isFiniteNumber, toNumber, isNaNNumber } from '../../utils/lang';
 import { KeyBuilderCS } from '../KeyBuilderCS';
-import { ILogger } from '../../logger/types';
+import { ILogger, ISplitFiltersValidation } from '../../types';
 import { LOG_PREFIX } from './constants';
 
 /**

package/src/storages/inLocalStorage/index.ts

@@ -1,7 +1,8 @@
 import { ImpressionsCacheInMemory } from '../inMemory/ImpressionsCacheInMemory';
 import { ImpressionCountsCacheInMemory } from '../inMemory/ImpressionCountsCacheInMemory';
 import { EventsCacheInMemory } from '../inMemory/EventsCacheInMemory';
-import { IStorageFactoryParams, IStorageSync, IStorageSyncFactory } from '../types';
+import { IStorageFactoryParams, IStorageSync } from '../types';
+import { StorageSyncFactory } from '../../types';
 import { validatePrefix } from '../KeyBuilder';
 import { KeyBuilderCS } from '../KeyBuilderCS';
 import { isLocalStorageAvailable } from '../../utils/env/isLocalStorageAvailable';
@@ -22,7 +23,7 @@ export interface InLocalStorageOptions {
 /**
  * InLocal storage factory for standalone client-side SplitFactory
  */
-export function InLocalStorage(options: InLocalStorageOptions = {}): IStorageSyncFactory {
+export function InLocalStorage(options: InLocalStorageOptions = {}): StorageSyncFactory {
 
   const prefix = validatePrefix(options.prefix);
 

package/src/storages/inMemory/EventsCacheInMemory.ts

@@ -1,4 +1,4 @@
-import { SplitIO } from '../../types';
+import { EventData } from '../../types';
 import { IEventsCacheSync } from '../types';
 
 const MAX_QUEUE_BYTE_SIZE = 5 * 1024 * 1024; // 5M
@@ -7,7 +7,7 @@ export class EventsCacheInMemory implements IEventsCacheSync {
 
   private onFullQueue?: () => void;
   private readonly maxQueue: number;
-  private queue: SplitIO.EventData[];
+  private queue: EventData[];
   private queueByteSize: number;
 
   /**
@@ -28,7 +28,7 @@ export class EventsCacheInMemory implements IEventsCacheSync {
   /**
    * Add a new event object at the end of the queue.
    */
-  track(data: SplitIO.EventData, size = 0) {
+  track(data: EventData, size = 0) {
     this.queueByteSize += size;
     this.queue.push(data);
 
@@ -48,7 +48,7 @@ export class EventsCacheInMemory implements IEventsCacheSync {
   /**
    * Pop the collected data, used as payload for posting.
    */
-  pop(toMerge?: SplitIO.EventData[]) {
+  pop(toMerge?: EventData[]) {
     const data = this.queue;
     this.clear();
     return toMerge ? toMerge.concat(data) : data;

package/src/storages/inRedis/EventsCacheInRedis.ts

@@ -1,8 +1,8 @@
 import { IEventsCacheAsync } from '../types';
 import { IMetadata } from '../../dtos/types';
 import { Redis } from 'ioredis';
-import { SplitIO } from '../../types';
-import { ILogger } from '../../logger/types';
+import { EventData } from '../../types';
+import { ILogger } from '../../types';
 import { LOG_PREFIX } from './constants';
 import { StoredEventWithMetadata } from '../../sync/submitters/types';
 
@@ -24,7 +24,7 @@ export class EventsCacheInRedis implements IEventsCacheAsync {
    * Add a new event object into the queue.
    * Unlike `impressions::track`, result promise is never rejected.
    */
-  track(eventData: SplitIO.EventData): Promise<boolean> {
+  track(eventData: EventData): Promise<boolean> {
     return this.redis.rpush(
       this.key,
       this._toJSON(eventData)
@@ -40,7 +40,7 @@ export class EventsCacheInRedis implements IEventsCacheAsync {
   /**
    * Generates the JSON as we'll store it on Redis.
    */
-  private _toJSON(eventData: SplitIO.EventData): string {
+  private _toJSON(eventData: EventData): string {
     return JSON.stringify({
       m: this.metadata,
       e: eventData

package/src/storages/inRedis/ImpressionsCacheInRedis.ts

@@ -3,7 +3,7 @@ import { IMetadata } from '../../dtos/types';
 import { ImpressionDTO } from '../../types';
 import { Redis } from 'ioredis';
 import { StoredImpressionWithMetadata } from '../../sync/submitters/types';
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 
 const IMPRESSIONS_TTL_REFRESH = 3600; // 1 hr
 

package/src/storages/inRedis/RedisAdapter.ts

@@ -1,5 +1,5 @@
 import ioredis from 'ioredis';
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 import { merge, isString } from '../../utils/lang';
 import { _Set, setToArray, ISet } from '../../utils/lang/sets';
 import { thenable } from '../../utils/promise/thenable';

package/src/storages/inRedis/SegmentsCacheInRedis.ts

@@ -1,5 +1,5 @@
 import { Redis } from 'ioredis';
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 import { isNaNNumber } from '../../utils/lang';
 import { LOG_PREFIX } from '../inLocalStorage/constants';
 import { KeyBuilderSS } from '../KeyBuilderSS';

package/src/storages/inRedis/SplitsCacheInRedis.ts

@@ -1,7 +1,7 @@
 import { isFiniteNumber, isNaNNumber } from '../../utils/lang';
 import { KeyBuilderSS } from '../KeyBuilderSS';
 import { Redis } from 'ioredis';
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 import { LOG_PREFIX } from './constants';
 import { ISplit } from '../../dtos/types';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';

package/src/storages/inRedis/TelemetryCacheInRedis.ts

@@ -1,4 +1,4 @@
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 import { Method } from '../../sync/submitters/types';
 import { KeyBuilderSS } from '../KeyBuilderSS';
 import { ITelemetryCacheAsync } from '../types';

package/src/storages/inRedis/index.ts

@@ -1,5 +1,6 @@
 import { RedisAdapter } from './RedisAdapter';
-import { IStorageAsync, IStorageAsyncFactory, IStorageFactoryParams } from '../types';
+import { IStorageAsync, IStorageFactoryParams } from '../types';
+import { StorageAsyncFactory } from '../../types';
 import { validatePrefix } from '../KeyBuilder';
 import { KeyBuilderSS } from '../KeyBuilderSS';
 import { SplitsCacheInRedis } from './SplitsCacheInRedis';
@@ -18,7 +19,7 @@ export interface InRedisStorageOptions {
  * InRedis storage factory for consumer server-side SplitFactory, that uses `Ioredis` Redis client for Node.
  * @see {@link https://www.npmjs.com/package/ioredis}
  */
-export function InRedisStorage(options: InRedisStorageOptions = {}): IStorageAsyncFactory {
+export function InRedisStorage(options: InRedisStorageOptions = {}): StorageAsyncFactory {
 
   const prefix = validatePrefix(options.prefix);
 

package/src/storages/pluggable/EventsCachePluggable.ts

@@ -1,7 +1,7 @@
 import { IPluggableStorageWrapper, IEventsCacheAsync } from '../types';
 import { IMetadata } from '../../dtos/types';
-import { SplitIO } from '../../types';
-import { ILogger } from '../../logger/types';
+import { EventData } from '../../types';
+import { ILogger } from '../../types';
 import { LOG_PREFIX } from './constants';
 import { StoredEventWithMetadata } from '../../sync/submitters/types';
 
@@ -25,7 +25,7 @@ export class EventsCachePluggable implements IEventsCacheAsync {
    * @returns  A promise that is resolved with a boolean value indicating if the push operation succeeded or failed.
    * Unlike `impressions::track`, The promise will never be rejected.
    */
-  track(eventData: SplitIO.EventData): Promise<boolean> {
+  track(eventData: EventData): Promise<boolean> {
     return this.wrapper.pushItems(
       this.key,
       [this._toJSON(eventData)]
@@ -38,7 +38,7 @@ export class EventsCachePluggable implements IEventsCacheAsync {
       });
   }
 
-  private _toJSON(eventData: SplitIO.EventData): string {
+  private _toJSON(eventData: EventData): string {
     return JSON.stringify({
       m: this.metadata,
       e: eventData

package/src/storages/pluggable/ImpressionsCachePluggable.ts

@@ -1,7 +1,7 @@
 import { IPluggableStorageWrapper, IImpressionsCacheAsync } from '../types';
 import { IMetadata } from '../../dtos/types';
 import { ImpressionDTO } from '../../types';
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 import { StoredImpressionWithMetadata } from '../../sync/submitters/types';
 
 export class ImpressionsCachePluggable implements IImpressionsCacheAsync {

package/src/storages/pluggable/SegmentsCachePluggable.ts

@@ -3,7 +3,7 @@
 import { isNaNNumber } from '../../utils/lang';
 import { KeyBuilderSS } from '../KeyBuilderSS';
 import { IPluggableStorageWrapper, ISegmentsCacheAsync } from '../types';
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 import { LOG_PREFIX } from './constants';
 import { _Set } from '../../utils/lang/sets';
 

package/src/storages/pluggable/SplitsCachePluggable.ts

@@ -1,7 +1,7 @@
 import { isFiniteNumber, isNaNNumber } from '../../utils/lang';
 import { KeyBuilder } from '../KeyBuilder';
 import { IPluggableStorageWrapper } from '../types';
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 import { ISplit } from '../../dtos/types';
 import { LOG_PREFIX } from './constants';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';

package/src/storages/pluggable/TelemetryCachePluggable.ts

@@ -1,4 +1,4 @@
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 import { Method } from '../../sync/submitters/types';
 import { KeyBuilderSS } from '../KeyBuilderSS';
 import { IPluggableStorageWrapper, ITelemetryCacheAsync } from '../types';

package/src/storages/pluggable/index.ts

@@ -1,5 +1,5 @@
-import { IPluggableStorageWrapper, IStorageAsync, IStorageAsyncFactory, IStorageFactoryParams } from '../types';
-
+import { IPluggableStorageWrapper, IStorageAsync, IStorageFactoryParams } from '../types';
+import { StorageAsyncFactory } from '../../types';
 import { KeyBuilderSS } from '../KeyBuilderSS';
 import { SplitsCachePluggable } from './SplitsCachePluggable';
 import { SegmentsCachePluggable } from './SegmentsCachePluggable';
@@ -58,7 +58,7 @@ function promisifyEventsTrack(events: any) {
 /**
  * Pluggable storage factory for consumer server-side & client-side SplitFactory.
  */
-export function PluggableStorage(options: PluggableStorageOptions): IStorageAsyncFactory {
+export function PluggableStorage(options: PluggableStorageOptions): StorageAsyncFactory {
 
   validatePluggableStorageOptions(options);
 

package/src/storages/pluggable/wrapperAdapter.ts

@@ -1,4 +1,4 @@
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 import { IPluggableStorageWrapper } from '../types';
 import { LOG_PREFIX } from './constants';
 

package/src/storages/types.ts

@@ -1,7 +1,6 @@
-import { MaybeThenable, IMetadata, ISplitFiltersValidation } from '../dtos/types';
-import { ILogger } from '../logger/types';
+import { MaybeThenable, IMetadata } from '../dtos/types';
 import { EventDataType, HttpErrors, HttpLatencies, ImpressionDataType, LastSync, Method, MethodExceptions, MethodLatencies, OperationType, StoredEventWithMetadata, StoredImpressionWithMetadata, StreamingEvent } from '../sync/submitters/types';
-import { SplitIO, ImpressionDTO, SDKMode } from '../types';
+import { ImpressionDTO, SDKMode, ILogger, EventData, ISplitFiltersValidation } from '../types';
 
 /**
  * Interface of a pluggable storage wrapper.
@@ -289,7 +288,7 @@ export interface IImpressionsCacheBase {
 
 export interface IEventsCacheBase {
   // Consumer API method, used by events tracker, in standalone and consumer modes, to push events into the storage.
-  track(data: SplitIO.EventData, size?: number): MaybeThenable<boolean>
+  track(data: EventData, size?: number): MaybeThenable<boolean>
 }
 
 /** Impressions and events cache for standalone mode (sync) */
@@ -312,8 +311,8 @@ export interface IImpressionsCacheSync extends IImpressionsCacheBase, IRecorderC
   setOnFullQueueCb(cb: () => void): void
 }
 
-export interface IEventsCacheSync extends IEventsCacheBase, IRecorderCacheProducerSync<SplitIO.EventData[]> {
-  track(data: SplitIO.EventData, size?: number): boolean
+export interface IEventsCacheSync extends IEventsCacheBase, IRecorderCacheProducerSync<EventData[]> {
+  track(data: EventData, size?: number): boolean
   /* Registers callback for full queue */
   setOnFullQueueCb(cb: () => void): void
 }
@@ -339,7 +338,7 @@ export interface IImpressionsCacheAsync extends IImpressionsCacheBase, IRecorder
 export interface IEventsCacheAsync extends IEventsCacheBase, IRecorderCacheProducerAsync<StoredEventWithMetadata[]> {
   // Consumer API method, used by events tracker (in standalone and consumer modes) to push data into.
   // The result promise cannot reject.
-  track(data: SplitIO.EventData, size?: number): Promise<boolean>
+  track(data: EventData, size?: number): Promise<boolean>
 }
 
 /**
@@ -352,7 +351,7 @@ export interface IImpressionCountsCacheSync extends IRecorderCacheProducerSync<R
 
   // Used by impressions count submitter in standalone and producer mode
   isEmpty(): boolean // check if cache is empty. Return true if the cache was just created or cleared.
-  pop(toMerge?: Record<string, number> ): Record<string, number> // pop cache data
+  pop(toMerge?: Record<string, number>): Record<string, number> // pop cache data
 }
 
 
@@ -495,14 +494,39 @@ export interface IStorageFactoryParams {
   metadata: IMetadata,
 }
 
-export type StorageType = 'MEMORY' | 'LOCALSTORAGE' | 'REDIS' | 'PLUGGABLE';
-
-export type IStorageSyncFactory = {
-  readonly type: StorageType,
-  (params: IStorageFactoryParams): IStorageSync
-}
-
-export type IStorageAsyncFactory = {
-  type: StorageType,
-  (params: IStorageFactoryParams): IStorageAsync
+/**
+ * Defines the format of Split data to preload on the factory storage (cache).
+ */
+export interface PreloadedData {
+  /**
+   * Timestamp of the last moment the data was synchronized with Split servers.
+   * If this value is older than 10 days ago (expiration time policy), the data is not used to update the storage content.
+   * @TODO configurable expiration time policy?
+   */
+  lastUpdated: number,
+  /**
+   * Change number of the preloaded data.
+   * If this value is older than the current changeNumber at the storage, the data is not used to update the storage content.
+   */
+  since: number,
+  /**
+   * Map of splits to their serialized definitions.
+   */
+  splitsData: {
+    [splitName: string]: string
+  },
+  /**
+   * Optional map of user keys to their list of segments.
+   * @TODO remove when releasing first version
+   */
+  mySegmentsData?: {
+    [key: string]: string[]
+  },
+  /**
+   * Optional map of segments to their serialized definitions.
+   * This property is ignored if `mySegmentsData` was provided.
+   */
+  segmentsData?: {
+    [segmentName: string]: string
+  },
 }

package/src/sync/offline/LocalhostFromObject.ts

@@ -1,12 +1,12 @@
 import { splitsParserFromSettingsFactory } from './splitsParser/splitsParserFromSettings';
 import { syncManagerOfflineFactory } from './syncManagerOffline';
-import { SplitIO } from '../../types';
+import { LocalhostFactory } from '../../types';
 
 // Singleton instance of the factory function for offline SyncManager from object (a.k.a. localhostFromObject)
 // SDK instances instantiate their SyncManagers with the same factory
-const localhostFromObject = syncManagerOfflineFactory(splitsParserFromSettingsFactory) as SplitIO.LocalhostFactory;
+const localhostFromObject: any = syncManagerOfflineFactory(splitsParserFromSettingsFactory);
 localhostFromObject.type = 'LocalhostFromObject';
 
-export function LocalhostFromObject(): SplitIO.LocalhostFactory {
-  return localhostFromObject;
+export function LocalhostFromObject() {
+  return localhostFromObject as LocalhostFactory;
 }

package/src/sync/offline/splitsParser/splitsParserFromSettings.ts

@@ -1,23 +1,23 @@
 import { ISplitPartial } from '../../../dtos/types';
-import { ISettings, SplitIO } from '../../../types';
+import { ISettings, MockedFeaturesMap, TreatmentWithConfig } from '../../../types';
 import { isObject, forOwn } from '../../../utils/lang';
 import { parseCondition } from './parseCondition';
 
-function hasTreatmentChanged(prev: string | SplitIO.TreatmentWithConfig, curr: string | SplitIO.TreatmentWithConfig) {
+function hasTreatmentChanged(prev: string | TreatmentWithConfig, curr: string | TreatmentWithConfig) {
   if (typeof prev !== typeof curr) return true;
 
   if (typeof prev === 'string') { // strings treatments, just compare
     return prev !== curr;
   } else { // has treatment and config, compare both
-    return prev.treatment !== (curr as SplitIO.TreatmentWithConfig).treatment || prev.config !== (curr as SplitIO.TreatmentWithConfig).config;
+    return prev.treatment !== (curr as TreatmentWithConfig).treatment || prev.config !== (curr as TreatmentWithConfig).config;
   }
 }
 
 export function splitsParserFromSettingsFactory() {
 
-  let previousMock: SplitIO.MockedFeaturesMap = { 'emptyMock': '1' };
+  let previousMock: MockedFeaturesMap = { 'emptyMock': '1' };
 
-  function mockUpdated(currentData: SplitIO.MockedFeaturesMap) {
+  function mockUpdated(currentData: MockedFeaturesMap) {
     const names = Object.keys(currentData);
 
     // Different amount of items
@@ -42,7 +42,7 @@ export function splitsParserFromSettingsFactory() {
    * @param settings validated object with mocked features mapping.
    */
   return function splitsParserFromSettings(settings: ISettings): false | Record<string, ISplitPartial> {
-    const features = settings.features as SplitIO.MockedFeaturesMap || {};
+    const features = settings.features as MockedFeaturesMap || {};
 
     if (!mockUpdated(features)) return false;
 
@@ -53,8 +53,8 @@ export function splitsParserFromSettingsFactory() {
       let config = null;
 
       if (isObject(data)) {
-        treatment = (data as SplitIO.TreatmentWithConfig).treatment;
-        config = (data as SplitIO.TreatmentWithConfig).config || config;
+        treatment = (data as TreatmentWithConfig).treatment;
+        config = (data as TreatmentWithConfig).config || config;
       }
       const configurations: Record<string, string> = {};
       if (config !== null) configurations[treatment as string] = config;

package/src/sync/polling/updaters/mySegmentsUpdater.ts

@@ -3,7 +3,7 @@ import { ISegmentsCacheSync, ISplitsCacheSync } from '../../../storages/types';
 import { ISegmentsEventEmitter } from '../../../readiness/types';
 import { timeout } from '../../../utils/promise/timeout';
 import { SDK_SEGMENTS_ARRIVED } from '../../../readiness/constants';
-import { ILogger } from '../../../logger/types';
+import { ILogger } from '../../../types';
 import { SYNC_MYSEGMENTS_FETCH_RETRY } from '../../../logger/constants';
 import { MySegmentsData } from '../types';
 

package/src/sync/polling/updaters/segmentChangesUpdater.ts

@@ -4,7 +4,7 @@ import { IReadinessManager } from '../../../readiness/types';
 import { MaybeThenable } from '../../../dtos/types';
 import { findIndex } from '../../../utils/lang';
 import { SDK_SEGMENTS_ARRIVED } from '../../../readiness/constants';
-import { ILogger } from '../../../logger/types';
+import { ILogger } from '../../../types';
 import { LOG_PREFIX_INSTANTIATION, LOG_PREFIX_SYNC_SEGMENTS } from '../../../logger/constants';
 import { thenable } from '../../../utils/promise/thenable';
 

package/src/sync/polling/updaters/splitChangesUpdater.ts

@@ -5,7 +5,7 @@ import { ISplit, ISplitChangesResponse } from '../../../dtos/types';
 import { ISplitsEventEmitter } from '../../../readiness/types';
 import { timeout } from '../../../utils/promise/timeout';
 import { SDK_SPLITS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../../../readiness/constants';
-import { ILogger } from '../../../logger/types';
+import { ILogger } from '../../../types';
 import { SYNC_SPLITS_FETCH, SYNC_SPLITS_NEW, SYNC_SPLITS_REMOVED, SYNC_SPLITS_SEGMENTS, SYNC_SPLITS_FETCH_FAILS, SYNC_SPLITS_FETCH_RETRY } from '../../../logger/constants';
 
 type ISplitChangesUpdater = (noCache?: boolean, till?: number) => Promise<boolean>

package/src/sync/streaming/SSEHandler/index.ts

@@ -4,7 +4,7 @@ import { PUSH_RETRYABLE_ERROR, PUSH_NONRETRYABLE_ERROR, OCCUPANCY, CONTROL, MY_S
 import { IPushEventEmitter } from '../types';
 import { ISseEventHandler } from '../SSEClient/types';
 import { INotificationError, INotificationMessage } from './types';
-import { ILogger } from '../../../logger/types';
+import { ILogger } from '../../../types';
 import { STREAMING_PARSING_ERROR_FAILS, ERROR_STREAMING_SSE, STREAMING_PARSING_MESSAGE_FAILS, STREAMING_NEW_MESSAGE } from '../../../logger/constants';
 import { ABLY_ERROR, NON_REQUESTED, SSE_CONNECTION_ERROR } from '../../../utils/constants';
 import { ITelemetryTracker } from '../../../trackers/types';

package/src/sync/streaming/UpdateWorkers/SegmentsUpdateWorker.ts

@@ -1,4 +1,4 @@
-import { ILogger } from '../../../logger/types';
+import { ILogger } from '../../../types';
 import { ISegmentsCacheSync } from '../../../storages/types';
 import { Backoff } from '../../../utils/Backoff';
 import { ISegmentsSyncTask } from '../../polling/types';

package/src/sync/streaming/UpdateWorkers/SplitsUpdateWorker.ts

@@ -1,4 +1,4 @@
-import { ILogger } from '../../../logger/types';
+import { ILogger } from '../../../types';
 import { SDK_SPLITS_ARRIVED } from '../../../readiness/constants';
 import { ISplitsEventEmitter } from '../../../readiness/types';
 import { ISplitsCacheSync } from '../../../storages/types';

package/src/sync/submitters/submitter.ts

@@ -1,7 +1,7 @@
 import { syncTaskFactory } from '../syncTask';
 import { ISyncTask } from '../types';
 import { IRecorderCacheProducerSync } from '../../storages/types';
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 import { SUBMITTERS_PUSH, SUBMITTERS_PUSH_FAILS, SUBMITTERS_PUSH_RETRY } from '../../logger/constants';
 import { IResponse } from '../../services/types';
 

package/src/sync/submitters/types.ts

@@ -1,5 +1,5 @@
 import { IMetadata } from '../../dtos/types';
-import { SplitIO } from '../../types';
+import { EventData } from '../../types';
 import { ISyncTask } from '../types';
 
 export type ImpressionsPayload = {
@@ -61,7 +61,7 @@ export type StoredEventWithMetadata = {
   /** Metadata */
   m: IMetadata,
   /** Stored event */
-  e: SplitIO.EventData
+  e: EventData
 }
 
 /**

package/src/sync/syncTask.ts

@@ -1,5 +1,5 @@
 import { SYNC_TASK_EXECUTE, SYNC_TASK_START, SYNC_TASK_STOP } from '../logger/constants';
-import { ILogger } from '../logger/types';
+import { ILogger } from '../types';
 import { ISyncTask } from './types';
 
 /**

package/src/trackers/eventTracker.ts

@@ -2,7 +2,7 @@ import { objectAssign } from '../utils/lang/objectAssign';
 import { thenable } from '../utils/promise/thenable';
 import { IEventsCacheBase, ITelemetryCacheAsync, ITelemetryCacheSync } from '../storages/types';
 import { IEventsHandler, IEventTracker } from './types';
-import { ISettings, SplitIO } from '../types';
+import { ISettings, EventData } from '../types';
 import { EVENTS_TRACKER_SUCCESS, ERROR_EVENTS_TRACKER } from '../logger/constants';
 import { CONSENT_DECLINED, DROPPED, QUEUED } from '../utils/constants';
 import { isStorageSync } from './impressionObserver/utils';
@@ -23,7 +23,7 @@ export function eventTrackerFactory(
   const log = settings.log;
   const isSync = isStorageSync(settings);
 
-  function queueEventsCallback(eventData: SplitIO.EventData, tracked: boolean) {
+  function queueEventsCallback(eventData: EventData, tracked: boolean) {
     const { eventTypeId, trafficTypeName, key, value, timestamp, properties } = eventData;
     // Logging every prop would be too much.
     const msg = `event of type "${eventTypeId}" for traffic type "${trafficTypeName}". Key: ${key}. Value: ${value}. Timestamp: ${timestamp}. ${properties ? 'With properties.' : 'With no properties.'}`;
@@ -48,7 +48,7 @@ export function eventTrackerFactory(
   }
 
   return {
-    track(eventData: SplitIO.EventData, size?: number) {
+    track(eventData: EventData, size?: number) {
       if (settings.userConsent === CONSENT_DECLINED) {
         return isSync ? false : Promise.resolve(false);
       }