@splitsoftware/splitio-commons 1.11.0 → 1.12.0

package/types/sdkClient/identity.d.ts

@@ -0,0 +1,6 @@
+import { SplitIO } from '../types';
+export declare function buildInstanceId(key: SplitIO.SplitKey, trafficType?: string): string;
+export declare function parseInstanceId(instanceId: string): {
+    key: SplitIO.SplitKey;
+    trafficType?: string;
+};

package/types/sdkFactory/types.d.ts

@@ -1,9 +1,9 @@
 import { IIntegrationManager, IIntegrationFactoryParams } from '../integrations/types';
 import { ISignalListener } from '../listeners/types';
-import { ILogger } from '../logger/types';
 import { IReadinessManager, ISdkReadinessManager } from '../readiness/types';
+import type { sdkManagerFactory } from '../sdkManager';
 import { IFetch, ISplitApi, IEventSourceConstructor } from '../services/types';
-import { IStorageAsync, IStorageSync, ISplitsCacheSync, ISplitsCacheAsync, IStorageFactoryParams } from '../storages/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';
@@ -66,7 +66,7 @@ export interface ISdkFactoryParams {
     storageFactory: (params: IStorageFactoryParams) => IStorageSync | IStorageAsync;
     splitApiFactory?: (settings: ISettings, platform: IPlatform, telemetryTracker: ITelemetryTracker) => ISplitApi;
     syncManagerFactory?: (params: ISdkFactoryContextSync) => ISyncManager;
-    sdkManagerFactory: (log: ILogger, splits: ISplitsCacheSync | ISplitsCacheAsync, sdkReadinessManager: ISdkReadinessManager) => SplitIO.IManager | SplitIO.IAsyncManager;
+    sdkManagerFactory: typeof sdkManagerFactory;
     sdkClientMethodFactory: (params: ISdkFactoryContext) => ({
         (): SplitIO.ICsClient;
         (key: SplitIO.SplitKey, trafficType?: string | undefined): SplitIO.ICsClient;

package/types/sdkManager/index.d.ts

@@ -1,5 +1,4 @@
 import { ISplitsCacheAsync, ISplitsCacheSync } from '../storages/types';
 import { ISdkReadinessManager } from '../readiness/types';
-import { SplitIO } from '../types';
-import { ILogger } from '../logger/types';
-export declare function sdkManagerFactory<TSplitCache extends ISplitsCacheSync | ISplitsCacheAsync>(log: ILogger, splits: TSplitCache, { readinessManager, sdkStatus }: ISdkReadinessManager): TSplitCache extends ISplitsCacheAsync ? SplitIO.IAsyncManager : SplitIO.IManager;
+import { ISettings, SplitIO } from '../types';
+export declare function sdkManagerFactory<TSplitCache extends ISplitsCacheSync | ISplitsCacheAsync>(settings: Pick<ISettings, 'log' | 'mode'>, splits: TSplitCache, { readinessManager, sdkStatus }: ISdkReadinessManager): TSplitCache extends ISplitsCacheAsync ? SplitIO.IAsyncManager : SplitIO.IManager;

package/types/storages/AbstractSplitsCacheAsync.d.ts

@@ -15,7 +15,7 @@ export declare abstract class AbstractSplitsCacheAsync implements ISplitsCacheAs
     abstract getChangeNumber(): Promise<number>;
     abstract getAll(): Promise<ISplit[]>;
     abstract getSplitNames(): Promise<string[]>;
-    abstract getNamesByFlagSets(flagSets: string[]): Promise<ISet<string>>;
+    abstract getNamesByFlagSets(flagSets: string[]): Promise<ISet<string>[]>;
     abstract trafficTypeExists(trafficType: string): Promise<boolean>;
     abstract clear(): Promise<boolean | void>;
     usesSegments(): Promise<boolean>;

package/types/storages/AbstractSplitsCacheSync.d.ts

@@ -35,7 +35,7 @@ export declare abstract class AbstractSplitsCacheSync implements ISplitsCacheSyn
      * for instance, if the `changeNumber` is old, or if the split is not found (e.g., `/splitchanges` hasn't been fetched yet), or if the storage fails to apply the update.
      */
     killLocally(name: string, defaultTreatment: string, changeNumber: number): boolean;
-    abstract getNamesByFlagSets(flagSets: string[]): ISet<string>;
+    abstract getNamesByFlagSets(flagSets: string[]): ISet<string>[];
 }
 /**
  * Given a parsed split, it returns a boolean flagging if its conditions use segments matchers (rules & whitelists).

package/types/storages/inLocalStorage/SplitsCacheInLocal.d.ts

@@ -48,7 +48,7 @@ export declare class SplitsCacheInLocal extends AbstractSplitsCacheSync {
      */
     private _checkExpiration;
     private _checkFilterQuery;
-    getNamesByFlagSets(flagSets: string[]): ISet<string>;
+    getNamesByFlagSets(flagSets: string[]): ISet<string>[];
     private addToFlagSets;
     private removeFromFlagSets;
     private removeNames;

package/types/storages/inMemory/SplitsCacheInMemory.d.ts

@@ -22,7 +22,7 @@ export declare class SplitsCacheInMemory extends AbstractSplitsCacheSync {
     getSplitNames(): string[];
     trafficTypeExists(trafficType: string): boolean;
     usesSegments(): boolean;
-    getNamesByFlagSets(flagSets: string[]): ISet<string>;
+    getNamesByFlagSets(flagSets: string[]): ISet<string>[];
     private addToFlagSets;
     private removeFromFlagSets;
     private removeNames;

package/types/storages/inRedis/EventsCacheInRedis.d.ts

@@ -1,15 +1,15 @@
 import { IEventsCacheAsync } from '../types';
 import { IMetadata } from '../../dtos/types';
-import { Redis } from 'ioredis';
 import { SplitIO } from '../../types';
 import { ILogger } from '../../logger/types';
 import { StoredEventWithMetadata } from '../../sync/submitters/types';
+import type { RedisAdapter } from './RedisAdapter';
 export declare class EventsCacheInRedis implements IEventsCacheAsync {
     private readonly log;
     private readonly key;
     private readonly redis;
     private readonly metadata;
-    constructor(log: ILogger, key: string, redis: Redis, metadata: IMetadata);
+    constructor(log: ILogger, key: string, redis: RedisAdapter, metadata: IMetadata);
     /**
      * Add a new event object into the queue.
      * Unlike `impressions::track`, result promise is never rejected.

package/types/storages/inRedis/ImpressionCountsCacheInRedis.d.ts

@@ -1,14 +1,15 @@
-import { Redis } from 'ioredis';
+/// <reference types="ioredis" />
 import { ILogger } from '../../logger/types';
 import { ImpressionCountsPayload } from '../../sync/submitters/types';
 import { ImpressionCountsCacheInMemory } from '../inMemory/ImpressionCountsCacheInMemory';
+import type { RedisAdapter } from './RedisAdapter';
 export declare class ImpressionCountsCacheInRedis extends ImpressionCountsCacheInMemory {
     private readonly log;
     private readonly key;
     private readonly redis;
     private readonly refreshRate;
     private intervalId;
-    constructor(log: ILogger, key: string, redis: Redis, impressionCountsCacheSize?: number, refreshRate?: number);
+    constructor(log: ILogger, key: string, redis: RedisAdapter, impressionCountsCacheSize?: number, refreshRate?: number);
     private postImpressionCountsInRedis;
     start(): void;
     stop(): Promise<boolean | import("ioredis").BooleanResponse | undefined>;

package/types/storages/inRedis/ImpressionsCacheInRedis.d.ts

@@ -1,15 +1,15 @@
 import { IImpressionsCacheAsync } from '../types';
 import { IMetadata } from '../../dtos/types';
 import { ImpressionDTO } from '../../types';
-import { Redis } from 'ioredis';
 import { StoredImpressionWithMetadata } from '../../sync/submitters/types';
 import { ILogger } from '../../logger/types';
+import type { RedisAdapter } from './RedisAdapter';
 export declare class ImpressionsCacheInRedis implements IImpressionsCacheAsync {
     private readonly log;
     private readonly key;
     private readonly redis;
     private readonly metadata;
-    constructor(log: ILogger, key: string, redis: Redis, metadata: IMetadata);
+    constructor(log: ILogger, key: string, redis: RedisAdapter, metadata: IMetadata);
     track(impressions: ImpressionDTO[]): Promise<void>;
     count(): Promise<number>;
     drop(count?: number): Promise<any>;

package/types/storages/inRedis/RedisAdapter.d.ts

@@ -8,7 +8,7 @@ export declare class RedisAdapter extends ioredis {
     private _options;
     private _notReadyCommandsQueue?;
     private _runningCommands;
-    constructor(log: ILogger, storageSettings: Record<string, any>);
+    constructor(log: ILogger, storageSettings?: Record<string, any>);
     _listenToEvents(): void;
     _setTimeoutWrappers(): void;
     _setDisconnectWrapper(): void;

package/types/storages/inRedis/SegmentsCacheInRedis.d.ts

@@ -1,12 +1,12 @@
-import { Redis } from 'ioredis';
 import { ILogger } from '../../logger/types';
 import { KeyBuilderSS } from '../KeyBuilderSS';
 import { ISegmentsCacheAsync } from '../types';
+import type { RedisAdapter } from './RedisAdapter';
 export declare class SegmentsCacheInRedis implements ISegmentsCacheAsync {
     private readonly log;
     private readonly redis;
     private readonly keys;
-    constructor(log: ILogger, keys: KeyBuilderSS, redis: Redis);
+    constructor(log: ILogger, keys: KeyBuilderSS, redis: RedisAdapter);
     addToSegment(name: string, segmentKeys: string[]): Promise<boolean>;
     removeFromSegment(name: string, segmentKeys: string[]): Promise<boolean>;
     isInSegment(name: string, key: string): Promise<boolean>;
@@ -14,5 +14,5 @@ export declare class SegmentsCacheInRedis implements ISegmentsCacheAsync {
     getChangeNumber(name: string): Promise<number>;
     registerSegments(segments: string[]): Promise<boolean>;
     getRegisteredSegments(): Promise<string[]>;
-    clear(): Promise<boolean>;
+    clear(): Promise<void>;
 }

package/types/storages/inRedis/SplitsCacheInRedis.d.ts

@@ -1,9 +1,9 @@
 import { KeyBuilderSS } from '../KeyBuilderSS';
-import { Redis } from 'ioredis';
 import { ILogger } from '../../logger/types';
-import { ISplit } from '../../dtos/types';
+import { ISplit, ISplitFiltersValidation } from '../../dtos/types';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
 import { ISet } from '../../utils/lang/sets';
+import type { RedisAdapter } from './RedisAdapter';
 /**
  * ISplitsCacheAsync implementation that stores split definitions in Redis.
  * Supported by Node.
@@ -13,9 +13,11 @@ export declare class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
     private readonly redis;
     private readonly keys;
     private redisError?;
-    constructor(log: ILogger, keys: KeyBuilderSS, redis: Redis);
+    private readonly flagSetsFilter;
+    constructor(log: ILogger, keys: KeyBuilderSS, redis: RedisAdapter, splitFiltersValidation?: ISplitFiltersValidation);
     private _decrementCounts;
     private _incrementCounts;
+    private _updateFlagSets;
     /**
      * Add a given split.
      * The returned promise is resolved when the operation success
@@ -73,12 +75,11 @@ export declare class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
      */
     getSplitNames(): Promise<string[]>;
     /**
-     * Get list of split names related to a given flag set names list.
-     * The returned promise is resolved with the list of split names,
-     * or rejected if wrapper operation fails.
-     * @todo this is a no-op method to be implemented
+     * Get list of feature flag names related to a given list of flag set names.
+     * The returned promise is resolved with the list of feature flag names per flag set,
+     * or rejected if the pipelined redis operation fails (e.g., timeout).
     */
-    getNamesByFlagSets(): Promise<ISet<string>>;
+    getNamesByFlagSets(flagSets: string[]): Promise<ISet<string>[]>;
     /**
      * Check traffic type existence.
      * The returned promise is resolved with a boolean indicating whether the TT exist or not.
@@ -86,12 +87,7 @@ export declare class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
      * It will never be rejected.
      */
     trafficTypeExists(trafficType: string): Promise<boolean>;
-    /**
-     * Delete everything in the current database.
-     *
-     * @NOTE documentation says it never fails.
-     */
-    clear(): Promise<boolean>;
+    clear(): Promise<void>;
     /**
      * Fetches multiple splits definitions.
      * Returned promise is rejected if redis operation fails.

package/types/storages/inRedis/TelemetryCacheInRedis.d.ts

@@ -2,7 +2,7 @@ import { ILogger } from '../../logger/types';
 import { Method, MultiConfigs, MultiMethodExceptions, MultiMethodLatencies } from '../../sync/submitters/types';
 import { KeyBuilderSS } from '../KeyBuilderSS';
 import { ITelemetryCacheAsync } from '../types';
-import { Redis } from 'ioredis';
+import type { RedisAdapter } from './RedisAdapter';
 export declare class TelemetryCacheInRedis implements ITelemetryCacheAsync {
     private readonly log;
     private readonly keys;
@@ -13,7 +13,7 @@ export declare class TelemetryCacheInRedis implements ITelemetryCacheAsync {
      * @param keys  Key builder.
      * @param redis  Redis client.
      */
-    constructor(log: ILogger, keys: KeyBuilderSS, redis: Redis);
+    constructor(log: ILogger, keys: KeyBuilderSS, redis: RedisAdapter);
     recordLatency(method: Method, latencyMs: number): Promise<number | void>;
     recordException(method: Method): Promise<number | void>;
     recordConfig(): Promise<number | void>;

package/types/storages/inRedis/{uniqueKeysCacheInRedis.d.ts → UniqueKeysCacheInRedis.d.ts}

@@ -1,15 +1,16 @@
+/// <reference types="ioredis" />
 import { IUniqueKeysCacheBase } from '../types';
-import { Redis } from 'ioredis';
 import { UniqueKeysCacheInMemory } from '../inMemory/UniqueKeysCacheInMemory';
 import { ILogger } from '../../logger/types';
 import { UniqueKeysItemSs } from '../../sync/submitters/types';
+import type { RedisAdapter } from './RedisAdapter';
 export declare class UniqueKeysCacheInRedis extends UniqueKeysCacheInMemory implements IUniqueKeysCacheBase {
     private readonly log;
     private readonly key;
     private readonly redis;
     private readonly refreshRate;
     private intervalId;
-    constructor(log: ILogger, key: string, redis: Redis, uniqueKeysQueueSize?: number, refreshRate?: number);
+    constructor(log: ILogger, key: string, redis: RedisAdapter, uniqueKeysQueueSize?: number, refreshRate?: number);
     private postUniqueKeysInRedis;
     start(): void;
     stop(): Promise<boolean | import("ioredis").BooleanResponse | undefined>;

package/types/storages/pluggable/SplitsCachePluggable.d.ts

@@ -1,7 +1,7 @@
 import { KeyBuilder } from '../KeyBuilder';
 import { IPluggableStorageWrapper } from '../types';
 import { ILogger } from '../../logger/types';
-import { ISplit } from '../../dtos/types';
+import { ISplit, ISplitFiltersValidation } from '../../dtos/types';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
 import { ISet } from '../../utils/lang/sets';
 /**
@@ -11,15 +11,17 @@ export declare class SplitsCachePluggable extends AbstractSplitsCacheAsync {
     private readonly log;
     private readonly keys;
     private readonly wrapper;
+    private readonly flagSetsFilter;
     /**
      * Create a SplitsCache that uses a storage wrapper.
      * @param log  Logger instance.
      * @param keys  Key builder.
      * @param wrapper  Adapted wrapper storage.
      */
-    constructor(log: ILogger, keys: KeyBuilder, wrapper: IPluggableStorageWrapper);
+    constructor(log: ILogger, keys: KeyBuilder, wrapper: IPluggableStorageWrapper, splitFiltersValidation?: ISplitFiltersValidation);
     private _decrementCounts;
     private _incrementCounts;
+    private _updateFlagSets;
     /**
      * Add a given split.
      * The returned promise is resolved when the operation success
@@ -37,7 +39,7 @@ export declare class SplitsCachePluggable extends AbstractSplitsCacheAsync {
      * The returned promise is resolved when the operation success, with a boolean indicating if the split existed or not.
      * or rejected if it fails (e.g., wrapper operation fails).
      */
-    removeSplit(name: string): Promise<boolean | void>;
+    removeSplit(name: string): Promise<boolean>;
     /**
      * Remove a list of splits.
      * The returned promise is resolved when the operation success, with a boolean array indicating if the splits existed or not.
@@ -69,12 +71,11 @@ export declare class SplitsCachePluggable extends AbstractSplitsCacheAsync {
      */
     getSplitNames(): Promise<string[]>;
     /**
-     * Get list of split names related to a given flag set names list.
-     * The returned promise is resolved with the list of split names,
-     * or rejected if wrapper operation fails.
-     * @todo this is a no-op method to be implemented
-    */
-    getNamesByFlagSets(): Promise<ISet<string>>;
+     * Get list of feature flag names related to a given list of flag set names.
+     * The returned promise is resolved with the list of feature flag names per flag set.
+     * It never rejects (If there is a wrapper error for some flag set, an empty set is returned for it).
+     */
+    getNamesByFlagSets(flagSets: string[]): Promise<ISet<string>[]>;
     /**
      * Check traffic type existence.
      * The returned promise is resolved with a boolean indicating whether the TT exist or not.

package/types/storages/types.d.ts

@@ -41,10 +41,10 @@ export interface IPluggableStorageWrapper {
      *
      * @function del
      * @param {string} key Item to delete
-     * @returns {Promise<void>} A promise that resolves if the operation success, whether the key existed and was removed or it didn't exist.
+     * @returns {Promise<boolean>} A promise that resolves if the operation success, whether the key existed and was removed (resolves with true) or it didn't exist (resolves with false).
      * The promise rejects if the operation fails, for example, if there is a connection error.
      */
-    del: (key: string) => Promise<boolean | void>;
+    del: (key: string) => Promise<boolean>;
     /**
      * Returns all keys matching the given prefix.
      *
@@ -193,7 +193,7 @@ export interface ISplitsCacheBase {
     clear(): MaybeThenable<boolean | void>;
     checkCache(): MaybeThenable<boolean>;
     killLocally(name: string, defaultTreatment: string, changeNumber: number): MaybeThenable<boolean>;
-    getNamesByFlagSets(flagSets: string[]): MaybeThenable<ISet<string>>;
+    getNamesByFlagSets(flagSets: string[]): MaybeThenable<ISet<string>[]>;
 }
 export interface ISplitsCacheSync extends ISplitsCacheBase {
     addSplits(entries: [string, ISplit][]): boolean[];
@@ -209,7 +209,7 @@ export interface ISplitsCacheSync extends ISplitsCacheBase {
     clear(): void;
     checkCache(): boolean;
     killLocally(name: string, defaultTreatment: string, changeNumber: number): boolean;
-    getNamesByFlagSets(flagSets: string[]): ISet<string>;
+    getNamesByFlagSets(flagSets: string[]): ISet<string>[];
 }
 export interface ISplitsCacheAsync extends ISplitsCacheBase {
     addSplits(entries: [string, ISplit][]): Promise<boolean[] | void>;
@@ -225,7 +225,7 @@ export interface ISplitsCacheAsync extends ISplitsCacheBase {
     clear(): Promise<boolean | void>;
     checkCache(): Promise<boolean>;
     killLocally(name: string, defaultTreatment: string, changeNumber: number): Promise<boolean>;
-    getNamesByFlagSets(flagSets: string[]): Promise<ISet<string>>;
+    getNamesByFlagSets(flagSets: string[]): Promise<ISet<string>[]>;
 }
 /** Segments cache */
 export interface ISegmentsCacheBase {

package/types/trackers/impressionObserver/utils.d.ts

@@ -2,4 +2,4 @@ import { ISettings } from '../../types';
 /**
  * Storage is async if mode is consumer or partial consumer
  */
-export declare function isStorageSync(settings: ISettings): boolean;
+export declare function isStorageSync(settings: Pick<ISettings, 'mode'>): boolean;

package/types/types.d.ts

@@ -191,8 +191,6 @@ interface ISharedSettings {
          * 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.
          *
-         * At the moment, only one type of feature flag filter is supported: by name.
-         *
          * 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'

package/types/utils/constants/index.d.ts

@@ -24,6 +24,18 @@ export declare const STORAGE_PLUGGABLE: StorageType;
 export declare const CONSENT_GRANTED = "GRANTED";
 export declare const CONSENT_DECLINED = "DECLINED";
 export declare const CONSENT_UNKNOWN = "UNKNOWN";
+export declare const GET_TREATMENT = "getTreatment";
+export declare const GET_TREATMENTS = "getTreatments";
+export declare const GET_TREATMENT_WITH_CONFIG = "getTreatmentWithConfig";
+export declare const GET_TREATMENTS_WITH_CONFIG = "getTreatmentsWithConfig";
+export declare const GET_TREATMENTS_BY_FLAG_SET = "getTreatmentsByFlagSet";
+export declare const GET_TREATMENTS_BY_FLAG_SETS = "getTreatmentsByFlagSets";
+export declare const GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET = "getTreatmentsWithConfigByFlagSet";
+export declare const GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS = "getTreatmentsWithConfigByFlagSets";
+export declare const TRACK_FN_LABEL = "track";
+export declare const SPLIT_FN_LABEL = "split";
+export declare const SPLITS_FN_LABEL = "splits";
+export declare const NAMES_FN_LABEL = "names";
 export declare const QUEUED = 0;
 export declare const DROPPED = 1;
 export declare const DEDUPED = 2;

package/types/utils/inputValidation/index.d.ts

@@ -8,6 +8,6 @@ export { validateSplit } from './split';
 export { validateSplits } from './splits';
 export { validateTrafficType } from './trafficType';
 export { validateIfNotDestroyed, validateIfOperational } from './isOperational';
-export { validateSplitExistance } from './splitExistance';
-export { validateTrafficTypeExistance } from './trafficTypeExistance';
+export { validateSplitExistence } from './splitExistence';
+export { validateTrafficTypeExistence } from './trafficTypeExistence';
 export { validatePreloadedData } from './preloadedData';

package/types/utils/inputValidation/sdkKey.d.ts

@@ -0,0 +1,7 @@
+import { ILogger } from '../../logger/types';
+/** validates the given SDK key */
+export declare function validateApiKey(log: ILogger, maybeSdkKey: any): string | false;
+export declare const usedKeysMap: Record<string, number>;
+/** validates the given SDK key and also warns if it is in use */
+export declare function validateAndTrackApiKey(log: ILogger, maybeSdkKey: any): string | false;
+export declare function releaseApiKey(sdkKey: string): void;

package/types/utils/inputValidation/splitExistence.d.ts

@@ -0,0 +1,7 @@
+import { IReadinessManager } from '../../readiness/types';
+import { ILogger } from '../../logger/types';
+/**
+ * This is defined here and in this format mostly because of the logger and the fact that it's considered a validation at product level.
+ * But it's not going to run on the input validation layer. In any case, the most compeling reason to use it as we do is to avoid going to Redis and get a split twice.
+ */
+export declare function validateSplitExistence(log: ILogger, readinessManager: IReadinessManager, splitName: string, labelOrSplitObj: any, method: string): boolean;

package/types/utils/inputValidation/trafficTypeExistence.d.ts

@@ -0,0 +1,9 @@
+import { ISplitsCacheBase } from '../../storages/types';
+import { IReadinessManager } from '../../readiness/types';
+import { SDKMode } from '../../types';
+import { MaybeThenable } from '../../dtos/types';
+import { ILogger } from '../../logger/types';
+/**
+ * Separated from the previous method since on some cases it'll be async.
+ */
+export declare function validateTrafficTypeExistence(log: ILogger, readinessManager: IReadinessManager, splitsCache: ISplitsCacheBase, mode: SDKMode, maybeTT: string, method: string): MaybeThenable<boolean>;

package/types/utils/lang/sets.d.ts

@@ -58,4 +58,5 @@ interface ISetConstructor {
 export declare function __getSetConstructor(): ISetConstructor;
 export declare const _Set: ISetConstructor;
 export declare function returnSetsUnion<T>(set: ISet<T>, set2: ISet<T>): ISet<T>;
+export declare function returnDifference<T>(list?: T[], list2?: T[]): T[];
 export {};

package/types/utils/settingsValidation/splitFilters.d.ts

@@ -5,6 +5,7 @@ import { ILogger } from '../../logger/types';
  *
  * @param {ILogger} log logger
  * @param {any} maybeSplitFilters split filters configuration param provided by the user
+ * @param {string} mode settings mode
  * @returns it returns an object with the following properties:
  *  - `validFilters`: the validated `splitFilters` configuration object defined by the user.
  *  - `queryString`: the parsed split filter query. it is null if all filters are invalid or all values in filters are invalid.
@@ -12,5 +13,5 @@ import { ILogger } from '../../logger/types';
  *
  * @throws Error if the some of the grouped list of values per filter exceeds the max allowed length
  */
-export declare function validateSplitFilters(log: ILogger, maybeSplitFilters: any): ISplitFiltersValidation;
-export declare function flagSetsAreValid(log: ILogger, method: string, flagSets: string[], flagSetsInConfig: string[]): string[];
+export declare function validateSplitFilters(log: ILogger, maybeSplitFilters: any, mode: string): ISplitFiltersValidation;
+export declare function validateFlagSets(log: ILogger, method: string, flagSets: string[], flagSetsInConfig: string[]): string[];

package/types/myLogger.d.ts

@@ -1,5 +0,0 @@
-export declare const myLogger: {
-    log: (msg: any) => void;
-    logCsv: (msg: any) => void;
-    logToFile: (file: any, msg: any) => void;
-};

package/types/sdkClient/types.d.ts

@@ -1,18 +0,0 @@
-import { ISignalListener } from '../listeners/types';
-import { ISdkReadinessManager } from '../readiness/types';
-import { IStorageAsync, IStorageSync } from '../storages/types';
-import { ISyncManager } from '../sync/types';
-import { IEventTracker, IImpressionsTracker } from '../trackers/types';
-import { ISettings } from '../types';
-export interface IClientFactoryParams {
-    storage: IStorageSync | IStorageAsync;
-    sdkReadinessManager: ISdkReadinessManager;
-    settings: ISettings;
-    impressionsTracker: IImpressionsTracker;
-    eventTracker: IEventTracker;
-}
-export interface ISdkClientFactoryParams extends IClientFactoryParams {
-    signalListener?: ISignalListener;
-    syncManager?: ISyncManager;
-    sharedClient?: boolean;
-}

package/types/storages/inMemory/CountsCacheInMemory.d.ts

@@ -1,20 +0,0 @@
-import { ICountsCacheSync } from '../types';
-export declare class CountsCacheInMemory implements ICountsCacheSync {
-    private counters;
-    /**
-     * Add counts.
-     */
-    track(metricName: string): boolean;
-    /**
-     * Clear the collector
-     */
-    clear(): void;
-    /**
-     * Get the collected data, used as payload for posting.
-     */
-    state(): Record<string, number>;
-    /**
-     * Check if the cache is empty.
-     */
-    isEmpty(): boolean;
-}

package/types/storages/inMemory/LatenciesCacheInMemory.d.ts

@@ -1,20 +0,0 @@
-import { ILatenciesCacheSync } from '../types';
-export declare class LatenciesCacheInMemory implements ILatenciesCacheSync {
-    private counters;
-    /**
-     * Add latencies.
-     */
-    track(metricName: string, latency: number): boolean;
-    /**
-     * Clear the collector
-     */
-    clear(): void;
-    /**
-     * Get the collected data, used as payload for posting.
-     */
-    state(): Record<string, number[]>;
-    /**
-     * Check if the cache is empty.
-     */
-    isEmpty(): boolean;
-}

package/types/storages/inRedis/CountsCacheInRedis.d.ts

@@ -1,9 +0,0 @@
-import { ICountsCacheAsync } from '../types';
-import { KeyBuilderSS } from '../KeyBuilderSS';
-import { Redis } from 'ioredis';
-export declare class CountsCacheInRedis implements ICountsCacheAsync {
-    private readonly redis;
-    private readonly keys;
-    constructor(keys: KeyBuilderSS, redis: Redis);
-    track(metricName: string): Promise<boolean>;
-}

package/types/storages/inRedis/LatenciesCacheInRedis.d.ts

@@ -1,9 +0,0 @@
-import { ILatenciesCacheAsync } from '../types';
-import { KeyBuilderSS } from '../KeyBuilderSS';
-import { Redis } from 'ioredis';
-export declare class LatenciesCacheInRedis implements ILatenciesCacheAsync {
-    private readonly redis;
-    private readonly keys;
-    constructor(keys: KeyBuilderSS, redis: Redis);
-    track(metricName: string, latency: number): Promise<boolean>;
-}

package/types/storages/metadataBuilder.d.ts

@@ -1,3 +0,0 @@
-import { IMetadata } from '../dtos/types';
-import { ISettings } from '../types';
-export declare function metadataBuilder(settings: Pick<ISettings, 'version' | 'runtime'>): IMetadata;

package/types/sync/offline/LocalhostFromFile.d.ts

@@ -1,2 +0,0 @@
-import { SplitIO } from '../../types';
-export declare function LocalhostFromFile(): SplitIO.LocalhostFactory;

package/types/sync/offline/splitsParser/splitsParserFromFile.d.ts

@@ -1,2 +0,0 @@
-import { ISplitsParser } from './types';
-export declare function splitsParserFromFileFactory(): ISplitsParser;

package/types/sync/submitters/eventsSyncTask.d.ts

@@ -1,8 +0,0 @@
-import { IEventsCacheSync } from '../../storages/types';
-import { IPostEventsBulk } from '../../services/types';
-import { ISyncTask, ITimeTracker } from '../types';
-import { ILogger } from '../../logger/types';
-/**
- * Sync task that periodically posts tracked events
- */
-export declare function eventsSyncTaskFactory(log: ILogger, postEventsBulk: IPostEventsBulk, eventsCache: IEventsCacheSync, eventsPushRate: number, eventsFirstPushWindow: number, latencyTracker?: ITimeTracker): ISyncTask;

package/types/sync/submitters/impressionCountsSubmitterInRedis.d.ts

@@ -1,5 +0,0 @@
-import { ISdkFactoryContextSync } from '../../sdkFactory/types';
-/**
- * Submitter that periodically posts impression counts
- */
-export declare function impressionCountsSubmitterInRedisFactory(params: ISdkFactoryContextSync): import("../types").ISyncTask<[], void>;

package/types/sync/submitters/impressionCountsSyncTask.d.ts

@@ -1,13 +0,0 @@
-import { ISyncTask, ITimeTracker } from '../types';
-import { IPostTestImpressionsCount } from '../../services/types';
-import { IImpressionCountsCacheSync } from '../../storages/types';
-import { ImpressionCountsPayload } from './types';
-import { ILogger } from '../../logger/types';
-/**
- * Converts `impressionCounts` data from cache into request payload.
- */
-export declare function fromImpressionCountsCollector(impressionsCount: Record<string, number>): ImpressionCountsPayload;
-/**
- * Sync task that periodically posts impression counts
- */
-export declare function impressionCountsSyncTaskFactory(log: ILogger, postTestImpressionsCount: IPostTestImpressionsCount, impressionCountsCache: IImpressionCountsCacheSync, latencyTracker?: ITimeTracker): ISyncTask;

package/types/sync/submitters/impressionsSyncTask.d.ts

@@ -1,14 +0,0 @@
-import { ISyncTask, ITimeTracker } from '../types';
-import { IPostTestImpressionsBulk } from '../../services/types';
-import { IImpressionsCacheSync } from '../../storages/types';
-import { ImpressionDTO } from '../../types';
-import { ImpressionsPayload } from './types';
-import { ILogger } from '../../logger/types';
-/**
- * Converts `impressions` data from cache into request payload.
- */
-export declare function fromImpressionsCollector(sendLabels: boolean, data: ImpressionDTO[]): ImpressionsPayload;
-/**
- * Sync task that periodically posts impressions data
- */
-export declare function impressionsSyncTaskFactory(log: ILogger, postTestImpressionsBulk: IPostTestImpressionsBulk, impressionsCache: IImpressionsCacheSync, impressionsRefreshRate: number, sendLabels?: boolean, latencyTracker?: ITimeTracker): ISyncTask;