/**
 * gtag.js loader.
 *
 * Loads `gtag/js?id=<primary>` from the vTilt gateway (`/gt`) so that every
 * subsequent measurement request — `gtag/js`, `/g/collect`, and
 * `/pagead/conversion` — stays on the first-party origin. Installs the
 * standard `window.dataLayer` queue and `window.gtag` shim exactly the way
 * Google's official snippet does, so any third-party integration that
 * expects them (Ads editor, Tag Assistant, CMP libraries) keeps working.
 */
import type { GoogleTagClientConfig } from "../../types";
import type { GtagFn } from "./consent-bridge";
export interface GtagLoaderOptions {
    /** Origin to load gtag.js from. Must include protocol. */
    origin: string;
    /** Path under `origin` that hosts the gateway. Defaults to `/gt`. */
    gatewayPath: string;
    /** Primary tag id used in the loader URL (first `G-*`, else first id). */
    primaryTagId: string;
    /** All tag ids to `gtag('config', id, ...)` after load. */
    tagIds: string[];
    /** Extra per-tag config. Currently only used to set `server_container_url`. */
    configParams?: Record<string, unknown>;
    /** Whether gtag.js should send its own `page_view` when configured. */
    sendPageView?: boolean;
    /** Enable `debug_mode` on gtag configs. */
    debugMode?: boolean;
    /** Enable `conversion_linker` (default true in gtag.js). */
    conversionLinker?: boolean;
    /** Domains for the `linker` feature (cross-domain). */
    linkerDomains?: string[];
}
export interface LoadedGtag {
    gtag: GtagFn;
    dataLayer: unknown[];
}
/**
 * Ensure a single `window.dataLayer` + `window.gtag` pair exists. Safe to
 * call multiple times — returns the same references. Matches Google's
 * reference snippet:
 *
 *   window.dataLayer = window.dataLayer || [];
 *   function gtag(){ dataLayer.push(arguments); }
 */
export declare function ensureDataLayer(): LoadedGtag;
/**
 * Inject the gtag.js <script> tag pointed at the vTilt gateway. The loader
 * script is fire-and-forget; the dataLayer/gtag shim queues any calls we
 * make before the script finishes.
 */
export declare function loadGtagScript(options: GtagLoaderOptions, onLoaded?: () => void, onError?: (err: Error) => void): HTMLScriptElement | null;
/**
 * Initialize gtag (`'js'` + per-id `'config'`) and — if provided — seed
 * conversion linker and cross-domain `linker` params. This runs through
 * the dataLayer shim, so calls made before `gtag.js` finishes loading are
 * replayed automatically once the script boots.
 */
export declare function installGtagConfigs(gtag: GtagFn, options: GtagLoaderOptions): void;
/**
 * Derive loader options from the server-provided feature config.
 *
 * There are exactly two proxy resolutions:
 *
 * | proxyMode  | base                                              | path  |
 * | ---------- | ------------------------------------------------- | ----- |
 * | `proxied`  | `api_host` verbatim (or `location.origin`)        | `/gt` |
 * | `direct`   | `https://www.googletagmanager.com`                | `""`  |
 *
 * In proxied mode `api_host` is treated as a verbatim URL prefix — matching
 * how the rest of the SDK builds URLs (`capture`, array loader, chat). It
 * may be any of:
 *
 *   - a full URL with a path, e.g. `https://proxy.example.com/v1`
 *   - a bare origin, e.g. `https://proxy.example.com`
 *   - a relative path, e.g. `/vt` (first-party reverse proxy)
 *
 * For `transport_url` we still need an absolute URL, so a relative
 * `api_host` is expanded against `window.location.origin` in that one
 * place. The loader `<script>` `src` itself keeps the original relative
 * form and is resolved by the browser against the document.
 *
 * Customers who self-host a proxy simply point `api_host` at it — the
 * proxy must implement `/gt/*` under that prefix.
 */
export declare function buildLoaderOptions(config: GoogleTagClientConfig, apiHost: string | undefined): GtagLoaderOptions | null;