@aranova/tracking-react 0.24.1 → 0.25.0

package/dist/ingest-typed-C-SPiigr.d.ts

@@ -0,0 +1,1365 @@
+import * as src from 'src';
+import { z } from 'zod';
+import { F as FormSubmitConfig, j as FormSubmitMetadata } from './phone-utils-BVzSNBf1.js';
+
+/**
+ * Metadata for a manually fired `cta_click` event.
+ *
+ * Use this for non-phone calls to action such as directions, appointment
+ * buttons, downloads, or external booking links.
+ */
+declare const ctaClickMetadataSchema: z.ZodObject<{
+    cta_name: z.ZodString;
+    page: z.ZodObject<{
+        path: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        path: string;
+    }, {
+        path: string;
+    }>;
+    section: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    destination_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    href: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    element: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, "strict", z.ZodTypeAny, {
+    page: {
+        path: string;
+    };
+    cta_name: string;
+    section?: string | null | undefined;
+    href?: string | null | undefined;
+    destination_url?: string | null | undefined;
+    element?: string | null | undefined;
+}, {
+    page: {
+        path: string;
+    };
+    cta_name: string;
+    section?: string | null | undefined;
+    href?: string | null | undefined;
+    destination_url?: string | null | undefined;
+    element?: string | null | undefined;
+}>;
+type CtaClickMetadata = z.infer<typeof ctaClickMetadataSchema>;
+/**
+ * Registration config for `cta_click`.
+ *
+ * The event stays manually fireable; `autoCapture` additionally attaches a
+ * delegated click listener that fires it for any element matching `selector`
+ * (default `[data-aranova-cta]`) — tag your CTAs, get analytics for free.
+ */
+declare const ctaClickConfigSchema: z.ZodObject<{
+    autoCapture: z.ZodOptional<z.ZodObject<{
+        selector: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        selector?: string | undefined;
+    }, {
+        selector?: string | undefined;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    autoCapture?: {
+        selector?: string | undefined;
+    } | undefined;
+}, {
+    autoCapture?: {
+        selector?: string | undefined;
+    } | undefined;
+}>;
+type CtaClickConfig = z.infer<typeof ctaClickConfigSchema>;
+
+/**
+ * Registered trigger names reported by the SDK heartbeat.
+ */
+declare const sdkHeartbeatTriggersSchema: z.ZodObject<{
+    automatic: z.ZodArray<z.ZodString, "many">;
+    manual: z.ZodArray<z.ZodString, "many">;
+}, "strict", z.ZodTypeAny, {
+    automatic: string[];
+    manual: string[];
+}, {
+    automatic: string[];
+    manual: string[];
+}>;
+/**
+ * Metadata for the SDK-internal `sdk_heartbeat` event.
+ *
+ * The SDK fires this once per new session so the dashboard can show which SDK
+ * version, install surface, and trigger registry a client site is running.
+ * Consumers do not manually register or fire this event.
+ */
+declare const sdkHeartbeatMetadataSchema: z.ZodObject<{
+    sdk_version: z.ZodString;
+    package_name: z.ZodNullable<z.ZodString>;
+    surface: z.ZodEnum<["next", "react", "script"]>;
+    triggers: z.ZodObject<{
+        automatic: z.ZodArray<z.ZodString, "many">;
+        manual: z.ZodArray<z.ZodString, "many">;
+    }, "strict", z.ZodTypeAny, {
+        automatic: string[];
+        manual: string[];
+    }, {
+        automatic: string[];
+        manual: string[];
+    }>;
+    trigger_config: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>>;
+    configured_gtag_ids: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>>;
+}, "strict", z.ZodTypeAny, {
+    sdk_version: string;
+    package_name: string | null;
+    surface: "next" | "react" | "script";
+    triggers: {
+        automatic: string[];
+        manual: string[];
+    };
+    trigger_config?: Record<string, Record<string, unknown>> | null | undefined;
+    configured_gtag_ids?: Record<string, string> | null | undefined;
+}, {
+    sdk_version: string;
+    package_name: string | null;
+    surface: "next" | "react" | "script";
+    triggers: {
+        automatic: string[];
+        manual: string[];
+    };
+    trigger_config?: Record<string, Record<string, unknown>> | null | undefined;
+    configured_gtag_ids?: Record<string, string> | null | undefined;
+}>;
+type SdkHeartbeatMetadata = z.infer<typeof sdkHeartbeatMetadataSchema>;
+/**
+ * Internal registration config for `sdk_heartbeat`.
+ *
+ * This event has no consumer-facing options.
+ */
+declare const sdkHeartbeatConfigSchema: z.ZodObject<{}, "strict", z.ZodTypeAny, {}, {}>;
+type SdkHeartbeatConfig = z.infer<typeof sdkHeartbeatConfigSchema>;
+
+/**
+ * Metadata for the automatic `form_start` event.
+ *
+ * The SDK emits this once per form when the visitor first focuses a field.
+ */
+declare const formStartMetadataSchema: z.ZodObject<{
+    form: z.ZodObject<{
+        id: z.ZodString;
+        action: z.ZodNullable<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        id: string;
+        action: string | null;
+    }, {
+        id: string;
+        action: string | null;
+    }>;
+    page: z.ZodObject<{
+        path: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        path: string;
+    }, {
+        path: string;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    form: {
+        id: string;
+        action: string | null;
+    };
+    page: {
+        path: string;
+    };
+}, {
+    form: {
+        id: string;
+        action: string | null;
+    };
+    page: {
+        path: string;
+    };
+}>;
+type FormStartMetadata = z.infer<typeof formStartMetadataSchema>;
+/**
+ * Registration config for automatic `form_start`.
+ *
+ * Use `selector` to narrow which forms can trigger the event. When omitted,
+ * the SDK observes all `<form>` elements.
+ */
+declare const formStartConfigSchema: z.ZodObject<{
+    selector: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    selector?: string | undefined;
+}, {
+    selector?: string | undefined;
+}>;
+type FormStartConfig = z.infer<typeof formStartConfigSchema>;
+
+/**
+ * Metadata for the automatic `multi_page_session` event.
+ *
+ * Fired when the visitor reaches the configured distinct-page threshold in a
+ * single tracking session.
+ */
+declare const multiPageSessionMetadataSchema: z.ZodObject<{
+    page_count: z.ZodNumber;
+    page: z.ZodObject<{
+        path: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        path: string;
+    }, {
+        path: string;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    page: {
+        path: string;
+    };
+    page_count: number;
+}, {
+    page: {
+        path: string;
+    };
+    page_count: number;
+}>;
+type MultiPageSessionMetadata = z.infer<typeof multiPageSessionMetadataSchema>;
+/**
+ * Registration config for automatic `multi_page_session`.
+ */
+declare const multiPageSessionConfigSchema: z.ZodObject<{
+    pageThreshold: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    pageThreshold: number;
+}, {
+    pageThreshold: number;
+}>;
+type MultiPageSessionConfig = z.infer<typeof multiPageSessionConfigSchema>;
+
+/**
+ * Metadata for the automatic `page_exit` event.
+ *
+ * Fired when the user leaves a page (SPA navigation away, tab hidden, or
+ * pagehide). `dwell_ms` is the ACTIVE (visible) time spent on the page segment
+ * being closed — hidden time never counts, matching `time_on_site` semantics.
+ * A page revisited after being hidden emits another `page_exit` for the next
+ * visible segment, so summing `dwell_ms` per page/session yields total active
+ * dwell without double counting.
+ */
+declare const pageExitMetadataSchema: z.ZodObject<{
+    dwell_ms: z.ZodNumber;
+    max_scroll_percent: z.ZodNullable<z.ZodNumber>;
+    scroll_baseline_percent: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    page: z.ZodObject<{
+        path: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        path: string;
+    }, {
+        path: string;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    page: {
+        path: string;
+    };
+    dwell_ms: number;
+    max_scroll_percent: number | null;
+    scroll_baseline_percent?: number | null | undefined;
+}, {
+    page: {
+        path: string;
+    };
+    dwell_ms: number;
+    max_scroll_percent: number | null;
+    scroll_baseline_percent?: number | null | undefined;
+}>;
+type PageExitMetadata = z.infer<typeof pageExitMetadataSchema>;
+/**
+ * Registration config for automatic `page_exit`.
+ *
+ * SDK-internal: attached unconditionally (like `sdk_heartbeat`), so there are
+ * no registration options.
+ */
+declare const pageExitConfigSchema: z.ZodObject<{}, "strict", z.ZodTypeAny, {}, {}>;
+type PageExitConfig = z.infer<typeof pageExitConfigSchema>;
+
+/**
+ * Metadata for the automatic `page_view` event.
+ *
+ * The SDK emits this on initial load, SPA route changes, and bfcache restores.
+ * Consumers do not call `trackEvent('page_view', ...)`; registering
+ * `automatic: { page_view: {} }` enables the SDK-owned trigger.
+ */
+declare const pageViewMetadataSchema: z.ZodObject<{
+    page: z.ZodObject<{
+        title: z.ZodNullable<z.ZodString>;
+        path: z.ZodString;
+        search: z.ZodString;
+        hash: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        path: string;
+        search: string;
+        title: string | null;
+        hash: string;
+    }, {
+        path: string;
+        search: string;
+        title: string | null;
+        hash: string;
+    }>;
+    referrer: z.ZodNullable<z.ZodString>;
+    viewport: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        w: z.ZodNumber;
+        h: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        w: number;
+        h: number;
+    }, {
+        w: number;
+        h: number;
+    }>>>;
+}, "strict", z.ZodTypeAny, {
+    page: {
+        path: string;
+        search: string;
+        title: string | null;
+        hash: string;
+    };
+    referrer: string | null;
+    viewport?: {
+        w: number;
+        h: number;
+    } | null | undefined;
+}, {
+    page: {
+        path: string;
+        search: string;
+        title: string | null;
+        hash: string;
+    };
+    referrer: string | null;
+    viewport?: {
+        w: number;
+        h: number;
+    } | null | undefined;
+}>;
+type PageViewMetadata = z.infer<typeof pageViewMetadataSchema>;
+/**
+ * Registration config for automatic `page_view`.
+ *
+ * `page_view` is required in every trigger registry and currently has no
+ * options. Use `{ page_view: {} }`.
+ */
+declare const pageViewConfigSchema: z.ZodObject<{}, "strict", z.ZodTypeAny, {}, {}>;
+type PageViewConfig = z.infer<typeof pageViewConfigSchema>;
+
+/**
+ * Metadata for a manually fired `phone_click` event.
+ *
+ * `phone_number` should be the business phone number from the clicked `tel:`
+ * link, not a visitor-entered phone number. `section` can distinguish header,
+ * footer, hero, or contact-page links.
+ */
+declare const phoneClickMetadataSchema: z.ZodObject<{
+    phone_number: z.ZodString;
+    page: z.ZodObject<{
+        path: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        path: string;
+    }, {
+        path: string;
+    }>;
+    section: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, "strict", z.ZodTypeAny, {
+    page: {
+        path: string;
+    };
+    phone_number: string;
+    section?: string | null | undefined;
+}, {
+    page: {
+        path: string;
+    };
+    phone_number: string;
+    section?: string | null | undefined;
+}>;
+type PhoneClickMetadata = z.infer<typeof phoneClickMetadataSchema>;
+/**
+ * Registration config for `phone_click`.
+ *
+ * The event stays manually fireable; `autoCapture` additionally attaches a
+ * delegated click listener that fires it for any `tel:` link matching
+ * `selector` (default `a[href^="tel:"]`) — link your phone number, get the
+ * analytics event (and, for a linked phone-click goal, the conversion) for free.
+ */
+declare const phoneClickConfigSchema: z.ZodObject<{
+    autoCapture: z.ZodOptional<z.ZodObject<{
+        selector: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        selector?: string | undefined;
+    }, {
+        selector?: string | undefined;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    autoCapture?: {
+        selector?: string | undefined;
+    } | undefined;
+}, {
+    autoCapture?: {
+        selector?: string | undefined;
+    } | undefined;
+}>;
+type PhoneClickConfig = z.infer<typeof phoneClickConfigSchema>;
+
+/**
+ * Metadata for the automatic `scroll_depth` event.
+ *
+ * Fired once per configured threshold per page.
+ */
+declare const scrollDepthMetadataSchema: z.ZodObject<{
+    depth_percent: z.ZodNumber;
+    page: z.ZodObject<{
+        path: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        path: string;
+    }, {
+        path: string;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    page: {
+        path: string;
+    };
+    depth_percent: number;
+}, {
+    page: {
+        path: string;
+    };
+    depth_percent: number;
+}>;
+type ScrollDepthMetadata = z.infer<typeof scrollDepthMetadataSchema>;
+/**
+ * Registration config for automatic `scroll_depth`.
+ *
+ * `thresholds` are integer percentages from 1 to 100.
+ */
+declare const scrollDepthConfigSchema: z.ZodObject<{
+    thresholds: z.ZodArray<z.ZodNumber, "many">;
+}, "strict", z.ZodTypeAny, {
+    thresholds: number[];
+}, {
+    thresholds: number[];
+}>;
+type ScrollDepthConfig = z.infer<typeof scrollDepthConfigSchema>;
+
+declare const PAGE_IDENTITY_MAX_LENGTH = 64;
+declare const PAGE_IDENTITY_PATTERN: RegExp;
+/** Common page identities offered as presets by operator tooling. */
+declare const SPECIFIC_PAGE_NAMES: readonly ["contact_page", "about_page", "services_page", "booking_page", "location_page", "pricing_page", "faq_page", "testimonials_page"];
+declare const pageIdentitySchema: z.ZodString;
+type PageIdentity = z.infer<typeof pageIdentitySchema>;
+/** @deprecated Use PageIdentity. Kept as a compatibility alias for existing consumers. */
+type SpecificPageName = PageIdentity;
+/** @deprecated Use pageIdentitySchema. Kept for source compatibility. */
+declare const specificPageNameSchema: z.ZodString;
+/**
+ * Metadata for the automatic `specific_page_visit` event.
+ *
+ * The SDK emits this when the current pathname matches one of the configured
+ * named page patterns.
+ */
+declare const specificPageVisitMetadataSchema: z.ZodObject<{
+    page_name: z.ZodString;
+    page: z.ZodObject<{
+        path: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        path: string;
+    }, {
+        path: string;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    page: {
+        path: string;
+    };
+    page_name: string;
+}, {
+    page: {
+        path: string;
+    };
+    page_name: string;
+}>;
+type SpecificPageVisitMetadata = z.infer<typeof specificPageVisitMetadataSchema>;
+/**
+ * Registration config for automatic `specific_page_visit`.
+ *
+ * Each page entry pairs a stable, validated identity with a `RegExp` that
+ * matches the pathname. The identity can use a preset above or a client-specific
+ * lowercase snake-case slug.
+ */
+declare const specificPageVisitConfigSchema: z.ZodObject<{
+    pages: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        pathPattern: z.ZodType<RegExp, z.ZodTypeDef, RegExp>;
+    }, "strict", z.ZodTypeAny, {
+        name: string;
+        pathPattern: RegExp;
+    }, {
+        name: string;
+        pathPattern: RegExp;
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    pages: {
+        name: string;
+        pathPattern: RegExp;
+    }[];
+}, {
+    pages: {
+        name: string;
+        pathPattern: RegExp;
+    }[];
+}>;
+type SpecificPageVisitConfig = z.infer<typeof specificPageVisitConfigSchema>;
+
+/**
+ * Metadata for the automatic `time_on_site` event.
+ *
+ * The SDK starts a visibility-aware timer and fires once when visible
+ * engagement crosses the configured threshold.
+ */
+declare const timeOnSiteMetadataSchema: z.ZodObject<{
+    duration_ms: z.ZodNumber;
+    page: z.ZodObject<{
+        path: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        path: string;
+    }, {
+        path: string;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    page: {
+        path: string;
+    };
+    duration_ms: number;
+}, {
+    page: {
+        path: string;
+    };
+    duration_ms: number;
+}>;
+type TimeOnSiteMetadata = z.infer<typeof timeOnSiteMetadataSchema>;
+/**
+ * Registration config for automatic `time_on_site`.
+ */
+declare const timeOnSiteConfigSchema: z.ZodObject<{
+    thresholdSeconds: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    thresholdSeconds: number;
+}, {
+    thresholdSeconds: number;
+}>;
+type TimeOnSiteConfig = z.infer<typeof timeOnSiteConfigSchema>;
+
+type EventOutcomeRole = "lead" | "engagement" | "navigation" | "diagnostic";
+type EventCategory = "page" | "engagement" | "lead" | "commerce" | "system";
+type EventClientVisibility = "simple" | "detailed" | "hidden";
+interface EventSemantics {
+    label: string;
+    category: EventCategory;
+    outcomeRole: EventOutcomeRole;
+    clientVisibility: EventClientVisibility;
+}
+/**
+ * Lightweight runtime event metadata. This module intentionally imports no
+ * Zod schemas so dashboards and framework adapters can consume it without
+ * pulling the validation registry into their bundles.
+ */
+declare const EVENT_SEMANTICS: {
+    readonly page_view: {
+        readonly label: "Page view";
+        readonly category: "page";
+        readonly outcomeRole: "navigation";
+        readonly clientVisibility: "simple";
+    };
+    readonly time_on_site: {
+        readonly label: "Time on site";
+        readonly category: "engagement";
+        readonly outcomeRole: "engagement";
+        readonly clientVisibility: "detailed";
+    };
+    readonly specific_page_visit: {
+        readonly label: "Key page visit";
+        readonly category: "engagement";
+        readonly outcomeRole: "engagement";
+        readonly clientVisibility: "detailed";
+    };
+    readonly scroll_depth: {
+        readonly label: "Scroll depth";
+        readonly category: "engagement";
+        readonly outcomeRole: "engagement";
+        readonly clientVisibility: "detailed";
+    };
+    readonly multi_page_session: {
+        readonly label: "Multi-page session";
+        readonly category: "engagement";
+        readonly outcomeRole: "engagement";
+        readonly clientVisibility: "detailed";
+    };
+    readonly form_start: {
+        readonly label: "Form started";
+        readonly category: "engagement";
+        readonly outcomeRole: "engagement";
+        readonly clientVisibility: "simple";
+    };
+    readonly sdk_heartbeat: {
+        readonly label: "SDK heartbeat";
+        readonly category: "system";
+        readonly outcomeRole: "diagnostic";
+        readonly clientVisibility: "hidden";
+    };
+    readonly page_exit: {
+        readonly label: "Page exit";
+        readonly category: "engagement";
+        readonly outcomeRole: "diagnostic";
+        readonly clientVisibility: "detailed";
+    };
+    readonly form_submit: {
+        readonly label: "Form submitted";
+        readonly category: "lead";
+        readonly outcomeRole: "lead";
+        readonly clientVisibility: "simple";
+    };
+    readonly phone_click: {
+        readonly label: "Phone click";
+        readonly category: "lead";
+        readonly outcomeRole: "lead";
+        readonly clientVisibility: "simple";
+    };
+    readonly cta_click: {
+        readonly label: "CTA click";
+        readonly category: "engagement";
+        readonly outcomeRole: "engagement";
+        readonly clientVisibility: "simple";
+    };
+};
+type EventName = keyof typeof EVENT_SEMANTICS;
+declare function getEventSemantics(eventName: string): EventSemantics | null;
+
+type EventKind = "automatic" | "manual";
+declare const EVENT_REGISTRY: {
+    readonly page_view: {
+        readonly kind: "automatic";
+        readonly semantics: {
+            readonly label: "Page view";
+            readonly category: "page";
+            readonly outcomeRole: "navigation";
+            readonly clientVisibility: "simple";
+        };
+        readonly metadataSchema: z.ZodObject<{
+            page: z.ZodObject<{
+                title: z.ZodNullable<z.ZodString>;
+                path: z.ZodString;
+                search: z.ZodString;
+                hash: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                path: string;
+                search: string;
+                title: string | null;
+                hash: string;
+            }, {
+                path: string;
+                search: string;
+                title: string | null;
+                hash: string;
+            }>;
+            referrer: z.ZodNullable<z.ZodString>;
+            viewport: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                w: z.ZodNumber;
+                h: z.ZodNumber;
+            }, "strict", z.ZodTypeAny, {
+                w: number;
+                h: number;
+            }, {
+                w: number;
+                h: number;
+            }>>>;
+        }, "strict", z.ZodTypeAny, {
+            page: {
+                path: string;
+                search: string;
+                title: string | null;
+                hash: string;
+            };
+            referrer: string | null;
+            viewport?: {
+                w: number;
+                h: number;
+            } | null | undefined;
+        }, {
+            page: {
+                path: string;
+                search: string;
+                title: string | null;
+                hash: string;
+            };
+            referrer: string | null;
+            viewport?: {
+                w: number;
+                h: number;
+            } | null | undefined;
+        }>;
+        readonly configSchema: z.ZodObject<{}, "strict", z.ZodTypeAny, {}, {}>;
+    };
+    readonly time_on_site: {
+        readonly kind: "automatic";
+        readonly semantics: {
+            readonly label: "Time on site";
+            readonly category: "engagement";
+            readonly outcomeRole: "engagement";
+            readonly clientVisibility: "detailed";
+        };
+        readonly metadataSchema: z.ZodObject<{
+            duration_ms: z.ZodNumber;
+            page: z.ZodObject<{
+                path: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                path: string;
+            }, {
+                path: string;
+            }>;
+        }, "strict", z.ZodTypeAny, {
+            page: {
+                path: string;
+            };
+            duration_ms: number;
+        }, {
+            page: {
+                path: string;
+            };
+            duration_ms: number;
+        }>;
+        readonly configSchema: z.ZodObject<{
+            thresholdSeconds: z.ZodNumber;
+        }, "strict", z.ZodTypeAny, {
+            thresholdSeconds: number;
+        }, {
+            thresholdSeconds: number;
+        }>;
+    };
+    readonly specific_page_visit: {
+        readonly kind: "automatic";
+        readonly semantics: {
+            readonly label: "Key page visit";
+            readonly category: "engagement";
+            readonly outcomeRole: "engagement";
+            readonly clientVisibility: "detailed";
+        };
+        readonly metadataSchema: z.ZodObject<{
+            page_name: z.ZodString;
+            page: z.ZodObject<{
+                path: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                path: string;
+            }, {
+                path: string;
+            }>;
+        }, "strict", z.ZodTypeAny, {
+            page: {
+                path: string;
+            };
+            page_name: string;
+        }, {
+            page: {
+                path: string;
+            };
+            page_name: string;
+        }>;
+        readonly configSchema: z.ZodObject<{
+            pages: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                pathPattern: z.ZodType<RegExp, z.ZodTypeDef, RegExp>;
+            }, "strict", z.ZodTypeAny, {
+                name: string;
+                pathPattern: RegExp;
+            }, {
+                name: string;
+                pathPattern: RegExp;
+            }>, "many">;
+        }, "strict", z.ZodTypeAny, {
+            pages: {
+                name: string;
+                pathPattern: RegExp;
+            }[];
+        }, {
+            pages: {
+                name: string;
+                pathPattern: RegExp;
+            }[];
+        }>;
+    };
+    readonly scroll_depth: {
+        readonly kind: "automatic";
+        readonly semantics: {
+            readonly label: "Scroll depth";
+            readonly category: "engagement";
+            readonly outcomeRole: "engagement";
+            readonly clientVisibility: "detailed";
+        };
+        readonly metadataSchema: z.ZodObject<{
+            depth_percent: z.ZodNumber;
+            page: z.ZodObject<{
+                path: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                path: string;
+            }, {
+                path: string;
+            }>;
+        }, "strict", z.ZodTypeAny, {
+            page: {
+                path: string;
+            };
+            depth_percent: number;
+        }, {
+            page: {
+                path: string;
+            };
+            depth_percent: number;
+        }>;
+        readonly configSchema: z.ZodObject<{
+            thresholds: z.ZodArray<z.ZodNumber, "many">;
+        }, "strict", z.ZodTypeAny, {
+            thresholds: number[];
+        }, {
+            thresholds: number[];
+        }>;
+    };
+    readonly multi_page_session: {
+        readonly kind: "automatic";
+        readonly semantics: {
+            readonly label: "Multi-page session";
+            readonly category: "engagement";
+            readonly outcomeRole: "engagement";
+            readonly clientVisibility: "detailed";
+        };
+        readonly metadataSchema: z.ZodObject<{
+            page_count: z.ZodNumber;
+            page: z.ZodObject<{
+                path: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                path: string;
+            }, {
+                path: string;
+            }>;
+        }, "strict", z.ZodTypeAny, {
+            page: {
+                path: string;
+            };
+            page_count: number;
+        }, {
+            page: {
+                path: string;
+            };
+            page_count: number;
+        }>;
+        readonly configSchema: z.ZodObject<{
+            pageThreshold: z.ZodNumber;
+        }, "strict", z.ZodTypeAny, {
+            pageThreshold: number;
+        }, {
+            pageThreshold: number;
+        }>;
+    };
+    readonly form_start: {
+        readonly kind: "automatic";
+        readonly semantics: {
+            readonly label: "Form started";
+            readonly category: "engagement";
+            readonly outcomeRole: "engagement";
+            readonly clientVisibility: "simple";
+        };
+        readonly metadataSchema: z.ZodObject<{
+            form: z.ZodObject<{
+                id: z.ZodString;
+                action: z.ZodNullable<z.ZodString>;
+            }, "strict", z.ZodTypeAny, {
+                id: string;
+                action: string | null;
+            }, {
+                id: string;
+                action: string | null;
+            }>;
+            page: z.ZodObject<{
+                path: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                path: string;
+            }, {
+                path: string;
+            }>;
+        }, "strict", z.ZodTypeAny, {
+            form: {
+                id: string;
+                action: string | null;
+            };
+            page: {
+                path: string;
+            };
+        }, {
+            form: {
+                id: string;
+                action: string | null;
+            };
+            page: {
+                path: string;
+            };
+        }>;
+        readonly configSchema: z.ZodObject<{
+            selector: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            selector?: string | undefined;
+        }, {
+            selector?: string | undefined;
+        }>;
+    };
+    readonly sdk_heartbeat: {
+        readonly kind: "automatic";
+        readonly semantics: {
+            readonly label: "SDK heartbeat";
+            readonly category: "system";
+            readonly outcomeRole: "diagnostic";
+            readonly clientVisibility: "hidden";
+        };
+        readonly metadataSchema: z.ZodObject<{
+            sdk_version: z.ZodString;
+            package_name: z.ZodNullable<z.ZodString>;
+            surface: z.ZodEnum<["next", "react", "script"]>;
+            triggers: z.ZodObject<{
+                automatic: z.ZodArray<z.ZodString, "many">;
+                manual: z.ZodArray<z.ZodString, "many">;
+            }, "strict", z.ZodTypeAny, {
+                automatic: string[];
+                manual: string[];
+            }, {
+                automatic: string[];
+                manual: string[];
+            }>;
+            trigger_config: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>>;
+            configured_gtag_ids: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>>;
+        }, "strict", z.ZodTypeAny, {
+            sdk_version: string;
+            package_name: string | null;
+            surface: "next" | "react" | "script";
+            triggers: {
+                automatic: string[];
+                manual: string[];
+            };
+            trigger_config?: Record<string, Record<string, unknown>> | null | undefined;
+            configured_gtag_ids?: Record<string, string> | null | undefined;
+        }, {
+            sdk_version: string;
+            package_name: string | null;
+            surface: "next" | "react" | "script";
+            triggers: {
+                automatic: string[];
+                manual: string[];
+            };
+            trigger_config?: Record<string, Record<string, unknown>> | null | undefined;
+            configured_gtag_ids?: Record<string, string> | null | undefined;
+        }>;
+        readonly configSchema: z.ZodObject<{}, "strict", z.ZodTypeAny, {}, {}>;
+    };
+    readonly page_exit: {
+        readonly kind: "automatic";
+        readonly semantics: {
+            readonly label: "Page exit";
+            readonly category: "engagement";
+            readonly outcomeRole: "diagnostic";
+            readonly clientVisibility: "detailed";
+        };
+        readonly metadataSchema: z.ZodObject<{
+            dwell_ms: z.ZodNumber;
+            max_scroll_percent: z.ZodNullable<z.ZodNumber>;
+            scroll_baseline_percent: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            page: z.ZodObject<{
+                path: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                path: string;
+            }, {
+                path: string;
+            }>;
+        }, "strict", z.ZodTypeAny, {
+            page: {
+                path: string;
+            };
+            dwell_ms: number;
+            max_scroll_percent: number | null;
+            scroll_baseline_percent?: number | null | undefined;
+        }, {
+            page: {
+                path: string;
+            };
+            dwell_ms: number;
+            max_scroll_percent: number | null;
+            scroll_baseline_percent?: number | null | undefined;
+        }>;
+        readonly configSchema: z.ZodObject<{}, "strict", z.ZodTypeAny, {}, {}>;
+    };
+    readonly form_submit: {
+        readonly kind: "manual";
+        readonly semantics: {
+            readonly label: "Form submitted";
+            readonly category: "lead";
+            readonly outcomeRole: "lead";
+            readonly clientVisibility: "simple";
+        };
+        readonly metadataSchema: z.ZodObject<{
+            form: z.ZodObject<{
+                id: z.ZodString;
+                action: z.ZodNullable<z.ZodString>;
+                fields: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    type: z.ZodString;
+                    label: z.ZodNullable<z.ZodString>;
+                    value: z.ZodType<src.JsonValue, z.ZodTypeDef, src.JsonValue>;
+                }, "strict", z.ZodTypeAny, {
+                    value: src.JsonValue;
+                    type: string;
+                    name: string;
+                    label: string | null;
+                }, {
+                    value: src.JsonValue;
+                    type: string;
+                    name: string;
+                    label: string | null;
+                }>, "many">>;
+            }, "strict", z.ZodTypeAny, {
+                id: string;
+                action: string | null;
+                fields?: {
+                    value: src.JsonValue;
+                    type: string;
+                    name: string;
+                    label: string | null;
+                }[] | undefined;
+            }, {
+                id: string;
+                action: string | null;
+                fields?: {
+                    value: src.JsonValue;
+                    type: string;
+                    name: string;
+                    label: string | null;
+                }[] | undefined;
+            }>;
+            page: z.ZodObject<{
+                path: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                path: string;
+            }, {
+                path: string;
+            }>;
+        }, "strict", z.ZodTypeAny, {
+            form: {
+                id: string;
+                action: string | null;
+                fields?: {
+                    value: src.JsonValue;
+                    type: string;
+                    name: string;
+                    label: string | null;
+                }[] | undefined;
+            };
+            page: {
+                path: string;
+            };
+        }, {
+            form: {
+                id: string;
+                action: string | null;
+                fields?: {
+                    value: src.JsonValue;
+                    type: string;
+                    name: string;
+                    label: string | null;
+                }[] | undefined;
+            };
+            page: {
+                path: string;
+            };
+        }>;
+        readonly configSchema: z.ZodObject<{}, "strict", z.ZodTypeAny, {}, {}>;
+    };
+    readonly phone_click: {
+        readonly kind: "manual";
+        readonly semantics: {
+            readonly label: "Phone click";
+            readonly category: "lead";
+            readonly outcomeRole: "lead";
+            readonly clientVisibility: "simple";
+        };
+        readonly metadataSchema: z.ZodObject<{
+            phone_number: z.ZodString;
+            page: z.ZodObject<{
+                path: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                path: string;
+            }, {
+                path: string;
+            }>;
+            section: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, "strict", z.ZodTypeAny, {
+            page: {
+                path: string;
+            };
+            phone_number: string;
+            section?: string | null | undefined;
+        }, {
+            page: {
+                path: string;
+            };
+            phone_number: string;
+            section?: string | null | undefined;
+        }>;
+        readonly configSchema: z.ZodObject<{
+            autoCapture: z.ZodOptional<z.ZodObject<{
+                selector: z.ZodOptional<z.ZodString>;
+            }, "strict", z.ZodTypeAny, {
+                selector?: string | undefined;
+            }, {
+                selector?: string | undefined;
+            }>>;
+        }, "strict", z.ZodTypeAny, {
+            autoCapture?: {
+                selector?: string | undefined;
+            } | undefined;
+        }, {
+            autoCapture?: {
+                selector?: string | undefined;
+            } | undefined;
+        }>;
+    };
+    readonly cta_click: {
+        readonly kind: "manual";
+        readonly semantics: {
+            readonly label: "CTA click";
+            readonly category: "engagement";
+            readonly outcomeRole: "engagement";
+            readonly clientVisibility: "simple";
+        };
+        readonly metadataSchema: z.ZodObject<{
+            cta_name: z.ZodString;
+            page: z.ZodObject<{
+                path: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                path: string;
+            }, {
+                path: string;
+            }>;
+            section: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            destination_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            href: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            element: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, "strict", z.ZodTypeAny, {
+            page: {
+                path: string;
+            };
+            cta_name: string;
+            section?: string | null | undefined;
+            href?: string | null | undefined;
+            destination_url?: string | null | undefined;
+            element?: string | null | undefined;
+        }, {
+            page: {
+                path: string;
+            };
+            cta_name: string;
+            section?: string | null | undefined;
+            href?: string | null | undefined;
+            destination_url?: string | null | undefined;
+            element?: string | null | undefined;
+        }>;
+        readonly configSchema: z.ZodObject<{
+            autoCapture: z.ZodOptional<z.ZodObject<{
+                selector: z.ZodOptional<z.ZodString>;
+            }, "strict", z.ZodTypeAny, {
+                selector?: string | undefined;
+            }, {
+                selector?: string | undefined;
+            }>>;
+        }, "strict", z.ZodTypeAny, {
+            autoCapture?: {
+                selector?: string | undefined;
+            } | undefined;
+        }, {
+            autoCapture?: {
+                selector?: string | undefined;
+            } | undefined;
+        }>;
+    };
+};
+/**
+ * Event names that are fired by the SDK when their configured signal occurs.
+ *
+ * Automatic events are not accepted by the typed `trackEvent()` API.
+ */
+type AutomaticEventName = {
+    [K in EventName]: (typeof EVENT_REGISTRY)[K]["kind"] extends "automatic" ? K : never;
+}[EventName];
+/**
+ * Event names that consumer code can fire manually after registering them.
+ */
+type ManualEventName = {
+    [K in EventName]: (typeof EVENT_REGISTRY)[K]["kind"] extends "manual" ? K : never;
+}[EventName];
+type MetadataByName = {
+    page_view: PageViewMetadata;
+    time_on_site: TimeOnSiteMetadata;
+    specific_page_visit: SpecificPageVisitMetadata;
+    scroll_depth: ScrollDepthMetadata;
+    multi_page_session: MultiPageSessionMetadata;
+    form_start: FormStartMetadata;
+    sdk_heartbeat: SdkHeartbeatMetadata;
+    page_exit: PageExitMetadata;
+    form_submit: FormSubmitMetadata;
+    phone_click: PhoneClickMetadata;
+    cta_click: CtaClickMetadata;
+};
+type ConfigByName = {
+    page_view: PageViewConfig;
+    time_on_site: TimeOnSiteConfig;
+    specific_page_visit: SpecificPageVisitConfig;
+    scroll_depth: ScrollDepthConfig;
+    multi_page_session: MultiPageSessionConfig;
+    form_start: FormStartConfig;
+    sdk_heartbeat: SdkHeartbeatConfig;
+    page_exit: PageExitConfig;
+    form_submit: FormSubmitConfig;
+    phone_click: PhoneClickConfig;
+    cta_click: CtaClickConfig;
+};
+/**
+ * Metadata payload type for a specific tracking event.
+ *
+ * @example
+ * ```ts
+ * type SubmitMetadata = EventMetadata<'form_submit'>;
+ * ```
+ */
+type EventMetadata<K extends EventName> = MetadataByName[K];
+/**
+ * Trigger registration config type for a specific tracking event.
+ */
+type EventConfig<K extends EventName> = ConfigByName[K];
+/**
+ * Runtime list of automatic event names.
+ */
+declare const ALL_AUTOMATIC_EVENT_NAMES: readonly AutomaticEventName[];
+/**
+ * Runtime list of manual event names.
+ */
+declare const ALL_MANUAL_EVENT_NAMES: readonly ManualEventName[];
+/**
+ * Events that represent a lead/outcome in first-party tracking projections.
+ */
+declare const ALL_LEAD_EVENT_NAMES: readonly EventName[];
+/**
+ * Trigger registry passed to `createTracking({ triggers })`.
+ *
+ * `automatic.page_view` is required because every install should capture page
+ * views. Other automatic events are opt-in. Manual events must be registered
+ * here before the typed client accepts `trackEvent()` calls for them.
+ *
+ * @example
+ * ```ts
+ * createTracking({
+ *   apiKey,
+ *   endpoint,
+ *   triggers: {
+ *     automatic: {
+ *       page_view: {},
+ *       time_on_site: { thresholdSeconds: 60 },
+ *     },
+ *     manual: {
+ *       form_submit: {},
+ *       phone_click: {},
+ *     },
+ *   },
+ * });
+ * ```
+ */
+type TriggerRegistryConfig = {
+    automatic: {
+        page_view: EventConfig<"page_view">;
+    } & Partial<{
+        time_on_site: EventConfig<"time_on_site">;
+        specific_page_visit: EventConfig<"specific_page_visit">;
+        scroll_depth: EventConfig<"scroll_depth">;
+        multi_page_session: EventConfig<"multi_page_session">;
+        form_start: EventConfig<"form_start">;
+    }>;
+    manual?: Partial<{
+        form_submit: EventConfig<"form_submit">;
+        phone_click: EventConfig<"phone_click">;
+        cta_click: EventConfig<"cta_click">;
+    }>;
+};
+/**
+ * Manual event names registered in a concrete trigger registry.
+ *
+ * Used by `TypedTrackingClient` so `trackEvent()` only accepts events the
+ * consumer explicitly enabled.
+ */
+type RegisteredManualEvents<TRegistry extends TriggerRegistryConfig> = Extract<keyof NonNullable<TRegistry["manual"]>, ManualEventName>;
+/**
+ * Automatic event names registered in a concrete trigger registry.
+ */
+type RegisteredAutomaticEvents<TRegistry extends TriggerRegistryConfig> = Extract<keyof TRegistry["automatic"], AutomaticEventName>;
+/**
+ * Discriminated union of valid manual tracking calls for a registry.
+ */
+type TrackableEvent<TRegistry extends TriggerRegistryConfig> = {
+    [K in RegisteredManualEvents<TRegistry>]: {
+        eventType: K;
+        metadata: EventMetadata<K>;
+    };
+}[RegisteredManualEvents<TRegistry>];
+declare function getEventDefinition(name: EventName): {
+    kind: EventKind;
+    semantics: EventSemantics;
+    metadataSchema: z.ZodTypeAny;
+    configSchema: z.ZodTypeAny;
+};
+
+interface TypedTrackEventOptions {
+    /**
+     * Override the page URL associated with this event.
+     *
+     * Omit this for normal browser usage; the SDK captures `window.location.href`.
+     */
+    pageUrl?: string | null;
+    /**
+     * Override the event timestamp.
+     *
+     * Defaults to the time the event is queued. Accepts a `Date` or ISO string.
+     */
+    occurredAt?: Date | string | null;
+}
+/**
+ * Typed tracking client returned by `useTracking()`.
+ *
+ * The accepted event names and metadata shapes are narrowed from the concrete
+ * trigger registry supplied to `createTracking()`.
+ */
+interface TypedTrackingClient<TRegistry extends TriggerRegistryConfig> {
+    /**
+     * Fire a manually-registered event. The event name must be present in
+     * the registry's `manual` map and the metadata must match that event's
+     * canonical Zod-derived shape.
+     */
+    trackEvent<K extends RegisteredManualEvents<TRegistry>>(eventType: K, metadata: EventMetadata<K>, options?: TypedTrackEventOptions): void;
+    /**
+     * Immediately flush queued events to the ingest endpoint.
+     *
+     * Normal consumers rarely need this because the SDK flushes on a debounce,
+     * when the queue reaches the batch threshold, and on `pagehide`.
+     */
+    flush(): Promise<void>;
+    /**
+     * Return the current rolling session id.
+     */
+    getSessionId(): string;
+    /**
+     * Return the persistent visitor id for this browser profile.
+     */
+    getVisitorId(): string;
+}
+
+export { multiPageSessionMetadataSchema as $, ALL_AUTOMATIC_EVENT_NAMES as A, type ScrollDepthMetadata as B, type CtaClickConfig as C, type SdkHeartbeatConfig as D, EVENT_REGISTRY as E, type FormStartConfig as F, type SdkHeartbeatMetadata as G, type SpecificPageName as H, type SpecificPageVisitConfig as I, type SpecificPageVisitMetadata as J, type TimeOnSiteMetadata as K, type TrackableEvent as L, type ManualEventName as M, type TriggerRegistryConfig as N, type TypedTrackEventOptions as O, PAGE_IDENTITY_MAX_LENGTH as P, type TypedTrackingClient as Q, type RegisteredAutomaticEvents as R, SPECIFIC_PAGE_NAMES as S, type TimeOnSiteConfig as T, ctaClickConfigSchema as U, ctaClickMetadataSchema as V, formStartConfigSchema as W, formStartMetadataSchema as X, getEventDefinition as Y, getEventSemantics as Z, multiPageSessionConfigSchema as _, ALL_LEAD_EVENT_NAMES as a, pageExitConfigSchema as a0, pageExitMetadataSchema as a1, pageIdentitySchema as a2, pageViewConfigSchema as a3, pageViewMetadataSchema as a4, phoneClickConfigSchema as a5, phoneClickMetadataSchema as a6, scrollDepthConfigSchema as a7, scrollDepthMetadataSchema as a8, sdkHeartbeatConfigSchema as a9, sdkHeartbeatMetadataSchema as aa, sdkHeartbeatTriggersSchema as ab, specificPageNameSchema as ac, specificPageVisitConfigSchema as ad, specificPageVisitMetadataSchema as ae, timeOnSiteConfigSchema as af, timeOnSiteMetadataSchema as ag, ALL_MANUAL_EVENT_NAMES as b, type AutomaticEventName as c, type CtaClickMetadata as d, EVENT_SEMANTICS as e, type EventCategory as f, type EventClientVisibility as g, type EventConfig as h, type EventKind as i, type EventMetadata as j, type EventName as k, type EventOutcomeRole as l, type EventSemantics as m, type FormStartMetadata as n, type MultiPageSessionConfig as o, type MultiPageSessionMetadata as p, PAGE_IDENTITY_PATTERN as q, type PageExitConfig as r, type PageExitMetadata as s, type PageIdentity as t, type PageViewConfig as u, type PageViewMetadata as v, type PhoneClickConfig as w, type PhoneClickMetadata as x, type RegisteredManualEvents as y, type ScrollDepthConfig as z };