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

package/src/utils/constants/index.ts

@@ -1,4 +1,4 @@
-import { StorageType } from '../../types';
+import { StorageType } from '../../storages/types';
 import { SDKMode } from '../../types';
 
 // Special treatments
@@ -19,6 +19,7 @@ export const SPLIT_EVENT = 'EVENT';
 // Impression collection modes
 export const DEBUG = 'DEBUG';
 export const OPTIMIZED = 'OPTIMIZED';
+export const NONE = 'NONE';
 
 // SDK Modes
 export const LOCALHOST_MODE: SDKMode = 'localhost';
@@ -49,6 +50,7 @@ export const CONSUMER_PARTIAL_ENUM = 2;
 
 export const OPTIMIZED_ENUM = 0;
 export const DEBUG_ENUM = 1;
+export const NONE_ENUM = 2;
 
 export const SPLITS = 'sp';
 export const IMPRESSIONS = 'im';

package/src/utils/inputValidation/apiKey.ts

@@ -1,5 +1,5 @@
 import { ERROR_NULL, ERROR_EMPTY, ERROR_INVALID, WARN_API_KEY, LOG_PREFIX_INSTANTIATION } from '../../logger/constants';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 import { isString } from '../lang';
 
 const item = 'api_key';

package/src/utils/inputValidation/attribute.ts

@@ -1,5 +1,5 @@
 import { isString, isFiniteNumber, isBoolean } from '../../utils/lang';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 
 export function validateAttribute(log: ILogger, attributeKey: string, attributeValue: Object, method: string): boolean {
   if (!isString(attributeKey) || attributeKey.length === 0) {

package/src/utils/inputValidation/attributes.ts

@@ -1,10 +1,10 @@
 import { isObject } from '../lang';
-import { Attributes } from '../../types';
-import { ILogger } from '../../types';
+import { SplitIO } from '../../types';
+import { ILogger } from '../../logger/types';
 import { validateAttribute } from './attribute';
 import { ERROR_NOT_PLAIN_OBJECT } from '../../logger/constants';
 
-export function validateAttributes(log: ILogger, maybeAttrs: any, method: string): Attributes | undefined | false {
+export function validateAttributes(log: ILogger, maybeAttrs: any, method: string): SplitIO.Attributes | undefined | false {
   // Attributes are optional
   if (maybeAttrs == undefined || isObject(maybeAttrs)) // eslint-disable-line eqeqeq
     return maybeAttrs;

package/src/utils/inputValidation/event.ts

@@ -1,5 +1,5 @@
 import { ERROR_EVENT_TYPE_FORMAT, ERROR_NULL, ERROR_INVALID, ERROR_EMPTY } from '../../logger/constants';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 import { isString } from '../lang';
 
 const EVENT_TYPE_REGEX = /^[a-zA-Z0-9][-_.:a-zA-Z0-9]{0,79}$/;

package/src/utils/inputValidation/eventProperties.ts

@@ -1,7 +1,7 @@
 import { isObject, isString, isFiniteNumber, isBoolean } from '../lang';
 import { objectAssign } from '../lang/objectAssign';
-import { Properties } from '../../types';
-import { ILogger } from '../../types';
+import { SplitIO } from '../../types';
+import { ILogger } from '../../logger/types';
 import { ERROR_NOT_PLAIN_OBJECT, ERROR_SIZE_EXCEEDED, WARN_SETTING_NULL, WARN_TRIMMING_PROPERTIES } from '../../logger/constants';
 
 const ECMA_SIZES = {
@@ -14,7 +14,7 @@ const MAX_PROPERTIES_AMOUNT = 300;
 const MAX_EVENT_SIZE = 1024 * 32;
 const BASE_EVENT_SIZE = 1024; // We assume 1kb events without properties (avg measured)
 
-export function validateEventProperties(log: ILogger, maybeProperties: any, method: string): { properties: Properties | null | false, size: number } {
+export function validateEventProperties(log: ILogger, maybeProperties: any, method: string): { properties: SplitIO.Properties | null | false, size: number } {
   if (maybeProperties == undefined) return { properties: null, size: BASE_EVENT_SIZE }; // eslint-disable-line eqeqeq
 
   if (!isObject(maybeProperties)) {

package/src/utils/inputValidation/eventValue.ts

@@ -1,5 +1,5 @@
 import { ERROR_NOT_FINITE } from '../../logger/constants';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 import { isFiniteNumber } from '../lang';
 
 export function validateEventValue(log: ILogger, maybeValue: any, method: string): number | false {

package/src/utils/inputValidation/isOperational.ts

@@ -1,5 +1,5 @@
 import { ERROR_CLIENT_DESTROYED, CLIENT_NOT_READY } from '../../logger/constants';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 import { IReadinessManager } from '../../readiness/types';
 
 export function validateIfNotDestroyed(log: ILogger, readinessManager: IReadinessManager, method: string): boolean {

package/src/utils/inputValidation/key.ts

@@ -1,6 +1,6 @@
 import { isObject, isString, isFiniteNumber, toString } from '../lang';
-import { SplitKey } from '../../types';
-import { ILogger } from '../../types';
+import { SplitIO } from '../../types';
+import { ILogger } from '../../logger/types';
 import { ERROR_NULL, WARN_CONVERTING, ERROR_EMPTY, ERROR_TOO_LONG, ERROR_INVALID, ERROR_INVALID_KEY_OBJECT } from '../../logger/constants';
 
 const KEY_MAX_LENGTH = 250;
@@ -33,7 +33,7 @@ function validateKeyValue(log: ILogger, maybeKey: any, method: string, type: str
   return false;
 }
 
-export function validateKey(log: ILogger, maybeKey: any, method: string): SplitKey | false {
+export function validateKey(log: ILogger, maybeKey: any, method: string): SplitIO.SplitKey | false {
   if (isObject(maybeKey)) {
     // Validate key object
     const matchingKey = validateKeyValue(log, maybeKey.matchingKey, method, 'matchingKey');

package/src/utils/inputValidation/preloadedData.ts

@@ -1,7 +1,7 @@
 import { isObject, isString, isFiniteNumber } from '../lang';
 import { validateSplit } from './split';
-import { ILogger } from '../../types';
-import { PreloadedData } from '../../storages/types';
+import { SplitIO } from '../../types';
+import { ILogger } from '../../logger/types';
 
 function validateTimestampData(log: ILogger, maybeTimestamp: any, method: string, item: string) {
   if (isFiniteNumber(maybeTimestamp) && maybeTimestamp > -1) return true;
@@ -42,7 +42,7 @@ function validateSegmentsData(log: ILogger, maybeSegmentsData: any, method: stri
   return false;
 }
 
-export function validatePreloadedData(log: ILogger, maybePreloadedData: any, method: string): maybePreloadedData is PreloadedData {
+export function validatePreloadedData(log: ILogger, maybePreloadedData: any, method: string): maybePreloadedData is SplitIO.PreloadedData {
   if (!isObject(maybePreloadedData)) {
     log.error(`${method}: preloadedData must be an object.`);
   } else if (

package/src/utils/inputValidation/split.ts

@@ -1,5 +1,5 @@
 import { ERROR_NULL, ERROR_INVALID, WARN_TRIMMING, ERROR_EMPTY } from '../../logger/constants';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 import { isString } from '../lang';
 
 // include BOM and nbsp

package/src/utils/inputValidation/splitExistance.ts

@@ -1,6 +1,6 @@
 import { SPLIT_NOT_FOUND } from '../labels';
 import { IReadinessManager } from '../../readiness/types';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 import { WARN_NOT_EXISTENT_SPLIT } from '../../logger/constants';
 
 /**

package/src/utils/inputValidation/splits.ts

@@ -1,5 +1,5 @@
 import { ERROR_EMPTY_ARRAY } from '../../logger/constants';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 import { uniq } from '../lang';
 import { validateSplit } from './split';
 

package/src/utils/inputValidation/trafficType.ts

@@ -1,5 +1,5 @@
 import { ERROR_NULL, ERROR_INVALID, ERROR_EMPTY, WARN_LOWERCASE_TRAFFIC_TYPE } from '../../logger/constants';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 import { isString } from '../lang';
 
 const CAPITAL_LETTERS_REGEX = /[A-Z]/;

package/src/utils/inputValidation/trafficTypeExistance.ts

@@ -4,7 +4,7 @@ import { ISplitsCacheBase } from '../../storages/types';
 import { IReadinessManager } from '../../readiness/types';
 import { SDKMode } from '../../types';
 import { MaybeThenable } from '../../dtos/types';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 import { WARN_NOT_EXISTENT_TT } from '../../logger/constants';
 
 function logTTExistanceWarning(log: ILogger, maybeTT: string, method: string) {

package/src/utils/key/index.ts

@@ -1,29 +1,29 @@
-import { SplitKey, SplitKeyObject } from '../../types';
+import { SplitIO } from '../../types';
 import { isObject } from '../lang';
 
-// function isSplitKeyObject(key: any): key is SplitKeyObject {
+// function isSplitKeyObject(key: any): key is SplitIO.SplitKeyObject {
 //   return key !== undefined && key !== null && typeof key.matchingKey === 'string';
 // }
 
 // returns the matchingKey if the Key is defined as an object or the key itself if it is a string
-export function getMatching(key?: SplitKey): string {
-  return isObject(key) ? (key as SplitKeyObject).matchingKey : key as string;
+export function getMatching(key: SplitIO.SplitKey): string {
+  return isObject(key) ? (key as SplitIO.SplitKeyObject).matchingKey : key as string;
 }
 
 // if the key is a string, there's no bucketingKey (undefined)
-export function getBucketing(key: SplitKey): string | undefined {
-  return isObject(key) ? (key as SplitKeyObject).bucketingKey : undefined;
+export function getBucketing(key: SplitIO.SplitKey): string | undefined {
+  return isObject(key) ? (key as SplitIO.SplitKeyObject).bucketingKey : undefined;
 }
 
 /**
  * Verify type of key and return a valid object key used for get treatment for a
  * specific split.
  */
-export function keyParser(key: SplitKey): SplitKeyObject {
+export function keyParser(key: SplitIO.SplitKey): SplitIO.SplitKeyObject {
   if (isObject(key)) {
     return {
-      matchingKey: (key as SplitKeyObject).matchingKey,
-      bucketingKey: (key as SplitKeyObject).bucketingKey
+      matchingKey: (key as SplitIO.SplitKeyObject).matchingKey,
+      bucketingKey: (key as SplitIO.SplitKeyObject).bucketingKey
     };
   } else {
     return {

package/src/utils/settingsValidation/consent.ts

@@ -1,5 +1,6 @@
 import { ERROR_INVALID_CONFIG_PARAM } from '../../logger/constants';
-import { ConsentStatus, ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
+import { ConsentStatus } from '../../types';
 import { CONSENT_DECLINED, CONSENT_GRANTED, CONSENT_UNKNOWN } from '../constants';
 import { stringToUpperCase } from '../lang';
 

package/src/utils/settingsValidation/impressionsMode.ts

@@ -1,14 +1,14 @@
 import { ERROR_INVALID_CONFIG_PARAM } from '../../logger/constants';
-import { ILogger } from '../../types';
-import { ImpressionsMode } from '../../types';
-import { DEBUG, OPTIMIZED } from '../constants';
+import { ILogger } from '../../logger/types';
+import { SplitIO } from '../../types';
+import { DEBUG, OPTIMIZED, NONE } from '../constants';
 import { stringToUpperCase } from '../lang';
 
-export function validImpressionsMode(log: ILogger, impressionsMode: any): ImpressionsMode {
+export function validImpressionsMode(log: ILogger, impressionsMode: any): SplitIO.ImpressionsMode {
   impressionsMode = stringToUpperCase(impressionsMode);
 
-  if ([DEBUG, OPTIMIZED].indexOf(impressionsMode) > -1) return impressionsMode;
+  if ([DEBUG, OPTIMIZED, NONE].indexOf(impressionsMode) > -1) return impressionsMode;
 
-  log.error(ERROR_INVALID_CONFIG_PARAM, ['impressionsMode', [DEBUG, OPTIMIZED], OPTIMIZED]);
+  log.error(ERROR_INVALID_CONFIG_PARAM, ['impressionsMode', [DEBUG, OPTIMIZED, NONE], OPTIMIZED]);
   return OPTIMIZED;
 }

package/src/utils/settingsValidation/index.ts

@@ -36,6 +36,8 @@ export const base = {
     telemetryRefreshRate: 3600,
     // publish evaluations each 300 sec (default value for OPTIMIZED impressions mode)
     impressionsRefreshRate: 300,
+    // publish unique Keys each 900 sec (15 min) 
+    uniqueKeysRefreshRate: 900,
     // fetch offline changes each 15 sec
     offlineRefreshRate: 15,
     // publish events every 60 seconds after the first flush
@@ -130,11 +132,14 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
   scheduler.segmentsRefreshRate = fromSecondsToMillis(scheduler.segmentsRefreshRate);
   scheduler.offlineRefreshRate = fromSecondsToMillis(scheduler.offlineRefreshRate);
   scheduler.eventsPushRate = fromSecondsToMillis(scheduler.eventsPushRate);
+  scheduler.uniqueKeysRefreshRate = fromSecondsToMillis(scheduler.uniqueKeysRefreshRate);
+  scheduler.impressionCountsRefreshRate = fromSecondsToMillis(scheduler.impressionCountsRefreshRate);
   scheduler.telemetryRefreshRate = fromSecondsToMillis(validateMinValue('telemetryRefreshRate', scheduler.telemetryRefreshRate, 60));
 
   // Default impressionsRefreshRate for DEBUG mode is 60 secs
   if (get(config, 'scheduler.impressionsRefreshRate') === undefined && withDefaults.sync.impressionsMode === DEBUG) scheduler.impressionsRefreshRate = 60;
   scheduler.impressionsRefreshRate = fromSecondsToMillis(scheduler.impressionsRefreshRate);
+  
 
   // Log deprecation for old telemetry param
   if (scheduler.metricsRefreshRate) log.warn('`metricsRefreshRate` will be deprecated soon. For configuring telemetry rates, update `telemetryRefreshRate` value in configs');
@@ -200,7 +205,6 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
   // validate the `splitFilters` settings and parse splits query
   const splitFiltersValidation = validateSplitFilters(log, withDefaults.sync.splitFilters, withDefaults.mode);
   withDefaults.sync.splitFilters = splitFiltersValidation.validFilters;
-  // @ts-ignore
   withDefaults.sync.__splitFiltersValidation = splitFiltersValidation;
 
   // ensure a valid user consent value

package/src/utils/settingsValidation/integrations/common.ts

@@ -1,5 +1,5 @@
 import { WARN_INTEGRATION_INVALID } from '../../../logger/constants';
-import { ILogger } from '../../../types';
+import { ILogger } from '../../../logger/types';
 
 /**
  * This function validates `settings.integrations` object

package/src/utils/settingsValidation/integrations/configurable.ts

@@ -1,6 +1,6 @@
 import { validateIntegrations } from './common';
 import { isString } from '../../lang';
-import { ILogger } from '../../../types';
+import { ILogger } from '../../../logger/types';
 
 /**
  * This function validates `settings.integrations` object that consists of a list of configuration items, used by the isomorphic JS SDK.

package/src/utils/settingsValidation/integrations/pluggable.ts

@@ -1,5 +1,6 @@
-import { ISettings, ILogger } from '../../../types';
+import { ISettings } from '../../../types';
 import { validateIntegrations } from './common';
+import { ILogger } from '../../../logger/types';
 
 /**
  * This function validates `settings.integrations` object that consists of a list of pluggable integration factories.

package/src/utils/settingsValidation/localhost/builtin.ts

@@ -1,4 +1,5 @@
-import { SDKMode, ILogger } from '../../../types';
+import { ILogger } from '../../../logger/types';
+import { SDKMode, } from '../../../types';
 import { LocalhostFromObject } from '../../../sync/offline/LocalhostFromObject';
 import { validateLocalhost } from './pluggable';
 

package/src/utils/settingsValidation/localhost/pluggable.ts

@@ -1,5 +1,6 @@
 import { ERROR_LOCALHOST_MODULE_REQUIRED } from '../../../logger/constants';
-import { SDKMode, ILogger } from '../../../types';
+import { ILogger } from '../../../logger/types';
+import { SDKMode, } from '../../../types';
 import { LOCALHOST_MODE } from '../../constants';
 
 /**

package/src/utils/settingsValidation/logger/builtinLogger.ts

@@ -1,10 +1,11 @@
 import { isLogLevelString, Logger, LogLevels } from '../../../logger';
+import { ILogger } from '../../../logger/types';
 import { isLocalStorageAvailable } from '../../env/isLocalStorageAvailable';
 import { isNode } from '../../env/isNode';
 import { codesDebug } from '../../../logger/messages/debug';
 import { _Map } from '../../lang/maps';
 import { getLogLevel } from './commons';
-import { LogLevel, ILogger } from '../../../types';
+import { LogLevel } from '../../../types';
 
 const allCodes = new _Map(codesDebug);
 

package/src/utils/settingsValidation/logger/pluggableLogger.ts

@@ -1,5 +1,6 @@
 import { Logger, LogLevels } from '../../../logger';
-import { LogLevel, ILogger } from '../../../types';
+import { ILogger } from '../../../logger/types';
+import { LogLevel } from '../../../types';
 import { getLogLevel } from './commons';
 
 function isLogger(log: any): log is ILogger {

package/src/utils/settingsValidation/splitFilters.ts

@@ -1,18 +1,20 @@
 import { STANDALONE_MODE } from '../constants';
 import { validateSplits } from '../inputValidation/splits';
-import { ISplitFiltersValidation, SplitFilterType, ILogger } from '../../types';
+import { ISplitFiltersValidation } from '../../dtos/types';
+import { SplitIO } from '../../types';
+import { ILogger } from '../../logger/types';
 import { WARN_SPLITS_FILTER_IGNORED, WARN_SPLITS_FILTER_EMPTY, WARN_SPLITS_FILTER_INVALID, SETTINGS_SPLITS_FILTER, LOG_PREFIX_SETTINGS } from '../../logger/constants';
 
 // Split filters metadata.
 // Ordered according to their precedency when forming the filter query string: `&names=<values>&prefixes=<values>`
 const FILTERS_METADATA = [
   {
-    type: 'byName' as SplitFilterType,
+    type: 'byName' as SplitIO.SplitFilterType,
     maxLength: 400,
     queryParam: 'names='
   },
   {
-    type: 'byPrefix' as SplitFilterType,
+    type: 'byPrefix' as SplitIO.SplitFilterType,
     maxLength: 50,
     queryParam: 'prefixes='
   }
@@ -21,7 +23,7 @@ const FILTERS_METADATA = [
 /**
  * Validates that the given value is a valid filter type
  */
-function validateFilterType(maybeFilterType: any): maybeFilterType is SplitFilterType {
+function validateFilterType(maybeFilterType: any): maybeFilterType is SplitIO.SplitFilterType {
   return FILTERS_METADATA.some(filterMetadata => filterMetadata.type === maybeFilterType);
 }
 
@@ -35,7 +37,7 @@ function validateFilterType(maybeFilterType: any): maybeFilterType is SplitFilte
  *
  * @throws Error if the sanitized list exceeds the length indicated by `maxLength`
  */
-function validateSplitFilter(log: ILogger, type: SplitFilterType, values: string[], maxLength: number) {
+function validateSplitFilter(log: ILogger, type: SplitIO.SplitFilterType, values: string[], maxLength: number) {
   // validate and remove invalid and duplicated values
   let result = validateSplits(log, values, LOG_PREFIX_SETTINGS, `${type} filter`, `${type} filter value`);
 
@@ -61,7 +63,7 @@ function validateSplitFilter(log: ILogger, type: SplitFilterType, values: string
  * @param {Object} groupedFilters object of filters. Each filter must be a list of valid, unique and ordered string values.
  * @returns null or string with the `split filter query` component of the URL.
  */
-function queryStringBuilder(groupedFilters: Record<SplitFilterType, string[]>) {
+function queryStringBuilder(groupedFilters: Record<SplitIO.SplitFilterType, string[]>) {
   const queryParams: string[] = [];
   FILTERS_METADATA.forEach(({ type, queryParam }) => {
     const filter = groupedFilters[type];
@@ -107,7 +109,7 @@ export function validateSplitFilters(log: ILogger, maybeSplitFilters: any, mode:
   // Validate filters and group their values by filter type inside `groupedFilters` object
   res.validFilters = maybeSplitFilters.filter((filter, index) => {
     if (filter && validateFilterType(filter.type) && Array.isArray(filter.values)) {
-      res.groupedFilters[filter.type as SplitFilterType] = res.groupedFilters[filter.type as SplitFilterType].concat(filter.values);
+      res.groupedFilters[filter.type as SplitIO.SplitFilterType] = res.groupedFilters[filter.type as SplitIO.SplitFilterType].concat(filter.values);
       return true;
     } else {
       log.warn(WARN_SPLITS_FILTER_INVALID, [index]);

package/src/utils/settingsValidation/storage/storageCS.ts

@@ -1,5 +1,6 @@
 import { InMemoryStorageCSFactory } from '../../../storages/inMemory/InMemoryStorageCS';
-import { ISettings, SDKMode, ILogger } from '../../../types';
+import { ISettings, SDKMode } from '../../../types';
+import { ILogger } from '../../../logger/types';
 import { ERROR_STORAGE_INVALID } from '../../../logger/constants';
 import { LOCALHOST_MODE, STANDALONE_MODE, STORAGE_PLUGGABLE, STORAGE_LOCALSTORAGE, STORAGE_MEMORY } from '../../../utils/constants';
 import { IStorageFactoryParams, IStorageSync } from '../../../storages/types';

package/types/consent/index.d.ts

@@ -0,0 +1,2 @@
+import { ISettings } from '../types';
+export declare function isConsentGranted(settings: ISettings): boolean;

package/types/consent/sdkUserConsent.d.ts

@@ -0,0 +1,13 @@
+import { ISdkFactoryContext } from '../sdkFactory/types';
+/**
+ * The public user consent API exposed via SplitFactory, used to control if the SDK tracks and sends impressions and events or not.
+ */
+export declare function createUserConsentAPI(params: ISdkFactoryContext): {
+    setStatus(consent: unknown): boolean;
+    getStatus(): import("../types").ConsentStatus | undefined;
+    Status: {
+        GRANTED: string;
+        DECLINED: string;
+        UNKNOWN: string;
+    };
+};

package/types/dtos/types.d.ts

@@ -0,0 +1,172 @@
+import { SplitIO } from '../types';
+export declare type MaybeThenable<T> = T | Promise<T>;
+/** Split Matchers */
+export declare type IMatcherDataType = null | 'DATETIME' | 'NUMBER';
+export interface IUnaryNumericMatcherData {
+    dataType: IMatcherDataType;
+    value: number;
+}
+export interface IBetweenMatcherData {
+    dataType: IMatcherDataType;
+    start: number;
+    end: number;
+}
+export interface IWhitelistMatcherData {
+    whitelist: string[];
+}
+export interface IInSegmentMatcherData {
+    segmentName: string;
+}
+export interface IDependencyMatcherData {
+    split: string;
+    treatments: string[];
+}
+interface ISplitMatcherBase {
+    matcherType: string;
+    negate: boolean;
+    keySelector: null | {
+        trafficType: string;
+        attribute: string | null;
+    };
+    userDefinedSegmentMatcherData?: null | IInSegmentMatcherData;
+    whitelistMatcherData?: null | IWhitelistMatcherData;
+    unaryNumericMatcherData?: null | IUnaryNumericMatcherData;
+    betweenMatcherData?: null | IBetweenMatcherData;
+    dependencyMatcherData?: null | IDependencyMatcherData;
+    booleanMatcherData?: null | boolean;
+    stringMatcherData?: null | string;
+}
+interface IAllKeysMatcher extends ISplitMatcherBase {
+    matcherType: 'ALL_KEYS';
+}
+interface IInSegmentMatcher extends ISplitMatcherBase {
+    matcherType: 'IN_SEGMENT';
+    userDefinedSegmentMatcherData: IInSegmentMatcherData;
+}
+interface IWhitelistMatcher extends ISplitMatcherBase {
+    matcherType: 'WHITELIST';
+    whitelistMatcherData: IWhitelistMatcherData;
+}
+interface IEqualToMatcher extends ISplitMatcherBase {
+    matcherType: 'EQUAL_TO';
+    unaryNumericMatcherData: IUnaryNumericMatcherData;
+}
+interface IGreaterThanOrEqualToMatcher extends ISplitMatcherBase {
+    matcherType: 'GREATER_THAN_OR_EQUAL_TO';
+    unaryNumericMatcherData: IUnaryNumericMatcherData;
+}
+interface ILessThanOrEqualToMatcher extends ISplitMatcherBase {
+    matcherType: 'LESS_THAN_OR_EQUAL_TO';
+    unaryNumericMatcherData: IUnaryNumericMatcherData;
+}
+interface IBetweenMatcher extends ISplitMatcherBase {
+    matcherType: 'BETWEEN';
+    betweenMatcherData: IBetweenMatcherData;
+}
+interface IEqualToSetMatcher extends ISplitMatcherBase {
+    matcherType: 'EQUAL_TO_SET';
+    whitelistMatcherData: IWhitelistMatcherData;
+}
+interface IContainsAnyOfSetMatcher extends ISplitMatcherBase {
+    matcherType: 'CONTAINS_ANY_OF_SET';
+    whitelistMatcherData: IWhitelistMatcherData;
+}
+interface IContainsAllOfSetMatcher extends ISplitMatcherBase {
+    matcherType: 'CONTAINS_ALL_OF_SET';
+    whitelistMatcherData: IWhitelistMatcherData;
+}
+interface IPartOfSetMatcher extends ISplitMatcherBase {
+    matcherType: 'PART_OF_SET';
+    whitelistMatcherData: IWhitelistMatcherData;
+}
+interface IStartsWithMatcher extends ISplitMatcherBase {
+    matcherType: 'STARTS_WITH';
+    whitelistMatcherData: IWhitelistMatcherData;
+}
+interface IEndsWithMatcher extends ISplitMatcherBase {
+    matcherType: 'ENDS_WITH';
+    whitelistMatcherData: IWhitelistMatcherData;
+}
+interface IContainsStringMatcher extends ISplitMatcherBase {
+    matcherType: 'CONTAINS_STRING';
+    whitelistMatcherData: IWhitelistMatcherData;
+}
+interface IInSplitTreatmentMatcher extends ISplitMatcherBase {
+    matcherType: 'IN_SPLIT_TREATMENT';
+    dependencyMatcherData: IDependencyMatcherData;
+}
+interface IEqualToBooleanMatcher extends ISplitMatcherBase {
+    matcherType: 'EQUAL_TO_BOOLEAN';
+    booleanMatcherData: boolean;
+}
+interface IMatchesStringMatcher extends ISplitMatcherBase {
+    matcherType: 'MATCHES_STRING';
+    stringMatcherData: string;
+}
+export declare type ISplitMatcher = IAllKeysMatcher | IInSegmentMatcher | IWhitelistMatcher | IEqualToMatcher | IGreaterThanOrEqualToMatcher | ILessThanOrEqualToMatcher | IBetweenMatcher | IEqualToSetMatcher | IContainsAnyOfSetMatcher | IContainsAllOfSetMatcher | IPartOfSetMatcher | IStartsWithMatcher | IEndsWithMatcher | IContainsStringMatcher | IInSplitTreatmentMatcher | IEqualToBooleanMatcher | IMatchesStringMatcher;
+/** Split object */
+export interface ISplitPartition {
+    treatment: string;
+    size: number;
+}
+export interface ISplitCondition {
+    matcherGroup: {
+        combiner: 'AND';
+        matchers: ISplitMatcher[];
+    };
+    partitions: ISplitPartition[];
+    label: string;
+    conditionType: 'ROLLOUT' | 'WHITELIST';
+}
+export interface ISplit {
+    name: string;
+    changeNumber: number;
+    killed: boolean;
+    defaultTreatment: string;
+    trafficTypeName: string;
+    conditions: ISplitCondition[];
+    status: 'ACTIVE' | 'ARCHIVED';
+    seed: number;
+    trafficAllocation?: number;
+    trafficAllocationSeed?: number;
+    configurations?: {
+        [treatmentName: string]: string;
+    };
+}
+export declare type ISplitPartial = Pick<ISplit, 'conditions' | 'configurations' | 'trafficTypeName'>;
+/** Interface of the parsed JSON response of `/splitChanges` */
+export interface ISplitChangesResponse {
+    till: number;
+    splits: ISplit[];
+}
+/** Interface of the parsed JSON response of `/segmentChanges/{segmentName}` */
+export interface ISegmentChangesResponse {
+    name: string;
+    added: string[];
+    removed: string[];
+    since: number;
+    till: number;
+}
+export interface IMySegmentsResponseItem {
+    id: string;
+    name: string;
+}
+/** Interface of the parsed JSON response of `/mySegments/{userKey}` */
+export interface IMySegmentsResponse {
+    mySegments: IMySegmentsResponseItem[];
+}
+/** Metadata internal type for storages */
+export interface IMetadata {
+    /** SDK version */
+    s: string;
+    /** host IP */
+    i: string;
+    /** host name */
+    n: string;
+}
+export declare type ISplitFiltersValidation = {
+    queryString: string | null;
+    groupedFilters: Record<SplitIO.SplitFilterType, string[]>;
+    validFilters: SplitIO.SplitFilter[];
+};
+export {};

package/types/evaluator/Engine.d.ts

@@ -0,0 +1,15 @@
+import { ISplit, MaybeThenable } from '../dtos/types';
+import { SplitIO } from '../types';
+import { IStorageAsync, IStorageSync } from '../storages/types';
+import { IEvaluationResult, IEvaluator, ISplitEvaluator } from './types';
+import { ILogger } from '../logger/types';
+export declare class Engine {
+    private baseInfo;
+    private evaluator;
+    constructor(baseInfo: ISplit, evaluator: IEvaluator);
+    static parse(log: ILogger, splitFlatStructure: ISplit, storage: IStorageSync | IStorageAsync): Engine;
+    getKey(): string;
+    getTreatment(key: SplitIO.SplitKey, attributes: SplitIO.Attributes | undefined, splitEvaluator: ISplitEvaluator): MaybeThenable<IEvaluationResult>;
+    isGarbage(): boolean;
+    getChangeNumber(): number;
+}

package/types/evaluator/combiners/and.d.ts

@@ -0,0 +1,4 @@
+import { ILogger } from '../../logger/types';
+import { MaybeThenable } from '../../dtos/types';
+import { IMatcher } from '../types';
+export declare function andCombinerContext(log: ILogger, matchers: IMatcher[]): (...params: any) => MaybeThenable<boolean>;

package/types/evaluator/combiners/ifelseif.d.ts

@@ -0,0 +1,3 @@
+import { ILogger } from '../../logger/types';
+import { IEvaluator } from '../types';
+export declare function ifElseIfCombinerContext(log: ILogger, predicates: IEvaluator[]): IEvaluator;