@beworke/pixel 0.1.0-rc.6 → 0.1.0-rc.7

package/dist/v2/index.d.ts

@@ -1,9 +1,793 @@
-export { Pixel, PixelDebugSnapshot } from '../index.js';
-export { P as PixelConfig } from '../pixel-BxZZx8l5.js';
-export { D as DEFAULT_PIXEL_CONFIG } from '../pixel-default-config-aAOujzwp.js';
-export { r as resolveStorageAdapterName } from '../StorageFactory-tjfzk57c.js';
-import '../index-CQAyT5Od.js';
-import '../url-context-BjAsQoVl.js';
-import '../PixelLogger-B21lEjep.js';
-import '../types-D_SsCur9.js';
-import '../types-C75pQP31.js';
+import { P as PixelEvent, l as PurchaseData, L as LeadData, m as AddToCartData, R as RemoveFromCartData, I as InitiateCheckoutData, n as AddPaymentInfoData, V as ViewContentData, o as SearchData, e as AttributionIdentifiers } from '../index-B8u_3PGG.js';
+import { P as PixelLogger } from '../PixelLogger-B21lEjep.js';
+import { P as PixelConfig } from '../pixel-2uL4LSyC.js';
+import { P as PixelRuntimeServices } from '../types-fFcQ1apy.js';
+import { P as PixelModule, a as PixelRuntimeContext } from '../types-BqUEoZo0.js';
+export { D as DEFAULT_PIXEL_CONFIG } from '../pixel-default-config-BDPUVHse.js';
+export { r as resolveStorageAdapterName } from '../StorageFactory-DeMaZ8wk.js';
+import '../url-context-Ck2LK18V.js';
+
+type DestinationResultStatus = 'success' | 'failed' | 'ignored' | 'retry' | 'skipped';
+type DestinationResult = {
+    readonly status: DestinationResultStatus;
+    readonly adapter: string;
+    readonly duration: number;
+    readonly timestamp: number;
+    readonly error?: string;
+    readonly ignored?: boolean;
+    readonly skipped?: boolean;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+};
+type DestinationMetricsSnapshot = {
+    readonly registeredDestinations: number;
+    readonly activeDestinations: number;
+    readonly eventsSent: number;
+    readonly eventsFailed: number;
+    readonly eventsIgnored: number;
+    readonly eventsSkipped: number;
+    readonly pageViewReceived: number;
+    readonly pageViewSent: number;
+    readonly pageViewSkipped: number;
+    readonly pageViewDeduped: number;
+    readonly pageViewFailed: number;
+    readonly scriptLoadAttempts: number;
+    readonly scriptLoadSuccess: number;
+    readonly scriptLoadFailure: number;
+    readonly initAttempts: number;
+    readonly initSuccess: number;
+    readonly initFailure: number;
+    readonly averageDuration: number;
+    readonly successRate: number;
+    readonly lastExecutionAt: number | null;
+    readonly lastErrorAt: number | null;
+    readonly lastErrorMessage: string | null;
+    readonly perDestination: Readonly<Record<string, {
+        readonly sent: number;
+        readonly failed: number;
+        readonly ignored: number;
+        readonly skipped: number;
+        readonly averageDuration: number;
+        readonly successRate: number;
+        readonly pageViewSent: number;
+        readonly pageViewDeduped: number;
+        readonly pageViewFailed: number;
+        readonly scriptLoadAttempts: number;
+        readonly scriptLoadSuccess: number;
+        readonly scriptLoadFailure: number;
+        readonly initAttempts: number;
+        readonly initSuccess: number;
+        readonly initFailure: number;
+        readonly lastError: string | null;
+    }>>;
+    readonly perDestinationId: Readonly<Record<string, {
+        readonly sent: number;
+        readonly failed: number;
+        readonly pageViewSent: number;
+        readonly pageViewDeduped: number;
+        readonly pageViewFailed: number;
+    }>>;
+};
+type IntegrationDebugState = {
+    readonly active: boolean;
+    readonly destinationNames: readonly string[];
+    readonly metrics: DestinationMetricsSnapshot;
+    readonly lastResults: readonly DestinationResult[];
+};
+
+type CompressionDebugState = {
+    readonly enabled: boolean;
+    readonly strategy: string;
+    readonly lastOriginalSize: number | null;
+    readonly lastCompressedSize: number | null;
+};
+
+type CoordinationDebugState = {
+    readonly enabled: boolean;
+    readonly tabId: string;
+    readonly isLeader: boolean;
+    readonly leaderTabId: string | null;
+    readonly tabCount: number;
+    readonly transport: 'broadcastChannel' | 'storageEvents' | 'none';
+};
+
+type DeadLetterReason = 'max_retries_exceeded' | 'circuit_open' | 'permanent_failure' | 'manual';
+type DeadLetterEntry = {
+    readonly id: string;
+    readonly events: readonly PixelEvent[];
+    readonly reason: DeadLetterReason;
+    readonly failedAt: number;
+    readonly attempts: number;
+    readonly lastError?: string;
+};
+type DeadLetterDebugState = {
+    readonly enabled: boolean;
+    readonly count: number;
+    readonly maxEntries: number;
+    readonly entries: readonly DeadLetterEntry[];
+};
+
+type BatchConfig = {
+    readonly batchSize: number;
+    readonly flushIntervalMs: number;
+    readonly maxWaitMs: number;
+};
+type BatchDebugState = {
+    readonly bufferSize: number;
+    readonly oldestEventAt: number | null;
+    readonly pendingBatches: number;
+};
+interface IBatchManager {
+    add(events: readonly PixelEvent[]): void;
+    takeBatch(maxSize?: number): PixelEvent[];
+    peek(): readonly PixelEvent[];
+    size(): number;
+    clear(): void;
+    shouldFlush(config: BatchConfig): boolean;
+    getState(): BatchDebugState;
+}
+
+type FlushDebugState = {
+    readonly flushCount: number;
+    readonly lastFlushAt: number | null;
+    readonly intervalActive: boolean;
+};
+interface IFlushManager {
+    init(onFlush: () => void): void;
+    flush(): void;
+    destroy(): void;
+    getState(): FlushDebugState;
+}
+
+type OfflineDebugState = {
+    readonly isOnline: boolean;
+    readonly paused: boolean;
+    readonly simulatedOffline: boolean;
+};
+interface IOfflineDetector {
+    init(onOnline: () => void, onOffline: () => void): void;
+    isOnline(): boolean;
+    isPaused(): boolean;
+    destroy(): void;
+    /** @internal Testes e playground apenas. */
+    simulateOffline(offline: boolean): void;
+    getState(): OfflineDebugState;
+}
+
+type RetryTask = () => Promise<void>;
+type RetryAttemptState = {
+    readonly id: string;
+    readonly attempt: number;
+    readonly nextRetryAt: number | null;
+    readonly status: 'pending' | 'running' | 'scheduled' | 'completed' | 'failed' | 'cancelled';
+};
+type RetryDebugState = {
+    readonly pendingCount: number;
+    readonly attempts: readonly RetryAttemptState[];
+};
+interface IRetryEngine {
+    retry(task: RetryTask, taskId?: string): Promise<void>;
+    cancel(taskId: string): void;
+    cancelAll(): void;
+    getState(): RetryDebugState;
+}
+
+type SendOptions = {
+    readonly signal?: AbortSignal;
+};
+type SendResult = {
+    readonly ack: boolean;
+    readonly eventCount: number;
+};
+interface EventSender {
+    send(events: PixelEvent[], options?: SendOptions): Promise<SendResult>;
+}
+
+type DeliveryConfig = {
+    readonly batch: BatchConfig;
+    readonly timeoutMs: number;
+};
+type DeliveryDebugState = {
+    readonly batch: ReturnType<IBatchManager['getState']>;
+    readonly retry: ReturnType<IRetryEngine['getState']>;
+    readonly offline: ReturnType<IOfflineDetector['getState']>;
+    readonly flush: ReturnType<IFlushManager['getState']>;
+    readonly timeoutMs: number;
+    readonly inFlight: boolean;
+    readonly ackCount: number;
+};
+declare class TransportDelivery {
+    private readonly batchManager;
+    private readonly flushManager;
+    private readonly retryEngine;
+    private readonly offlineDetector;
+    private readonly sender;
+    private readonly config;
+    private readonly logger;
+    private active;
+    private inFlight;
+    private ackCount;
+    private abortPending;
+    private readonly onPermanentFailure;
+    constructor(deps: {
+        batchManager: IBatchManager;
+        flushManager: IFlushManager;
+        retryEngine: IRetryEngine;
+        offlineDetector: IOfflineDetector;
+        sender: EventSender;
+        config: DeliveryConfig;
+        logger: PixelLogger;
+        abortPending?: () => void;
+        onPermanentFailure?: (events: readonly PixelEvent[], error: unknown) => void;
+    });
+    init(): void;
+    destroy(): void;
+    ingest(events: readonly PixelEvent[]): void;
+    flush(): void;
+    getDebugState(): DeliveryDebugState;
+    getOfflineDetector(): IOfflineDetector;
+    private processBatch;
+}
+
+type OrderingDebugState = {
+    readonly enabled: boolean;
+    readonly globalSequence: number;
+    readonly sessionSequence: number;
+    readonly lastCorrelationId: string | null;
+    readonly recordCount: number;
+};
+
+type BackpressurePolicy = 'drop_oldest' | 'drop_newest' | 'reject_new' | 'sample' | 'none';
+type BackpressureDebugState = {
+    readonly enabled: boolean;
+    readonly currentSize: number;
+    readonly maxQueueSize: number;
+    readonly policy: BackpressurePolicy;
+    readonly totalDropped: number;
+    readonly totalRejected: number;
+    readonly totalSampled: number;
+};
+
+type ReplayTrigger = 'init' | 'reload' | 'reconnect' | 'restart' | 'manual';
+type ReplayDebugState = {
+    readonly enabled: boolean;
+    readonly lastTrigger: ReplayTrigger | null;
+    readonly lastReplayAt: number | null;
+    readonly totalReplayed: number;
+    readonly pendingCount: number;
+};
+
+type CircuitBreakerState = 'closed' | 'open' | 'half_open';
+type CircuitBreakerMetrics = {
+    readonly state: CircuitBreakerState;
+    readonly consecutiveFailures: number;
+    readonly totalFailures: number;
+    readonly totalSuccesses: number;
+    readonly totalBlocked: number;
+    readonly lastFailureAt: number | null;
+    readonly lastSuccessAt: number | null;
+    readonly openedAt: number | null;
+};
+
+type TransportAdvancedDebugState = {
+    readonly storage: {
+        readonly adapter: string;
+        readonly persistenceEnabled: boolean;
+        readonly recordCount: number;
+    };
+    readonly replay: ReplayDebugState;
+    readonly ordering: OrderingDebugState;
+    readonly coordination: CoordinationDebugState;
+    readonly circuitBreaker: CircuitBreakerMetrics;
+    readonly backpressure: BackpressureDebugState;
+    readonly deadLetter: DeadLetterDebugState;
+    readonly compression: CompressionDebugState;
+    readonly senderMode: 'mock' | 'http';
+};
+type TransportDebugState = {
+    readonly queueSize: number;
+    readonly queueContents: readonly PixelEvent[];
+    readonly pipelineSteps: readonly string[];
+    readonly senderLogs: readonly string[];
+    readonly sentCount: number;
+    readonly delivery: ReturnType<TransportDelivery['getDebugState']> | null;
+    readonly sender: Record<string, unknown> | null;
+    readonly advanced: TransportAdvancedDebugState | null;
+};
+
+/**
+ * Contratos oficiais do Debug Snapshot (Etapa 16).
+ * Somente dados serializáveis, read-only, sem DOM/callbacks/classes.
+ */
+type DebugHealthStatus = 'healthy' | 'degraded' | 'unhealthy' | 'unknown';
+type DebugWarning = {
+    readonly code: string;
+    readonly message: string;
+    readonly source?: string;
+};
+type DebugError = {
+    readonly code: string;
+    readonly message: string;
+    readonly source?: string;
+    readonly at?: number;
+};
+type RuntimeHealthSnapshot = {
+    readonly status: DebugHealthStatus;
+    readonly checks: ReadonlyArray<{
+        readonly id: string;
+        readonly status: DebugHealthStatus;
+        readonly detail?: string;
+    }>;
+    readonly reasons: readonly string[];
+};
+type RuntimeDebugSnapshot = {
+    readonly initialized: boolean;
+    readonly destroyed: boolean;
+    readonly moduleCount: number;
+    readonly activeModuleCount: number;
+    readonly moduleNames: readonly string[];
+    readonly activeModuleNames: readonly string[];
+};
+type ModuleDebugSnapshot = {
+    /** Identificador do módulo (não confundir com PII `name`). */
+    readonly id: string;
+    readonly configuredEnabled: boolean;
+    readonly initialized: boolean;
+};
+type CoreDebugSnapshot = {
+    readonly enabled: boolean;
+    readonly visitorId: string | null;
+    readonly sessionId: string | null;
+    readonly sessionExpired: boolean | null;
+    readonly fingerprint: string | null;
+    readonly urlContextEnabled: boolean;
+};
+type UrlContextDebugSnapshot = {
+    readonly enabled: boolean;
+    readonly available: boolean;
+    readonly managedKeys: readonly string[];
+    readonly forwardedKeys: readonly string[];
+    readonly source: Readonly<Record<string, string>>;
+    readonly queryParamCount: number;
+};
+type AttributionDebugSnapshot = {
+    readonly enabled: boolean;
+    readonly available: boolean;
+    readonly identifierKeys: readonly string[];
+    /** Valores mascarados / públicos apenas. */
+    readonly identifiers: Readonly<Record<string, string>>;
+};
+type CommerceDebugSnapshot = {
+    readonly enabled: boolean;
+    readonly available: boolean;
+    readonly mode: string | null;
+    readonly currency: string | null;
+    readonly catalogSize: number;
+    readonly itemCount: number;
+    readonly cartValue: number | null;
+    readonly productIds: readonly string[];
+};
+type BehaviorHeartbeatDebugSnapshot = {
+    readonly enabled: boolean;
+    readonly initialized: boolean;
+    readonly running: boolean;
+    readonly intervalMs: number;
+    readonly hiddenIntervalMs: number;
+    readonly sequence: number;
+    readonly emittedCount: number;
+    readonly skippedCount: number;
+    readonly lastEmittedAt: number | undefined;
+    readonly nextExpectedAt: number | undefined;
+    readonly lastDriftMs: number | undefined;
+};
+type BehaviorViewportDebugSnapshot = {
+    readonly enabled: boolean;
+    readonly initialized: boolean;
+    readonly available: boolean;
+    readonly targetCount: number;
+    readonly matchedElementCount: number;
+    readonly observedElementCount: number;
+    readonly activeElementCount: number;
+    readonly pendingElementCount: number;
+    readonly enterCount: number;
+    readonly exitCount: number;
+    readonly mutationObserverEnabled: boolean;
+    readonly maxObservedElements: number;
+    readonly limitReached: boolean;
+    readonly lastEventAt: number | undefined;
+};
+type BehaviorEngagementSignalCounts = {
+    readonly HEARTBEAT: number;
+    readonly SCROLL: number;
+    readonly CLICK: number;
+    readonly RAGE_CLICK: number;
+    readonly IDLE: number;
+    readonly ACTIVITY: number;
+    readonly VISIBLE: number;
+    readonly HIDDEN: number;
+    readonly VIEWPORT_ENTER: number;
+    readonly VIEWPORT_EXIT: number;
+};
+type BehaviorEngagementDebugSnapshot = {
+    readonly enabled: boolean;
+    readonly initialized: boolean;
+    readonly running: boolean;
+    readonly score: number;
+    readonly previousScore: number;
+    readonly peakScore: number;
+    readonly averageScore: number;
+    readonly level: 'low' | 'medium' | 'high';
+    readonly evaluationCount: number;
+    readonly emittedUpdateCount: number;
+    readonly emittedSummaryCount: number;
+    readonly lastEvaluatedAt: number | undefined;
+    readonly lastEmittedAt: number | undefined;
+    readonly evaluationIntervalMs: number;
+    readonly lastDriftMs: number | undefined;
+    readonly hasError: boolean;
+    readonly signalCounts: BehaviorEngagementSignalCounts;
+};
+type BehaviorRateLimitDebugSnapshot = {
+    readonly enabled: boolean;
+    readonly windowMs: number;
+    readonly maxSignalsPerWindow: number;
+    readonly criticalBypass: boolean;
+    readonly accepted: number;
+    readonly dropped: number;
+    readonly bypassed: number;
+    readonly windowCount: number;
+    readonly windowStartedAt: number | undefined;
+};
+type BehaviorBufferDebugSnapshot = {
+    readonly enabled: boolean;
+    readonly size: number;
+    readonly maxSize: number;
+    readonly flushSize: number;
+    readonly maxAgeMs: number;
+    readonly dropStrategy: 'drop_oldest' | 'drop_newest' | 'compress_similar';
+    readonly flushCount: number;
+    readonly dropCount: number;
+    readonly compressedCount: number;
+    readonly lastFlushAt: number | undefined;
+    readonly lastFlushReason: 'size' | 'age' | 'hidden' | 'destroy' | 'manual' | undefined;
+};
+type BehaviorStateMachineDebugSnapshot = {
+    readonly enabled: boolean;
+    readonly state: string;
+    readonly previousState: string | undefined;
+    readonly generation: number;
+    readonly changedAt: number | undefined;
+    readonly transitionCount: number;
+    readonly invalidTransitionCount: number;
+    readonly historySize: number;
+};
+type BehaviorSessionSummaryDebugSnapshot = {
+    readonly enabled: boolean;
+    readonly emitOnHidden: boolean;
+    readonly emitOnDestroy: boolean;
+    readonly minimumSessionMs: number;
+    readonly emittedCount: number;
+    readonly lastEmittedAt: number | undefined;
+    readonly startedAt: number | undefined;
+};
+type BehaviorDebugSnapshot = {
+    readonly enabled: boolean;
+    readonly configuredTrackers: readonly string[];
+    readonly configuredEngines: readonly string[];
+    readonly heartbeat: BehaviorHeartbeatDebugSnapshot | null;
+    readonly viewport: BehaviorViewportDebugSnapshot | null;
+    readonly engagement: BehaviorEngagementDebugSnapshot | null;
+    readonly rateLimit: BehaviorRateLimitDebugSnapshot | null;
+    readonly buffer: BehaviorBufferDebugSnapshot | null;
+    readonly stateMachine: BehaviorStateMachineDebugSnapshot | null;
+    readonly sessionSummary: BehaviorSessionSummaryDebugSnapshot | null;
+};
+type ConversionDebugSnapshot = {
+    readonly enabled: boolean;
+    readonly autoEnabled: boolean;
+    readonly manualEnabledFlags: Readonly<Record<string, boolean>>;
+    readonly detectorCount: number;
+    readonly activeDetectors: readonly string[];
+    readonly dedupeKeyCount: number;
+};
+type IntegrationsDebugSnapshot = {
+    readonly enabled: boolean;
+    readonly available: boolean;
+    readonly active: boolean;
+    readonly destinationNames: readonly string[];
+    readonly metrics: Readonly<Record<string, unknown>> | null;
+};
+type TransportDebugSnapshot = {
+    readonly enabled: boolean;
+    readonly available: boolean;
+    readonly online: boolean | 'unknown';
+    readonly senderMode: string | 'unknown' | 'unavailable';
+    readonly queueSize: number | 'unavailable';
+    readonly sentCount: number | 'unavailable';
+    readonly ackCount: number | 'unavailable';
+    readonly inFlight: boolean | 'unavailable';
+    readonly retryPending: number | 'unavailable';
+    readonly circuitBreakerState: string | 'unavailable';
+    readonly dlqCount: number | 'unavailable';
+    readonly isLeader: boolean | 'unavailable';
+    readonly persistenceEnabled: boolean | 'unavailable';
+};
+type PixelDebugSnapshot = {
+    readonly sdkVersion: string;
+    readonly capturedAt: number;
+    readonly runtime: RuntimeDebugSnapshot;
+    readonly modules: readonly ModuleDebugSnapshot[];
+    readonly core: CoreDebugSnapshot;
+    readonly urlContext: UrlContextDebugSnapshot;
+    readonly attribution: AttributionDebugSnapshot;
+    readonly commerce: CommerceDebugSnapshot;
+    readonly behavior: BehaviorDebugSnapshot;
+    readonly conversion: ConversionDebugSnapshot;
+    readonly integrations: IntegrationsDebugSnapshot;
+    readonly transport: TransportDebugSnapshot;
+    readonly health: RuntimeHealthSnapshot;
+    readonly warnings: readonly DebugWarning[];
+    readonly errors: readonly DebugError[];
+    /** Config sanitizada (sem secrets). */
+    readonly config: Readonly<Record<string, unknown>>;
+};
+
+/** Contratos Engagement Runtime (Etapa 19) — readonly, serializáveis, sem DOM. */
+type EngagementLevel = 'low' | 'medium' | 'high';
+type EngagementSignalCounts = {
+    readonly HEARTBEAT: number;
+    readonly SCROLL: number;
+    readonly CLICK: number;
+    readonly RAGE_CLICK: number;
+    readonly IDLE: number;
+    readonly ACTIVITY: number;
+    readonly VISIBLE: number;
+    readonly HIDDEN: number;
+    readonly VIEWPORT_ENTER: number;
+    readonly VIEWPORT_EXIT: number;
+};
+/** Snapshot read-only para diagnostics (sanitizado, imutável, sem sinais completos). */
+type EngagementSnapshot = {
+    readonly enabled: boolean;
+    readonly initialized: boolean;
+    readonly running: boolean;
+    readonly score: number;
+    readonly previousScore: number;
+    readonly peakScore: number;
+    readonly averageScore: number;
+    readonly level: EngagementLevel;
+    readonly evaluationCount: number;
+    readonly emittedUpdateCount: number;
+    readonly emittedSummaryCount: number;
+    readonly lastEvaluatedAt: number | undefined;
+    readonly lastEmittedAt: number | undefined;
+    readonly evaluationIntervalMs: number;
+    readonly lastDriftMs: number | undefined;
+    readonly hasError: boolean;
+    readonly signalCounts: EngagementSignalCounts;
+};
+
+type HeartbeatSnapshot = {
+    readonly enabled: boolean;
+    readonly initialized: boolean;
+    readonly running: boolean;
+    readonly intervalMs: number;
+    readonly hiddenIntervalMs: number;
+    readonly sequence: number;
+    readonly emittedCount: number;
+    readonly skippedCount: number;
+    readonly lastEmittedAt: number | undefined;
+    readonly nextExpectedAt: number | undefined;
+    readonly lastDriftMs: number | undefined;
+};
+
+/** Sinais internos do módulo Behavior (não são eventos públicos). */
+type BehaviorSignalType = 'ACTIVITY' | 'IDLE' | 'VISIBLE' | 'HIDDEN' | 'SCROLL' | 'CLICK' | 'RAGE_CLICK' | 'EXIT_INTENT' | 'HEARTBEAT' | 'VIEWPORT_ENTER' | 'VIEWPORT_EXIT';
+type BehaviorSignalData = Readonly<Record<string, unknown>>;
+
+/** Contratos do Behavior Rate Limiter (Etapa 20) — readonly, serializáveis. */
+
+/** Snapshot read-only para diagnostics. */
+type RateLimitSnapshot = {
+    readonly enabled: boolean;
+    readonly windowMs: number;
+    readonly maxSignalsPerWindow: number;
+    readonly criticalBypass: boolean;
+    readonly accepted: number;
+    readonly dropped: number;
+    readonly bypassed: number;
+    /** Sinais na janela corrente. */
+    readonly windowCount: number;
+    readonly windowStartedAt: number | undefined;
+};
+
+/** Contratos do Behavior Buffer (Etapa 20) — agregação interna, não Transport. */
+
+type BufferDropStrategy = 'drop_oldest' | 'drop_newest' | 'compress_similar';
+type BufferFlushReason = 'size' | 'age' | 'hidden' | 'destroy' | 'manual';
+/** Snapshot read-only para diagnostics. */
+type BufferSnapshot = {
+    readonly enabled: boolean;
+    readonly size: number;
+    readonly maxSize: number;
+    readonly flushSize: number;
+    readonly maxAgeMs: number;
+    readonly dropStrategy: BufferDropStrategy;
+    readonly flushCount: number;
+    readonly dropCount: number;
+    readonly compressedCount: number;
+    readonly lastFlushAt: number | undefined;
+    readonly lastFlushReason: BufferFlushReason | undefined;
+};
+
+/** Contratos da Behavior State Machine (Etapa 20) — readonly, serializáveis. */
+type BehaviorState = 'NOT_INITIALIZED' | 'INITIALIZING' | 'ACTIVE' | 'IDLE' | 'HIDDEN' | 'PAUSED' | 'DESTROYING' | 'DESTROYED';
+/** Snapshot read-only para diagnostics. */
+type StateMachineSnapshot = {
+    readonly enabled: boolean;
+    readonly state: BehaviorState;
+    readonly previousState: BehaviorState | undefined;
+    readonly generation: number;
+    readonly changedAt: number | undefined;
+    readonly transitionCount: number;
+    readonly invalidTransitionCount: number;
+    readonly historySize: number;
+};
+
+/** Contratos do Behavior Session Summary (Etapa 20) — sem PII, sem DOM. */
+
+type SessionSummaryReason = 'hidden' | 'destroy';
+/** Snapshot read-only para diagnostics. */
+type SessionSummarySnapshot = {
+    readonly enabled: boolean;
+    readonly emitOnHidden: boolean;
+    readonly emitOnDestroy: boolean;
+    readonly minimumSessionMs: number;
+    readonly emittedCount: number;
+    readonly lastEmittedAt: number | undefined;
+    readonly startedAt: number | undefined;
+};
+
+type ViewportSnapshot = {
+    readonly enabled: boolean;
+    readonly initialized: boolean;
+    readonly available: boolean;
+    readonly targetCount: number;
+    readonly matchedElementCount: number;
+    readonly observedElementCount: number;
+    readonly activeElementCount: number;
+    readonly pendingElementCount: number;
+    readonly enterCount: number;
+    readonly exitCount: number;
+    readonly mutationObserverEnabled: boolean;
+    readonly maxObservedElements: number;
+    readonly limitReached: boolean;
+    readonly lastEventAt: number | undefined;
+};
+
+declare class BehaviorModule implements PixelModule {
+    readonly name: "behavior";
+    private trackers;
+    private heartbeatEngine;
+    private engagementEngine;
+    private viewportTracker;
+    private signalBus;
+    /**
+     * Coordenador de Runtime Intelligence (Etapa 20). Persiste entre init/destroy
+     * para manter a continuidade de geração da state machine no reinit.
+     */
+    private coordinator;
+    private coordinatorActive;
+    private active;
+    init(context: PixelRuntimeContext): void;
+    destroy(): void;
+    private destroyCoordinator;
+    getHeartbeatSnapshot(): HeartbeatSnapshot | null;
+    getViewportSnapshot(): ViewportSnapshot | null;
+    getEngagementSnapshot(): EngagementSnapshot | null;
+    getRateLimitSnapshot(): RateLimitSnapshot | null;
+    getBufferSnapshot(): BufferSnapshot | null;
+    getStateMachineSnapshot(): StateMachineSnapshot | null;
+    getSessionSummarySnapshot(): SessionSummarySnapshot | null;
+    /** @internal Avaliação manual para playground/testes. */
+    evaluateEngagementNow(): void;
+    /** @internal Flush manual do buffer (playground/testes). */
+    flushBufferNow(): void;
+    /** @internal Emissão manual de session summary (playground/testes). */
+    emitSessionSummaryNow(reason?: SessionSummaryReason): boolean;
+    /** @internal Publica um sinal interno no bus (playground/testes). */
+    debugPublishSignal(type: BehaviorSignalType, data?: BehaviorSignalData): void;
+}
+
+declare class Pixel {
+    private readonly runtime;
+    private readonly config;
+    private readonly conversionModule;
+    private readonly transportModule;
+    private readonly integrationsModule;
+    private readonly behaviorModule;
+    private readonly snapshotService;
+    private readonly diagnosticsModule;
+    constructor(config: PixelConfig);
+    init(): Promise<void>;
+    destroy(): Promise<void>;
+    isInitialized(): boolean;
+    /**
+     * Snapshot oficial read-only do Runtime (Etapa 16).
+     * Seguro antes/depois do init e após destroy. Retorno congelado e sanitizado.
+     */
+    getDebugSnapshot(): Readonly<PixelDebugSnapshot>;
+    /**
+     * Define ou substitui um managed param do UrlContext após o init
+     * (ex.: `oid` quando a Order é criada no checkout).
+     * No-op se UrlContext desabilitado ou o param não estiver na config.
+     */
+    setManagedUrlParam(param: string, value: string): boolean;
+    purchase(data?: PurchaseData): void;
+    lead(data: LeadData): void;
+    addToCart(data?: AddToCartData): void;
+    removeFromCart(data?: RemoveFromCartData): void;
+    initiateCheckout(data?: InitiateCheckoutData): void;
+    addPaymentInfo(data?: AddPaymentInfoData): void;
+    viewContent(data?: ViewContentData): void;
+    search(data: SearchData): void;
+    /** @internal For playground and development only. */
+    getDebugDedupeKeys(): readonly string[];
+    /** @internal For playground and development only. */
+    getDebugActiveDetectors(): readonly string[];
+    /** @internal For playground and development only. */
+    getDebugTransportState(): TransportDebugState | null;
+    /** @internal For playground — flush manual do transport. */
+    flushTransport(): void;
+    /** @internal For playground — simular offline. */
+    simulateTransportOffline(offline: boolean): void;
+    /** @internal For playground — forçar falhas no MockSender (retry). */
+    configureTransportMockSender(options: {
+        delayMs?: number;
+        failUntilAttempt?: number;
+        simulateTimeout?: boolean;
+    }): void;
+    /** @internal For playground — simular reload da página. */
+    simulateTransportReload(): Promise<void>;
+    /** @internal For playground — simular restart do transport. */
+    simulateTransportRestart(): Promise<void>;
+    /** @internal For playground — abrir circuit breaker. */
+    forceTransportCircuitOpen(): void;
+    /** @internal For playground — fechar circuit breaker. */
+    forceTransportCircuitClose(): void;
+    /** @internal For playground — replay manual da fila persistida. */
+    manualTransportReplay(): Promise<number>;
+    /** @internal For playground — replay dead letter. */
+    replayTransportDeadLetter(): PixelEvent[];
+    /** @internal For playground — limpar dead letter. */
+    clearTransportDeadLetter(): void;
+    /** @internal For playground — exportar fila. */
+    exportTransportQueue(): string;
+    /** @internal For playground — importar fila. */
+    importTransportQueue(raw: string): number;
+    /** @internal For playground — Integration Engine debug state. */
+    getDebugIntegrationState(): IntegrationDebugState | null;
+    /** @internal For playground — MemoryDestination records. */
+    getDebugIntegrationMemoryRecords(): readonly {
+        readonly at: number;
+        readonly type: string;
+        readonly payload: Readonly<Record<string, unknown>>;
+    }[];
+    /** @internal For playground — Attribution snapshot. */
+    getDebugAttributionSnapshot(): AttributionIdentifiers | null;
+    /** @internal For playground — recolher attribution. */
+    collectAttribution(): AttributionIdentifiers | null;
+    /** @internal For playground — limpar attribution. */
+    clearAttribution(): void;
+    /** @internal For playground and development only. Not part of the stable public API. */
+    getDebugServices(): PixelRuntimeServices | null;
+    /** @internal For playground — força avaliação de engagement. */
+    evaluateEngagement(): void;
+    /** @internal For playground — publica sinal interno de comportamento. */
+    debugPublishBehaviorSignal(type: Parameters<BehaviorModule['debugPublishSignal']>[0], data?: Parameters<BehaviorModule['debugPublishSignal']>[1]): void;
+    /** @internal For playground — flush manual do behavior buffer. */
+    flushBehaviorBuffer(): void;
+    /** @internal For playground — emite BEHAVIOR_SESSION_SUMMARY manualmente. */
+    emitBehaviorSessionSummary(reason?: Parameters<BehaviorModule['emitSessionSummaryNow']>[0]): boolean;
+}
+
+export { Pixel, PixelConfig, type PixelDebugSnapshot };