import type { EventProcessorFn, MapLike, TypedAny } from '../common/app-types';
export declare class MpDataLayerHelper {
    private readonly dlEventName;
    private readonly dlInitMode;
    private readonly storageKeyName;
    isReady: boolean;
    _masterDataLayer: MapLike;
    _persistedVars: MapLike;
    eventProcessors: Record<string, any>;
    stateTracker: Array<any>;
    dlInitEvent: string;
    receivedInitialEvent: boolean;
    eventQueue: Array<any>;
    private isProcessing;
    private isEntryPoint;
    private eventDedupWindowMs;
    private eventDeduplicationCache;
    private purchaseTransactionCache;
    constructor(dlEventName: string, dlInitMode: string, dlInitEvent: string, storageKeyName?: string);
    init(globalEventListeners: Record<string, EventProcessorFn>): Promise<void>;
    /**
     * Set the event deduplication window
     * @param windowMs Window in milliseconds (0 to disable)
     */
    setDeduplicationWindow(windowMs: number): void;
    /**
     * Generate a unique fingerprint for an event
     * @param eventName Event name
     * @param payload Event payload
     * @returns Fingerprint string
     */
    private getEventFingerprint;
    /**
     * Extract transaction_id from purchase event payload
     * @param payload Event payload
     * @returns transaction_id or null
     */
    private extractTransactionId;
    /**
     * Check if event is a duplicate within the deduplication window
     * @param eventName Event name
     * @param payload Event payload
     * @returns true if duplicate, false otherwise
     */
    private isDuplicateEvent;
    /**
     * Remove expired entries from deduplication caches
     * @param now Current timestamp
     */
    private cleanupDeduplicationCache;
    pushEvent(eventName: string, payload: MapLike): void;
    processQItems(eventName: string, payload: MapLike): Promise<void>;
    /**
     * Private Processor for 'set' command object
     */
    setDl(obj: TypedAny | undefined): boolean;
    getDl(): TypedAny;
    private setUserData;
    private deleteData;
    private storeData;
    private reloadPersistedVars;
    private getFullData;
    private storeFullData;
    /**
     * Private event processor. Idea is that whenever an event is detected, we create a copy of the master data layer,
     * add the event variables, and trigger the event requested when initializing the data layer helper
     * @param eventName
     * @param model
     */
    eventProcessor(eventName: string, model: TypedAny | undefined): Promise<void>;
    overrideDlInitEvent(eventName: string): string;
    /**
     * Exposed method for registering custom processors for events
     * @param eventType
     * @param fn
     */
    registerProcessor(eventType: string, fn: EventProcessorFn): void;
    /**
     * Exposed getter for getting values from data layer
     * @param key
     * @returns {*|undefined}
     */
    get(key: string): MapLike | undefined;
    getState(): TypedAny[];
    hasEventHappened(key: string): boolean;
    reset(): boolean;
    /**
     * Full shutdown - clears all state and allows reinitialization
     */
    shutdown(): void;
    ready(): void;
    /**
     * Process next event in queue with atomic check-and-set
     * Ensures only one event processes at a time, eliminating race conditions
     */
    processNext(): void;
    getIsEntryPointValue(): number;
    resetEntryPointInfo(): void;
}