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

package/src/{splitio.d.ts → types.d.ts}

@@ -4,489 +4,368 @@
 // Definitions by: Nico Zelaya <https://github.com/NicoZelaya/>
 
 /// <reference types="google.analytics" />
-import { RedisOptions } from 'ioredis';
 
 export as namespace SplitIO;
 export = SplitIO;
 
+/****** Exposed namespace ******/
 /**
- * NodeJS.EventEmitter interface
- * @see {@link https://nodejs.org/api/events.html}
- */
-interface EventEmitter {
-  addListener(event: string | symbol, listener: (...args: any[]) => void): this;
-  on(event: string | symbol, listener: (...args: any[]) => void): this;
-  once(event: string | symbol, listener: (...args: any[]) => void): this;
-  removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
-  off(event: string | symbol, listener: (...args: any[]) => void): this;
-  removeAllListeners(event?: string | symbol): this;
-  setMaxListeners(n: number): this;
-  getMaxListeners(): number;
-  listeners(event: string | symbol): Function[];
-  rawListeners(event: string | symbol): Function[];
-  emit(event: string | symbol, ...args: any[]): boolean;
-  listenerCount(type: string | symbol): number;
-  // Added in Node 6...
-  prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
-  prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
-  eventNames(): Array<string | symbol>;
-}
-/**
- * @typedef {Object} EventConsts
- * @property {string} SDK_READY The ready event.
- * @property {string} SDK_READY_FROM_CACHE The ready event when fired with cached data.
- * @property {string} SDK_READY_TIMED_OUT The timeout event.
- * @property {string} SDK_UPDATE The update event.
- */
-type EventConsts = {
-  SDK_READY: 'init::ready',
-  SDK_READY_FROM_CACHE: 'init::cache-ready',
-  SDK_READY_TIMED_OUT: 'init::timeout',
-  SDK_UPDATE: 'state::update'
-};
-/**
- * SDK Modes.
- * @typedef {string} SDKMode
- */
-type SDKMode = 'standalone' | 'consumer';
-/**
- * Storage types.
- * @typedef {string} StorageType
- */
-type StorageType = 'MEMORY' | 'LOCALSTORAGE' | 'REDIS';
-/**
- * Settings interface. This is a representation of the settings the SDK expose, that's why
- * most of it's props are readonly. Only features should be rewritten when localhost mode is active.
- * @interface ISettings
- */
-interface ISettings {
-  readonly core: {
-    authorizationKey: string,
-    key: SplitIO.SplitKey,
-    trafficType: string,
-    labelsEnabled: boolean,
-    IPAddressesEnabled: boolean
-  },
-  readonly mode: SDKMode,
-  readonly scheduler: {
-    featuresRefreshRate: number,
-    impressionsRefreshRate: number,
-    impressionsQueueSize: number,
-    /**
-     * @deprecated
-     */
-    metricsRefreshRate?: number,
-    telemetryRefreshRate: number,
-    segmentsRefreshRate: number,
-    offlineRefreshRate: number,
-    eventsPushRate: number,
-    eventsQueueSize: number,
-    pushRetryBackoffBase: number
-  },
-  readonly startup: {
-    readyTimeout: number,
-    requestTimeoutBeforeReady: number,
-    retriesOnFailureBeforeReady: number,
-    eventsFirstPushWindow: number
-  },
-  readonly storage: {
-    prefix: string,
-    options: Object,
-    type: StorageType
-  },
-  readonly urls: {
-    events: string,
-    sdk: string,
-    auth: string,
-    streaming: string,
-    telemetry: string
-  },
-  readonly debug: boolean | LogLevel,
-  readonly version: string,
-  /**
-   * Mocked features map if using in browser, or mocked features file path string if using in NodeJS.
-   */
-  features: SplitIO.MockedFeaturesMap | SplitIO.MockedFeaturesFilePath,
-  readonly streamingEnabled: boolean,
-  readonly sync: {
-    splitFilters: SplitIO.SplitFilter[],
-    impressionsMode: SplitIO.ImpressionsMode,
-    enabled: boolean
-  }
-  /**
-   * User consent status if using in browser. Undefined if using in NodeJS.
-   */
-  readonly userConsent?: SplitIO.ConsentStatus
-}
-/**
- * Log levels.
- * @typedef {string} LogLevel
- */
-type LogLevel = 'DEBUG' | 'INFO' | 'WARN' | 'ERROR' | 'NONE';
-/**
- * Logger API
- * @interface ILoggerAPI
+ * Types and interfaces for @splitsoftware/splitio package for usage when integrating javascript sdk on typescript apps.
+ * For the SDK package information
+ * @see {@link https://www.npmjs.com/package/@splitsoftware/splitio}
  */
-interface ILoggerAPI {
-  /**
-   * Enables SDK logging to the console.
-   * @function enable
-   * @returns {void}
-   */
-  enable(): void,
-  /**
-   * Disables SDK logging.
-   * @function disable
-   * @returns {void}
-   */
-  disable(): void,
-  /**
-   * Sets a log level for the SDK logs.
-   * @function setLogLevel
-   * @returns {void}
-   */
-  setLogLevel(logLevel: LogLevel): void,
+declare namespace SplitIO {
   /**
-   * Log level constants. Use this to pass them to setLogLevel function.
-   */
-  LogLevel: {
-    [level in LogLevel]: LogLevel
+   * Reduced version of NodeJS.EventEmitter interface with the minimal methods used by the SDK
+   * @see {@link https://nodejs.org/api/events.html}
+   */
+  interface IEventEmitter {
+    addListener(event: string, listener: (...args: any[]) => void): this
+    on(event: string, listener: (...args: any[]) => void): this
+    once(event: string, listener: (...args: any[]) => void): this
+    removeListener(event: string, listener: (...args: any[]) => void): this
+    off(event: string, listener: (...args: any[]) => void): this
+    removeAllListeners(event?: string): this
+    emit(event: string, ...args: any[]): boolean
   }
-}
-/**
- * User consent API
- * @interface IUserConsentAPI
- */
-interface IUserConsentAPI {
-  /**
-   * Set or update the user consent status. Possible values are `true` and `false`, which represent user consent `'GRANTED'` and `'DECLINED'` respectively.
-   * - `true ('GRANTED')`: the user has granted consent for tracking events and impressions. The SDK will send them to Split cloud.
-   * - `false ('DECLINED')`: the user has declined consent for tracking events and impressions. The SDK will not send them to Split cloud.
-   *
-   * NOTE: calling this method updates the user consent at a factory level, affecting all clients of the same factory.
-   *
-   * @function setStatus
-   * @param {boolean} userConsent The user consent status, true for 'GRANTED' and false for 'DECLINED'.
-   * @returns {boolean} Whether the provided param is a valid value (i.e., a boolean value) or not.
-   */
-  setStatus(userConsent: boolean): boolean;
   /**
-   * Get the user consent status.
-   *
-   * @function getStatus
-   * @returns {ConsentStatus} The user consent status.
-   */
-  getStatus(): SplitIO.ConsentStatus;
+   * NodeJS.EventEmitter interface
+   * @see {@link https://nodejs.org/api/events.html}
+   */
+  interface EventEmitter extends IEventEmitter {
+    addListener(event: string, listener: (...args: any[]) => void): this;
+    on(event: string, listener: (...args: any[]) => void): this;
+    once(event: string, listener: (...args: any[]) => void): this;
+    removeListener(event: string, listener: (...args: any[]) => void): this;
+    off(event: string, listener: (...args: any[]) => void): this;
+    removeAllListeners(event?: string): this;
+    setMaxListeners(n: number): this;
+    getMaxListeners(): number;
+    listeners(event: string): Function[];
+    rawListeners(event: string): Function[];
+    emit(event: string, ...args: any[]): boolean;
+    listenerCount(type: string): number;
+    // Added in Node 6...
+    prependListener(event: string, listener: (...args: any[]) => void): this;
+    prependOnceListener(event: string, listener: (...args: any[]) => void): this;
+    eventNames(): Array<string | symbol>;
+  }
+
   /**
-   * Consent status constants. Use this to compare with the getStatus function result.
+   * impression DTO generated by the Sdk client when processing evaluations
    */
-  Status: {
-    [status in SplitIO.ConsentStatus]: SplitIO.ConsentStatus
+  type ImpressionDTO = {
+    feature: string,
+    keyName: string,
+    treatment: string,
+    time: number,
+    bucketingKey?: string,
+    label: string,
+    changeNumber: number,
+    pt?: number,
   }
-}
-/**
- * Common settings between Browser and NodeJS settings interface.
- * @interface ISharedSettings
- */
-interface ISharedSettings {
   /**
-   * Whether the logger should be enabled or disabled by default.
-   * @property {Boolean} debug
-   * @default false
-   */
-  debug?: boolean | LogLevel,
+   * @typedef {Object} EventConsts
+   * @property {string} SDK_READY The ready event.
+   * @property {string} SDK_READY_FROM_CACHE The ready event when fired with cached data.
+   * @property {string} SDK_READY_TIMED_OUT The timeout event.
+   * @property {string} SDK_UPDATE The update event.
+   */
+  type EventConsts = {
+    SDK_READY: 'init::ready',
+    SDK_READY_FROM_CACHE: 'init::cache-ready',
+    SDK_READY_TIMED_OUT: 'init::timeout',
+    SDK_UPDATE: 'state::update'
+  };
   /**
-   * The impression listener, which is optional. Whatever you provide here needs to comply with the SplitIO.IImpressionListener interface,
-   * which will check for the logImpression method.
-   * @property {IImpressionListener} impressionListener
-   * @default undefined
+   * SDK Modes.
+   * @typedef {string} SDKMode
    */
-  impressionListener?: SplitIO.IImpressionListener,
+  type SDKMode = 'standalone' | 'localhost' | 'consumer' | 'consumer_partial';
   /**
-   * Boolean flag to enable the streaming service as default synchronization mechanism. In the event of any issue with streaming,
-   * the SDK would fallback to the polling mechanism. If false, the SDK would poll for changes as usual without attempting to use streaming.
-   * @property {boolean} streamingEnabled
-   * @default true
+   * Storage types.
+   * @typedef {string} StorageType
    */
-  streamingEnabled?: boolean,
+  type StorageType = 'MEMORY' | 'LOCALSTORAGE' | 'REDIS' | 'PLUGGABLE';
   /**
-   * SDK synchronization settings.
-   * @property {Object} sync
+   * Settings interface. This is a representation of the settings the SDK expose, that's why
+   * most of it's props are readonly. Only features should be rewritten when localhost mode is active.
+   * @interface ISettings
    */
-  sync?: {
-    /**
-     * List of Split filters. These filters are used to fetch a subset of the Splits definitions in your environment, in order to reduce the delay of the SDK to be ready.
-     * This configuration is only meaningful when the SDK is working in "standalone" mode.
-     *
-     * At the moment, two types of split filters are supported: by name and by prefix.
-     *
-     * Example:
-     *  `splitFilter: [
-     *    { type: 'byName', values: ['my_split_1', 'my_split_2'] }, // will fetch splits named 'my_split_1' and 'my_split_2'
-     *    { type: 'byPrefix', values: ['testing'] } // will fetch splits whose names start with 'testing__' prefix
-     *  ]`
-     * @property {SplitIO.SplitFilter[]} splitFilters
-     */
-    splitFilters?: SplitIO.SplitFilter[]
-    /**
-     * Impressions Collection Mode. Option to determine how impressions are going to be sent to Split Servers.
-     * Possible values are 'DEBUG' and 'OPTIMIZED'.
-     * - DEBUG: will send all the impressions generated (recommended only for debugging purposes).
-     * - OPTIMIZED: will send unique impressions to Split Servers avoiding a considerable amount of traffic that duplicated impressions could generate.
-     * @property {string} impressionsMode
-     * @default 'OPTIMIZED'
-     */
-    impressionsMode?: SplitIO.ImpressionsMode,
+  interface ISettings {
+    readonly core: {
+      authorizationKey: string,
+      key?: SplitKey,
+      trafficType?: string,
+      labelsEnabled: boolean,
+      IPAddressesEnabled?: boolean
+    },
+    readonly mode: SDKMode,
+    readonly scheduler: {
+      featuresRefreshRate: number,
+      impressionsRefreshRate: number,
+      impressionsQueueSize: number,
+      /**
+       * @deprecated
+       */
+      metricsRefreshRate?: number,
+      telemetryRefreshRate: number,
+      segmentsRefreshRate: number,
+      offlineRefreshRate: number,
+      eventsPushRate: number,
+      eventsQueueSize: number,
+      pushRetryBackoffBase: number
+    },
+    readonly startup: {
+      readyTimeout: number,
+      requestTimeoutBeforeReady: number,
+      retriesOnFailureBeforeReady: number,
+      eventsFirstPushWindow: number
+    },
+    readonly storage: {
+      prefix: string,
+      options: Object,
+      type: StorageType
+    } | StorageSyncFactory | StorageAsyncFactory,
+    readonly urls: {
+      events: string,
+      sdk: string,
+      auth: string,
+      streaming: string,
+      telemetry: string
+    },
+    readonly integrations?: BrowserIntegration[] | IntegrationFactory[],
+    readonly debug: boolean | LogLevel | ILogger,
+    readonly version: string,
+    /**
+     * Mocked features map.
+     */
+    features?: MockedFeaturesMap | MockedFeaturesFilePath,
+    readonly streamingEnabled: boolean,
+    readonly sync: {
+      splitFilters: SplitFilter[],
+      impressionsMode: ImpressionsMode,
+      enabled: boolean,
+      localhostMode?: LocalhostFactory,
+      __splitFiltersValidation: ISplitFiltersValidation,
+    },
+    readonly runtime: {
+      ip: string | false
+      hostname: string | false
+    },
+    readonly log: ILogger
+    readonly impressionListener?: unknown
     /**
-     * Controls the SDK continuous synchronization flags.
-     *
-     * When `true` a running SDK will process rollout plan updates performed on the UI (default).
-     * When false it'll just fetch all data upon init.
-     *
-     * @property {boolean} enabled
-     * @default true
+     * User consent status if using in browser. Undefined if using in NodeJS.
      */
-    enabled?: boolean
+    readonly userConsent?: ConsentStatus
   }
-}
-/**
- * Common settings interface for SDK instances on NodeJS.
- * @interface INodeBasicSettings
- * @extends ISharedSettings
- */
-interface INodeBasicSettings extends ISharedSettings {
   /**
-   * SDK Startup settings for NodeJS.
-   * @property {Object} startup
+   * Log levels.
+   * @typedef {string} LogLevel
    */
-  startup?: {
+  type LogLevel = 'DEBUG' | 'INFO' | 'WARN' | 'ERROR' | 'NONE';
+  /**
+   * Logger API
+   * @interface ILoggerAPI
+   */
+  interface ILoggerAPI {
     /**
-     * Maximum amount of time used before notify a timeout.
-     * @property {number} readyTimeout
-     * @default 15
+     * Enables SDK logging to the console.
+     * @function enable
+     * @returns {void}
      */
-    readyTimeout?: number,
+    enable(): void,
     /**
-     * Time to wait for a request before the SDK is ready. If this time expires, JS Sdk will retry 'retriesOnFailureBeforeReady' times before notifying its failure to be 'ready'.
-     * @property {number} requestTimeoutBeforeReady
-     * @default 15
+     * Disables SDK logging.
+     * @function disable
+     * @returns {void}
      */
-    requestTimeoutBeforeReady?: number,
+    disable(): void,
     /**
-     * How many quick retries we will do while starting up the SDK.
-     * @property {number} retriesOnFailureBeforeReady
-     * @default 1
+     * Sets a log level for the SDK logs.
+     * @function setLogLevel
+     * @returns {void}
      */
-    retriesOnFailureBeforeReady?: number,
+    setLogLevel(logLevel: LogLevel): void,
     /**
-     * For SDK posts the queued events data in bulks with a given rate, but the first push window is defined separately,
-     * to better control on browsers. This number defines that window before the first events push.
-     *
-     * @property {number} eventsFirstPushWindow
-     * @default 0
+     * Log level constants. Use this to pass them to setLogLevel function.
      */
-    eventsFirstPushWindow?: number,
-  },
+    LogLevel: {
+      [level in LogLevel]: LogLevel
+    }
+  }
   /**
-   * SDK scheduler settings.
-   * @property {Object} scheduler
+   * User consent API
+   * @interface IUserConsentAPI
    */
-  scheduler?: {
-    /**
-     * The SDK polls Split servers for changes to feature roll-out plans. This parameter controls this polling period in seconds.
-     * @property {number} featuresRefreshRate
-     * @default 5
-     */
-    featuresRefreshRate?: number,
+  interface IUserConsentAPI {
     /**
-     * The SDK sends information on who got what treatment at what time back to Split servers to power analytics. This parameter controls how often this data is sent to Split servers. The parameter should be in seconds.
-     * @property {number} impressionsRefreshRate
-     * @default 300
+     * Set or update the user consent status. Possible values are `true` and `false`, which represent user consent `'GRANTED'` and `'DECLINED'` respectively.
+     * - `true ('GRANTED')`: the user has granted consent for tracking events and impressions. The SDK will send them to Split cloud.
+     * - `false ('DECLINED')`: the user has declined consent for tracking events and impressions. The SDK will not send them to Split cloud.
+     *
+     * NOTE: calling this method updates the user consent at a factory level, affecting all clients of the same factory.
+     *
+     * @function setStatus
+     * @param {boolean} userConsent The user consent status, true for 'GRANTED' and false for 'DECLINED'.
+     * @returns {boolean} Whether the provided param is a valid value (i.e., a boolean value) or not.
      */
-    impressionsRefreshRate?: number,
+    setStatus(userConsent: boolean): boolean;
     /**
-     * The maximum number of impression items we want to queue. If we queue more values, it will trigger a flush and reset the timer.
-     * If you use a 0 here, the queue will have no maximum size.
-     * @property {number} impressionsQueueSize
-     * @default 30000
+     * Get the user consent status.
+     *
+     * @function getStatus
+     * @returns {ConsentStatus} The user consent status.
      */
-    impressionsQueueSize?: number,
+    getStatus(): ConsentStatus;
     /**
-     * The SDK sends diagnostic metrics to Split servers. This parameters controls this metric flush period in seconds.
-     * @property {number} metricsRefreshRate
-     * @default 120
-     * @deprecated This parameter is ignored now. Use `telemetryRefreshRate` instead.
+     * Consent status constants. Use this to compare with the getStatus function result.
      */
-    metricsRefreshRate?: number,
+    Status: {
+      [status in ConsentStatus]: ConsentStatus
+    }
+  }
+  /**
+   * Common settings between Browser and NodeJS settings interface.
+   * @interface ISharedSettings
+   */
+  interface ISharedSettings {
     /**
-     * The SDK sends diagnostic metrics to Split servers. This parameters controls this metric flush period in seconds.
-     * @property {number} telemetryRefreshRate
-     * @default 3600
+     * SDK Core settings.
+     * @property {Object} core
      */
-    telemetryRefreshRate?: number,
+    core: {
+      /**
+       * Your API key. More information: @see {@link https://help.split.io/hc/en-us/articles/360019916211-API-keys}
+       * @property {string} authorizationKey
+       */
+      authorizationKey: string,
+      /**
+       * Disable labels from being sent to Split backend. Labels may contain sensitive information.
+       * This configuration is applicable if the SDK is running in "standalone" or "partial consumer" mode.
+       * @property {boolean} labelsEnabled
+       * @default true
+       */
+      labelsEnabled?: boolean
+    },
     /**
-     * The SDK polls Split servers for changes to segment definitions. This parameter controls this polling period in seconds.
-     * @property {number} segmentsRefreshRate
-     * @default 60
+     * The SDK mode. Possible values are "standalone", which is the default when using a synchronous storage, like 'MEMORY' and 'LOCALSTORAGE',
+     * and "consumer", which must be set when using an asynchronous storage, like 'REDIS'. For "localhost" mode, use "localhost" as authorizationKey.
+     * @property {SDKMode} mode
+     * @default standalone
      */
-    segmentsRefreshRate?: number,
+    mode?: SDKMode,
     /**
-     * The SDK posts the queued events data in bulks. This parameter controls the posting rate in seconds.
-     * @property {number} eventsPushRate
-     * @default 60
+     * The impression listener, which is optional. Whatever you provide here needs to comply with the IImpressionListener interface,
+     * which will check for the logImpression method.
+     * @property {IImpressionListener} impressionListener
+     * @default undefined
      */
-    eventsPushRate?: number,
+    impressionListener?: IImpressionListener,
     /**
-     * The maximum number of event items we want to queue. If we queue more values, it will trigger a flush and reset the timer.
-     * If you use a 0 here, the queue will have no maximum size.
-     * @property {number} eventsQueueSize
-     * @default 500
+     * Boolean flag to enable the streaming service as default synchronization mechanism. In the event of any issue with streaming,
+     * the SDK would fallback to the polling mechanism. If false, the SDK would poll for changes as usual without attempting to use streaming.
+     * This configuration is applicable if the SDK is running in "standalone" mode.
+     * @property {boolean} streamingEnabled
+     * @default true
      */
-    eventsQueueSize?: number,
+    streamingEnabled?: boolean,
     /**
-     * For mocking/testing only. The SDK will refresh the features mocked data when mode is set to "localhost" by defining the key.
-     * For more information @see {@link https://help.split.io/hc/en-us/articles/360020564931-Node-js-SDK#localhost-mode}
-     * @property {number} offlineRefreshRate
-     * @default 15
+     * SDK synchronization settings.
+     * @property {Object} sync
      */
-    offlineRefreshRate?: number
+    sync?: {
+      /**
+       * List of Split filters. These filters are used to fetch a subset of the Splits definitions in your environment, in order to reduce the delay of the SDK to be ready.
+       * This configuration is applicable if the SDK is running in "standalone" mode.
+       *
+       * At the moment, two types of split filters are supported: by name and by prefix.
+       *
+       * Example:
+       *  `splitFilter: [
+       *    { type: 'byName', values: ['my_split_1', 'my_split_2'] }, // will fetch splits named 'my_split_1' and 'my_split_2'
+       *    { type: 'byPrefix', values: ['testing'] } // will fetch splits whose names start with 'testing__' prefix
+       *  ]`
+       * @property {SplitFilter[]} splitFilters
+       */
+      splitFilters?: SplitFilter[]
+      /**
+       * Impressions Collection Mode. Option to determine how impressions are going to be sent to Split Servers.
+       * Possible values are 'DEBUG' and 'OPTIMIZED'.
+       * - DEBUG: will send all the impressions generated (recommended only for debugging purposes).
+       * - OPTIMIZED: will send unique impressions to Split Servers avoiding a considerable amount of traffic that duplicated impressions could generate.
+       * @property {string} impressionsMode
+       * @default 'OPTIMIZED'
+       */
+      impressionsMode?: ImpressionsMode,
+      /**
+       * Controls the SDK continuous synchronization flags.
+       *
+       * When `true` a running SDK will process rollout plan updates performed on the UI (default).
+       * When false it'll just fetch all data upon init.
+       * This configuration is applicable if the SDK is running in "standalone" mode.
+       *
+       * @property {boolean} enabled
+       * @default true
+       */
+      enabled?: boolean
+    },
     /**
-     * When using streaming mode, seconds to wait before re attempting to connect for push notifications.
-     * Next attempts follow intervals in power of two: base seconds, base x 2 seconds, base x 4 seconds, ...
-     * @property {number} pushRetryBackoffBase
-     * @default 1
+     * List of URLs that the SDK will use as base for it's synchronization functionalities.
+     * This configuration is applicable if the SDK is running in "standalone" or "partial consumer" mode.
+     * Do not change these settings unless you're working an advanced use case, like connecting to the Split proxy.
+     * @property {Object} urls
      */
-    pushRetryBackoffBase?: number,
-  },
+    urls?: UrlSettings,
+  }
+  // @TODO Should extends IEventEmitter for React Native and JS Browser SDK
   /**
-   * SDK Core settings for NodeJS.
-   * @property {Object} core
+   * Common API for entities that expose status handlers.
+   * @interface IStatusInterface
+   * @extends IEventEmitter
    */
-  core: {
-    /**
-     * Your API key. More information: @see {@link https://help.split.io/hc/en-us/articles/360019916211-API-keys}
-     * @property {string} authorizationKey
-     */
-    authorizationKey: string,
+  interface IStatusInterface extends IEventEmitter {
     /**
-     * Disable labels from being sent to Split backend. Labels may contain sensitive information.
-     * @property {boolean} labelsEnabled
-     * @default true
+     * Constant object containing the SDK events for you to use.
+     * @property {EventConsts} Event
      */
-    labelsEnabled?: boolean
+    Event: EventConsts,
     /**
-     * Disable machine IP and Name from being sent to Split backend.
-     * @property {boolean} IPAddressesEnabled
-     * @default true
+     * Returns a promise that will be resolved once the SDK has finished loading (SDK_READY event emitted) or rejected if the SDK has timedout (SDK_READY_TIMED_OUT event emitted).
+     * As it's meant to provide similar flexibility to the event approach, given that the SDK might be eventually ready after a timeout event, calling the `ready` method after the
+     * SDK had timed out will return a new promise that should eventually resolve if the SDK gets ready.
+     *
+     * Caveats: the method was designed to avoid an unhandled Promise rejection if the rejection case is not handled, so that `onRejected` handler is optional when using promises.
+     * However, when using async/await syntax, the rejection should be explicitly propagated like in the following example:
+     * ```
+     * try {
+     *   await client.ready().catch((e) => { throw e; });
+     *   // SDK is ready
+     * } catch(e) {
+     *   // SDK has timedout
+     * }
+     * ```
+     *
+     * @function ready
+     * @returns {Promise<void>}
      */
-    IPAddressesEnabled?: boolean
-  },
+    ready(): Promise<void>
+  }
   /**
-   * Defines which kind of storage we should instantiate.
-   * @property {Object} storage
+   * Common definitions between clients for different environments interface.
+   * @interface IBasicClient
+   * @extends IStatusInterface
    */
-  storage?: {
-    /**
-     * Storage type to be instantiated by the SDK.
-     * @property {StorageType} type
-     * @default MEMORY
-     */
-    type?: StorageType,
+  interface IBasicClient extends IStatusInterface {
     /**
-     * Options to be passed to the selected storage.
-     * @property {Object} options
+     * Destroy the client instance.
+     * @function destroy
+     * @returns {Promise<void>}
      */
-    options?: Object,
-    /**
-     * Optional prefix to prevent any kind of data collision between SDK versions.
-     * @property {string} prefix
-     * @default SPLITIO
-     */
-    prefix?: string
-  },
-  /**
-   * The SDK mode. Possible values are "standalone", which is the default when using a synchronous storage, like 'MEMORY' and 'LOCALSTORAGE',
-   * and "consumer", which must be set when using an asynchronous storage, like 'REDIS'. For "localhost" mode, use "localhost" as authorizationKey.
-   * @property {SDKMode} mode
-   * @default standalone
-   */
-  mode?: SDKMode,
-  /**
-   * Mocked features file path. For testing purposses only. For using this you should specify "localhost" as authorizationKey on core settings.
-   * @see {@link https://help.split.io/hc/en-us/articles/360020564931-Node-js-SDK#localhost-mode}
-   * @property {MockedFeaturesFilePath} features
-   * @default $HOME/.split
-   */
-  features?: SplitIO.MockedFeaturesFilePath,
-}
-/**
- * Common API for entities that expose status handlers.
- * @interface IStatusInterface
- * @extends EventEmitter
- */
-interface IStatusInterface extends EventEmitter {
-  /**
-   * Constant object containing the SDK events for you to use.
-   * @property {EventConsts} Event
-   */
-  Event: EventConsts,
-  /**
-   * Returns a promise that will be resolved once the SDK has finished loading (SDK_READY event emitted) or rejected if the SDK has timedout (SDK_READY_TIMED_OUT event emitted).
-   * As it's meant to provide similar flexibility to the event approach, given that the SDK might be eventually ready after a timeout event, calling the `ready` method after the
-   * SDK had timed out will return a new promise that should eventually resolve if the SDK gets ready.
-   *
-   * Caveats: the method was designed to avoid an unhandled Promise rejection if the rejection case is not handled, so that `onRejected` handler is optional when using promises.
-   * However, when using async/await syntax, the rejection should be explicitly propagated like in the following example:
-   * ```
-   * try {
-   *   await client.ready().catch((e) => { throw e; });
-   *   // SDK is ready
-   * } catch(e) {
-   *   // SDK has timedout
-   * }
-   * ```
-   *
-   * @function ready
-   * @returns {Promise<void>}
-   */
-  ready(): Promise<void>
-}
-/**
- * Common definitions between clients for different environments interface.
- * @interface IBasicClient
- * @extends IStatusInterface
- */
-interface IBasicClient extends IStatusInterface {
-  /**
-   * Destroy the client instance.
-   * @function destroy
-   * @returns {Promise<void>}
-   */
-  destroy(): Promise<void>
-}
-/**
- * Common definitions between SDK instances for different environments interface.
- * @interface IBasicSDK
- */
-interface IBasicSDK {
-  /**
-   * Current settings of the SDK instance.
-   * @property settings
-   */
-  settings: ISettings,
-  /**
-   * Logger API.
-   * @property Logger
-   */
-  Logger: ILoggerAPI
-}
-/****** Exposed namespace ******/
-/**
- * Types and interfaces for @splitsoftware/splitio package for usage when integrating javascript sdk on typescript apps.
- * For the SDK package information
- * @see {@link https://www.npmjs.com/package/@splitsoftware/splitio}
- */
-declare namespace SplitIO {
+    destroy(): Promise<void>
+  }
+
   /**
    * Split treatment value, returned by getTreatment.
    * @typedef {string} Treatment
@@ -509,7 +388,7 @@ declare namespace SplitIO {
     [featureName: string]: Treatment
   };
   /**
-   * Split treatments promise that will resolve to the actual SplitIO.Treatments object.
+   * Split treatments promise that will resolve to the actual Treatments object.
    * @typedef {Promise<Treatments>} AsyncTreatments
    */
   type AsyncTreatments = Promise<Treatments>;
@@ -541,7 +420,7 @@ declare namespace SplitIO {
     [featureName: string]: TreatmentWithConfig
   };
   /**
-   * Split treatments promise that will resolve to the actual SplitIO.TreatmentsWithConfig object.
+   * Split treatments promise that will resolve to the actual TreatmentsWithConfig object.
    * @typedef {Promise<TreatmentsWithConfig>} AsyncTreatmentsWithConfig
    */
   type AsyncTreatmentsWithConfig = Promise<TreatmentsWithConfig>;
@@ -596,25 +475,21 @@ declare namespace SplitIO {
   type MockedFeaturesMap = {
     [featureName: string]: string | TreatmentWithConfig
   };
+  /**
+   * Localhost types.
+   * @typedef {string} LocalhostType
+   */
+  type LocalhostType = 'LocalhostFromObject'
   /**
    * Object with information about an impression. It contains the generated impression DTO as well as
    * complementary information around where and how it was generated in that way.
    * @typedef {Object} ImpressionData
    */
   type ImpressionData = {
-    impression: {
-      feature: string,
-      keyName: string,
-      treatment: string,
-      time: number,
-      bucketingKey?: string,
-      label: string,
-      changeNumber: number,
-      pt?: number,
-    },
-    attributes?: SplitIO.Attributes,
-    ip: string,
-    hostname: string,
+    impression: ImpressionDTO,
+    attributes?: Attributes,
+    ip: string | false,
+    hostname: string | false,
     sdkLanguageVersion: string
   };
   /**
@@ -662,11 +537,11 @@ declare namespace SplitIO {
    */
   type SplitViewAsync = Promise<SplitView | null>;
   /**
-   * An array containing the SplitIO.SplitView elements.
+   * An array containing the SplitView elements.
    */
   type SplitViews = Array<SplitView>;
   /**
-   * A promise that will be resolved with an SplitIO.SplitViews array.
+   * A promise that will be resolved with an SplitViews array.
    * @typedef {Promise<SplitViews>} SplitViewsAsync
    */
   type SplitViewsAsync = Promise<SplitViews>;
@@ -695,6 +570,68 @@ declare namespace SplitIO {
    * @typedef {string} BrowserStorage
    */
   type BrowserStorage = 'MEMORY' | 'LOCALSTORAGE';
+  /**
+   * Storage for synchronous (standalone) SDK.
+   * Its interface details are not part of the public API.
+   */
+  type StorageSync = any;
+  /**
+   * Storage builder for synchronous (standalone) SDK.
+   * By returning undefined, the SDK will use the default IN MEMORY storage.
+   * Input parameter details are not part of the public API.
+   */
+  type StorageSyncFactory = {
+    readonly type: StorageType
+    (params: any): (StorageSync | undefined)
+  }
+  /**
+   * Configuration params for `InLocalStorage`
+   */
+  type InLocalStorageOptions = {
+    /**
+     * Optional prefix to prevent any kind of data collision when having multiple factories using the same storage type.
+     * @property {string} prefix
+     * @default SPLITIO
+     */
+    prefix?: string
+  }
+  /**
+   * Storage for asynchronous (consumer) SDK.
+   * Its interface details are not part of the public API.
+   */
+  type StorageAsync = any
+  /**
+   * Storage builder for asynchronous (consumer) SDK.
+   * Input parameter details are not part of the public API.
+   */
+  type StorageAsyncFactory = {
+    readonly type: StorageType
+    (params: any): StorageAsync
+  }
+  /**
+   * Configuration params for `PluggableStorage`
+   */
+  type PluggableStorageOptions = {
+    /**
+     * Optional prefix to prevent any kind of data collision when having multiple factories using the same storage wrapper.
+     * @property {string} prefix
+     * @default SPLITIO
+     */
+    prefix?: string,
+    /**
+     * Storage wrapper.
+     * @property {Object} wrapper
+     */
+    wrapper: Object
+  }
+  /**
+   * Localhost mode factory.
+   * Its interface details are not part of the public API.
+   */
+  type LocalhostFactory = {
+    readonly type: LocalhostType
+    (params: any): any
+  }
   /**
    * Impression listener interface. This is the interface that needs to be implemented
    * by the element you provide to the SDK as impression listener.
@@ -702,7 +639,21 @@ declare namespace SplitIO {
    * @see {@link https://help.split.io/hc/en-us/articles/360020564931-Node-js-SDK#listener}
    */
   interface IImpressionListener {
-    logImpression(data: SplitIO.ImpressionData): void
+    logImpression(data: ImpressionData): void
+  }
+  /**
+   * SDK integration instance.
+   * Its interface details are not part of the public API.
+   */
+  type Integration = any;
+  /**
+   * SDK integration factory.
+   * By returning an integration, the SDK will queue events and impressions into it.
+   * Input parameter details are not part of the public API.
+   */
+  type IntegrationFactory = {
+    readonly type: string
+    (params: any): (Integration | void)
   }
   /**
    * A pair of user key and it's trafficType, required for tracking valid Split events.
@@ -731,8 +682,15 @@ declare namespace SplitIO {
    *
    * @see {@link https://help.split.io/hc/en-us/articles/360040838752#google-analytics-to-split}
    */
-  interface IGoogleAnalyticsToSplitConfig {
+  interface IGoogleAnalyticsToSplitConfig extends GoogleAnalyticsToSplitOptions {
     type: 'GOOGLE_ANALYTICS_TO_SPLIT',
+  }
+  /**
+   * Configuration params for 'Google Analytics to Split' integration plugin, to track Google Analytics hits as Split events.
+   *
+   * @see {@link https://help.split.io/hc/en-us/articles/360040838752#google-analytics-to-split}
+   */
+  interface GoogleAnalyticsToSplitOptions {
     /**
      * Optional flag to filter GA hits from being tracked as Split events.
      * @property {boolean} hits
@@ -759,7 +717,7 @@ declare namespace SplitIO {
      *      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
@@ -768,7 +726,7 @@ declare namespace SplitIO {
     prefix?: string,
     /**
      * List of Split identities (key & traffic type pairs) used to track events.
-     * If not provided, events are sent using the key and traffic type provided at SDK config
+     * If not provided, events are sent using the key and traffic type provided at SDK config.
      */
     identities?: Identity[],
     /**
@@ -789,14 +747,21 @@ declare namespace SplitIO {
    * @property {string} type The type of Split data, either 'IMPRESSION' or 'EVENT'.
    * @property {ImpressionData | EventData} payload The data instance itself.
    */
-  type IntegrationData = { type: 'IMPRESSION', payload: SplitIO.ImpressionData } | { type: 'EVENT', payload: SplitIO.EventData };
+  type IntegrationData = { type: 'IMPRESSION', payload: ImpressionData } | { type: 'EVENT', payload: EventData };
   /**
    * Enable 'Split to Google Analytics' integration, to track Split impressions and events as Google Analytics hits.
    *
    * @see {@link https://help.split.io/hc/en-us/articles/360040838752#split-to-google-analytics}
    */
-  interface ISplitToGoogleAnalyticsConfig {
+  interface ISplitToGoogleAnalyticsConfig extends SplitToGoogleAnalyticsOptions {
     type: 'SPLIT_TO_GOOGLE_ANALYTICS',
+  }
+  /**
+   * Configuration params for 'Split to Google Analytics' integration plugin, to track Split impressions and events as Google Analytics hits.
+   *
+   * @see {@link https://help.split.io/hc/en-us/articles/360040838752#split-to-google-analytics}
+   */
+  interface SplitToGoogleAnalyticsOptions {
     /**
      * Optional flag to filter Split impressions from being tracked as GA hits.
      * @property {boolean} impressions
@@ -814,7 +779,7 @@ declare namespace SplitIO {
      * 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:
@@ -845,7 +810,7 @@ declare namespace SplitIO {
      *    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.
@@ -912,6 +877,11 @@ declare namespace SplitIO {
      */
     values: string[],
   }
+  type ISplitFiltersValidation = {
+    queryString: string | null,
+    groupedFilters: Record<SplitFilterType, string[]>,
+    validFilters: SplitFilter[]
+  };
   /**
   * ImpressionsMode type
   * @typedef {string} ImpressionsMode
@@ -923,31 +893,117 @@ declare namespace SplitIO {
    */
   type ConsentStatus = 'GRANTED' | 'DECLINED' | 'UNKNOWN';
   /**
-   * Settings interface for SDK instances created on the browser
-   * @interface IBrowserSettings
+   * Logger
+   * Its interface details are not part of the public API. It shouldn't be used directly.
+   * @interface ILogger
+   */
+  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
+  }
+  /**
+   * Common settings interface with non-pluggable API (JS SDK).
+   * @interface IStaticSettings
+   * @extends ISharedSettings
+   */
+  interface IStaticSettings {
+    /**
+     * Whether the logger should be enabled or disabled by default.
+     * @property {Boolean} debug
+     * @default false
+     */
+    debug?: boolean | LogLevel,
+  }
+  /**
+   * Common settings interface with pluggable API (JS Browser and React Native SDKs).
+   * @interface IPluggableSettings
+   * @extends ISharedSettings
+   */
+  interface IPluggableSettings {
+    /**
+     * Boolean value to indicate whether the logger should be enabled or disabled by default, or a log level string or a Logger object.
+     * Passing a logger object is required to get descriptive log messages. Otherwise most logs will print with message codes.
+     * @see {@link https://help.split.io/hc/en-us/articles/360058730852-Browser-SDK#logging}
+     *
+     * Examples:
+     * ```typescript
+     * config.debug = true
+     * config.debug = 'WARN'
+     * config.debug = ErrorLogger()
+     * ```
+     * @property {boolean | LogLevel | ILogger} debug
+     * @default false
+     */
+    debug?: boolean | LogLevel | ILogger,
+    /**
+     * Defines an optional list of factory functions used to instantiate SDK integrations.
+     *
+     * Example:
+     * ```typescript
+     * SplitFactory({
+     *   ...
+     *   integrations: [SplitToGoogleAnalytics(), GoogleAnalyticsToSplit()]
+     * })
+     * ```
+     * @property {Object} integrations
+     */
+    integrations?: IntegrationFactory[],
+  }
+  /**
+   * Common settings interface for SDK instances on NodeJS.
+   * @interface IServerSideSharedSettings
    * @extends ISharedSettings
-   * @see {@link https://help.split.io/hc/en-us/articles/360020448791-JavaScript-SDK#configuration}
    */
-  interface IBrowserSettings extends ISharedSettings {
+  interface IServerSideSharedSettings extends ISharedSettings {
     /**
-     * SDK Startup settings for the Browser.
+     * SDK Core settings for NodeJS.
+     * @property {Object} core
+     */
+    core: ISharedSettings['core'] & {
+      /**
+       * Disable machine IP and Name from being sent to Split backend.
+       * @property {boolean} IPAddressesEnabled
+       * @default true
+       */
+      IPAddressesEnabled?: boolean
+    },
+    /**
+     * Mocked features file path. For testing purposses only. For using this you should specify "localhost" as authorizationKey on core settings.
+     * @see {@link https://help.split.io/hc/en-us/articles/360020564931-Node-js-SDK#localhost-mode}
+     * @property {MockedFeaturesFilePath} features
+     * @default $HOME/.split
+     */
+    features?: MockedFeaturesFilePath,
+    /**
+     * SDK Startup settings for NodeJS.
      * @property {Object} startup
      */
     startup?: {
       /**
        * Maximum amount of time used before notify a timeout.
        * @property {number} readyTimeout
-       * @default 1.5
+       * @default 15
        */
       readyTimeout?: number,
       /**
        * Time to wait for a request before the SDK is ready. If this time expires, JS Sdk will retry 'retriesOnFailureBeforeReady' times before notifying its failure to be 'ready'.
+       *
+       * NOTE: this param is applicable in "standalone" mode.
        * @property {number} requestTimeoutBeforeReady
-       * @default 1.5
+       * @default 15
        */
       requestTimeoutBeforeReady?: number,
       /**
        * How many quick retries we will do while starting up the SDK.
+       *
+       * NOTE: this param is applicable in "standalone" mode.
        * @property {number} retriesOnFailureBeforeReady
        * @default 1
        */
@@ -956,8 +1012,9 @@ declare namespace SplitIO {
        * For SDK posts the queued events data in bulks with a given rate, but the first push window is defined separately,
        * to better control on browsers. This number defines that window before the first events push.
        *
+       * NOTE: this param is ignored in "consumer" mode.
        * @property {number} eventsFirstPushWindow
-       * @default 10
+       * @default 0
        */
       eventsFirstPushWindow?: number,
     },
@@ -968,19 +1025,33 @@ declare namespace SplitIO {
     scheduler?: {
       /**
        * The SDK polls Split servers for changes to feature roll-out plans. This parameter controls this polling period in seconds.
+       *
+       * NOTE: this param is applicable in "standalone" mode.
        * @property {number} featuresRefreshRate
-       * @default 30
+       * @default 5
        */
       featuresRefreshRate?: number,
+      /**
+       * The SDK polls Split servers for changes to segment definitions. This parameter controls this polling period in seconds.
+       *
+       * NOTE: this param is applicable in "standalone" mode.
+       * @property {number} segmentsRefreshRate
+       * @default 60
+       */
+      segmentsRefreshRate?: number,
       /**
        * The SDK sends information on who got what treatment at what time back to Split servers to power analytics. This parameter controls how often this data is sent to Split servers. The parameter should be in seconds.
+       *
+       * NOTE: this param is ignored in "consumer" mode.
        * @property {number} impressionsRefreshRate
-       * @default 60
+       * @default 300
        */
       impressionsRefreshRate?: number,
       /**
        * The maximum number of impression items we want to queue. If we queue more values, it will trigger a flush and reset the timer.
        * If you use a 0 here, the queue will have no maximum size.
+       *
+       * NOTE: this param is ignored in "consumer" mode.
        * @property {number} impressionsQueueSize
        * @default 30000
        */
@@ -994,18 +1065,16 @@ declare namespace SplitIO {
       metricsRefreshRate?: number,
       /**
        * The SDK sends diagnostic metrics to Split servers. This parameters controls this metric flush period in seconds.
+       *
+       * NOTE: this param is ignored in "consumer" mode.
        * @property {number} telemetryRefreshRate
        * @default 3600
        */
       telemetryRefreshRate?: number,
-      /**
-       * The SDK polls Split servers for changes to segment definitions. This parameter controls this polling period in seconds.
-       * @property {number} segmentsRefreshRate
-       * @default 60
-       */
-      segmentsRefreshRate?: number,
       /**
        * The SDK posts the queued events data in bulks. This parameter controls the posting rate in seconds.
+       *
+       * NOTE: this param is ignored in "consumer" mode.
        * @property {number} eventsPushRate
        * @default 60
        */
@@ -1013,52 +1082,46 @@ declare namespace SplitIO {
       /**
        * The maximum number of event items we want to queue. If we queue more values, it will trigger a flush and reset the timer.
        * If you use a 0 here, the queue will have no maximum size.
+       *
+       * NOTE: this param is ignored in "consumer" mode.
        * @property {number} eventsQueueSize
        * @default 500
        */
       eventsQueueSize?: number,
       /**
        * For mocking/testing only. The SDK will refresh the features mocked data when mode is set to "localhost" by defining the key.
-       * For more information @see {@link https://help.split.io/hc/en-us/articles/360020448791-JavaScript-SDK#localhost-mode}
+       * For more information @see {@link https://help.split.io/hc/en-us/articles/360020564931-Node-js-SDK#localhost-mode}
        * @property {number} offlineRefreshRate
        * @default 15
        */
-      offlineRefreshRate?: number,
+      offlineRefreshRate?: number
       /**
        * When using streaming mode, seconds to wait before re attempting to connect for push notifications.
        * Next attempts follow intervals in power of two: base seconds, base x 2 seconds, base x 4 seconds, ...
+       *
+       * NOTE: this param is applicable in "standalone" mode.
        * @property {number} pushRetryBackoffBase
        * @default 1
        */
       pushRetryBackoffBase?: number,
     },
+  }
+  /**
+   * Common settings interface for SDK instances created on client-side (Browser & React Native).
+   * @interface IClientSideSharedSettings
+   * @extends ISharedSettings
+   */
+  interface IClientSideSharedSettings extends ISharedSettings {
     /**
-     * SDK Core settings for the browser.
+     * SDK Core settings for client-side.
      * @property {Object} core
      */
-    core: {
-      /**
-       * Your API key. More information: @see {@link https://help.split.io/hc/en-us/articles/360019916211-API-keys}
-       * @property {string} authorizationKey
-       */
-      authorizationKey: string,
+    core: ISharedSettings['core'] & {
       /**
        * Customer identifier. Whatever this means to you. @see {@link https://help.split.io/hc/en-us/articles/360019916311-Traffic-type}
        * @property {SplitKey} key
        */
       key: SplitKey,
-      /**
-       * Traffic type associated with the customer identifier. @see {@link https://help.split.io/hc/en-us/articles/360019916311-Traffic-type}
-       * If no provided as a setting it will be required on the client.track() calls.
-       * @property {string} trafficType
-       */
-      trafficType?: string,
-      /**
-       * Disable labels from being sent to Split backend. Labels may contain sensitive information.
-       * @property {boolean} labelsEnabled
-       * @default true
-       */
-      labelsEnabled?: boolean
     },
     /**
      * Mocked features map. For testing purposses only. For using this you should specify "localhost" as authorizationKey on core settings.
@@ -1066,268 +1129,188 @@ declare namespace SplitIO {
      */
     features?: MockedFeaturesMap,
     /**
-     * Defines which kind of storage we can instantiate on the browser.
-     * Possible storage types are 'MEMORY', which is the default, and 'LOCALSTORAGE'.
-     * @property {Object} storage
+     * SDK Startup settings for client-side.
+     * @property {Object} startup
      */
-    storage?: {
+    startup?: {
       /**
-       * Storage type to be instantiated by the SDK.
-       * @property {BrowserStorage} type
-       * @default MEMORY
+       * Maximum amount of time used before notify a timeout.
+       * @property {number} readyTimeout
+       * @default 1.5
        */
-      type?: BrowserStorage,
+      readyTimeout?: number,
       /**
-       * Optional prefix to prevent any kind of data collision between SDK versions.
-       * @property {string} prefix
-       * @default SPLITIO
+       * Time to wait for a request before the SDK is ready. If this time expires, JS Sdk will retry 'retriesOnFailureBeforeReady' times before notifying its failure to be 'ready'.
+       *
+       * NOTE: this param is applicable in "standalone" mode.
+       * @property {number} requestTimeoutBeforeReady
+       * @default 1.5
        */
-      prefix?: string
-    },
-    /**
-     * List of URLs that the SDK will use as base for it's synchronization functionalities, applicable only when running as standalone.
-     * Do not change these settings unless you're working an advanced use case, like connecting to the Split proxy.
-     * @property {Object} urls
-     */
-    urls?: UrlSettings,
-    /**
-     * SDK integration settings for the Browser.
-     * @property {Object} integrations
-     */
-    integrations?: BrowserIntegration[],
-    /**
-     * User consent status. Possible values are `'GRANTED'`, which is the default, `'DECLINED'` or `'UNKNOWN'`.
-     * - `'GRANTED'`: the user grants consent for tracking events and impressions. The SDK sends them to Split cloud.
-     * - `'DECLINED'`: the user declines consent for tracking events and impressions. The SDK does not send them to Split cloud.
-     * - `'UNKNOWN'`: the user neither grants nor declines consent for tracking events and impressions. The SDK tracks them in its internal storage, and eventually either sends
-     * them or not if the consent status is updated to 'GRANTED' or 'DECLINED' respectively. The status can be updated at any time with the `UserConsent.setStatus` factory method.
-     *
-     * @typedef {string} userConsent
-     * @default 'GRANTED'
-     */
-    userConsent?: ConsentStatus
-  }
-  /**
-   * Settings interface for SDK instances created on NodeJS.
-   * If your storage is asynchronous (Redis for example) use SplitIO.INodeAsyncSettings instead.
-   * @interface INodeSettings
-   * @extends INodeBasicSettings
-   * @see {@link https://help.split.io/hc/en-us/articles/360020564931-Node-js-SDK#configuration}
-   */
-  interface INodeSettings extends INodeBasicSettings {
-    /**
-     * List of URLs that the SDK will use as base for it's synchronization functionalities, applicable only when running as standalone.
-     * Do not change these settings unless you're working an advanced use case, like connecting to the Split proxy.
-     * @property {Object} urls
-     */
-    urls?: UrlSettings,
-    /**
-     * Defines which kind of storage we can instantiate on NodeJS for 'standalone' mode.
-     * The only possible storage type is 'MEMORY', which is the default.
-     * @property {Object} storage
-     */
-    storage?: {
+      requestTimeoutBeforeReady?: number,
       /**
-       * Synchronous storage type to be instantiated by the SDK.
-       * @property {NodeSyncStorage} type
-       * @default MEMORY
+       * How many quick retries we will do while starting up the SDK.
+       *
+       * NOTE: this param is applicable in "standalone" mode.
+       * @property {number} retriesOnFailureBeforeReady
+       * @default 1
        */
-      type?: NodeSyncStorage,
+      retriesOnFailureBeforeReady?: number,
       /**
-       * Optional prefix to prevent any kind of data collision between SDK versions.
-       * @property {string} prefix
-       * @default SPLITIO
+       * For SDK posts the queued events data in bulks with a given rate, but the first push window is defined separately,
+       * to better control on browsers. This number defines that window before the first events push.
+       *
+       * NOTE: this param is ignored in "consumer" mode.
+       * @property {number} eventsFirstPushWindow
+       * @default 10
        */
-      prefix?: string
+      eventsFirstPushWindow?: number,
     },
     /**
-     * The SDK mode. When using the default 'MEMORY' storage, the only possible value is "standalone", which is the default.
-     * For "localhost" mode, use "localhost" as authorizationKey.
-     *
-     * @property {'standalone'} mode
-     * @default standalone
-     */
-    mode?: 'standalone'
-  }
-  /**
-   * Settings interface with async storage for SDK instances created on NodeJS.
-   * If your storage is synchronous (by defaut we use memory, which is sync) use SplitIO.INodeSettings instead.
-   * @interface INodeAsyncSettings
-   * @extends INodeBasicSettings
-   * @see {@link https://help.split.io/hc/en-us/articles/360020564931-Node-js-SDK#configuration}
-   */
-  interface INodeAsyncSettings extends INodeBasicSettings {
-    /**
-     * Defines which kind of async storage we can instantiate on NodeJS for 'consumer' mode.
-     * The only possible storage type is 'REDIS'.
-     * @property {Object} storage
+     * SDK scheduler settings.
+     * @property {Object} scheduler
      */
-    storage: {
+    scheduler?: {
       /**
-       * 'REDIS' storage type to be instantiated by the SDK.
-       * @property {NodeAsyncStorage} type
+       * The SDK polls Split servers for changes to feature roll-out plans. This parameter controls this polling period in seconds.
+       *
+       * NOTE: this param is applicable in "standalone" mode.
+       * @property {number} featuresRefreshRate
+       * @default 30
        */
-      type: NodeAsyncStorage,
+      featuresRefreshRate?: number,
       /**
-       * Options to be passed to the Redis storage. Use it with storage type: 'REDIS'.
-       * @property {Object} options
+       * The SDK polls Split servers for changes to segment definitions. This parameter controls this polling period in seconds.
+       *
+       * NOTE: this param is applicable in "standalone" mode.
+       * @property {number} segmentsRefreshRate
+       * @default 60
        */
-      options?: {
-        /**
-         * Redis URL. If set, `host`, `port`, `db` and `pass` params will be ignored.
-         *
-         * Examples:
-         * ```
-         *   url: 'localhost'
-         *   url: '127.0.0.1:6379'
-         *   url: 'redis://:authpassword@127.0.0.1:6379/0'
-         * ```
-         * @property {string=} url
-         */
-        url?: string,
-        /**
-         * Redis host.
-         * @property {string=} host
-         * @default 'localhost'
-         */
-        host?: string,
-        /**
-         * Redis port.
-         * @property {number=} port
-         * @default 6379
-         */
-        port?: number,
-        /**
-         * Redis database to be used.
-         * @property {number=} db
-         * @default 0
-         */
-        db?: number,
-        /**
-         * Redis password. Don't define if no password is used.
-         * @property {string=} pass
-         * @default undefined
-         */
-        pass?: string,
-        /**
-         * The milliseconds before a timeout occurs during the initial connection to the Redis server.
-         * @property {number=} connectionTimeout
-         * @default 10000
-         */
-        connectionTimeout?: number,
-        /**
-         * The milliseconds before Redis commands are timeout by the SDK.
-         * Method calls that involve Redis commands, like `client.getTreatment` or `client.track` calls, are resolved when the commands success or timeout.
-         * @property {number=} operationTimeout
-         * @default 5000
-         */
-        operationTimeout?: number,
-        /**
-         * TLS configuration for Redis connection.
-         * @see {@link https://www.npmjs.com/package/ioredis#tls-options }
-         *
-         * @property {Object=} tls
-         * @default undefined
-         */
-        tls?: RedisOptions['tls'],
-      },
+      segmentsRefreshRate?: number,
       /**
-       * Optional prefix to prevent any kind of data collision between SDK versions.
-       * @property {string} prefix
-       * @default SPLITIO
+       * The SDK sends information on who got what treatment at what time back to Split servers to power analytics. This parameter controls how often this data is sent to Split servers. The parameter should be in seconds.
+       *
+       * NOTE: this param is ignored in "consumer" mode.
+       * @property {number} impressionsRefreshRate
+       * @default 60
        */
-      prefix?: string
-    },
+      impressionsRefreshRate?: number,
+      /**
+       * The maximum number of impression items we want to queue. If we queue more values, it will trigger a flush and reset the timer.
+       * If you use a 0 here, the queue will have no maximum size.
+       *
+       * NOTE: this param is ignored in "consumer" mode.
+       * @property {number} impressionsQueueSize
+       * @default 30000
+       */
+      impressionsQueueSize?: number,
+      /**
+       * The SDK sends diagnostic metrics to Split servers. This parameters controls this metric flush period in seconds.
+       * @property {number} metricsRefreshRate
+       * @default 120
+       * @deprecated This parameter is ignored now. Use `telemetryRefreshRate` instead.
+       */
+      metricsRefreshRate?: number,
+      /**
+       * The SDK sends diagnostic metrics to Split servers. This parameters controls this metric flush period in seconds.
+       *
+       * NOTE: this param is ignored in "consumer" mode.
+       * @property {number} telemetryRefreshRate
+       * @default 3600
+       */
+      telemetryRefreshRate?: number,
+      /**
+       * The SDK posts the queued events data in bulks. This parameter controls the posting rate in seconds.
+       *
+       * NOTE: this param is ignored in "consumer" mode.
+       * @property {number} eventsPushRate
+       * @default 60
+       */
+      eventsPushRate?: number,
+      /**
+       * The maximum number of event items we want to queue. If we queue more values, it will trigger a flush and reset the timer.
+       * If you use a 0 here, the queue will have no maximum size.
+       *
+       * NOTE: this param is ignored in "consumer" mode.
+       * @property {number} eventsQueueSize
+       * @default 500
+       */
+      eventsQueueSize?: number,
+      /**
+       * For mocking/testing only. The SDK will refresh the features mocked data when mode is set to "localhost" by defining the key.
+       * For more information @see {@link https://help.split.io/hc/en-us/articles/360020448791-JavaScript-SDK#localhost-mode}
+       * @property {number} offlineRefreshRate
+       * @default 15
+       */
+      offlineRefreshRate?: number,
+      /**
+       * When using streaming, seconds to wait before re attempting to connect for push notifications.
+       * Next attempts follow intervals in power of two: base seconds, base x 2 seconds, base x 4 seconds, ...
+       *
+       * NOTE: this param is applicable in "standalone" mode.
+       * @property {number} pushRetryBackoffBase
+       * @default 1
+       */
+      pushRetryBackoffBase?: number,
+    }
     /**
-     * The SDK mode. When using 'REDIS' storage type, the only possible value is "consumer", which is required.
-     *
-     * @see {@link https://help.split.io/hc/en-us/articles/360020564931-Node-js-SDK#state-sharing-redis-integration}
+     * User consent status. Possible values are `'GRANTED'`, which is the default, `'DECLINED'` or `'UNKNOWN'`.
+     * - `'GRANTED'`: the user grants consent for tracking events and impressions. The SDK sends them to Split cloud.
+     * - `'DECLINED'`: the user declines consent for tracking events and impressions. The SDK does not send them to Split cloud.
+     * - `'UNKNOWN'`: the user neither grants nor declines consent for tracking events and impressions. The SDK tracks them in its internal storage, and eventually either sends
+     * them or not if the consent status is updated to 'GRANTED' or 'DECLINED' respectively. The status can be updated at any time with the `UserConsent.setStatus` factory method.
      *
-     * @property {'consumer'} mode
+     * @typedef {string} userConsent
+     * @default 'GRANTED'
      */
-    mode: 'consumer'
+    userConsent?: ConsentStatus
   }
   /**
-   * This represents the interface for the SDK instance with synchronous storage.
-   * @interface ISDK
-   * @extends IBasicSDK
+   * Common definitions between SDK instances for different environments interface.
+   * @interface IBasicSDK
    */
-  interface ISDK extends IBasicSDK {
+  interface IBasicSDK<TClient, TManager> {
     /**
      * Returns the default client instance of the SDK.
      * @function client
      * @returns {IClient} The client instance.
      */
-    client(): IClient,
-    /**
-     * Returns a shared client of the SDK. For usage on the browser.
-     * @function client
-     * @param {SplitKey} key The key for the new client instance.
-     * @param {string=} trafficType The traffic type of the provided key.
-     * @returns {IClient} The client instance.
-     */
-    client(key: SplitKey, trafficType?: string): IClient,
+    client(): TClient,
     /**
      * Returns a manager instance of the SDK to explore available information.
      * @function manager
      * @returns {IManager} The manager instance.
      */
-    manager(): IManager
-  }
-  /**
-   * This represents the interface for the SDK instance with synchronous storage.
-   * @interface ISDK
-   * @extends IBasicSDK
-   */
-  interface IBrowserSDK extends ISDK {
-    /**
-     * Returns the default client instance of the SDK.
-     * @function client
-     * @returns {IBrowserClient} The client instance.
-     */
-    client(): IBrowserClient,
+    manager(): TManager
     /**
-     * Returns a shared client of the SDK. For usage on the browser.
-     * @function client
-     * @param {SplitKey} key The key for the new client instance.
-     * @param {string=} trafficType The traffic type of the provided key.
-     * @returns {IBrowserClient} The client instance.
+     * Current settings of the SDK instance.
+     * @property settings
      */
-    client(key: SplitKey, trafficType?: string): IBrowserClient
+    settings: ISettings,
     /**
-     * User consent API.
-     * @property UserConsent
+     * Logger API.
+     * @property Logger
      */
-    UserConsent: IUserConsentAPI
+    Logger: ILoggerAPI
   }
   /**
-   * This represents the interface for the SDK instance with asynchronous storage.
-   * @interface IAsyncSDK
-   * @extends IBasicSDK
+   * Common interface between client-side SDK instances.
+   * @interface ISDKCs
    */
-  interface IAsyncSDK extends IBasicSDK {
+  interface ISDKWithUserConsent<TClient, TManager> extends IBasicSDK<TClient, TManager> {
     /**
-     * Returns the default client instance of the SDK.
-     * @function client
-     * @returns {IAsyncClient} The asynchronous client instance.
-     */
-    client(): IAsyncClient,
-    /**
-     * Returns a manager instance of the SDK to explore available information.
-     * @function manager
-     * @returns {IManager} The manager instance.
+     * User consent API.
+     * @property UserConsent
      */
-    manager(): IAsyncManager
+    UserConsent: IUserConsentAPI
   }
   /**
-   * This represents the interface for the Client instance with synchronous storage.
+   * This represents the interface for the Client instance with synchronous method calls and server-side API, where we don't have only one key.
    * @interface IClient
    * @extends IBasicClient
    */
-  interface IClient extends IBasicClient {
+  interface IClientSS extends IBasicClient {
     /**
      * Returns a Treatment value, which is the treatment string for the given feature.
-     * For usage on NodeJS as we don't have only one key.
      * @function getTreatment
      * @param {string} key - The string key representing the consumer.
      * @param {string} splitName - The string that represents the split we wan't to get the treatment.
@@ -1335,18 +1318,8 @@ declare namespace SplitIO {
      * @returns {Treatment} The treatment string.
      */
     getTreatment(key: SplitKey, splitName: string, attributes?: Attributes): Treatment,
-    /**
-     * Returns a Treatment value, which is the treatment string for the given feature.
-     * For usage on the Browser as we defined the key on the settings.
-     * @function getTreatment
-     * @param {string} splitName - The string that represents the split we wan't to get the treatment.
-     * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
-     * @returns {Treatment} The treatment string.
-     */
-    getTreatment(splitName: string, attributes?: Attributes): Treatment,
     /**
      * Returns a TreatmentWithConfig value, which is an object with both treatment and config string for the given feature.
-     * For usage on NodeJS as we don't have only one key.
      * @function getTreatmentWithConfig
      * @param {string} key - The string key representing the consumer.
      * @param {string} splitName - The string that represents the split we wan't to get the treatment.
@@ -1355,20 +1328,8 @@ declare namespace SplitIO {
      *                                configuration stringified JSON (or null if there was no config for that treatment).
      */
     getTreatmentWithConfig(key: SplitKey, splitName: string, attributes?: Attributes): TreatmentWithConfig,
-    /**
-     * Returns a TreatmentWithConfig value, which an object with both treatment and config string for the given feature.
-     * For usage on the Browser as we defined the key on the settings.
-     * @function getTreatment
-     * @param {string} splitName - The string that represents the split we wan't to get the treatment.
-     * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
-     * @returns {TreatmentWithConfig} The TreatmentWithConfig, the object containing the treatment string and the
-     *                                configuration stringified JSON (or null if there was no config for that treatment).
-     */
-    getTreatmentWithConfig(splitName: string, attributes?: Attributes): TreatmentWithConfig,
     /**
      * Returns a Treatments value, which is an object map with the treatments for the given features.
-     * For usage on NodeJS as we don't have only one key.
-     * NOTE: Treatment will be a promise only in async storages, like REDIS.
      * @function getTreatments
      * @param {string} key - The string key representing the consumer.
      * @param {Array<string>} splitNames - An array of the split names we wan't to get the treatments.
@@ -1376,19 +1337,8 @@ declare namespace SplitIO {
      * @returns {Treatments} The treatments object map.
      */
     getTreatments(key: SplitKey, splitNames: string[], attributes?: Attributes): Treatments,
-    /**
-     * Returns a Treatments value, which is an object map with the treatments for the given features.
-     * For usage on the Browser as we defined the key on the settings.
-     * NOTE: Treatment will be a promise only in async storages, like REDIS.
-     * @function getTreatments
-     * @param {Array<string>} splitNames - An array of the split names we wan't to get the treatments.
-     * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
-     * @returns {Treatments} The treatments object map.
-     */
-    getTreatments(splitNames: string[], attributes?: Attributes): Treatments,
     /**
      * Returns a TreatmentsWithConfig value, which is an object map with the TreatmentWithConfig (an object with both treatment and config string) for the given features.
-     * For usage on NodeJS as we don't have only one key.
      * @function getTreatmentsWithConfig
      * @param {string} key - The string key representing the consumer.
      * @param {Array<string>} splitNames - An array of the split names we wan't to get the treatments.
@@ -1396,18 +1346,8 @@ declare namespace SplitIO {
      * @returns {TreatmentsWithConfig} The map with all the TreatmentWithConfig objects
      */
     getTreatmentsWithConfig(key: SplitKey, splitNames: string[], attributes?: Attributes): TreatmentsWithConfig,
-    /**
-     * Returns a TreatmentsWithConfig value, which is an object map with the TreatmentWithConfig (an object with both treatment and config string) for the given features.
-     * For usage on the Browser as we defined the key on the settings.
-     * @function getTreatmentsWithConfig
-     * @param {Array<string>} splitNames - An array of the split names we wan't to get the treatments.
-     * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
-     * @returns {TreatmentsWithConfig} The map with all the TreatmentWithConfig objects
-     */
-    getTreatmentsWithConfig(splitNames: string[], attributes?: Attributes): TreatmentsWithConfig,
     /**
      * Tracks an event to be fed to the results product on Split Webconsole.
-     * For usage on NodeJS as we don't have only one key.
      * @function track
      * @param {SplitKey} key - The key that identifies the entity related to this event.
      * @param {string} trafficType - The traffic type of the entity related to this event.
@@ -1416,35 +1356,74 @@ declare namespace SplitIO {
      * @param {Properties=} properties - The properties of this event. Values can be string, number, boolean or null.
      * @returns {boolean} Whether the event was added to the queue successfully or not.
      */
-    track(key: SplitIO.SplitKey, trafficType: string, eventType: string, value?: number, properties?: Properties): boolean,
+    track(key: SplitKey, trafficType: string, eventType: string, value?: number, properties?: Properties): boolean,
+  }
+  /**
+   * This represents the interface for the Client instance with asynchronous method calls and server-side SDK, where we don't have only one key.
+   * @interface IAsyncClient
+   * @extends IBasicClient
+   */
+  interface IAsyncClientSS extends IBasicClient {
     /**
-     * Tracks an event to be fed to the results product on Split Webconsole.
-     * For usage on the Browser as we defined the key on the settings.
-     * @function track
-     * @param {string} trafficType - The traffic type of the entity related to this event.
-     * @param {string} eventType - The event type corresponding to this event.
-     * @param {number=} value - The value of this event.
-     * @param {Properties=} properties - The properties of this event. Values can be string, number, boolean or null.
-     * @returns {boolean} Whether the event was added to the queue successfully or not.
+     * Returns a Treatment value, which will be (or eventually be) the treatment string for the given feature.
+     * For usage on NodeJS as we don't have only one key.
+     * NOTE: Treatment will be a promise only in async storages, like REDIS.
+     * @function getTreatment
+     * @param {string} key - The string key representing the consumer.
+     * @param {string} splitName - The string that represents the split we wan't to get the treatment.
+     * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns {AsyncTreatment} Treatment promise which will resolve to the treatment string.
      */
-    track(trafficType: string, eventType: string, value?: number, properties?: Properties): boolean,
+    getTreatment(key: SplitKey, splitName: string, attributes?: Attributes): AsyncTreatment,
     /**
-     * Tracks an event to be fed to the results product on Split Webconsole.
-     * For usage on the Browser if we defined the key and also the trafficType on the settings.
+     * Returns a TreatmentWithConfig value, which will be (or eventually be) an object with both treatment and config string for the given feature.
+     * For usage on NodeJS as we don't have only one key.
+     * NOTE: Treatment will be a promise only in async storages, like REDIS.
+     * @function getTreatmentWithConfig
+     * @param {string} key - The string key representing the consumer.
+     * @param {string} splitName - The string that represents the split we wan't to get the treatment.
+     * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns {AsyncTreatmentWithConfig} TreatmentWithConfig promise which will resolve to the TreatmentWithConfig object.
+     */
+    getTreatmentWithConfig(key: SplitKey, splitName: string, attributes?: Attributes): AsyncTreatmentWithConfig,
+    /**
+     * Returns a Treatments value, which will be (or eventually be) an object map with the treatments for the given features.
+     * For usage on NodeJS as we don't have only one key.
+     * @function getTreatments
+     * @param {string} key - The string key representing the consumer.
+     * @param {Array<string>} splitNames - An array of the split names we wan't to get the treatments.
+     * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns {AsyncTreatments} Treatments promise which will resolve to the treatments object map.
+     */
+    getTreatments(key: SplitKey, splitNames: string[], attributes?: Attributes): AsyncTreatments,
+    /**
+     * Returns a TreatmentsWithConfig value, which will be (or eventually be) an object map with the TreatmentWithConfig (an object with both treatment and config string) for the given features.
+     * For usage on NodeJS as we don't have only one key.
+     * @function getTreatmentsWithConfig
+     * @param {string} key - The string key representing the consumer.
+     * @param {Array<string>} splitNames - An array of the split names we wan't to get the treatments.
+     * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns {AsyncTreatmentsWithConfig} TreatmentsWithConfig promise which will resolve to the map of TreatmentsWithConfig objects.
+     */
+    getTreatmentsWithConfig(key: SplitKey, splitNames: string[], attributes?: Attributes): AsyncTreatmentsWithConfig,
+    /**
+     * Tracks an event to be fed to the results product on Split Webconsole and returns a promise to signal when the event was successfully queued (or not).
      * @function track
+     * @param {SplitKey} key - The key that identifies the entity related to this event.
+     * @param {string} trafficType - The traffic type of the entity related to this event.
      * @param {string} eventType - The event type corresponding to this event.
      * @param {number=} value - The value of this event.
      * @param {Properties=} properties - The properties of this event. Values can be string, number, boolean or null.
-     * @returns {boolean} Whether the event was added to the queue successfully or not.
+     * @returns {Promise<boolean>} A promise that resolves to a boolean indicating if the event was added to the queue successfully or not.
      */
-    track(eventType: string, value?: number, properties?: Properties): boolean
+    track(key: SplitKey, trafficType: string, eventType: string, value?: number, properties?: Properties): Promise<boolean>
   }
   /**
-   * This represents the interface for the Client instance with attributes binding.
-   * @interface IBrowserClient
-   * @Extends IClient
+   * This represents the interface for the Client instance with attributes binding
+   * @interface IClientWithAttributeBinding
+   * @extends IBasicClient
    */
-  interface IBrowserClient extends IClient {
+  interface IClientWithAttributeBinding extends IBasicClient {
     /**
      * Add an attribute to client's in memory attributes storage.
      *
@@ -1488,64 +1467,129 @@ declare namespace SplitIO {
     clearAttributes(): boolean
   }
   /**
-   * This represents the interface for the Client instance with asynchronous storage.
-   * @interface IAsyncClient
-   * @extends IBasicClient
+   * This represents the interface for the Client instance with attributes binding, synchronous method calls, and client-side API, where each client has a key associated.
+   * @interface IClientWithKey
+   * @extends IClientWithAttributeBinding
+   */
+  interface IClientWithKey extends IClientWithAttributeBinding {
+    /**
+     * Returns a Treatment value, which is the treatment string for the given feature.
+     * @function getTreatment
+     * @param {string} splitName - The string that represents the split we wan't to get the treatment.
+     * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns {Treatment} The treatment string.
+     */
+    getTreatment(splitName: string, attributes?: Attributes): Treatment,
+    /**
+     * Returns a TreatmentWithConfig value, which is an object with both treatment and config string for the given feature.
+     * @function getTreatmentWithConfig
+     * @param {string} splitName - The string that represents the split we wan't to get the treatment.
+     * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns {TreatmentWithConfig} The map containing the treatment and the configuration stringified JSON (or null if there was no config for that treatment).
+     */
+    getTreatmentWithConfig(splitName: string, attributes?: Attributes): TreatmentWithConfig,
+    /**
+     * Returns a Treatments value, which is an object map with the treatments for the given features.
+     * @function getTreatments
+     * @param {Array<string>} splitNames - An array of the split names we wan't to get the treatments.
+     * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns {Treatments} The treatments object map.
+     */
+    getTreatments(splitNames: string[], attributes?: Attributes): Treatments,
+    /**
+     * Returns a TreatmentsWithConfig value, which is an object map with the TreatmentWithConfig (an object with both treatment and config string) for the given features.
+     * @function getTreatmentsWithConfig
+     * @param {Array<string>} splitNames - An array of the split names we wan't to get the treatments.
+     * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns {TreatmentsWithConfig} The map with all the TreatmentWithConfig objects
+     */
+    getTreatmentsWithConfig(splitNames: string[], attributes?: Attributes): TreatmentsWithConfig,
+    /**
+     * Tracks an event to be fed to the results product on Split Webconsole.
+     * @function track
+     * @param {string} trafficType - The traffic type of the entity related to this event.
+     * @param {string} eventType - The event type corresponding to this event.
+     * @param {number=} value - The value of this event.
+     * @param {Properties=} properties - The properties of this event. Values can be string, number, boolean or null.
+     * @returns {boolean} Whether the event was added to the queue successfully or not.
+     */
+    track(trafficType: string, eventType: string, value?: number, properties?: Properties): boolean,
+  }
+  /**
+   * This represents the interface for the Client instance with attributes binding, synchronous method calls, and client-side API, where each client has a key associated and optionally a traffic type.
+   * @interface IClientWithKeyLegacy
+   * @extends IClientWithKey
    */
-  interface IAsyncClient extends IBasicClient {
+  interface IClientWithKeyLegacy extends IClientWithKey {
+    /**
+     * Tracks an event to be fed to the results product on Split Webconsole.
+     * @function track
+     * @param {string} trafficType - The traffic type of the entity related to this event.
+     * @param {string} eventType - The event type corresponding to this event.
+     * @param {number=} value - The value of this event.
+     * @param {Properties=} properties - The properties of this event. Values can be string, number, boolean or null.
+     * @returns {boolean} Whether the event was added to the queue successfully or not.
+     */
+    track(trafficType: string, eventType: string, value?: number, properties?: Properties): boolean,
+    /**
+     * Tracks an event to be fed to the results product on Split Webconsole.
+     * For usage on the Browser if we defined the key and also the trafficType on the settings.
+     * @function track
+     * @param {string} eventType - The event type corresponding to this event.
+     * @param {number=} value - The value of this event.
+     * @param {Properties=} properties - The properties of this event. Values can be string, number, boolean or null.
+     * @returns {boolean} Whether the event was added to the queue successfully or not.
+     */
+    track(eventType: string, value?: number, properties?: Properties): boolean
+  }
+  /**
+   * This represents the interface for the Client instance with attributes binding, asynchronous method calls, and client-side API, where each client has a key associated.
+   * @interface IAsyncClientWithKey
+   * @extends IClientWithAttributeBinding
+   */
+  interface IAsyncClientWithKey extends IClientWithAttributeBinding {
     /**
      * Returns a Treatment value, which will be (or eventually be) the treatment string for the given feature.
-     * For usage on NodeJS as we don't have only one key.
-     * NOTE: Treatment will be a promise only in async storages, like REDIS.
      * @function getTreatment
-     * @param {string} key - The string key representing the consumer.
      * @param {string} splitName - The string that represents the split we wan't to get the treatment.
      * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
      * @returns {AsyncTreatment} Treatment promise which will resolve to the treatment string.
      */
-    getTreatment(key: SplitKey, splitName: string, attributes?: Attributes): AsyncTreatment,
+    getTreatment(splitName: string, attributes?: Attributes): AsyncTreatment,
     /**
      * Returns a TreatmentWithConfig value, which will be (or eventually be) an object with both treatment and config string for the given feature.
-     * For usage on NodeJS as we don't have only one key.
-     * NOTE: Treatment will be a promise only in async storages, like REDIS.
      * @function getTreatmentWithConfig
-     * @param {string} key - The string key representing the consumer.
      * @param {string} splitName - The string that represents the split we wan't to get the treatment.
      * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
      * @returns {AsyncTreatmentWithConfig} TreatmentWithConfig promise which will resolve to the TreatmentWithConfig object.
      */
-    getTreatmentWithConfig(key: SplitKey, splitName: string, attributes?: Attributes): AsyncTreatmentWithConfig,
+    getTreatmentWithConfig(splitName: string, attributes?: Attributes): AsyncTreatmentWithConfig,
     /**
      * Returns a Treatments value, which will be (or eventually be) an object map with the treatments for the given features.
-     * For usage on NodeJS as we don't have only one key.
      * @function getTreatments
-     * @param {string} key - The string key representing the consumer.
      * @param {Array<string>} splitNames - An array of the split names we wan't to get the treatments.
      * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
      * @returns {AsyncTreatments} Treatments promise which will resolve to the treatments object map.
      */
-    getTreatments(key: SplitKey, splitNames: string[], attributes?: Attributes): AsyncTreatments,
+    getTreatments(splitNames: string[], attributes?: Attributes): AsyncTreatments,
     /**
      * Returns a TreatmentsWithConfig value, which will be (or eventually be) an object map with the TreatmentWithConfig (an object with both treatment and config string) for the given features.
-     * For usage on NodeJS as we don't have only one key.
      * @function getTreatmentsWithConfig
-     * @param {string} key - The string key representing the consumer.
      * @param {Array<string>} splitNames - An array of the split names we wan't to get the treatments.
      * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
-     * @returns {AsyncTreatmentsWithConfig} TreatmentsWithConfig promise which will resolve to the map of TreatmentsWithConfig objects.
+     * @returns {TreatmentsWithConfig} TreatmentsWithConfig promise which will resolve to the map of TreatmentsWithConfig objects.
      */
-    getTreatmentsWithConfig(key: SplitKey, splitNames: string[], attributes?: Attributes): AsyncTreatmentsWithConfig,
+    getTreatmentsWithConfig(splitNames: string[], attributes?: Attributes): AsyncTreatmentsWithConfig,
     /**
      * Tracks an event to be fed to the results product on Split Webconsole and returns a promise to signal when the event was successfully queued (or not).
      * @function track
-     * @param {SplitKey} key - The key that identifies the entity related to this event.
      * @param {string} trafficType - The traffic type of the entity related to this event.
      * @param {string} eventType - The event type corresponding to this event.
      * @param {number=} value - The value of this event.
      * @param {Properties=} properties - The properties of this event. Values can be string, number, boolean or null.
-     * @returns {Promise<boolean>} A promise that resolves to a boolean indicating if the event was added to the queue successfully or not.
+     * @returns {boolean} A promise that resolves to a boolean indicating if the event was added to the queue successfully or not.
      */
-    track(key: SplitIO.SplitKey, trafficType: string, eventType: string, value?: number, properties?: Properties): Promise<boolean>
+    track(trafficType: string, eventType: string, value?: number, properties?: Properties): Promise<boolean>,
   }
   /**
    * Representation of a manager instance with synchronous storage of the SDK.
@@ -1562,14 +1606,14 @@ declare namespace SplitIO {
     /**
      * Get the array of splits data in SplitView format.
      * @function splits
-     * @returns {SplitViews} The list of SplitIO.SplitView.
+     * @returns {SplitViews} The list of SplitView.
      */
     splits(): SplitViews;
     /**
      * Get the data of a split in SplitView format.
      * @function split
      * @param {string} splitName The name of the split we wan't to get info of.
-     * @returns {SplitView | null} The SplitIO.SplitView of the given split or null if the split is not found.
+     * @returns {SplitView | null} The SplitView of the given split or null if the split is not found.
      */
     split(splitName: string): SplitView | null;
   }
@@ -1588,14 +1632,14 @@ declare namespace SplitIO {
     /**
      * Get the array of splits data in SplitView format.
      * @function splits
-     * @returns {SplitViewsAsync} A promise that will resolve to the SplitIO.SplitView list.
+     * @returns {SplitViewsAsync} A promise that will resolve to the SplitView list.
      */
     splits(): SplitViewsAsync;
     /**
      * Get the data of a split in SplitView format.
      * @function split
      * @param {string} splitName The name of the split we wan't to get info of.
-     * @returns {SplitViewAsync} A promise that will resolve to the SplitIO.SplitView value or null if the split is not found.
+     * @returns {SplitViewAsync} A promise that will resolve to the SplitView value or null if the split is not found.
      */
     split(splitName: string): SplitViewAsync;
   }