@aranova/tracking-next 0.14.2 → 0.16.0

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { C as ConsentState, a as TrackingInstallSurface, b as TrackingEnvironment, c as TrackingClientContext, T as TrackingParams, d as TrackingEventCreatePayload, e as TrackingSessionUpsertPayload, F as FormSubmitConfig, f as FormSubmitMetadata, G as GtagEnvironmentMap, M as MetaPixelEnvironmentMap, P as PhoneConfig, g as ParsedPhone, h as PhoneDisplayFormat } from './phone-utils-CcU5mwzc.js';
-export { D as DEFAULT_PHONE_COUNTRY, J as JsonValue, i as TrackedField, j as TrackingInitConfig, k as formSubmitConfigSchema, l as formSubmitMetadataSchema, m as formatPhone, n as formatPhoneAsTyped, o as jsonValueSchema, p as parsePhone, q as phoneField, t as toE164 } from './phone-utils-CcU5mwzc.js';
+import { T as TrackingParams, a as TrackingInstallSurface, b as TrackingEnvironment, c as TrackingClientContext, d as TrackingEventCreatePayload, e as TrackingSessionUpsertPayload, F as FormSubmitConfig, f as FormSubmitMetadata, C as ConsentState, g as ConsentChoiceState, h as ConsentSource, G as GtagEnvironmentMap, M as MetaPixelEnvironmentMap, P as PhoneConfig, i as ParsedPhone, j as PhoneDisplayFormat } from './phone-utils-DlAQK-gU.js';
+export { k as ConsentChoice, D as DEFAULT_DECLINE_TTL_DAYS, l as DEFAULT_PHONE_COUNTRY, J as JsonValue, S as SetConsentOptions, m as TrackedField, n as TrackingInitConfig, o as formSubmitConfigSchema, p as formSubmitMetadataSchema, q as formatPhone, r as formatPhoneAsTyped, s as getConsentChoice, t as getConsentState, u as jsonValueSchema, v as onConsentChange, w as optIn, x as optOut, y as parsePhone, z as phoneField, A as resetConsent, B as setConsentState, E as toE164 } from './phone-utils-DlAQK-gU.js';
 import { C as ConversionConfig } from './sales-Bq7H-Vym.js';
 export { A as AranovaApiError, B as BusinessConfig, a as BusinessConfigFeatures, b as BusinessConfigService, c as CompareTo, d as ConversionConfigStore, e as CurrencyRevenue, f as CustomerCurrencyDelta, g as CustomerCurrencyTotal, h as CustomerGetOptions, i as CustomerGetResult, j as CustomerKpis, k as CustomerKpisDeltas, l as CustomerKpisPrevious, m as CustomerListPage, n as CustomerListQuery, o as CustomerProfile, p as CustomerSegment, q as CustomerSegmentCount, r as CustomerSortField, s as CustomerSummary, t as CustomerSummaryQuery, D as DistinctCustomersByCurrency, G as Granularity, N as NAMED_RANGES, u as NamedRange, P as PublicServiceItem, S as SUPPORTED_CURRENCIES, v as Sale, w as SaleCursorPage, x as SaleFilters, y as SaleInput, z as SaleItem, E as SaleItemInput, F as SaleKeysetSortField, H as SaleListPage, I as SaleListQuery, J as SaleListQueryV2, K as SaleService, L as SaleServiceInput, M as SaleSortField, O as SaleSortOrder, Q as SaleSummary, R as SaleSummaryPrevious, T as SaleSummaryQuery, U as SaleSummaryQueryV2, V as SaleSummaryV2, W as SaleUpdateInput, X as SalesBusinessClient, Y as SalesCategoryBreakdown, Z as SalesClient, _ as SalesClientConfig, $ as SalesCustomersClient, a0 as SalesServiceBreakdown, a1 as SalesTransportConfig, a2 as SalesTrendPoint, a3 as SummaryCurrencyDelta, a4 as SummaryDeltas, a5 as SummaryWindow, a6 as SupportedCurrency, a7 as TRACKING_RANGES, a8 as TrackingOverviewRange, a9 as createSalesClient, aa as fetchServices, ab as formatDateInTz, ac as formatMoney, ad as fromMinor, ae as resolveConversionConfig, af as saleCreateSchema, ag as saleItemSchema, ah as saleServiceSchema, ai as saleUpdateSchema, aj as salesRequest, ak as toMinor } from './sales-Bq7H-Vym.js';
 import { z } from 'zod';
@@ -11,37 +11,17 @@ import { CountryCode } from 'libphonenumber-js';
 export { CountryCode } from 'libphonenumber-js';
 
 /**
- * Google Consent Mode value sent to `gtag('consent', 'update', ...)`.
- */
-type GtagConsentValue = "granted" | "denied";
-/**
- * Read the persisted visitor consent state from localStorage.
- *
- * Returns `pending` when called during SSR or before the visitor has made a
- * choice.
- */
-declare function getConsentState(): ConsentState;
-/**
- * Persist a visitor consent choice and update Google Consent Mode when gtag is
- * loaded.
+ * Attribution query/cookie keys captured by the SDK.
  */
-declare function setConsentState(state: GtagConsentValue): void;
+declare const TRACKING_PARAM_KEYS: readonly ["gclid", "fbclid", "utm_source", "utm_medium", "utm_campaign", "utm_term", "utm_content"];
+type TrackingParamKey = (typeof TRACKING_PARAM_KEYS)[number];
 /**
- * Clear the stored consent choice so the banner re-appears on next render.
- *
- * Power a "Cookie preferences" link in a footer so visitors can change their
- * mind without losing access to your site:
- *
- * ```tsx
- * const { reset } = useConsent();
- * <button onClick={reset}>Cookie preferences</button>
- * ```
+ * Capture tracking params from a URL, persist them to first-party cookies, and
+ * return the current cookie-backed attribution state.
  *
- * Does NOT push an `update` to gtag — there's nothing to update because the
- * visitor hasn't chosen anything yet. The next `setConsentState()` call will
- * sync gtag once they re-choose.
+ * Defaults to `window.location.href` in the browser.
  */
-declare function resetConsent(): void;
+declare function captureTrackingParamsFromLocation(url?: string, maxAgeSeconds?: number): TrackingParams;
 
 interface TrackingContextInput {
     packageName?: string | null;
@@ -63,6 +43,12 @@ interface TrackingSessionInput {
     firstPage?: string | null;
     sessionId: string;
     visitorId?: string | null;
+    /**
+     * Landing attribution override (ADR-016). When omitted, the session's
+     * persisted landing record is used (captured from the current URL if the
+     * session has none yet).
+     */
+    landingParams?: Partial<Record<TrackingParamKey, string>>;
 }
 /**
  * Build runtime context attached to tracking sessions and events.
@@ -94,6 +80,8 @@ declare const ctaClickMetadataSchema: z.ZodObject<{
     }>;
     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;
@@ -101,6 +89,8 @@ declare const ctaClickMetadataSchema: z.ZodObject<{
     cta_name: string;
     section?: string | null | undefined;
     destination_url?: string | null | undefined;
+    href?: string | null | undefined;
+    element?: string | null | undefined;
 }, {
     page: {
         path: string;
@@ -108,14 +98,34 @@ declare const ctaClickMetadataSchema: z.ZodObject<{
     cta_name: string;
     section?: string | null | undefined;
     destination_url?: string | null | undefined;
+    href?: string | null | undefined;
+    element?: string | null | undefined;
 }>;
 type CtaClickMetadata = z.infer<typeof ctaClickMetadataSchema>;
 /**
  * Registration config for `cta_click`.
  *
- * This event is manual-only and currently has no registration options.
+ * 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<{}, "strict", z.ZodTypeAny, {}, {}>;
+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>;
 
 /**
@@ -279,6 +289,49 @@ declare const multiPageSessionConfigSchema: z.ZodObject<{
 }>;
 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>;
+    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;
+}, {
+    page: {
+        path: string;
+    };
+    dwell_ms: number;
+    max_scroll_percent: number | null;
+}>;
+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.
  *
@@ -810,6 +863,33 @@ declare const EVENT_REGISTRY: {
         }>;
         readonly configSchema: z.ZodObject<{}, "strict", z.ZodTypeAny, {}, {}>;
     };
+    readonly page_exit: {
+        readonly kind: "automatic";
+        readonly metadataSchema: z.ZodObject<{
+            dwell_ms: z.ZodNumber;
+            max_scroll_percent: 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;
+        }, {
+            page: {
+                path: string;
+            };
+            dwell_ms: number;
+            max_scroll_percent: number | null;
+        }>;
+        readonly configSchema: z.ZodObject<{}, "strict", z.ZodTypeAny, {}, {}>;
+    };
     readonly form_submit: {
         readonly kind: "manual";
         readonly metadataSchema: z.ZodObject<{
@@ -929,6 +1009,8 @@ declare const EVENT_REGISTRY: {
             }>;
             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;
@@ -936,6 +1018,8 @@ declare const EVENT_REGISTRY: {
             cta_name: string;
             section?: string | null | undefined;
             destination_url?: string | null | undefined;
+            href?: string | null | undefined;
+            element?: string | null | undefined;
         }, {
             page: {
                 path: string;
@@ -943,8 +1027,26 @@ declare const EVENT_REGISTRY: {
             cta_name: string;
             section?: string | null | undefined;
             destination_url?: string | null | undefined;
+            href?: 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;
         }>;
-        readonly configSchema: z.ZodObject<{}, "strict", z.ZodTypeAny, {}, {}>;
     };
 };
 /**
@@ -973,6 +1075,7 @@ type MetadataByName = {
     multi_page_session: MultiPageSessionMetadata;
     form_start: FormStartMetadata;
     sdk_heartbeat: SdkHeartbeatMetadata;
+    page_exit: PageExitMetadata;
     form_submit: FormSubmitMetadata;
     phone_click: PhoneClickMetadata;
     cta_click: CtaClickMetadata;
@@ -985,6 +1088,7 @@ type ConfigByName = {
     multi_page_session: MultiPageSessionConfig;
     form_start: FormStartConfig;
     sdk_heartbeat: SdkHeartbeatConfig;
+    page_exit: PageExitConfig;
     form_submit: FormSubmitConfig;
     phone_click: PhoneClickConfig;
     cta_click: CtaClickConfig;
@@ -1099,8 +1203,14 @@ interface TrackEventInput {
 interface TrackingClient {
     /** Enqueue an event for batched delivery. */
     trackEvent: (input: TrackEventInput) => void;
-    /** Flush queued events immediately. */
+    /** Flush queued events immediately (fetch, non-keepalive). */
     flush: () => Promise<void>;
+    /**
+     * Flush queued events through the keepalive transport so the request
+     * survives document unload. Use from `pagehide`/`visibilitychange:hidden`
+     * handlers — a plain `flush()` there is aborted by the browser on unload.
+     */
+    flushBeacon: () => void;
     /** Return the current rolling session id. */
     getSessionId: () => string;
     /** Return the persistent visitor id. */
@@ -1109,18 +1219,6 @@ interface TrackingClient {
     destroy: () => void;
 }
 
-/**
- * Attribution query/cookie keys captured by the SDK.
- */
-declare const TRACKING_PARAM_KEYS: readonly ["gclid", "fbclid", "utm_source", "utm_medium", "utm_campaign", "utm_term", "utm_content"];
-/**
- * Capture tracking params from a URL, persist them to first-party cookies, and
- * return the current cookie-backed attribution state.
- *
- * Defaults to `window.location.href` in the browser.
- */
-declare function captureTrackingParamsFromLocation(url?: string, maxAgeSeconds?: number): TrackingParams;
-
 interface TypedTrackEventOptions {
     /**
      * Override the page URL associated with this event.
@@ -1166,37 +1264,14 @@ interface TypedTrackingClient<TRegistry extends TriggerRegistryConfig> {
 }
 
 /**
- * Default non-blocking consent banner.
- *
- * Renders only while consent is `pending`; collapses to `null` once the
- * visitor has chosen.
- *
- * **Styling is intentionally self-contained** — inline styles, zero CSS
- * dependencies, no Tailwind required at the consumer. The Tailwind-based
- * banner shipped before 0.9.1 rendered as transparent in any consumer that
- * didn't configure their content array to scan
- * `node_modules/@aranova/tracking-next/dist/**`; this version sidesteps that
- * class of bug entirely.
- *
- * For a fully bespoke banner, skip this component and use {@link useConsent}
- * directly to drive your own UI.
- *
- * @example
- * // Drop-in default
- * <ConsentBanner />
+ * Legacy opt-in-era consent banner.
  *
- * @example
- * // Customized
- * <ConsentBanner
- *   message="We use cookies to learn which ads drive bookings."
- *   acceptLabel="Sounds good"
- *   declineLabel="No thanks"
- *   policyHref="/privacy"
- *   policyLabel="Privacy policy"
- *   theme="dark"
- *   onAccept={() => track('consent_accepted')}
- *   onDecline={() => track('consent_declined')}
- * />
+ * @deprecated PERMANENTLY INERT since consent v2 (opt-out model): it renders
+ * only while consent is `pending`, and the effective state is never `pending`
+ * anymore, so this component always returns `null`. Tracking is on by default;
+ * replace the banner with a footer "cookie preferences" control built on
+ * {@link useCookiePreferences} (see the package README). Kept exported so
+ * existing integrations keep compiling; scheduled for removal.
  */
 interface ConsentBannerProps {
     /** Body text. Defaults to the standard cookies-for-ad-performance message. */
@@ -1228,6 +1303,12 @@ interface ConsentBannerProps {
     /** Inline style overrides applied to the outer wrapper after the defaults. */
     style?: CSSProperties;
 }
+/**
+ * @deprecated Permanently inert since consent v2 — always renders `null`
+ * because the effective consent state is never `pending`. Use a footer
+ * control built on {@link useCookiePreferences} instead. See
+ * {@link ConsentBannerProps} for details.
+ */
 declare function ConsentBanner({ message, title, acceptLabel, declineLabel, policyHref, policyLabel, onAccept, onDecline, position, theme, className, style, }?: ConsentBannerProps): ReactNode;
 
 /**
@@ -1242,38 +1323,69 @@ declare function useGclid(): string | null;
  * Values are loaded after mount, so the initial render returns all `null`s.
  */
 declare function useTrackingParams(): TrackingParams;
+/** Options for {@link useCookiePreferences}. */
+interface UseCookiePreferencesOptions {
+    /** Days an explicit decline is honored. Defaults to 90. */
+    declineTtlDays?: number;
+}
 /**
- * Read the current visitor consent state and update when another tab changes
- * the stored value.
- *
- * Prefer {@link useConsent} for new code — it returns the same state plus
- * the `accept` / `decline` / `reset` actions a custom consent UI needs.
- * `useConsentState` is kept as a convenience for callers that only need to
- * read.
+ * The headless cookie-preferences surface returned by
+ * {@link useCookiePreferences}.
  */
-declare function useConsentState(): ConsentState;
+interface UseCookiePreferencesResult {
+    /** Effective consent — `granted` unless an unexpired explicit decline exists. */
+    state: ConsentChoiceState;
+    /** `default` = no valid explicit choice stored; `explicit` = visitor chose. */
+    source: ConsentSource;
+    /** True when the visitor has made no (valid, unexpired) explicit choice. */
+    isDefault: boolean;
+    isGranted: boolean;
+    isDenied: boolean;
+    /** ISO timestamp of the explicit choice; null for the default state. */
+    updatedAt: string | null;
+    /** ISO expiry of an unexpired decline; null otherwise. */
+    expiresAt: string | null;
+    /** Explicitly opt out of ad tracking (honored for 90 days by default). */
+    optOut: () => void;
+    /** Explicitly opt in (never expires). */
+    optIn: () => void;
+    /** Clear the explicit choice — back to default-granted. */
+    reset: () => void;
+}
 /**
- * The headless consent surface — state + actions in one hook.
+ * Headless cookie-preferences hook for the opt-out consent model (consent v2).
  *
- * Build a fully-custom banner without losing the gtag-sync, localStorage
- * persistence, or cross-tab propagation:
+ * Tracking is ON by default; this hook is how each client site wires its own
+ * footer "Cookie preferences" control (button, dialog, toggle — the packages
+ * ship no consent UI). State stays in sync with actions from other components
+ * in the same tab (via `onConsentChange`) and other tabs (via `storage`
+ * events).
  *
  * ```tsx
- * const { state, accept, decline, reset, isPending } = useConsent();
- *
- * if (!isPending) {
- *   return <button onClick={reset}>Cookie preferences</button>;
+ * function CookiePreferences() {
+ *   const { isDenied, optOut, optIn } = useCookiePreferences();
+ *   return isDenied ? (
+ *     <button onClick={optIn}>Enable ad measurement</button>
+ *   ) : (
+ *     <button onClick={optOut}>Opt out of ad measurement</button>
+ *   );
  * }
- * return (
- *   <MyBannerStyling>
- *     <button onClick={decline}>No thanks</button>
- *     <button onClick={accept}>Sure</button>
- *   </MyBannerStyling>
- * );
  * ```
+ */
+declare function useCookiePreferences(options?: UseCookiePreferencesOptions): UseCookiePreferencesResult;
+/**
+ * Read the current visitor consent state.
  *
- * The boolean helpers (`isPending` / `isGranted` / `isDenied`) are equivalent
- * to comparing `state` directly — they're there for readability at call sites.
+ * @deprecated Since consent v2 (opt-out model) the state is never `pending`.
+ * Use {@link useCookiePreferences} — it exposes the effective state plus
+ * `source` so you can tell a default grant from an explicit one.
+ */
+declare function useConsentState(): ConsentState;
+/**
+ * Result shape of the deprecated {@link useConsent} hook.
+ *
+ * @deprecated Use {@link UseCookiePreferencesResult} via
+ * {@link useCookiePreferences}. `isPending` is always `false` since consent v2.
  */
 interface UseConsentResult {
     state: ConsentState;
@@ -1284,6 +1396,14 @@ interface UseConsentResult {
     decline: () => void;
     reset: () => void;
 }
+/**
+ * Legacy opt-in-era consent hook.
+ *
+ * @deprecated Since consent v2 tracking defaults ON (opt-out model): the state
+ * is never `pending`, so banner UIs gated on `isPending` never render. Use
+ * {@link useCookiePreferences} for footer "cookie preferences" controls.
+ * `accept` / `decline` still work and map to `optIn` / `optOut`.
+ */
 declare function useConsent(): UseConsentResult;
 
 /**
@@ -1470,4 +1590,4 @@ interface PhoneFieldProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "t
  */
 declare const PhoneField: react.ForwardRefExoticComponent<PhoneFieldProps & react.RefAttributes<HTMLInputElement>>;
 
-export { ALL_AUTOMATIC_EVENT_NAMES, ALL_MANUAL_EVENT_NAMES, AdPlatformTracking, type AdPlatformTrackingProps, type AutomaticEventName, ConsentBanner, type ConsentBannerProps, ConsentState, ConversionConfig, type CreateTrackingOptions, type CreateTrackingResult, type CtaClickConfig, type CtaClickMetadata, EVENT_REGISTRY, type EventConfig, type EventKind, type EventMetadata, type EventName, type FormStartConfig, type FormStartMetadata, FormSubmitConfig, FormSubmitMetadata, GoogleAdsTracking, type GoogleAdsTrackingProps, GtagEnvironmentMap, type ManualEventName, MetaPixelEnvironmentMap, type MultiPageSessionConfig, type MultiPageSessionMetadata, type PageViewConfig, type PageViewMetadata, ParsedPhone, type PhoneClickConfig, type PhoneClickMetadata, PhoneConfig, PhoneDisplayFormat, PhoneField, type PhoneFieldApi, type PhoneFieldProps, type PhoneInputProps, type RegisteredAutomaticEvents, type RegisteredManualEvents, SPECIFIC_PAGE_NAMES, type ScrollDepthConfig, type ScrollDepthMetadata, type SdkHeartbeatConfig, type SdkHeartbeatMetadata, type SpecificPageName, type SpecificPageVisitConfig, type SpecificPageVisitMetadata, TRACKING_PARAM_KEYS, type TimeOnSiteConfig, type TimeOnSiteMetadata, type TrackableEvent, type TrackingClient, TrackingClientContext, TrackingEventCreatePayload, TrackingInstallSurface, TrackingParams, type TrackingProviderProps, TrackingSessionUpsertPayload, type TriggerRegistryConfig, type TypedTrackEventOptions, type TypedTrackingClient, type UseConsentResult, type UsePhoneFieldOptions, captureTrackingParamsFromLocation, createTracking, createTrackingClientContext, createTrackingEventCreatePayload, createTrackingSessionUpsertPayload, ctaClickConfigSchema, ctaClickMetadataSchema, formStartConfigSchema, formStartMetadataSchema, getConsentState, getEventDefinition, multiPageSessionConfigSchema, multiPageSessionMetadataSchema, pageViewConfigSchema, pageViewMetadataSchema, phoneClickConfigSchema, phoneClickMetadataSchema, resetConsent, scrollDepthConfigSchema, scrollDepthMetadataSchema, sdkHeartbeatConfigSchema, sdkHeartbeatMetadataSchema, sdkHeartbeatTriggersSchema, setConsentState, specificPageNameSchema, specificPageVisitConfigSchema, specificPageVisitMetadataSchema, timeOnSiteConfigSchema, timeOnSiteMetadataSchema, useConsent, useConsentState, useGclid, usePhoneConfig, usePhoneField, useTrackingParams };
+export { ALL_AUTOMATIC_EVENT_NAMES, ALL_MANUAL_EVENT_NAMES, AdPlatformTracking, type AdPlatformTrackingProps, type AutomaticEventName, ConsentBanner, type ConsentBannerProps, ConsentChoiceState, ConsentSource, ConsentState, ConversionConfig, type CreateTrackingOptions, type CreateTrackingResult, type CtaClickConfig, type CtaClickMetadata, EVENT_REGISTRY, type EventConfig, type EventKind, type EventMetadata, type EventName, type FormStartConfig, type FormStartMetadata, FormSubmitConfig, FormSubmitMetadata, GoogleAdsTracking, type GoogleAdsTrackingProps, GtagEnvironmentMap, type ManualEventName, MetaPixelEnvironmentMap, type MultiPageSessionConfig, type MultiPageSessionMetadata, type PageExitConfig, type PageExitMetadata, type PageViewConfig, type PageViewMetadata, ParsedPhone, type PhoneClickConfig, type PhoneClickMetadata, PhoneConfig, PhoneDisplayFormat, PhoneField, type PhoneFieldApi, type PhoneFieldProps, type PhoneInputProps, type RegisteredAutomaticEvents, type RegisteredManualEvents, SPECIFIC_PAGE_NAMES, type ScrollDepthConfig, type ScrollDepthMetadata, type SdkHeartbeatConfig, type SdkHeartbeatMetadata, type SpecificPageName, type SpecificPageVisitConfig, type SpecificPageVisitMetadata, TRACKING_PARAM_KEYS, type TimeOnSiteConfig, type TimeOnSiteMetadata, type TrackableEvent, type TrackingClient, TrackingClientContext, TrackingEventCreatePayload, TrackingInstallSurface, TrackingParams, type TrackingProviderProps, TrackingSessionUpsertPayload, type TriggerRegistryConfig, type TypedTrackEventOptions, type TypedTrackingClient, type UseConsentResult, type UseCookiePreferencesOptions, type UseCookiePreferencesResult, type UsePhoneFieldOptions, captureTrackingParamsFromLocation, createTracking, createTrackingClientContext, createTrackingEventCreatePayload, createTrackingSessionUpsertPayload, ctaClickConfigSchema, ctaClickMetadataSchema, formStartConfigSchema, formStartMetadataSchema, getEventDefinition, multiPageSessionConfigSchema, multiPageSessionMetadataSchema, pageExitConfigSchema, pageExitMetadataSchema, pageViewConfigSchema, pageViewMetadataSchema, phoneClickConfigSchema, phoneClickMetadataSchema, scrollDepthConfigSchema, scrollDepthMetadataSchema, sdkHeartbeatConfigSchema, sdkHeartbeatMetadataSchema, sdkHeartbeatTriggersSchema, specificPageNameSchema, specificPageVisitConfigSchema, specificPageVisitMetadataSchema, timeOnSiteConfigSchema, timeOnSiteMetadataSchema, useConsent, useConsentState, useCookiePreferences, useGclid, usePhoneConfig, usePhoneField, useTrackingParams };