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

package/src/utils/constants/index.ts

@@ -1,4 +1,4 @@
-import { StorageType } from '../../storages/types';
+import { StorageType } from '../../types';
 import { SDKMode } from '../../types';
 
 // Special treatments
@@ -19,7 +19,6 @@ 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';
@@ -50,7 +49,6 @@ 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 '../../logger/types';
+import { ILogger } from '../../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 '../../logger/types';
+import { ILogger } from '../../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 { SplitIO } from '../../types';
-import { ILogger } from '../../logger/types';
+import { Attributes } from '../../types';
+import { ILogger } from '../../types';
 import { validateAttribute } from './attribute';
 import { ERROR_NOT_PLAIN_OBJECT } from '../../logger/constants';
 
-export function validateAttributes(log: ILogger, maybeAttrs: any, method: string): SplitIO.Attributes | undefined | false {
+export function validateAttributes(log: ILogger, maybeAttrs: any, method: string): 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 '../../logger/types';
+import { ILogger } from '../../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 { SplitIO } from '../../types';
-import { ILogger } from '../../logger/types';
+import { Properties } from '../../types';
+import { ILogger } from '../../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: SplitIO.Properties | null | false, size: number } {
+export function validateEventProperties(log: ILogger, maybeProperties: any, method: string): { properties: 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 '../../logger/types';
+import { ILogger } from '../../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 '../../logger/types';
+import { ILogger } from '../../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 { SplitIO } from '../../types';
-import { ILogger } from '../../logger/types';
+import { SplitKey } from '../../types';
+import { ILogger } from '../../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): SplitIO.SplitKey | false {
+export function validateKey(log: ILogger, maybeKey: any, method: string): 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 { SplitIO } from '../../types';
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
+import { PreloadedData } from '../../storages/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 SplitIO.PreloadedData {
+export function validatePreloadedData(log: ILogger, maybePreloadedData: any, method: string): maybePreloadedData is 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 '../../logger/types';
+import { ILogger } from '../../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 '../../logger/types';
+import { ILogger } from '../../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 '../../logger/types';
+import { ILogger } from '../../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 '../../logger/types';
+import { ILogger } from '../../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 '../../logger/types';
+import { ILogger } from '../../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 { SplitIO } from '../../types';
+import { SplitKey, SplitKeyObject } from '../../types';
 import { isObject } from '../lang';
 
-// function isSplitKeyObject(key: any): key is SplitIO.SplitKeyObject {
+// function isSplitKeyObject(key: any): key is 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: SplitIO.SplitKey): string {
-  return isObject(key) ? (key as SplitIO.SplitKeyObject).matchingKey : key as string;
+export function getMatching(key?: SplitKey): string {
+  return isObject(key) ? (key as SplitKeyObject).matchingKey : key as string;
 }
 
 // if the key is a string, there's no bucketingKey (undefined)
-export function getBucketing(key: SplitIO.SplitKey): string | undefined {
-  return isObject(key) ? (key as SplitIO.SplitKeyObject).bucketingKey : undefined;
+export function getBucketing(key: SplitKey): string | undefined {
+  return isObject(key) ? (key as 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: SplitIO.SplitKey): SplitIO.SplitKeyObject {
+export function keyParser(key: SplitKey): SplitKeyObject {
   if (isObject(key)) {
     return {
-      matchingKey: (key as SplitIO.SplitKeyObject).matchingKey,
-      bucketingKey: (key as SplitIO.SplitKeyObject).bucketingKey
+      matchingKey: (key as SplitKeyObject).matchingKey,
+      bucketingKey: (key as SplitKeyObject).bucketingKey
     };
   } else {
     return {

package/src/utils/settingsValidation/consent.ts

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

package/src/utils/settingsValidation/index.ts

@@ -36,8 +36,6 @@ 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
@@ -132,13 +130,11 @@ 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.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');
@@ -204,6 +200,7 @@ 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 '../../../logger/types';
+import { ILogger } from '../../../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 '../../../logger/types';
+import { ILogger } from '../../../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,6 +1,5 @@
-import { ISettings } from '../../../types';
+import { ISettings, ILogger } 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,5 +1,4 @@
-import { ILogger } from '../../../logger/types';
-import { SDKMode, } from '../../../types';
+import { SDKMode, ILogger } from '../../../types';
 import { LocalhostFromObject } from '../../../sync/offline/LocalhostFromObject';
 import { validateLocalhost } from './pluggable';
 

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

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

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

@@ -1,11 +1,10 @@
 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 } from '../../../types';
+import { LogLevel, ILogger } from '../../../types';
 
 const allCodes = new _Map(codesDebug);
 

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

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

package/src/utils/settingsValidation/splitFilters.ts

@@ -1,20 +1,18 @@
 import { STANDALONE_MODE } from '../constants';
 import { validateSplits } from '../inputValidation/splits';
-import { ISplitFiltersValidation } from '../../dtos/types';
-import { SplitIO } from '../../types';
-import { ILogger } from '../../logger/types';
+import { ISplitFiltersValidation, SplitFilterType, ILogger } from '../../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 SplitIO.SplitFilterType,
+    type: 'byName' as SplitFilterType,
     maxLength: 400,
     queryParam: 'names='
   },
   {
-    type: 'byPrefix' as SplitIO.SplitFilterType,
+    type: 'byPrefix' as SplitFilterType,
     maxLength: 50,
     queryParam: 'prefixes='
   }
@@ -23,7 +21,7 @@ const FILTERS_METADATA = [
 /**
  * Validates that the given value is a valid filter type
  */
-function validateFilterType(maybeFilterType: any): maybeFilterType is SplitIO.SplitFilterType {
+function validateFilterType(maybeFilterType: any): maybeFilterType is SplitFilterType {
   return FILTERS_METADATA.some(filterMetadata => filterMetadata.type === maybeFilterType);
 }
 
@@ -37,7 +35,7 @@ function validateFilterType(maybeFilterType: any): maybeFilterType is SplitIO.Sp
  *
  * @throws Error if the sanitized list exceeds the length indicated by `maxLength`
  */
-function validateSplitFilter(log: ILogger, type: SplitIO.SplitFilterType, values: string[], maxLength: number) {
+function validateSplitFilter(log: ILogger, type: 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`);
 
@@ -63,7 +61,7 @@ function validateSplitFilter(log: ILogger, type: SplitIO.SplitFilterType, values
  * @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<SplitIO.SplitFilterType, string[]>) {
+function queryStringBuilder(groupedFilters: Record<SplitFilterType, string[]>) {
   const queryParams: string[] = [];
   FILTERS_METADATA.forEach(({ type, queryParam }) => {
     const filter = groupedFilters[type];
@@ -109,7 +107,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 SplitIO.SplitFilterType] = res.groupedFilters[filter.type as SplitIO.SplitFilterType].concat(filter.values);
+      res.groupedFilters[filter.type as SplitFilterType] = res.groupedFilters[filter.type as SplitFilterType].concat(filter.values);
       return true;
     } else {
       log.warn(WARN_SPLITS_FILTER_INVALID, [index]);

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

@@ -1,6 +1,5 @@
 import { InMemoryStorageCSFactory } from '../../../storages/inMemory/InMemoryStorageCS';
-import { ISettings, SDKMode } from '../../../types';
-import { ILogger } from '../../../logger/types';
+import { ISettings, SDKMode, ILogger } from '../../../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/sdkUserConsent.d.ts

@@ -1,13 +1,6 @@
 import { ISdkFactoryContext } from '../sdkFactory/types';
+import { IUserConsentAPI } from '../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;
-    };
-};
+export declare function createUserConsentAPI(params: ISdkFactoryContext): IUserConsentAPI;

package/types/dtos/types.d.ts

@@ -1,4 +1,3 @@
-import { SplitIO } from '../types';
 export declare type MaybeThenable<T> = T | Promise<T>;
 /** Split Matchers */
 export declare type IMatcherDataType = null | 'DATETIME' | 'NUMBER';
@@ -164,9 +163,4 @@ export interface IMetadata {
     /** 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

@@ -1,15 +1,15 @@
 import { ISplit, MaybeThenable } from '../dtos/types';
-import { SplitIO } from '../types';
+import { SplitKey, Attributes } from '../types';
 import { IStorageAsync, IStorageSync } from '../storages/types';
 import { IEvaluationResult, IEvaluator, ISplitEvaluator } from './types';
-import { ILogger } from '../logger/types';
+import { ILogger } from '../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>;
+    getTreatment(key: SplitKey, attributes: Attributes | undefined, splitEvaluator: ISplitEvaluator): MaybeThenable<IEvaluationResult>;
     isGarbage(): boolean;
     getChangeNumber(): number;
 }

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

@@ -1,4 +1,4 @@
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../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

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

package/types/evaluator/condition/engineUtils.d.ts

@@ -1,4 +1,4 @@
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 /**
  * Get the treatment name given a key, a seed, and the percentage of each treatment.
  */

package/types/evaluator/condition/index.d.ts

@@ -1,6 +1,6 @@
 import { MaybeThenable } from '../../dtos/types';
 import { IEvaluator } from '../types';
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 export declare function conditionContext(log: ILogger, matcherEvaluator: (...args: any) => MaybeThenable<boolean>, treatments: {
     getTreatmentFor: (x: number) => string;
 }, label: string, conditionType: 'ROLLOUT' | 'WHITELIST'): IEvaluator;

package/types/evaluator/index.d.ts

@@ -1,7 +1,7 @@
 import { MaybeThenable } from '../dtos/types';
 import { IStorageAsync, IStorageSync } from '../storages/types';
 import { IEvaluationResult } from './types';
-import { SplitIO } from '../types';
-import { ILogger } from '../logger/types';
-export declare function evaluateFeature(log: ILogger, key: SplitIO.SplitKey, splitName: string, attributes: SplitIO.Attributes | undefined, storage: IStorageSync | IStorageAsync): MaybeThenable<IEvaluationResult>;
-export declare function evaluateFeatures(log: ILogger, key: SplitIO.SplitKey, splitNames: string[], attributes: SplitIO.Attributes | undefined, storage: IStorageSync | IStorageAsync): MaybeThenable<Record<string, IEvaluationResult>>;
+import { SplitKey, Attributes } from '../types';
+import { ILogger } from '../types';
+export declare function evaluateFeature(log: ILogger, key: SplitKey, splitName: string, attributes: Attributes | undefined, storage: IStorageSync | IStorageAsync): MaybeThenable<IEvaluationResult>;
+export declare function evaluateFeatures(log: ILogger, key: SplitKey, splitNames: string[], attributes: Attributes | undefined, storage: IStorageSync | IStorageAsync): MaybeThenable<Record<string, IEvaluationResult>>;

package/types/evaluator/matchers/all.d.ts

@@ -1,2 +1,2 @@
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 export declare function allMatcherContext(log: ILogger): (runtimeAttr: string) => boolean;

package/types/evaluator/matchers/between.d.ts

@@ -1,3 +1,3 @@
 import { IBetweenMatcherData } from '../../dtos/types';
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 export declare function betweenMatcherContext(log: ILogger, ruleVO: IBetweenMatcherData): (runtimeAttr: number) => boolean;

package/types/evaluator/matchers/boolean.d.ts

@@ -1,2 +1,2 @@
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 export declare function booleanMatcherContext(log: ILogger, ruleAttr: boolean): (runtimeAttr: boolean) => boolean;

package/types/evaluator/matchers/cont_all.d.ts

@@ -1,2 +1,2 @@
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 export declare function containsAllSetMatcherContext(log: ILogger, ruleAttr: string[]): (runtimeAttr: string[]) => boolean;

package/types/evaluator/matchers/cont_any.d.ts

@@ -1,2 +1,2 @@
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 export declare function containsAnySetMatcherContext(log: ILogger, ruleAttr: string[]): (runtimeAttr: string[]) => boolean;

package/types/evaluator/matchers/cont_str.d.ts

@@ -1,2 +1,2 @@
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 export declare function containsStringMatcherContext(log: ILogger, ruleAttr: string[]): (runtimeAttr: string) => boolean;

package/types/evaluator/matchers/dependency.d.ts

@@ -1,5 +1,5 @@
 import { IDependencyMatcherData, MaybeThenable } from '../../dtos/types';
 import { IStorageAsync, IStorageSync } from '../../storages/types';
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 import { IDependencyMatcherValue, ISplitEvaluator } from '../types';
 export declare function dependencyMatcherContext(log: ILogger, { split, treatments }: IDependencyMatcherData, storage: IStorageSync | IStorageAsync): ({ key, attributes }: IDependencyMatcherValue, splitEvaluator: ISplitEvaluator) => MaybeThenable<boolean>;

package/types/evaluator/matchers/eq.d.ts

@@ -1,2 +1,2 @@
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 export declare function equalToMatcherContext(log: ILogger, ruleAttr: number): (runtimeAttr: number) => boolean;

package/types/evaluator/matchers/eq_set.d.ts

@@ -1,2 +1,2 @@
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 export declare function equalToSetMatcherContext(log: ILogger, ruleAttr: string[]): (runtimeAttr: string[]) => boolean;

package/types/evaluator/matchers/ew.d.ts

@@ -1,2 +1,2 @@
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 export declare function endsWithMatcherContext(log: ILogger, ruleAttr: string[]): (runtimeAttr: string) => boolean;

package/types/evaluator/matchers/gte.d.ts

@@ -1,2 +1,2 @@
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 export declare function greaterThanEqualMatcherContext(log: ILogger, ruleAttr: number): (runtimeAttr: number) => boolean;

package/types/evaluator/matchers/index.d.ts

@@ -1,6 +1,6 @@
 import { IStorageAsync, IStorageSync } from '../../storages/types';
 import { IMatcher, IMatcherDto } from '../types';
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 /**
  * Matcher factory.
  */

package/types/evaluator/matchers/lte.d.ts

@@ -1,2 +1,2 @@
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 export declare function lessThanEqualMatcherContext(log: ILogger, ruleAttr: number): (runtimeAttr: number) => boolean;

package/types/evaluator/matchers/part_of.d.ts

@@ -1,2 +1,2 @@
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 export declare function partOfSetMatcherContext(log: ILogger, ruleAttr: string[]): (runtimeAttr: string[]) => boolean;

package/types/evaluator/matchers/segment.d.ts

@@ -1,6 +1,6 @@
 import { MaybeThenable } from '../../dtos/types';
 import { ISegmentsCacheBase } from '../../storages/types';
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 export declare function segmentMatcherContext(log: ILogger, segmentName: string, storage: {
     segments: ISegmentsCacheBase;
 }): (key: string) => MaybeThenable<boolean>;

package/types/evaluator/matchers/string.d.ts

@@ -1,2 +1,2 @@
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 export declare function stringMatcherContext(log: ILogger, ruleAttr: string): (runtimeAttr: string) => boolean;