@nuxt/scripts 1.0.0-beta.7 → 1.0.0-rc.10

package/dist/runtime/composables/useScript.js

@@ -1,9 +1,111 @@
-import { defu } from "defu";
+import { resolveTrigger } from "#build/nuxt-scripts-trigger-resolver";
 import { useScript as _useScript } from "@unhead/vue/scripts";
-import { reactive, ref } from "vue";
-import { onNuxtReady, useNuxtApp, useRuntimeConfig, injectHead, useHead } from "nuxt/app";
+import { defu } from "defu";
+import { injectHead, onNuxtReady, useHead, useNuxtApp, useRuntimeConfig } from "nuxt/app";
+import { markRaw, ref } from "vue";
 import { logger } from "../logger.js";
-import { resolveTrigger } from "#build/nuxt-scripts-trigger-resolver";
+function resolveProxyPrefix() {
+  const devtoolsConfig = useRuntimeConfig().public["nuxt-scripts-devtools"];
+  return devtoolsConfig?.proxyPrefix || "/_scripts/p";
+}
+function toNetworkRequest(entry, proxyPrefix) {
+  const isProxied = entry.name.includes(`${proxyPrefix}/`);
+  return {
+    url: entry.name,
+    startTime: entry.startTime,
+    duration: entry.duration,
+    transferSize: entry.transferSize,
+    encodedBodySize: entry.encodedBodySize,
+    decodedBodySize: entry.decodedBodySize,
+    initiatorType: entry.initiatorType,
+    dns: entry.domainLookupEnd - entry.domainLookupStart,
+    connect: entry.connectEnd - entry.connectStart,
+    ssl: entry.secureConnectionStart > 0 ? entry.connectEnd - entry.secureConnectionStart : 0,
+    ttfb: entry.responseStart - entry.requestStart,
+    download: entry.responseEnd - entry.responseStart,
+    isProxied
+  };
+}
+function createDomainMatcher(domains, proxyPrefix, scriptSrc) {
+  const localHostname = window.location.hostname;
+  const scriptUrl = (() => {
+    if (!scriptSrc)
+      return "";
+    try {
+      return new URL(scriptSrc, window.location.origin).href;
+    } catch {
+      return "";
+    }
+  })();
+  return function matchesScript(entry) {
+    try {
+      const entryUrl = new URL(entry.name, window.location.origin);
+      if (scriptUrl && entryUrl.href === scriptUrl)
+        return true;
+      if (entryUrl.hostname !== localHostname && domains.has(entryUrl.hostname))
+        return true;
+      const proxyPath = `${proxyPrefix}/`;
+      const proxyIdx = entryUrl.pathname.indexOf(proxyPath);
+      if (proxyIdx !== -1) {
+        const afterPrefix = entryUrl.pathname.slice(proxyIdx + proxyPath.length);
+        const proxyDomain = afterPrefix.split("/")[0];
+        if (proxyDomain && domains.has(proxyDomain))
+          return true;
+      }
+    } catch {
+    }
+    return false;
+  };
+}
+function observeNetworkRequests(payload, domains, onUpdate, scriptSrc) {
+  if (typeof PerformanceObserver === "undefined")
+    return () => {
+    };
+  const proxyPrefix = resolveProxyPrefix();
+  const matchesScript = createDomainMatcher(domains, proxyPrefix, scriptSrc);
+  const seen = /* @__PURE__ */ new Set();
+  function entryKey(entry) {
+    return `${entry.name}@${entry.startTime}`;
+  }
+  function processEntry(entry) {
+    const key = entryKey(entry);
+    if (seen.has(key))
+      return false;
+    if (!matchesScript(entry))
+      return false;
+    seen.add(key);
+    payload.networkRequests.push(toNetworkRequest(entry, proxyPrefix));
+    return true;
+  }
+  for (const entry of performance.getEntriesByType("resource"))
+    processEntry(entry);
+  const observer = new PerformanceObserver((list) => {
+    let added = false;
+    for (const entry of list.getEntries()) {
+      if (processEntry(entry))
+        added = true;
+    }
+    if (added)
+      onUpdate();
+  });
+  observer.observe({ type: "resource", buffered: false });
+  return () => observer.disconnect();
+}
+function extractExternalHostname(src) {
+  if (!src)
+    return "";
+  try {
+    const hostname = new URL(src, window.location.origin).hostname;
+    return hostname === window.location.hostname ? "" : hostname;
+  } catch {
+    return "";
+  }
+}
+function ensureScripts(nuxtApp) {
+  if (!nuxtApp.$scripts) {
+    nuxtApp.$scripts = {};
+  }
+}
 function useNuxtScriptRuntimeConfig() {
   return useRuntimeConfig().public["nuxt-scripts"];
 }
@@ -22,16 +124,44 @@ export function useScript(input, options) {
       script: [{ src, type: "text/partytown" }]
     });
     const nuxtApp2 = useNuxtApp();
-    nuxtApp2.$scripts = nuxtApp2.$scripts || reactive({});
+    ensureScripts(nuxtApp2);
     const status = ref("loaded");
+    let disconnectObserver = () => {
+    };
     const stub = {
       id: src,
       status,
       load: () => Promise.resolve({}),
-      remove: () => false,
+      remove: () => {
+        disconnectObserver();
+        return false;
+      },
       entry: void 0
     };
     nuxtApp2.$scripts[src] = stub;
+    if (import.meta.dev && import.meta.client) {
+      let syncScripts = function() {
+        nuxtApp2._scripts[src] = payload;
+        nuxtApp2.hooks.callHook("scripts:updated", { scripts: nuxtApp2._scripts });
+      };
+      nuxtApp2._scripts = nuxtApp2._scripts || {};
+      const scriptHostname = extractExternalHostname(src);
+      const domains = /* @__PURE__ */ new Set([
+        ...scriptHostname ? [scriptHostname] : [],
+        ...options.devtools?.domains || []
+      ]);
+      const payload = {
+        ...options.devtools,
+        src,
+        $script: stub,
+        events: [
+          { type: "status", status: "loaded", at: Date.now() }
+        ],
+        networkRequests: []
+      };
+      disconnectObserver = observeNetworkRequests(payload, domains, syncScripts, src);
+      syncScripts();
+    }
     return stub;
   }
   if (import.meta.dev && options.bundle === "unsupported") {
@@ -50,7 +180,7 @@ export function useScript(input, options) {
   if (!options.head) {
     throw new Error("useScript() has been called without Nuxt context.");
   }
-  nuxtApp.$scripts = nuxtApp.$scripts || reactive({});
+  ensureScripts(nuxtApp);
   const exists = !!nuxtApp.$scripts?.[id];
   const err = options._validate?.();
   if (import.meta.dev && import.meta.client && err) {
@@ -109,7 +239,8 @@ export function useScript(input, options) {
       ...options.devtools,
       src: input.src,
       $script: null,
-      events: []
+      events: [],
+      networkRequests: []
     };
     nuxtApp._scripts = nuxtApp._scripts || {};
     if (!nuxtApp._scripts[instance.id]) {
@@ -149,8 +280,28 @@ export function useScript(input, options) {
         trigger: options?.trigger,
         at: Date.now()
       });
+      const scriptHostname = extractExternalHostname(input.src);
+      const domains = /* @__PURE__ */ new Set([
+        ...scriptHostname ? [scriptHostname] : [],
+        ...options.devtools?.domains || []
+      ]);
+      let disconnectObserver = observeNetworkRequests(payload, domains, syncScripts, input.src);
+      const _origRemove = instance.remove;
+      const _origReload = instance.reload;
+      instance.remove = () => {
+        disconnectObserver();
+        return _origRemove();
+      };
+      instance.reload = async () => {
+        disconnectObserver();
+        const result = await _origReload();
+        disconnectObserver = observeNetworkRequests(payload, domains, syncScripts, input.src);
+        return result;
+      };
       syncScripts();
     }
   }
+  markRaw(instance);
+  instance.toJSON = () => ({ id: instance.id, status: instance.status.value });
   return instance;
 }

package/dist/runtime/composables/useScriptEventPage.js

@@ -1,5 +1,5 @@
-import { useNuxtApp, useRoute, injectHead } from "nuxt/app";
-import { ref, onScopeDispose } from "vue";
+import { injectHead, useNuxtApp, useRoute } from "nuxt/app";
+import { onScopeDispose, ref } from "vue";
 export function useScriptEventPage(onChange) {
   const nuxt = useNuxtApp();
   const route = useRoute();

package/dist/runtime/composables/useScriptProxyToken.d.ts

@@ -0,0 +1,12 @@
+export interface ScriptProxyToken {
+    token: string;
+    ts: number;
+}
+/**
+ * Shared `useState` holding the proxy page token emitted during SSR.
+ *
+ * Populated by the `nuxt-scripts:proxy-token` server plugin when
+ * `runtimeConfig['nuxt-scripts'].proxySecret` is set, and hydrated to the
+ * client via the Nuxt payload. Stays null when signing is disabled.
+ */
+export declare function useScriptProxyToken(): import("vue").Ref<ScriptProxyToken | null, ScriptProxyToken | null>;

package/dist/runtime/composables/useScriptProxyToken.js

@@ -0,0 +1,4 @@
+import { useState } from "nuxt/app";
+export function useScriptProxyToken() {
+  return useState("nuxt-scripts:proxy-token", () => null);
+}

package/dist/runtime/composables/useScriptProxyUrl.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Build proxy URLs that the server's `withSigning` middleware accepts.
+ *
+ * Attaches the page token emitted during SSR (`_pt` + `_ts`) when one is
+ * available, so client-driven proxy calls (e.g. reactive fetches, dynamic
+ * image helpers exposed in slot props) authenticate without needing a
+ * server round-trip to sign each URL.
+ *
+ * When no token is present (signing disabled or no secret), emits plain
+ * `?url=...` URLs, matching the pre-signing behavior.
+ */
+export declare function useScriptProxyUrl(): (path: string, query?: Record<string, unknown>) => string;

package/dist/runtime/composables/useScriptProxyUrl.js

@@ -0,0 +1,27 @@
+import { PAGE_TOKEN_PARAM, PAGE_TOKEN_TS_PARAM } from "../server/utils/sign-constants.js";
+import { useScriptProxyToken } from "./useScriptProxyToken.js";
+export function useScriptProxyUrl() {
+  const token = useScriptProxyToken();
+  return (path, query = {}) => {
+    const parts = [];
+    for (const [key, value] of Object.entries(query)) {
+      if (value === void 0 || value === null)
+        continue;
+      const encodedKey = encodeURIComponent(key);
+      if (Array.isArray(value)) {
+        for (const item of value) {
+          if (item === void 0 || item === null)
+            continue;
+          parts.push(`${encodedKey}=${encodeURIComponent(String(item))}`);
+        }
+      } else {
+        parts.push(`${encodedKey}=${encodeURIComponent(String(value))}`);
+      }
+    }
+    if (token.value) {
+      parts.push(`${PAGE_TOKEN_PARAM}=${encodeURIComponent(token.value.token)}`);
+      parts.push(`${PAGE_TOKEN_TS_PARAM}=${token.value.ts}`);
+    }
+    return parts.length ? `${path}?${parts.join("&")}` : path;
+  };
+}

package/dist/runtime/composables/useScriptTriggerConsent.d.ts

@@ -1,12 +1,22 @@
+import type { Ref } from 'vue';
 import type { ConsentScriptTriggerOptions } from '../types.js';
 interface UseConsentScriptTriggerApi extends Promise<void> {
     /**
      * A function that can be called to accept the consent and load the script.
      */
     accept: () => void;
+    /**
+     * A function that can be called to revoke consent and signal the script should be unloaded.
+     */
+    revoke: () => void;
+    /**
+     * Reactive reference to the consent state
+     */
+    consented: Ref<boolean>;
 }
 /**
  * Load a script once consent has been provided either through a resolvable `consent` or calling the `accept` method.
+ * Supports revoking consent via the reactive `consented` ref. Consumers should watch `consented` to react to revocation.
  * @param options
  */
 export declare function useScriptTriggerConsent(options?: ConsentScriptTriggerOptions): UseConsentScriptTriggerApi;

package/dist/runtime/composables/useScriptTriggerConsent.js

@@ -1,14 +1,37 @@
+import { onNuxtReady, requestIdleCallback, tryUseNuxtApp } from "nuxt/app";
 import { isRef, ref, toValue, watch } from "vue";
-import { tryUseNuxtApp, onNuxtReady, requestIdleCallback } from "nuxt/app";
 export function useScriptTriggerConsent(options) {
-  if (import.meta.server)
-    return new Promise(() => {
+  if (import.meta.server) {
+    const p = new Promise(() => {
     });
+    p.accept = () => {
+    };
+    p.revoke = () => {
+    };
+    p.consented = ref(false);
+    return p;
+  }
   const consented = ref(false);
   const nuxtApp = tryUseNuxtApp();
+  if (options?.consent) {
+    if (isRef(options?.consent)) {
+      watch(options.consent, (_val) => {
+        const val = toValue(_val);
+        consented.value = Boolean(val);
+      }, { immediate: true });
+    } else if (typeof options?.consent === "boolean") {
+      consented.value = options?.consent;
+    } else if (options?.consent instanceof Promise) {
+      options.consent.then((res) => {
+        consented.value = typeof res === "boolean" ? res : true;
+      }).catch(() => {
+        consented.value = false;
+      });
+    }
+  }
   const promise = new Promise((resolve) => {
-    watch(consented, (ready) => {
-      if (ready) {
+    watch(consented, (newValue, oldValue) => {
+      if (newValue && !oldValue) {
         const runner = nuxtApp?.runWithContext || ((cb) => cb());
         if (options?.postConsentTrigger instanceof Promise) {
           options.postConsentTrigger.then(() => runner(resolve));
@@ -32,24 +55,14 @@ export function useScriptTriggerConsent(options) {
         }
         runner(resolve);
       }
-    });
-    if (options?.consent) {
-      if (isRef(options?.consent)) {
-        watch(options.consent, (_val) => {
-          const val = toValue(_val);
-          consented.value = Boolean(val);
-        }, { immediate: true });
-      } else if (typeof options?.consent === "boolean") {
-        consented.value = options?.consent;
-      } else if (options?.consent instanceof Promise) {
-        options?.consent.then((res) => {
-          consented.value = typeof res === "boolean" ? res : true;
-        });
-      }
-    }
+    }, { immediate: true });
   });
   promise.accept = () => {
     consented.value = true;
   };
+  promise.revoke = () => {
+    consented.value = false;
+  };
+  promise.consented = consented;
   return promise;
 }

package/dist/runtime/composables/useScriptTriggerElement.js

@@ -2,7 +2,7 @@ import {
   useEventListener,
   useIntersectionObserver
 } from "@vueuse/core";
-import { tryOnScopeDispose, tryOnMounted } from "@vueuse/shared";
+import { tryOnMounted, tryOnScopeDispose } from "@vueuse/shared";
 import { watch } from "vue";
 function useElementVisibilityPromise(element) {
   let observer;

package/dist/runtime/composables/useScriptTriggerIdleTimeout.js

@@ -1,5 +1,5 @@
-import { tryOnScopeDispose } from "@vueuse/shared";
 import { useTimeoutFn } from "@vueuse/core";
+import { tryOnScopeDispose } from "@vueuse/shared";
 import { onNuxtReady } from "nuxt/app";
 export function useScriptTriggerIdleTimeout(options) {
   if (import.meta.server) {

package/dist/runtime/devtools-standalone-bridge.client.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Dev-only client plugin that bridges script state to the standalone devtools API.
+ * When `_standaloneDevtools` is enabled, this plugin listens for `scripts:updated`
+ * and POSTs a serializable snapshot of script state to `/__nuxt-scripts-api/state`.
+ * Also syncs the current route path so standalone devtools can show which page the user is on.
+ */
+declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/devtools-standalone-bridge.client.js

@@ -0,0 +1,50 @@
+import { defineNuxtPlugin, useNuxtApp, useRuntimeConfig } from "nuxt/app";
+export default defineNuxtPlugin(() => {
+  const nuxtApp = useNuxtApp();
+  const config = useRuntimeConfig();
+  const version = config.public["nuxt-scripts"]?.version;
+  const firstPartyData = config.public["nuxt-scripts-devtools"] || null;
+  let lastScripts = {};
+  function pushState(scripts) {
+    if (scripts)
+      lastScripts = scripts;
+    const route = nuxtApp.$router?.currentRoute?.value;
+    if (route?.path?.startsWith("/__nuxt-scripts"))
+      return;
+    fetch("/__nuxt-scripts-api/state", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        scripts: serializeScripts(lastScripts),
+        version,
+        firstPartyData,
+        route: route ? { path: route.path, fullPath: route.fullPath, query: route.query } : null
+      })
+    }).catch(() => {
+    });
+  }
+  nuxtApp.hooks.hook("scripts:updated", (ctx) => {
+    pushState(ctx.scripts);
+  });
+  nuxtApp.$router?.afterEach(() => {
+    pushState();
+  });
+  pushState(nuxtApp._scripts || {});
+});
+function serializeScripts(scripts) {
+  const result = {};
+  for (const [key, script] of Object.entries(scripts)) {
+    result[key] = {
+      src: script.src,
+      key: script.key,
+      registryKey: script.registryKey,
+      registryMeta: script.registryMeta,
+      loadedFrom: script.loadedFrom && script.loadedFrom !== "unknown" ? script.loadedFrom : void 0,
+      events: script.events,
+      networkRequests: script.networkRequests,
+      // Serialize $script status as a plain string (methods won't transfer)
+      $script: script.$script ? { status: typeof script.$script.status === "object" ? script.$script.status.value : script.$script.status } : { status: "unknown" }
+    };
+  }
+  return result;
+}

package/dist/runtime/plugins/proxy-token.server.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Emit a per-request proxy page token into the SSR payload.
+ *
+ * The token authorizes client-side proxy calls (`/embed/x-image?url=...`,
+ * `/embed/bluesky?url=...`, etc.) without needing each URL to be signed
+ * ahead of time. It stays null when no proxy secret is configured, in
+ * which case `withSigning` passes requests through unchecked.
+ */
+declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/plugins/proxy-token.server.js

@@ -0,0 +1,17 @@
+import { defineNuxtPlugin, useRuntimeConfig } from "nuxt/app";
+import { useScriptProxyToken } from "../composables/useScriptProxyToken.js";
+import { generateProxyToken } from "../server/utils/sign.js";
+export default defineNuxtPlugin({
+  name: "nuxt-scripts:proxy-token",
+  enforce: "pre",
+  setup() {
+    const secret = useRuntimeConfig()["nuxt-scripts"]?.proxySecret;
+    if (!secret)
+      return;
+    const ts = Math.floor(Date.now() / 1e3);
+    useScriptProxyToken().value = {
+      token: generateProxyToken(secret, ts),
+      ts
+    };
+  }
+});

package/dist/runtime/registry/bing-uet.d.ts

@@ -0,0 +1,198 @@
+import type { RegistryScriptInput, UseScriptContext } from '#nuxt-scripts/types';
+import { BingUetOptions } from './schemas.js';
+export { BingUetOptions };
+export type BingUetInput = RegistryScriptInput<typeof BingUetOptions, true, false>;
+export type BingUetConsentStatus = 'granted' | 'denied';
+export interface BingUetConsentOptions {
+    /**
+     * Controls storage of advertising identifiers. Currently the only field UET honors.
+     */
+    ad_storage?: BingUetConsentStatus;
+}
+export type BingUetEventName = 'page_view' | 'screen_view' | 'login' | 'sign_up' | 'subscribe' | 'start_trial' | 'lead' | 'generate_lead' | 'submit_lead_form' | 'contact' | 'search' | 'view_search_results' | 'select_content' | 'share' | 'exception' | 'find_location' | 'book_appointment' | 'get_route' | 'view_item' | 'view_item_list' | 'view_promotion' | 'add_to_cart' | 'remove_from_cart' | 'add_to_wishlist' | 'add_payment_info' | 'begin_checkout' | 'checkout_progress' | 'set_checkout_option' | 'purchase' | 'refund' | (string & {});
+export interface BingUetItem {
+    id?: string;
+    name?: string;
+    brand?: string;
+    category?: string;
+    variant?: string;
+    price?: number;
+    quantity?: number;
+    list_name?: string;
+    list_position?: number;
+    creative_name?: string;
+    creative_slot?: string;
+    location_id?: string;
+    [key: string]: any;
+}
+export interface BingUetPromotion {
+    id?: string;
+    name?: string;
+    creative_name?: string;
+    creative_slot?: string;
+    [key: string]: any;
+}
+export interface BingUetEventParams {
+    /** Event category (beacon shortcut). */
+    ec?: string;
+    /** Event action (beacon shortcut). */
+    ea?: string;
+    /** Event label (beacon shortcut). */
+    el?: string;
+    /** Event value, numeric (beacon shortcut). */
+    ev?: number;
+    /** Goal category / goal completion. */
+    gc?: string;
+    /** Goal value. */
+    gv?: number;
+    /** Long-form alias for `ec`. */
+    event_category?: string;
+    /** Long-form alias for `ea`. */
+    event_action?: string;
+    /** Long-form alias for `el`. */
+    event_label?: string;
+    /** Long-form alias for `ev`. */
+    event_value?: number;
+    /** Unique event identifier (dedup). */
+    event_id?: string;
+    /** Variable revenue amount. */
+    revenue_value?: number;
+    /** ISO 4217 currency code (e.g. "USD"). */
+    currency?: string;
+    /** Unique order/transaction ID (dedup). */
+    transaction_id?: string;
+    /** Ecommerce items. */
+    items?: BingUetItem[];
+    /** Promotions associated with the event. */
+    promotions?: BingUetPromotion[];
+    /** Sign-up/login method (e.g. "Google"). */
+    method?: string;
+    coupon?: string;
+    tax?: number;
+    shipping?: number;
+    affiliation?: string;
+    /** Search query. */
+    search_term?: string;
+    content_type?: string;
+    content_id?: string;
+    checkout_step?: number;
+    checkout_option?: string;
+    description?: string;
+    name?: string;
+    screen_name?: string;
+    /** Whether an exception is fatal. */
+    fatal?: boolean;
+    /** Flags a new customer conversion. */
+    new_customer?: boolean | number;
+    /** Retail vertical: product ID. */
+    ecomm_prodid?: string | string[];
+    /** Retail vertical: page type. */
+    ecomm_pagetype?: 'home' | 'searchresults' | 'category' | 'product' | 'cart' | 'purchase' | 'other' | (string & {});
+    ecomm_totalvalue?: number;
+    ecomm_category?: string | string[];
+    ecomm_query?: string;
+    /** Override page path. */
+    page_path?: string;
+    /** Override page title. */
+    page_title?: string;
+    /** Override full page URL. */
+    page_location?: string;
+    [key: string]: any;
+}
+export interface BingUetEnhancedConversionsPid {
+    /** SHA-256 hashed email (lowercase, trimmed). Alias: `email`. */
+    em?: string;
+    /** SHA-256 hashed phone (E.164 digits only). Alias: `phone_number`. */
+    ph?: string;
+    /** Long-form alias for `em`. */
+    email?: string;
+    /** Long-form alias for `ph`. */
+    phone_number?: string;
+    [key: string]: any;
+}
+export interface BingUetSetParams {
+    /** Partner identifiers for enhanced conversions. */
+    pid?: BingUetEnhancedConversionsPid;
+    page_path?: string;
+    page_title?: string;
+    page_location?: string;
+    [key: string]: any;
+}
+export interface BingUetTcfConfig {
+    /** Enable TCF v2.0 auto-consent handling (Microsoft vendorId 1126). */
+    enabled?: boolean;
+    [key: string]: any;
+}
+export interface BingUetConstructorOptions {
+    /** UET tag ID. */
+    ti: string;
+    /** Alternate tag ID field (same effect as `ti`). */
+    tagId?: string;
+    /** Auto-fire pageLoad on SPA route changes. */
+    enableAutoSpaTracking?: boolean;
+    /** Enable TCF v2.0 auto-consent handling. */
+    enableAutoConsent?: boolean;
+    /** Suppress automatic page_view on load. */
+    disableAutoPageView?: boolean;
+    /** Disable the UET container entirely. */
+    disableContainer?: boolean;
+    /** Disable writing the UET visitor ID cookie. */
+    disableUetVid?: boolean;
+    /** Disable visibility (tab focus/blur) events. */
+    disableVisibilityEvents?: boolean;
+    /** Defer loading the beacon. */
+    deferLoad?: boolean;
+    /** Strip query strings from reported URLs. */
+    removeQueryFromUrls?: boolean;
+    /** Store conversion tracking cookies. */
+    storeConvTrackCookies?: boolean;
+    /** Cookie domain. */
+    cookieDomain?: string;
+    /** Cookie flags (e.g. "SameSite=None; Secure"). */
+    cookieFlags?: string;
+    /** Enable MS DNS cookie. */
+    msDnsCookie?: boolean;
+    /** UID cookie name. */
+    uidCookie?: string;
+    /** Error beacon verbosity level. */
+    errorBeaconLevel?: number;
+    /** Microsoft Clarity project ID for integration. */
+    clarityProjectId?: string;
+    /** When true, reads `window.enhanced_conversion_data` for gtag-style enhanced conversions. */
+    gtagPid?: boolean;
+    /** Beacon protocol version. */
+    Ver?: 1 | 2;
+    /** Associated advertiser ID. */
+    advertiserId?: string;
+    /** Source tag for GTM integration. */
+    gtmTagSource?: string;
+    /** Queue reference, typically `window.uetq`. */
+    q?: any[];
+    [key: string]: any;
+}
+export interface BingUetQueue {
+    push: {
+        (event: BingUetEventParams): void;
+        (command: 'pageLoad'): void;
+        (command: 'event', eventName: BingUetEventName, eventParams?: BingUetEventParams): void;
+        (command: 'consent', action: 'default' | 'update', consentParams: BingUetConsentOptions): void;
+        (command: 'set', params: BingUetSetParams): void;
+        (command: 'config', target: 'tcf', params: BingUetTcfConfig): void;
+    };
+}
+export interface BingUetApi {
+    uetq: BingUetQueue;
+}
+declare global {
+    interface Window {
+        UET: new (options: BingUetConstructorOptions) => BingUetQueue;
+        uetq: any[] | BingUetQueue;
+    }
+}
+export interface BingUetConsent {
+    /** Push `['consent','update', state]` with the `ad_storage` signal. */
+    update: (state: BingUetConsentOptions) => void;
+}
+export declare function useScriptBingUet<T extends BingUetApi>(_options?: BingUetInput & {
+    onBeforeUetStart?: (uetq: BingUetQueue) => void;
+}): UseScriptContext<T, BingUetConsent>;