export interface ITrackerSettings {
    enable: boolean;
    categoryPrefix?: string;
}
export type TrackingPayloadType = "event" | "page" | "timing";
export interface ITrackingPayload {
    _type: TrackingPayloadType;
}
export interface IEventTrackingPayload extends ITrackingPayload {
    _type: "event";
    /**
     * Event category. If not specified will be defaulted to `analyticalDesigner`
     */
    category?: string;
    action: string;
    label: string;
    value?: number;
    fieldObjects?: {
        [key: string]: any;
    };
}
export interface IPageViewTrackingPayload extends ITrackingPayload {
    _type: "page";
    page?: string;
    location?: string;
    [key: string]: any;
}
export interface ITimingTrackingPayload extends ITrackingPayload {
    _type: "timing";
    label: string;
    value: number;
    variable: string;
    [key: string]: any;
}
export type AnyTrackingPayload = IEventTrackingPayload | IPageViewTrackingPayload | ITimingTrackingPayload;
/**
 * Abstract superclass for all trackers. This already implements some base functionality and
 * through the different abstract methods specifies the interface to implement in the concrete trackers.
 *
 * The different implementations need to transform the payload to whatever the backend accepts and send it
 * out.
 */
export declare abstract class AbstractAnalyticsTracker {
    /**
     * Tracks application event.
     *
     * @param payload - event payload
     */
    abstract trackEvent(payload: IEventTrackingPayload): void;
    /**
     * Tracks application page view.
     *
     * @param payload - page view payload
     */
    abstract trackPageView(payload: IPageViewTrackingPayload): void;
    /**
     * Tracks application timing information.
     *
     * @param payload - timing payload
     */
    abstract trackTiming(payload: ITimingTrackingPayload): void;
    /**
     * Some tracker implementations may accumulating tracking payloads instead of sending them out. Those
     * trackers should return the accumulated events through
     */
    getAccumulated(): AnyTrackingPayload[];
    /**
     * Track all payloads that may be accumulated in the 'other' tracker.
     *
     * @param other - the other tracker with accumulated payloads
     */
    trackAccumulated(other: AbstractAnalyticsTracker): void;
}
/**
 * This implementation of analytics tracker will hoard the different payloads to track in the order which they
 * are submitted. The tracker will not do anything apart from that. The accumulated payloads can be retrieved
 * at later time.
 *
 * The purpose of this tracker is to hold onto various tracking payloads that the app MAY try to dispatch before
 * the tracking is fully initialized. This can happen in some contexts - such as in Tiger where the tracking is
 * only enabled later on as the app learns whether the telemetry is setup for the current user.
 */
export declare class AccumulatingTracker extends AbstractAnalyticsTracker {
    private readonly accumulator;
    trackEvent(payload: IEventTrackingPayload): void;
    trackPageView(payload: IPageViewTrackingPayload): void;
    trackTiming(payload: ITimingTrackingPayload): void;
    getAccumulated(): AnyTrackingPayload[];
}
/**
 * This implementation of analytics tracker does nothing. It sinks all the events.
 */
export declare class NoopAnalyticsTracker extends AbstractAnalyticsTracker {
    trackEvent(_payload: IEventTrackingPayload): void;
    trackPageView(_payload: IPageViewTrackingPayload): void;
    trackTiming(_payload: ITimingTrackingPayload): void;
}
