@splitsoftware/splitio-commons 1.10.0 → 1.10.1-rc.1

package/types/storages/types.d.ts

@@ -1,6 +1,7 @@
 import { MaybeThenable, ISplit } from '../dtos/types';
 import { EventDataType, HttpErrors, HttpLatencies, ImpressionDataType, LastSync, Method, MethodExceptions, MethodLatencies, MultiMethodExceptions, MultiMethodLatencies, MultiConfigs, OperationType, StoredEventWithMetadata, StoredImpressionWithMetadata, StreamingEvent, UniqueKeysPayloadCs, UniqueKeysPayloadSs, TelemetryUsageStatsPayload, UpdatesFromSSEEnum } from '../sync/submitters/types';
 import { SplitIO, ImpressionDTO, ISettings } from '../types';
+import { ISet } from '../utils/lang/sets';
 /**
  * Interface of a pluggable storage wrapper.
  */
@@ -192,6 +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>>;
 }
 export interface ISplitsCacheSync extends ISplitsCacheBase {
     addSplits(entries: [string, ISplit][]): boolean[];
@@ -207,6 +209,7 @@ export interface ISplitsCacheSync extends ISplitsCacheBase {
     clear(): void;
     checkCache(): boolean;
     killLocally(name: string, defaultTreatment: string, changeNumber: number): boolean;
+    getNamesByFlagSets(flagSets: string[]): ISet<string>;
 }
 export interface ISplitsCacheAsync extends ISplitsCacheBase {
     addSplits(entries: [string, ISplit][]): Promise<boolean[] | void>;
@@ -222,6 +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>>;
 }
 /** Segments cache */
 export interface ISegmentsCacheBase {

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

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

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

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

package/types/sync/polling/updaters/splitChangesUpdater.d.ts

@@ -1,7 +1,7 @@
 import { ISet } from '../../../utils/lang/sets';
 import { ISegmentsCacheBase, ISplitsCacheBase } from '../../../storages/types';
 import { ISplitChangesFetcher } from '../fetchers/types';
-import { ISplit } from '../../../dtos/types';
+import { ISplit, ISplitFiltersValidation } from '../../../dtos/types';
 import { ISplitsEventEmitter } from '../../../readiness/types';
 import { ILogger } from '../../../logger/types';
 declare type ISplitChangesUpdater = (noCache?: boolean, till?: number, splitUpdateNotification?: {
@@ -23,7 +23,7 @@ interface ISplitMutations {
  * i.e., an object with added splits, removed splits and used segments.
  * Exported for testing purposes.
  */
-export declare function computeSplitsMutation(entries: ISplit[]): ISplitMutations;
+export declare function computeSplitsMutation(entries: ISplit[], filters: ISplitFiltersValidation): ISplitMutations;
 /**
  * factory of SplitChanges updater, a task that:
  *  - fetches split changes using `splitChangesFetcher`
@@ -38,5 +38,5 @@ export declare function computeSplitsMutation(entries: ISplit[]): ISplitMutation
  * @param requestTimeoutBeforeReady  How long the updater will wait for the request to timeout. Default 0, i.e., never timeout.
  * @param retriesOnFailureBeforeReady  How many retries on `/splitChanges` we the updater do in case of failure or timeout. Default 0, i.e., no retries.
  */
-export declare function splitChangesUpdaterFactory(log: ILogger, splitChangesFetcher: ISplitChangesFetcher, splits: ISplitsCacheBase, segments: ISegmentsCacheBase, splitsEventEmitter?: ISplitsEventEmitter, requestTimeoutBeforeReady?: number, retriesOnFailureBeforeReady?: number, isClientSide?: boolean): ISplitChangesUpdater;
+export declare function splitChangesUpdaterFactory(log: ILogger, splitChangesFetcher: ISplitChangesFetcher, splits: ISplitsCacheBase, segments: ISegmentsCacheBase, splitFiltersValidation: ISplitFiltersValidation, splitsEventEmitter?: ISplitsEventEmitter, requestTimeoutBeforeReady?: number, retriesOnFailureBeforeReady?: number, isClientSide?: boolean): ISplitChangesUpdater;
 export {};

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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,14 @@
+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;

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

@@ -0,0 +1,12 @@
+import { ICountsCacheSync, ILatenciesCacheSync } from '../../storages/types';
+import { IPostMetricsCounters, IPostMetricsTimes } from '../../services/types';
+import { ISyncTask, ITimeTracker } from '../types';
+import { ILogger } from '../../logger/types';
+/**
+ * Sync task that periodically posts telemetry counts
+ */
+export declare function countsSyncTaskFactory(log: ILogger, postMetricsCounters: IPostMetricsCounters, countsCache: ICountsCacheSync, metricsRefreshRate: number, latencyTracker?: ITimeTracker): ISyncTask;
+/**
+ * Sync task that periodically posts telemetry latencies
+ */
+export declare function latenciesSyncTaskFactory(log: ILogger, postMetricsLatencies: IPostMetricsTimes, latenciesCache: ILatenciesCacheSync, metricsRefreshRate: number, latencyTracker?: ITimeTracker): ISyncTask;

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

@@ -0,0 +1,10 @@
+import { ISyncTask, ITimeTracker } from '../types';
+import { IRecorderCacheProducerSync } from '../../storages/types';
+import { ILogger } from '../../logger/types';
+import { IResponse } from '../../services/types';
+/**
+ * Base function to create submitter sync tasks, such as ImpressionsSyncTask and EventsSyncTask
+ */
+export declare function submitterSyncTaskFactory<TState extends {
+    length?: number;
+}>(log: ILogger, postClient: (body: string) => Promise<IResponse>, sourceCache: IRecorderCacheProducerSync<TState>, postRate: number, dataName: string, latencyTracker?: ITimeTracker, fromCacheToPayload?: (cacheData: TState) => any, maxRetries?: number, debugLogs?: boolean): ISyncTask<[], void>;

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

@@ -110,7 +110,11 @@ export declare type TREATMENTS = 'ts';
 export declare type TREATMENT_WITH_CONFIG = 'tc';
 export declare type TREATMENTS_WITH_CONFIG = 'tcs';
 export declare type TRACK = 'tr';
-export declare type Method = TREATMENT | TREATMENTS | TREATMENT_WITH_CONFIG | TREATMENTS_WITH_CONFIG | TRACK;
+export declare type TREATMENTS_BY_FLAGSET = 'tf';
+export declare type TREATMENTS_BY_FLAGSETS = 'tfs';
+export declare type TREATMENTS_WITH_CONFIG_BY_FLAGSET = 'tcf';
+export declare type TREATMENTS_WITH_CONFIG_BY_FLAGSETS = 'tcfs';
+export declare type Method = TREATMENT | TREATMENTS | TREATMENT_WITH_CONFIG | TREATMENTS_WITH_CONFIG | TRACK | TREATMENTS_BY_FLAGSET | TREATMENTS_BY_FLAGSETS | TREATMENTS_WITH_CONFIG_BY_FLAGSET | TREATMENTS_WITH_CONFIG_BY_FLAGSETS;
 export declare type MethodLatencies = Partial<Record<Method, Array<number>>>;
 export declare type MethodExceptions = Partial<Record<Method, number>>;
 export declare type CONNECTION_ESTABLISHED = 0;
@@ -201,6 +205,8 @@ export declare type TelemetryConfigStatsPayload = TelemetryConfigStats & {
     nR: number;
     i?: Array<string>;
     uC: number;
+    fsT: number;
+    fsI: number;
 };
 export interface ISubmitterManager extends ISyncTask {
     start(onlyTelemetry?: boolean): void;

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

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

package/types/sync/syncTaskComposite.d.ts

@@ -0,0 +1,5 @@
+import { ISyncTask } from './types';
+/**
+ * Composite Sync Task: group of sync tasks that are treated as a single one.
+ */
+export declare function syncTaskComposite(syncTasks: ISyncTask[]): ISyncTask;

package/types/trackers/filter/bloomFilter.d.ts

@@ -0,0 +1,10 @@
+import { IFilter } from './types';
+export declare class BloomFilterImp implements IFilter {
+    private spectedInsertions;
+    private errorRate;
+    private filter;
+    constructor(spectedInsertions: number, errorRate: number);
+    add(data: string): boolean;
+    contains(data: string): boolean;
+    clear(): void;
+}

package/types/trackers/filter/dictionaryFilter.d.ts

@@ -0,0 +1,8 @@
+import { IFilter } from './types';
+export declare class DictionaryFilter implements IFilter {
+    private filter;
+    constructor();
+    add(data: string): boolean;
+    contains(data: string): boolean;
+    clear(): void;
+}

package/types/trackers/filter/types.d.ts

@@ -0,0 +1,5 @@
+export interface IFilter {
+    add(data: string): boolean;
+    contains(data: string): boolean;
+    clear(): void;
+}

package/types/types.d.ts

@@ -601,6 +601,11 @@ export declare namespace SplitIO {
         configs: {
             [treatmentName: string]: string;
         };
+        /**
+         * List of sets of the feature flag.
+         * @property {string[]} sets
+         */
+        sets: string[];
         /**
          * The default treatment of the feature flag.
          * @property {string} defaultTreatment
@@ -711,7 +716,7 @@ export declare namespace SplitIO {
      * SplitFilter type.
      * @typedef {string} SplitFilterType
      */
-    type SplitFilterType = 'byName' | 'byPrefix';
+    type SplitFilterType = 'byName' | 'byPrefix' | 'bySet';
     /**
      * Defines a feature flag filter, described by a type and list of values.
      */
@@ -1061,6 +1066,42 @@ export declare namespace SplitIO {
          * @returns {TreatmentsWithConfig} The map with all the TreatmentWithConfig objects
          */
         getTreatmentsWithConfig(key: SplitKey, featureFlagNames: string[], attributes?: Attributes): TreatmentsWithConfig;
+        /**
+         * Returns a Treatments value, which is an object map with the treatments for the feature flags related to the given flagSet.
+         * @function getTreatmentsByFlagSet
+         * @param {string} key - The string key representing the consumer.
+         * @param {string} flagSet - The flagSet name we want to get the treatments.
+         * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
+         * @returns {Treatments} The map with all the TreatmentWithConfig objects
+         */
+        getTreatmentsByFlagSet(key: SplitKey, flagSet: string, attributes?: Attributes): Treatments;
+        /**
+         * Returns a TreatmentsWithConfig value, which is an object map with the TreatmentWithConfig (an object with both treatment and config string) for the feature flags related to the given flagSets.
+         * @function getTreatmentsWithConfigByFlagSet
+         * @param {string} key - The string key representing the consumer.
+         * @param {string} flagSet - The flagSet name we want to get the treatments.
+         * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
+         * @returns {Treatments} The map with all the TreatmentWithConfig objects
+         */
+        getTreatmentsWithConfigByFlagSet(key: SplitKey, flagSet: string, attributes?: Attributes): TreatmentsWithConfig;
+        /**
+         * Returns a Returns a Treatments value, which is an object with both treatment and config string for to the feature flags related to the given flagSets.
+         * @function getTreatmentsByFlagSets
+         * @param {string} key - The string key representing the consumer.
+         * @param {Array<string>} flagSets - An array of the flagSet names we want to get the treatments.
+         * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
+         * @returns {Treatments} The map with all the TreatmentWithConfig objects
+         */
+        getTreatmentsByFlagSets(key: SplitKey, flagSets: string[], attributes?: Attributes): Treatments;
+        /**
+         * Returns a TreatmentsWithConfig value, which is an object map with the TreatmentWithConfig (an object with both treatment and config string) for the feature flags related to the given flagSets.
+         * @function getTreatmentsWithConfigByFlagSets
+         * @param {string} key - The string key representing the consumer.
+         * @param {Array<string>} flagSets - An array of the flagSet names we want to get the treatments.
+         * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
+         * @returns {Treatments} The map with all the TreatmentWithConfig objects
+         */
+        getTreatmentsWithConfigByFlagSets(key: SplitKey, flagSets: string[], attributes?: Attributes): TreatmentsWithConfig;
         /**
          * Tracks an event to be fed to the results product on Split user interface.
          * @function track
@@ -1121,6 +1162,46 @@ export declare namespace SplitIO {
          * @returns {AsyncTreatmentsWithConfig} TreatmentsWithConfig promise that resolves to the map of TreatmentsWithConfig objects.
          */
         getTreatmentsWithConfig(key: SplitKey, featureFlagNames: string[], attributes?: Attributes): AsyncTreatmentsWithConfig;
+        /**
+         * Returns a Treatments value, which will be (or eventually be) an object map with the treatments for the features related to the given flag set.
+         * For usage on NodeJS as we don't have only one key.
+         * @function getTreatmentsByFlagSet
+         * @param {string} key - The string key representing the consumer.
+         * @param {string} flagSet - The flag set name we want to get the treatments.
+         * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
+         * @returns {Treatments} The map with all the TreatmentWithConfig objects
+         */
+        getTreatmentsByFlagSet(key: SplitKey, flagSet: string, attributes?: Attributes): AsyncTreatments;
+        /**
+         * Returns a TreatmentWithConfig value, which will be (or eventually be) an object with both treatment and config string for features related to the given flag set.
+         * For usage on NodeJS as we don't have only one key.
+         * @function getTreatmentsWithConfigByFlagSet
+         * @param {string} key - The string key representing the consumer.
+         * @param {string} flagSet - The flag set name we want to get the treatments.
+         * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
+         * @returns {Treatments} The map with all the TreatmentWithConfig objects
+         */
+        getTreatmentsWithConfigByFlagSet(key: SplitKey, flagSet: string, attributes?: Attributes): AsyncTreatmentsWithConfig;
+        /**
+         * Returns a Treatments value, which will be (or eventually be) an object map with the treatments for the feature flags related to the given flag sets.
+         * For usage on NodeJS as we don't have only one key.
+         * @function getTreatmentsByFlagSets
+         * @param {string} key - The string key representing the consumer.
+         * @param {Array<string>} flagSets - An array of the flag set names we want to get the treatments.
+         * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
+         * @returns {Treatments} The map with all the TreatmentWithConfig objects
+         */
+        getTreatmentsByFlagSets(key: SplitKey, flagSets: string[], attributes?: Attributes): AsyncTreatments;
+        /**
+         * Returns a TreatmentWithConfig value, which will be (or eventually be) an object with both treatment and config string for the feature flags related to the given flag sets.
+         * For usage on NodeJS as we don't have only one key.
+         * @function getTreatmentsWithConfigByFlagSets
+         * @param {string} key - The string key representing the consumer.
+         * @param {Array<string>} flagSets - An array of the flag set names we want to get the treatments.
+         * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
+         * @returns {Treatments} The map with all the TreatmentWithConfig objects
+         */
+        getTreatmentsWithConfigByFlagSets(key: SplitKey, flagSets: string[], attributes?: Attributes): AsyncTreatmentsWithConfig;
         /**
          * Tracks an event to be fed to the results product on Split user interface, and returns a promise to signal when the event was successfully queued (or not).
          * @function track
@@ -1171,6 +1252,38 @@ export declare namespace SplitIO {
          * @returns {TreatmentsWithConfig} The map with all the TreatmentWithConfig objects
          */
         getTreatmentsWithConfig(featureFlagNames: string[], attributes?: Attributes): TreatmentsWithConfig;
+        /**
+         * Returns a Treatments value, which is an object map with the treatments for the feature flags related to the given flag set.
+         * @function getTreatmentsByFlagSet
+         * @param {string} flagSet - The flag set name we want to get the treatments.
+         * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
+         * @returns {Treatments} The map with all the TreatmentWithConfig objects
+         */
+        getTreatmentsByFlagSet(flagSet: string, attributes?: Attributes): Treatments;
+        /**
+         * Returns a TreatmentsWithConfig value, which is an object map with the TreatmentWithConfig (an object with both treatment and config string) for the feature flags related to the given flag set.
+         * @function getTreatmentsWithConfigByFlagSet
+         * @param {string} flagSet - The flag set name we want to get the treatments.
+         * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
+         * @returns {Treatments} The map with all the TreatmentWithConfig objects
+         */
+        getTreatmentsWithConfigByFlagSet(flagSet: string, attributes?: Attributes): TreatmentsWithConfig;
+        /**
+         * Returns a Returns a Treatments value, which is an object with both treatment and config string for to the feature flags related to the given flag sets.
+         * @function getTreatmentsByFlagSets
+         * @param {Array<string>} flagSets - An array of the flag set names we want to get the treatments.
+         * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
+         * @returns {Treatments} The map with all the TreatmentWithConfig objects
+         */
+        getTreatmentsByFlagSets(flagSets: string[], attributes?: Attributes): Treatments;
+        /**
+         * Returns a TreatmentsWithConfig value, which is an object map with the TreatmentWithConfig (an object with both treatment and config string) for the feature flags related to the given flag sets.
+         * @function getTreatmentsWithConfigByFlagSets
+         * @param {Array<string>} flagSets - An array of the flag set names we want to get the treatments.
+         * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
+         * @returns {Treatments} The map with all the TreatmentWithConfig objects
+         */
+        getTreatmentsWithConfigByFlagSets(flagSets: string[], attributes?: Attributes): TreatmentsWithConfig;
         /**
          * Tracks an event to be fed to the results product on Split user interface.
          * @function track

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

@@ -45,6 +45,10 @@ export declare const TREATMENT = "t";
 export declare const TREATMENTS = "ts";
 export declare const TREATMENT_WITH_CONFIG = "tc";
 export declare const TREATMENTS_WITH_CONFIG = "tcs";
+export declare const TREATMENTS_BY_FLAGSET = "tf";
+export declare const TREATMENTS_BY_FLAGSETS = "tfs";
+export declare const TREATMENTS_WITH_CONFIG_BY_FLAGSET = "tcf";
+export declare const TREATMENTS_WITH_CONFIG_BY_FLAGSETS = "tcfs";
 export declare const TRACK = "tr";
 export declare const CONNECTION_ESTABLISHED = 0;
 export declare const OCCUPANCY_PRI = 10;

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

@@ -57,4 +57,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 {};

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

@@ -5,7 +5,6 @@ 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.
@@ -13,4 +12,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, mode: string): ISplitFiltersValidation;
+export declare function validateSplitFilters(log: ILogger, maybeSplitFilters: any): ISplitFiltersValidation;
+export declare function flagSetsAreValid(log: ILogger, method: string, flagSets: string[], flagSetsInConfig: string[]): string[];

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

@@ -0,0 +1,70 @@
+import { ILogger } from '../../logger/types';
+import { IResponse } from '../../services/types';
+interface MetricsCollector {
+    countException(): void;
+    count(status: number): void;
+    latency(ms: number): void;
+    ready(ms: number): void;
+    getTreatment(ms: number): void;
+    getTreatments(ms: number): void;
+    getTreatmentWithConfig(ms: number): void;
+    getTreatmentsWithConfig(ms: number): void;
+    [method: string]: (ms: number) => void;
+}
+export declare const TrackerAPI: {
+    /**
+     * "Private" method, used to attach count/countException and stop callbacks to a promise.
+     *
+     * @param {ILogger} log - Logger.
+     * @param {Promise} promise - The promise we want to attach the callbacks.
+     * @param {string} task - The name of the task.
+     * @param {number | string} modifier - (optional) The modifier for the task, if any.
+     */
+    __attachToPromise(log: ILogger, promise: Promise<IResponse>, task: string, collector: false | MetricsCollector, modifier?: string | number | undefined): Promise<IResponse>;
+    /**
+     * Starts tracking the time for a given task. All tasks tracked are considered "unique" because
+     * there may be multiple SDK instances tracking a "generic" task, making any task non-generic.
+     *
+     * @param {ILogger} log - Logger.
+     * @param {string} task - The task we are starting.
+     * @param {Object} collectors - The collectors map.
+     * @param {Promise} promise - (optional) The promise we are tracking.
+     * @return {Function | Promise} The stop function for this specific task or the promise received with the callbacks registered.
+     */
+    start(log: ILogger, task: string, collectors?: Record<string, MetricsCollector> | undefined, promise?: Promise<IResponse> | undefined, now?: (() => number) | undefined): Promise<IResponse> | (() => number);
+    /**
+     * Setup the collector for a task that reports metrics.
+     *
+     * @param {string} task - The task name
+     * @param {number | string} taskUniqueId - The unique identifier for this task
+     * @param {Object} collectors - The collectors map.
+     */
+    setCollectorForTask(task: string, taskUniqueId: number | string, collectors: Record<string, MetricsCollector>): void;
+    /**
+     * Stops the tracking of a given task.
+     *
+     * @param {ILogger} log - Logger.
+     * @param {string} task - The task we are starting.
+     * @param {number | string} modifier - (optional) The modifier for that specific task.
+     */
+    stop(log: ILogger, task: string, modifier?: string | number | undefined): number | undefined;
+    /**
+     * The constants shortcut for the task names.
+     */
+    TaskNames: {
+        SDK_READY: string;
+        SDK_GET_TREATMENT: string;
+        SDK_GET_TREATMENTS: string;
+        SDK_GET_TREATMENT_WITH_CONFIG: string;
+        SDK_GET_TREATMENTS_WITH_CONFIG: string;
+        SPLITS_READY: string;
+        SEGMENTS_READY: string;
+        METRICS_PUSH: string;
+        IMPRESSIONS_PUSH: string;
+        EVENTS_PUSH: string;
+        MY_SEGMENTS_FETCH: string;
+        SEGMENTS_FETCH: string;
+        SPLITS_FETCH: string;
+    };
+};
+export {};

package/types/sdkClient/identity.d.ts

@@ -1,6 +0,0 @@
-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/utils/inputValidation/sdkKey.d.ts

@@ -1,7 +0,0 @@
-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;