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

package/types/evaluator/types.d.ts

@@ -1,11 +1,11 @@
 import { IBetweenMatcherData, IDependencyMatcherData, MaybeThenable } from '../dtos/types';
 import { IStorageAsync, IStorageSync } from '../storages/types';
 import { ISet } from '../utils/lang/sets';
-import { SplitKey, Attributes } from '../types';
-import { ILogger } from '../types';
+import { SplitIO } from '../types';
+import { ILogger } from '../logger/types';
 export interface IDependencyMatcherValue {
-    key: SplitKey;
-    attributes?: Attributes;
+    key: SplitIO.SplitKey;
+    attributes?: SplitIO.Attributes;
 }
 export interface IMatcherDto {
     type: number;
@@ -23,6 +23,6 @@ export interface IEvaluation {
 export declare type IEvaluationResult = IEvaluation & {
     treatment: string;
 };
-export declare type ISplitEvaluator = (log: ILogger, key: SplitKey, splitName: string, attributes: Attributes | undefined, storage: IStorageSync | IStorageAsync) => MaybeThenable<IEvaluation>;
-export declare type IEvaluator = (key: SplitKey, seed: number, trafficAllocation?: number, trafficAllocationSeed?: number, attributes?: Attributes, splitEvaluator?: ISplitEvaluator) => MaybeThenable<IEvaluation | undefined>;
+export declare type ISplitEvaluator = (log: ILogger, key: SplitIO.SplitKey, splitName: string, attributes: SplitIO.Attributes | undefined, storage: IStorageSync | IStorageAsync) => MaybeThenable<IEvaluation>;
+export declare type IEvaluator = (key: SplitIO.SplitKey, seed: number, trafficAllocation?: number, trafficAllocationSeed?: number, attributes?: SplitIO.Attributes, splitEvaluator?: ISplitEvaluator) => MaybeThenable<IEvaluation | undefined>;
 export declare type IMatcher = (...args: any) => MaybeThenable<boolean>;

package/types/evaluator/value/index.d.ts

@@ -1,7 +1,7 @@
-import { Attributes } from '../../types';
+import { SplitIO } from '../../types';
 import { IMatcherDto } from '../types';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 /**
  * Defines value to be matched (key / attribute).
  */
-export declare function sanitizeValue(log: ILogger, key: string, matcherDto: IMatcherDto, attributes?: Attributes): string | number | boolean | (string | number)[] | import("../types").IDependencyMatcherValue | undefined;
+export declare function sanitizeValue(log: ILogger, key: string, matcherDto: IMatcherDto, attributes?: SplitIO.Attributes): string | number | boolean | (string | number)[] | import("../types").IDependencyMatcherValue | undefined;

package/types/evaluator/value/sanitize.d.ts

@@ -1,7 +1,7 @@
-import { Attributes } from '../../types';
+import { SplitIO } from '../../types';
 import { IDependencyMatcherValue } from '../types';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 /**
  * Sanitize matcher value
  */
-export declare function sanitize(log: ILogger, matcherTypeID: number, value: string | number | boolean | Array<string | number> | undefined, dataType: string, attributes?: Attributes): string | number | boolean | (string | number)[] | IDependencyMatcherValue | undefined;
+export declare function sanitize(log: ILogger, matcherTypeID: number, value: string | number | boolean | Array<string | number> | undefined, dataType: string, attributes?: SplitIO.Attributes): string | number | boolean | (string | number)[] | IDependencyMatcherValue | undefined;

package/types/integrations/ga/GaToSplit.d.ts

@@ -1,9 +1,9 @@
 /// <reference types="google.analytics" />
-import { EventData } from '../../types';
+import { SplitIO } from '../../types';
 import { Identity, GoogleAnalyticsToSplitOptions } from './types';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 import { IIntegrationFactoryParams } from '../types';
-export declare const defaultMapper: (model: UniversalAnalytics.Model) => EventData;
+export declare const defaultMapper: (model: UniversalAnalytics.Model) => SplitIO.EventData;
 export declare const defaultPrefix = "ga";
 /**
  * Return a new list of identities removing invalid and duplicated ones.
@@ -19,7 +19,7 @@ export declare function validateIdentities(identities?: Identity[]): Identity[];
  * @param {EventData} data event data instance to validate. Precondition: data != undefined
  * @returns {boolean} Whether the data instance is a valid EventData or not.
  */
-export declare function validateEventData(log: ILogger, eventData: any): eventData is EventData;
+export declare function validateEventData(log: ILogger, eventData: any): eventData is SplitIO.EventData;
 /**
  * Fixes the passed string value to comply with EventTypeId format, by removing invalid characters and truncating if necessary.
  *

package/types/integrations/ga/SplitToGa.d.ts

@@ -1,8 +1,8 @@
 /// <reference types="google.analytics" />
-import { IntegrationData } from '../../types';
+import { SplitIO } from '../../types';
 import { IIntegration } from '../types';
 import { SplitToGoogleAnalyticsOptions } from './types';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 export declare class SplitToGa implements IIntegration {
     static defaultTrackerNames: string[];
     private trackerNames;
@@ -11,7 +11,7 @@ export declare class SplitToGa implements IIntegration {
     private impressions;
     private events;
     private log;
-    static defaultMapper({ type, payload }: IntegrationData): UniversalAnalytics.FieldsObject;
+    static defaultMapper({ type, payload }: SplitIO.IntegrationData): UniversalAnalytics.FieldsObject;
     static getGa(): UniversalAnalytics.ga | undefined;
     /**
      * Validates if a given object is a UniversalAnalytics.FieldsObject instance, and logs a warning if not.
@@ -30,5 +30,5 @@ export declare class SplitToGa implements IIntegration {
      * @param {object} options options passed at the SDK integrations settings (isomorphic SDK) or the SplitToGoogleAnalytics plugin (pluggable browser SDK)
      */
     constructor(log: ILogger, options: SplitToGoogleAnalyticsOptions);
-    queue(data: IntegrationData): void;
+    queue(data: SplitIO.IntegrationData): void;
 }

package/types/integrations/ga/types.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="google.analytics" />
-import { IntegrationData, EventData } from '../../types';
+import { SplitIO } from '../../types';
 /**
  * A pair of user key and it's trafficType, required for tracking valid Split events.
  * @typedef {Object} Identity
@@ -40,7 +40,7 @@ export interface GoogleAnalyticsToSplitOptions {
      *      return defaultMapping;
      *  }`
      */
-    mapper?: (model: UniversalAnalytics.Model, defaultMapping: EventData) => EventData;
+    mapper?: (model: UniversalAnalytics.Model, defaultMapping: SplitIO.EventData) => SplitIO.EventData;
     /**
      * Optional prefix for EventTypeId, to prevent any kind of data collision between events.
      * @property {string} prefix
@@ -94,7 +94,7 @@ export interface SplitToGoogleAnalyticsOptions {
      * For example, the following filter allows to track only impressions, equivalent to setting events to false:
      *  `(data) => data.type === 'IMPRESSION'`
      */
-    filter?: (data: IntegrationData) => boolean;
+    filter?: (data: SplitIO.IntegrationData) => boolean;
     /**
      * Optional function useful when you need to modify the GA hit before sending it.
      * This function is invoked with two arguments:
@@ -125,7 +125,7 @@ export interface SplitToGoogleAnalyticsOptions {
      *    nonInteraction: true,
      *  }`
      */
-    mapper?: (data: IntegrationData, defaultMapping: UniversalAnalytics.FieldsObject) => UniversalAnalytics.FieldsObject;
+    mapper?: (data: SplitIO.IntegrationData, defaultMapping: UniversalAnalytics.FieldsObject) => UniversalAnalytics.FieldsObject;
     /**
      * List of tracker names to send the hit. An empty string represents the default tracker.
      * If not provided, hits are only sent to default tracker.

package/types/integrations/types.d.ts

@@ -1,8 +1,8 @@
 import { IEventsCacheBase } from '../storages/types';
-import { IEventsHandler, IImpressionsHandler } from '../trackers/types';
-import { ISettings, IntegrationData } from '../types';
+import { IEventsHandler, IImpressionsHandler, ITelemetryTracker } from '../trackers/types';
+import { ISettings, SplitIO } from '../types';
 export interface IIntegration {
-    queue(data: IntegrationData): void;
+    queue(data: SplitIO.IntegrationData): void;
 }
 export declare type IIntegrationManager = IEventsHandler & IImpressionsHandler;
 export interface IIntegrationFactoryParams {
@@ -10,6 +10,7 @@ export interface IIntegrationFactoryParams {
         events: IEventsCacheBase;
     };
     settings: ISettings;
+    telemetryTracker: ITelemetryTracker;
 }
 export declare type IntegrationFactory = {
     readonly type: string;

package/types/logger/index.d.ts

@@ -1,7 +1,9 @@
-import { ILoggerOptions } from './types';
-import { LogLevel, ILogger, ILoggerAPI } from '../types';
+import { ILoggerOptions, ILogger } from './types';
+import { LogLevel } from '../types';
 import { IMap } from '../utils/lang/maps';
-export declare const LogLevels: ILoggerAPI['LogLevel'];
+export declare const LogLevels: {
+    [level: string]: LogLevel;
+};
 export declare function isLogLevelString(str: string): str is LogLevel;
 export declare function _sprintf(format?: string, args?: any[]): string;
 export declare class Logger implements ILogger {

package/types/logger/sdkLogger.d.ts

@@ -1,4 +1,5 @@
-import { ILoggerAPI, ILogger } from '../types';
+import { ILoggerAPI } from '../types';
+import { ILogger } from './types';
 /**
  * The public Logger utility API exposed via SplitFactory, used to update the log level.
  *

package/types/logger/types.d.ts

@@ -4,3 +4,14 @@ export interface ILoggerOptions {
     logLevel?: LogLevel;
     showLevel?: boolean;
 }
+export interface ILogger {
+    setLogLevel(logLevel: LogLevel): void;
+    debug(msg: any): void;
+    debug(msg: string | number, args?: any[]): void;
+    info(msg: any): void;
+    info(msg: string | number, args?: any[]): void;
+    warn(msg: any): void;
+    warn(msg: string | number, args?: any[]): void;
+    error(msg: any): void;
+    error(msg: string | number, args?: any[]): void;
+}

package/types/readiness/sdkReadinessManager.d.ts

@@ -1,6 +1,6 @@
 import { ISdkReadinessManager } from './types';
 import { IEventEmitter } from '../types';
-import { ILogger } 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.

package/types/readiness/types.d.ts

@@ -1,4 +1,4 @@
-import { IEventEmitter, IStatusInterface, Event } from '../types';
+import { IEventEmitter, IStatusInterface } from '../types';
 /** Splits data emitter */
 declare type SDK_SPLITS_ARRIVED = 'state::splits-arrived';
 declare type SDK_SPLITS_CACHE_LOADED = 'state::splits-cache-loaded';
@@ -20,8 +20,14 @@ export interface ISegmentsEventEmitter extends IEventEmitter {
     segmentsArrived: boolean;
 }
 /** Readiness emitter */
+export declare type SDK_READY_TIMED_OUT = 'init::timeout';
+export declare type SDK_READY = 'init::ready';
+export declare type SDK_READY_FROM_CACHE = 'init::cache-ready';
+export declare type SDK_UPDATE = 'state::update';
+export declare type SDK_DESTROY = 'state::destroy';
+export declare type IReadinessEvent = SDK_READY_TIMED_OUT | SDK_READY | SDK_READY_FROM_CACHE | SDK_UPDATE | SDK_DESTROY;
 export interface IReadinessEventEmitter extends IEventEmitter {
-    emit(event: Event, ...args: any[]): boolean;
+    emit(event: IReadinessEvent, ...args: any[]): boolean;
 }
 /** Readiness manager */
 export interface IReadinessManager {

package/types/sdkClient/client.d.ts

@@ -1,6 +1,6 @@
-import { IClientSS, IAsyncClientSS } from '../types';
+import { SplitIO } from '../types';
 import { ISdkFactoryContext } from '../sdkFactory/types';
 /**
  * Creator of base client with getTreatments and track methods.
  */
-export declare function clientFactory(params: ISdkFactoryContext): IClientSS | IAsyncClientSS;
+export declare function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | SplitIO.IAsyncClient;

package/types/sdkClient/clientAttributesDecoration.d.ts

@@ -1,14 +1,14 @@
-import { Attributes, IAsyncClientSS, IClientSS, Properties, SplitKey } from '../types';
-import { ILogger } from '../types';
+import { SplitIO } from '../types';
+import { ILogger } from '../logger/types';
 /**
  * Add in memory attributes storage methods and combine them with any attribute received from the getTreatment/s call
  */
-export declare function clientAttributesDecoration(log: ILogger, client: IClientSS | IAsyncClientSS): (IClientSS | IAsyncClientSS) & {
-    getTreatment: (maybeKey: SplitKey, maybeSplit: string, maybeAttributes?: Attributes | undefined) => string | import("../types").AsyncTreatment;
-    getTreatmentWithConfig: (maybeKey: SplitKey, maybeSplit: string, maybeAttributes?: Attributes | undefined) => import("../types").TreatmentWithConfig | import("../types").AsyncTreatmentWithConfig;
-    getTreatments: (maybeKey: SplitKey, maybeSplits: string[], maybeAttributes?: Attributes | undefined) => import("../types").Treatments | import("../types").AsyncTreatments;
-    getTreatmentsWithConfig: (maybeKey: SplitKey, maybeSplits: string[], maybeAttributes?: Attributes | undefined) => import("../types").TreatmentsWithConfig | import("../types").AsyncTreatmentsWithConfig;
-    track: (maybeKey: SplitKey, maybeTT: string, maybeEvent: string, maybeEventValue?: number | undefined, maybeProperties?: Properties | undefined) => boolean | Promise<boolean>;
+export declare function clientAttributesDecoration<TClient extends SplitIO.IClient | SplitIO.IAsyncClient>(log: ILogger, client: TClient): TClient & {
+    getTreatment: (maybeKey: SplitIO.SplitKey, maybeSplit: string, maybeAttributes?: SplitIO.Attributes | undefined) => string | SplitIO.AsyncTreatment;
+    getTreatmentWithConfig: (maybeKey: SplitIO.SplitKey, maybeSplit: string, maybeAttributes?: SplitIO.Attributes | undefined) => SplitIO.TreatmentWithConfig | SplitIO.AsyncTreatmentWithConfig;
+    getTreatments: (maybeKey: SplitIO.SplitKey, maybeSplits: string[], maybeAttributes?: SplitIO.Attributes | undefined) => SplitIO.Treatments | SplitIO.AsyncTreatments;
+    getTreatmentsWithConfig: (maybeKey: SplitIO.SplitKey, maybeSplits: string[], maybeAttributes?: SplitIO.Attributes | undefined) => SplitIO.TreatmentsWithConfig | SplitIO.AsyncTreatmentsWithConfig;
+    track: (maybeKey: SplitIO.SplitKey, maybeTT: string, maybeEvent: string, maybeEventValue?: number | undefined, maybeProperties?: SplitIO.Properties | undefined) => boolean | Promise<boolean>;
     /**
      * Add an attribute to client's in memory attributes storage
      *

package/types/sdkClient/clientCS.d.ts

@@ -1,4 +1,5 @@
-import { IClientSS, IClientWithKeyLegacy, ILogger, SplitKey } from '../types';
+import { ILogger } from '../logger/types';
+import { SplitIO } from '../types';
 /**
  * Decorator that binds a key and (optionally) a traffic type to client methods
  *
@@ -6,4 +7,4 @@ import { IClientSS, IClientWithKeyLegacy, ILogger, SplitKey } from '../types';
  * @param key validated split key
  * @param trafficType validated traffic type
  */
-export declare function clientCSDecorator(log: ILogger, client: IClientSS, key: SplitKey, trafficType?: string): IClientWithKeyLegacy;
+export declare function clientCSDecorator(log: ILogger, client: SplitIO.IClient, key: SplitIO.SplitKey, trafficType?: string): SplitIO.ICsClient;

package/types/sdkClient/clientInputValidation.d.ts

@@ -1,7 +1,7 @@
 import { IReadinessManager } from '../readiness/types';
-import { ISettings, IClientSS, IAsyncClientSS } from '../types';
+import { ISettings, SplitIO } from '../types';
 /**
  * Decorator that validates the input before actually executing the client methods.
  * We should "guard" the client here, while not polluting the "real" implementation of those methods.
  */
-export declare function clientInputValidationDecorator(settings: ISettings, client: IClientSS | IAsyncClientSS, readinessManager: IReadinessManager): IClientSS | IAsyncClientSS;
+export declare function clientInputValidationDecorator<TClient extends SplitIO.IClient | SplitIO.IAsyncClient>(settings: ISettings, client: TClient, readinessManager: IReadinessManager): TClient;

package/types/sdkClient/sdkClient.d.ts

@@ -1,6 +1,6 @@
-import { IBasicClient } from '../types';
+import { SplitIO } from '../types';
 import { ISdkFactoryContext } from '../sdkFactory/types';
 /**
  * Creates an Sdk client, i.e., a base client with status and destroy interface
  */
-export declare function sdkClientFactory(params: ISdkFactoryContext, isSharedClient?: boolean): IBasicClient;
+export declare function sdkClientFactory(params: ISdkFactoryContext, isSharedClient?: boolean): SplitIO.IClient | SplitIO.IAsyncClient;

package/types/sdkClient/sdkClientMethod.d.ts

@@ -1,6 +1,6 @@
-import { IBasicClient } from '../types';
+import { SplitIO } from '../types';
 import { ISdkFactoryContext } from '../sdkFactory/types';
 /**
  * Factory of client method for server-side SDKs (ISDK and IAsyncSDK)
  */
-export declare function sdkClientMethodFactory(params: ISdkFactoryContext): () => IBasicClient;
+export declare function sdkClientMethodFactory(params: ISdkFactoryContext): () => SplitIO.IClient | SplitIO.IAsyncClient;

package/types/sdkClient/sdkClientMethodCS.d.ts

@@ -1,7 +1,7 @@
-import { IClientWithKey, SplitKey } from '../types';
+import { SplitIO } from '../types';
 import { ISdkFactoryContext } from '../sdkFactory/types';
 /**
  * Factory of client method for the client-side API variant where TT is ignored and thus
  * clients don't have a binded TT for the track method.
  */
-export declare function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: SplitKey) => IClientWithKey;
+export declare function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: SplitIO.SplitKey) => SplitIO.ICsClient;

package/types/sdkClient/sdkClientMethodCSWithTT.d.ts

@@ -1,8 +1,8 @@
-import { IClientWithKeyLegacy, SplitKey } from '../types';
+import { SplitIO } from '../types';
 import { ISdkFactoryContext } from '../sdkFactory/types';
 /**
  * Factory of client method for the client-side (browser) variant of the Isomorphic JS SDK,
  * where clients can have a binded TT for the track method, which is provided via the settings
  * (default client) or the client method (shared clients).
  */
-export declare function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: SplitKey, trafficType?: string) => IClientWithKeyLegacy;
+export declare function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: SplitIO.SplitKey, trafficType?: string) => SplitIO.ICsClient;

package/types/sdkFactory/index.d.ts

@@ -1,6 +1,6 @@
 import { ISdkFactoryParams } from './types';
-import { IBasicSDK } from '../types';
+import { SplitIO } from '../types';
 /**
  * Modular SDK factory
  */
-export declare function sdkFactory(params: ISdkFactoryParams): IBasicSDK<any, any>;
+export declare function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.ISDK | SplitIO.IAsyncSDK;

package/types/sdkFactory/types.d.ts

@@ -1,13 +1,13 @@
 import { IIntegrationManager, IIntegrationFactoryParams } from '../integrations/types';
 import { ISignalListener } from '../listeners/types';
-import { IAsyncClientSS, IAsyncManager, IClientSS, IClientWithKey, ILogger, IManager, SplitKey } from '../types';
+import { ILogger } from '../logger/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 { ISettings, IEventEmitter } from '../types';
+import { SplitIO, ISettings, IEventEmitter } from '../types';
 /**
  * Environment related dependencies.
  */
@@ -65,11 +65,11 @@ export interface ISdkFactoryParams {
     storageFactory: (params: IStorageFactoryParams) => IStorageSync | IStorageAsync;
     splitApiFactory?: (settings: ISettings, platform: IPlatform, telemetryTracker: ITelemetryTracker) => ISplitApi;
     syncManagerFactory?: (params: ISdkFactoryContextSync) => ISyncManager;
-    sdkManagerFactory: (log: ILogger, splits: ISplitsCacheSync | ISplitsCacheAsync, sdkReadinessManager: ISdkReadinessManager) => IManager | IAsyncManager;
+    sdkManagerFactory: (log: ILogger, splits: ISplitsCacheSync | ISplitsCacheAsync, sdkReadinessManager: ISdkReadinessManager) => SplitIO.IManager | SplitIO.IAsyncManager;
     sdkClientMethodFactory: (params: ISdkFactoryContext) => ({
-        (): IClientWithKey;
-        (key: SplitKey, trafficType?: string | undefined): IClientWithKey;
-    } | (() => IClientSS) | (() => IAsyncClientSS));
+        (): SplitIO.ICsClient;
+        (key: SplitIO.SplitKey, trafficType?: string | undefined): SplitIO.ICsClient;
+    } | (() => SplitIO.IClient) | (() => SplitIO.IAsyncClient));
     SignalListener?: new (syncManager: ISyncManager | undefined, // Used by NodeSignalListener to flush data, and by BrowserSignalListener to close streaming connection.
     settings: ISettings, // Used by BrowserSignalListener
     storage: IStorageSync | IStorageAsync, // Used by BrowserSignalListener

package/types/sdkManager/index.d.ts

@@ -1,5 +1,5 @@
 import { ISplitsCacheAsync, ISplitsCacheSync } from '../storages/types';
 import { ISdkReadinessManager } from '../readiness/types';
-import { IAsyncManager, IManager } from '../types';
-import { ILogger } from '../types';
-export declare function sdkManagerFactory<TSplitCache extends ISplitsCacheSync | ISplitsCacheAsync>(log: ILogger, splits: TSplitCache, { readinessManager, sdkStatus }: ISdkReadinessManager): TSplitCache extends ISplitsCacheAsync ? IAsyncManager : IManager;
+import { SplitIO } from '../types';
+import { ILogger } from '../logger/types';
+export declare function sdkManagerFactory<TSplitCache extends ISplitsCacheSync | ISplitsCacheAsync>(log: ILogger, splits: TSplitCache, { readinessManager, sdkStatus }: ISdkReadinessManager): TSplitCache extends ISplitsCacheAsync ? SplitIO.IAsyncManager : SplitIO.IManager;

package/types/storages/AbstractSplitsCacheAsync.d.ts

@@ -1,17 +1,18 @@
 import { ISplitsCacheAsync } from './types';
+import { ISplit } from '../dtos/types';
 /**
  * This class provides a skeletal implementation of the ISplitsCacheAsync interface
  * to minimize the effort required to implement this interface.
  */
 export declare abstract class AbstractSplitsCacheAsync implements ISplitsCacheAsync {
-    abstract addSplit(name: string, split: string): Promise<boolean>;
-    abstract addSplits(entries: [string, string][]): Promise<boolean[] | void>;
+    abstract addSplit(name: string, split: ISplit): Promise<boolean>;
+    abstract addSplits(entries: [string, ISplit][]): Promise<boolean[] | void>;
     abstract removeSplits(names: string[]): Promise<boolean[] | void>;
-    abstract getSplit(name: string): Promise<string | null>;
-    abstract getSplits(names: string[]): Promise<Record<string, string | null>>;
+    abstract getSplit(name: string): Promise<ISplit | null>;
+    abstract getSplits(names: string[]): Promise<Record<string, ISplit | null>>;
     abstract setChangeNumber(changeNumber: number): Promise<boolean | void>;
     abstract getChangeNumber(): Promise<number>;
-    abstract getAll(): Promise<string[]>;
+    abstract getAll(): Promise<ISplit[]>;
     abstract getSplitNames(): Promise<string[]>;
     abstract trafficTypeExists(trafficType: string): Promise<boolean>;
     abstract clear(): Promise<boolean | void>;

package/types/storages/AbstractSplitsCacheSync.d.ts

@@ -5,15 +5,15 @@ import { ISplit } from '../dtos/types';
  * to minimize the effort required to implement this interface.
  */
 export declare abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
-    abstract addSplit(name: string, split: string): boolean;
-    addSplits(entries: [string, string][]): boolean[];
+    abstract addSplit(name: string, split: ISplit): boolean;
+    addSplits(entries: [string, ISplit][]): boolean[];
     abstract removeSplit(name: string): boolean;
     removeSplits(names: string[]): boolean[];
-    abstract getSplit(name: string): string | null;
-    getSplits(names: string[]): Record<string, string | null>;
+    abstract getSplit(name: string): ISplit | null;
+    getSplits(names: string[]): Record<string, ISplit | null>;
     abstract setChangeNumber(changeNumber: number): boolean;
     abstract getChangeNumber(): number;
-    getAll(): string[];
+    getAll(): ISplit[];
     abstract getSplitNames(): string[];
     abstract trafficTypeExists(trafficType: string): boolean;
     abstract usesSegments(): boolean;

package/types/storages/dataLoader.d.ts

@@ -1,4 +1,4 @@
-import { PreloadedData } from './types';
+import { SplitIO } from '../types';
 import { DataLoader } from './types';
 /**
  * Factory of client-side storage loader
@@ -7,4 +7,4 @@ import { DataLoader } from './types';
  * and extended with a `mySegmentsData` property.
  * @returns function to preload the storage
  */
-export declare function dataLoaderFactory(preloadedData: PreloadedData): DataLoader;
+export declare function dataLoaderFactory(preloadedData: SplitIO.PreloadedData): DataLoader;

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

@@ -1,4 +1,4 @@
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 import { AbstractSegmentsCacheSync } from '../AbstractSegmentsCacheSync';
 import { KeyBuilderCS } from '../KeyBuilderCS';
 export declare class MySegmentsCacheInLocal extends AbstractSegmentsCacheSync {

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

@@ -1,6 +1,7 @@
+import { ISplit, ISplitFiltersValidation } from '../../dtos/types';
 import { AbstractSplitsCacheSync } from '../AbstractSplitsCacheSync';
 import { KeyBuilderCS } from '../KeyBuilderCS';
-import { ILogger, ISplitFiltersValidation } from '../../types';
+import { ILogger } from '../../logger/types';
 /**
  * ISplitsCacheSync implementation that stores split definitions in browser LocalStorage.
  */
@@ -25,9 +26,9 @@ export declare class SplitsCacheInLocal extends AbstractSplitsCacheSync {
      * We cannot simply call `localStorage.clear()` since that implies removing user items from the storage.
      */
     clear(): void;
-    addSplit(name: string, split: string): boolean;
+    addSplit(name: string, split: ISplit): boolean;
     removeSplit(name: string): boolean;
-    getSplit(name: string): string | null;
+    getSplit(name: string): any;
     setChangeNumber(changeNumber: number): boolean;
     getChangeNumber(): number;
     getSplitNames(): string[];

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

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

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

@@ -1,4 +1,4 @@
-import { EventData } from '../../types';
+import { SplitIO } from '../../types';
 import { IEventsCacheSync } from '../types';
 export declare class EventsCacheInMemory implements IEventsCacheSync {
     private onFullQueue?;
@@ -15,7 +15,7 @@ export declare class EventsCacheInMemory implements IEventsCacheSync {
     /**
      * Add a new event object at the end of the queue.
      */
-    track(data: EventData, size?: number): boolean;
+    track(data: SplitIO.EventData, size?: number): boolean;
     /**
      * Clear the data stored on the cache.
      */
@@ -23,7 +23,7 @@ export declare class EventsCacheInMemory implements IEventsCacheSync {
     /**
      * Pop the collected data, used as payload for posting.
      */
-    pop(toMerge?: EventData[]): EventData[];
+    pop(toMerge?: SplitIO.EventData[]): SplitIO.EventData[];
     /**
      * Check if the cache is empty.
      */

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

@@ -6,5 +6,5 @@ import { IStorageFactoryParams, IStorageSync } from '../types';
  */
 export declare function InMemoryStorageFactory(params: IStorageFactoryParams): IStorageSync;
 export declare namespace InMemoryStorageFactory {
-    var type: import("../../types").StorageType;
+    var type: import("../types").StorageType;
 }

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

@@ -6,5 +6,5 @@ import { IStorageSync, IStorageFactoryParams } from '../types';
  */
 export declare function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorageSync;
 export declare namespace InMemoryStorageCSFactory {
-    var type: import("../../types").StorageType;
+    var type: import("../types").StorageType;
 }

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

@@ -1,3 +1,4 @@
+import { ISplit } from '../../dtos/types';
 import { AbstractSplitsCacheSync } from '../AbstractSplitsCacheSync';
 /**
  * Default ISplitsCacheSync implementation that stores split definitions in memory.
@@ -9,9 +10,9 @@ export declare class SplitsCacheInMemory extends AbstractSplitsCacheSync {
     private changeNumber;
     private splitsWithSegmentsCount;
     clear(): void;
-    addSplit(name: string, split: string): boolean;
+    addSplit(name: string, split: ISplit): boolean;
     removeSplit(name: string): boolean;
-    getSplit(name: string): string | null;
+    getSplit(name: string): ISplit | null;
     setChangeNumber(changeNumber: number): boolean;
     getChangeNumber(): number;
     getSplitNames(): string[];

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

@@ -1,8 +1,8 @@
 import { IEventsCacheAsync } from '../types';
 import { IMetadata } from '../../dtos/types';
 import { Redis } from 'ioredis';
-import { EventData } from '../../types';
-import { ILogger } from '../../types';
+import { SplitIO } from '../../types';
+import { ILogger } from '../../logger/types';
 import { StoredEventWithMetadata } from '../../sync/submitters/types';
 export declare class EventsCacheInRedis implements IEventsCacheAsync {
     private readonly log;
@@ -14,7 +14,7 @@ export declare class EventsCacheInRedis implements IEventsCacheAsync {
      * Add a new event object into the queue.
      * Unlike `impressions::track`, result promise is never rejected.
      */
-    track(eventData: EventData): Promise<boolean>;
+    track(eventData: SplitIO.EventData): Promise<boolean>;
     /**
      * Generates the JSON as we'll store it on Redis.
      */

package/types/storages/inRedis/ImpressionsCacheInRedis.d.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 '../../types';
+import { ILogger } from '../../logger/types';
 export declare class ImpressionsCacheInRedis implements IImpressionsCacheAsync {
     private readonly log;
     private readonly key;

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

@@ -1,5 +1,5 @@
 import ioredis from 'ioredis';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 /**
  * Redis adapter on top of the library of choice (written with ioredis) for some extra control.
  */

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

@@ -1,5 +1,5 @@
 import { Redis } from 'ioredis';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 import { KeyBuilderSS } from '../KeyBuilderSS';
 import { ISegmentsCacheAsync } from '../types';
 export declare class SegmentsCacheInRedis implements ISegmentsCacheAsync {