@nuxt/scripts 1.0.0-rc.9 → 1.0.0

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

@@ -1,4 +1,4 @@
-import type { RegistryScriptInput } from '#nuxt-scripts/types';
+import type { RegistryScriptInput, UseScriptContext } from '#nuxt-scripts/types';
 import { BingUetOptions } from './schemas.js';
 export { BingUetOptions };
 export type BingUetInput = RegistryScriptInput<typeof BingUetOptions, true, false>;
@@ -189,6 +189,10 @@ declare global {
         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;
-}): import("#nuxt-scripts/types").UseScriptContext<T>;
+}): UseScriptContext<T, BingUetConsent>;

package/dist/runtime/registry/bing-uet.js

@@ -2,7 +2,7 @@ import { useRegistryScript } from "../utils.js";
 import { BingUetOptions } from "./schemas.js";
 export { BingUetOptions };
 export function useScriptBingUet(_options) {
-  return useRegistryScript("bingUet", (options) => ({
+  const instance = useRegistryScript("bingUet", (options) => ({
     scriptInput: {
       src: "https://bat.bing.com/bat.js",
       crossorigin: false
@@ -25,7 +25,19 @@ export function useScriptBingUet(_options) {
     clientInit: import.meta.server ? void 0 : () => {
       const uetq = window.uetq || [];
       window.uetq = uetq;
+      if (options?.defaultConsent) {
+        uetq.push("consent", "default", options.defaultConsent);
+      }
       _options?.onBeforeUetStart?.(uetq);
     }
   }), _options);
+  if (import.meta.client && !instance.consent) {
+    instance.consent = {
+      update: (state) => {
+        ;
+        instance.proxy.uetq.push("consent", "update", state);
+      }
+    };
+  }
+  return instance;
 }

package/dist/runtime/registry/bluesky-embed.d.ts

@@ -98,10 +98,6 @@ export declare function extractBlueskyPostId(url: string): {
     actor: string;
     rkey: string;
 } | undefined;
-/**
- * Proxy a Bluesky image URL through the server
- */
-export declare function proxyBlueskyImageUrl(url: string, proxyEndpoint?: string): string;
 /**
  * Format a Bluesky post date for display
  */

package/dist/runtime/registry/bluesky-embed.js

@@ -7,10 +7,6 @@ export function extractBlueskyPostId(url) {
     return void 0;
   return { actor: match[1], rkey: match[2] };
 }
-export function proxyBlueskyImageUrl(url, proxyEndpoint = "/_scripts/embed/bluesky-image") {
-  const separator = proxyEndpoint.includes("?") ? "&" : "?";
-  return `${proxyEndpoint}${separator}url=${encodeURIComponent(url)}`;
-}
 export function formatBlueskyDate(dateString) {
   const date = new Date(dateString);
   const time = date.toLocaleString("en-US", {

package/dist/runtime/registry/clarity.d.ts

@@ -1,4 +1,4 @@
-import type { RegistryScriptInput } from '#nuxt-scripts/types';
+import type { RegistryScriptInput, UseScriptContext } from '#nuxt-scripts/types';
 import { ClarityOptions } from './schemas.js';
 export { ClarityOptions };
 type ClarityFunctions = ((fn: 'start', options?: {
@@ -25,4 +25,8 @@ declare global {
     }
 }
 export type ClarityInput = RegistryScriptInput<typeof ClarityOptions>;
-export declare function useScriptClarity<T extends ClarityApi>(_options?: ClarityInput): import("#nuxt-scripts/types").UseScriptContext<T>;
+export interface ClarityConsent {
+    /** Call `clarity('consent', value)` with either a boolean (default) or Clarity's advanced vector. */
+    set: (value: boolean | Record<string, string>) => void;
+}
+export declare function useScriptClarity<T extends ClarityApi>(_options?: ClarityInput): UseScriptContext<T, ClarityConsent>;

package/dist/runtime/registry/clarity.js

@@ -2,7 +2,7 @@ import { useRegistryScript } from "../utils.js";
 import { ClarityOptions } from "./schemas.js";
 export { ClarityOptions };
 export function useScriptClarity(_options) {
-  return useRegistryScript("clarity", (options) => ({
+  const instance = useRegistryScript("clarity", (options) => ({
     scriptInput: {
       src: `https://www.clarity.ms/tag/${options.id}`
     },
@@ -22,6 +22,17 @@ export function useScriptClarity(_options) {
       window.clarity = window.clarity || function(...params) {
         (window.clarity.q = window.clarity.q || []).push(params);
       };
+      if (options?.defaultConsent !== void 0)
+        window.clarity("consent", options.defaultConsent);
     }
   }), _options);
+  if (import.meta.client && !instance.consent) {
+    instance.consent = {
+      set: (value) => {
+        ;
+        instance.proxy.clarity("consent", value);
+      }
+    };
+  }
+  return instance;
 }

package/dist/runtime/registry/google-analytics.d.ts

@@ -1,4 +1,4 @@
-import type { RegistryScriptInput } from '#nuxt-scripts/types';
+import type { ConsentState, RegistryScriptInput, UseScriptContext } from '#nuxt-scripts/types';
 import { GoogleAnalyticsOptions } from './schemas.js';
 export type GtagCustomParams = Record<string, any>;
 export type ConsentStatus = 'granted' | 'denied';
@@ -58,6 +58,10 @@ export interface GoogleAnalyticsApi {
 }
 export { GoogleAnalyticsOptions };
 export type GoogleAnalyticsInput = RegistryScriptInput<typeof GoogleAnalyticsOptions>;
+export interface GoogleAnalyticsConsent {
+    /** Send `gtag('consent','update', state)` with GCMv2 partial state. */
+    update: (state: ConsentState) => void;
+}
 export declare function useScriptGoogleAnalytics<T extends GoogleAnalyticsApi>(_options?: GoogleAnalyticsInput & {
     onBeforeGtagStart?: (gtag: GTag) => void;
-}): import("#nuxt-scripts/types").UseScriptContext<T>;
+}): UseScriptContext<T, GoogleAnalyticsConsent>;

package/dist/runtime/registry/google-analytics.js

@@ -3,7 +3,7 @@ import { withQuery } from "ufo";
 import { GoogleAnalyticsOptions } from "./schemas.js";
 export { GoogleAnalyticsOptions };
 export function useScriptGoogleAnalytics(_options) {
-  return useRegistryScript(_options?.key || "googleAnalytics", (options) => {
+  const instance = useRegistryScript(_options?.key || "googleAnalytics", (options) => {
     const dataLayerName = options?.l ?? "dataLayer";
     const w = import.meta.client ? window : {};
     return {
@@ -24,6 +24,8 @@ export function useScriptGoogleAnalytics(_options) {
         w.gtag = function() {
           w[dataLayerName].push(arguments);
         };
+        if (options?.defaultConsent)
+          w.gtag("consent", "default", options.defaultConsent);
         _options?.onBeforeGtagStart?.(w.gtag);
         w.gtag("js", /* @__PURE__ */ new Date());
         if (options?.id) {
@@ -32,4 +34,13 @@ export function useScriptGoogleAnalytics(_options) {
       }
     };
   }, _options);
+  if (import.meta.client && !instance.consent) {
+    instance.consent = {
+      update: (state) => {
+        ;
+        instance.proxy.gtag("consent", "update", state);
+      }
+    };
+  }
+  return instance;
 }

package/dist/runtime/registry/google-tag-manager.d.ts

@@ -1,4 +1,4 @@
-import type { NuxtUseScriptOptions, RegistryScriptInput, UseFunctionType, UseScriptContext } from '#nuxt-scripts/types';
+import type { ConsentState, NuxtUseScriptOptions, RegistryScriptInput, UseFunctionType, UseScriptContext } from '#nuxt-scripts/types';
 import type { GTag } from './google-analytics.js';
 import { GoogleTagManagerOptions } from './schemas.js';
 /**
@@ -68,6 +68,10 @@ declare global {
 }
 export { GoogleTagManagerOptions };
 export type GoogleTagManagerInput = RegistryScriptInput<typeof GoogleTagManagerOptions>;
+export interface GoogleTagManagerConsent {
+    /** Push `['consent','update', state]` onto dataLayer with GCMv2 partial state. */
+    update: (state: ConsentState) => void;
+}
 /**
  * Hook to use Google Tag Manager in Nuxt applications
  */
@@ -77,4 +81,4 @@ export declare function useScriptGoogleTagManager<T extends GoogleTagManagerApi>
      * Allows for custom initialization or configuration
      */
     onBeforeGtmStart?: (gtag: DataLayerPush) => void;
-}): UseScriptContext<UseFunctionType<NuxtUseScriptOptions<T>, T>>;
+}): UseScriptContext<UseFunctionType<NuxtUseScriptOptions<T>, T>, GoogleTagManagerConsent>;

package/dist/runtime/registry/google-tag-manager.js

@@ -54,5 +54,14 @@ export function useScriptGoogleTagManager(options) {
     if (gtag)
       options.onBeforeGtmStart(gtag);
   }
-  return instance;
+  const typed = instance;
+  if (import.meta.client && !typed.consent) {
+    typed.consent = {
+      update: (state) => {
+        ;
+        typed.proxy.dataLayer.push(["consent", "update", state]);
+      }
+    };
+  }
+  return typed;
 }

package/dist/runtime/registry/gravatar.js

@@ -1,4 +1,5 @@
 import { scriptsPrefix, useRegistryScript } from "#nuxt-scripts/utils";
+import { useScriptProxyUrl } from "../composables/useScriptProxyUrl.js";
 import { GravatarOptions } from "./schemas.js";
 export { GravatarOptions } from "./schemas.js";
 export function useScriptGravatar(_options) {
@@ -6,13 +7,11 @@ export function useScriptGravatar(_options) {
     const size = options?.size ?? 80;
     const defaultImg = options?.default ?? "mp";
     const rating = options?.rating ?? "g";
-    const buildQuery = (overrides) => {
-      const params = new URLSearchParams();
-      params.set("s", String(overrides?.size ?? size));
-      params.set("d", overrides?.default ?? defaultImg);
-      params.set("r", overrides?.rating ?? rating);
-      return params.toString();
-    };
+    const buildQuery = (overrides) => ({
+      s: overrides?.size ?? size,
+      d: overrides?.default ?? defaultImg,
+      r: overrides?.rating ?? rating
+    });
     return {
       scriptInput: {
         src: "https://secure.gravatar.com/js/gprofiles.js"
@@ -21,13 +20,11 @@ export function useScriptGravatar(_options) {
       scriptOptions: {
         use: () => {
           const prefix = scriptsPrefix();
+          const proxyUrl = useScriptProxyUrl();
+          const path = `${prefix}/proxy/gravatar`;
           return {
-            getAvatarUrl: (hash, overrides) => {
-              return `${prefix}/proxy/gravatar?hash=${encodeURIComponent(hash)}&${buildQuery(overrides)}`;
-            },
-            getAvatarUrlFromEmail: (email, overrides) => {
-              return `${prefix}/proxy/gravatar?email=${encodeURIComponent(email)}&${buildQuery(overrides)}`;
-            }
+            getAvatarUrl: (hash, overrides) => proxyUrl(path, { hash, ...buildQuery(overrides) }),
+            getAvatarUrlFromEmail: (email, overrides) => proxyUrl(path, { email, ...buildQuery(overrides) })
           };
         }
       }

package/dist/runtime/registry/matomo-analytics.d.ts

@@ -1,12 +1,18 @@
-import type { RegistryScriptInput } from '#nuxt-scripts/types';
+import type { RegistryScriptInput, UseScriptContext } from '#nuxt-scripts/types';
 import { MatomoAnalyticsOptions } from './schemas.js';
 export { MatomoAnalyticsOptions };
 export type MatomoAnalyticsInput = RegistryScriptInput<typeof MatomoAnalyticsOptions, false, false>;
-interface MatomoAnalyticsApi {
+export interface MatomoAnalyticsApi {
     _paq: unknown[];
 }
 declare global {
     interface Window extends MatomoAnalyticsApi {
     }
 }
-export declare function useScriptMatomoAnalytics<T extends MatomoAnalyticsApi>(_options?: MatomoAnalyticsInput): import("#nuxt-scripts/types").UseScriptContext<T>;
+export interface MatomoConsent {
+    /** Push `setConsentGiven`. Requires `defaultConsent: 'required' | 'given'` at registration to have an effect. */
+    give: () => void;
+    /** Push `forgetConsentGiven`. Requires `defaultConsent: 'required' | 'given'` at registration to have an effect. */
+    forget: () => void;
+}
+export declare function useScriptMatomoAnalytics<T extends MatomoAnalyticsApi>(_options?: MatomoAnalyticsInput): UseScriptContext<T, MatomoConsent>;

package/dist/runtime/registry/matomo-analytics.js

@@ -5,7 +5,7 @@ import { useRegistryScript } from "../utils.js";
 import { MatomoAnalyticsOptions } from "./schemas.js";
 export { MatomoAnalyticsOptions };
 export function useScriptMatomoAnalytics(_options) {
-  return useRegistryScript("matomoAnalytics", (options) => {
+  const instance = useRegistryScript("matomoAnalytics", (options) => {
     const normalizedCloudId = options?.cloudId ? withoutTrailingSlash(withoutProtocol(options.cloudId)) : void 0;
     const origin = options?.matomoUrl ? options.matomoUrl : `https://cdn.matomo.cloud/${normalizedCloudId}/`;
     const _paq = import.meta.client ? window._paq = window._paq || [] : [];
@@ -30,6 +30,12 @@ export function useScriptMatomoAnalytics(_options) {
         }
       },
       clientInit: import.meta.server ? void 0 : () => {
+        if (options?.defaultConsent === "required") {
+          _paq.push(["requireConsent"]);
+        } else if (options?.defaultConsent === "given") {
+          _paq.push(["requireConsent"]);
+          _paq.push(["setConsentGiven"]);
+        }
         if (options?.enableLinkTracking) {
           _paq.push(["enableLinkTracking"]);
         }
@@ -59,4 +65,25 @@ export function useScriptMatomoAnalytics(_options) {
       }
     };
   }, _options);
+  if (import.meta.client && !instance.consent) {
+    const requiresConsent = _options?.defaultConsent === "required" || _options?.defaultConsent === "given";
+    const warnIfUnsafe = import.meta.dev ? (method) => {
+      if (!requiresConsent) {
+        logger.warn(`matomo consent.${method}() is a no-op unless \`defaultConsent: 'required'\` or \`'given'\` is set at registration.`);
+      }
+    } : () => {
+    };
+    const paq = instance.proxy._paq;
+    instance.consent = {
+      give: () => {
+        warnIfUnsafe("give");
+        paq.push(["setConsentGiven"]);
+      },
+      forget: () => {
+        warnIfUnsafe("forget");
+        paq.push(["forgetConsentGiven"]);
+      }
+    };
+  }
+  return instance;
 }

package/dist/runtime/registry/meta-pixel.d.ts

@@ -1,4 +1,4 @@
-import type { RegistryScriptInput } from '#nuxt-scripts/types';
+import type { RegistryScriptInput, UseScriptContext } from '#nuxt-scripts/types';
 import { MetaPixelOptions } from './schemas.js';
 type StandardEvents = 'AddPaymentInfo' | 'AddToCart' | 'AddToWishlist' | 'CompleteRegistration' | 'Contact' | 'CustomizeProduct' | 'Donate' | 'FindLocation' | 'InitiateCheckout' | 'Lead' | 'Purchase' | 'Schedule' | 'Search' | 'StartTrial' | 'SubmitApplication' | 'Subscribe' | 'ViewContent';
 interface EventObjectProperties {
@@ -38,4 +38,10 @@ declare global {
 }
 export { MetaPixelOptions };
 export type MetaPixelInput = RegistryScriptInput<typeof MetaPixelOptions, true, false>;
-export declare function useScriptMetaPixel<T extends MetaPixelApi>(_options?: MetaPixelInput): import("#nuxt-scripts/types").UseScriptContext<T>;
+export interface MetaPixelConsent {
+    /** Call `fbq('consent','grant')`. */
+    grant: () => void;
+    /** Call `fbq('consent','revoke')`. */
+    revoke: () => void;
+}
+export declare function useScriptMetaPixel<T extends MetaPixelApi>(_options?: MetaPixelInput): UseScriptContext<T, MetaPixelConsent>;

package/dist/runtime/registry/meta-pixel.js

@@ -2,7 +2,7 @@ import { useRegistryScript } from "../utils.js";
 import { MetaPixelOptions } from "./schemas.js";
 export { MetaPixelOptions };
 export function useScriptMetaPixel(_options) {
-  return useRegistryScript("metaPixel", (options) => ({
+  const instance = useRegistryScript("metaPixel", (options) => ({
     scriptInput: {
       src: "https://connect.facebook.net/en_US/fbevents.js",
       crossorigin: false
@@ -27,8 +27,17 @@ export function useScriptMetaPixel(_options) {
       fbq.loaded = true;
       fbq.version = "2.0";
       fbq.queue = [];
+      if (options?.defaultConsent)
+        fbq("consent", options.defaultConsent === "granted" ? "grant" : "revoke");
       fbq("init", options?.id);
       fbq("track", "PageView");
     }
   }), _options);
+  if (import.meta.client && !instance.consent) {
+    instance.consent = {
+      grant: () => instance.proxy.fbq("consent", "grant"),
+      revoke: () => instance.proxy.fbq("consent", "revoke")
+    };
+  }
+  return instance;
 }

package/dist/runtime/registry/mixpanel-analytics.d.ts

@@ -1,4 +1,4 @@
-import type { RegistryScriptInput } from '#nuxt-scripts/types';
+import type { RegistryScriptInput, UseScriptContext } from '#nuxt-scripts/types';
 import { MixpanelAnalyticsOptions } from './schemas.js';
 export { MixpanelAnalyticsOptions };
 export type MixpanelAnalyticsInput = RegistryScriptInput<typeof MixpanelAnalyticsOptions>;
@@ -12,6 +12,10 @@ export interface MixpanelAnalyticsApi {
         };
         register: (properties: Record<string, any>) => void;
         init: (token: string, config?: Record<string, any>) => void;
+        /** Opt the user in to tracking. Available after the real SDK loads. */
+        opt_in_tracking?: () => void;
+        /** Opt the user out of tracking. Available after the real SDK loads. */
+        opt_out_tracking?: () => void;
     };
 }
 declare global {
@@ -19,4 +23,10 @@ declare global {
         mixpanel: MixpanelAnalyticsApi['mixpanel'];
     }
 }
-export declare function useScriptMixpanelAnalytics<T extends MixpanelAnalyticsApi>(_options?: MixpanelAnalyticsInput): import("#nuxt-scripts/types").UseScriptContext<T>;
+export interface MixpanelConsent {
+    /** Call `mixpanel.opt_in_tracking()`. */
+    optIn: () => void;
+    /** Call `mixpanel.opt_out_tracking()`. For boot-time opt-out, use `defaultConsent: 'opt-out'` instead. */
+    optOut: () => void;
+}
+export declare function useScriptMixpanelAnalytics<T extends MixpanelAnalyticsApi>(_options?: MixpanelAnalyticsInput): UseScriptContext<T, MixpanelConsent>;

package/dist/runtime/registry/mixpanel-analytics.js

@@ -1,10 +1,10 @@
 import { useRegistryScript } from "../utils.js";
 import { MixpanelAnalyticsOptions } from "./schemas.js";
 export { MixpanelAnalyticsOptions };
-const methods = ["track", "identify", "reset", "register"];
+const methods = ["track", "identify", "reset", "register", "opt_in_tracking", "opt_out_tracking"];
 const peopleMethods = ["set"];
 export function useScriptMixpanelAnalytics(_options) {
-  return useRegistryScript("mixpanelAnalytics", (options) => {
+  const instance = useRegistryScript("mixpanelAnalytics", (options) => {
     return {
       scriptInput: {
         src: "https://cdn.mxpnl.com/libs/mixpanel-2-latest.min.js"
@@ -38,9 +38,21 @@ export function useScriptMixpanelAnalytics(_options) {
             mp._i.push([token, config, name]);
           };
         }
-        if (options?.token)
-          mp.init(options.token);
+        if (options?.token) {
+          const optOutByDefault = options?.defaultConsent === "opt-out";
+          mp.init(options.token, optOutByDefault ? { opt_out_tracking_by_default: true } : void 0);
+          if (options?.defaultConsent === "opt-in") {
+            mp.opt_in_tracking?.();
+          }
+        }
       }
     };
   }, _options);
+  if (import.meta.client && !instance.consent) {
+    instance.consent = {
+      optIn: () => instance.proxy.mixpanel.opt_in_tracking?.(),
+      optOut: () => instance.proxy.mixpanel.opt_out_tracking?.()
+    };
+  }
+  return instance;
 }

package/dist/runtime/registry/posthog.d.ts

@@ -1,4 +1,4 @@
-import type { RegistryScriptInput } from '#nuxt-scripts/types';
+import type { RegistryScriptInput, UseScriptContext } from '#nuxt-scripts/types';
 import type { PostHog, PostHogConfig } from 'posthog-js';
 import { PostHogOptions } from './schemas.js';
 export { PostHogOptions };
@@ -22,4 +22,10 @@ declare global {
         }[];
     }
 }
-export declare function useScriptPostHog<T extends PostHogApi>(_options?: PostHogInput): import("#nuxt-scripts/types").UseScriptContext<T>;
+export interface PostHogConsent {
+    /** Call `posthog.opt_in_capturing()`. */
+    optIn: () => void;
+    /** Call `posthog.opt_out_capturing()`. For boot-time opt-out, use `defaultConsent: 'opt-out'` instead. */
+    optOut: () => void;
+}
+export declare function useScriptPostHog<T extends PostHogApi>(_options?: PostHogInput): UseScriptContext<T, PostHogConsent>;

package/dist/runtime/registry/posthog.js

@@ -3,7 +3,7 @@ import { useRegistryScript } from "../utils.js";
 import { PostHogOptions } from "./schemas.js";
 export { PostHogOptions };
 export function useScriptPostHog(_options) {
-  return useRegistryScript("posthog", (options) => {
+  const instance = useRegistryScript("posthog", (options) => {
     return {
       scriptMode: "npm",
       // Use NPM mode - no external script tag
@@ -55,13 +55,17 @@ export function useScriptPostHog(_options) {
             config.capture_pageleave = options.capturePageleave;
           if (typeof options?.disableSessionRecording === "boolean")
             config.disable_session_recording = options.disableSessionRecording;
-          const instance = posthog.init(options.apiKey, config);
-          if (!instance) {
+          if (options?.defaultConsent === "opt-out")
+            config.opt_out_capturing_by_default = true;
+          const instance2 = posthog.init(options.apiKey, config);
+          if (!instance2) {
             logger.error("PostHog init returned undefined - initialization failed");
             delete window._posthogQueue;
             return void 0;
           }
-          window.posthog = instance;
+          window.posthog = instance2;
+          if (options?.defaultConsent === "opt-in")
+            instance2.opt_in_capturing?.();
           if (window._posthogQueue && window._posthogQueue.length > 0) {
             window._posthogQueue.forEach((q) => window.posthog[q.prop]?.(...q.args));
             delete window._posthogQueue;
@@ -76,4 +80,11 @@ export function useScriptPostHog(_options) {
       }
     };
   }, _options);
+  if (import.meta.client && !instance.consent) {
+    instance.consent = {
+      optIn: () => instance.proxy.posthog?.opt_in_capturing?.(),
+      optOut: () => instance.proxy.posthog?.opt_out_capturing?.()
+    };
+  }
+  return instance;
 }

package/dist/runtime/registry/schemas.d.ts

@@ -21,6 +21,13 @@ export declare const ClarityOptions: import("valibot").ObjectSchema<{
      * @see https://learn.microsoft.com/en-us/clarity/setup-clarity
      */
     readonly id: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 10, undefined>]>;
+    /**
+     * Default consent state applied before Clarity starts.
+     * - `boolean` - enable / disable cookies.
+     * - `Record<string, string>` - advanced consent vector (see Clarity docs).
+     * @see https://learn.microsoft.com/en-us/clarity/setup-and-installation/cookie-consent
+     */
+    readonly defaultConsent: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").BooleanSchema<undefined>, import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").StringSchema<undefined>, undefined>], undefined>, undefined>;
 }, undefined>;
 export declare const CloudflareWebAnalyticsOptions: import("valibot").ObjectSchema<{
     /**
@@ -267,6 +274,21 @@ export declare const GoogleAnalyticsOptions: import("valibot").ObjectSchema<{
      * @see https://developers.google.com/analytics/devguides/collection/gtagjs/setting-up-gtag#rename_the_data_layer
      */
     readonly l: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    /**
+     * Default GCMv2 consent state fired as `gtag('consent', 'default', ...)` before `gtag('js', ...)`.
+     * @see https://developers.google.com/tag-platform/security/guides/consent
+     */
+    readonly defaultConsent: import("valibot").OptionalSchema<import("valibot").ObjectSchema<{
+        readonly ad_storage: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"granted", undefined>, import("valibot").LiteralSchema<"denied", undefined>], undefined>, undefined>;
+        readonly ad_user_data: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"granted", undefined>, import("valibot").LiteralSchema<"denied", undefined>], undefined>, undefined>;
+        readonly ad_personalization: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"granted", undefined>, import("valibot").LiteralSchema<"denied", undefined>], undefined>, undefined>;
+        readonly analytics_storage: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"granted", undefined>, import("valibot").LiteralSchema<"denied", undefined>], undefined>, undefined>;
+        readonly functionality_storage: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"granted", undefined>, import("valibot").LiteralSchema<"denied", undefined>], undefined>, undefined>;
+        readonly personalization_storage: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"granted", undefined>, import("valibot").LiteralSchema<"denied", undefined>], undefined>, undefined>;
+        readonly security_storage: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"granted", undefined>, import("valibot").LiteralSchema<"denied", undefined>], undefined>, undefined>;
+        readonly wait_for_update: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+        readonly region: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+    }, undefined>, undefined>;
 }, undefined>;
 export declare const GoogleMapsOptions: import("valibot").ObjectSchema<{
     /**
@@ -533,6 +555,14 @@ export declare const MatomoAnalyticsOptions: import("valibot").ObjectSchema<{
      * @default true
      */
     readonly watch: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    /**
+     * Default tracking-consent state applied BEFORE the tracker is initialised.
+     * - `'required'` — call `requireConsent` without granting (user must opt in later).
+     * - `'given'` — call `requireConsent` then `setConsentGiven`.
+     * - `'not-required'` — no consent gating (default Matomo behaviour).
+     * @see https://developer.matomo.org/guides/tracking-consent
+     */
+    readonly defaultConsent: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"required", undefined>, import("valibot").LiteralSchema<"given", undefined>, import("valibot").LiteralSchema<"not-required", undefined>], undefined>, undefined>;
 }, undefined>;
 export declare const MetaPixelOptions: import("valibot").ObjectSchema<{
     /**
@@ -540,6 +570,12 @@ export declare const MetaPixelOptions: import("valibot").ObjectSchema<{
      * @see https://developers.facebook.com/docs/meta-pixel/get-started
      */
     readonly id: import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").NumberSchema<undefined>], undefined>;
+    /**
+     * Default consent state. `'granted'` fires `fbq('consent', 'grant')`,
+     * `'denied'` fires `fbq('consent', 'revoke')`, both called before `fbq('init', id)`.
+     * @see https://www.facebook.com/business/help/1151321516677370
+     */
+    readonly defaultConsent: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"granted", undefined>, import("valibot").LiteralSchema<"denied", undefined>], undefined>, undefined>;
 }, undefined>;
 export declare const NpmOptions: import("valibot").ObjectSchema<{
     /**
@@ -630,6 +666,13 @@ export declare const PostHogOptions: import("valibot").ObjectSchema<{
      * @see https://posthog.com/docs/libraries/js#config
      */
     readonly config: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").AnySchema, undefined>, undefined>;
+    /**
+     * Default capture-consent state for PostHog.
+     * - `'opt-out'`: passed as `opt_out_capturing_by_default: true` to `posthog.init`, so capturing is suppressed from the first event.
+     * - `'opt-in'`: applied after `posthog.init` via `posthog.opt_in_capturing()` on the returned instance.
+     * @see https://posthog.com/docs/privacy/opting-out
+     */
+    readonly defaultConsent: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"opt-in", undefined>, import("valibot").LiteralSchema<"opt-out", undefined>], undefined>, undefined>;
 }, undefined>;
 export declare const RedditPixelOptions: import("valibot").ObjectSchema<{
     /**
@@ -703,6 +746,13 @@ export declare const MixpanelAnalyticsOptions: import("valibot").ObjectSchema<{
      * @see https://docs.mixpanel.com/docs/tracking-methods/sdks/javascript#1-initialize-the-library
      */
     readonly token: import("valibot").StringSchema<undefined>;
+    /**
+     * Default tracking-consent state for Mixpanel.
+     * - `'opt-out'`: passed as `opt_out_tracking_by_default: true` to `mixpanel.init`, so tracking is suppressed from the first call.
+     * - `'opt-in'`: queued via `mixpanel.push(['opt_in_tracking'])` so the real SDK runs it immediately after load.
+     * @see https://docs.mixpanel.com/docs/privacy/opt-out-of-tracking
+     */
+    readonly defaultConsent: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"opt-in", undefined>, import("valibot").LiteralSchema<"opt-out", undefined>], undefined>, undefined>;
 }, undefined>;
 export declare const BingUetOptions: import("valibot").ObjectSchema<{
     /**
@@ -715,6 +765,13 @@ export declare const BingUetOptions: import("valibot").ObjectSchema<{
      * @default true
      */
     readonly enableAutoSpaTracking: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    /**
+     * Default consent state fired as `uetq.push('consent', 'default', ...)` before UET init.
+     * @see https://help.ads.microsoft.com/#apex/ads/en/60119/1-500
+     */
+    readonly defaultConsent: import("valibot").OptionalSchema<import("valibot").ObjectSchema<{
+        readonly ad_storage: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"granted", undefined>, import("valibot").LiteralSchema<"denied", undefined>], undefined>, undefined>;
+    }, undefined>, undefined>;
 }, undefined>;
 export declare const SegmentOptions: import("valibot").ObjectSchema<{
     /**
@@ -857,6 +914,14 @@ export declare const TikTokPixelOptions: import("valibot").ObjectSchema<{
      * @default true
      */
     readonly trackPageView: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    /**
+     * Default consent state, applied before `ttq('init', id)`.
+     * - `'granted'` fires `ttq.grantConsent()`
+     * - `'denied'` fires `ttq.revokeConsent()`
+     * - `'hold'` fires `ttq.holdConsent()` to defer until an explicit update
+     * @see https://business-api.tiktok.com/portal/docs?id=1739585600931842
+     */
+    readonly defaultConsent: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"granted", undefined>, import("valibot").LiteralSchema<"denied", undefined>, import("valibot").LiteralSchema<"hold", undefined>], undefined>, undefined>;
 }, undefined>;
 export declare const UmamiAnalyticsOptions: import("valibot").ObjectSchema<{
     /**