@nuxt/scripts 1.0.0-beta.2 → 1.0.0-beta.20

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

@@ -1,11 +1,6 @@
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
-export declare const GoogleMapsOptions: import("valibot").ObjectSchema<{
-    readonly apiKey: import("valibot").StringSchema<undefined>;
-    readonly libraries: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
-    readonly language: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly region: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly v: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"weekly", undefined>, import("valibot").LiteralSchema<"quarterly", undefined>, import("valibot").LiteralSchema<"beta", undefined>, import("valibot").LiteralSchema<"alpha", undefined>, import("valibot").StringSchema<undefined>], undefined>, undefined>;
-}, undefined>;
+import { GoogleMapsOptions } from './schemas.js';
+export { GoogleMapsOptions };
 export type GoogleMapsInput = RegistryScriptInput<typeof GoogleMapsOptions>;
 type MapsNamespace = typeof window.google.maps;
 export interface GoogleMapsApi {
@@ -15,10 +10,9 @@ declare global {
     interface Window {
         google: {
             maps: {
-                __ib__(): void;
+                __ib__: () => void;
             };
         };
     }
 }
 export declare function useScriptGoogleMaps<T extends GoogleMapsApi>(_options?: GoogleMapsInput): import("#nuxt-scripts/types").UseScriptContext<T>;
-export {};

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

@@ -1,13 +1,7 @@
 import { withQuery } from "ufo";
 import { useRegistryScript } from "../utils.js";
-import { array, literal, object, optional, string, union } from "#nuxt-scripts-validator";
-export const GoogleMapsOptions = object({
-  apiKey: string(),
-  libraries: optional(array(string())),
-  language: optional(string()),
-  region: optional(string()),
-  v: optional(union([literal("weekly"), literal("quarterly"), literal("beta"), literal("alpha"), string()]))
-});
+import { GoogleMapsOptions } from "./schemas.js";
+export { GoogleMapsOptions };
 export function useScriptGoogleMaps(_options) {
   let readyPromise = Promise.resolve();
   return useRegistryScript("googleMaps", (options) => {

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

@@ -1,10 +1,6 @@
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
-export declare const GoogleRecaptchaOptions: import("valibot").ObjectSchema<{
-    readonly siteKey: import("valibot").StringSchema<undefined>;
-    readonly enterprise: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-    readonly recaptchaNet: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-    readonly hl: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-}, undefined>;
+import { GoogleRecaptchaOptions } from './schemas.js';
+export { GoogleRecaptchaOptions };
 export type GoogleRecaptchaInput = RegistryScriptInput<typeof GoogleRecaptchaOptions>;
 export interface GoogleRecaptchaApi {
     grecaptcha: {

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

@@ -1,15 +1,7 @@
-import { withQuery } from "ufo";
 import { useRegistryScript } from "#nuxt-scripts/utils";
-import { object, string, optional, boolean } from "#nuxt-scripts-validator";
-export const GoogleRecaptchaOptions = object({
-  siteKey: string(),
-  // Use enterprise.js instead of api.js
-  enterprise: optional(boolean()),
-  // Use recaptcha.net (works in China)
-  recaptchaNet: optional(boolean()),
-  // Language code
-  hl: optional(string())
-});
+import { withQuery } from "ufo";
+import { GoogleRecaptchaOptions } from "./schemas.js";
+export { GoogleRecaptchaOptions };
 export function useScriptGoogleRecaptcha(_options) {
   return useRegistryScript(_options?.key || "googleRecaptcha", (options) => {
     const baseUrl = options?.recaptchaNet ? "https://www.recaptcha.net/recaptcha" : "https://www.google.com/recaptcha";
@@ -32,7 +24,7 @@ export function useScriptGoogleRecaptcha(_options) {
         const w = window;
         w.grecaptcha = w.grecaptcha || {};
         const readyFn = function(cb) {
-          (w.___grecaptcha_cfg = w.___grecaptcha_cfg || {}).fns = (w.___grecaptcha_cfg.fns || []).concat([cb]);
+          (w.___grecaptcha_cfg = w.___grecaptcha_cfg || {}).fns = [...w.___grecaptcha_cfg.fns || [], ...[cb]];
         };
         w.grecaptcha.ready = w.grecaptcha.ready || readyFn;
         if (options?.enterprise) {

package/dist/runtime/registry/google-sign-in.d.ts

@@ -1,4 +1,5 @@
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
+import { GoogleSignInOptions } from './schemas.js';
 export interface CredentialResponse {
     credential: string;
     select_by: 'auto' | 'user' | 'user_1tap' | 'user_2tap' | 'btn' | 'btn_confirm' | 'btn_add_session' | 'btn_confirm_add_session';
@@ -67,18 +68,6 @@ type AccountsNamespace = typeof google.accounts;
 export interface GoogleSignInApi {
     accounts: AccountsNamespace;
 }
-export declare const GoogleSignInOptions: import("valibot").ObjectSchema<{
-    readonly clientId: import("valibot").StringSchema<undefined>;
-    readonly autoSelect: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-    readonly context: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"signin", undefined>, import("valibot").LiteralSchema<"signup", undefined>, import("valibot").LiteralSchema<"use", undefined>], undefined>, undefined>;
-    readonly useFedcmForPrompt: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-    readonly cancelOnTapOutside: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-    readonly uxMode: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"popup", undefined>, import("valibot").LiteralSchema<"redirect", undefined>], undefined>, undefined>;
-    readonly loginUri: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly itpSupport: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-    readonly allowedParentOrigin: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>], undefined>, undefined>;
-    readonly hd: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-}, undefined>;
+export { GoogleSignInOptions };
 export type GoogleSignInInput = RegistryScriptInput<typeof GoogleSignInOptions>;
 export declare function useScriptGoogleSignIn<T extends GoogleSignInApi>(_options?: GoogleSignInInput): import("#nuxt-scripts/types").UseScriptContext<T>;
-export {};

package/dist/runtime/registry/google-sign-in.js

@@ -1,26 +1,6 @@
 import { useRegistryScript } from "#nuxt-scripts/utils";
-import { object, string, optional, boolean, array, union, literal } from "#nuxt-scripts-validator";
-export const GoogleSignInOptions = object({
-  clientId: string(),
-  // Auto-select credentials if only one is available
-  autoSelect: optional(boolean()),
-  // Context for One Tap (signin, signup, or use)
-  context: optional(union([literal("signin"), literal("signup"), literal("use")])),
-  // FedCM API support (Privacy Sandbox) - mandatory from August 2025
-  useFedcmForPrompt: optional(boolean()),
-  // Cancel One Tap if user clicks outside
-  cancelOnTapOutside: optional(boolean()),
-  // UX mode: popup or redirect
-  uxMode: optional(union([literal("popup"), literal("redirect")])),
-  // Login URI for redirect flow
-  loginUri: optional(string()),
-  // ITP (Intelligent Tracking Prevention) support
-  itpSupport: optional(boolean()),
-  // Allowed parent origins for iframe embedding
-  allowedParentOrigin: optional(union([string(), array(string())])),
-  // Hosted domain - restrict to specific Google Workspace domain
-  hd: optional(string())
-});
+import { GoogleSignInOptions } from "./schemas.js";
+export { GoogleSignInOptions };
 export function useScriptGoogleSignIn(_options) {
   return useRegistryScript(_options?.key || "googleSignIn", () => {
     return {

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

@@ -1,5 +1,6 @@
-import type { GTag } from './google-analytics.js';
 import type { NuxtUseScriptOptions, RegistryScriptInput, UseFunctionType, UseScriptContext } from '#nuxt-scripts/types';
+import type { GTag } from './google-analytics.js';
+import { GoogleTagManagerOptions } from './schemas.js';
 /**
  * Improved DataLayer type that better reflects GTM's capabilities
  * Can contain either gtag event parameters or custom data objects
@@ -65,33 +66,7 @@ declare global {
     interface Window extends GoogleTagManagerApi {
     }
 }
-/**
- * GTM configuration options with improved documentation
- */
-export declare const GoogleTagManagerOptions: import("valibot").ObjectSchema<{
-    /** GTM container ID (format: GTM-XXXXXX) */
-    readonly id: import("valibot").StringSchema<undefined>;
-    /** Optional dataLayer variable name */
-    readonly l: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    /** Authentication token for environment-specific container versions */
-    readonly auth: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    /** Preview environment name */
-    readonly preview: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    /** Forces GTM cookies to take precedence when true */
-    readonly cookiesWin: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").BooleanSchema<undefined>, import("valibot").LiteralSchema<"x", undefined>], undefined>, undefined>;
-    /** Enables debug mode when true */
-    readonly debug: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").BooleanSchema<undefined>, import("valibot").LiteralSchema<"x", undefined>], undefined>, undefined>;
-    /** No Personal Advertising - disables advertising features when true */
-    readonly npa: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").BooleanSchema<undefined>, import("valibot").LiteralSchema<"1", undefined>], undefined>, undefined>;
-    /** Custom dataLayer name (alternative to "l" property) */
-    readonly dataLayer: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    /** Environment name for environment-specific container */
-    readonly envName: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    /** Referrer policy for analytics requests */
-    readonly authReferrerPolicy: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    /** Default consent settings for GTM */
-    readonly defaultConsent: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").NumberSchema<undefined>], undefined>, undefined>, undefined>;
-}, undefined>;
+export { GoogleTagManagerOptions };
 export type GoogleTagManagerInput = RegistryScriptInput<typeof GoogleTagManagerOptions>;
 /**
  * Hook to use Google Tag Manager in Nuxt applications

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

@@ -1,30 +1,7 @@
-import { withQuery } from "ufo";
 import { useRegistryScript } from "#nuxt-scripts/utils";
-import { object, string, optional, boolean, union, literal, record, number } from "#nuxt-scripts-validator";
-export const GoogleTagManagerOptions = object({
-  /** GTM container ID (format: GTM-XXXXXX) */
-  id: string(),
-  /** Optional dataLayer variable name */
-  l: optional(string()),
-  /** Authentication token for environment-specific container versions */
-  auth: optional(string()),
-  /** Preview environment name */
-  preview: optional(string()),
-  /** Forces GTM cookies to take precedence when true */
-  cookiesWin: optional(union([boolean(), literal("x")])),
-  /** Enables debug mode when true */
-  debug: optional(union([boolean(), literal("x")])),
-  /** No Personal Advertising - disables advertising features when true */
-  npa: optional(union([boolean(), literal("1")])),
-  /** Custom dataLayer name (alternative to "l" property) */
-  dataLayer: optional(string()),
-  /** Environment name for environment-specific container */
-  envName: optional(string()),
-  /** Referrer policy for analytics requests */
-  authReferrerPolicy: optional(string()),
-  /** Default consent settings for GTM */
-  defaultConsent: optional(record(string(), union([string(), number()])))
-});
+import { withQuery } from "ufo";
+import { GoogleTagManagerOptions } from "./schemas.js";
+export { GoogleTagManagerOptions };
 export function useScriptGoogleTagManager(options) {
   const instance = useRegistryScript(
     options?.key || "googleTagManager",
@@ -64,7 +41,7 @@ export function useScriptGoogleTagManager(options) {
           if (opts.defaultConsent)
             gtag("consent", "default", opts.defaultConsent);
           window[dataLayerName].push({
-            "gtm.start": (/* @__PURE__ */ new Date()).getTime(),
+            "gtm.start": Date.now(),
             "event": "gtm.js"
           });
         }

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

@@ -0,0 +1,25 @@
+import type { RegistryScriptInput } from '#nuxt-scripts/types';
+import { GravatarOptions } from './schemas.js';
+export type GravatarInput = RegistryScriptInput<typeof GravatarOptions>;
+export interface GravatarApi {
+    /**
+     * Get a proxied avatar URL for a given SHA256 email hash.
+     * When firstParty mode is enabled, this routes through your server.
+     */
+    getAvatarUrl: (hash: string, options?: {
+        size?: number;
+        default?: string;
+        rating?: string;
+    }) => string;
+    /**
+     * Get a proxied avatar URL using the server-side hashing endpoint.
+     * The email is sent to YOUR server (not Gravatar) for hashing.
+     * Only available when the gravatar proxy is enabled.
+     */
+    getAvatarUrlFromEmail: (email: string, options?: {
+        size?: number;
+        default?: string;
+        rating?: string;
+    }) => string;
+}
+export declare function useScriptGravatar<T extends GravatarApi>(_options?: GravatarInput): import("#nuxt-scripts/types").UseScriptContext<T>;

package/dist/runtime/registry/gravatar.js

@@ -0,0 +1,32 @@
+import { useRegistryScript } from "#nuxt-scripts/utils";
+import { GravatarOptions } from "./schemas.js";
+export function useScriptGravatar(_options) {
+  return useRegistryScript(_options?.key || "gravatar", (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();
+    };
+    return {
+      scriptInput: {
+        src: "https://secure.gravatar.com/js/gprofiles.js"
+      },
+      schema: import.meta.dev ? GravatarOptions : void 0,
+      scriptOptions: {
+        use: () => ({
+          getAvatarUrl: (hash, overrides) => {
+            return `/_scripts/gravatar-proxy?hash=${encodeURIComponent(hash)}&${buildQuery(overrides)}`;
+          },
+          getAvatarUrlFromEmail: (email, overrides) => {
+            return `/_scripts/gravatar-proxy?email=${encodeURIComponent(email)}&${buildQuery(overrides)}`;
+          }
+        })
+      }
+    };
+  }, _options);
+}

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

@@ -1,6 +1,8 @@
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
+import { HotjarOptions } from './schemas.js';
+export { HotjarOptions };
 export interface HotjarApi {
-    hj: ((event: 'identify', userId: string, attributes?: Record<string, any>) => void) & ((event: 'stateChange', path: string) => void) & ((event: 'event', eventName: string) => void) & ((event: string, arg?: string) => void) & ((...params: any[]) => void) & {
+    hj: ((event: 'identify', userId: string, attributes?: Record<string, any>) => void) & ((event: 'stateChange', path: string) => void) & ((event: 'vPageView', path: string) => void) & ((event: 'event', eventName: string) => void) & ((event: (string & {}), ...args: any[]) => void) & {
         q: any[];
     };
 }
@@ -12,9 +14,5 @@ declare global {
         };
     }
 }
-export declare const HotjarOptions: import("valibot").ObjectSchema<{
-    readonly id: import("valibot").NumberSchema<undefined>;
-    readonly sv: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
-}, undefined>;
 export type HotjarInput = RegistryScriptInput<typeof HotjarOptions, true, false, false>;
 export declare function useScriptHotjar<T extends HotjarApi>(_options?: HotjarInput): import("#nuxt-scripts/types").UseScriptContext<T>;

package/dist/runtime/registry/hotjar.js

@@ -1,9 +1,6 @@
 import { useRegistryScript } from "../utils.js";
-import { number, object, optional } from "#nuxt-scripts-validator";
-export const HotjarOptions = object({
-  id: number(),
-  sv: optional(number())
-});
+import { HotjarOptions } from "./schemas.js";
+export { HotjarOptions };
 export function useScriptHotjar(_options) {
   return useRegistryScript("hotjar", (options) => ({
     scriptInput: {

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

@@ -1,21 +1,6 @@
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
-export declare const InstagramEmbedOptions: import("valibot").ObjectSchema<{
-    /**
-     * The Instagram post URL to embed
-     * e.g., https://www.instagram.com/p/ABC123/
-     */
-    readonly postUrl: import("valibot").StringSchema<undefined>;
-    /**
-     * Whether to include captions in the embed
-     * @default true
-     */
-    readonly captions: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-    /**
-     * Custom API endpoint for fetching embed HTML
-     * @default '/api/_scripts/instagram-embed'
-     */
-    readonly apiEndpoint: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-}, undefined>;
+import { InstagramEmbedOptions } from './schemas.js';
+export { InstagramEmbedOptions };
 export type InstagramEmbedInput = RegistryScriptInput<typeof InstagramEmbedOptions, false, false, false>;
 /**
  * Extract the post shortcode from an Instagram URL

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

@@ -1,22 +1,7 @@
-import { boolean, object, optional, string } from "#nuxt-scripts-validator";
-export const InstagramEmbedOptions = object({
-  /**
-   * The Instagram post URL to embed
-   * e.g., https://www.instagram.com/p/ABC123/
-   */
-  postUrl: string(),
-  /**
-   * Whether to include captions in the embed
-   * @default true
-   */
-  captions: optional(boolean()),
-  /**
-   * Custom API endpoint for fetching embed HTML
-   * @default '/api/_scripts/instagram-embed'
-   */
-  apiEndpoint: optional(string())
-});
+import { InstagramEmbedOptions } from "./schemas.js";
+export { InstagramEmbedOptions };
+const INSTAGRAM_SHORTCODE_RE = /instagram\.com\/(?:p|reel|tv)\/([^/?]+)/;
 export function extractInstagramShortcode(url) {
-  const match = url.match(/instagram\.com\/(?:p|reel|tv)\/([^/?]+)/);
+  const match = url.match(INSTAGRAM_SHORTCODE_RE);
   return match?.[1];
 }

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

@@ -1,18 +1,10 @@
 import type { InferInput } from '#nuxt-scripts-validator';
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
-export declare const IntercomOptions: import("valibot").ObjectSchema<{
-    readonly app_id: import("valibot").StringSchema<undefined>;
-    readonly api_base: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"https://api-iam.intercom.io", undefined>, import("valibot").LiteralSchema<"https://api-iam.eu.intercom.io", undefined>, import("valibot").LiteralSchema<"https://api-iam.au.intercom.io", undefined>], undefined>, undefined>;
-    readonly name: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly email: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly user_id: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly alignment: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"left", undefined>, import("valibot").LiteralSchema<"right", undefined>], undefined>, undefined>;
-    readonly horizontal_padding: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
-    readonly vertical_padding: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
-}, undefined>;
+import { IntercomOptions } from './schemas.js';
+export { IntercomOptions };
 export type IntercomInput = RegistryScriptInput<typeof IntercomOptions, true, false, false>;
 export interface IntercomApi {
-    Intercom: ((event: 'boot', data?: InferInput<typeof IntercomOptions>) => void) & ((event: 'shutdown') => void) & ((event: 'update', options?: InferInput<typeof IntercomOptions>) => void) & ((event: 'hide') => void) & ((event: 'show') => void) & ((event: 'showSpace', spaceName: 'home' | 'messages' | 'help' | 'news' | 'tasks' | 'tickets' | string) => void) & ((event: 'showMessages') => void) & ((event: 'showNewMessage', content?: string) => void) & ((event: 'onHide', fn: () => void) => void) & ((event: 'onShow', fn: () => void) => void) & ((event: 'onUnreadCountChange', fn: () => void) => void) & ((event: 'trackEvent', eventName: string, metadata?: Record<string, any>) => void) & ((event: 'getVisitorId') => Promise<string>) & ((event: 'startTour', tourId: string | number) => void) & ((event: 'showArticle', articleId: string | number) => void) & ((event: 'showNews', newsItemId: string | number) => void) & ((event: 'startSurvey', surveyId: string | number) => void) & ((event: 'startChecklist', checklistId: string | number) => void) & ((event: 'showTicket', ticketId: string | number) => void) & ((event: 'showConversation', conversationId: string | number) => void) & ((event: 'onUserEmailSupplied', fn: () => void) => void) & ((event: string, ...params: any[]) => void);
+    Intercom: ((event: 'boot', data?: InferInput<typeof IntercomOptions>) => void) & ((event: 'shutdown') => void) & ((event: 'update', options?: InferInput<typeof IntercomOptions>) => void) & ((event: 'hide') => void) & ((event: 'show') => void) & ((event: 'showSpace', spaceName: 'home' | 'messages' | 'help' | 'news' | 'tasks' | 'tickets' | (string & {})) => void) & ((event: 'showMessages') => void) & ((event: 'showNewMessage', content?: string) => void) & ((event: 'onHide', fn: () => void) => void) & ((event: 'onShow', fn: () => void) => void) & ((event: 'onUnreadCountChange', fn: () => void) => void) & ((event: 'trackEvent', eventName: string, metadata?: Record<string, any>) => void) & ((event: 'getVisitorId') => Promise<string>) & ((event: 'startTour', tourId: string | number) => void) & ((event: 'showArticle', articleId: string | number) => void) & ((event: 'showNews', newsItemId: string | number) => void) & ((event: 'startSurvey', surveyId: string | number) => void) & ((event: 'startChecklist', checklistId: string | number) => void) & ((event: 'showTicket', ticketId: string | number) => void) & ((event: 'showConversation', conversationId: string | number) => void) & ((event: 'onUserEmailSupplied', fn: () => void) => void) & ((event: (string & {}), ...params: any[]) => void);
 }
 declare global {
     interface Window extends IntercomApi {

package/dist/runtime/registry/intercom.js

@@ -1,17 +1,7 @@
 import { joinURL } from "ufo";
 import { useRegistryScript } from "../utils.js";
-import { literal, number, object, optional, string, union } from "#nuxt-scripts-validator";
-export const IntercomOptions = object({
-  app_id: string(),
-  api_base: optional(union([literal("https://api-iam.intercom.io"), literal("https://api-iam.eu.intercom.io"), literal("https://api-iam.au.intercom.io")])),
-  name: optional(string()),
-  email: optional(string()),
-  user_id: optional(string()),
-  // customizing the messenger
-  alignment: optional(union([literal("left"), literal("right")])),
-  horizontal_padding: optional(number()),
-  vertical_padding: optional(number())
-});
+import { IntercomOptions } from "./schemas.js";
+export { IntercomOptions };
 export function useScriptIntercom(_options) {
   return useRegistryScript("intercom", (options) => ({
     scriptInput: {

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

@@ -1,14 +1,6 @@
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
-export declare const MatomoAnalyticsOptions: import("valibot").ObjectSchema<{
-    readonly matomoUrl: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly siteId: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").NumberSchema<undefined>], undefined>, undefined>;
-    readonly cloudId: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly trackerUrl: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly trackPageView: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-    readonly enableLinkTracking: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-    readonly disableCookies: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-    readonly watch: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-}, undefined>;
+import { MatomoAnalyticsOptions } from './schemas.js';
+export { MatomoAnalyticsOptions };
 export type MatomoAnalyticsInput = RegistryScriptInput<typeof MatomoAnalyticsOptions, false, false, false>;
 interface MatomoAnalyticsApi {
     _paq: unknown[];
@@ -18,4 +10,3 @@ declare global {
     }
 }
 export declare function useScriptMatomoAnalytics<T extends MatomoAnalyticsApi>(_options?: MatomoAnalyticsInput): import("#nuxt-scripts/types").UseScriptContext<T>;
-export {};

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

@@ -1,18 +1,9 @@
 import { withBase, withHttps, withoutProtocol, withoutTrailingSlash } from "ufo";
-import { useRegistryScript } from "../utils.js";
 import { useScriptEventPage } from "../composables/useScriptEventPage.js";
-import { boolean, object, optional, string, number, union } from "#nuxt-scripts-validator";
 import { logger } from "../logger.js";
-export const MatomoAnalyticsOptions = object({
-  matomoUrl: optional(string()),
-  siteId: optional(union([string(), number()])),
-  cloudId: optional(string()),
-  trackerUrl: optional(string()),
-  trackPageView: optional(boolean()),
-  enableLinkTracking: optional(boolean()),
-  disableCookies: optional(boolean()),
-  watch: optional(boolean())
-});
+import { useRegistryScript } from "../utils.js";
+import { MatomoAnalyticsOptions } from "./schemas.js";
+export { MatomoAnalyticsOptions };
 export function useScriptMatomoAnalytics(_options) {
   return useRegistryScript("matomoAnalytics", (options) => {
     const normalizedCloudId = options?.cloudId ? withoutTrailingSlash(withoutProtocol(options.cloudId)) : void 0;

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

@@ -1,4 +1,5 @@
 import type { RegistryScriptInput } 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 {
     content_category?: string;
@@ -14,7 +15,7 @@ interface EventObjectProperties {
     num_items?: number;
     predicted_ltv?: number;
     search_string?: string;
-    status?: 'completed' | 'updated' | 'viewed' | 'added_to_cart' | 'removed_from_cart' | string;
+    status?: 'completed' | 'updated' | 'viewed' | 'added_to_cart' | 'removed_from_cart' | (string & {});
     value?: number;
     [key: string]: any;
 }
@@ -35,9 +36,6 @@ declare global {
     interface Window extends MetaPixelApi {
     }
 }
-export declare const MetaPixelOptions: import("valibot").ObjectSchema<{
-    readonly id: import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").NumberSchema<undefined>], undefined>;
-}, undefined>;
+export { MetaPixelOptions };
 export type MetaPixelInput = RegistryScriptInput<typeof MetaPixelOptions, true, false, false>;
 export declare function useScriptMetaPixel<T extends MetaPixelApi>(_options?: MetaPixelInput): import("#nuxt-scripts/types").UseScriptContext<T>;
-export {};

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

@@ -1,8 +1,6 @@
 import { useRegistryScript } from "../utils.js";
-import { number, object, string, union } from "#nuxt-scripts-validator";
-export const MetaPixelOptions = object({
-  id: union([string(), number()])
-});
+import { MetaPixelOptions } from "./schemas.js";
+export { MetaPixelOptions };
 export function useScriptMetaPixel(_options) {
   return useRegistryScript("metaPixel", (options) => ({
     scriptInput: {

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

@@ -1,9 +1,5 @@
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
-export declare const NpmOptions: import("valibot").ObjectSchema<{
-    readonly packageName: import("valibot").StringSchema<undefined>;
-    readonly file: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly version: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly provider: import("valibot").OptionalSchema<import("valibot").UnionSchema<import("valibot").LiteralSchema<"jsdelivr" | "cdnjs" | "unpkg", undefined>[], undefined>, undefined>;
-}, undefined>;
+import { NpmOptions } from './schemas.js';
+export { NpmOptions };
 export type NpmInput = RegistryScriptInput<typeof NpmOptions, true, true, false>;
 export declare function useScriptNpm<T extends Record<string | symbol, any>>(_options: NpmInput): import("#nuxt-scripts/types").UseScriptContext<T>;

package/dist/runtime/registry/npm.js

@@ -1,14 +1,7 @@
 import { withBase } from "ufo";
 import { useRegistryScript } from "../utils.js";
-import { object, optional, string, union, literal } from "#nuxt-scripts-validator";
-const PROVIDERS = ["jsdelivr", "cdnjs", "unpkg"];
-const providerValidator = union(PROVIDERS.map((provider) => literal(provider)));
-export const NpmOptions = object({
-  packageName: string(),
-  file: optional(string()),
-  version: optional(string()),
-  provider: optional(providerValidator)
-});
+import { NpmOptions } from "./schemas.js";
+export { NpmOptions };
 export function useScriptNpm(_options) {
   return useRegistryScript(`${_options.packageName}-npm`, (options) => {
     const baseUrl = getProviderBaseUrl(options.provider, options.packageName, options.version);

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

@@ -1,34 +1,13 @@
-import type { PayPalNamespace } from '@paypal/paypal-js';
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
+import type { PayPalV6Namespace } from '@paypal/paypal-js/sdk-v6';
+import { PayPalOptions } from './schemas.js';
+export { PayPalOptions };
 export interface PayPalApi {
-    paypal: PayPalNamespace;
+    paypal: PayPalV6Namespace;
 }
 declare global {
     interface Window extends PayPalApi {
     }
 }
-export declare const PayPalOptions: import("valibot").ObjectSchema<{
-    readonly clientId: import("valibot").StringSchema<undefined>;
-    readonly buyerCountry: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly commit: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly components: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>], undefined>, undefined>;
-    readonly currency: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly debug: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").BooleanSchema<undefined>], undefined>, undefined>;
-    readonly disableFunding: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>], undefined>, undefined>;
-    readonly enableFunding: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>], undefined>, undefined>;
-    readonly integrationDate: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly intent: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly locale: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    /**
-     * loadScript() supports an array for merchantId, even though
-     * merchant-id technically may not contain multiple values.
-     * For an array with a length of > 1 it automatically sets
-     * merchantId to "*" and moves the actual values to dataMerchantId
-     */
-    readonly merchantId: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>], undefined>, undefined>;
-    readonly partnerAttributionId: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly vault: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").BooleanSchema<undefined>], undefined>, undefined>;
-    readonly sandbox: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-}, undefined>;
 export type PayPalInput = RegistryScriptInput<typeof PayPalOptions>;
 export declare function useScriptPayPal<T extends PayPalApi>(_options?: PayPalInput): import("#nuxt-scripts/types").UseScriptContext<T>;