@splitsoftware/splitio-commons 1.6.2-rc.1 → 1.6.2-rc.4

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, AttributeType, 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);
@@ -57,10 +57,10 @@ export function clientAttributesDecoration<TClient extends SplitIO.IClient | Spl
      * Add an attribute to client's in memory attributes storage
      *
      * @param {string} attributeName Attrinute name
-     * @param {string, number, boolean, list} attributeValue Attribute value
+     * @param {AttributeType} attributeValue Attribute value
      * @returns {boolean} true if the attribute was stored and false otherways
      */
-    setAttribute(attributeName: string, attributeValue: Object) {
+    setAttribute(attributeName: string, attributeValue: AttributeType) {
       const attribute: Record<string, Object> = {};
       attribute[attributeName] = attributeValue;
       if (!validateAttributesDeep(log, attribute, 'setAttribute')) return false;
@@ -85,7 +85,7 @@ export function clientAttributesDecoration<TClient extends SplitIO.IClient | Spl
      * @param {Object} attributes Object with attributes to store
      * @returns true if attributes were stored an false otherways
      */
-    setAttributes(attributes: Record<string, Object>) {
+    setAttributes(attributes: Record<string, AttributeType>) {
       if (!validateAttributesDeep(log, attributes, 'setAttributes')) return false;
       return attributeStorage.setAttributes(attributes);
     },
@@ -95,7 +95,7 @@ export function clientAttributesDecoration<TClient extends SplitIO.IClient | Spl
      *
      * @returns {Object} returns all the stored attributes
      */
-    getAttributes(): Record<string, Object> {
+    getAttributes(): Record<string, AttributeType> {
       return attributeStorage.getAll();
     },
 

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, IClientWithKey, 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) {
 
   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 IClientWithKey;
 }

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);
 

package/src/sdkClient/sdkClientMethodCS.ts

@@ -1,5 +1,5 @@
 import { clientCSDecorator } from './clientCS';
-import { SplitIO } from '../types';
+import { IClientSS, IClientWithKey, SplitKey } from '../types';
 import { validateKey } from '../utils/inputValidation/key';
 import { getMatching, keyParser } from '../utils/key';
 import { sdkClientFactory } from './sdkClient';
@@ -9,7 +9,7 @@ import { RETRIEVE_CLIENT_DEFAULT, NEW_SHARED_CLIENT, RETRIEVE_CLIENT_EXISTING }
 import { SDK_SEGMENTS_ARRIVED } from '../readiness/constants';
 import { ISdkFactoryContext } from '../sdkFactory/types';
 
-function buildInstanceId(key: SplitIO.SplitKey) {
+function buildInstanceId(key: SplitKey) {
   // @ts-ignore
   return `${key.matchingKey ? key.matchingKey : key}-${key.bucketingKey ? key.bucketingKey : key}-`;
 }
@@ -20,23 +20,23 @@ const method = 'Client instantiation';
  * 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 function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: SplitIO.SplitKey) => SplitIO.ICsClient {
+export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: SplitKey) => IClientWithKey {
   const { storage, syncManager, sdkReadinessManager, settings: { core: { key }, startup: { readyTimeout }, log } } = params;
 
   const mainClientInstance = clientCSDecorator(
     log,
-    sdkClientFactory(params) as SplitIO.IClient,
-    key
+    sdkClientFactory(params) as IClientSS,
+    key!
   );
 
-  const parsedDefaultKey = keyParser(key);
+  const parsedDefaultKey = keyParser(key!);
   const defaultInstanceId = buildInstanceId(parsedDefaultKey);
 
   // Cache instances created per factory.
-  const clientInstances: Record<string, SplitIO.ICsClient> = {};
+  const clientInstances: Record<string, IClientWithKey> = {};
   clientInstances[defaultInstanceId] = mainClientInstance;
 
-  return function client(key?: SplitIO.SplitKey) {
+  return function client(key?: SplitKey) {
     if (key === undefined) {
       log.debug(RETRIEVE_CLIENT_DEFAULT);
       return mainClientInstance;
@@ -76,7 +76,7 @@ export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: Spl
           storage: sharedStorage || storage,
           syncManager: sharedSyncManager,
           signalListener: undefined, // only the main client "destroy" method stops the signal listener
-        }), true) as SplitIO.IClient,
+        }), true) as IClientSS,
         validKey
       );
 

package/src/sdkClient/sdkClientMethodCSWithTT.ts

@@ -1,5 +1,5 @@
 import { clientCSDecorator } from './clientCS';
-import { SplitIO } from '../types';
+import { IClientSS, IClientWithKey, SplitKey } from '../types';
 import { validateKey } from '../utils/inputValidation/key';
 import { validateTrafficType } from '../utils/inputValidation/trafficType';
 import { getMatching, keyParser } from '../utils/key';
@@ -10,7 +10,7 @@ import { RETRIEVE_CLIENT_DEFAULT, NEW_SHARED_CLIENT, RETRIEVE_CLIENT_EXISTING }
 import { SDK_SEGMENTS_ARRIVED } from '../readiness/constants';
 import { ISdkFactoryContext } from '../sdkFactory/types';
 
-function buildInstanceId(key: SplitIO.SplitKey, trafficType?: string) {
+function buildInstanceId(key: SplitKey, trafficType?: string) {
   // @ts-ignore
   return `${key.matchingKey ? key.matchingKey : key}-${key.bucketingKey ? key.bucketingKey : key}-${trafficType !== undefined ? trafficType : ''}`;
 }
@@ -22,24 +22,24 @@ const method = 'Client instantiation';
  * 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 function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: SplitIO.SplitKey, trafficType?: string) => SplitIO.ICsClient {
+export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: SplitKey, trafficType?: string) => IClientWithKey {
   const { storage, syncManager, sdkReadinessManager, settings: { core: { key, trafficType }, startup: { readyTimeout }, log } } = params;
 
   const mainClientInstance = clientCSDecorator(
     log,
-    sdkClientFactory(params) as SplitIO.IClient,
-    key,
+    sdkClientFactory(params) as IClientSS,
+    key!,
     trafficType
   );
 
-  const parsedDefaultKey = keyParser(key);
+  const parsedDefaultKey = keyParser(key!);
   const defaultInstanceId = buildInstanceId(parsedDefaultKey, trafficType);
 
   // Cache instances created per factory.
-  const clientInstances: Record<string, SplitIO.ICsClient> = {};
+  const clientInstances: Record<string, IClientWithKey> = {};
   clientInstances[defaultInstanceId] = mainClientInstance;
 
-  return function client(key?: SplitIO.SplitKey, trafficType?: string) {
+  return function client(key?: SplitKey, trafficType?: string) {
     if (key === undefined) {
       log.debug(RETRIEVE_CLIENT_DEFAULT);
       return mainClientInstance;
@@ -86,7 +86,7 @@ export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: Spl
           storage: sharedStorage || storage,
           syncManager: sharedSyncManager,
           signalListener: undefined, // only the main client "destroy" method stops the signal listener
-        }), true) as SplitIO.IClient,
+        }), true) as IClientSS,
         validKey,
         validTrafficType
       );