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

package/src/evaluator/value/sanitize.ts

@@ -1,6 +1,6 @@
-import { SplitIO } from '../../types';
+import { Attributes } from '../../types';
 import { IDependencyMatcherValue } from '../types';
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 import { isObject, uniq, toString, toNumber } from '../../utils/lang';
 import { zeroSinceHH, zeroSinceSS } from '../convertions';
 import { matcherTypes, matcherDataTypes } from '../matchers/matcherTypes';
@@ -41,7 +41,7 @@ function sanitizeBoolean(val: any): boolean | undefined {
   return undefined;
 }
 
-function dependencyProcessor(sanitizedValue: string, attributes?: SplitIO.Attributes): IDependencyMatcherValue {
+function dependencyProcessor(sanitizedValue: string, attributes?: Attributes): IDependencyMatcherValue {
   return {
     key: sanitizedValue,
     attributes
@@ -69,7 +69,7 @@ function getProcessingFunction(matcherTypeID: number, dataType: string) {
 /**
  * Sanitize matcher value
  */
-export function sanitize(log: ILogger, matcherTypeID: number, value: string | number | boolean | Array<string | number> | undefined, dataType: string, attributes?: SplitIO.Attributes) {
+export function sanitize(log: ILogger, matcherTypeID: number, value: string | number | boolean | Array<string | number> | undefined, dataType: string, attributes?: Attributes) {
   const processor = getProcessingFunction(matcherTypeID, dataType);
   let sanitizedValue: string | number | boolean | Array<string | number> | IDependencyMatcherValue | undefined;
 

package/src/integrations/ga/GaToSplit.ts

@@ -8,9 +8,9 @@ import {
   validateKey,
   validateTrafficType,
 } from '../../utils/inputValidation';
-import { SplitIO } from '../../types';
+import { EventData } from '../../types';
 import { Identity, GoogleAnalyticsToSplitOptions } from './types';
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 import { IIntegrationFactoryParams } from '../types';
 
 const logPrefix = 'ga-to-split: ';
@@ -67,7 +67,7 @@ const defaultMapping = {
  * @param {object} mapping
  */
 function mapperBuilder(mapping: typeof defaultMapping) {
-  return function (model: UniversalAnalytics.Model): SplitIO.EventData {
+  return function (model: UniversalAnalytics.Model): EventData {
     const hitType: string = model.get('hitType');
     // @ts-expect-error
     const eventTypeId = model.get(mapping.eventTypeId[hitType] || 'hitType');
@@ -133,7 +133,7 @@ export function validateIdentities(identities?: 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 function validateEventData(log: ILogger, eventData: any): eventData is SplitIO.EventData {
+export function validateEventData(log: ILogger, eventData: any): eventData is EventData {
   if (!validateEvent(log, eventData.eventTypeId, logNameMapper))
     return false;
 
@@ -251,10 +251,10 @@ export function GaToSplit(sdkOptions: GoogleAnalyticsToSplitOptions, params: IIn
         }
 
         // map hit into an EventData instance
-        let eventData: SplitIO.EventData = defaultMapper(model);
+        let eventData: EventData = defaultMapper(model);
         if (opts.mapper) {
           try {
-            eventData = opts.mapper(model, eventData as SplitIO.EventData);
+            eventData = opts.mapper(model, eventData as EventData);
           } catch (err) {
             log.warn(logPrefix + `custom mapper threw: ${err}`);
             return;

package/src/integrations/ga/SplitToGa.ts

@@ -1,10 +1,10 @@
 /* eslint-disable no-undef */
 import { uniq } from '../../utils/lang';
 import { SPLIT_IMPRESSION, SPLIT_EVENT } from '../../utils/constants';
-import { SplitIO } from '../../types';
+import { IntegrationData, ImpressionData, EventData } from '../../types';
 import { IIntegration } from '../types';
 import { SplitToGoogleAnalyticsOptions } from './types';
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 
 const logPrefix = 'split-to-ga: ';
 const noGaWarning = '`ga` command queue not found.';
@@ -16,29 +16,29 @@ export class SplitToGa implements IIntegration {
   static defaultTrackerNames = [''];
 
   private trackerNames: string[];
-  private filter?: (data: SplitIO.IntegrationData) => boolean;
-  private mapper?: (data: SplitIO.IntegrationData, defaultMapping: UniversalAnalytics.FieldsObject) => UniversalAnalytics.FieldsObject;
+  private filter?: (data: IntegrationData) => boolean;
+  private mapper?: (data: IntegrationData, defaultMapping: UniversalAnalytics.FieldsObject) => UniversalAnalytics.FieldsObject;
   private impressions: boolean | undefined;
   private events: boolean | undefined;
   private log: ILogger;
 
   // Default mapper function.
-  static defaultMapper({ type, payload }: SplitIO.IntegrationData): UniversalAnalytics.FieldsObject {
+  static defaultMapper({ type, payload }: IntegrationData): UniversalAnalytics.FieldsObject {
     switch (type) {
       case SPLIT_IMPRESSION:
         return {
           hitType: 'event',
           eventCategory: 'split-impression',
-          eventAction: 'Evaluate ' + (payload as SplitIO.ImpressionData).impression.feature,
-          eventLabel: 'Treatment: ' + (payload as SplitIO.ImpressionData).impression.treatment + '. Targeting rule: ' + (payload as SplitIO.ImpressionData).impression.label + '.',
+          eventAction: 'Evaluate ' + (payload as ImpressionData).impression.feature,
+          eventLabel: 'Treatment: ' + (payload as ImpressionData).impression.treatment + '. Targeting rule: ' + (payload as ImpressionData).impression.label + '.',
           nonInteraction: true,
         };
       case SPLIT_EVENT:
         return {
           hitType: 'event',
           eventCategory: 'split-event',
-          eventAction: (payload as SplitIO.EventData).eventTypeId,
-          eventValue: (payload as SplitIO.EventData).value,
+          eventAction: (payload as EventData).eventTypeId,
+          eventValue: (payload as EventData).value,
           nonInteraction: true,
         };
     }
@@ -93,7 +93,7 @@ export class SplitToGa implements IIntegration {
     if (typeof SplitToGa.getGa() !== 'function') log.warn(logPrefix + `${noGaWarning} No hits will be sent until it is available.`);
   }
 
-  queue(data: SplitIO.IntegrationData) {
+  queue(data: IntegrationData) {
     // access ga command queue via `getGa` method, accounting for the possibility that
     // the global `ga` reference was not yet mutated by analytics.js.
     const ga = SplitToGa.getGa();

package/src/integrations/ga/types.ts

@@ -1,4 +1,4 @@
-import { SplitIO } from '../../types';
+import { IntegrationData, EventData } from '../../types';
 
 /**
  * A pair of user key and it's trafficType, required for tracking valid Split events.
@@ -41,7 +41,7 @@ export interface GoogleAnalyticsToSplitOptions {
    *      return defaultMapping;
    *  }`
    */
-  mapper?: (model: UniversalAnalytics.Model, defaultMapping: SplitIO.EventData) => SplitIO.EventData,
+  mapper?: (model: UniversalAnalytics.Model, defaultMapping: EventData) => EventData,
   /**
    * Optional prefix for EventTypeId, to prevent any kind of data collision between events.
    * @property {string} prefix
@@ -97,7 +97,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: SplitIO.IntegrationData) => boolean,
+  filter?: (data: IntegrationData) => boolean,
   /**
    * Optional function useful when you need to modify the GA hit before sending it.
    * This function is invoked with two arguments:
@@ -128,7 +128,7 @@ export interface SplitToGoogleAnalyticsOptions {
    *    nonInteraction: true,
    *  }`
    */
-  mapper?: (data: SplitIO.IntegrationData, defaultMapping: UniversalAnalytics.FieldsObject) => UniversalAnalytics.FieldsObject,
+  mapper?: (data: 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/src/integrations/pluggable.ts

@@ -1,5 +1,5 @@
 import { SPLIT_IMPRESSION, SPLIT_EVENT } from '../utils/constants';
-import { SplitIO } from '../types';
+import { ImpressionData, EventData } from '../types';
 import { IIntegration, IIntegrationManager, IIntegrationFactoryParams } from './types';
 
 /**
@@ -29,10 +29,10 @@ export function pluggableIntegrationsManagerFactory(
 
   // Exception safe methods: each integration module is responsable for handling errors
   return {
-    handleImpression(impressionData: SplitIO.ImpressionData) {
+    handleImpression(impressionData: ImpressionData) {
       listeners.forEach(listener => listener.queue({ type: SPLIT_IMPRESSION, payload: impressionData }));
     },
-    handleEvent(eventData: SplitIO.EventData) {
+    handleEvent(eventData: EventData) {
       listeners.forEach(listener => listener.queue({ type: SPLIT_EVENT, payload: eventData }));
     }
   };

package/src/integrations/types.ts

@@ -1,9 +1,9 @@
 import { IEventsCacheBase } from '../storages/types';
 import { IEventsHandler, IImpressionsHandler } from '../trackers/types';
-import { ISettings, SplitIO } from '../types';
+import { ISettings, IntegrationData } from '../types';
 
 export interface IIntegration {
-  queue(data: SplitIO.IntegrationData): void
+  queue(data: IntegrationData): void
 }
 
 export type IIntegrationManager = IEventsHandler & IImpressionsHandler;

package/src/listeners/browser.ts

@@ -7,7 +7,7 @@ import { fromImpressionCountsCollector } from '../sync/submitters/impressionCoun
 import { IResponse, ISplitApi } from '../services/types';
 import { ImpressionDTO, ISettings } from '../types';
 import { ImpressionsPayload } from '../sync/submitters/types';
-import { OPTIMIZED, DEBUG, NONE } from '../utils/constants';
+import { OPTIMIZED, DEBUG } from '../utils/constants';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { CLEANUP_REGISTERING, CLEANUP_DEREGISTERING } from '../logger/constants';
 import { ISyncManager } from '../sync/types';
@@ -88,10 +88,9 @@ export class BrowserSignalListener implements ISignalListener {
     // Flush impressions & events data if there is user consent
     if (isConsentGranted(this.settings)) {
       const eventsUrl = this.settings.urls.events;
-      const sim = this.settings.sync.impressionsMode;
       const extraMetadata = {
         // sim stands for Sync/Split Impressions Mode
-        sim: sim === OPTIMIZED ? OPTIMIZED : sim === DEBUG ? DEBUG : NONE
+        sim: this.settings.sync.impressionsMode === OPTIMIZED ? OPTIMIZED : DEBUG
       };
 
       this._flushData(eventsUrl + '/testImpressions/beacon', this.storage.impressions, this.serviceApi.postTestImpressionsBulk, this.fromImpressionsCollector, extraMetadata);

package/src/logger/constants.ts

@@ -143,5 +143,4 @@ export const LOG_PREFIX_SYNC_POLLING = LOG_PREFIX_SYNC + ':polling-manager: ';
 export const LOG_PREFIX_SYNC_SUBMITTERS = LOG_PREFIX_SYNC + ':submitter: ';
 export const LOG_PREFIX_IMPRESSIONS_TRACKER = 'impressions-tracker: ';
 export const LOG_PREFIX_EVENTS_TRACKER = 'events-tracker: ';
-export const LOG_PREFIX_UNIQUE_KEYS_TRACKER = 'unique-keys-tracker: ';
 export const LOG_PREFIX_CLEANUP = 'cleanup: ';

package/src/logger/index.ts

@@ -1,10 +1,10 @@
 import { objectAssign } from '../utils/lang/objectAssign';
-import { ILoggerOptions, ILogger } from './types';
+import { ILoggerOptions } from './types';
 import { find } from '../utils/lang';
-import { LogLevel } from '../types';
+import { LogLevel, ILogger, ILoggerAPI } from '../types';
 import { IMap, _Map } from '../utils/lang/maps';
 
-export const LogLevels: { [level: string]: LogLevel } = {
+export const LogLevels: ILoggerAPI['LogLevel'] = {
   DEBUG: 'DEBUG',
   INFO: 'INFO',
   WARN: 'WARN',

package/src/logger/sdkLogger.ts

@@ -1,6 +1,5 @@
 import { LogLevels, isLogLevelString } from './index';
-import { ILoggerAPI } from '../types';
-import { ILogger } from './types';
+import { ILoggerAPI, ILogger } from '../types';
 import { ERROR_LOGLEVEL_INVALID } from './constants';
 
 /**

package/src/logger/types.ts

@@ -5,19 +5,3 @@ export interface ILoggerOptions {
   logLevel?: LogLevel,
   showLevel?: boolean, // @TODO remove this param eventually since it is not being set `false` anymore
 }
-
-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/src/readiness/sdkReadinessManager.ts

@@ -4,7 +4,7 @@ import { readinessManagerFactory } from './readinessManager';
 import { ISdkReadinessManager } from './types';
 import { IEventEmitter } from '../types';
 import { SDK_READY, SDK_READY_TIMED_OUT, SDK_READY_FROM_CACHE, SDK_UPDATE } from './constants';
-import { ILogger } from '../logger/types';
+import { ILogger } from '../types';
 import { ERROR_CLIENT_LISTENER, CLIENT_READY_FROM_CACHE, CLIENT_READY, CLIENT_NO_LISTENER } from '../logger/constants';
 
 const NEW_LISTENER_EVENT = 'newListener';

package/src/readiness/types.ts

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

package/src/sdkClient/client.ts

@@ -6,18 +6,18 @@ import { validateTrafficTypeExistance } from '../utils/inputValidation/trafficTy
 import { SDK_NOT_READY } from '../utils/labels';
 import { CONTROL, TREATMENT, TREATMENTS, TREATMENT_WITH_CONFIG, TREATMENTS_WITH_CONFIG, TRACK } from '../utils/constants';
 import { IEvaluationResult } from '../evaluator/types';
-import { SplitIO, ImpressionDTO } from '../types';
+import { SplitKey, Attributes,ImpressionDTO, Treatment, TreatmentWithConfig, Properties, EventData, IClientSS, IAsyncClientSS } from '../types';
 import { IMPRESSION, IMPRESSION_QUEUEING } from '../logger/constants';
 import { ISdkFactoryContext } from '../sdkFactory/types';
 
 /**
  * Creator of base client with getTreatments and track methods.
  */
-export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | SplitIO.IAsyncClient {
+export function clientFactory(params: ISdkFactoryContext): IClientSS | IAsyncClientSS {
   const { sdkReadinessManager: { readinessManager }, storage, settings, impressionsTracker, eventTracker, telemetryTracker } = params;
   const { log, mode } = settings;
 
-  function getTreatment(key: SplitIO.SplitKey, splitName: string, attributes: SplitIO.Attributes | undefined, withConfig = false) {
+  function getTreatment(key: SplitKey, splitName: string, attributes: Attributes | undefined, withConfig = false) {
     const stopTelemetryTracker = telemetryTracker.trackEval(withConfig ? TREATMENT_WITH_CONFIG : TREATMENT);
 
     const wrapUp = (evaluationResult: IEvaluationResult) => {
@@ -34,16 +34,16 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
     return thenable(evaluation) ? evaluation.then((res) => wrapUp(res)) : wrapUp(evaluation);
   }
 
-  function getTreatmentWithConfig(key: SplitIO.SplitKey, splitName: string, attributes: SplitIO.Attributes | undefined) {
+  function getTreatmentWithConfig(key: SplitKey, splitName: string, attributes: Attributes | undefined) {
     return getTreatment(key, splitName, attributes, true);
   }
 
-  function getTreatments(key: SplitIO.SplitKey, splitNames: string[], attributes: SplitIO.Attributes | undefined, withConfig = false) {
+  function getTreatments(key: SplitKey, splitNames: string[], attributes: Attributes | undefined, withConfig = false) {
     const stopTelemetryTracker = telemetryTracker.trackEval(withConfig ? TREATMENTS_WITH_CONFIG : TREATMENTS);
 
     const wrapUp = (evaluationResults: Record<string, IEvaluationResult>) => {
       const queue: ImpressionDTO[] = [];
-      const treatments: Record<string, SplitIO.Treatment | SplitIO.TreatmentWithConfig> = {};
+      const treatments: Record<string, Treatment | TreatmentWithConfig> = {};
       Object.keys(evaluationResults).forEach(splitName => {
         treatments[splitName] = processEvaluation(evaluationResults[splitName], splitName, key, attributes, withConfig, `getTreatments${withConfig ? 'withConfig' : ''}`, queue);
       });
@@ -58,7 +58,7 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
     return thenable(evaluations) ? evaluations.then((res) => wrapUp(res)) : wrapUp(evaluations);
   }
 
-  function getTreatmentsWithConfig(key: SplitIO.SplitKey, splitNames: string[], attributes: SplitIO.Attributes | undefined) {
+  function getTreatmentsWithConfig(key: SplitKey, splitNames: string[], attributes: Attributes | undefined) {
     return getTreatments(key, splitNames, attributes, true);
   }
 
@@ -66,12 +66,12 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
   function processEvaluation(
     evaluation: IEvaluationResult,
     splitName: string,
-    key: SplitIO.SplitKey,
-    attributes: SplitIO.Attributes | undefined,
+    key: SplitKey,
+    attributes: Attributes | undefined,
     withConfig: boolean,
     invokingMethodName: string,
     queue: ImpressionDTO[]
-  ): SplitIO.Treatment | SplitIO.TreatmentWithConfig {
+  ): Treatment | TreatmentWithConfig {
     const isSdkReady = readinessManager.isReady() || readinessManager.isReadyFromCache();
     const matchingKey = getMatching(key);
     const bucketingKey = getBucketing(key);
@@ -107,12 +107,12 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
     return treatment;
   }
 
-  function track(key: SplitIO.SplitKey, trafficTypeName: string, eventTypeId: string, value?: number, properties?: SplitIO.Properties, size = 1024) {
+  function track(key: SplitKey, trafficTypeName: string, eventTypeId: string, value?: number, properties?: Properties, size = 1024) {
     const stopTelemetryTracker = telemetryTracker.trackEval(TRACK);
 
     const matchingKey = getMatching(key);
     const timestamp = Date.now();
-    const eventData: SplitIO.EventData = {
+    const eventData: EventData = {
       eventTypeId,
       trafficTypeName,
       value,
@@ -144,5 +144,5 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
     getTreatmentsWithConfig,
     track,
     isClientSide: false
-  } as SplitIO.IClient | SplitIO.IAsyncClient;
+  } as any;
 }

package/src/sdkClient/clientAttributesDecoration.ts

@@ -1,13 +1,13 @@
 import { AttributesCacheInMemory } from '../storages/inMemory/AttributesCacheInMemory';
 import { validateAttributesDeep } from '../utils/inputValidation/attributes';
-import { SplitIO } from '../types';
-import { ILogger } from '../logger/types';
+import { Attributes, IAsyncClientSS, IClientSS, Properties, SplitKey } from '../types';
+import { ILogger } from '../types';
 import { objectAssign } from '../utils/lang/objectAssign';
 
 /**
  * Add in memory attributes storage methods and combine them with any attribute received from the getTreatment/s call
  */
-export function clientAttributesDecoration<TClient extends SplitIO.IClient | SplitIO.IAsyncClient>(log: ILogger, client: TClient) {
+export function clientAttributesDecoration(log: ILogger, client: IClientSS | IAsyncClientSS) {
 
   const attributeStorage = new AttributesCacheInMemory();
 
@@ -18,27 +18,27 @@ export function clientAttributesDecoration<TClient extends SplitIO.IClient | Spl
   const clientGetTreatmentsWithConfig = client.getTreatmentsWithConfig;
   const clientTrack = client.track;
 
-  function getTreatment(maybeKey: SplitIO.SplitKey, maybeSplit: string, maybeAttributes?: SplitIO.Attributes) {
+  function getTreatment(maybeKey: SplitKey, maybeSplit: string, maybeAttributes?: Attributes) {
     return clientGetTreatment(maybeKey, maybeSplit, combineAttributes(maybeAttributes));
   }
 
-  function getTreatmentWithConfig(maybeKey: SplitIO.SplitKey, maybeSplit: string, maybeAttributes?: SplitIO.Attributes) {
+  function getTreatmentWithConfig(maybeKey: SplitKey, maybeSplit: string, maybeAttributes?: Attributes) {
     return clientGetTreatmentWithConfig(maybeKey, maybeSplit, combineAttributes(maybeAttributes));
   }
 
-  function getTreatments(maybeKey: SplitIO.SplitKey, maybeSplits: string[], maybeAttributes?: SplitIO.Attributes) {
+  function getTreatments(maybeKey: SplitKey, maybeSplits: string[], maybeAttributes?: Attributes) {
     return clientGetTreatments(maybeKey, maybeSplits, combineAttributes(maybeAttributes));
   }
 
-  function getTreatmentsWithConfig(maybeKey: SplitIO.SplitKey, maybeSplits: string[], maybeAttributes?: SplitIO.Attributes) {
+  function getTreatmentsWithConfig(maybeKey: SplitKey, maybeSplits: string[], maybeAttributes?: Attributes) {
     return clientGetTreatmentsWithConfig(maybeKey, maybeSplits, combineAttributes(maybeAttributes));
   }
 
-  function track(maybeKey: SplitIO.SplitKey, maybeTT: string, maybeEvent: string, maybeEventValue?: number, maybeProperties?: SplitIO.Properties) {
+  function track(maybeKey: SplitKey, maybeTT: string, maybeEvent: string, maybeEventValue?: number, maybeProperties?: Properties) {
     return clientTrack(maybeKey, maybeTT, maybeEvent, maybeEventValue, maybeProperties);
   }
 
-  function combineAttributes(maybeAttributes: SplitIO.Attributes | undefined): SplitIO.Attributes | undefined{
+  function combineAttributes(maybeAttributes: Attributes | undefined): Attributes | undefined{
     const storedAttributes = attributeStorage.getAll();
     if (Object.keys(storedAttributes).length > 0) {
       return objectAssign({}, storedAttributes, maybeAttributes);

package/src/sdkClient/clientCS.ts

@@ -1,6 +1,5 @@
 import { objectAssign } from '../utils/lang/objectAssign';
-import { ILogger } from '../logger/types';
-import { SplitIO } from '../types';
+import { IClientSS, IClientWithKeyLegacy, ILogger, SplitKey } from '../types';
 import { clientAttributesDecoration } from './clientAttributesDecoration';
 
 
@@ -11,7 +10,7 @@ import { clientAttributesDecoration } from './clientAttributesDecoration';
  * @param key validated split key
  * @param trafficType validated traffic type
  */
-export function clientCSDecorator(log: ILogger, client: SplitIO.IClient, key: SplitIO.SplitKey, trafficType?: string): SplitIO.ICsClient {
+export function clientCSDecorator(log: ILogger, client: IClientSS, key: SplitKey, trafficType?: string): IClientWithKeyLegacy {
 
   let clientCS = clientAttributesDecoration(log, client);
 
@@ -26,5 +25,5 @@ export function clientCSDecorator(log: ILogger, client: SplitIO.IClient, key: Sp
     track: trafficType ? clientCS.track.bind(clientCS, key, trafficType) : clientCS.track.bind(clientCS, key),
 
     isClientSide: true
-  }) as SplitIO.ICsClient;
+  }) as any;
 }

package/src/sdkClient/clientInputValidation.ts

@@ -15,14 +15,14 @@ import { startsWith } from '../utils/lang';
 import { CONTROL, CONTROL_WITH_CONFIG } from '../utils/constants';
 import { IReadinessManager } from '../readiness/types';
 import { MaybeThenable } from '../dtos/types';
-import { ISettings, SplitIO } from '../types';
+import { ISettings, SplitKey, Treatments, TreatmentsWithConfig, Properties, Attributes, IClientSS, IAsyncClientSS } from '../types';
 import { isStorageSync } from '../trackers/impressionObserver/utils';
 
 /**
  * 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 function clientInputValidationDecorator<TClient extends SplitIO.IClient | SplitIO.IAsyncClient>(settings: ISettings, client: TClient, readinessManager: IReadinessManager): TClient {
+export function clientInputValidationDecorator(settings: ISettings, client: IClientSS | IAsyncClientSS, readinessManager: IReadinessManager): IClientSS | IAsyncClientSS {
 
   const log = settings.log;
   const isSync = isStorageSync(settings);
@@ -30,7 +30,7 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
   /**
    * Avoid repeating this validations code
    */
-  function validateEvaluationParams(maybeKey: SplitIO.SplitKey, maybeSplitOrSplits: string | string[], maybeAttributes: SplitIO.Attributes | undefined, methodName: string) {
+  function validateEvaluationParams(maybeKey: SplitKey, maybeSplitOrSplits: string | string[], maybeAttributes: Attributes | undefined, methodName: string) {
     const multi = startsWith(methodName, 'getTreatments');
     const key = validateKey(log, maybeKey, methodName);
     const splitOrSplits = multi ? validateSplits(log, maybeSplitOrSplits, methodName) : validateSplit(log, maybeSplitOrSplits, methodName);
@@ -53,53 +53,53 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
     return isSync ? value : Promise.resolve(value);
   }
 
-  function getTreatment(maybeKey: SplitIO.SplitKey, maybeSplit: string, maybeAttributes?: SplitIO.Attributes) {
+  function getTreatment(maybeKey: SplitKey, maybeSplit: string, maybeAttributes?: Attributes) {
     const params = validateEvaluationParams(maybeKey, maybeSplit, maybeAttributes, 'getTreatment');
 
     if (params.valid) {
-      return client.getTreatment(params.key as SplitIO.SplitKey, params.splitOrSplits as string, params.attributes as SplitIO.Attributes | undefined);
+      return client.getTreatment(params.key as SplitKey, params.splitOrSplits as string, params.attributes as Attributes | undefined);
     } else {
       return wrapResult(CONTROL);
     }
   }
 
-  function getTreatmentWithConfig(maybeKey: SplitIO.SplitKey, maybeSplit: string, maybeAttributes?: SplitIO.Attributes) {
+  function getTreatmentWithConfig(maybeKey: SplitKey, maybeSplit: string, maybeAttributes?: Attributes) {
     const params = validateEvaluationParams(maybeKey, maybeSplit, maybeAttributes, 'getTreatmentWithConfig');
 
     if (params.valid) {
-      return client.getTreatmentWithConfig(params.key as SplitIO.SplitKey, params.splitOrSplits as string, params.attributes as SplitIO.Attributes | undefined);
+      return client.getTreatmentWithConfig(params.key as SplitKey, params.splitOrSplits as string, params.attributes as Attributes | undefined);
     } else {
       return wrapResult(objectAssign({}, CONTROL_WITH_CONFIG));
     }
   }
 
-  function getTreatments(maybeKey: SplitIO.SplitKey, maybeSplits: string[], maybeAttributes?: SplitIO.Attributes) {
+  function getTreatments(maybeKey: SplitKey, maybeSplits: string[], maybeAttributes?: Attributes) {
     const params = validateEvaluationParams(maybeKey, maybeSplits, maybeAttributes, 'getTreatments');
 
     if (params.valid) {
-      return client.getTreatments(params.key as SplitIO.SplitKey, params.splitOrSplits as string[], params.attributes as SplitIO.Attributes | undefined);
+      return client.getTreatments(params.key as SplitKey, params.splitOrSplits as string[], params.attributes as Attributes | undefined);
     } else {
-      const res: SplitIO.Treatments = {};
+      const res: Treatments = {};
       if (params.splitOrSplits) (params.splitOrSplits as string[]).forEach((split: string) => res[split] = CONTROL);
 
       return wrapResult(res);
     }
   }
 
-  function getTreatmentsWithConfig(maybeKey: SplitIO.SplitKey, maybeSplits: string[], maybeAttributes?: SplitIO.Attributes) {
+  function getTreatmentsWithConfig(maybeKey: SplitKey, maybeSplits: string[], maybeAttributes?: Attributes) {
     const params = validateEvaluationParams(maybeKey, maybeSplits, maybeAttributes, 'getTreatmentsWithConfig');
 
     if (params.valid) {
-      return client.getTreatmentsWithConfig(params.key as SplitIO.SplitKey, params.splitOrSplits as string[], params.attributes as SplitIO.Attributes | undefined);
+      return client.getTreatmentsWithConfig(params.key as SplitKey, params.splitOrSplits as string[], params.attributes as Attributes | undefined);
     } else {
-      const res: SplitIO.TreatmentsWithConfig = {};
+      const res: TreatmentsWithConfig = {};
       if (params.splitOrSplits) (params.splitOrSplits as string[]).forEach(split => res[split] = objectAssign({}, CONTROL_WITH_CONFIG));
 
       return wrapResult(res);
     }
   }
 
-  function track(maybeKey: SplitIO.SplitKey, maybeTT: string, maybeEvent: string, maybeEventValue?: number, maybeProperties?: SplitIO.Properties) {
+  function track(maybeKey: SplitKey, maybeTT: string, maybeEvent: string, maybeEventValue?: number, maybeProperties?: Properties) {
     const key = validateKey(log, maybeKey, 'track');
     const tt = validateTrafficType(log, maybeTT, 'track');
     const event = validateEvent(log, maybeEvent, 'track');
@@ -120,5 +120,5 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
     getTreatments,
     getTreatmentsWithConfig,
     track
-  } as TClient;
+  } as IClientSS | IAsyncClientSS;
 }

package/src/sdkClient/sdkClient.ts

@@ -1,5 +1,5 @@
 import { objectAssign } from '../utils/lang/objectAssign';
-import { IStatusInterface, SplitIO } from '../types';
+import { IBasicClient, IStatusInterface } from '../types';
 import { releaseApiKey } from '../utils/inputValidation/apiKey';
 import { clientFactory } from './client';
 import { clientInputValidationDecorator } from './clientInputValidation';
@@ -8,7 +8,7 @@ import { ISdkFactoryContext } from '../sdkFactory/types';
 /**
  * Creates an Sdk client, i.e., a base client with status and destroy interface
  */
-export function sdkClientFactory(params: ISdkFactoryContext, isSharedClient?: boolean): SplitIO.IClient | SplitIO.IAsyncClient {
+export function sdkClientFactory(params: ISdkFactoryContext, isSharedClient?: boolean): IBasicClient {
   const { sdkReadinessManager, syncManager, storage, signalListener, settings, telemetryTracker } = params;
 
   return objectAssign(

package/src/sdkClient/sdkClientMethod.ts

@@ -1,4 +1,4 @@
-import { SplitIO } from '../types';
+import { IBasicClient } from '../types';
 import { sdkClientFactory } from './sdkClient';
 import { RETRIEVE_CLIENT_DEFAULT } from '../logger/constants';
 import { ISdkFactoryContext } from '../sdkFactory/types';
@@ -6,7 +6,7 @@ import { ISdkFactoryContext } from '../sdkFactory/types';
 /**
  * Factory of client method for server-side SDKs (ISDK and IAsyncSDK)
  */
-export function sdkClientMethodFactory(params: ISdkFactoryContext): () => SplitIO.IClient | SplitIO.IAsyncClient {
+export function sdkClientMethodFactory(params: ISdkFactoryContext): () => IBasicClient {
   const log = params.settings.log;
   const clientInstance = sdkClientFactory(params);