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

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

@@ -0,0 +1,11 @@
+import { ILogger } from '../../logger/types';
+/**
+ * Get the treatment name given a key, a seed, and the percentage of each treatment.
+ */
+export declare function getTreatment(log: ILogger, key: string, seed: number, treatments: {
+    getTreatmentFor: (x: number) => string;
+}): string;
+/**
+ * Evaluates the traffic allocation to see if we should apply rollout conditions or not.
+ */
+export declare function shouldApplyRollout(trafficAllocation: number, key: string, trafficAllocationSeed: number): boolean;

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

@@ -0,0 +1,6 @@
+import { MaybeThenable } from '../../dtos/types';
+import { IEvaluator } from '../types';
+import { ILogger } from '../../logger/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/convertions/index.d.ts

@@ -0,0 +1,2 @@
+export declare function zeroSinceHH(millisSinceEpoch: number): number;
+export declare function zeroSinceSS(millisSinceEpoch: number): number;

package/types/evaluator/index.d.ts

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,5 @@
+import { IDependencyMatcherData, MaybeThenable } from '../../dtos/types';
+import { IStorageAsync, IStorageSync } from '../../storages/types';
+import { ILogger } from '../../logger/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

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

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

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

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

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

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

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

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

@@ -0,0 +1,7 @@
+import { IStorageAsync, IStorageSync } from '../../storages/types';
+import { IMatcher, IMatcherDto } from '../types';
+import { ILogger } from '../../logger/types';
+/**
+ * Matcher factory.
+ */
+export declare function matcherFactory(log: ILogger, matcherDto: IMatcherDto, storage?: IStorageSync | IStorageAsync): IMatcher | undefined;

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

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

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

@@ -0,0 +1,10 @@
+export declare const matcherTypes: Record<string, number>;
+export declare const matcherDataTypes: {
+    BOOLEAN: string;
+    STRING: string;
+    NUMBER: string;
+    SET: string;
+    DATETIME: string;
+    NOT_SPECIFIED: string;
+};
+export declare function matcherTypesMapper(matcherType: string): number;

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,3 @@
+import { ISet } from '../../utils/lang/sets';
+import { ILogger } from '../../logger/types';
+export declare function whitelistMatcherContext(log: ILogger, ruleAttr: ISet<string>): (runtimeAttr: string) => boolean;

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

@@ -0,0 +1,6 @@
+import { ISplitMatcher } from '../../dtos/types';
+import { IMatcherDto } from '../types';
+/**
+ * Flat the complex matcherGroup structure into something handy.
+ */
+export declare function matchersTransform(matchers: ISplitMatcher[]): IMatcherDto[];

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

@@ -0,0 +1,5 @@
+import { IInSegmentMatcherData } from '../../dtos/types';
+/**
+ * Extract segment name as a plain string.
+ */
+export declare function segmentTransform(segment?: IInSegmentMatcherData): string | undefined;

package/types/evaluator/matchersTransform/set.d.ts

@@ -0,0 +1,5 @@
+import { IWhitelistMatcherData } from '../../dtos/types';
+/**
+ * Extract whitelist array. Used by set and string matchers
+ */
+export declare function setTransform(whitelistObject: IWhitelistMatcherData): string[];

package/types/evaluator/matchersTransform/unaryNumeric.d.ts

@@ -0,0 +1,5 @@
+import { IUnaryNumericMatcherData } from '../../dtos/types';
+/**
+ * Extract value from unary matcher data.
+ */
+export declare function numericTransform(unaryNumericObject: IUnaryNumericMatcherData): number;

package/types/evaluator/matchersTransform/whitelist.d.ts

@@ -0,0 +1,5 @@
+import { IWhitelistMatcherData } from '../../dtos/types';
+/**
+ * Extract whitelist as a set. Used by 'WHITELIST' matcher.
+ */
+export declare function whitelistTransform(whitelistObject: IWhitelistMatcherData): import("../../utils/lang/sets").ISet<string>;

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

@@ -0,0 +1,5 @@
+import { IEvaluator } from '../types';
+import { ISplitCondition } from '../../dtos/types';
+import { IStorageAsync, IStorageSync } from '../../storages/types';
+import { ILogger } from '../../logger/types';
+export declare function parser(log: ILogger, conditions: ISplitCondition[], storage: IStorageSync | IStorageAsync): IEvaluator;

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

@@ -0,0 +1,8 @@
+import { ISplitPartition } from '../../dtos/types';
+export declare class Treatments {
+    private _ranges;
+    private _treatments;
+    constructor(ranges: number[], treatments: string[]);
+    static parse(data: ISplitPartition[]): Treatments;
+    getTreatmentFor(x: number): string;
+}

package/types/evaluator/types.d.ts

@@ -0,0 +1,28 @@
+import { IBetweenMatcherData, IDependencyMatcherData, MaybeThenable } from '../dtos/types';
+import { IStorageAsync, IStorageSync } from '../storages/types';
+import { ISet } from '../utils/lang/sets';
+import { SplitIO } from '../types';
+import { ILogger } from '../logger/types';
+export interface IDependencyMatcherValue {
+    key: SplitIO.SplitKey;
+    attributes?: SplitIO.Attributes;
+}
+export interface IMatcherDto {
+    type: number;
+    value?: string | number | boolean | string[] | IDependencyMatcherData | ISet<string> | IBetweenMatcherData | null;
+    attribute: string | null;
+    negate: boolean;
+    dataType: string;
+}
+export interface IEvaluation {
+    treatment?: string;
+    label: string;
+    changeNumber?: number;
+    config?: string | null;
+}
+export declare type IEvaluationResult = IEvaluation & {
+    treatment: string;
+};
+export declare type ISplitEvaluator = (log: ILogger, key: SplitIO.SplitKey, splitName: string, attributes: SplitIO.Attributes | undefined, storage: IStorageSync | IStorageAsync) => MaybeThenable<IEvaluation>;
+export declare type IEvaluator = (key: SplitIO.SplitKey, seed: number, trafficAllocation?: number, trafficAllocationSeed?: number, attributes?: SplitIO.Attributes, splitEvaluator?: ISplitEvaluator) => MaybeThenable<IEvaluation | undefined>;
+export declare type IMatcher = (...args: any) => MaybeThenable<boolean>;

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

@@ -0,0 +1,7 @@
+import { SplitIO } from '../../types';
+import { IMatcherDto } from '../types';
+import { ILogger } from '../../logger/types';
+/**
+ * Defines value to be matched (key / attribute).
+ */
+export declare function sanitizeValue(log: ILogger, key: string, matcherDto: IMatcherDto, attributes?: SplitIO.Attributes): string | number | boolean | (string | number)[] | import("../types").IDependencyMatcherValue | undefined;

package/types/evaluator/value/sanitize.d.ts

@@ -0,0 +1,7 @@
+import { SplitIO } from '../../types';
+import { IDependencyMatcherValue } from '../types';
+import { ILogger } from '../../logger/types';
+/**
+ * Sanitize matcher value
+ */
+export declare function sanitize(log: ILogger, matcherTypeID: number, value: string | number | boolean | Array<string | number> | undefined, dataType: string, attributes?: SplitIO.Attributes): string | number | boolean | (string | number)[] | IDependencyMatcherValue | undefined;

package/types/index.d.ts

@@ -0,0 +1,5 @@
+export { InMemoryStorageFactory } from './storages/inMemory/InMemoryStorage';
+export { InMemoryStorageCSFactory } from './storages/inMemory/InMemoryStorageCS';
+export { InLocalStorage } from './storages/inLocalStorage';
+export { PluggableStorage } from './storages/pluggable';
+export { InRedisStorage } from './storages/inRedis';

package/types/integrations/browser.d.ts

@@ -0,0 +1,12 @@
+import { IIntegrationManager, IIntegrationFactoryParams } from './types';
+import { BrowserIntegration } from './ga/types';
+/**
+ * IntegrationsManager factory for the browser variant of the isomorphic JS SDK.
+ * The integrations manager instantiates integration modules, and bypass tracked events and impressions to them.
+ *
+ * @param integrations valid integration settings object for browser sdk
+ * @param params information of the Sdk factory instance that integrations can access to
+ *
+ * @returns integration manager or undefined if `integrations` are not present in settings.
+ */
+export declare function integrationsManagerFactory(integrations: BrowserIntegration[], params: IIntegrationFactoryParams): IIntegrationManager | undefined;

package/types/integrations/ga/GaToSplit.d.ts

@@ -0,0 +1,40 @@
+/// <reference types="google.analytics" />
+import { SplitIO } from '../../types';
+import { Identity, GoogleAnalyticsToSplitOptions } from './types';
+import { ILogger } from '../../logger/types';
+import { IIntegrationFactoryParams } from '../types';
+export declare const defaultMapper: (model: UniversalAnalytics.Model) => SplitIO.EventData;
+export declare const defaultPrefix = "ga";
+/**
+ * Return a new list of identities removing invalid and duplicated ones.
+ *
+ * @param {Array} identities list of identities
+ * @returns list of valid and unique identities. The list might be empty if `identities` is not an array or all its elements are invalid.
+ */
+export declare function validateIdentities(identities?: Identity[]): Identity[];
+/**
+ * Checks if EventData fields (except EventTypeId) are valid, and logs corresponding warnings.
+ * EventTypeId is validated separately.
+ *
+ * @param {EventData} data event data instance to validate. Precondition: data != undefined
+ * @returns {boolean} Whether the data instance is a valid EventData or not.
+ */
+export declare function validateEventData(log: ILogger, eventData: any): eventData is SplitIO.EventData;
+/**
+ * Fixes the passed string value to comply with EventTypeId format, by removing invalid characters and truncating if necessary.
+ *
+ * @param {object} log factory logger
+ * @param {string} eventTypeId string value to fix.
+ * @returns {string} Fixed version of `eventTypeId`.
+ */
+export declare function fixEventTypeId(log: ILogger, eventTypeId: any): any;
+/**
+ * GaToSplit integration.
+ * This function provides the SplitTracker plugin to ga command queue.
+ *
+ * @param {object} sdkOptions options passed at the SDK integrations settings (isomorphic SDK) or the GoogleAnalyticsToSplit plugin (pluggable browser SDK)
+ * @param {object} storage SDK storage passed to track events
+ * @param {object} coreSettings core settings used to define an identity if no one provided as SDK or plugin options
+ * @param {object} log factory logger
+ */
+export declare function GaToSplit(sdkOptions: GoogleAnalyticsToSplitOptions, params: IIntegrationFactoryParams): void;

package/types/integrations/ga/GoogleAnalyticsToSplit.d.ts

@@ -0,0 +1,3 @@
+import { IntegrationFactory } from '../types';
+import { GoogleAnalyticsToSplitOptions } from './types';
+export declare function GoogleAnalyticsToSplit(options?: GoogleAnalyticsToSplitOptions): IntegrationFactory;

package/types/integrations/ga/SplitToGa.d.ts

@@ -0,0 +1,34 @@
+/// <reference types="google.analytics" />
+import { SplitIO } from '../../types';
+import { IIntegration } from '../types';
+import { SplitToGoogleAnalyticsOptions } from './types';
+import { ILogger } from '../../logger/types';
+export declare class SplitToGa implements IIntegration {
+    static defaultTrackerNames: string[];
+    private trackerNames;
+    private filter?;
+    private mapper?;
+    private impressions;
+    private events;
+    private log;
+    static defaultMapper({ type, payload }: SplitIO.IntegrationData): UniversalAnalytics.FieldsObject;
+    static getGa(): UniversalAnalytics.ga | undefined;
+    /**
+     * Validates if a given object is a UniversalAnalytics.FieldsObject instance, and logs a warning if not.
+     * It checks that the object contains a `hitType`, since it is the minimal field required to send the hit
+     * and avoid the GA error `No hit type specified. Aborting hit.`.
+     * Other validations (e.g., an `event` hitType must have a `eventCategory` and `eventAction`) are handled
+     * and logged (as warnings or errors depending the case) by GA debugger, but the hit is sent anyway.
+     *
+     * @param {object} log factory logger
+     * @param {UniversalAnalytics.FieldsObject} fieldsObject object to validate.
+     * @returns {boolean} Whether the data instance is a valid FieldsObject or not.
+     */
+    static validateFieldsObject(log: ILogger, fieldsObject: any): fieldsObject is UniversalAnalytics.FieldsObject;
+    /**
+     * constructor description
+     * @param {object} options options passed at the SDK integrations settings (isomorphic SDK) or the SplitToGoogleAnalytics plugin (pluggable browser SDK)
+     */
+    constructor(log: ILogger, options: SplitToGoogleAnalyticsOptions);
+    queue(data: SplitIO.IntegrationData): void;
+}

package/types/integrations/ga/SplitToGoogleAnalytics.d.ts

@@ -0,0 +1,3 @@
+import { IntegrationFactory } from '../types';
+import { SplitToGoogleAnalyticsOptions } from './types';
+export declare function SplitToGoogleAnalytics(options?: SplitToGoogleAnalyticsOptions): IntegrationFactory;

package/types/integrations/ga/types.d.ts

@@ -0,0 +1,148 @@
+/// <reference types="google.analytics" />
+import { SplitIO } from '../../types';
+/**
+ * A pair of user key and it's trafficType, required for tracking valid Split events.
+ * @typedef {Object} Identity
+ * @property {string} key The user key.
+ * @property {string} trafficType The key traffic type.
+ */
+export declare type Identity = {
+    key: string;
+    trafficType: string;
+};
+/**
+ * Options for GoogleAnalyticsToSplit integration plugin
+ */
+export interface GoogleAnalyticsToSplitOptions {
+    /**
+     * Optional flag to filter GA hits from being tracked as Split events.
+     * @property {boolean} hits
+     * @default true
+     */
+    hits?: boolean;
+    /**
+     * Optional predicate used to define a custom filter for tracking GA hits as Split events.
+     * For example, the following filter allows to track only 'event' hits:
+     *  `(model) => model.get('hitType') === 'event'`
+     * By default, all hits are tracked as Split events.
+     */
+    filter?: (model: UniversalAnalytics.Model) => boolean;
+    /**
+     * Optional function useful when you need to modify the Split event before tracking it.
+     * This function is invoked with two arguments:
+     * 1. the GA model object representing the hit.
+     * 2. the default format of the mapped Split event instance.
+     * The return value must be a Split event, that can be the second argument or a new object.
+     *
+     * For example, the following mapper adds a custom property to events:
+     *  `(model, defaultMapping) => {
+     *      defaultMapping.properties.someProperty = SOME_VALUE;
+     *      return defaultMapping;
+     *  }`
+     */
+    mapper?: (model: UniversalAnalytics.Model, defaultMapping: SplitIO.EventData) => SplitIO.EventData;
+    /**
+     * Optional prefix for EventTypeId, to prevent any kind of data collision between events.
+     * @property {string} prefix
+     * @default 'ga'
+     */
+    prefix?: string;
+    /**
+     * List of Split identities (key & traffic type pairs) used to track events.
+     * If not provided, events are sent using the key and traffic type provided at SDK config
+     */
+    identities?: Identity[];
+    /**
+     * Optional flag to log an error if the `auto-require` script is not detected.
+     * The auto-require script automatically requires the `splitTracker` plugin for created trackers,
+     * and should be placed right after your Google Analytics, Google Tag Manager or gtag.js script tag.
+     *
+     * @see {@link https://help.split.io/hc/en-us/articles/360040838752#set-up-with-gtm-and-gtag.js}
+     *
+     * @property {boolean} autoRequire
+     * @default false
+     */
+    autoRequire?: boolean;
+}
+/**
+ * Enable 'Google Analytics to Split' integration, to track Google Analytics hits as Split events.
+ * Used by the browser variant of the isomorphic JS SDK.
+ *
+ * @see {@link https://help.split.io/hc/en-us/articles/360040838752#google-analytics-to-split}
+ */
+export interface IGoogleAnalyticsToSplitConfig extends GoogleAnalyticsToSplitOptions {
+    type: 'GOOGLE_ANALYTICS_TO_SPLIT';
+}
+/**
+ * Options for SplitToGoogleAnalytics integration plugin
+ */
+export interface SplitToGoogleAnalyticsOptions {
+    /**
+     * Optional flag to filter Split impressions from being tracked as GA hits.
+     * @property {boolean} impressions
+     * @default true
+     */
+    impressions?: boolean;
+    /**
+     * Optional flag to filter Split events from being tracked as GA hits.
+     * @property {boolean} events
+     * @default true
+     */
+    events?: boolean;
+    /**
+     * Optional predicate used to define a custom filter for tracking Split data (events and impressions) as GA hits.
+     * For example, the following filter allows to track only impressions, equivalent to setting events to false:
+     *  `(data) => data.type === 'IMPRESSION'`
+     */
+    filter?: (data: SplitIO.IntegrationData) => boolean;
+    /**
+     * Optional function useful when you need to modify the GA hit before sending it.
+     * This function is invoked with two arguments:
+     * 1. the input data (Split event or impression).
+     * 2. the default format of the mapped FieldsObject instance (GA hit).
+     * The return value must be a FieldsObject, that can be the second argument or a new object.
+     *
+     * For example, the following mapper adds a custom dimension to hits:
+     *  `(data, defaultMapping) => {
+     *      defaultMapping.dimension1 = SOME_VALUE;
+     *      return defaultMapping;
+     *  }`
+     *
+     * Default FieldsObject instance for data.type === 'IMPRESSION':
+     *  `{
+     *    hitType: 'event',
+     *    eventCategory: 'split-impression',
+     *    eventAction: 'Evaluate ' + data.payload.impression.feature,
+     *    eventLabel: 'Treatment: ' + data.payload.impression.treatment + '. Targeting rule: ' + data.payload.impression.label + '.',
+     *    nonInteraction: true,
+     *  }`
+     * Default FieldsObject instance for data.type === 'EVENT':
+     *  `{
+     *    hitType: 'event',
+     *    eventCategory: 'split-event',
+     *    eventAction: data.payload.eventTypeId,
+     *    eventValue: data.payload.value,
+     *    nonInteraction: true,
+     *  }`
+     */
+    mapper?: (data: SplitIO.IntegrationData, defaultMapping: UniversalAnalytics.FieldsObject) => UniversalAnalytics.FieldsObject;
+    /**
+     * List of tracker names to send the hit. An empty string represents the default tracker.
+     * If not provided, hits are only sent to default tracker.
+     */
+    trackerNames?: string[];
+}
+/**
+ * Enable 'Split to Google Analytics' integration, to track Split impressions and events as Google Analytics hits.
+ * Used by the browser variant of the isomorphic JS SDK.
+ *
+ * @see {@link https://help.split.io/hc/en-us/articles/360040838752#split-to-google-analytics}
+ */
+export interface ISplitToGoogleAnalyticsConfig extends SplitToGoogleAnalyticsOptions {
+    type: 'SPLIT_TO_GOOGLE_ANALYTICS';
+}
+/**
+ * Available integration options for the browser
+ * Used by the browser variant of the isomorphic JS SDK.
+ */
+export declare type BrowserIntegration = ISplitToGoogleAnalyticsConfig | IGoogleAnalyticsToSplitConfig;

package/types/integrations/pluggable.d.ts

@@ -0,0 +1,11 @@
+import { IIntegration, IIntegrationManager, IIntegrationFactoryParams } from './types';
+/**
+ * Factory function for IntegrationsManager with pluggable integrations.
+ * The integrations manager instantiates integration, and bypass tracked events and impressions to them.
+ *
+ * @param integrations validated list of integration factories
+ * @param params information of the Sdk factory instance that integrations can access to
+ *
+ * @returns integration manager or undefined if `integrations` are not present in settings.
+ */
+export declare function pluggableIntegrationsManagerFactory(integrations: Array<(params: IIntegrationFactoryParams) => IIntegration | void>, params: IIntegrationFactoryParams): IIntegrationManager | undefined;

package/types/integrations/types.d.ts

@@ -0,0 +1,17 @@
+import { IEventsCacheBase } from '../storages/types';
+import { IEventsHandler, IImpressionsHandler } from '../trackers/types';
+import { ISettings, SplitIO } from '../types';
+export interface IIntegration {
+    queue(data: SplitIO.IntegrationData): void;
+}
+export declare type IIntegrationManager = IEventsHandler & IImpressionsHandler;
+export interface IIntegrationFactoryParams {
+    storage: {
+        events: IEventsCacheBase;
+    };
+    settings: ISettings;
+}
+export declare type IntegrationFactory = {
+    readonly type: string;
+    (params: IIntegrationFactoryParams): IIntegration | void;
+};

package/types/listeners/browser.d.ts

@@ -0,0 +1,40 @@
+import { ISignalListener } from './types';
+import { IStorageSync } from '../storages/types';
+import { ISplitApi } from '../services/types';
+import { ISettings } from '../types';
+import { ISyncManager } from '../sync/types';
+/**
+ * We'll listen for events over the window object.
+ */
+export declare class BrowserSignalListener implements ISignalListener {
+    private syncManager;
+    private settings;
+    private storage;
+    private serviceApi;
+    private fromImpressionsCollector;
+    constructor(syncManager: ISyncManager | undefined, settings: ISettings, storage: IStorageSync, serviceApi: ISplitApi);
+    /**
+     * start method.
+     * Called when SplitFactory is initialized, it adds event listeners to close streaming and flush impressions and events.
+     */
+    start(): void;
+    /**
+     * stop method.
+     * Called when client is destroyed, it removes event listeners.
+     */
+    stop(): void;
+    stopSync(): void;
+    /**
+     * flushData method.
+     * Called when pagehide event is triggered. It flushed remaining impressions and events to the backend,
+     * using beacon API if possible, or falling back to regular post transport.
+     */
+    flushData(): void;
+    flushDataIfHidden(): void;
+    private _flushData;
+    /**
+     * _sendBeacon method.
+     * Util method that check if beacon API is available, build the payload and send it.
+     */
+    private _sendBeacon;
+}

package/types/listeners/node.d.ts

@@ -0,0 +1,22 @@
+import { ISignalListener } from './types';
+import { ISettings } from '../types';
+import { ISyncManager } from '../sync/types';
+/**
+ * We'll listen for SIGTERM since it's the standard signal for server shutdown.
+ *
+ * If you're stopping the execution yourself via the keyboard, or by calling process.exit,
+ * you should call the cleanup logic yourself, since we cannot ensure the data is sent after
+ * the process is already exiting.
+ */
+export declare class NodeSignalListener implements ISignalListener {
+    private handler;
+    private settings;
+    constructor(syncManager: ISyncManager | undefined, // private handler: () => MaybeThenable<void>,
+    settings: ISettings);
+    start(): void;
+    stop(): void;
+    /**
+     * Call the handler, clean up listeners and emit the signal again.
+     */
+    private _sigtermHandler;
+}

package/types/listeners/types.d.ts

@@ -0,0 +1,4 @@
+export interface ISignalListener {
+    start(): any;
+    stop(): any;
+}

package/types/logger/browser/DebugLogger.d.ts

@@ -0,0 +1,2 @@
+import { Logger } from '../index';
+export declare function DebugLogger(): Logger;

package/types/logger/browser/ErrorLogger.d.ts

@@ -0,0 +1,2 @@
+import { Logger } from '../index';
+export declare function ErrorLogger(): Logger;

package/types/logger/browser/InfoLogger.d.ts

@@ -0,0 +1,2 @@
+import { Logger } from '../index';
+export declare function InfoLogger(): Logger;

package/types/logger/browser/WarnLogger.d.ts

@@ -0,0 +1,2 @@
+import { Logger } from '../index';
+export declare function WarnLogger(): Logger;