declare interface ButtonClickEvent {
    elementId: string | null;
    element: HTMLElement;
}

declare interface ContactCapturedEvent {
    data: Record<string, string>;
}

declare function createRouter(options?: RouterOptions): Router;

declare function createTracker(options?: TrackerOptions): Tracker;

declare interface ElementVisibleEvent {
    elementId: string;
    element: HTMLElement;
}

/**
 * Why: os três bundles do SDK (forms, tracking, routing) coexistem na mesma
 * página sem se conhecerem. O bus desacopla "quem detecta DOM" (collectors em
 * tracking/listeners/*) de "quem reage" (router de funnel em routing/, plugins
 * de pixel em tracking/plugins/*).
 *
 * Dois canais de entrega intencionais:
 *  - `listeners`: assinantes tipados por evento (TrackingEventMap) — uso interno
 *    do SDK, ex.: routing escuta `button_click`/`scroll` para resolver redirects.
 *  - `plugins`: catch-all que recebe TODOS os eventos — usado por integrações
 *    3rd-party (Facebook Pixel etc.) que precisam observar o fluxo inteiro sem
 *    listar cada tipo manualmente.
 */
declare class EventBus {
    private listeners;
    private plugins;
    on<K extends keyof TrackingEventMap>(type: K, handler: EventHandler<TrackingEventMap[K]>): void;
    on(type: string, handler: EventHandler): void;
    off<K extends keyof TrackingEventMap>(type: K, handler: EventHandler<TrackingEventMap[K]>): void;
    off(type: string, handler: EventHandler): void;
    once<K extends keyof TrackingEventMap>(type: K, handler: EventHandler<TrackingEventMap[K]>): void;
    once(type: string, handler: EventHandler): void;
    emit<K extends keyof TrackingEventMap>(type: K, data: TrackingEventMap[K]): void;
    emit(type: string, data: unknown): void;
    registerPlugin(plugin: TrackingPlugin): () => void;
    destroy(): void;
}

declare type EventHandler<T = any> = (data: T) => void;

declare function facebookPixel(): TrackingPlugin;

declare function findTriggerUrl(type: string, elementId: string | null): URL | undefined;

export declare namespace forms {
    export {
        submitLead,
        SubmitLeadOptions
    }
}

declare interface FormSubmitEvent {
    formId: string | null;
}

declare function getScrollTriggers(): Array<{
    percentage: number;
    url: string;
}>;

export declare function initRouting(): void;

export declare function initTracking(): void;

declare interface LinkClickEvent {
    elementId: string | null;
    element: HTMLElement;
}

declare function nextNodeFromDeployConfig(key: 'nextUrl' | 'nextUpsellUrl' | 'nextDownsellUrl', errorMsg: string): URL | undefined;

declare interface PageViewEvent {
    url: string;
}

declare interface PurchaseEvent {
    value?: number;
    currency?: string;
}

declare interface Router {
    bus: EventBus;
    init(): void;
    destroy(): void;
}

declare interface RouterOptions {
    bus?: EventBus;
}

export declare namespace routing {
    export {
        initRouting,
        createRouter,
        EventBus,
        findTriggerUrl,
        getScrollTriggers,
        nextNodeFromDeployConfig,
        RouterOptions,
        Router
    }
}

declare interface ScrollEvent {
    percentage: number;
}

/**
 * Sends a lead directly to the Clickmax ingest endpoint.
 * Use this when the host page already owns the markup and submit lifecycle.
 */
declare function submitLead(options: SubmitLeadOptions): Promise<SubmitLeadResponse>;

declare interface SubmitLeadInput {
    email?: string;
    lgpdApproved?: boolean;
    name?: string;
    telephone?: string;
    utmCampaign?: string;
    utmContent?: string;
    utmMedium?: string;
    utmSource?: string;
    utmTerm?: string;
}

declare interface SubmitLeadOptions {
    apiUrl?: string;
    data: SubmitLeadInput;
    signal?: AbortSignal;
    slug: string;
}

declare interface SubmitLeadResponse {
    leadId: string;
    redirectUrl?: string | null;
}

declare interface Tracker {
    bus: EventBus;
    on: EventBus['on'];
    off: EventBus['off'];
    once: EventBus['once'];
    init(): void;
    destroy(): void;
}

declare interface TrackerOptions {
    clicks?: boolean;
    forms?: boolean;
    scroll?: {
        thresholds?: number[];
    } | boolean;
    visibility?: boolean;
    messages?: boolean;
    plugins?: TrackingPlugin[];
    bus?: EventBus;
}

export declare namespace tracking {
    export {
        initTracking,
        createTracker,
        EventBus,
        TrackingEventMap,
        TrackingPlugin,
        facebookPixel,
        TrackerOptions,
        Tracker
    }
}

declare interface TrackingEventMap {
    button_click: ButtonClickEvent;
    link_click: LinkClickEvent;
    scroll: ScrollEvent;
    form_submit: FormSubmitEvent;
    page_view: PageViewEvent;
    element_visible: ElementVisibleEvent;
    contact_captured: ContactCapturedEvent;
    purchase: PurchaseEvent;
    initiate_checkout: Record<string, never>;
}

declare interface TrackingPlugin {
    name: string;
    init?(): void;
    onEvent(type: string, data: unknown): void;
    destroy?(): void;
}

export { }