@drip-apex/sdk 0.1.0 → 0.3.0

package/dist/types/public-api.d.ts

@@ -0,0 +1,209 @@
+import { type CartAttributeEntry, type CartMetafieldInput, type CartAttributeSyncInput } from "./shopify-cart";
+import { getPendingGiftChoices, selectGiftOption } from "./commerce-gift";
+import { type ApexRuntimeTools } from "./runtime-tools";
+import { rememberProduct, setCartSignals, setSearchSignal } from "./signals";
+import { Assignment, Experiment, Goal, InitConfig, SdkDiagnostics } from "./types";
+import { setPublicSignal, getPublicSignals, triggerPage } from "./config-runtime";
+import { evaluate } from "./assignment-runtime";
+export declare function loadQaToolbar(experiments: Experiment[]): void;
+export declare function loadQaAssistant(onUnavailable?: () => void): void;
+export declare function loadDevtoolsIfEnabled(experiments: Experiment[]): void;
+export declare function loadDevtools(experiments: Experiment[]): void;
+export declare function init(config: InitConfig): Assignment[];
+export declare function trackEvent(type: string, data?: Record<string, unknown>, experimentId?: string, variationId?: string, eventId?: string, forceUnassigned?: boolean, timestamp?: number): void;
+export declare function track(type: string, data?: Record<string, unknown>, experimentId?: string, variationId?: string): void;
+export declare function funnelStepStorageKey(stepName: string): string;
+export declare function shouldTrackFunnelStep(stepName: string, oncePerSession: boolean): boolean;
+/**
+ * Track a virtual funnel step that has no reliable browser event by default,
+ * such as a postcode form submit, embedded quiz step, or third-party handoff.
+ */
+export declare function trackStep(name: string, data?: Record<string, unknown>): void;
+export declare function trackGoal(goalId: string, data?: Record<string, unknown>): void;
+export declare function setConsent(granted: boolean): void;
+export declare function hold(): number;
+export declare function release(): number;
+export declare function hydrated(): void;
+export declare function recheckPrerequisites(): void;
+export declare function reInit(forceReapply?: boolean): Assignment[];
+/**
+ * Track a revenue/purchase event. Convenience method that fires a "purchase" event
+ * with revenue data for all active experiments.
+ *
+ * Usage: drip.trackRevenue(49.99) or drip.trackRevenue(49.99, { orderId: "123", currency: "EUR" })
+ */
+export type RevenueEventData = Record<string, unknown> & {
+    currency?: string;
+};
+export declare function normalizeRevenueCurrency(value: unknown): string | undefined;
+export declare function trackRevenue(revenue: number, data?: RevenueEventData): void;
+export declare function flush(): Promise<void>;
+export declare function getAssignments(): Assignment[];
+export declare function buildCurrentCartAttributes(scopedInput: CartAttributeSyncInput | null): CartAttributeEntry[];
+export declare function getCartAttributes(): CartAttributeEntry[];
+export declare function getCartMetafields(options?: {
+    namespace?: string;
+}): CartMetafieldInput[];
+/** Return cart-metafield keys that must be deleted to clear the previous mirror. */
+export declare function getCartMetafieldStaleKeys(options?: {
+    namespace?: string;
+}): string[];
+/** Replace entries supplied by the fresh Apex stamp while preserving valid cart attributes. */
+export declare function mergeCartAttributes(existing: unknown): CartAttributeEntry[];
+export declare function normalizedHeadlessCartToken(value: unknown): string | null;
+/**
+ * Build cart attributes for a headless Shopify Storefront API cart.
+ *
+ * Integrator contract: pass the cart's full Storefront Cart GID (including its
+ * `?key=` secret), write every returned entry to that same cart, and verify the
+ * Storefront API mutation succeeded with no `userErrors`. Only then call
+ * {@link confirmCartAttributesWritten} with the same Cart GID. Returning signed
+ * attributes does not authorize treatment display or exposure by itself. An
+ * empty result is fail-closed and must not be replaced with unsigned attributes.
+ * Theme storefronts use the SDK-managed `/cart/update.js` path and do not call
+ * either headless API.
+ */
+export declare function getSignedCartAttributes(cartToken?: string): Promise<CartAttributeEntry[]>;
+/**
+ * Acknowledge that the latest signed headless cart attributes were persisted.
+ *
+ * Call this only after the Storefront API cart-attributes mutation succeeded
+ * and returned no `userErrors`. The Cart GID must match the one passed to the
+ * latest {@link getSignedCartAttributes} call. Stale-generation, mismatched,
+ * or repeated acknowledgements are no-ops and cannot grant or change display
+ * and exposure authorization. When a staged offer adoption can no longer
+ * apply, the acknowledgement is rejected (`false`) with retryable pending
+ * state and no authorization is granted.
+ *
+ * @returns `true` only when the latest matching acknowledgement was accepted.
+ */
+export declare function confirmCartAttributesWritten(cartToken?: string): boolean;
+export declare function getExperiments(): Experiment[];
+export declare function getGoals(): Goal[];
+export declare function getActiveExperimentIds(): Record<string, string>;
+export declare function getRuntimeValue(key: string): unknown;
+export declare function getRuntimeTools(): ApexRuntimeTools;
+export declare function buildFlagContext(context?: {
+    url?: string;
+    attributes?: Record<string, unknown>;
+    userId?: string;
+}): {
+    url: string;
+    attributes: Record<string, unknown>;
+    userId: string | undefined;
+    forceMap: Record<string, string> | undefined;
+};
+export declare function evaluateFlag(flagId: string, context?: {
+    url?: string;
+    attributes?: Record<string, unknown>;
+    userId?: string;
+}): boolean;
+export declare function evaluateFlagAssignment(flagId: string, context?: {
+    url?: string;
+    attributes?: Record<string, unknown>;
+    userId?: string;
+}): Assignment | null;
+export declare function evaluateFlagValue<T = unknown>(flagId: string, fallback?: T, context?: {
+    url?: string;
+    attributes?: Record<string, unknown>;
+    userId?: string;
+}): T | unknown;
+export declare function getDiagnostics(): SdkDiagnostics;
+export type QueueCommand = {
+    type: "trackGoal";
+    goalId: string;
+    data?: Record<string, unknown>;
+} | {
+    type: "trackRevenue";
+    revenue: number;
+    data?: RevenueEventData;
+} | {
+    type: "track";
+    event: string;
+    data?: Record<string, unknown>;
+} | {
+    type: "step";
+    name: string;
+    data?: Record<string, unknown>;
+} | {
+    type: "signal";
+    key: string;
+    value: unknown;
+    ttlDays?: number;
+} | {
+    type: "triggerPage";
+    apiName: string;
+    active?: unknown;
+} | {
+    type: "rememberProduct";
+    product: Parameters<typeof rememberProduct>[0];
+    ttlDays?: number;
+} | {
+    type: "setCart";
+    itemCount?: number;
+    productIds?: string[];
+    ttlDays?: number;
+} | {
+    type: "setSearch";
+    query: string;
+    ttlDays?: number;
+} | {
+    type: "setConsent";
+    granted: boolean;
+} | {
+    type: "hold";
+} | {
+    type: "release";
+} | {
+    type: "hydrated";
+} | {
+    type: "reInit";
+    force?: boolean;
+} | {
+    type: "recheckPrerequisites";
+} | {
+    type: "init";
+    config: InitConfig;
+};
+export declare function processCommand(cmd: QueueCommand): void;
+export declare function processQueue(): void;
+export declare let installedGlobalApi: ReturnType<typeof createGlobalApi> | undefined;
+export declare function createGlobalApi(): ((command: string) => number | void) & {
+    init: typeof init;
+    track: typeof track;
+    step: typeof trackStep;
+    trackGoal: typeof trackGoal;
+    trackRevenue: typeof trackRevenue;
+    setConsent: typeof setConsent;
+    hold: typeof hold;
+    release: typeof release;
+    hydrated: typeof hydrated;
+    reInit: typeof reInit;
+    recheckPrerequisites: typeof recheckPrerequisites;
+    flush: typeof flush;
+    evaluate: typeof evaluate;
+    evaluateFlag: typeof evaluateFlag;
+    evaluateFlagAssignment: typeof evaluateFlagAssignment;
+    evaluateFlagValue: typeof evaluateFlagValue;
+    signal: typeof setPublicSignal;
+    triggerPage: typeof triggerPage;
+    rememberProduct: typeof rememberProduct;
+    setCart: typeof setCartSignals;
+    setSearch: typeof setSearchSignal;
+    getSignals: typeof getPublicSignals;
+    getAssignments: typeof getAssignments;
+    getCartAttributes: typeof getCartAttributes;
+    getCartMetafields: typeof getCartMetafields;
+    getCartMetafieldStaleKeys: typeof getCartMetafieldStaleKeys;
+    mergeCartAttributes: typeof mergeCartAttributes;
+    getSignedCartAttributes: typeof getSignedCartAttributes;
+    confirmCartAttributesWritten: typeof confirmCartAttributesWritten;
+    getExperiments: typeof getExperiments;
+    getTools: typeof getRuntimeTools;
+    get: typeof getRuntimeValue;
+    getDiagnostics: typeof getDiagnostics;
+    getPendingGiftChoices: typeof getPendingGiftChoices;
+    selectGiftOption: typeof selectGiftOption;
+    push(cmd: QueueCommand): void;
+};
+export declare function installGlobalApi(): void;

package/dist/types/qa-assistant-state.d.ts

@@ -30,8 +30,18 @@ export type QaEventModel = {
     type: "exposure" | "goal" | "revenue" | "pageview";
     label: string;
     value: string | null;
+    goalId?: string;
     duplicateOf?: number;
 };
+export type QaGoalScopeModel = {
+    id: string;
+    name: string;
+    pageId: string | null;
+    pageLabel: string | null;
+    urlPattern?: string | null;
+    status: "active" | "inactive" | "not_wired";
+    assignmentPageActive?: boolean | null;
+};
 export type QaTransactionsModel = {
     kind: "unsupported";
 } | {
@@ -52,11 +62,35 @@ export type QaTransactionsModel = {
     }>;
     serverReceipt: "pending" | "confirmed" | "unknown";
 };
+export type ForcedUnavailable = {
+    experimentId: string;
+    reason: "archived" | "runtime_disabled" | "not_found" | "environment_mismatch" | "not_in_config";
+};
+export type EdgeDeviceAudienceUnsupported = {
+    experimentId: string;
+    audienceName: string;
+};
+export type QaPageActivationModel = {
+    pageId: string;
+    pageName: string;
+    active: boolean;
+    lastTransitionMode: "reset" | "deactivate" | "force_reset" | "persistent" | null;
+    isolationFallback: "whole_experiment" | null;
+    triggerDetector?: "history" | "polling" | "dom" | null;
+    triggerPollAttempts?: number;
+    triggerOutcome?: "activated" | "condition_failed" | "window_expired" | null;
+    triggerElapsedMs?: number;
+};
 export type QaAssistantState = {
+    storeVersion: number;
     experiments: QaExperimentModel[];
     events: QaEventModel[];
+    goalScopes: QaGoalScopeModel[];
+    pageActivation: QaPageActivationModel[];
     transactions: QaTransactionsModel;
     forcedSummary: string | null;
+    forcedUnavailable: ForcedUnavailable[];
+    edgeDeviceAudienceUnsupported: EdgeDeviceAudienceUnsupported[];
 };
 export type QaAssistantStore = {
     getState(): QaAssistantState;

package/dist/types/react/index.d.ts

@@ -2,7 +2,7 @@
  * React bindings for Drip SDK.
  *
  * Usage:
- *   import { DripProvider, useExperiment, useVariation, useFeatureFlag, useFeatureFlagValue, useTrackGoal } from "@drip-apex/sdk/react";
+ *   import { DripProvider, useExperiment, useVariation, useFeatureFlag, useFeatureFlagValue, useTrackGoal, useGetCartMetafields } from "@drip-apex/sdk/react";
  *
  *   function App() {
  *     return (
@@ -28,7 +28,27 @@
  *   }
  */
 import { type ReactNode } from "react";
-import type { Assignment, InitConfig, Variation } from "../types";
+import type { Assignment, Experiment, InitConfig, Variation } from "../types";
+import type { RevenueEventData } from "../index";
+import type { CartMetafieldInput } from "../shopify-cart";
+interface DripContextValue {
+    /** Current experiment assignments. */
+    assignments: Assignment[];
+    /** Loaded experiment configs. */
+    experiments: Experiment[];
+    /** Whether the SDK is still loading config. */
+    loading: boolean;
+    /** Track a goal by goalId with optional data. */
+    trackGoal: (goalId: string, data?: Record<string, unknown>) => void;
+    /** Track a custom event. */
+    track: (type: string, data?: Record<string, unknown>) => void;
+    /** Track revenue. */
+    trackRevenue: (revenue: number, data?: RevenueEventData) => void;
+    /** Build headless Shopify cart metafields from the current attribution stamp. */
+    getCartMetafields: (options?: {
+        namespace?: string;
+    }) => Promise<CartMetafieldInput[]>;
+}
 export interface DripProviderProps extends Omit<InitConfig, "onExperimentViewed"> {
     children: ReactNode;
     /** Callback when an experiment is viewed (assignment applied). */
@@ -40,7 +60,7 @@ export interface DripProviderProps extends Omit<InitConfig, "onExperimentViewed"
  * Initializes the SDK, fetches experiment config (if shopId provided),
  * and provides assignment context to child components.
  */
-export declare function DripProvider({ children, onExperimentViewed, ...config }: DripProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function DripProvider({ children, onExperimentViewed, ...config }: DripProviderProps): import("react").JSX.Element;
 /**
  * Get the assignment for a specific experiment by ID or slug.
  * Returns `null` if the user is not assigned to this experiment.
@@ -73,6 +93,10 @@ export declare function useTrack(): (type: string, data?: Record<string, unknown
  * Returns a function to track revenue.
  */
 export declare function useTrackRevenue(): (revenue: number, data?: Record<string, unknown>) => void;
+/**
+ * Returns a function that builds the current Shopify cart-metafield mirror.
+ */
+export declare function useGetCartMetafields(): DripContextValue["getCartMetafields"];
 /**
  * Get all current assignments.
  */
@@ -82,3 +106,4 @@ export declare function useAssignments(): Assignment[];
  */
 export declare function useLoading(): boolean;
 export type { Assignment, Experiment, Variation, InitConfig } from "../types";
+export type { CartMetafieldInput } from "../shopify-cart";

package/dist/types/reassert-sentinel.d.ts

@@ -2,5 +2,11 @@ import type { Mutation } from "./types";
 export declare function trackAppliedMutation(element: Element, mutation: Mutation, context: {
     experimentId?: string;
     variationId?: string;
+    journalSeq?: number;
+    artifactId?: string;
+    ownerKeys?: readonly string[];
 }, apply: (element: Element, mutation: Mutation) => void): void;
+export declare function addReassertSentinelOwners(existingOwnerKeys: ReadonlySet<string>, ownerKeys: readonly string[], artifactId?: string): void;
+export declare function resetReassertSentinelForOwner(ownerKey: string, artifactId?: string): void;
+export declare function replayReassertSentinelEntry(journalSeq: number, element: Element): void;
 export declare function resetReassertSentinel(): void;

package/dist/types/redirect.d.ts

@@ -0,0 +1,48 @@
+import type { Assignment, Experiment } from "./types";
+import type { ExternalTrackingSettings } from "./types";
+export declare const REDIRECT_ASSIGNMENT_PARAM = "_apex_assignment";
+export declare const REDIRECT_ASSIGNMENT_PENDING_KEY = "drip_redirect_assignment_pending_v1";
+export type ParsedRedirectCarry = {
+    experimentId: string;
+    variationId: string;
+    assignmentEpoch: number;
+    handoverToken: string;
+    expiresAt: number;
+    exposureSent: boolean;
+    destinationPath?: string;
+};
+export type VerifiedRedirectCarry = ParsedRedirectCarry & {
+    visitorId: string;
+    attributionToken?: string;
+    attributionDestinationUrl?: string;
+    attributionIssuedAt?: number;
+};
+export type ImportedRedirectCarry = {
+    experiment: Experiment;
+    variationId: string;
+    visitorId: string;
+    exposureSent: boolean;
+    attributionToken?: string;
+    attributionDestinationUrl?: string;
+    attributionIssuedAt?: number;
+};
+export declare function hasGeneratedRedirectAssignmentCarry(destination: URL): boolean;
+export declare function buildRedirectDestination(currentHref: string, redirectUrl: string, assignment: Pick<Assignment, "experimentId" | "variationId" | "assignmentEpoch">, visitorId?: string, handoverSettings?: ExternalTrackingSettings, includeAssignmentCarry?: boolean, exposureSent?: boolean): URL | null;
+export declare function markRedirectAssignmentCarryExposed(destination: URL): void;
+export declare function finalizeRedirectAssignmentCarryHandover(destination: URL, verifiedToken: string | null): void;
+export declare function isRedirectLoop(currentHref: string, destination: URL): boolean;
+export declare function filterUnsafeRedirectAssignments(experiments: Experiment[], assignments: Assignment[], currentHref: string, visitorId?: string, handoverSettings?: ExternalTrackingSettings, preserveAssignment?: (assignment: Assignment) => boolean, storeOrigin?: string | string[]): Assignment[];
+export declare function redirectPlanForAssignment(experiments: Experiment[], assignments: Assignment[], currentHref: string, visitorId?: string, handoverSettings?: ExternalTrackingSettings, includeAssignmentCarry?: boolean, storeOrigin?: string | string[]): {
+    destination: URL;
+    assignment: Assignment;
+} | null;
+export declare function redirectForAssignment(experiments: Experiment[], assignments: Assignment[], currentHref: string, visitorId?: string, handoverSettings?: ExternalTrackingSettings, includeAssignmentCarry?: boolean, storeOrigin?: string | string[]): URL | null;
+export declare function parseRedirectAssignmentCarry(href: string): ParsedRedirectCarry | null;
+export declare function persistPendingRedirectAssignmentCarry(carry: ParsedRedirectCarry | null): void;
+export declare function readPendingRedirectAssignmentCarry(): ParsedRedirectCarry | null;
+export declare function clearPendingRedirectAssignmentCarry(): void;
+export declare function verifyRedirectAssignmentCarry(carry: ParsedRedirectCarry | null, shopId: string, verifyToken: (token: string) => Promise<unknown>): Promise<VerifiedRedirectCarry | null>;
+export declare function validateRedirectAssignmentCarry(experiments: Experiment[], carry: VerifiedRedirectCarry | null, href?: string): ImportedRedirectCarry | null;
+export declare function readRedirectAssignmentCarry(experiments: Experiment[], href: string, shopId: string, verifyToken: (token: string) => Promise<unknown>): Promise<ImportedRedirectCarry | null>;
+export declare function importRedirectAssignmentCarry(carry: ImportedRedirectCarry, href: string, persistAttribution?: boolean): void;
+export declare function stripRedirectAssignmentCarry(href: string): void;

package/dist/types/replay-recorder-entry.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/replay-signal-state.d.ts

@@ -0,0 +1,6 @@
+import type { ReplaySignals } from "./replay";
+export declare const REPLAY_MAX_CLICK_SIGNALS = 100;
+export declare const REPLAY_MAX_NAV_SIGNALS = 50;
+export declare const REPLAY_MAX_ERROR_SIGNALS = 20;
+export declare const REPLAY_MAX_FORM_SIGNALS = 20;
+export declare function normalizeReplaySignalState(value: Partial<Record<keyof ReplaySignals, unknown>> | undefined): ReplaySignals;

package/dist/types/replay-signals.d.ts

@@ -0,0 +1,13 @@
+import type { ReplaySignals } from "./replay";
+type RrwebEvent = {
+    type?: number;
+    timestamp?: number;
+    data?: Record<string, unknown>;
+};
+export declare function createReplaySignalDeriver(signalState?: ReplaySignals, captureStartedAt?: number): {
+    accept: (event: RrwebEvent, target: Element | null) => void;
+    error: (message: string, ts?: number) => void;
+    snapshot: (now?: number) => ReplaySignals;
+    submit: (target: Element | null, ts?: number) => void;
+};
+export {};

package/dist/types/replay.d.ts

@@ -0,0 +1,110 @@
+import type { Assignment, Experiment } from "./types";
+export declare const REPLAY_RECORDER_FILENAME = "drip.replay-recorder.js";
+export declare const REPLAY_FLUSH_INTERVAL_MS = 10000;
+export declare const REPLAY_UNCOMPRESSED_BLOCK_BYTES: number;
+export declare const REPLAY_MAX_DURATION_MS: number;
+export declare const REPLAY_MAX_COMPRESSED_BYTES: number;
+export declare const REPLAY_SAMPLE_KEY_PREFIX = "drip_rp:";
+export declare const REPLAY_PROGRESS_KEY_PREFIX = "drip_replay_progress:";
+export declare const REPLAY_EXCLUDED_CHECKOUT_PATHS: readonly ["/checkout", "/checkouts/", "/cart/checkout"];
+export type ReplayAssignment = {
+    experiment_id: string;
+    variation_id: string;
+};
+type ReplayEvent = {
+    type?: number;
+    timestamp?: number;
+    data?: Record<string, unknown>;
+    [key: string]: unknown;
+};
+export type ReplayRecorderEmission = {
+    event?: ReplayEvent;
+};
+export type ReplayRecorderApi = {
+    start: (options: {
+        emit: (emission: ReplayRecorderEmission) => void;
+        signalState?: ReplaySignals;
+    }) => () => void;
+    compress: (bytes: Uint8Array) => Promise<Uint8Array>;
+    compressSync: (bytes: Uint8Array) => Uint8Array;
+    takeSignals: () => ReplaySignals;
+    version: string;
+};
+type ReplayClickSignal = {
+    ts: number;
+    selector: string;
+    x: number;
+    y: number;
+    mut_ms?: number;
+};
+export type ReplaySignals = {
+    clicks: ReplayClickSignal[];
+    nav: Array<{
+        ts: number;
+        url: string;
+    }>;
+    errors: Array<{
+        ts: number;
+        message: string;
+    }>;
+    form_focus: Array<{
+        ts: number;
+        selector: string;
+    }>;
+    form_submit: Array<{
+        ts: number;
+        selector: string;
+    }>;
+    scroll_max_pct: number;
+};
+export type ReplayEnvelope = {
+    contract: 1;
+    shop_id: string;
+    visitor_id: string;
+    session_id: string;
+    seq: number;
+    first_ts: number;
+    last_ts: number;
+    event_count: number;
+    url: string;
+    environment: string;
+    qa_mode: 0 | 1;
+    qa_session_id?: string;
+    sdk_version: string;
+    assignments: ReplayAssignment[];
+    codec: "deflate";
+    payload_b64: string;
+    signals: ReplaySignals;
+};
+export type ReplayController = {
+    stop: (discard?: boolean) => void;
+    isStopped: () => boolean;
+    update: (assignments: Assignment[], experiments: Experiment[]) => void;
+};
+type ReplayControllerOptions = {
+    assignments: Assignment[];
+    experiments: Experiment[];
+    recorderUrl: string;
+    endpoint: string;
+    shopId: string;
+    visitorId: string;
+    sessionId: string;
+    environment: string;
+    qaMode: boolean;
+    qaSessionId?: string;
+    sdkVersion: string;
+    ingestSignature?: string;
+    isTrackingBlocked: () => boolean;
+    loadRecorder?: (url: string) => Promise<ReplayRecorderApi>;
+};
+export declare function normalizeReplaySampleRate(value: unknown): number;
+export declare function resolveReplayAssignments(assignments: Assignment[], experiments: Experiment[]): ReplayAssignment[];
+export declare function isReplayCheckoutPath(pathname: string): boolean;
+export declare function resolveReplayRecorderUrl(input: {
+    configuredUrl?: string;
+    scriptSrc?: string;
+    pageUrl?: string;
+}): string | null;
+export declare function loadReplayRecorder(recorderUrl: string, documentLike?: Document): Promise<ReplayRecorderApi>;
+export declare function startReplayCapture(options: ReplayControllerOptions): Promise<ReplayController | null>;
+export {};

package/dist/types/router.d.ts

@@ -2,8 +2,18 @@ import { RouterMode } from "./types";
 export type RouteChangeEvent = {
     previousUrl: string;
     nextUrl: string;
-    reason: "pushState" | "replaceState" | "popstate" | "hashchange" | "navigation";
+    reason: "pushState" | "replaceState" | "popstate" | "hashchange" | "navigation" | "polling";
 };
 type RouteObserver = (event: RouteChangeEvent) => void;
-export declare function observeRouteChanges(mode: RouterMode, observer: RouteObserver): () => void;
+export declare function notifyIfChanged(lastUrlRef: {
+    value: string;
+}, reason: RouteChangeEvent["reason"], observer: RouteObserver, onObserverError?: (error: unknown) => void): void;
+export declare const PAGE_URL_POLL_INTERVAL_MS = 250;
+export declare function observePollingChanges(observer: RouteObserver, intervalMs?: number, lastUrlRef?: {
+    value: string;
+}, onObserverError?: (error: unknown) => void): () => void;
+export declare function observeRouteChanges(mode: RouterMode, observer: RouteObserver, options?: {
+    pollingIntervalMs?: number;
+    onObserverError?: (error: unknown) => void;
+}): () => void;
 export {};