@splitsoftware/splitio-commons 2.5.0-rc.0 → 11.5.0-rc.0

package/src/sdkFactory/types.ts

@@ -1,119 +0,0 @@
-import { IIntegrationManager, IIntegrationFactoryParams } from '../integrations/types';
-import { ISignalListener } from '../listeners/types';
-import { IReadinessManager, ISdkReadinessManager } from '../readiness/types';
-import type { sdkManagerFactory } from '../sdkManager';
-import type { splitApiFactory } from '../services/splitApi';
-import { IFetch, ISplitApi, IEventSourceConstructor } from '../services/types';
-import { IStorageAsync, IStorageSync, IStorageFactoryParams } from '../storages/types';
-import { ISyncManager } from '../sync/types';
-import { IImpressionObserver } from '../trackers/impressionObserver/types';
-import { IImpressionsTracker, IEventTracker, ITelemetryTracker, IFilterAdapter, IUniqueKeysTracker } from '../trackers/types';
-import { ISettings } from '../types';
-import SplitIO from '../../types/splitio';
-
-/**
- * Environment related dependencies.
- */
-export interface IPlatform {
-  /**
-   * If provided, it is used to retrieve the Fetch API for HTTP requests. Otherwise, the global fetch is used.
-   */
-  getFetch?: (settings: ISettings) => (IFetch | undefined)
-  /**
-   * If provided, it is used to pass additional options to fetch and eventsource calls.
-   */
-  getOptions?: (settings: ISettings) => (object | undefined)
-  /**
-   * If provided, it is used to retrieve the EventSource constructor for streaming support.
-   */
-  getEventSource?: (settings: ISettings) => (IEventSourceConstructor | undefined)
-  /**
-   * EventEmitter constructor, like Node.js EventEmitter or a polyfill.
-   */
-  EventEmitter: new () => SplitIO.IEventEmitter,
-  /**
-   * Function used to track latencies for telemetry.
-   */
-  now?: () => number
-}
-
-export interface ISdkFactoryContext {
-  platform: IPlatform,
-  sdkReadinessManager: ISdkReadinessManager,
-  readiness: IReadinessManager,
-  settings: ISettings
-  impressionsTracker: IImpressionsTracker,
-  eventTracker: IEventTracker,
-  telemetryTracker: ITelemetryTracker,
-  storage: IStorageSync | IStorageAsync,
-  uniqueKeysTracker: IUniqueKeysTracker,
-  signalListener?: ISignalListener
-  splitApi?: ISplitApi
-  syncManager?: ISyncManager,
-  clients: Record<string, SplitIO.IBasicClient>,
-}
-
-export interface ISdkFactoryContextSync extends ISdkFactoryContext {
-  storage: IStorageSync,
-  splitApi: ISplitApi
-  syncManager: ISyncManager,
-}
-
-export interface ISdkFactoryContextAsync extends ISdkFactoryContext {
-  storage: IStorageAsync,
-  splitApi: undefined,
-  syncManager: undefined
-}
-
-/**
- * Object parameter with the modules required to create an SDK factory instance
- */
-export interface ISdkFactoryParams {
-  // If true, the `sdkFactory` is pure (no side effects), and the SDK instance includes a `init` method to run initialization side effects
-  lazyInit?: boolean,
-
-  // The settings must be already validated
-  settings: ISettings,
-
-  // Platform dependencies
-  platform: IPlatform,
-
-  // Storage factory. The result storage type implies the type of the SDK:
-  // sync SDK (`IBrowserSDK` and `ISDK`) with `IStorageSync`, and async SDK (`IBrowserAsyncSDK` and `IAsyncSDK`) with `IStorageAsync`
-  storageFactory: (params: IStorageFactoryParams) => IStorageSync | IStorageAsync,
-
-  // Factory of Split Api (HTTP Client Service).
-  // It is not required when providing an asynchronous storage or offline SyncManager
-  splitApiFactory?: typeof splitApiFactory,
-
-  // SyncManager factory.
-  // Not required when providing an asynchronous storage (consumer mode), but required in standalone mode to avoid SDK timeout.
-  // It can create an offline or online sync manager, with or without streaming support.
-  syncManagerFactory?: (params: ISdkFactoryContextSync) => ISyncManager,
-
-  // Sdk manager factory
-  sdkManagerFactory: typeof sdkManagerFactory,
-
-  // Sdk client method factory.
-  // It Allows to distinguish SDK clients with the client-side API (`IBrowserSDK` and `IBrowserAsyncSDK`) or server-side API (`ISDK` and `IAsyncSDK`).
-  sdkClientMethodFactory: (params: ISdkFactoryContext) => ({ (): SplitIO.IBrowserClient; (key: SplitIO.SplitKey): SplitIO.IBrowserClient; } | (() => SplitIO.IClient) | (() => SplitIO.IAsyncClient))
-
-  // Impression observer factory.
-  impressionsObserverFactory: () => IImpressionObserver
-
-  filterAdapterFactory?: () => IFilterAdapter
-
-  // Optional signal listener constructor. Used to handle special app states, like shutdown, app paused or resumed.
-  // Pass only if `syncManager` (used by NodeSignalListener) and `splitApi` (used by Browser listener) are passed.
-  SignalListener?: new (
-    syncManager: ISyncManager | undefined, // Used by NodeSignalListener to flush data, and by BrowserSignalListener to close streaming connection.
-    settings: ISettings, // Used by BrowserSignalListener
-    storage: IStorageSync | IStorageAsync, // Used by BrowserSignalListener
-    serviceApi: ISplitApi | undefined) => ISignalListener, // Used by BrowserSignalListener
-
-  // @TODO review impressionListener and integrations interfaces. What about handling impressionListener as an integration ?
-  integrationsManagerFactory?: (params: IIntegrationFactoryParams) => IIntegrationManager | undefined,
-
-  // Optional function to assign additional properties to the factory instance
-  extraProps?: (params: ISdkFactoryContext) => object
-}

package/src/sdkManager/index.ts

@@ -1,114 +0,0 @@
-import { objectAssign } from '../utils/lang/objectAssign';
-import { thenable } from '../utils/promise/thenable';
-import { find } from '../utils/lang';
-import { validateSplit, validateSplitExistence, validateIfNotDestroyed, validateIfOperational } from '../utils/inputValidation';
-import { ISplitsCacheAsync, ISplitsCacheSync } from '../storages/types';
-import { ISdkReadinessManager } from '../readiness/types';
-import { ISplit } from '../dtos/types';
-import { ISettings } from '../types';
-import SplitIO from '../../types/splitio';
-import { isConsumerMode } from '../utils/settingsValidation/mode';
-import { SPLIT_FN_LABEL, SPLITS_FN_LABEL, NAMES_FN_LABEL } from '../utils/constants';
-
-function collectTreatments(splitObject: ISplit) {
-  const conditions = splitObject.conditions;
-  // Rollout conditions are supposed to have the entire partitions list, so we find the first one.
-  let allTreatmentsCondition = find(conditions, (cond) => cond.conditionType === 'ROLLOUT');
-  // Localstorage mode could fall into a no rollout conditions state. Take the first condition in that case.
-  if (!allTreatmentsCondition) allTreatmentsCondition = conditions[0];
-  // Then extract the treatments from the partitions
-  return allTreatmentsCondition ? allTreatmentsCondition.partitions!.map(v => v.treatment) : [];
-}
-
-function objectToView(splitObject: ISplit | null): SplitIO.SplitView | null {
-  if (!splitObject) return null;
-
-  return {
-    name: splitObject.name,
-    trafficType: splitObject.trafficTypeName,
-    killed: splitObject.killed,
-    changeNumber: splitObject.changeNumber || 0,
-    treatments: collectTreatments(splitObject),
-    configs: splitObject.configurations || {},
-    sets: splitObject.sets || [],
-    defaultTreatment: splitObject.defaultTreatment,
-    impressionsDisabled: splitObject.impressionsDisabled === true,
-    prerequisites: (splitObject.prerequisites || []).map(p => ({ flagName: p.n, treatments: p.ts })),
-  };
-}
-
-function objectsToViews(splitObjects: ISplit[]) {
-  let views: SplitIO.SplitView[] = [];
-
-  splitObjects.forEach(split => {
-    const view = objectToView(split);
-    if (view) views.push(view);
-  });
-
-  return views;
-}
-
-export function sdkManagerFactory<TSplitCache extends ISplitsCacheSync | ISplitsCacheAsync>(
-  settings: Pick<ISettings, 'log' | 'mode'>,
-  splits: TSplitCache,
-  { readinessManager, sdkStatus }: ISdkReadinessManager,
-): TSplitCache extends ISplitsCacheAsync ? SplitIO.IAsyncManager : SplitIO.IManager {
-
-  const { log, mode } = settings;
-  const isAsync = isConsumerMode(mode);
-
-  return objectAssign(
-    // Proto-linkage of the readiness Event Emitter
-    Object.create(sdkStatus),
-    {
-      /**
-       * Get the feature flag object corresponding to the given feature flag name if valid
-       */
-      split(featureFlagName: string) {
-        const splitName = validateSplit(log, featureFlagName, SPLIT_FN_LABEL);
-        if (!validateIfNotDestroyed(log, readinessManager, SPLIT_FN_LABEL) || !validateIfOperational(log, readinessManager, SPLIT_FN_LABEL) || !splitName) {
-          return isAsync ? Promise.resolve(null) : null;
-        }
-
-        const split = splits.getSplit(splitName);
-
-        if (thenable(split)) {
-          return split.catch(() => null).then(result => { // handle possible rejections when using pluggable storage
-            validateSplitExistence(log, readinessManager, splitName, result, SPLIT_FN_LABEL);
-            return objectToView(result);
-          });
-        }
-
-        validateSplitExistence(log, readinessManager, splitName, split, SPLIT_FN_LABEL);
-
-        return objectToView(split);
-      },
-      /**
-       * Get the feature flag objects present on the factory storage
-       */
-      splits() {
-        if (!validateIfNotDestroyed(log, readinessManager, SPLITS_FN_LABEL) || !validateIfOperational(log, readinessManager, SPLITS_FN_LABEL)) {
-          return isAsync ? Promise.resolve([]) : [];
-        }
-        const currentSplits = splits.getAll();
-
-        return thenable(currentSplits) ?
-          currentSplits.catch(() => []).then(objectsToViews) : // handle possible rejections when using pluggable storage
-          objectsToViews(currentSplits);
-      },
-      /**
-       * Get the feature flag names present on the factory storage
-       */
-      names() {
-        if (!validateIfNotDestroyed(log, readinessManager, NAMES_FN_LABEL) || !validateIfOperational(log, readinessManager, NAMES_FN_LABEL)) {
-          return isAsync ? Promise.resolve([]) : [];
-        }
-        const splitNames = splits.getSplitNames();
-
-        return thenable(splitNames) ?
-          splitNames.catch(() => []) : // handle possible rejections when using pluggable storage
-          splitNames;
-      }
-    }
-  );
-}

package/src/services/decorateHeaders.ts

@@ -1,37 +0,0 @@
-import { objectAssign } from '../utils/lang/objectAssign';
-import { ISettings } from '../types';
-
-const FORBIDDEN_HEADERS = new Set([
-  'splitsdkclientkey',
-  'splitsdkversion',
-  'splitsdkmachineip',
-  'splitsdkmachinename',
-  'splitsdkimpressionsmode',
-  'host',
-  'referrer',
-  'content-type',
-  'content-length',
-  'content-encoding',
-  'accept',
-  'keep-alive',
-  'x-fastly-debug'
-]);
-
-export function decorateHeaders(settings: ISettings, headers: Record<string, string>) {
-  if (settings.sync.requestOptions?.getHeaderOverrides) {
-    try {
-      const headerOverrides = settings.sync.requestOptions.getHeaderOverrides({ headers: objectAssign({}, headers) });
-      Object.keys(headerOverrides)
-        .filter(key => !FORBIDDEN_HEADERS.has(key.toLowerCase()))
-        .forEach(key => headers[key] = headerOverrides[key]);
-    } catch (e) {
-      settings.log.error('Problem adding custom headers to request decorator: ' + e);
-    }
-  }
-  return headers;
-}
-
-export function removeNonISO88591(input: string) {
-  // eslint-disable-next-line no-control-regex
-  return input.replace(/[^\x00-\xFF]/g, '');
-}

package/src/services/splitApi.ts

@@ -1,148 +0,0 @@
-import { IPlatform } from '../sdkFactory/types';
-import { ISettings } from '../types';
-import { splitHttpClientFactory } from './splitHttpClient';
-import { ISplitApi } from './types';
-import { objectAssign } from '../utils/lang/objectAssign';
-import { ITelemetryTracker } from '../trackers/types';
-import { SPLITS, IMPRESSIONS, IMPRESSIONS_COUNT, EVENTS, TELEMETRY, TOKEN, SEGMENT, MEMBERSHIPS } from '../utils/constants';
-import { ERROR_TOO_MANY_SETS } from '../logger/constants';
-
-const noCacheHeaderOptions = { headers: { 'Cache-Control': 'no-cache' } };
-
-function userKeyToQueryParam(userKey: string) {
-  return 'users=' + encodeURIComponent(userKey); // no need to check availability of `encodeURIComponent`, since it is a global highly supported.
-}
-
-/**
- * Factory of SplitApi objects, which group the collection of Split HTTP endpoints used by the SDK
- *
- * @param settings - validated settings object
- * @param platform - object containing environment-specific dependencies
- * @param telemetryTracker - telemetry tracker
- */
-export function splitApiFactory(
-  settings: ISettings,
-  platform: Pick<IPlatform, 'getOptions' | 'getFetch'>,
-  telemetryTracker: ITelemetryTracker
-): ISplitApi {
-
-  const urls = settings.urls;
-  const filterQueryString = settings.sync.__splitFiltersValidation && settings.sync.__splitFiltersValidation.queryString;
-  const SplitSDKImpressionsMode = settings.sync.impressionsMode;
-  const splitHttpClient = splitHttpClientFactory(settings, platform);
-
-  return {
-    // @TODO throw errors if health check requests fail, to log them in the Synchronizer
-    getSdkAPIHealthCheck() {
-      const url = `${urls.sdk}/version`;
-      return splitHttpClient(url).then(() => true).catch(() => false);
-    },
-
-    getEventsAPIHealthCheck() {
-      const url = `${urls.events}/version`;
-      return splitHttpClient(url).then(() => true).catch(() => false);
-    },
-
-    fetchAuth(userMatchingKeys?: string[]) {
-      let url = `${urls.auth}/v2/auth?s=${settings.sync.flagSpecVersion}`;
-      if (userMatchingKeys) { // `userMatchingKeys` is undefined in server-side
-        const queryParams = userMatchingKeys.map(userKeyToQueryParam).join('&');
-        if (queryParams) url += '&' + queryParams;
-      }
-      return splitHttpClient(url, undefined, telemetryTracker.trackHttp(TOKEN));
-    },
-
-    fetchSplitChanges(since: number, noCache?: boolean, till?: number, rbSince?: number) {
-      const url = `${urls.sdk}/splitChanges?s=${settings.sync.flagSpecVersion}&since=${since}${rbSince ? '&rbSince=' + rbSince : ''}${filterQueryString || ''}${till ? '&till=' + till : ''}`;
-      return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SPLITS))
-        .catch((err) => {
-          if (err.statusCode === 414) settings.log.error(ERROR_TOO_MANY_SETS);
-          throw err;
-        });
-    },
-
-    fetchSegmentChanges(since: number, segmentName: string, noCache?: boolean, till?: number) {
-      const url = `${urls.sdk}/segmentChanges/${segmentName}?since=${since}${till ? '&till=' + till : ''}`;
-      return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SEGMENT));
-    },
-
-    fetchMemberships(userMatchingKey: string, noCache?: boolean, till?: number) {
-      /**
-       * URI encoding of user keys in order to:
-       *  - avoid 400 responses (due to URI malformed). E.g.: '/api/memberships/%'
-       *  - avoid 404 responses. E.g.: '/api/memberships/foo/bar'
-       *  - match user keys with special characters. E.g.: 'foo%bar', 'foo/bar'
-       */
-      const url = `${urls.sdk}/memberships/${encodeURIComponent(userMatchingKey)}${till ? '?till=' + till : ''}`;
-      return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(MEMBERSHIPS));
-    },
-
-    /**
-     * Post events.
-     *
-     * @param body -  Events bulk payload
-     * @param headers -  Optionals headers to overwrite default ones. For example, it is used in producer mode to overwrite metadata headers.
-     */
-    postEventsBulk(body: string, headers?: Record<string, string>) {
-      const url = `${urls.events}/events/bulk`;
-      return splitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(EVENTS));
-    },
-
-    /**
-     * Post impressions.
-     *
-     * @param body -  Impressions bulk payload
-     * @param headers -  Optionals headers to overwrite default ones. For example, it is used in producer mode to overwrite metadata headers.
-     */
-    postTestImpressionsBulk(body: string, headers?: Record<string, string>) {
-      const url = `${urls.events}/testImpressions/bulk`;
-      return splitHttpClient(url, {
-        // Adding extra headers to send impressions in OPTIMIZED or DEBUG modes.
-        method: 'POST', body, headers: objectAssign({ SplitSDKImpressionsMode }, headers)
-      }, telemetryTracker.trackHttp(IMPRESSIONS));
-    },
-
-    /**
-     * Post impressions counts.
-     *
-     * @param body -  Impressions counts payload
-     * @param headers -  Optionals headers to overwrite default ones. For example, it is used in producer mode to overwrite metadata headers.
-     */
-    postTestImpressionsCount(body: string, headers?: Record<string, string>) {
-      const url = `${urls.events}/testImpressions/count`;
-      return splitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(IMPRESSIONS_COUNT));
-    },
-
-    /**
-     * Post unique keys for client side.
-     *
-     * @param body -  unique keys payload
-     * @param headers -  Optionals headers to overwrite default ones. For example, it is used in producer mode to overwrite metadata headers.
-     */
-    postUniqueKeysBulkCs(body: string, headers?: Record<string, string>) {
-      const url = `${urls.telemetry}/v1/keys/cs`;
-      return splitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(TELEMETRY));
-    },
-
-    /**
-     * Post unique keys for server side.
-     *
-     * @param body -  unique keys payload
-     * @param headers -  Optionals headers to overwrite default ones. For example, it is used in producer mode to overwrite metadata headers.
-     */
-    postUniqueKeysBulkSs(body: string, headers?: Record<string, string>) {
-      const url = `${urls.telemetry}/v1/keys/ss`;
-      return splitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(TELEMETRY));
-    },
-
-    postMetricsConfig(body: string, headers?: Record<string, string>) {
-      const url = `${urls.telemetry}/v1/metrics/config`;
-      return splitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(TELEMETRY), true);
-    },
-
-    postMetricsUsage(body: string, headers?: Record<string, string>) {
-      const url = `${urls.telemetry}/v1/metrics/usage`;
-      return splitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(TELEMETRY), true);
-    }
-  };
-}

package/src/services/splitHttpClient.ts

@@ -1,84 +0,0 @@
-import { IRequestOptions, IResponse, ISplitHttpClient, NetworkError } from './types';
-import { objectAssign } from '../utils/lang/objectAssign';
-import { ERROR_HTTP, ERROR_CLIENT_CANNOT_GET_READY } from '../logger/constants';
-import { ISettings } from '../types';
-import { IPlatform } from '../sdkFactory/types';
-import { decorateHeaders, removeNonISO88591 } from './decorateHeaders';
-import { timeout } from '../utils/promise/timeout';
-
-const PENDING_FETCH_ERROR_TIMEOUT = 100;
-const messageNoFetch = 'Global fetch API is not available.';
-
-/**
- * Factory of Split HTTP clients, which are HTTP clients with predefined headers for Split endpoints.
- *
- * @param settings - SDK settings, used to access authorizationKey, logger instance and metadata (SDK version, ip and hostname) to set additional headers
- * @param platform - object containing environment-specific dependencies
- */
-export function splitHttpClientFactory(settings: ISettings, { getOptions, getFetch }: Pick<IPlatform, 'getOptions' | 'getFetch'>): ISplitHttpClient {
-
-  const { log, core: { authorizationKey }, version, runtime: { ip, hostname } } = settings;
-  const options = getOptions && getOptions(settings);
-  const fetch = getFetch && getFetch(settings);
-
-  // if fetch is not available, log Error
-  if (!fetch) log.error(ERROR_CLIENT_CANNOT_GET_READY, [messageNoFetch]);
-
-  const commonHeaders: Record<string, string> = {
-    'Accept': 'application/json',
-    'Content-Type': 'application/json',
-    'Authorization': `Bearer ${authorizationKey}`,
-    'SplitSDKVersion': version
-  };
-
-  if (ip) commonHeaders['SplitSDKMachineIP'] = ip;
-  if (hostname) commonHeaders['SplitSDKMachineName'] = removeNonISO88591(hostname);
-
-  return function httpClient(url: string, reqOpts: IRequestOptions = {}, latencyTracker: (error?: NetworkError) => void = () => { }, logErrorsAsInfo: boolean = false): Promise<IResponse> {
-
-    const request = objectAssign({
-      headers: decorateHeaders(settings, objectAssign({}, commonHeaders, reqOpts.headers || {})),
-      method: reqOpts.method || 'GET',
-      body: reqOpts.body
-    }, options);
-
-    // using `fetch(url, options)` signature to work with unfetch, a lightweight ponyfill of fetch API.
-    return fetch ? fetch(url, request)
-      // https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch#Checking_that_the_fetch_was_successful
-      .then(response => {
-        if (!response.ok) {
-          // timeout since `text()` promise might not settle in some fetch implementations and cases (e.g. no content)
-          return timeout(PENDING_FETCH_ERROR_TIMEOUT, response.text()).then(message => Promise.reject({ response, message }), () => Promise.reject({ response }));
-        }
-        latencyTracker();
-        return response;
-      })
-      .catch(error => {
-        const resp = error && error.response;
-        let msg = '';
-
-        if (resp) { // An HTTP error
-          switch (resp.status) {
-            case 404: msg = 'Invalid SDK key or resource not found.';
-              break;
-            // Don't use resp.statusText since reason phrase is removed in HTTP/2
-            default: msg = error.message;
-              break;
-          }
-        } else { // Something else, either an error making the request or a Network error.
-          msg = error.message || 'Network Error';
-        }
-
-        if (!resp || resp.status !== 403) { // 403's log we'll be handled somewhere else.
-          log[logErrorsAsInfo ? 'info' : 'error'](ERROR_HTTP, [resp ? 'status code ' + resp.status : 'no status code', url, msg]);
-        }
-
-        const networkError: NetworkError = new Error(msg);
-        // passes `undefined` as statusCode if not an HTTP error (resp === undefined)
-        networkError.statusCode = resp && resp.status;
-
-        latencyTracker(networkError);
-        throw networkError;
-      }) : Promise.reject(new Error(messageNoFetch));
-  };
-}

package/src/services/types.ts

@@ -1,86 +0,0 @@
-export type IRequestOptions = {
-	method?: string,
-	headers?: Record<string, string>,
-	body?: string
-};
-
-export type IResponse = {
-	ok: boolean,
-	status: number,
-	json: () => Promise<any>, // Used to parse OK response body. Promise rejects if body cannot be parsed
-	text: () => Promise<string>, // Used to read Not OK response body. Promise never rejects
-
-	/** Other available properties when using Unfetch */
-	// statusText: string, // `undefined` in Web fetch since HTTP/2 doesn't have reason phrases anymore. `node-fetch` overwrites it depending on the status code
-	// url: string,
-	// blob: () => Promise<Blob>,
-	// clone: () => IResponse,
-	// headers: {
-	// 	keys: () => string[],
-	// 	entries: () => Array<[string, string]>,
-	// 	get: (key: string) => string | undefined,
-	// 	has: (key: string) => boolean,
-	// }
-}
-
-export type NetworkError = Error & { statusCode?: number }
-
-// Reduced version of Fetch API
-export type IFetch = (url: string, options?: IRequestOptions) => Promise<IResponse>
-
-// IFetch specialization
-export type IHealthCheckAPI = () => Promise<boolean>
-
-export type ISplitHttpClient = (url: string, options?: IRequestOptions, latencyTracker?: (error?: NetworkError) => void, logErrorsAsInfo?: boolean) => Promise<IResponse>
-
-export type IFetchAuth = (userKeys?: string[]) => Promise<IResponse>
-
-export type IFetchSplitChanges = (since: number, noCache?: boolean, till?: number, rbSince?: number) => Promise<IResponse>
-
-export type IFetchSegmentChanges = (since: number, segmentName: string, noCache?: boolean, till?: number) => Promise<IResponse>
-
-export type IFetchMemberships = (userMatchingKey: string, noCache?: boolean, till?: number) => Promise<IResponse>
-
-export type IPostEventsBulk = (body: string, headers?: Record<string, string>) => Promise<IResponse>
-
-export type IPostUniqueKeysBulkCs = (body: string, headers?: Record<string, string>) => Promise<IResponse>
-
-export type IPostUniqueKeysBulkSs = (body: string, headers?: Record<string, string>) => Promise<IResponse>
-
-export type IPostTestImpressionsBulk = (body: string, headers?: Record<string, string>) => Promise<IResponse>
-
-export type IPostTestImpressionsCount = (body: string, headers?: Record<string, string>) => Promise<IResponse>
-
-export type IPostMetricsConfig = (body: string, headers?: Record<string, string>) => Promise<IResponse>
-
-export type IPostMetricsUsage = (body: string, headers?: Record<string, string>) => Promise<IResponse>
-
-export interface ISplitApi {
-	getSdkAPIHealthCheck: IHealthCheckAPI
-	getEventsAPIHealthCheck: IHealthCheckAPI
-	fetchAuth: IFetchAuth
-	fetchSplitChanges: IFetchSplitChanges
-	fetchSegmentChanges: IFetchSegmentChanges
-	fetchMemberships: IFetchMemberships
-	postEventsBulk: IPostEventsBulk
-	postUniqueKeysBulkCs: IPostUniqueKeysBulkCs
-	postUniqueKeysBulkSs: IPostUniqueKeysBulkSs
-	postTestImpressionsBulk: IPostTestImpressionsBulk
-	postTestImpressionsCount: IPostTestImpressionsCount
-	postMetricsConfig: IPostMetricsConfig
-	postMetricsUsage: IPostMetricsUsage
-}
-
-// Minimal version of EventSource API used by the SDK
-interface EventSourceEventMap {
-	'error': Event
-	'message': MessageEvent
-	'open': Event
-}
-
-interface IEventSource {
-	addEventListener<K extends keyof EventSourceEventMap>(type: K, listener: (this: IEventSource, ev: EventSourceEventMap[K]) => any): void
-	close(): void
-}
-
-export type IEventSourceConstructor = new (url: string, eventSourceInitDict?: any) => IEventSource