import { Dimensions, EventTransformer, AardEvent, SimpleAardEvent } from './recorder.types';
interface RecorderConfig {
    projectName: string;
    apiKey: string;
    session?: boolean;
    fetchFn?: typeof fetch;
    maxRetries?: number;
    environment?: string;
    baseUrlCreator?: (env: string) => string;
    transformers?: EventTransformer[];
    debug?: boolean;
}
export default class AardRecorder {
    projectName: string;
    session: boolean;
    private client;
    private fragments;
    private transformers;
    private eventQueue;
    private busyCount;
    constructor({ projectName, apiKey, session, fetchFn, maxRetries, environment, baseUrlCreator, transformers, debug, }: RecorderConfig);
    /**
     * Register a fragmet on Aard server and store its hash with the provided arbitrary name
     * The hash will be added to every event, in order to have the fragment merged to the event server side.
     */
    registerFragment(name: string, dimensionsObject: Dimensions): Promise<void>;
    /**
     * Adds a fragment hash to the recorder without registering any fragment on the server
     */
    addFragmentHash(name: string, hash: string): void;
    /**
     * Returns a map of fragment names and their hash
     */
    getFragments(): Map<string, string>;
    /**
     * Returns a the fragment hash stored with the provided name
     */
    getFragment(name: string): string | undefined;
    /**
     * Returns an array with all the fragment hashes stored in the recoder
     */
    getFragmentsHashes(): string[];
    /**
     * Removes the fragment hash stored with the provided name
     */
    removeFragment(name: string): void;
    /**
     * Adds a transformer to the recorder.
     * This transformer will be applied to every event.
     */
    addTransformer(transformer: EventTransformer): void;
    /**
     * Removes a transformer from the recorder.
     */
    removeTransformer(transformer: EventTransformer): void;
    /**
     * Returns a list of all the stored transformers.
     */
    getTransformersList(): EventTransformer[];
    /**
     * Returns the internal client used to communicate with the Aard client.
     * The client is an object that expose the following functions:
     * - trasnformEvent(event, transformers) transforms an event with the provided transformers
     * - saveFragment(dimensions) saves the provided dimensions as a fragment on the Aard server and returns its hash
     * - sendEvent(dimensions) sends an event to the Aard server
     */
    getClient: () => {
        transformEvent: (event: AardEvent, transformers: EventTransformer[]) => AardEvent;
        saveFragment: (dimensions: Dimensions) => Promise<unknown>;
        sendEvent: (event: AardEvent) => Promise<unknown>;
    };
    /**
     * Sends an event to the Aard server.
     * It applies the following modifications to the event:
     * - applies all the transformer provided to this method
     * - applies all the transformer stored in the recoder
     * - adds the restore fragment plugin for every fragment hash stored in the recorder
     */
    sendEvent(name: string, { dimensions, plugins, unit, value, }: SimpleAardEvent, transformers?: EventTransformer[]): void;
    /**
     * Same as sendEvent, but specifically for the pageview event.
     */
    sendPageView({ dimensions, plugins, }: SimpleAardEvent, transformers?: EventTransformer[]): void;
    private transformEvent;
    private addEventToQueue;
    private tryConsumeQueue;
}
export {};