@splitsoftware/splitio-commons 2.0.0-rc.4 → 2.0.0-rc.6

package/types/splitio.d.ts

@@ -8,334 +8,759 @@ export as namespace SplitIO;
 export = SplitIO;
 
 /**
- * EventEmitter interface based on a subset of the NodeJS.EventEmitter methods.
+ * Common settings properties.
  */
-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;
-}
-/**
- * NodeJS.EventEmitter interface
- * @see {@link https://nodejs.org/api/events.html}
- */
-interface EventEmitter extends IEventEmitter {
-  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;
-  emit(event: string | symbol, ...args: any[]): boolean;
-  setMaxListeners(n: number): this;
-  getMaxListeners(): number;
-  listeners(event: string | symbol): Function[];
-  rawListeners(event: string | symbol): Function[];
-  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' | 'localhost' | 'consumer' | 'consumer_partial';
-/**
- * Storage types.
- * @typedef {string} StorageType
- */
-type StorageType = 'MEMORY' | 'LOCALSTORAGE' | 'REDIS' | 'PLUGGABLE';
-/**
- * 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;
-    labelsEnabled: boolean;
-    IPAddressesEnabled: boolean;
-  };
-  readonly mode: SDKMode;
-  readonly scheduler: {
-    featuresRefreshRate: number;
-    impressionsRefreshRate: number;
-    impressionsQueueSize: number;
+interface ISharedSettings {
+  /**
+   * 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.
+   *
+   * @defaultValue `undefined`
+   */
+  impressionListener?: SplitIO.IImpressionListener;
+  /**
+   * SDK synchronization settings.
+   */
+  sync?: {
     /**
-     * @deprecated
+     * List of feature flag filters. These filters are used to fetch a subset of the feature flag 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.
+     *
+     * Example:
+     * ```
+     *   splitFilter: [
+     *     { type: 'byName', values: ['my_feature_flag_1', 'my_feature_flag_2'] }, // will fetch feature flags named 'my_feature_flag_1' and 'my_feature_flag_2'
+     *   ]
+     * ```
+     */
+    splitFilters?: SplitIO.SplitFilter[];
+    /**
+     * Impressions Collection Mode. Option to determine how impressions are going to be sent to Split servers.
+     * Possible values are 'DEBUG', 'OPTIMIZED', and 'NONE'.
+     * - 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.
+     * - NONE: will send unique keys evaluated per feature to Split servers instead of full blown impressions, avoiding a considerable amount of traffic that impressions could generate.
+     *
+     * @defaultValue `'OPTIMIZED'`
+     */
+    impressionsMode?: SplitIO.ImpressionsMode;
+    /**
+     * Custom options object for HTTP(S) requests.
+     * If provided, this object is merged with the options object passed by the SDK for EventSource and Fetch calls.
+     * This configuration has no effect in "consumer" mode, as no HTTP(S) requests are made by the SDK.
      */
-    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: SplitIO.StorageSyncFactory | SplitIO.StorageAsyncFactory | SplitIO.StorageOptions;
-  readonly urls: {
-    events: string;
-    sdk: string;
-    auth: string;
-    streaming: string;
-    telemetry: string;
-  };
-  readonly integrations?: SplitIO.IntegrationFactory[];
-  readonly debug: boolean | LogLevel | SplitIO.ILogger;
-  readonly version: string;
-  /**
-   * Mocked features map if using in client-side, or mocked features file path string if using in server-side (NodeJS).
-   */
-  features: SplitIO.MockedFeaturesMap | SplitIO.MockedFeaturesFilePath;
-  readonly streamingEnabled: boolean;
-  readonly sync: {
-    splitFilters: SplitIO.SplitFilter[];
-    impressionsMode: SplitIO.ImpressionsMode;
-    enabled: boolean;
-    flagSpecVersion: string;
     requestOptions?: {
+      /**
+       * Custom function called before each request, allowing you to add or update headers in SDK HTTP requests.
+       * Some headers, such as `SplitSDKVersion`, are required by the SDK and cannot be overridden.
+       * To pass multiple headers with the same name, combine their values into a single line, separated by commas. Example: `{ 'Authorization': 'value1, value2' }`
+       * Or provide keys with different cases since headers are case-insensitive. Example: `{ 'authorization': 'value1', 'Authorization': 'value2' }`
+       *
+       * NOTE: to pass custom headers to the streaming connection in Browser, you should polyfill the `window.EventSource` object with a library that supports headers,
+       * like https://www.npmjs.com/package/event-source-polyfill, since native EventSource does not support them and they will be ignored.
+       *
+       * @defaultValue `undefined`
+       *
+       * @param context - The context for the request, which contains the `headers` property object representing the current headers in the request.
+       * @returns An object representing a set of headers to be merged with the current headers.
+       *
+       * @example
+       * ```
+       * const getHeaderOverrides = (context) => {
+       *   return {
+       *     'Authorization': context.headers['Authorization'] + ', other-value',
+       *     'custom-header': 'custom-value'
+       *   };
+       * };
+       * ```
+       */
       getHeaderOverrides?: (context: { headers: Record<string, string> }) => Record<string, string>;
     };
   };
   /**
-   * User consent status if using in client-side. Undefined if using in server-side (NodeJS).
+   * List of URLs that the SDK will use as base for it's synchronization functionalities, applicable only when running as standalone and partial consumer modes.
+   * Do not change these settings unless you're working an advanced use case, like connecting to the Split proxy.
    */
-  readonly userConsent?: SplitIO.ConsentStatus
+  urls?: SplitIO.UrlSettings;
 }
 /**
- * Log levels.
- * @typedef {string} LogLevel
+ * Common settings properties for SDKs with synchronous API (standalone  and localhost modes).
  */
-type LogLevel = 'DEBUG' | 'INFO' | 'WARN' | 'ERROR' | 'NONE';
-/**
- * Logger API
- * @interface ILoggerAPI
- */
-interface ILoggerAPI {
-  /**
-   * Enables SDK logging to the console.
-   * @function enable
-   * @returns {void}
-   */
-  enable(): void;
+interface ISyncSharedSettings extends ISharedSettings {
   /**
-   * Disables SDK logging.
-   * @function disable
-   * @returns {void}
+   * The SDK mode. When using the default in-memory storage or `InLocalStorage` as storage, the only possible value is "standalone", which is the default.
+   * For "localhost" mode, use "localhost" as authorizationKey.
+   *
+   * @defaultValue `'standalone'`
    */
-  disable(): void;
+  mode?: 'standalone';
   /**
-   * Sets a log level for the SDK logs.
-   * @function setLogLevel
-   * @returns {void}
+   * 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.
+   *
+   * @defaultValue `true`
    */
-  setLogLevel(logLevel: LogLevel): void;
+  streamingEnabled?: boolean;
   /**
-   * Log level constants. Use this to pass them to setLogLevel function.
+   * SDK synchronization settings.
    */
-  LogLevel: {
-    [level in LogLevel]: LogLevel;
+  sync?: ISharedSettings['sync'] & {
+    /**
+     * 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.
+     *
+     * @defaultValue `true`
+     */
+    enabled?: boolean;
   };
 }
 /**
- * User consent API
- * @interface IUserConsentAPI
+ * Common settings properties for SDKs with pluggable configuration.
  */
-interface IUserConsentAPI {
+interface IPluggableSettings {
   /**
-   * Sets or updates 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.
+   * 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}.
    *
-   * NOTE: calling this method updates the user consent at a factory level, affecting all clients of the same factory.
+   * Examples:
+   * ```
+   * config.debug = true
+   * config.debug = 'WARN'
+   * config.debug = ErrorLogger()
+   * ```
    *
-   * @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.
+   * @defaultValue `false`
    */
-  setStatus(userConsent: boolean): boolean;
+  debug?: boolean | SplitIO.LogLevel | SplitIO.ILogger;
   /**
-   * Gets the user consent status.
+   * Defines an optional list of factory functions used to instantiate SDK integrations.
    *
-   * @function getStatus
-   * @returns {ConsentStatus} The user consent status.
-   */
-  getStatus(): SplitIO.ConsentStatus;
-  /**
-   * Consent status constants. Use this to compare with the getStatus function result.
+   * NOTE: at the moment there are not integrations to plug in.
    */
-  Status: {
-    [status in SplitIO.ConsentStatus]: SplitIO.ConsentStatus;
-  };
+  integrations?: SplitIO.IntegrationFactory[];
 }
 /**
- * Common API for entities that expose status handlers.
- * @interface IStatusInterface
- * @extends EventEmitter
+ * Common settings properties for SDKs without pluggable configuration.
  */
-interface IStatusInterface extends EventEmitter {
-  /**
-   * Constant object containing the SDK events for you to use.
-   * @property {EventConsts} Event
-   */
-  Event: EventConsts;
+interface INonPluggableSettings {
   /**
-   * Returns a promise that resolves 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, the `ready` method will return a resolved promise once the SDK is ready.
+   * Boolean value to indicate whether the logger should be enabled or disabled, or a log level string.
    *
-   * 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:
+   * Examples:
    * ```
-   * try {
-   *   await client.ready().catch((e) => { throw e; });
-   *   // SDK is ready
-   * } catch(e) {
-   *   // SDK has timedout
-   * }
+   * config.debug = true
+   * config.debug = 'WARN'
    * ```
    *
-   * @function ready
-   * @returns {Promise<void>}
+   * @defaultValue `false`
    */
-  ready(): Promise<void>;
+  debug?: boolean | SplitIO.LogLevel;
 }
 /**
- * Common definitions between clients for different environments interface.
- * @interface IBasicClient
- * @extends IStatusInterface
+ * Common settings properties for server-side SDKs.
  */
-interface IBasicClient extends IStatusInterface {
+interface IServerSideSharedSettings {
   /**
-   * Destroys the client instance.
+   * SDK Core settings for NodeJS.
+   */
+  core: {
+    /**
+     * Your SDK key.
+     *
+     * @see {@link https://help.split.io/hc/en-us/articles/360019916211-API-keys}
+     */
+    authorizationKey: string;
+    /**
+     * Disable labels from being sent to Split backend. Labels may contain sensitive information.
+     *
+     * @defaultValue `true`
+     */
+    labelsEnabled?: boolean;
+    /**
+     * Disable machine IP and Name from being sent to Split backend.
+     *
+     * @defaultValue `true`
+     */
+    IPAddressesEnabled?: boolean;
+  };
+  /**
+   * SDK Startup settings for NodeJS.
+   */
+  startup?: {
+    /**
+     * Maximum amount of time used before notify a timeout.
+     *
+     * @defaultValue `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'.
+     *
+     * @defaultValue `15`
+     */
+    requestTimeoutBeforeReady?: number;
+    /**
+     * How many quick retries we will do while starting up the SDK.
+     *
+     * @defaultValue `1`
+     */
+    retriesOnFailureBeforeReady?: number;
+    /**
+     * 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.
+     *
+     * @defaultValue `0`
+     */
+    eventsFirstPushWindow?: number;
+  };
+  /**
+   * SDK scheduler settings.
+   */
+  scheduler?: {
+    /**
+     * The SDK polls Split servers for changes to feature flag definitions. This parameter controls this polling period in seconds.
+     *
+     * @defaultValue `60`
+     */
+    featuresRefreshRate?: 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.
+     *
+     * @defaultValue `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.
+     *
+     * @defaultValue `30000`
+     */
+    impressionsQueueSize?: number;
+    /**
+     * The SDK sends diagnostic metrics to Split servers. This parameters controls this metric flush period in seconds.
+     *
+     * @defaultValue `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.
+     *
+     * @defaultValue `3600`
+     */
+    telemetryRefreshRate?: number;
+    /**
+     * The SDK polls Split servers for changes to segment definitions. This parameter controls this polling period in seconds.
+     *
+     * @defaultValue `60`
+     */
+    segmentsRefreshRate?: number;
+    /**
+     * The SDK posts the queued events data in bulks. This parameter controls the posting rate in seconds.
+     *
+     * @defaultValue `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.
+     *
+     * @defaultValue `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/360020564931-Node-js-SDK#localhost-mode}
+     *
+     * @defaultValue `15`
+     */
+    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, ...
+     *
+     * @defaultValue `1`
+     */
+    pushRetryBackoffBase?: number;
+  };
+  /**
+   * Mocked features file path. For testing purposes 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}
    *
-   * In 'standalone' and 'partial consumer' modes, this method will flush any pending impressions and events.
-   * In 'standalone' mode, it also stops the synchronization of feature flag definitions with the backend.
-   * In 'consumer' and 'partial consumer' modes, this method also disconnects the SDK from the Pluggable storage.
+   * @defaultValue `'$HOME/.split'`
+   */
+  features?: SplitIO.MockedFeaturesFilePath;
+}
+/**
+ * Common settings properties for client-side SDKs.
+ */
+interface IClientSideSharedSettings {
+  /**
+   * SDK Core settings for client-side.
+   */
+  core: {
+    /**
+     * Your SDK key.
+     *
+     * @see {@link https://help.split.io/hc/en-us/articles/360019916211-API-keys}
+     */
+    authorizationKey: string;
+    /**
+     * Customer identifier. Whatever this means to you.
+     *
+     * @see {@link https://help.split.io/hc/en-us/articles/360019916311-Traffic-type}
+     */
+    key: SplitIO.SplitKey;
+    /**
+     * Disable labels from being sent to Split backend. Labels may contain sensitive information.
+     *
+     * @defaultValue `true`
+     */
+    labelsEnabled?: boolean;
+  };
+  /**
+   * 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.
    *
-   * @function destroy
-   * @returns {Promise<void>} A promise that resolves once the client is destroyed.
+   * @defaultValue `'GRANTED'`
    */
-  destroy(): Promise<void>;
+  userConsent?: SplitIO.ConsentStatus;
 }
 /**
- * Common definitions between SDK instances for different environments interface.
- * @interface IBasicSDK
+ * Common settings properties for client-side standalone SDKs.
  */
-interface IBasicSDK {
+interface IClientSideSyncSharedSettings extends IClientSideSharedSettings, ISyncSharedSettings {
   /**
-   * Current settings of the SDK instance.
-   * @property settings
+   * Mocked features map. For testing purposes only. For using this you should specify "localhost" as authorizationKey on core settings.
+   * @see {@link https://help.split.io/hc/en-us/articles/360020448791-JavaScript-SDK#localhost-mode}
    */
-  settings: ISettings;
+  features?: SplitIO.MockedFeaturesMap;
   /**
-   * Logger API.
-   * @property Logger
+   * SDK Startup settings.
    */
-  Logger: ILoggerAPI;
+  startup?: {
+    /**
+     * Maximum amount of time used before notify a timeout.
+     *
+     * @defaultValue `10`
+     */
+    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'.
+     *
+     * @defaultValue `5`
+     */
+    requestTimeoutBeforeReady?: number;
+    /**
+     * How many quick retries we will do while starting up the SDK.
+     *
+     * @defaultValue `1`
+     */
+    retriesOnFailureBeforeReady?: number;
+    /**
+     * 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 or mobile. This number defines that window before the first events push.
+     *
+     * @defaultValue `10`
+     */
+    eventsFirstPushWindow?: number;
+  };
   /**
-   * Destroys all the clients created by this factory.
-   * @function destroy
-   * @returns {Promise<void>}
+   * SDK scheduler settings.
    */
-  destroy(): Promise<void>;
+  scheduler?: {
+    /**
+     * The SDK polls Split servers for changes to feature flag definitions. This parameter controls this polling period in seconds.
+     *
+     * @defaultValue `60`
+     */
+    featuresRefreshRate?: 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.
+     *
+     * @defaultValue `60`
+     */
+    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.
+     *
+     * @defaultValue `30000`
+     */
+    impressionsQueueSize?: number;
+    /**
+     * The SDK sends diagnostic metrics to Split servers. This parameters controls this metric flush period in seconds.
+     *
+     * @defaultValue `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.
+     *
+     * @defaultValue `3600`
+     */
+    telemetryRefreshRate?: number;
+    /**
+     * The SDK polls Split servers for changes to segment definitions. This parameter controls this polling period in seconds.
+     *
+     * @defaultValue `60`
+     */
+    segmentsRefreshRate?: number;
+    /**
+     * The SDK posts the queued events data in bulks. This parameter controls the posting rate in seconds.
+     *
+     * @defaultValue `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.
+     *
+     * @defaultValue `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}
+     *
+     * @defaultValue `15`
+     */
+    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, ...
+     *
+     * @defaultValue `1`
+     */
+    pushRetryBackoffBase?: number;
+  };
 }
+
 /****** Exposed namespace ******/
 /**
- * Shared types and interfaces for `@splitsoftware` packages for usage when integrating JavaScript SDKs with TypeScript.
+ * Shared types and interfaces for `@splitsoftware` packages, to support integrating JavaScript SDKs with TypeScript.
  */
 declare namespace SplitIO {
+
+  /**
+   * EventEmitter interface based on a subset of the NodeJS.EventEmitter methods.
+   */
+  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;
+  }
+  /**
+   * NodeJS.EventEmitter interface
+   * @see {@link https://nodejs.org/api/events.html}
+   */
+  interface EventEmitter extends IEventEmitter {
+    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;
+    emit(event: string | symbol, ...args: any[]): boolean;
+    setMaxListeners(n: number): this;
+    getMaxListeners(): number;
+    listeners(event: string | symbol): Function[];
+    rawListeners(event: string | symbol): Function[];
+    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>;
+  }
+  /**
+   * Event constants.
+   */
+  type EventConsts = {
+    /**
+     * The ready event.
+     */
+    SDK_READY: 'init::ready';
+    /**
+     * The ready event when fired with cached data.
+     */
+    SDK_READY_FROM_CACHE: 'init::cache-ready';
+    /**
+     * The timeout event.
+     */
+    SDK_READY_TIMED_OUT: 'init::timeout';
+    /**
+     * The update event.
+     */
+    SDK_UPDATE: 'state::update';
+  };
+  /**
+   * SDK Modes.
+   */
+  type SDKMode = 'standalone' | 'localhost' | 'consumer' | 'consumer_partial';
+  /**
+   * Storage types.
+   */
+  type StorageType = 'MEMORY' | 'LOCALSTORAGE' | 'REDIS' | 'PLUGGABLE';
+  /**
+   * 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 {
+    readonly core: {
+      authorizationKey: string;
+      key: SplitKey;
+      labelsEnabled: boolean;
+      IPAddressesEnabled: boolean;
+    };
+    readonly mode: SDKMode;
+    readonly scheduler: {
+      featuresRefreshRate: number;
+      impressionsRefreshRate: number;
+      impressionsQueueSize: number;
+      /**
+       * @deprecated Use `telemetryRefreshRate` instead.
+       */
+      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: StorageSyncFactory | StorageAsyncFactory | StorageOptions;
+    readonly urls: {
+      events: string;
+      sdk: string;
+      auth: string;
+      streaming: string;
+      telemetry: string;
+    };
+    readonly integrations?: IntegrationFactory[];
+    readonly debug: boolean | LogLevel | ILogger;
+    readonly version: string;
+    /**
+     * Mocked features map if using in client-side, or mocked features file path string if using in server-side (NodeJS).
+     */
+    features: MockedFeaturesMap | MockedFeaturesFilePath;
+    readonly streamingEnabled: boolean;
+    readonly sync: {
+      splitFilters: SplitFilter[];
+      impressionsMode: ImpressionsMode;
+      enabled: boolean;
+      flagSpecVersion: string;
+      requestOptions?: {
+        getHeaderOverrides?: (context: { headers: Record<string, string> }) => Record<string, string>;
+      };
+    };
+    readonly runtime: {
+      ip: string | false;
+      hostname: string | false;
+    };
+    readonly impressionListener?: IImpressionListener;
+    /**
+     * User consent status if using in client-side. Undefined if using in server-side (NodeJS).
+     */
+    readonly userConsent?: ConsentStatus;
+  }
+  /**
+   * Log levels.
+   */
+  type LogLevel = 'DEBUG' | 'INFO' | 'WARN' | 'ERROR' | 'NONE';
+  /**
+   * Logger API
+   */
+  interface ILoggerAPI {
+    /**
+     * Enables SDK logging to the console.
+     */
+    enable(): void;
+    /**
+     * Disables SDK logging.
+     */
+    disable(): void;
+    /**
+     * Sets a log level for the SDK logs.
+     */
+    setLogLevel(logLevel: LogLevel): void;
+    /**
+     * Log level constants. Use this to pass them to setLogLevel function.
+     */
+    LogLevel: {
+      [level in LogLevel]: LogLevel;
+    };
+  }
+  /**
+   * User consent API
+   */
+  interface IUserConsentAPI {
+    /**
+     * Sets or updates 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.
+     *
+     * @param userConsent - The user consent status, true for 'GRANTED' and false for 'DECLINED'.
+     * @returns Whether the provided param is a valid value (i.e., a boolean value) or not.
+     */
+    setStatus(userConsent: boolean): boolean;
+    /**
+     * Gets the user consent status.
+     *
+     * @returns The user consent status.
+     */
+    getStatus(): ConsentStatus;
+    /**
+     * Consent status constants. Use this to compare with the getStatus function result.
+     */
+    Status: {
+      [status in ConsentStatus]: ConsentStatus;
+    };
+  }
+  /**
+   * Common API for entities that expose status handlers.
+   */
+  interface IStatusInterface extends EventEmitter {
+    /**
+     * Constant object containing the SDK events for you to use.
+     */
+    Event: EventConsts;
+    /**
+     * Returns a promise that resolves 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, the `ready` method will return a resolved promise once the SDK is 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
+     * }
+     * ```
+     *
+     * @returns A promise that resolves once the SDK is ready or rejects if the SDK has timedout.
+     */
+    ready(): Promise<void>;
+  }
+  /**
+   * Common definitions between clients for different environments interface.
+   */
+  interface IBasicClient extends IStatusInterface {
+    /**
+     * Destroys the client instance.
+     *
+     * In 'standalone' and 'partial consumer' modes, this method will flush any pending impressions and events.
+     * In 'standalone' mode, it also stops the synchronization of feature flag definitions with the backend.
+     * In 'consumer' and 'partial consumer' modes, this method also disconnects the SDK from the Pluggable storage.
+     *
+     * @returns A promise that resolves once the client is destroyed.
+     */
+    destroy(): Promise<void>;
+  }
+  /**
+   * Common definitions between SDK instances for different environments interface.
+   */
+  interface IBasicSDK {
+    /**
+     * Current settings of the SDK instance.
+     */
+    settings: ISettings;
+    /**
+     * Logger API.
+     */
+    Logger: ILoggerAPI;
+    /**
+     * Destroys all the clients created by this factory.
+     *
+     * @returns A promise that resolves once all clients are destroyed.
+     */
+    destroy(): Promise<void>;
+  }
   /**
    * Feature flag treatment value, returned by getTreatment.
-   * @typedef {string} Treatment
    */
   type Treatment = string;
   /**
    * Feature flag treatment promise that resolves to actual treatment value.
-   * @typedef {Promise<string>} AsyncTreatment
    */
-  type AsyncTreatment = Promise<string>;
+  type AsyncTreatment = Promise<Treatment>;
   /**
    * An object with the treatments for a bulk of feature flags, returned by getTreatments. For example:
+   * ```
    *   {
    *     feature1: 'on',
-   *     feature2: 'off
+   *     feature2: 'off'
    *   }
-   * @typedef {Object.<Treatment>} Treatments
+   * ```
    */
   type Treatments = {
     [featureName: string]: Treatment;
   };
   /**
    * Feature flag treatments promise that resolves to the actual SplitIO.Treatments object.
-   * @typedef {Promise<Treatments>} AsyncTreatments
    */
   type AsyncTreatments = Promise<Treatments>;
   /**
    * Feature flag evaluation result with treatment and configuration, returned by getTreatmentWithConfig.
-   * @typedef {Object} TreatmentWithConfig
-   * @property {string} treatment The treatment string
-   * @property {string | null} config The stringified version of the JSON config defined for that treatment, null if there is no config for the resulting treatment.
    */
   type TreatmentWithConfig = {
+    /**
+     * The treatment string.
+     */
     treatment: string;
+    /**
+     * The stringified version of the JSON config defined for that treatment, null if there is no config for the resulting treatment.
+     */
     config: string | null;
   };
   /**
-   * Feature flag treatment promise that resolves to actual treatment with config value.
-   * @typedef {Promise<TreatmentWithConfig>} AsyncTreatmentWithConfig
+   * Feature flag treatment promise that resolves to actual SplitIO.TreatmentWithConfig object.
    */
   type AsyncTreatmentWithConfig = Promise<TreatmentWithConfig>;
   /**
    * An object with the treatments with configs for a bulk of feature flags, returned by getTreatmentsWithConfig.
    * Each existing configuration is a stringified version of the JSON you defined on the Split user interface. For example:
+   * ```
    *   {
    *     feature1: { treatment: 'on', config: null }
    *     feature2: { treatment: 'off', config: '{"bannerText":"Click here."}' }
    *   }
-   * @typedef {Object.<TreatmentWithConfig>} Treatments
+   * ```
    */
   type TreatmentsWithConfig = {
     [featureName: string]: TreatmentWithConfig;
   };
   /**
    * Feature flag treatments promise that resolves to the actual SplitIO.TreatmentsWithConfig object.
-   * @typedef {Promise<TreatmentsWithConfig>} AsyncTreatmentsWithConfig
    */
   type AsyncTreatmentsWithConfig = Promise<TreatmentsWithConfig>;
   /**
    * Possible Split SDK events.
-   * @typedef {string} Event
    */
   type Event = 'init::timeout' | 'init::ready' | 'init::cache-ready' | 'state::update';
   /**
    * Attributes should be on object with values of type string, boolean, number (dates should be sent as millis since epoch) or array of strings or numbers.
-   * @typedef {Object.<AttributeType>} Attributes
+   *
    * @see {@link https://help.split.io/hc/en-us/articles/360020448791-JavaScript-SDK#attribute-syntax}
    */
   type Attributes = {
@@ -343,20 +768,18 @@ declare namespace SplitIO {
   };
   /**
    * Type of an attribute value
-   * @typedef {string | number | boolean | Array<string | number>} AttributeType
    */
   type AttributeType = string | number | boolean | Array<string | number>;
   /**
    * Properties should be an object with values of type string, number, boolean or null. Size limit of ~31kb.
-   * @typedef {Object.<number, string, boolean, null>} Properties
-   * @see {@link https://help.split.io/hc/en-us/articles/360020448791-JavaScript-SDK#track
+   *
+   * @see {@link https://help.split.io/hc/en-us/articles/360020448791-JavaScript-SDK#track}
    */
   type Properties = {
     [propertyName: string]: string | number | boolean | null;
   };
   /**
    * The SplitKey object format.
-   * @typedef {Object.<string>} SplitKeyObject
    */
   type SplitKeyObject = {
     matchingKey: string;
@@ -364,128 +787,114 @@ declare namespace SplitIO {
   };
   /**
    * The customer identifier. Could be a SplitKeyObject or a string.
-   * @typedef {SplitKeyObject|string} SplitKey
    */
   type SplitKey = SplitKeyObject | string;
   /**
    * Path to file with mocked features (for node).
-   * @typedef {string} MockedFeaturesFilePath
    */
   type MockedFeaturesFilePath = string;
   /**
    * Object with mocked features mapping for client-side (e.g., Browser or React Native). We need to specify the featureName as key, and the mocked treatment as value.
-   * @typedef {Object} MockedFeaturesMap
    */
   type MockedFeaturesMap = {
     [featureName: string]: string | TreatmentWithConfig;
   };
+  /**
+   * Impression DTO generated by the SDK when processing evaluations.
+   */
+  type ImpressionDTO = {
+    feature: string;
+    keyName: string;
+    treatment: string;
+    time: number;
+    bucketingKey?: string;
+    label: string;
+    changeNumber: number;
+    pt?: number;
+  }
   /**
    * 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;
   };
   /**
    * Data corresponding to one feature flag view.
-   * @typedef {Object} SplitView
    */
   type SplitView = {
     /**
      * The name of the feature flag.
-     * @property {string} name
      */
     name: string;
     /**
      * The traffic type of the feature flag.
-     * @property {string} trafficType
      */
     trafficType: string;
     /**
      * Whether the feature flag is killed or not.
-     * @property {boolean} killed
      */
     killed: boolean;
     /**
      * The list of treatments available for the feature flag.
-     * @property {Array<string>} treatments
      */
     treatments: Array<string>;
     /**
      * Current change number of the feature flag.
-     * @property {number} changeNumber
      */
     changeNumber: number;
     /**
      * Map of configurations per treatment.
      * Each existing configuration is a stringified version of the JSON you defined on the Split user interface.
-     * @property {Object.<string>} configs
      */
     configs: {
       [treatmentName: string]: string;
     };
     /**
      * List of sets of the feature flag.
-     * @property {string[]} sets
      */
     sets: string[];
     /**
      * The default treatment of the feature flag.
-     * @property {string} defaultTreatment
      */
     defaultTreatment: string;
   };
   /**
-   * A promise that resolves to a feature flag view.
-   * @typedef {Promise<SplitView>} SplitView
+   * A promise that resolves to a feature flag view or null if the feature flag is not found.
    */
-  type SplitViewAsync = Promise<SplitView>;
+  type SplitViewAsync = Promise<SplitView | null>;
   /**
    * An array containing the SplitIO.SplitView elements.
    */
   type SplitViews = Array<SplitView>;
   /**
    * A promise that resolves to an SplitIO.SplitViews array.
-   * @typedef {Promise<SplitViews>} SplitViewsAsync
    */
   type SplitViewsAsync = Promise<SplitViews>;
   /**
    * An array of feature flag names.
-   * @typedef {Array<string>} SplitNames
    */
   type SplitNames = Array<string>;
   /**
    * A promise that resolves to an array of feature flag names.
-   * @typedef {Promise<SplitNames>} SplitNamesAsync
    */
   type SplitNamesAsync = Promise<SplitNames>;
   /**
    * Storage for synchronous (standalone) SDK.
    * Its interface details are not part of the public API.
    */
-  type StorageSync = {};
+  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: {}): (StorageSync | undefined);
+    (params: any): (StorageSync | undefined);
   }
   /**
    * Configuration params for `InLocalStorage`
@@ -493,8 +902,8 @@ declare namespace SplitIO {
   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'
+     *
+     * @defaultValue `'SPLITIO'`
      */
     prefix?: string;
   }
@@ -502,14 +911,14 @@ declare namespace SplitIO {
    * Storage for asynchronous (consumer) SDK.
    * Its interface details are not part of the public API.
    */
-  type StorageAsync = {}
+  type StorageAsync = any
   /**
    * Storage builder for asynchronous (consumer) SDK.
    * Input parameter details are not part of the public API.
    */
   type StorageAsyncFactory = {
-    readonly type: 'PLUGGABLE';
-    (params: {}): StorageAsync;
+    readonly type: StorageType;
+    (params: any): StorageAsync;
   }
   /**
    * Configuration params for `PluggableStorage`
@@ -517,29 +926,25 @@ declare namespace SplitIO {
   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'
+     *
+     * @defaultValue `'SPLITIO'`
      */
     prefix?: string;
     /**
      * Storage wrapper.
-     * @property {Object} wrapper
      */
     wrapper: Object;
   }
   /**
    * Synchronous storage valid types for NodeJS.
-   * @typedef {string} NodeSyncStorage
    */
   type NodeSyncStorage = 'MEMORY';
   /**
    * Asynchronous storages valid types for NodeJS.
-   * @typedef {string} NodeAsyncStorage
    */
   type NodeAsyncStorage = 'REDIS';
   /**
    * Storage valid types for the browser.
-   * @typedef {string} BrowserStorage
    */
   type BrowserStorage = 'MEMORY' | 'LOCALSTORAGE';
   /**
@@ -553,17 +958,17 @@ declare namespace SplitIO {
   /**
    * Impression listener interface. This is the interface that needs to be implemented
    * by the element you provide to the SDK as impression listener.
-   * @interface IImpressionListener
+   *
    * @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 = {};
+  type Integration = any;
   /**
    * SDK integration factory.
    * By returning an integration, the SDK will queue events and impressions into it.
@@ -571,21 +976,23 @@ declare namespace SplitIO {
    */
   type IntegrationFactory = {
     readonly type: string;
-    (params: {}): (Integration | void);
+    (params: any): (Integration | void);
   }
   /**
    * A pair of user key and it's trafficType, required for tracking valid Split events.
-   * @typedef {Object} Identity
-   * @property {string} key The user key.
-   * @property {string} trafficType The key traffic type.
    */
   type Identity = {
+    /**
+     * The user key.
+     */
     key: string;
+    /**
+     * The key traffic type.
+     */
     trafficType: string;
   };
   /**
    * Object with information about a Split event.
-   * @typedef {Object} EventData
    */
   type EventData = {
     eventTypeId: string;
@@ -593,55 +1000,68 @@ declare namespace SplitIO {
     properties?: Properties;
     trafficTypeName?: string;
     key?: string;
-    timestamp?: number;
+    timestamp: number;
   };
   /**
    * Object representing the data sent by Split (events and impressions).
-   * @typedef {Object} IntegrationData
-   * @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 = {
+    /**
+     * The type of Split data.
+     */
+    type: 'IMPRESSION';
+    /**
+     * The impression data.
+     */
+    payload: ImpressionData;
+  } | {
+    /**
+     * The type of Split data.
+     */
+    type: 'EVENT';
+    /**
+     * The event data.
+     */
+    payload: EventData;
+  };
   /**
    * Available URL settings for the SDKs.
    */
   type UrlSettings = {
     /**
      * String property to override the base URL where the SDK will get rollout plan related data, like feature flags and segments definitions.
-     * @property {string} sdk
-     * @default 'https://sdk.split.io/api'
+     *
+     * @defaultValue `'https://sdk.split.io/api'`
      */
     sdk?: string;
     /**
      * String property to override the base URL where the SDK will post event-related information like impressions.
-     * @property {string} events
-     * @default 'https://events.split.io/api'
+     *
+     * @defaultValue `'https://events.split.io/api'`
      */
     events?: string;
     /**
      * String property to override the base URL where the SDK will get authorization tokens to be used with functionality that requires it, like streaming.
-     * @property {string} auth
-     * @default 'https://auth.split.io/api'
+     *
+     * @defaultValue `'https://auth.split.io/api'`
      */
     auth?: string;
     /**
      * String property to override the base URL where the SDK will connect to receive streaming updates.
-     * @property {string} streaming
-     * @default 'https://streaming.split.io'
+     *
+     * @defaultValue `'https://streaming.split.io'`
      */
     streaming?: string;
     /**
      * String property to override the base URL where the SDK will post telemetry data.
-     * @property {string} telemetry
-     * @default 'https://telemetry.split.io/api'
+     *
+     * @defaultValue `'https://telemetry.split.io/api'`
      */
     telemetry?: string;
   };
 
   /**
    * SplitFilter type.
-   *
-   * @typedef {string} SplitFilterType
    */
   type SplitFilterType = 'bySet' | 'byName' | 'byPrefix';
   /**
@@ -650,215 +1070,37 @@ declare namespace SplitIO {
   interface SplitFilter {
     /**
      * Type of the filter.
-     *
-     * @property {SplitFilterType} type
      */
     type: SplitFilterType;
     /**
      * List of values: feature flag names for 'byName' filter type, and feature flag name prefixes for 'byPrefix' type.
-     *
-     * @property {string[]} values
      */
     values: string[];
   }
   /**
   * ImpressionsMode type
-  * @typedef {string} ImpressionsMode
   */
   type ImpressionsMode = 'OPTIMIZED' | 'DEBUG' | 'NONE';
   /**
    * User consent status.
-   * @typedef {string} ConsentStatus
    */
   type ConsentStatus = 'GRANTED' | 'DECLINED' | 'UNKNOWN';
   /**
-   * Logger
-   * Its interface details are not part of the public API. It shouldn't be used directly.
-   * @interface ILogger
+   * Logger. Its interface details are not part of the public API. It shouldn't be used directly.
    */
   interface ILogger {
     setLogLevel(logLevel: LogLevel): void;
   }
   /**
-   * Common settings interface for SDK instances created for client-side.
+   * Settings interface for Browser SDK instances created with client-side API and synchronous storage (e.g., in-memory or local storage).
    *
-   * @interface IClientSideBasicSettings
-   */
-  interface IClientSideBasicSettings {
-    /**
-     * SDK Core settings for client-side.
-     * @property {Object} core
-     */
-    core: {
-      /**
-       * Your SDK key.
-       * @see {@link https://help.split.io/hc/en-us/articles/360019916211-API-keys}
-       * @property {string} authorizationKey
-       */
-      authorizationKey: string;
-      /**
-       * 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;
-      /**
-       * Disable labels from being sent to Split backend. Labels may contain sensitive information.
-       * @property {boolean} labelsEnabled
-       * @default true
-       */
-      labelsEnabled?: boolean;
-    };
-    /**
-     * 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:
-     * ```
-     * config.debug = true
-     * config.debug = 'WARN'
-     * config.debug = ErrorLogger()
-     * ```
-     * @property {boolean | LogLevel | ILogger} debug
-     * @default false
-     */
-    debug?: boolean | LogLevel | SplitIO.ILogger;
-    /**
-     * 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
-     */
-    impressionListener?: SplitIO.IImpressionListener;
-    /**
-     * 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
-     */
-    streamingEnabled?: boolean;
-    /**
-     * SDK synchronization settings.
-     * @property {Object} sync
-     */
-    sync?: {
-      /**
-       * List of feature flag filters. These filters are used to fetch a subset of the feature flag 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.
-       *
-       * Example:
-       *  `splitFilter: [
-       *    { type: 'byName', values: ['my_feature_flag_1', 'my_feature_flag_2'] }, // will fetch feature flags named 'my_feature_flag_1' and 'my_feature_flag_2'
-       *  ]`
-       * @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', 'OPTIMIZED', and 'NONE'.
-       * - 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.
-       * - NONE: will send unique keys evaluated per feature to Split servers instead of full blown impressions, avoiding a considerable amount of traffic that impressions could generate.
-       *
-       * @property {string} impressionsMode
-       * @default 'OPTIMIZED'
-       */
-      impressionsMode?: SplitIO.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.
-       *
-       * @property {boolean} enabled
-       * @default true
-       */
-      enabled?: boolean
-      /**
-       * Custom options object for HTTP(S) requests.
-       * If provided, this object is merged with the options object passed by the SDK for EventSource and Fetch calls.
-       * This configuration has no effect in "consumer" mode, as no HTTP(S) requests are made by the SDK.
-       */
-      requestOptions?: {
-        /**
-         * Custom function called before each request, allowing you to add or update headers in SDK HTTP requests.
-         * Some headers, such as `SplitSDKVersion`, are required by the SDK and cannot be overridden.
-         * To pass multiple headers with the same name, combine their values into a single line, separated by commas. Example: `{ 'Authorization': 'value1, value2' }`
-         * Or provide keys with different case since headers are case-insensitive. Example: `{ 'authorization': 'value1', 'Authorization': 'value2' }`
-         *
-         * NOTE: to pass custom headers to the streaming connection in Browser, you should polyfill the `window.EventSource` object with a library that supports headers,
-         * like https://www.npmjs.com/package/event-source-polyfill, since native EventSource does not support them and will be ignored.
-         *
-         * @property getHeaderOverrides
-         * @default undefined
-         *
-         * @param context - The context for the request.
-         * @param context.headers - The current headers in the request.
-         * @returns A set of headers to be merged with the current headers.
-         *
-         * @example
-         * const getHeaderOverrides = (context) => {
-         *   return {
-         *     'Authorization': context.headers['Authorization'] + ', other-value',
-         *     'custom-header': 'custom-value'
-         *   };
-         * };
-         */
-        getHeaderOverrides?: (context: { headers: Record<string, string> }) => Record<string, 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;
-    /**
-     * Defines an optional list of factory functions used to instantiate SDK integrations.
-     *
-     * NOTE: at the moment there are not integrations to plug in.
-     *
-     * @property {Object} integrations
-     */
-    integrations?: IntegrationFactory[];
-    /**
-     * 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 for client-side with synchronous storage (e.g., Browser or React Native).
-   *
-   * @interface IClientSideSettings
-   * @extends IClientSideBasicSettings
    * @see {@link https://help.split.io/hc/en-us/articles/360058730852-Browser-SDK#configuration}
    */
-  interface IClientSideSettings extends IClientSideBasicSettings {
+  interface IClientSideSettings extends IClientSideSyncSharedSettings, IPluggableSettings {
     /**
-     * The SDK mode. When using the default in memory storage or `InLocalStorage` as storage, the only possible value is "standalone", which is the default.
-     * For "localhost" mode, use "localhost" as authorizationKey.
+     * Defines the factory function to instantiate the storage. If not provided, the default in-memory storage is used.
      *
-     * @property {'standalone'} mode
-     * @default 'standalone'
-     */
-    mode?: 'standalone';
-    /**
-     * Mocked features map. For testing purposes only. For using this you should specify "localhost" as authorizationKey on core settings.
-     * @see {@link https://help.split.io/hc/en-us/articles/360058730852-Browser-SDK#localhost-mode}
-     */
-    features?: MockedFeaturesMap;
-    /**
-     * Defines the factory function to instantiate the storage. If not provided, the default IN MEMORY storage is used.
-     *
-     * NOTE: at the moment there are not storages to plug in React Native SDK, only `InLocalStorage` for Browser SDK.
+     * NOTE: Currently, there is no persistent storage option available for the React Native SDK; only `InLocalStorage` for the Browser SDK.
      *
      * Example:
      * ```
@@ -867,119 +1109,26 @@ declare namespace SplitIO {
      *   storage: InLocalStorage()
      * })
      * ```
-     * @property {Object} storage
      */
     storage?: StorageSyncFactory;
-    /**
-     * SDK Startup settings.
-     * @property {Object} startup
-     */
-    startup?: {
-      /**
-       * Maximum amount of time used before notify a timeout.
-       * @property {number} readyTimeout
-       * @default 1.5
-       */
-      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'.
-       * @property {number} requestTimeoutBeforeReady
-       * @default 1.5
-       */
-      requestTimeoutBeforeReady?: number;
-      /**
-       * How many quick retries we will do while starting up the SDK.
-       * @property {number} retriesOnFailureBeforeReady
-       * @default 1
-       */
-      retriesOnFailureBeforeReady?: number;
-      /**
-       * 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 or mobile. This number defines that window before the first events push.
-       *
-       * @property {number} eventsFirstPushWindow
-       * @default 10
-       */
-      eventsFirstPushWindow?: number;
-    };
-    /**
-     * SDK scheduler settings.
-     * @property {Object} scheduler
-     */
-    scheduler?: {
-      /**
-       * The SDK polls Split servers for changes to feature flag definitions. This parameter controls this polling period in seconds.
-       * @property {number} featuresRefreshRate
-       * @default 60
-       */
-      featuresRefreshRate?: 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.
-       * @property {number} impressionsRefreshRate
-       * @default 60
-       */
-      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.
-       * @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} 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.
-       * @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.
-       * @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/360058730852-Browser-SDK#localhost-mode}
-       * @property {number} offlineRefreshRate
-       * @default 15
-       */
-      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, ...
-       * @property {number} pushRetryBackoffBase
-       * @default 1
-       */
-      pushRetryBackoffBase?: number;
-    }
   }
   /**
-   * Settings interface with async storage for SDK instances created for client-side (e.g., Serverless environments).
-   * If your storage is synchronous (by defaut we use memory, which is sync) use SplitIO.IClientSideSettings instead.
-   * @interface IClientSideAsyncSettings
-   * @extends IClientSideBasicSettings
+   * Settings interface for React Native SDK instances, with client-side API and synchronous storage.
+   *
+   * @see {@link https://help.split.io/hc/en-us/articles/4406066357901-React-Native-SDK#configuration}
+   */
+  interface IReactNativeSettings extends IClientSideSettings { }
+  /**
+   * Settings interface for Browser SDK instances created with client-side API and asynchronous storage (e.g., serverless environments with a persistent storage).
+   * If your storage is synchronous (by default we use memory, which is sync) use SplitIO.IClientSideSettings instead.
+   *
+   * @see {@link https://help.split.io/hc/en-us/articles/360058730852-Browser-SDK#sharing-state-with-a-pluggable-storage}
    */
-  interface IClientSideAsyncSettings extends IClientSideBasicSettings {
+  interface IClientSideAsyncSettings extends IClientSideSharedSettings, ISharedSettings, IPluggableSettings {
     /**
      * The SDK mode. When using `PluggableStorage` as storage, the possible values are "consumer" and "consumer_partial".
      *
      * @see {@link https://help.split.io/hc/en-us/articles/360058730852-Browser-SDK#sharing-state-with-a-pluggable-storage}
-     *
-     * @property {'consumer' | 'consumer_partial'} mode
      */
     mode: 'consumer' | 'consumer_partial';
     /**
@@ -992,18 +1141,16 @@ declare namespace SplitIO {
      *   storage: PluggableStorage({ wrapper: SomeWrapper })
      * })
      * ```
-     * @property {Object} storage
      */
     storage: StorageAsyncFactory;
     /**
      * SDK Startup settings.
-     * @property {Object} startup
      */
     startup?: {
       /**
        * Maximum amount of time used before notify a timeout.
-       * @property {number} readyTimeout
-       * @default 1.5
+       *
+       * @defaultValue `5`
        */
       readyTimeout?: number;
       /**
@@ -1011,43 +1158,46 @@ declare namespace SplitIO {
        * to better control on browsers or mobile. This number defines that window before the first events push.
        *
        * NOTE: this param is ignored in 'consumer' mode.
-       * @property {number} eventsFirstPushWindow
-       * @default 10
+       *
+       * @defaultValue `10`
        */
       eventsFirstPushWindow?: number;
     };
     /**
      * SDK scheduler settings.
-     * @property {Object} scheduler
      */
     scheduler?: {
       /**
        * 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
+       *
+       * @defaultValue `60`
        */
       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.
-       * @property {number} impressionsQueueSize
-       * @default 30000
+       *
+       * NOTE: this param is ignored in 'consumer' mode.
+       *
+       * @defaultValue `30000`
        */
       impressionsQueueSize?: number;
       /**
        * The SDK sends diagnostic metrics to Split servers. This parameters controls this metric flush period in seconds.
-       * @property {number} telemetryRefreshRate
-       * @default 3600
+       *
+       * NOTE: this param is ignored in 'consumer' mode.
+       *
+       * @defaultValue `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
+       *
+       * @defaultValue `60`
        */
       eventsPushRate?: number;
       /**
@@ -1055,504 +1205,63 @@ declare namespace SplitIO {
        * 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;
-    }
-  }
-  /**
-   * Common settings between Browser and NodeJS settings interface.
-   * @interface ISharedSettings
-   */
-  interface ISharedSettings {
-    /**
-     * Boolean value to indicate whether the logger should be enabled or disabled, or a log level string.
-     *
-     * Examples:
-     * ```
-     * config.debug = true
-     * config.debug = 'WARN'
-     * ```
-     * @property {boolean | LogLevel} debug
-     * @default false
-     */
-    debug?: boolean | LogLevel,
-    /**
-     * 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
-     */
-    impressionListener?: SplitIO.IImpressionListener,
-    /**
-     * 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
-     */
-    streamingEnabled?: boolean,
-    /**
-     * SDK synchronization settings.
-     * @property {Object} sync
-     */
-    sync?: {
-      /**
-       * List of feature flag filters. These filters are used to fetch a subset of the feature flag 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.
-       *
-       * Example:
-       *  `splitFilter: [
-       *    { type: 'byName', values: ['my_feature_flag_1', 'my_feature_flag_2'] }, // will fetch feature flags named 'my_feature_flag_1' and 'my_feature_flag_2'
-       *  ]`
-       * @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', 'OPTIMIZED', and 'NONE'.
-       * - 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.
-       * - NONE: will send unique keys evaluated per feature to Split servers instead of full blown impressions, avoiding a considerable amount of traffic that impressions could generate.
-       *
-       * @property {string} impressionsMode
-       * @default 'OPTIMIZED'
-       */
-      impressionsMode?: SplitIO.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.
-       *
-       * @property {boolean} enabled
-       * @default true
-       */
-      enabled?: boolean
-    }
-  }
-  /**
-   * Common settings interface for SDK instances on NodeJS.
-   * @interface INodeBasicSettings
-   * @extends ISharedSettings
-   */
-  interface INodeBasicSettings extends ISharedSettings {
-    /**
-     * SDK Startup settings for NodeJS.
-     * @property {Object} startup
-     */
-    startup?: {
-      /**
-       * Maximum amount of time used before notify a timeout.
-       * @property {number} readyTimeout
-       * @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'.
-       * @property {number} requestTimeoutBeforeReady
-       * @default 15
-       */
-      requestTimeoutBeforeReady?: number,
-      /**
-       * How many quick retries we will do while starting up the SDK.
-       * @property {number} retriesOnFailureBeforeReady
-       * @default 1
-       */
-      retriesOnFailureBeforeReady?: number,
-      /**
-       * 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
-       */
-      eventsFirstPushWindow?: number,
-    },
-    /**
-     * SDK scheduler settings.
-     * @property {Object} scheduler
-     */
-    scheduler?: {
-      /**
-       * The SDK polls Split servers for changes to feature flag definitions. This parameter controls this polling period in seconds.
-       * @property {number} featuresRefreshRate
-       * @default 60
-       */
-      featuresRefreshRate?: 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.
-       * @property {number} impressionsRefreshRate
-       * @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.
-       * @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.
-       * @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.
-       * @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.
-       * @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/360020564931-Node-js-SDK#localhost-mode}
-       * @property {number} offlineRefreshRate
-       * @default 15
-       */
-      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, ...
-       * @property {number} pushRetryBackoffBase
-       * @default 1
-       */
-      pushRetryBackoffBase?: number,
-    },
-    /**
-     * SDK Core settings for NodeJS.
-     * @property {Object} core
-     */
-    core: {
-      /**
-       * Your SDK key.
-       * @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.
-       * @property {boolean} labelsEnabled
-       * @default true
-       */
-      labelsEnabled?: boolean
-      /**
-       * Disable machine IP and Name from being sent to Split backend.
-       * @property {boolean} IPAddressesEnabled
-       * @default true
-       */
-      IPAddressesEnabled?: boolean
-    },
-    /**
-     * Defines which kind of storage we should instantiate.
-     * @property {Object} storage
-     */
-    storage?: {
-      /**
-       * Storage type to be instantiated by the SDK.
-       * @property {StorageType} type
-       * @default 'MEMORY'
-       */
-      type?: StorageType,
-      /**
-       * Options to be passed to the selected storage.
-       * @property {Object} options
+       * @defaultValue `500`
        */
-      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 purposes 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,
+      eventsQueueSize?: number;
+    };
   }
   /**
-   * Settings interface for SDK instances created on the browser
-   * @interface IBrowserSettings
-   * @extends ISharedSettings
+   * Settings interface for JavaScript SDK instances created on the browser, with client-side API and synchronous storage (e.g., in-memory or local storage).
+   *
    * @see {@link https://help.split.io/hc/en-us/articles/360020448791-JavaScript-SDK#configuration}
    */
-  interface IBrowserSettings extends ISharedSettings {
-    /**
-     * SDK Startup settings for the Browser.
-     * @property {Object} startup
-     */
-    startup?: {
-      /**
-       * Maximum amount of time used before notify a timeout.
-       * @property {number} readyTimeout
-       * @default 1.5
-       */
-      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'.
-       * @property {number} requestTimeoutBeforeReady
-       * @default 1.5
-       */
-      requestTimeoutBeforeReady?: number,
-      /**
-       * How many quick retries we will do while starting up the SDK.
-       * @property {number} retriesOnFailureBeforeReady
-       * @default 1
-       */
-      retriesOnFailureBeforeReady?: number,
-      /**
-       * 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 10
-       */
-      eventsFirstPushWindow?: number,
-    },
-    /**
-     * SDK scheduler settings.
-     * @property {Object} scheduler
-     */
-    scheduler?: {
-      /**
-       * The SDK polls Split servers for changes to feature flag definitions. This parameter controls this polling period in seconds.
-       * @property {number} featuresRefreshRate
-       * @default 60
-       */
-      featuresRefreshRate?: 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.
-       * @property {number} impressionsRefreshRate
-       * @default 60
-       */
-      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.
-       * @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.
-       * @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.
-       * @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.
-       * @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 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
-       */
-      pushRetryBackoffBase?: number,
-    },
-    /**
-     * SDK Core settings for the browser.
-     * @property {Object} core
-     */
-    core: {
-      /**
-       * Your SDK key.
-       * @see {@link https://help.split.io/hc/en-us/articles/360019916211-API-keys}
-       * @property {string} authorizationKey
-       */
-      authorizationKey: string,
-      /**
-       * 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,
-      /**
-       * 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 purposes only. For using this you should specify "localhost" as authorizationKey on core settings.
-     * @see {@link https://help.split.io/hc/en-us/articles/360020448791-JavaScript-SDK#localhost-mode}
-     */
-    features?: MockedFeaturesMap,
+  interface IBrowserSettings extends IClientSideSyncSharedSettings, INonPluggableSettings {
     /**
      * 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
      */
     storage?: {
       /**
        * Storage type to be instantiated by the SDK.
-       * @property {BrowserStorage} type
-       * @default 'MEMORY'
+       *
+       * @defaultValue `'MEMORY'`
        */
-      type?: BrowserStorage,
+      type?: BrowserStorage;
       /**
        * Optional prefix to prevent any kind of data collision between SDK versions.
-       * @property {string} prefix
-       * @default 'SPLITIO'
-       */
-      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,
-    /**
-     * 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,
-    sync?: ISharedSettings['sync'] & {
-      /**
-       * Custom options object for HTTP(S) requests in the Browser.
-       * If provided, this object is merged with the options object passed by the SDK for EventSource and Fetch calls.
+       *
+       * @defaultValue `'SPLITIO'`
        */
-      requestOptions?: {
-        /**
-         * Custom function called before each request, allowing you to add or update headers in SDK HTTP requests.
-         * Some headers, such as `SplitSDKVersion`, are required by the SDK and cannot be overridden.
-         * To pass multiple headers with the same name, combine their values into a single line, separated by commas. Example: `{ 'Authorization': 'value1, value2' }`
-         * Or provide keys with different case since headers are case-insensitive. Example: `{ 'authorization': 'value1', 'Authorization': 'value2' }`
-         *
-         * NOTE: to pass custom headers to the streaming connection in Browser, you should polyfill the `window.EventSource` object with a library that supports headers,
-         * like https://www.npmjs.com/package/event-source-polyfill, since native EventSource does not support them and will be ignored.
-         *
-         * @property getHeaderOverrides
-         * @default undefined
-         *
-         * @param context - The context for the request.
-         * @param context.headers - The current headers in the request.
-         * @returns A set of headers to be merged with the current headers.
-         *
-         * @example
-         * const getHeaderOverrides = (context) => {
-         *   return {
-         *     'Authorization': context.headers['Authorization'] + ', other-value',
-         *     'custom-header': 'custom-value'
-         *   };
-         * };
-         */
-        getHeaderOverrides?: (context: { headers: Record<string, string> }) => Record<string, string>
-      },
-    }
+      prefix?: string;
+    };
   }
   /**
-   * Settings interface for SDK instances created on NodeJS.
+   * Settings interface for JavaScript SDK instances created on NodeJS, with server-side API and synchronous in-memory storage.
    * 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,
+  interface INodeSettings extends IServerSideSharedSettings, ISyncSharedSettings, INonPluggableSettings {
     /**
      * 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?: {
       /**
        * Synchronous storage type to be instantiated by the SDK.
-       * @property {NodeSyncStorage} type
-       * @default 'MEMORY'
+       *
+       * @defaultValue `'MEMORY'`
        */
-      type?: NodeSyncStorage,
+      type?: NodeSyncStorage;
       /**
        * Optional prefix to prevent any kind of data collision between SDK versions.
-       * @property {string} prefix
-       * @default 'SPLITIO'
+       *
+       * @defaultValue `'SPLITIO'`
        */
-      prefix?: string
-    },
-    /**
-     * 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'
-    sync?: INodeBasicSettings['sync'] & {
+      prefix?: string;
+    };
+    sync?: ISyncSharedSettings['sync'] & {
       /**
        * Custom options object for HTTP(S) requests in NodeJS.
        * If provided, this object is merged with the options object passed by the SDK for EventSource and Node-Fetch calls.
@@ -1563,24 +1272,24 @@ declare namespace SplitIO {
          * Custom function called before each request, allowing you to add or update headers in SDK HTTP requests.
          * Some headers, such as `SplitSDKVersion`, are required by the SDK and cannot be overridden.
          * To pass multiple headers with the same name, combine their values into a single line, separated by commas. Example: `{ 'Authorization': 'value1, value2' }`
-         * Or provide keys with different case since headers are case-insensitive. Example: `{ 'authorization': 'value1', 'Authorization': 'value2' }`
+         * Or provide keys with different cases since headers are case-insensitive. Example: `{ 'authorization': 'value1', 'Authorization': 'value2' }`
          *
-         * @property getHeaderOverrides
-         * @default undefined
+         * @defaultValue `undefined`
          *
-         * @param context - The context for the request.
-         * @param context.headers - The current headers in the request.
-         * @returns A set of headers to be merged with the current headers.
+         * @param context - The context for the request, which contains the `headers` property object representing the current headers in the request.
+         * @returns An object representing a set of headers to be merged with the current headers.
          *
          * @example
+         * ```
          * const getHeaderOverrides = (context) => {
          *   return {
          *     'Authorization': context.headers['Authorization'] + ', other-value',
          *     'custom-header': 'custom-value'
          *   };
          * };
+         * ```
          */
-        getHeaderOverrides?: (context: { headers: Record<string, string> }) => Record<string, string>
+        getHeaderOverrides?: (context: { headers: Record<string, string> }) => Record<string, string>;
         /**
          * Custom NodeJS HTTP(S) Agent used by the SDK for HTTP(S) requests.
          *
@@ -1603,35 +1312,36 @@ declare namespace SplitIO {
          *
          * @see {@link https://nodejs.org/api/https.html#class-httpsagent}
          *
-         * @property {http.Agent | https.Agent} agent
-         * @default undefined
+         * @defaultValue `undefined`
          */
-        agent?: RequestOptions["agent"]
-      },
-    }
+        agent?: RequestOptions['agent'];
+      };
+    };
   }
   /**
-   * 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
+   * Settings interface for JavaScript SDK instances created on NodeJS, with asynchronous storage like Redis.
+   * If your storage is synchronous (by default we use memory, which is sync) use SplitIO.INodeSettings instead.
+   *
    * @see {@link https://help.split.io/hc/en-us/articles/360020564931-Node-js-SDK#configuration}
    */
-  interface INodeAsyncSettings extends INodeBasicSettings {
+  interface INodeAsyncSettings extends IServerSideSharedSettings, ISharedSettings, INonPluggableSettings {
+    /**
+     * 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}
+     */
+    mode: 'consumer';
     /**
      * Defines which kind of async storage we can instantiate on NodeJS for 'consumer' mode.
      * The only possible storage type is 'REDIS'.
-     * @property {Object} storage
      */
     storage: {
       /**
        * 'REDIS' storage type to be instantiated by the SDK.
-       * @property {NodeAsyncStorage} type
        */
-      type: NodeAsyncStorage,
+      type: NodeAsyncStorage;
       /**
        * Options to be passed to the Redis storage. Use it with storage type: 'REDIS'.
-       * @property {Object} options
        */
       options?: {
         /**
@@ -1643,650 +1353,578 @@ declare namespace SplitIO {
          *   url: '127.0.0.1:6379'
          *   url: 'redis://:authpassword@127.0.0.1:6379/0'
          * ```
-         * @property {string=} url
          */
-        url?: string,
+        url?: string;
         /**
          * Redis host.
-         * @property {string=} host
-         * @default 'localhost'
+         *
+         * @defaultValue `'localhost'`
          */
-        host?: string,
+        host?: string;
         /**
          * Redis port.
-         * @property {number=} port
-         * @default 6379
+         *
+         * @defaultValue `6379`
          */
-        port?: number,
+        port?: number;
         /**
          * Redis database to be used.
-         * @property {number=} db
-         * @default 0
+         *
+         * @defaultValue `0`
          */
-        db?: number,
+        db?: number;
         /**
          * Redis password. Don't define if no password is used.
-         * @property {string=} pass
-         * @default undefined
+         *
+         * @defaultValue `undefined`
          */
-        pass?: string,
+        pass?: string;
         /**
          * The milliseconds before a timeout occurs during the initial connection to the Redis server.
-         * @property {number=} connectionTimeout
-         * @default 10000
+         *
+         * @defaultValue `10000`
          */
-        connectionTimeout?: number,
+        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
+         *
+         * @defaultValue `5000`
          */
-        operationTimeout?: number,
+        operationTimeout?: number;
         /**
          * TLS configuration for Redis connection.
          * @see {@link https://www.npmjs.com/package/ioredis#tls-options }
          *
-         * @property {Object=} tls
-         * @default undefined
+         * @defaultValue `undefined`
          */
-        tls?: RedisOptions['tls'],
-      },
+        tls?: RedisOptions['tls'];
+      };
       /**
        * Optional prefix to prevent any kind of data collision between SDK versions.
-       * @property {string} prefix
-       * @default 'SPLITIO'
+       *
+       * @defaultValue `'SPLITIO'`
        */
-      prefix?: string
-    },
-    /**
-     * 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}
-     *
-     * @property {'consumer'} mode
-     */
-    mode: 'consumer'
+      prefix?: string;
+    };
   }
   /**
    * This represents the interface for the SDK instance with synchronous storage and client-side API,
    * i.e., where client instances have a bound user key.
-   * @interface ISDK
-   * @extends IBasicSDK
    */
-  interface ISDK extends IBasicSDK {
+  interface IBrowserSDK extends IBasicSDK {
     /**
      * Returns the default client instance of the SDK, associated with the key provided on settings.
-     * @function client
-     * @returns {IClient} The client instance.
+     *
+     * @returns The client instance.
      */
-    client(): IClient;
+    client(): IBrowserClient;
     /**
      * Returns a shared client of the SDK, associated with the given key.
-     * @function client
-     * @param {SplitKey} key The key for the new client instance.
-     * @returns {IClient} The client instance.
+     * @param key - The key for the new client instance.
+     * @returns The client instance.
      */
-    client(key: SplitKey): IClient;
+    client(key: SplitKey): IBrowserClient;
     /**
      * Returns a manager instance of the SDK to explore available information.
-     * @function manager
-     * @returns {IManager} The manager instance.
+     *
+     * @returns The manager instance.
      */
     manager(): IManager;
     /**
      * User consent API.
-     * @property UserConsent
      */
     UserConsent: IUserConsentAPI;
   }
   /**
    * This represents the interface for the SDK instance with asynchronous storage and client-side API,
    * i.e., where client instances have a bound user key.
-   * @interface IAsyncSDK
-   * @extends IBasicSDK
    */
-  interface IAsyncSDK extends IBasicSDK {
+  interface IBrowserAsyncSDK extends IBasicSDK {
     /**
      * Returns the default client instance of the SDK, associated with the key provided on settings.
-     * @function client
-     * @returns {IAsyncClient} The asynchronous client instance.
+     *
+     * @returns The asynchronous client instance.
      */
-    client(): IAsyncClient;
+    client(): IBrowserAsyncClient;
     /**
      * Returns a shared client of the SDK, associated with the given key.
-     * @function client
-     * @param {SplitKey} key The key for the new client instance.
-     * @returns {IAsyncClient} The asynchronous client instance.
+     *
+     * @param key - The key for the new client instance.
+     * @returns The asynchronous client instance.
      */
-    client(key: SplitKey): IAsyncClient;
+    client(key: SplitKey): IBrowserAsyncClient;
     /**
      * Returns a manager instance of the SDK to explore available information.
-     * @function manager
-     * @returns {IManager} The manager instance.
+     *
+     * @returns The manager instance.
      */
     manager(): IAsyncManager;
     /**
      * User consent API.
-     * @property UserConsent
      */
     UserConsent: IUserConsentAPI;
   }
   /**
    * This represents the interface for the SDK instance for server-side with synchronous storage.
-   * @interface INodeSDK
-   * @extends IBasicSDK
    */
-  interface INodeSDK extends IBasicSDK {
+  interface ISDK extends IBasicSDK {
     /**
      * Returns the default client instance of the SDK.
-     * @function client
-     * @returns {INodeClient} The client instance.
+     *
+     * @returns The client instance.
      */
-    client(): INodeClient;
+    client(): IClient;
     /**
      * Returns a manager instance of the SDK to explore available information.
-     * @function manager
-     * @returns {IManager} The manager instance.
+     *
+     * @returns The manager instance.
      */
     manager(): IManager;
   }
   /**
    * This represents the interface for the SDK instance for server-side with asynchronous storage.
-   * @interface INodeAsyncSDK
-   * @extends IBasicSDK
    */
-  interface INodeAsyncSDK extends IBasicSDK {
+  interface IAsyncSDK extends IBasicSDK {
     /**
      * Returns the default client instance of the SDK.
-     * @function client
-     * @returns {INodeAsyncClient} The asynchronous client instance.
+     *
+     * @returns The asynchronous client instance.
      */
-    client(): INodeAsyncClient;
+    client(): IAsyncClient;
     /**
      * Returns a manager instance of the SDK to explore available information.
-     * @function manager
-     * @returns {IManager} The manager instance.
+     *
+     * @returns The manager instance.
      */
     manager(): IAsyncManager;
   }
   /**
    * This represents the interface for the Client instance on server-side, where the user key is not bound to the instance and must be provided on each method call.
    * This interface is available in NodeJS, or when importing the 'server' sub-package of JS SDK (e.g., `import { SplitFactory } from '@splitsoftware/splitio/server'`).
-   *
-   * @interface INodeClient
-   * @extends IBasicClient
    */
-  interface INodeClient extends IBasicClient {
+  interface IClient extends IBasicClient {
     /**
      * Returns a Treatment value, which is the treatment string for the given feature.
      *
-     * @function getTreatment
-     * @param {string} key - The string key representing the consumer.
-     * @param {string} featureFlagName - The string that represents the feature flag we want to get the treatment.
-     * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
-     * @returns {Treatment} The treatment string.
+     * @param key - The string key representing the consumer.
+     * @param featureFlagName - The string that represents the feature flag we want to get the treatment.
+     * @param attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns The treatment string.
      */
     getTreatment(key: SplitKey, featureFlagName: 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} key - The string key representing the consumer.
-     * @param {string} featureFlagName - The string that represents the feature flag we want 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
+     * @param key - The string key representing the consumer.
+     * @param featureFlagName - The string that represents the feature flag we want to get the treatment.
+     * @param attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns The TreatmentWithConfig, the object containing the treatment string and the
      *                                configuration stringified JSON (or null if there was no config for that treatment).
      */
     getTreatmentWithConfig(key: SplitKey, featureFlagName: string, attributes?: Attributes): TreatmentWithConfig;
     /**
      * Returns a Treatments value, which is an object map with the treatments for the given features.
      *
-     * @function getTreatments
-     * @param {string} key - The string key representing the consumer.
-     * @param {Array<string>} featureFlagNames - An array of the feature flag names we want 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.
+     * @param key - The string key representing the consumer.
+     * @param featureFlagNames - An array of the feature flag names we want to get the treatments.
+     * @param attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns The treatments object map.
      */
     getTreatments(key: SplitKey, featureFlagNames: 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 {string} key - The string key representing the consumer.
-     * @param {Array<string>} featureFlagNames - An array of the feature flag names we want 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
+     * @param key - The string key representing the consumer.
+     * @param featureFlagNames - An array of the feature flag names we want to get the treatments.
+     * @param attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns The map with all the TreatmentWithConfig objects
      */
     getTreatmentsWithConfig(key: SplitKey, featureFlagNames: string[], attributes?: Attributes): TreatmentsWithConfig;
     /**
      * Returns a Treatments value, which is an object map with the treatments for the feature flags related to the given flag set.
      *
-     * @function getTreatmentsByFlagSet
-     * @param {string} key - The string key representing the consumer.
-     * @param {string} flagSet - The flag set name we want to get the treatments.
-     * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
-     * @returns {Treatments} The map with all the Treatment objects
+     * @param key - The string key representing the consumer.
+     * @param flagSet - The flag set name we want to get the treatments.
+     * @param attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns The map with all the Treatment objects
      */
     getTreatmentsByFlagSet(key: SplitKey, flagSet: 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 feature flags related to the given flag set.
      *
-     * @function getTreatmentsWithConfigByFlagSet
-     * @param {string} key - The string key representing the consumer.
-     * @param {string} flagSet - The flag set name we want 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
+     * @param key - The string key representing the consumer.
+     * @param flagSet - The flag set name we want to get the treatments.
+     * @param attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns The map with all the TreatmentWithConfig objects
      */
     getTreatmentsWithConfigByFlagSet(key: SplitKey, flagSet: string, attributes?: Attributes): TreatmentsWithConfig;
     /**
      * Returns a Returns a Treatments value, which is an object with both treatment and config string for to the feature flags related to the given flag sets.
      *
-     * @function getTreatmentsByFlagSets
-     * @param {string} key - The string key representing the consumer.
-     * @param {Array<string>} flagSets - An array of the flag set names we want to get the treatments.
-     * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
-     * @returns {Treatments} The map with all the Treatment objects
+     * @param key - The string key representing the consumer.
+     * @param flagSets - An array of the flag set names we want to get the treatments.
+     * @param attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns The map with all the Treatment objects
      */
     getTreatmentsByFlagSets(key: SplitKey, flagSets: 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 feature flags related to the given flag sets.
      *
-     * @function getTreatmentsWithConfigByFlagSets
-     * @param {string} key - The string key representing the consumer.
-     * @param {Array<string>} flagSets - An array of the flag set names we want 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
+     * @param key - The string key representing the consumer.
+     * @param flagSets - An array of the flag set names we want to get the treatments.
+     * @param attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns The map with all the TreatmentWithConfig objects
      */
     getTreatmentsWithConfigByFlagSets(key: SplitKey, flagSets: string[], attributes?: Attributes): TreatmentsWithConfig;
     /**
      * Tracks an event to be fed to the results product on Split user interface.
      *
-     * @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. See {@link https://help.split.io/hc/en-us/articles/360019916311-Traffic-type}
-     * @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(key: SplitIO.SplitKey, trafficType: string, eventType: string, value?: number, properties?: Properties): boolean;
+     * @param key - The key that identifies the entity related to this event.
+     * @param trafficType - The traffic type of the entity related to this event. See {@link https://help.split.io/hc/en-us/articles/360019916311-Traffic-type}
+     * @param eventType - The event type corresponding to this event.
+     * @param value - The value of this event.
+     * @param properties - The properties of this event. Values can be string, number, boolean or null.
+     * @returns Whether the event was added to the queue successfully or not.
+     */
+    track(key: SplitKey, trafficType: string, eventType: string, value?: number, properties?: Properties): boolean;
   }
   /**
    * This represents the interface for the Client instance on server-side with asynchronous storage, like REDIS.
    * User key is not bound to the instance and must be provided on each method call, which returns a promise.
    * This interface is available in NodeJS, or when importing the 'server' sub-package in JS SDK (e.g., `import { SplitFactory } from '@splitsoftware/splitio/server'`).
-   *
-   * @interface INodeAsyncClient
-   * @extends IBasicClient
    */
-  interface INodeAsyncClient extends IBasicClient {
+  interface IAsyncClient extends IBasicClient {
     /**
      * Returns a Treatment value, which will be (or eventually be) the treatment string for the given feature.
      *
-     * @function getTreatment
-     * @param {string} key - The string key representing the consumer.
-     * @param {string} featureFlagName - The string that represents the feature flag we want to get the treatment.
-     * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
-     * @returns {AsyncTreatment} Treatment promise that resolves to the treatment string.
+     * @param key - The string key representing the consumer.
+     * @param featureFlagName - The string that represents the feature flag we want to get the treatment.
+     * @param attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns Treatment promise that resolves to the treatment string.
      */
     getTreatment(key: SplitKey, featureFlagName: 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.
      *
-     * @function getTreatmentWithConfig
-     * @param {string} key - The string key representing the consumer.
-     * @param {string} featureFlagName - The string that represents the feature flag we want to get the treatment.
-     * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
-     * @returns {AsyncTreatmentWithConfig} TreatmentWithConfig promise that resolves to the TreatmentWithConfig object.
+     * @param key - The string key representing the consumer.
+     * @param featureFlagName - The string that represents the feature flag we want to get the treatment.
+     * @param attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns TreatmentWithConfig promise that resolves to the TreatmentWithConfig object.
      */
     getTreatmentWithConfig(key: SplitKey, featureFlagName: string, attributes?: Attributes): AsyncTreatmentWithConfig;
     /**
      * Returns a Treatments value, which will be (or eventually be) an object map with the treatments for the given features.
      *
-     * @function getTreatments
-     * @param {string} key - The string key representing the consumer.
-     * @param {Array<string>} featureFlagNames - An array of the feature flag names we want to get the treatments.
-     * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
-     * @returns {AsyncTreatments} Treatments promise that resolves to the treatments object map.
+     * @param key - The string key representing the consumer.
+     * @param featureFlagNames - An array of the feature flag names we want to get the treatments.
+     * @param attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns Treatments promise that resolves to the treatments object map.
      */
     getTreatments(key: SplitKey, featureFlagNames: 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.
      *
-     * @function getTreatmentsWithConfig
-     * @param {string} key - The string key representing the consumer.
-     * @param {Array<string>} featureFlagNames - An array of the feature flag names we want to get the treatments.
-     * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
-     * @returns {AsyncTreatmentsWithConfig} TreatmentsWithConfig promise that resolves to the map of TreatmentsWithConfig objects.
+     * @param key - The string key representing the consumer.
+     * @param featureFlagNames - An array of the feature flag names we want to get the treatments.
+     * @param attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns TreatmentsWithConfig promise that resolves to the map of TreatmentsWithConfig objects.
      */
     getTreatmentsWithConfig(key: SplitKey, featureFlagNames: string[], attributes?: Attributes): AsyncTreatmentsWithConfig;
     /**
      * Returns a Treatments value, which is an object map with the treatments for the feature flags related to the given flag set.
      *
-     * @function getTreatmentsByFlagSet
-     * @param {string} key - The string key representing the consumer.
-     * @param {string} flagSet - The flag set name we want to get the treatments.
-     * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
-     * @returns {AsyncTreatments} Treatments promise that resolves to the treatments object map.
+     * @param key - The string key representing the consumer.
+     * @param flagSet - The flag set name we want to get the treatments.
+     * @param attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns Treatments promise that resolves to the treatments object map.
      */
     getTreatmentsByFlagSet(key: SplitKey, flagSet: string, attributes?: Attributes): AsyncTreatments;
     /**
      * Returns a TreatmentsWithConfig value, which is an object map with the TreatmentWithConfig (an object with both treatment and config string) for the feature flags related to the given flag set.
      *
-     * @function getTreatmentsWithConfigByFlagSet
-     * @param {string} key - The string key representing the consumer.
-     * @param {string} flagSet - The flag set name we want to get the treatments.
-     * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
-     * @returns {AsyncTreatmentsWithConfig} TreatmentsWithConfig promise that resolves to the map of TreatmentsWithConfig objects.
+     * @param key - The string key representing the consumer.
+     * @param flagSet - The flag set name we want to get the treatments.
+     * @param attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns TreatmentsWithConfig promise that resolves to the map of TreatmentsWithConfig objects.
      */
     getTreatmentsWithConfigByFlagSet(key: SplitKey, flagSet: string, attributes?: Attributes): AsyncTreatmentsWithConfig;
     /**
      * Returns a Returns a Treatments value, which is an object with both treatment and config string for to the feature flags related to the given flag sets.
      *
-     * @function getTreatmentsByFlagSets
-     * @param {string} key - The string key representing the consumer.
-     * @param {Array<string>} flagSets - An array of the flag set names we want to get the treatments.
-     * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
-     * @returns {AsyncTreatments} Treatments promise that resolves to the treatments object map.
+     * @param key - The string key representing the consumer.
+     * @param flagSets - An array of the flag set names we want to get the treatments.
+     * @param attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns Treatments promise that resolves to the treatments object map.
      */
     getTreatmentsByFlagSets(key: SplitKey, flagSets: string[], attributes?: Attributes): AsyncTreatments;
     /**
      * Returns a TreatmentsWithConfig value, which is an object map with the TreatmentWithConfig (an object with both treatment and config string) for the feature flags related to the given flag sets.
      *
-     * @function getTreatmentsWithConfigByFlagSets
-     * @param {string} key - The string key representing the consumer.
-     * @param {Array<string>} flagSets - An array of the flag set names we want to get the treatments.
-     * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
-     * @returns {AsyncTreatmentsWithConfig} TreatmentsWithConfig promise that resolves to the map of TreatmentsWithConfig objects.
+     * @param key - The string key representing the consumer.
+     * @param flagSets - An array of the flag set names we want to get the treatments.
+     * @param attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns TreatmentsWithConfig promise that resolves to the map of TreatmentsWithConfig objects.
      */
     getTreatmentsWithConfigByFlagSets(key: SplitKey, flagSets: string[], attributes?: Attributes): AsyncTreatmentsWithConfig;
     /**
      * Tracks an event to be fed to the results product on Split user interface, 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. See {@link https://help.split.io/hc/en-us/articles/360019916311-Traffic-type}
-     * @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.
-     */
-    track(key: SplitIO.SplitKey, trafficType: string, eventType: string, value?: number, properties?: Properties): Promise<boolean>;
+     * @param key - The key that identifies the entity related to this event.
+     * @param trafficType - The traffic type of the entity related to this event. See {@link https://help.split.io/hc/en-us/articles/360019916311-Traffic-type}
+     * @param eventType - The event type corresponding to this event.
+     * @param value - The value of this event.
+     * @param properties - The properties of this event. Values can be string, number, boolean or null.
+     * @returns A promise that resolves to a boolean indicating if the event was added to the queue successfully or not.
+     */
+    track(key: SplitKey, trafficType: string, eventType: string, value?: number, properties?: Properties): Promise<boolean>;
   }
   interface IClientWithAttributes extends IBasicClient {
     /**
-     * Add an attribute to client's in memory attributes storage.
+     * Add an attribute to client's in-memory attributes storage.
      *
-     * @param {string} attributeName Attribute name
-     * @param {AttributeType} attributeValue Attribute value
-     * @returns {boolean} true if the attribute was stored and false otherwise
+     * @param attributeName - Attribute name
+     * @param attributeValue - Attribute value
+     * @returns true if the attribute was stored and false otherwise
      */
     setAttribute(attributeName: string, attributeValue: AttributeType): boolean;
     /**
      * Returns the attribute with the given name.
      *
-     * @param {string} attributeName Attribute name
-     * @returns {AttributeType} Attribute with the given name
+     * @param attributeName - Attribute name
+     * @returns Attribute with the given name
      */
     getAttribute(attributeName: string): AttributeType;
     /**
-     * Removes from client's in memory attributes storage the attribute with the given name.
+     * Removes from client's in-memory attributes storage the attribute with the given name.
      *
-     * @param {string} attributeName
-     * @returns {boolean} true if attribute was removed and false otherwise
+     * @param attributeName - Attribute name
+     * @returns true if attribute was removed and false otherwise
      */
     removeAttribute(attributeName: string): boolean;
     /**
-     * Add to client's in memory attributes storage the attributes in 'attributes'.
+     * Add to client's in-memory attributes storage the attributes in 'attributes'.
      *
-     * @param {Attributes} attributes Object with attributes to store
+     * @param attributes - Object with attributes to store
      * @returns true if attributes were stored an false otherwise
      */
     setAttributes(attributes: Attributes): boolean;
     /**
-     * Return all the attributes stored in client's in memory attributes storage.
+     * Return all the attributes stored in client's in-memory attributes storage.
      *
-     * @returns {Attributes} returns all the stored attributes
+     * @returns returns all the stored attributes
      */
     getAttributes(): Attributes;
     /**
-     * Remove all the stored attributes in the client's in memory attribute storage.
+     * Remove all the stored attributes in the client's in-memory attribute storage.
      *
-     * @returns {boolean} true if all attribute were removed and false otherwise
+     * @returns true if all attribute were removed and false otherwise
      */
     clearAttributes(): boolean;
   }
   /**
    * This represents the interface for the Client instance on client-side, where the user key is bound to the instance on creation and does not need to be provided on each method call.
-   *
-   * @interface IClient
-   * @extends IClientWithAttributes
    */
-  interface IClient extends IClientWithAttributes {
+  interface IBrowserClient extends IClientWithAttributes {
     /**
      * Returns a Treatment value, which is the treatment string for the given feature.
      *
-     * @function getTreatment
-     * @param {string} featureFlagName - The string that represents the feature flag we want to get the treatment.
-     * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
-     * @returns {Treatment} The treatment string.
+     * @param featureFlagName - The string that represents the feature flag we want to get the treatment.
+     * @param attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns The treatment string.
      */
     getTreatment(featureFlagName: 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} featureFlagName - The string that represents the feature flag we want 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).
+     * @param featureFlagName - The string that represents the feature flag we want to get the treatment.
+     * @param attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns The map containing the treatment and the configuration stringified JSON (or null if there was no config for that treatment).
      */
     getTreatmentWithConfig(featureFlagName: 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>} featureFlagNames - An array of the feature flag names we want 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.
+     * @param featureFlagNames - An array of the feature flag names we want to get the treatments.
+     * @param attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns The treatments object map.
      */
     getTreatments(featureFlagNames: 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>} featureFlagNames - An array of the feature flag names we want 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
+     * @param featureFlagNames - An array of the feature flag names we want to get the treatments.
+     * @param attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns The map with all the TreatmentWithConfig objects
      */
     getTreatmentsWithConfig(featureFlagNames: string[], attributes?: Attributes): TreatmentsWithConfig;
     /**
      * Returns a Treatments value, which is an object map with the treatments for the feature flags related to the given flag set.
      *
-     * @function getTreatmentsByFlagSet
-     * @param {string} flagSet - The flag set name we want to get the treatments.
-     * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
-     * @returns {Treatments} The map with all the Treatments objects
+     * @param flagSet - The flag set name we want to get the treatments.
+     * @param attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns The map with all the Treatments objects
      */
     getTreatmentsByFlagSet(flagSet: 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 feature flags related to the given flag set.
      *
-     * @function getTreatmentsWithConfigByFlagSet
-     * @param {string} flagSet - The flag set name we want 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
+     * @param flagSet - The flag set name we want to get the treatments.
+     * @param attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns The map with all the TreatmentWithConfig objects
      */
     getTreatmentsWithConfigByFlagSet(flagSet: string, attributes?: Attributes): TreatmentsWithConfig;
     /**
      * Returns a Returns a Treatments value, which is an object with both treatment and config string for to the feature flags related to the given flag sets.
      *
-     * @function getTreatmentsByFlagSets
-     * @param {Array<string>} flagSets - An array of the flag set names we want to get the treatments.
-     * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
-     * @returns {Treatments} The map with all the Treatments objects
+     * @param flagSets - An array of the flag set names we want to get the treatments.
+     * @param attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns The map with all the Treatments objects
      */
     getTreatmentsByFlagSets(flagSets: 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 feature flags related to the given flag sets.
      *
-     * @function getTreatmentsWithConfigByFlagSets
-     * @param {Array<string>} flagSets - An array of the flag set names we want 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
+     * @param flagSets - An array of the flag set names we want to get the treatments.
+     * @param attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns The map with all the TreatmentWithConfig objects
      */
     getTreatmentsWithConfigByFlagSets(flagSets: string[], attributes?: Attributes): TreatmentsWithConfig;
     /**
      * Tracks an event to be fed to the results product on Split user interface.
      *
-     * @function track
-     * @param {string} trafficType - The traffic type of the entity related to this event. See {@link https://help.split.io/hc/en-us/articles/360019916311-Traffic-type}
-     * @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.
+     * @param trafficType - The traffic type of the entity related to this event. See {@link https://help.split.io/hc/en-us/articles/360019916311-Traffic-type}
+     * @param eventType - The event type corresponding to this event.
+     * @param value - The value of this event.
+     * @param properties - The properties of this event. Values can be string, number, boolean or null.
+     * @returns 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 asynchronous storage for client-side SDK, where each client has associated a key.
-   * @interface IAsyncClient
-   * @extends IClientWithAttributes
    */
-  interface IAsyncClient extends IClientWithAttributes {
+  interface IBrowserAsyncClient extends IClientWithAttributes {
     /**
      * Returns a Treatment value, which will be (or eventually be) the treatment string for the given feature.
      *
-     * @function getTreatment
-     * @param {string} featureFlagName - The string that represents the feature flag we want to get the treatment.
-     * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
-     * @returns {AsyncTreatment} Treatment promise that resolves to the treatment string.
+     * @param featureFlagName - The string that represents the feature flag we want to get the treatment.
+     * @param attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns Treatment promise that resolves to the treatment string.
      */
     getTreatment(featureFlagName: 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.
      *
-     * @function getTreatmentWithConfig
-     * @param {string} featureFlagName - The string that represents the feature flag we want to get the treatment.
-     * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
-     * @returns {AsyncTreatmentWithConfig} TreatmentWithConfig promise that resolves to the TreatmentWithConfig object.
+     * @param featureFlagName - The string that represents the feature flag we want to get the treatment.
+     * @param attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns TreatmentWithConfig promise that resolves to the TreatmentWithConfig object.
      */
     getTreatmentWithConfig(featureFlagName: string, attributes?: Attributes): AsyncTreatmentWithConfig;
     /**
      * Returns a Treatments value, which will be (or eventually be) an object map with the treatments for the given features.
      *
-     * @function getTreatments
-     * @param {Array<string>} featureFlagNames - An array of the feature flag names we want to get the treatments.
-     * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
-     * @returns {AsyncTreatments} Treatments promise that resolves to the treatments object map.
+     * @param featureFlagNames - An array of the feature flag names we want to get the treatments.
+     * @param attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns Treatments promise that resolves to the treatments object map.
      */
     getTreatments(featureFlagNames: 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.
      *
-     * @function getTreatmentsWithConfig
-     * @param {Array<string>} featureFlagNames - An array of the feature flag names we want to get the treatments.
-     * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
-     * @returns {AsyncTreatmentsWithConfig} TreatmentsWithConfig promise that resolves to the TreatmentsWithConfig object.
+     * @param featureFlagNames - An array of the feature flag names we want to get the treatments.
+     * @param attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns TreatmentsWithConfig promise that resolves to the TreatmentsWithConfig object.
      */
     getTreatmentsWithConfig(featureFlagNames: string[], attributes?: Attributes): AsyncTreatmentsWithConfig;
     /**
      * Returns a Treatments value, which is an object map with the treatments for the feature flags related to the given flag set.
      *
-     * @function getTreatmentsByFlagSet
-     * @param {string} flagSet - The flag set name we want to get the treatments.
-     * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
-     * @returns {AsyncTreatments} Treatments promise that resolves to the treatments object map.
+     * @param flagSet - The flag set name we want to get the treatments.
+     * @param attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns Treatments promise that resolves to the treatments object map.
      */
     getTreatmentsByFlagSet(flagSet: string, attributes?: Attributes): AsyncTreatments;
     /**
      * Returns a TreatmentsWithConfig value, which is an object map with the TreatmentWithConfig (an object with both treatment and config string) for the feature flags related to the given flag set.
      *
-     * @function getTreatmentsWithConfigByFlagSet
-     * @param {string} flagSet - The flag set name we want to get the treatments.
-     * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
-     * @returns {AsyncTreatmentsWithConfig} TreatmentsWithConfig promise that resolves to the TreatmentsWithConfig object.
+     * @param flagSet - The flag set name we want to get the treatments.
+     * @param attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns TreatmentsWithConfig promise that resolves to the TreatmentsWithConfig object.
      */
     getTreatmentsWithConfigByFlagSet(flagSet: string, attributes?: Attributes): AsyncTreatmentsWithConfig;
     /**
      * Returns a Returns a Treatments value, which is an object with both treatment and config string for to the feature flags related to the given flag sets.
      *
-     * @function getTreatmentsByFlagSets
-     * @param {Array<string>} flagSets - An array of the flag set names we want to get the treatments.
-     * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
-     * @returns {AsyncTreatments} Treatments promise that resolves to the treatments object map.
+     * @param flagSets - An array of the flag set names we want to get the treatments.
+     * @param attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns Treatments promise that resolves to the treatments object map.
      */
     getTreatmentsByFlagSets(flagSets: string[], attributes?: Attributes): AsyncTreatments;
     /**
      * Returns a TreatmentsWithConfig value, which is an object map with the TreatmentWithConfig (an object with both treatment and config string) for the feature flags related to the given flag sets.
      *
-     * @function getTreatmentsWithConfigByFlagSets
-     * @param {Array<string>} flagSets - An array of the flag set names we want to get the treatments.
-     * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
-     * @returns {AsyncTreatmentsWithConfig} TreatmentsWithConfig promise that resolves to the TreatmentsWithConfig object.
+     * @param flagSets - An array of the flag set names we want to get the treatments.
+     * @param attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns TreatmentsWithConfig promise that resolves to the TreatmentsWithConfig object.
      */
     getTreatmentsWithConfigByFlagSets(flagSets: string[], attributes?: Attributes): AsyncTreatmentsWithConfig;
     /**
      * Tracks an event to be fed to the results product on Split user interface, and returns a promise to signal when the event was successfully queued (or not).
      *
-     * @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} A promise that resolves to a boolean indicating if the event was added to the queue successfully or not.
+     * @param trafficType - The traffic type of the entity related to this event.
+     * @param eventType - The event type corresponding to this event.
+     * @param value - The value of this event.
+     * @param properties - The properties of this event. Values can be string, number, boolean or null.
+     * @returns A promise that resolves to a boolean indicating if the event was added to the queue successfully or not.
      */
     track(trafficType: string, eventType: string, value?: number, properties?: Properties): Promise<boolean>;
   }
   /**
    * Representation of a manager instance with synchronous storage of the SDK.
-   * @interface IManager
-   * @extends IStatusInterface
    */
   interface IManager extends IStatusInterface {
     /**
      * Get the array of feature flag names.
-     * @function names
-     * @returns {SplitNames} The list of feature flag names.
+     *
+     * @returns The list of feature flag names.
      */
     names(): SplitNames;
     /**
      * Get the array of feature flags data in SplitView format.
-     * @function splits
-     * @returns {SplitViews} The list of SplitIO.SplitView.
+     *
+     * @returns The list of SplitIO.SplitView.
      */
     splits(): SplitViews;
     /**
      * Get the data of a feature flag in SplitView format.
-     * @function split
-     * @param {string} featureFlagName The name of the feature flag we want to get info of.
-     * @returns {SplitView | null} The SplitIO.SplitView of the given feature flag name or null if the feature flag is not found.
+     *
+     * @param featureFlagName - The name of the feature flag we want to get info of.
+     * @returns The SplitIO.SplitView of the given feature flag name or null if the feature flag is not found.
      */
     split(featureFlagName: string): SplitView | null;
   }
   /**
    * Representation of a manager instance with asynchronous storage of the SDK.
-   * @interface IAsyncManager
-   * @extends IStatusInterface
    */
   interface IAsyncManager extends IStatusInterface {
     /**
      * Get the array of feature flag names.
-     * @function names
-     * @returns {SplitNamesAsync} A promise that resolves to the list of feature flag names.
+     *
+     * @returns A promise that resolves to the list of feature flag names.
      */
     names(): SplitNamesAsync;
     /**
      * Get the array of feature flags data in SplitView format.
-     * @function splits
-     * @returns {SplitViewsAsync} A promise that resolves to the SplitIO.SplitView list.
+     *
+     * @returns A promise that resolves to the SplitIO.SplitView list.
      */
     splits(): SplitViewsAsync;
     /**
      * Get the data of a feature flag in SplitView format.
-     * @function split
-     * @param {string} featureFlagName The name of the feature flag we want to get info of.
-     * @returns {SplitViewAsync} A promise that resolves to the SplitIO.SplitView value.
+     *
+     * @param featureFlagName - The name of the feature flag we want to get info of.
+     * @returns A promise that resolves to the SplitIO.SplitView value.
      */
     split(featureFlagName: string): SplitViewAsync;
   }