import { CallerRegistry } from './caller-registry';
import { DataFile } from './data-file';
import { Callback as ListenerCallback, EngineListener } from './engine-listener';
import { EventTransmitter } from './event-transmitter';
import type { Fetch } from './fetch';
import { LogLevel, Logger } from './logger';
import { Store, Targeting } from './store';
export interface MetaData {
    experiment: string | undefined;
    isDataFileAvailable: boolean;
    isDeviceIdentified: boolean;
    isTargeted: boolean;
    variant: string | undefined;
}
export declare type variable = unknown;
interface AbstractFeature {
    isEnabled: boolean;
    variables?: Record<string, variable>;
    metaData: MetaData;
}
export interface FallbackFeature extends AbstractFeature {
    isEnabled: false;
    metaData: {
        experiment: undefined;
        isDataFileAvailable: false;
        isDeviceIdentified: false;
        isTargeted: false;
        variant: undefined;
    };
}
export interface ActiveFeature extends AbstractFeature {
    isEnabled: true;
    variables: Record<string, variable>;
    metaData: {
        experiment: undefined;
        isDataFileAvailable: true;
        isDeviceIdentified: boolean;
        isTargeted: boolean;
        variant: undefined;
    };
}
export interface ActiveFeatureVariation extends AbstractFeature {
    isEnabled: true;
    variables: Record<string, variable>;
    metaData: {
        experiment: string;
        isDataFileAvailable: true;
        isDeviceIdentified: true;
        isTargeted: boolean;
        variant: string;
    };
}
export interface InactiveFeature extends AbstractFeature {
    isEnabled: false;
    metaData: {
        experiment: undefined;
        isDataFileAvailable: true;
        isDeviceIdentified: boolean;
        isTargeted: boolean;
        variant: undefined;
    };
}
export interface InactiveFeatureExperiment extends AbstractFeature {
    isEnabled: false;
    metaData: {
        experiment: string;
        isDataFileAvailable: true;
        isDeviceIdentified: true;
        isTargeted: boolean;
        variant: undefined;
    };
}
export interface InactiveFeatureVariation extends AbstractFeature {
    isEnabled: false;
    metaData: {
        experiment: string;
        isDataFileAvailable: true;
        isDeviceIdentified: true;
        isTargeted: boolean;
        variant: string;
    };
}
export declare type Feature = FallbackFeature | ActiveFeature | ActiveFeatureVariation | InactiveFeature | InactiveFeatureExperiment | InactiveFeatureVariation;
export interface EngineStatus {
    activeExperiment: string | undefined;
    activeVariant: string | undefined;
    isDataFileAvailable: boolean;
    isDecisionMade: boolean;
    isDeviceIdentified: boolean;
}
export interface Engine {
    addEngineListener: (callback: ListenerCallback) => string;
    getDataFile: () => DataFile | undefined;
    getDeviceId: () => string | undefined;
    getFeature: (featureReadableId: string, callerId: string) => Feature;
    getRevision: () => string | undefined;
    getStatus: () => EngineStatus;
    getTargeting: () => Targeting | undefined;
    removeEngineListener: (callbackId: string) => boolean;
    setTargeting: (targeting: Targeting) => void;
    unregisterCaller: (callerId: string) => void;
}
interface BaseEngineConfiguration {
    apiKey: string;
    dataFile?: DataFile | undefined;
    dataFileUrl?: string;
    deviceId?: string | undefined;
    disableEventTransmission?: boolean;
    environmentId?: string | undefined;
    eventGatewayUrl?: string;
    fetch?: Fetch;
    logLevel?: LogLevel;
    targeting?: Targeting;
}
interface DataFileEngineConfiguration extends BaseEngineConfiguration {
    dataFile: DataFile;
    environmentId?: undefined;
}
interface EnvironmentEngineConfiguration extends BaseEngineConfiguration {
    dataFile?: undefined;
    environmentId: string;
}
declare type EngineConfiguration = DataFileEngineConfiguration | EnvironmentEngineConfiguration;
/**
 * Creates an instance of Context Experiments Engine. The Engine is responsible for deciding which features
 * are active and which are inactive.
 *
 * @param apiKey The unique identifier that authenticates requests associated with this project
 * @param dataFile Data file object for this environment fetched from the Context Experiments CDN
 * @param dataFileUrl the location of the Context Experiments data file CDN
 * @param deviceId The Segment Analytics.JS Anonymous Identifier unique to this device
 * @param environmentId The unique identifier of the environment for the data file to be automatically fetched
 * @param eventGatewayUrl The location of the Context Experiments event gateway
 * @param fetch If you're using a platform (i.e Node) that doesn't have a global fetch.
 * @param logLevel The level severity the Engine will log
 */
export declare const create: ({ apiKey, dataFile, dataFileUrl, deviceId, disableEventTransmission, environmentId, eventGatewayUrl, fetch, logLevel, targeting, }: EngineConfiguration) => Engine;
interface BuildEngine {
    callerRegistry: CallerRegistry;
    engineListener: EngineListener;
    logger: Logger;
    store: Store;
    eventTransmitter: EventTransmitter;
}
export declare const buildEngine: ({ callerRegistry, engineListener, logger, store, eventTransmitter, }: BuildEngine) => Engine;
export declare const getFeature: (featureReadableId: string, callerId: string, store: Store, callerRegistry: CallerRegistry, eventTransmitter: EventTransmitter, logger: Logger) => ActiveFeature | ActiveFeatureVariation | InactiveFeature | InactiveFeatureExperiment | InactiveFeatureVariation;
export declare const getExperimentFeature: (featureReadableId: string, callerId: string, store: Store, callerRegistry: CallerRegistry, eventTransmitter: EventTransmitter, logger: Logger) => ActiveFeatureVariation | InactiveFeatureExperiment | InactiveFeatureVariation | undefined;
export declare const getDefaultDeployment: (featureReadableId: string, callerId: string, store: Store, callerRegistry: CallerRegistry, eventTransmitter: EventTransmitter, logger: Logger) => ActiveFeature | undefined;
export {};
//# sourceMappingURL=engine.d.ts.map