ubean 0.1.13 → 0.2.0

package/dist/client/index.d.ts

@@ -0,0 +1,2480 @@
+import { CSSProperties, ComputedRef, Plugin, Ref } from "vue";
+export * from "@ubean/client";
+//#region ../../node_modules/.pnpm/hookable@6.1.1/node_modules/hookable/dist/index.d.mts
+type HookCallback = (...arguments_: any) => Promise<void> | void;
+type HookKeys<T> = keyof T & string;
+type InferCallback<HT, HN extends keyof HT> = HT[HN] extends HookCallback ? HT[HN] : never;
+declare class HookableCore<HooksT extends Record<string, any> = Record<string, HookCallback>, HookNameT extends HookKeys<HooksT> = HookKeys<HooksT>> {
+  protected _hooks: {
+    [key: string]: HookCallback[] | undefined;
+  };
+  constructor();
+  hook<NameT extends HookNameT>(name: NameT, fn: InferCallback<HooksT, NameT>): () => void;
+  removeHook<NameT extends HookNameT>(name: NameT, function_: InferCallback<HooksT, NameT>): void;
+  callHook<NameT extends HookNameT>(name: NameT, ...args: Parameters<InferCallback<HooksT, NameT>>): Promise<any> | void;
+}
+type CreateTask = (name?: string) => {
+  run: (function_: () => Promise<any> | any) => Promise<any> | any;
+};
+declare global {
+  interface Console {
+    createTask?: CreateTask;
+  }
+}
+//#endregion
+//#region ../../node_modules/.pnpm/unhead@3.3.2_@voidzero-dev+vite-plus-core@0.2.9_rollup@4.62.4/node_modules/unhead/dist/shared/unhead.DZFTh_Dn.d.ts
+type Booleanable = boolean | 'false' | 'true' | '';
+type Stringable = string | Booleanable | number;
+type Falsy$1 = false | null | undefined;
+type ResolvableValue$1<T> = T | Falsy$1 | (() => (T | Falsy$1));
+type Prettify$1<T> = { [K in keyof T]: T[K]; } & {};
+type _ResolvablePropertiesRaw$1<T> = { [K in keyof T as {} extends Pick<T, K> ? never : K]: ResolvableValue$1<T[K]>; } & { [K in keyof T as {} extends Pick<T, K> ? K : never]?: ResolvableValue$1<T[K]>; };
+type ResolvableProperties$1<T> = Prettify$1<_ResolvablePropertiesRaw$1<T>>;
+interface DataKeys {
+  [key: `data-${string}`]: Stringable;
+}
+interface BaseFields {
+  /**
+   * The base URL to be used throughout the document for relative URLs. Absolute and relative URLs are allowed.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/base#attr-href
+   */
+  href?: string;
+  /**
+   * A keyword or author-defined name of the default browsing context to show the results of navigation from `<a>`,
+   * `<area>`, or `<form>` elements without explicit target attributes.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/base#attr-target
+   */
+  target?: '_blank' | '_self' | '_parent' | '_top' | (string & Record<never, never>);
+}
+/**
+ * The `<base>` HTML element requires at least `href` or `target` to be valid.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/base
+ */
+type Base$1 = (BaseFields & {
+  href: string;
+}) | (BaseFields & {
+  target: '_blank' | '_self' | '_parent' | '_top' | (string & Record<never, never>);
+});
+interface GlobalAttributes {
+  /**
+   * Provides a hint for generating a keyboard shortcut for the current element. This attribute consists of a
+   * space-separated list of characters. The browser should use the first one that exists on the computer keyboard layout.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/accesskey
+   */
+  accesskey?: string;
+  /**
+   * Controls whether and how text input is automatically capitalized as it is entered/edited by the user.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/autocapitalize
+   */
+  autocapitalize?: 'off' | 'none' | 'on' | 'sentences' | 'words' | 'characters';
+  /**
+   * Indicates that an element is to be focused on page load, or as soon as the `<dialog>` it is part of is displayed.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/autofocus
+   */
+  autofocus?: Booleanable;
+  /**
+   * A space-separated list of the classes of the element. Classes allows CSS and JavaScript to select and access
+   * specific elements via the class selectors or functions like the method Document.getElementsByClassName().
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/class
+   */
+  class?: Stringable;
+  /**
+   * An enumerated attribute indicating if the element should be editable by the user.
+   * If so, the browser modifies its widget to allow editing.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/contenteditable
+   */
+  contenteditable?: Booleanable;
+  /**
+   * An enumerated attribute indicating the directionality of the element's text.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/dir
+   */
+  dir?: 'ltr' | 'rtl' | 'auto';
+  /**
+   * An enumerated attribute indicating whether the element can be dragged, using the Drag and Drop API.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/draggable
+   */
+  draggable?: Booleanable;
+  /**
+   * Hints what action label (or icon) to present for the enter key on virtual keyboards.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/enterkeyhint
+   */
+  enterkeyhint?: string;
+  /**
+   * Used to transitively export shadow parts from a nested shadow tree into a containing light tree.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/exportparts
+   */
+  exportparts?: string;
+  /**
+   * A Boolean attribute indicates that the element is not yet, or is no longer, relevant.
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/hidden
+   */
+  hidden?: Booleanable;
+  /**
+   * The id global attribute defines a unique identifier (ID) which must be unique in the whole document.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/id
+   */
+  id?: string;
+  /**
+   * Provides a hint to browsers as to the type of virtual keyboard configuration to use when editing this element or its contents.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/inputmode
+   */
+  inputmode?: 'none' | 'text' | 'decimal' | 'numeric' | 'tel' | 'search' | 'email' | 'url';
+  /**
+   * Allows you to specify that a standard HTML element should behave like a registered custom built-in element.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/is
+   */
+  is?: string;
+  /**
+   * The unique, global identifier of an item.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/itemid
+   */
+  itemid?: string;
+  /**
+   * Used to add properties to an item.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/itemprop
+   */
+  itemprop?: string;
+  /**
+   * Properties that are not descendants of an element with the itemscope attribute can be associated with the item using an itemref.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/itemref
+   */
+  itemref?: string;
+  /**
+   * itemscope (usually) works along with itemtype to specify that the HTML contained in a block is about a particular item.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/itemscope
+   */
+  itemscope?: string;
+  /**
+   * Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in the data structure.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/itemtype
+   */
+  itemtype?: string;
+  /**
+   * Helps define the language of an element: the language that non-editable elements are in, or the language
+   * that editable elements should be written in by the user.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/lang
+   */
+  lang?: 'en' | 'en-US' | 'en-GB' | 'de' | 'fr' | 'es' | 'it' | 'ja' | 'ko' | 'nl' | 'pl' | 'pt' | 'pt-BR' | 'ru' | 'zh' | 'zh-CN' | 'zh-TW' | 'ar' | 'hi' | 'id' | 'th' | 'tr' | 'uk' | 'vi' | (string & Record<never, never>);
+  /**
+   * A cryptographic nonce ("number used once") which can be used by Content Security Policy to determine whether or not
+   * a given fetch will be allowed to proceed.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/nonce
+   */
+  nonce?: string;
+  /**
+   * A space-separated list of the part names of the element. Part names allows CSS to select and style specific elements
+   * in a shadow tree via the ::part pseudo-element.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/part
+   */
+  part?: string;
+  /**
+   * Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is assigned to the slot
+   * created by the `<slot>` element whose name attribute's value matches that slot attribute's value.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot
+   */
+  slot?: string;
+  /**
+   * An enumerated attribute defines whether the element may be checked for spelling errors.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/spellcheck
+   */
+  spellcheck?: Booleanable;
+  /**
+   * Contains CSS styling declarations to be applied to the element.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/style
+   */
+  style?: string;
+  /**
+   * An integer attribute indicating if the element can take input focus (is focusable),
+   * if it should participate to sequential keyboard navigation, and if so, at what position.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/tabindex
+   */
+  tabindex?: number;
+  /**
+   * Contains a text representing advisory information related to the element it belongs to.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/title
+   */
+  title?: string;
+  /**
+   * An enumerated attribute that is used to specify whether an element's attribute values and the values of its
+   * Text node children are to be translated when the page is localized, or whether to leave them unchanged.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/translate
+   */
+  translate?: 'yes' | 'no' | '';
+}
+interface BodyEvents {
+  /**
+   * Script to be run after the document is printed
+   */
+  onafterprint?: string;
+  /**
+   * Script to be run before the document is printed
+   */
+  onbeforeprint?: string;
+  /**
+   * Script to be run when the document is about to be unloaded
+   */
+  onbeforeunload?: string;
+  /**
+   * Script to be run when an error occurs
+   */
+  onerror?: string;
+  /**
+   * Script to be run when there has been changes to the anchor part of the a URL
+   */
+  onhashchange?: string;
+  /**
+   * Fires after the page is finished loading
+   */
+  onload?: string;
+  /**
+   * Script to be run when the message is triggered
+   */
+  onmessage?: string;
+  /**
+   * Script to be run when the browser starts to work offline
+   */
+  onoffline?: string;
+  /**
+   * Script to be run when the browser starts to work online
+   */
+  ononline?: string;
+  /**
+   * Script to be run when a user navigates away from a page
+   */
+  onpagehide?: string;
+  /**
+   * Script to be run when a user navigates to a page
+   */
+  onpageshow?: string;
+  /**
+   * Script to be run when the window's history changes
+   */
+  onpopstate?: string;
+  /**
+   * Fires when the browser window is resized
+   */
+  onresize?: string;
+  /**
+   * Script to be run when a Web Storage area is updated
+   */
+  onstorage?: string;
+  /**
+   * Fires once a page has unloaded (or the browser window has been closed)
+   */
+  onunload?: string;
+}
+interface BodyAttributesWithoutEvents extends Pick<GlobalAttributes, 'class' | 'style' | 'id' | 'dir' | 'lang' | 'translate'> {}
+interface HtmlAttributes$1 extends Pick<GlobalAttributes, 'lang' | 'dir' | 'translate' | 'class' | 'style' | 'id'> {
+  /**
+   * Open-graph protocol prefix.
+   *
+   * @see https://ogp.me/
+   */
+  prefix?: 'og: https://ogp.me/ns#' | (string & Record<never, never>);
+  /**
+   * XML namespace
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/SVG/Namespaces_Crash_Course
+   */
+  xmlns?: string;
+  /**
+   * Custom XML namespace
+   *
+   * @See https://developer.mozilla.org/en-US/docs/Web/SVG/Namespaces_Crash_Course
+   */
+  [key: `xmlns:${'og' | string}`]: string;
+}
+interface HttpEventAttributes {
+  /**
+   * Script to be run on abort
+   */
+  onabort?: string;
+  /**
+   * Script to be run when an error occurs when the file is being loaded
+   */
+  onerror?: string;
+  /**
+   * Script to be run when the file is loaded
+   */
+  onload?: string;
+  /**
+   * The progress event is fired periodically when a request receives more data.
+   */
+  onprogress?: string;
+  /**
+   * Script to be run just as the file begins to load before anything is actually loaded
+   */
+  onloadstart?: string;
+}
+type ReferrerPolicy = '' | 'no-referrer' | 'no-referrer-when-downgrade' | 'origin' | 'origin-when-cross-origin' | 'same-origin' | 'strict-origin' | 'strict-origin-when-cross-origin' | 'unsafe-url';
+/**
+ * Represents the possible blocking tokens for an element.
+ */
+type BlockingToken = 'render';
+/**
+ * Represents the blocking attribute for an element.
+ * The blocking attribute must have a value that is an unordered set of unique space-separated tokens,
+ * each of which are possible blocking tokens.
+ */
+interface Blocking {
+  /**
+   * The blocking attribute indicates that certain operations should be blocked on the fetching of an external resource.
+   * The value is an unordered set of unique space-separated tokens, each of which are possible blocking tokens.
+   *
+   * @example
+   * blocking: "render"
+   */
+  blocking?: BlockingToken | string;
+}
+/**
+ * Events that fire on link elements (load/error)
+ */
+type LinkHttpEvents = Pick<HttpEventAttributes, 'onload' | 'onerror'>;
+/**
+ * Base properties shared by all link types
+ */
+interface LinkBase extends Pick<GlobalAttributes, 'nonce' | 'id'>, Blocking, DataKeys {
+  /**
+   * Provides a hint of the relative priority to use when fetching a preloaded resource.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-fetchpriority
+   */
+  fetchpriority?: 'high' | 'low' | 'auto';
+  /**
+   * A string indicating which referrer to use when fetching the resource.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-referrerpolicy
+   */
+  referrerpolicy?: ReferrerPolicy;
+}
+/**
+ * Stylesheet-specific link (fires events)
+ */
+interface StylesheetLink extends LinkBase, LinkHttpEvents {
+  rel: 'stylesheet';
+  /**
+   * This attribute specifies the URL of the linked resource.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-href
+   */
+  href: string;
+  /**
+   * This attribute specifies the media that the linked resource applies to.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-media
+   */
+  media?: string;
+  /**
+   * Contains inline metadata — a base64-encoded cryptographic hash of the resource.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-integrity
+   */
+  integrity?: string;
+  /**
+   * This enumerated attribute indicates whether CORS must be used when fetching the resource.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-crossorigin
+   */
+  crossorigin?: '' | 'anonymous' | 'use-credentials';
+  /**
+   * The title attribute has special semantics on the `<link>` element.
+   * When used on a `<link rel="stylesheet">` it defines a default or an alternate stylesheet.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-title
+   */
+  title?: string;
+  /**
+   * This attribute is used to define the type of the content linked to.
+   * It can be omitted; `text/css` is assumed.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-type
+   */
+  type?: 'text/css' | (string & Record<never, never>);
+  /**
+   * Whether the stylesheet is disabled.
+   */
+  disabled?: boolean;
+}
+/**
+ * Base for preload links (fires events)
+ */
+interface PreloadLinkBase extends LinkBase, LinkHttpEvents {
+  rel: 'preload';
+  /**
+   * This attribute specifies the URL of the linked resource.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-href
+   */
+  href: string;
+  /**
+   * This enumerated attribute indicates whether CORS must be used when fetching the resource.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-crossorigin
+   */
+  crossorigin?: '' | 'anonymous' | 'use-credentials';
+  /**
+   * Contains inline metadata — a base64-encoded cryptographic hash of the resource.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-integrity
+   */
+  integrity?: string;
+  /**
+   * This attribute specifies the media that the linked resource applies to.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-media
+   */
+  media?: string;
+}
+/**
+ * Base fields for image preload links.
+ */
+interface PreloadImageLinkFields extends Omit<PreloadLinkBase, 'href'> {
+  as: 'image';
+  /**
+   * This attribute specifies the URL of the linked resource.
+   * Optional for image preloads when using imagesrcset instead.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-href
+   */
+  href?: string;
+  type?: 'image/webp' | 'image/avif' | 'image/png' | 'image/jpeg' | 'image/gif' | 'image/svg+xml' | (string & Record<never, never>);
+  /**
+   * For rel="preload" and as="image" only, the imagesizes attribute indicates
+   * to preload the appropriate resource used by an img element.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-imagesizes
+   */
+  imagesizes?: string;
+  /**
+   * For rel="preload" and as="image" only, the imagesrcset attribute indicates
+   * to preload the appropriate resource used by an img element.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-imagesrcset
+   */
+  imagesrcset?: string;
+}
+/**
+ * Preload: image (has imagesrcset/imagesizes).
+ * Requires at least one of `href` or `imagesrcset`.
+ */
+type PreloadImageLink = (PreloadImageLinkFields & {
+  href: string;
+}) | (PreloadImageLinkFields & {
+  imagesrcset: string;
+});
+/**
+ * Preload: font
+ */
+interface PreloadFontLink extends PreloadLinkBase {
+  as: 'font';
+  type?: 'font/woff2' | 'font/woff' | 'font/ttf' | 'font/otf' | (string & Record<never, never>);
+  /**
+   * For fonts, crossorigin is required for CORS.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-crossorigin
+   */
+  crossorigin: '' | 'anonymous' | 'use-credentials';
+}
+/**
+ * Preload: script
+ */
+interface PreloadScriptLink extends PreloadLinkBase {
+  as: 'script';
+  type?: 'text/javascript' | 'module' | (string & Record<never, never>);
+}
+/**
+ * Preload: style
+ */
+interface PreloadStyleLink extends PreloadLinkBase {
+  as: 'style';
+  type?: 'text/css' | (string & Record<never, never>);
+}
+/**
+ * Preload: other types
+ */
+interface PreloadOtherLink extends PreloadLinkBase {
+  as: 'audio' | 'document' | 'embed' | 'fetch' | 'object' | 'track' | 'video' | 'worker';
+  type?: string;
+}
+/**
+ * Combined preload union
+ */
+type PreloadLink = PreloadImageLink | PreloadFontLink | PreloadScriptLink | PreloadStyleLink | PreloadOtherLink;
+/**
+ * Modulepreload-specific link (fires events)
+ */
+interface ModulepreloadLink extends LinkBase, LinkHttpEvents {
+  rel: 'modulepreload';
+  /**
+   * This attribute specifies the URL of the linked resource.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-href
+   */
+  href: string;
+  /**
+   * Contains inline metadata — a base64-encoded cryptographic hash of the resource.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-integrity
+   */
+  integrity?: string;
+  /**
+   * This enumerated attribute indicates whether CORS must be used when fetching the resource.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-crossorigin
+   */
+  crossorigin?: '' | 'anonymous' | 'use-credentials';
+}
+/**
+ * Prefetch-specific link
+ */
+interface PrefetchLink extends LinkBase {
+  rel: 'prefetch';
+  /**
+   * This attribute specifies the URL of the linked resource.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-href
+   */
+  href: string;
+  /**
+   * This attribute is used when rel="prefetch" to specify the type of content being loaded.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-as
+   */
+  as?: 'audio' | 'document' | 'embed' | 'fetch' | 'font' | 'image' | 'object' | 'script' | 'style' | 'track' | 'video' | 'worker';
+  /**
+   * This enumerated attribute indicates whether CORS must be used when fetching the resource.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-crossorigin
+   */
+  crossorigin?: '' | 'anonymous' | 'use-credentials';
+}
+/**
+ * Icon links may be scoped to a media query, most commonly to serve
+ * separate light and dark variants.
+ */
+interface IconLinkBase extends LinkBase {
+  /**
+   * This attribute specifies the media that the linked resource applies to,
+   * for example `(prefers-color-scheme: dark)`.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-media
+   */
+  media?: string;
+  /**
+   * This enumerated attribute indicates whether CORS must be used when fetching the resource.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-crossorigin
+   */
+  crossorigin?: '' | 'anonymous' | 'use-credentials';
+}
+/**
+ * Favicon link.
+ *
+ * Prefer `rel: 'icon'` over `'shortcut icon'` — the `shortcut` keyword is non-standard
+ * and was only used by older versions of Internet Explorer.
+ */
+interface FaviconLink extends IconLinkBase {
+  rel: 'icon' | 'shortcut icon';
+  /**
+   * This attribute specifies the URL of the linked resource.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-href
+   */
+  href: string;
+  /**
+   * This attribute defines the sizes of the icons for visual media contained in the resource.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-sizes
+   */
+  sizes?: 'any' | '16x16' | '32x32' | '48x48' | '64x64' | '96x96' | '128x128' | '192x192' | '512x512' | (string & Record<never, never>);
+  /**
+   * This attribute is used to define the type of the content linked to.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-type
+   */
+  type?: 'image/png' | 'image/svg+xml' | 'image/x-icon' | 'image/gif' | 'image/webp' | (string & Record<never, never>);
+}
+/**
+ * Apple touch icon link
+ */
+interface AppleTouchIconLink extends IconLinkBase {
+  rel: 'apple-touch-icon';
+  /**
+   * This attribute specifies the URL of the linked resource.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-href
+   */
+  href: string;
+  /**
+   * This attribute defines the sizes of the icons for visual media contained in the resource.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-sizes
+   */
+  sizes?: '180x180' | '152x152' | '120x120' | '76x76' | (string & Record<never, never>);
+  /**
+   * This attribute is used to define the type of the content linked to.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-type
+   */
+  type?: 'image/png' | (string & Record<never, never>);
+}
+/**
+ * Mask icon link (Safari pinned tab). Requires `color`.
+ *
+ * @see https://developer.apple.com/library/archive/documentation/AppleApplications/Reference/SafariWebContent/pinnedTabs/pinnedTabs.html
+ */
+interface MaskIconLink extends IconLinkBase {
+  rel: 'mask-icon';
+  /**
+   * This attribute specifies the URL of the linked resource.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-href
+   */
+  href: string;
+  /**
+   * The color for the mask icon. Required per spec.
+   *
+   * @see https://html.spec.whatwg.org/multipage/semantics.html#attr-link-color
+   */
+  color: string;
+}
+/**
+ * Manifest link
+ */
+interface ManifestLink extends LinkBase {
+  rel: 'manifest';
+  /**
+   * This attribute specifies the URL of the linked resource.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-href
+   */
+  href: string;
+  /**
+   * This attribute is used to define the type of the content linked to.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-type
+   */
+  type?: 'application/manifest+json' | (string & Record<never, never>);
+  /**
+   * This enumerated attribute indicates whether CORS must be used when fetching the resource.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-crossorigin
+   */
+  crossorigin?: '' | 'anonymous' | 'use-credentials';
+}
+/**
+ * Canonical link
+ */
+interface CanonicalLink extends LinkBase {
+  rel: 'canonical';
+  /**
+   * This attribute specifies the URL of the linked resource.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-href
+   */
+  href: string;
+}
+/**
+ * DNS-prefetch link (no events, minimal props)
+ */
+interface DnsPrefetchLink extends LinkBase {
+  rel: 'dns-prefetch';
+  /**
+   * This attribute specifies the URL of the linked resource.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-href
+   */
+  href: string;
+}
+/**
+ * Preconnect link (no events)
+ */
+interface PreconnectLink extends LinkBase {
+  rel: 'preconnect';
+  /**
+   * This attribute specifies the URL of the linked resource.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-href
+   */
+  href: string;
+  /**
+   * This enumerated attribute indicates whether CORS must be used when fetching the resource.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-crossorigin
+   */
+  crossorigin?: '' | 'anonymous' | 'use-credentials';
+}
+/**
+ * Prerender link
+ */
+interface PrerenderLink extends LinkBase {
+  rel: 'prerender';
+  /**
+   * This attribute specifies the URL of the linked resource.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-href
+   */
+  href: string;
+}
+/**
+ * Alternate language link (hreflang translations)
+ */
+interface AlternateLanguageLink extends LinkBase {
+  rel: 'alternate';
+  /**
+   * This attribute specifies the URL of the linked resource.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-href
+   */
+  href: string;
+  /**
+   * This attribute indicates the language of the linked resource.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-hreflang
+   */
+  hreflang: 'x-default' | 'en' | 'en-US' | 'en-GB' | 'de' | 'fr' | 'es' | 'it' | 'ja' | 'ko' | 'nl' | 'pl' | 'pt' | 'pt-BR' | 'ru' | 'zh' | 'zh-CN' | 'zh-TW' | 'ar' | 'hi' | 'id' | 'th' | 'tr' | 'uk' | 'vi' | (string & Record<never, never>);
+  /**
+   * The title attribute defines the title of the link.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-title
+   */
+  title?: string;
+  /**
+   * This attribute is used to define the type of the content linked to.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-type
+   */
+  type?: string;
+  /**
+   * This attribute specifies the media that the linked resource applies to.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-media
+   */
+  media?: string;
+}
+/**
+ * Alternate feed link (RSS, Atom, JSON Feed)
+ */
+interface AlternateFeedLink extends LinkBase {
+  rel: 'alternate';
+  /**
+   * This attribute specifies the URL of the linked resource.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-href
+   */
+  href: string;
+  /**
+   * This attribute is used to define the type of the content linked to.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-type
+   */
+  type: 'application/rss+xml' | 'application/atom+xml' | 'application/json' | (string & Record<never, never>);
+  /**
+   * The title attribute defines the title of the link.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-title
+   */
+  title?: string;
+  /**
+   * This attribute indicates the language of the linked resource.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-hreflang
+   */
+  hreflang?: 'x-default' | 'en' | 'en-US' | 'en-GB' | 'de' | 'fr' | 'es' | 'it' | 'ja' | 'ko' | 'nl' | 'pl' | 'pt' | 'pt-BR' | 'ru' | 'zh' | 'zh-CN' | 'zh-TW' | 'ar' | 'hi' | 'id' | 'th' | 'tr' | 'uk' | 'vi' | (string & Record<never, never>);
+}
+/**
+ * Alternate media link (responsive/device-specific)
+ */
+interface AlternateMediaLink extends LinkBase {
+  rel: 'alternate';
+  /**
+   * This attribute specifies the URL of the linked resource.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-href
+   */
+  href: string;
+  /**
+   * This attribute specifies the media that the linked resource applies to.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-media
+   */
+  media: string;
+  /**
+   * The title attribute defines the title of the link.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-title
+   */
+  title?: string;
+  /**
+   * This attribute is used to define the type of the content linked to.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-type
+   */
+  type?: string;
+}
+/**
+ * Bare alternate link without hreflang, type, or media.
+ * Valid HTML, typically used as a fallback or generic alternate.
+ */
+interface BareAlternateLink extends LinkBase {
+  rel: 'alternate';
+  /**
+   * This attribute specifies the URL of the linked resource.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-href
+   */
+  href: string;
+}
+/**
+ * Author link
+ */
+interface AuthorLink extends LinkBase {
+  rel: 'author';
+  href: string;
+}
+/**
+ * License link
+ */
+interface LicenseLink extends LinkBase {
+  rel: 'license';
+  href: string;
+}
+/**
+ * Help link
+ */
+interface HelpLink extends LinkBase {
+  rel: 'help';
+  href: string;
+}
+/**
+ * Search link
+ */
+interface SearchLink extends LinkBase {
+  rel: 'search';
+  href: string;
+  type?: 'application/opensearchdescription+xml' | (string & Record<never, never>);
+  title?: string;
+}
+/**
+ * Prev/Next navigation links
+ */
+interface PrevLink extends LinkBase {
+  rel: 'prev';
+  href: string;
+}
+interface NextLink extends LinkBase {
+  rel: 'next';
+  href: string;
+}
+/**
+ * Pingback link
+ */
+interface PingbackLink extends LinkBase {
+  rel: 'pingback';
+  href: string;
+}
+/**
+ * Me link. Identifies the resource as representing the current user
+ * (IndieWeb / rel-me verification, Mastodon profile verification).
+ *
+ * @see https://html.spec.whatwg.org/multipage/links.html#link-type-me
+ */
+interface MeLink extends LinkBase {
+  rel: 'me';
+  href: string;
+}
+/**
+ * Privacy policy link.
+ *
+ * @see https://html.spec.whatwg.org/multipage/links.html#link-type-privacy-policy
+ */
+interface PrivacyPolicyLink extends LinkBase {
+  rel: 'privacy-policy';
+  href: string;
+}
+/**
+ * Terms of service link.
+ *
+ * @see https://html.spec.whatwg.org/multipage/links.html#link-type-terms-of-service
+ */
+interface TermsOfServiceLink extends LinkBase {
+  rel: 'terms-of-service';
+  href: string;
+}
+/**
+ * Expect link. Blocks rendering until a named element is present and ready.
+ *
+ * @see https://html.spec.whatwg.org/multipage/links.html#link-type-expect
+ */
+interface ExpectLink extends LinkBase {
+  rel: 'expect';
+  href: string;
+  blocking?: 'render';
+}
+/**
+ * Webmention endpoint link (IndieWeb).
+ *
+ * @see https://www.w3.org/TR/webmention/
+ */
+interface WebmentionLink extends LinkBase {
+  rel: 'webmention';
+  href: string;
+}
+/**
+ * Compression dictionary link (experimental).
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/link#compression-dictionary
+ */
+interface CompressionDictionaryLink extends LinkBase {
+  rel: 'compression-dictionary';
+  href: string;
+}
+/**
+ * Sitemap link. Points to a sitemap for the site.
+ *
+ * @see https://www.iana.org/assignments/link-relations/link-relations.xhtml
+ */
+interface SitemapLink extends LinkBase {
+  rel: 'sitemap';
+  href: string;
+  type?: 'application/xml' | (string & Record<never, never>);
+  title?: string;
+}
+/**
+ * Apple touch startup image link. Specifies a splash screen image for iOS
+ * when a web app is launched from the home screen.
+ *
+ * @see https://developer.apple.com/library/archive/documentation/AppleApplications/Reference/SafariWebContent/ConfiguringWebApplications/ConfiguringWebApplications.html
+ */
+interface AppleTouchStartupImageLink extends LinkBase {
+  rel: 'apple-touch-startup-image';
+  href: string;
+  media?: string;
+}
+/**
+ * AMP HTML link. Points to the AMP version of the current document.
+ *
+ * @see https://amp.dev/documentation/guides-and-tutorials/start/create/prepare_for_discovery/
+ */
+interface AmpHtmlLink extends LinkBase {
+  rel: 'amphtml';
+  href: string;
+}
+/**
+ * WebSub hub link. Points to a WebSub hub for real-time content distribution.
+ *
+ * @see https://www.w3.org/TR/websub/
+ */
+interface HubLink extends LinkBase {
+  rel: 'hub';
+  href: string;
+}
+/**
+ * Alternate stylesheet link. User-selectable alternate stylesheet.
+ * Requires a `title` to appear in the browser's stylesheet picker.
+ *
+ * @see https://html.spec.whatwg.org/multipage/semantics.html#rel-alternate-stylesheet
+ */
+interface AlternateStylesheetLink extends LinkBase, LinkHttpEvents {
+  rel: 'alternate stylesheet';
+  href: string;
+  title: string;
+  media?: string;
+  crossorigin?: '' | 'anonymous' | 'use-credentials';
+  integrity?: string;
+  type?: 'text/css' | (string & Record<never, never>);
+  disabled?: boolean;
+}
+/**
+ * Discriminated union of all link types.
+ *
+ * Each named `rel` value maps to a specific interface that enforces per-`rel` required
+ * attributes. For example, `rel="preload"` requires the `as` attribute (see {@link PreloadLink}),
+ * and `rel="mask-icon"` requires `color` (see {@link MaskIconLink}).
+ *
+ * For non-standard `rel` values not covered by {@link KnownLinkRel}, use {@link defineLink}:
+ * ```ts
+ * import { defineLink } from 'unhead'
+ * useHead({ link: [defineLink({ rel: 'openid2.provider', href: 'https://...' })] })
+ * ```
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/rel
+ */
+type Link = StylesheetLink | AlternateStylesheetLink | PreloadLink | ModulepreloadLink | PrefetchLink | FaviconLink | AppleTouchIconLink | MaskIconLink | ManifestLink | CanonicalLink | DnsPrefetchLink | PreconnectLink | PrerenderLink | AlternateLanguageLink | AlternateFeedLink | AlternateMediaLink | BareAlternateLink | AuthorLink | LicenseLink | HelpLink | SearchLink | PrevLink | NextLink | PingbackLink | MeLink | WebmentionLink | PrivacyPolicyLink | TermsOfServiceLink | ExpectLink | CompressionDictionaryLink | SitemapLink | AppleTouchStartupImageLink | AmpHtmlLink | HubLink;
+/**
+ * Known meta name values
+ */
+type MetaNames = 'apple-itunes-app' | 'apple-mobile-web-app-capable' | 'apple-mobile-web-app-status-bar-style' | 'apple-mobile-web-app-title' | 'application-name' | 'author' | 'color-scheme' | 'creator' | 'description' | 'fb:app_id' | 'fediverse:creator' | 'format-detection' | 'generator' | 'google-site-verification' | 'google' | 'googlebot' | 'keywords' | 'mobile-web-app-capable' | 'msapplication-Config' | 'msapplication-TileColor' | 'msapplication-TileImage' | 'publisher' | 'rating' | 'referrer' | 'robots' | 'theme-color' | 'twitter:app:id:googleplay' | 'twitter:app:id:ipad' | 'twitter:app:id:iphone' | 'twitter:app:name:googleplay' | 'twitter:app:name:ipad' | 'twitter:app:name:iphone' | 'twitter:app:url:googleplay' | 'twitter:app:url:ipad' | 'twitter:app:url:iphone' | 'twitter:card' | 'twitter:creator:id' | 'twitter:creator' | 'twitter:data:1' | 'twitter:data:2' | 'twitter:description' | 'twitter:image:alt' | 'twitter:image' | 'twitter:label:1' | 'twitter:label:2' | 'twitter:player:height' | 'twitter:player:stream' | 'twitter:player:width' | 'twitter:player' | 'twitter:site:id' | 'twitter:site' | 'twitter:title' | 'viewport';
+/**
+ * Known meta property values (OpenGraph, etc.)
+ */
+type MetaProperties = 'article:author' | 'article:expiration_time' | 'article:modified_time' | 'article:published_time' | 'article:section' | 'article:tag' | 'book:author' | 'book:isbn' | 'book:release_date' | 'book:tag' | 'fb:app:id' | 'og:audio:secure_url' | 'og:audio:type' | 'og:audio:url' | 'og:description' | 'og:determiner' | 'og:image:height' | 'og:image:secure_url' | 'og:image:type' | 'og:image:url' | 'og:image:width' | 'og:image' | 'og:locale:alternate' | 'og:locale' | 'og:site:name' | 'og:title' | 'og:type' | 'og:url' | 'og:video:height' | 'og:video:secure_url' | 'og:video:type' | 'og:video:url' | 'og:video:width' | 'og:video' | 'payment:amount' | 'payment:currency' | 'payment:description' | 'payment:expires_at' | 'payment:id' | 'payment:status' | 'payment:success_url' | 'profile:first_name' | 'profile:gender' | 'profile:last_name' | 'profile:username';
+/**
+ * Base properties shared by all meta types
+ */
+interface MetaBase extends Pick<GlobalAttributes, 'id'>, DataKeys {
+  /**
+   * A valid media query list that can be included to set the media the metadata applies to.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/meta/name/theme-color
+   */
+  media?: '(prefers-color-scheme: light)' | '(prefers-color-scheme: dark)' | (string & Record<never, never>);
+}
+/**
+ * Name-based meta (description, viewport, robots, etc.)
+ * Mutual exclusion: no property, no http-equiv, no charset
+ */
+interface NameMeta extends MetaBase {
+  /**
+   * The name and content attributes can be used together to provide document metadata
+   * in terms of name-value pairs.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/meta#attr-name
+   */
+  'name': MetaNames | (string & Record<never, never>);
+  /**
+   * This attribute contains the value for the name attribute.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/meta#attr-content
+   */
+  'content': string | number;
+  'property'?: never;
+  'http-equiv'?: never;
+  'charset'?: never;
+}
+/**
+ * Property-based meta (OpenGraph, etc.)
+ * Mutual exclusion: no name, no http-equiv, no charset
+ */
+interface PropertyMeta extends MetaBase {
+  /**
+   * The property attribute is used to define a property associated with the content attribute.
+   * Mainly used for og and twitter meta tags.
+   */
+  'property': MetaProperties | (string & Record<never, never>);
+  /**
+   * This attribute contains the value for the property attribute.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/meta#attr-content
+   */
+  'content': string | number;
+  'name'?: never;
+  'http-equiv'?: never;
+  'charset'?: never;
+}
+/**
+ * HTTP-equiv meta
+ * Mutual exclusion: no name, no property, no charset
+ */
+interface HttpEquivMeta extends MetaBase {
+  /**
+   * Defines a pragma directive. The attribute is named http-equiv(alent) because all
+   * the allowed values are names of particular HTTP headers.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/meta#attr-http-equiv
+   */
+  'http-equiv': 'content-security-policy' | 'content-type' | 'default-style' | 'x-ua-compatible' | 'refresh' | 'accept-ch' | 'origin-trial' | (string & Record<never, never>);
+  /**
+   * This attribute contains the value for the http-equiv attribute.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/meta#attr-content
+   */
+  'content': string | number;
+  'name'?: never;
+  'property'?: never;
+  'charset'?: never;
+}
+/**
+ * Charset meta (standalone, no content)
+ * Mutual exclusion: no name, no property, no http-equiv, no content
+ */
+interface CharsetMeta extends MetaBase {
+  /**
+   * This attribute declares the document's character encoding.
+   * If the attribute is present, its value must be an ASCII case-insensitive match for the string "utf-8".
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/meta#attr-charset
+   */
+  'charset': 'utf-8' | (string & Record<never, never>);
+  'name'?: never;
+  'property'?: never;
+  'http-equiv'?: never;
+  'content'?: never;
+}
+/**
+ * Discriminated union of all meta types.
+ * Provides mutual exclusion of name/property/http-equiv/charset.
+ */
+type Meta = NameMeta | PropertyMeta | HttpEquivMeta | CharsetMeta;
+/**
+ * Content for noscript elements - either textContent or innerHTML, not both
+ */
+type NoscriptContent = {
+  /**
+   * Sets the textContent of an element. Safer for XSS.
+   */
+  textContent?: string;
+  innerHTML?: never;
+} | {
+  textContent?: never;
+  /**
+   * Text content of the tag.
+   *
+   * Warning: This is not safe for XSS. Do not use this with user input, use `textContent` instead.
+   */
+  innerHTML?: string;
+};
+type Noscript$1 = Pick<GlobalAttributes, 'id' | 'class' | 'style'> & NoscriptContent;
+/**
+ * A JSON speculation rule set.
+ *
+ * @see https://html.spec.whatwg.org/multipage/speculative-loading.html#speculation-rules
+ */
+interface SpeculationRules {
+  /** Identifies speculative requests through the `Sec-Speculation-Tags` header. */
+  tag?: string | null;
+  prefetch?: readonly SpeculationRule[];
+  prerender?: readonly SpeculationRule[];
+}
+type SpeculationRuleEagerness = 'immediate' | 'eager' | 'moderate' | 'conservative' | (string & Record<never, never>);
+type SpeculationRuleRequirement = 'anonymous-client-ip-when-cross-origin';
+interface SpeculationRuleBase {
+  /** A hint about when the browser should consider the speculative load. */
+  eagerness?: SpeculationRuleEagerness;
+  /** The referrer policy for the speculative request. */
+  referrer_policy?: ReferrerPolicy;
+  /** Identifies this rule through the `Sec-Speculation-Tags` header. */
+  tag?: string | null;
+  /** Required browser capabilities for executing the rule. */
+  requires?: readonly SpeculationRuleRequirement[];
+  /** Expected `No-Vary-Search` response header value. */
+  expects_no_vary_search?: string;
+  /** The browsing context in which a prerendered page is expected to open. */
+  target_hint?: '_blank' | '_self' | '_parent' | '_top' | (string & Record<never, never>);
+}
+/** An explicit list of URLs to speculate. */
+type SpeculationRuleList = SpeculationRuleBase & {
+  source?: 'list';
+  urls: readonly string[];
+  where?: never;
+  /** Selects the base URL used to resolve `urls`. */
+  relative_to?: 'ruleset' | 'document';
+};
+/** A rule which selects links from the current document. */
+type SpeculationRuleDocument = SpeculationRuleBase & {
+  urls?: never;
+  relative_to?: never;
+} & ({
+  source: 'document';
+  where?: SpeculationRuleWhere;
+} | {
+  source?: never;
+  where: SpeculationRuleWhere;
+});
+type SpeculationRule = SpeculationRuleList | SpeculationRuleDocument;
+/** The object form accepted by `href_matches`, equivalent to `URLPatternInit`. */
+interface SpeculationRuleUrlPattern {
+  baseURL?: string;
+  protocol?: string;
+  username?: string;
+  password?: string;
+  hostname?: string;
+  port?: string;
+  pathname?: string;
+  search?: string;
+  hash?: string;
+}
+type SpeculationRuleUrlPatternInput = string | SpeculationRuleUrlPattern;
+/**
+ * A recursive document rule predicate. Exactly one predicate operator is valid
+ * at each level; only `href_matches` also accepts `relative_to`.
+ */
+type SpeculationRuleWhere = {
+  and: readonly SpeculationRuleWhere[];
+  or?: never;
+  not?: never;
+  href_matches?: never;
+  selector_matches?: never;
+  relative_to?: never;
+} | {
+  and?: never;
+  or: readonly SpeculationRuleWhere[];
+  not?: never;
+  href_matches?: never;
+  selector_matches?: never;
+  relative_to?: never;
+} | {
+  and?: never;
+  or?: never;
+  not: SpeculationRuleWhere;
+  href_matches?: never;
+  selector_matches?: never;
+  relative_to?: never;
+} | {
+  and?: never;
+  or?: never;
+  not?: never;
+  href_matches: SpeculationRuleUrlPatternInput | readonly SpeculationRuleUrlPatternInput[];
+  selector_matches?: never;
+  relative_to?: 'ruleset' | 'document';
+} | {
+  and?: never;
+  or?: never;
+  not?: never;
+  href_matches?: never;
+  selector_matches: string | readonly string[];
+  relative_to?: never;
+};
+/**
+ * Events that fire on script elements (load/error)
+ */
+type ScriptHttpEvents = Pick<HttpEventAttributes, 'onload' | 'onerror'>;
+/**
+ * Base properties shared by all script types
+ */
+interface ScriptBase extends Pick<GlobalAttributes, 'nonce' | 'id'>, Blocking, DataKeys {
+  /**
+   * Provides a hint of the relative priority to use when fetching an external script.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script#attr-fetchpriority
+   */
+  fetchpriority?: 'high' | 'low' | 'auto';
+  /**
+   * Indicates which referrer to send when fetching the script, or resources fetched by the script.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script#attr-referrerpolicy
+   */
+  referrerpolicy?: ReferrerPolicy;
+}
+/**
+ * Props that are invalid on non-loadable script types (data scripts, inline scripts)
+ */
+interface NoLoadableScriptProps {
+  src?: never;
+  async?: never;
+  defer?: never;
+  integrity?: never;
+  crossorigin?: never;
+  nomodule?: never;
+}
+/**
+ * Content for data scripts — requires exactly one of `textContent` or
+ * `innerHTML`. Data scripts (JSON-LD, speculation rules, application/json) must
+ * carry inline content; an empty payload is invalid.
+ */
+type DataScriptTextContent<T = string | Record<string, unknown>> = {
+  /**
+   * Sets the textContent of an element. Safer for XSS.
+   * Can be a string or an object that will be serialized to JSON.
+   */
+  textContent: T;
+  innerHTML?: never;
+} | {
+  textContent?: never;
+  /**
+   * Sets the innerHTML of an element.
+   * Can be a string or an object that will be serialized to JSON.
+   */
+  innerHTML: T;
+};
+/**
+ * External JavaScript (fires events)
+ */
+interface ExternalScript extends ScriptBase, ScriptHttpEvents {
+  /**
+   * This attribute specifies the URI of an external script.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script#attr-src
+   */
+  src: string;
+  /**
+   * This attribute indicates the type of script represented.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script#attr-type
+   */
+  type?: '' | 'text/javascript';
+  /**
+   * For classic scripts, if the async attribute is present,
+   * then the classic script will be fetched in parallel to parsing and evaluated as soon as it is available.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script#attr-async
+   */
+  async?: Booleanable;
+  /**
+   * This Boolean attribute is set to indicate to a browser that the script is meant to be executed after the document
+   * has been parsed, but before firing DOMContentLoaded.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script#attr-defer
+   */
+  defer?: Booleanable;
+  /**
+   * Normal script elements pass minimal information to the window.onerror
+   * for scripts which do not pass the standard CORS checks.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script#attr-crossorigin
+   */
+  crossorigin?: '' | 'anonymous' | 'use-credentials';
+  /**
+   * This attribute contains inline metadata that a user agent can use to verify
+   * that a fetched resource has been delivered free of unexpected manipulation.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script#attr-integrity
+   */
+  integrity?: string;
+  /**
+   * This Boolean attribute is set to indicate that the script should not be executed in browsers
+   * that support ES modules.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script#attr-nomodule
+   */
+  nomodule?: Booleanable;
+  /** Inline content is ignored when `src` is present. */
+  textContent?: never;
+  /** Inline content is ignored when `src` is present. */
+  innerHTML?: never;
+}
+/**
+ * ES Module script (fires events)
+ */
+interface ModuleScript extends ScriptBase, ScriptHttpEvents {
+  /**
+   * This attribute specifies the URI of an external script.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script#attr-src
+   */
+  src: string;
+  /**
+   * This attribute indicates the type of script represented.
+   * Required discriminant for module scripts.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script#attr-type
+   */
+  type: 'module';
+  /**
+   * For module scripts, if the async attribute is present then the scripts and all their dependencies
+   * will be executed in the defer queue.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script#attr-async
+   */
+  async?: Booleanable;
+  /**
+   * Normal script elements pass minimal information to the window.onerror
+   * for scripts which do not pass the standard CORS checks.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script#attr-crossorigin
+   */
+  crossorigin?: '' | 'anonymous' | 'use-credentials';
+  /**
+   * This attribute contains inline metadata that a user agent can use to verify
+   * that a fetched resource has been delivered free of unexpected manipulation.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script#attr-integrity
+   */
+  integrity?: string;
+  /** Inline content is ignored when `src` is present. */
+  textContent?: never;
+  /** Inline content is ignored when `src` is present. */
+  innerHTML?: never;
+}
+/**
+ * Inline JavaScript (no events, no src).
+ * Requires either `textContent` (recommended, XSS-safe) or `innerHTML`.
+ */
+type InlineScript = ScriptBase & NoLoadableScriptProps & {
+  /**
+   * This attribute indicates the type of script represented.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script#attr-type
+   */
+  type?: '' | 'text/javascript';
+} & ({
+  /** Sets the textContent of an element. Safer for XSS. */
+  textContent: string;
+  innerHTML?: never;
+} | {
+  textContent?: never;
+  /**
+   * Sets the innerHTML of an element.
+   *
+   * Warning: not safe for XSS. Prefer `textContent` for inline scripts.
+   */
+  innerHTML: string | Record<string, unknown>;
+});
+/**
+ * Inline ES Module script (no src).
+ * Requires either `textContent` (recommended, XSS-safe) or `innerHTML`.
+ */
+type InlineModuleScript = ScriptBase & NoLoadableScriptProps & {
+  /**
+   * This attribute indicates the type of script represented.
+   * Required discriminant for module scripts.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script#attr-type
+   */
+  type: 'module';
+} & ({
+  /** Sets the textContent of an element. Safer for XSS. */
+  textContent: string;
+  innerHTML?: never;
+} | {
+  textContent?: never;
+  /**
+   * Sets the innerHTML of an element.
+   *
+   * Warning: not safe for XSS. Prefer `textContent` for inline scripts.
+   */
+  innerHTML: string;
+});
+/**
+ * JSON-LD structured data (uses textContent for XSS safety)
+ * Note: For full schema.org typing, use @unhead/schema-org with useSchemaOrg()
+ */
+type JsonLdScript = ScriptBase & NoLoadableScriptProps & DataScriptTextContent & {
+  /**
+   * This attribute indicates the type of script represented.
+   * Required discriminant for JSON-LD scripts.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script#attr-type
+   */
+  type: 'application/ld+json';
+};
+/**
+ * Speculation Rules (uses textContent for safety)
+ */
+type SpeculationRulesScript = ScriptBase & NoLoadableScriptProps & DataScriptTextContent<string | SpeculationRules> & {
+  /**
+   * This attribute indicates the type of script represented.
+   * Required discriminant for speculation rules scripts.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script#attr-type
+   */
+  type: 'speculationrules';
+};
+/**
+ * Import map configuration
+ */
+interface ImportMapConfig {
+  imports: Record<string, string>;
+  scopes?: Record<string, Record<string, string>>;
+}
+/**
+ * Import map. Requires either `textContent` (recommended) or `innerHTML`.
+ */
+type ImportMapScript = ScriptBase & NoLoadableScriptProps & {
+  /**
+   * This attribute indicates the type of script represented.
+   * Required discriminant for import map scripts.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script#attr-type
+   */
+  type: 'importmap';
+} & ({
+  /** Import map content as a string or ImportMapConfig object (auto-serialized). */
+  textContent: string | ImportMapConfig;
+  innerHTML?: never;
+} | {
+  textContent?: never;
+  /** Import map content as a string or ImportMapConfig object (auto-serialized). */
+  innerHTML: string | ImportMapConfig;
+});
+/**
+ * Application JSON script (generic JSON data)
+ */
+type ApplicationJsonScript = ScriptBase & NoLoadableScriptProps & DataScriptTextContent & {
+  /**
+   * This attribute indicates the type of script represented.
+   * Required discriminant for JSON scripts.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script#attr-type
+   */
+  type: 'application/json';
+};
+/**
+ * Discriminated union of all script types.
+ *
+ * Each `type` value maps to a specific interface that enforces per-type constraints.
+ * For example, inline scripts require `textContent` and forbid `src`/`async`/`defer`.
+ *
+ * For custom or non-standard `type` values, use {@link defineScript}:
+ * ```ts
+ * import { defineScript } from 'unhead'
+ * useHead({ script: [defineScript({ type: 'text/plain', textContent: '...' })] })
+ * ```
+ */
+type Script = ExternalScript | ModuleScript | InlineScript | InlineModuleScript | JsonLdScript | SpeculationRulesScript | ImportMapScript | ApplicationJsonScript;
+interface Style$1 extends Pick<GlobalAttributes, 'nonce' | 'id'>, Blocking {
+  /**
+   * This attribute defines which media the style should be applied to.
+   * Its value is a media query, which defaults to all if the attribute is missing.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/style#attr-media
+   */
+  media?: string;
+  /**
+   * A cryptographic nonce (number used once) used to allow inline styles in a style-src Content-Security-Policy.
+   * The server must generate a unique nonce value each time it transmits a policy.
+   * It is critical to provide a nonce that cannot be guessed as bypassing a resource's policy is otherwise trivial.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/style#attr-nonce
+   */
+  nonce?: string;
+  /**
+   * This attribute specifies alternative style sheet sets.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/style#attr-title
+   */
+  title?: string;
+}
+interface TemplateParamsAugmentations {}
+interface SchemaAugmentations {
+  title: TagPriority;
+  titleTemplate: TagPriority;
+  base: ResolvesDuplicates & TagPriority;
+  htmlAttrs: ResolvesDuplicates & TagPriority;
+  bodyAttrs: ResolvesDuplicates & TagPriority;
+  link: TagPriority & TagPosition & ResolvesDuplicates & ProcessesTemplateParams;
+  meta: TagPriority & ResolvesDuplicates & ProcessesTemplateParams;
+  style: TagPriority & TagPosition & StringInnerContent & ResolvesDuplicates & ProcessesTemplateParams;
+  script: TagPriority & TagPosition & InnerContent & ResolvesDuplicates & ProcessesTemplateParams;
+  noscript: TagPriority & TagPosition & StringInnerContent & ResolvesDuplicates & ProcessesTemplateParams;
+}
+type MaybeArray<T> = T | T[];
+interface UnheadBodyAttributesWithoutEvents extends Omit<BodyAttributesWithoutEvents, 'class' | 'style'> {
+  /**
+   * The class global attribute is a space-separated list of the case-sensitive classes of the element.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/class
+   */
+  class?: MaybeArray<ResolvableValue$1<Stringable>> | Record<string, ResolvableValue$1<boolean>>;
+  /**
+   * The style attribute contains CSS styling declarations to be applied to the element.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/style
+   */
+  style?: MaybeArray<ResolvableValue$1<Stringable>> | Record<string, ResolvableValue$1<Stringable>>;
+}
+interface UnheadHtmlAttributes extends Omit<HtmlAttributes$1, 'class' | 'style'> {
+  /**
+   * The class global attribute is a space-separated list of the case-sensitive classes of the element.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/class
+   */
+  class?: MaybeArray<ResolvableValue$1<Stringable>> | Record<string, ResolvableValue$1<boolean>>;
+  /**
+   * The style attribute contains CSS styling declarations to be applied to the element.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/style
+   */
+  style?: MaybeArray<ResolvableValue$1<Stringable>> | Record<string, ResolvableValue$1<Stringable>>;
+}
+/**
+ * Unhead meta with support for array content values.
+ * Content is required (use `null` explicitly to remove a meta tag).
+ */
+type UnheadMeta = (Omit<NameMeta, 'content'> & {
+  content: MaybeArray<string | number> | null;
+}) | (Omit<PropertyMeta, 'content'> & {
+  content: MaybeArray<string | number> | null;
+}) | (Omit<HttpEquivMeta, 'content'> & {
+  content: MaybeArray<string | number> | null;
+}) | CharsetMeta;
+type MaybeEventFnHandlers<T> = { [key in keyof T]?: T[key] | ((e: Event) => void); };
+type ResolvableTitle$1 = ResolvableValue$1<Stringable> | ResolvableProperties$1<({
+  textContent: string;
+} & SchemaAugmentations['title'])>;
+type ResolvableTitleTemplate$1 = string | ((title?: string) => string | null) | null | ({
+  textContent: string | ((title?: string) => string | null);
+} & SchemaAugmentations['titleTemplate']);
+type ResolvableBase$1 = DistributeResolvable$1<Base$1, SchemaAugmentations['base']>;
+type DistributeResolvable$1<T, Aug> = T extends any ? ResolvableProperties$1<T & Aug> : never;
+type DistributeResolvableWithEvents$1<T, Aug, Events> = T extends any ? T extends Events ? ResolvableProperties$1<Omit<T, keyof Events> & Aug> & MaybeEventFnHandlers<Events> : ResolvableProperties$1<T & Aug> : never;
+type ResolvableLink$1 = DistributeResolvableWithEvents$1<Link, SchemaAugmentations['link'], LinkHttpEvents>;
+type ResolvableMeta$1 = DistributeResolvable$1<UnheadMeta, SchemaAugmentations['meta']>;
+type ResolvableStyle$1 = ResolvableProperties$1<Style$1 & DataKeys & SchemaAugmentations['style']> | string;
+type ResolvableScript$1 = DistributeResolvableWithEvents$1<Script, SchemaAugmentations['script'], ScriptHttpEvents> | string;
+type ResolvableNoscript$1 = ResolvableProperties$1<Noscript$1 & DataKeys & SchemaAugmentations['noscript']> | string;
+type ResolvableHtmlAttributes$1 = ResolvableProperties$1<UnheadHtmlAttributes & DataKeys & SchemaAugmentations['htmlAttrs']>;
+type ResolvableBodyAttributes$1 = ResolvableProperties$1<UnheadBodyAttributesWithoutEvents & DataKeys & SchemaAugmentations['bodyAttrs']> & MaybeEventFnHandlers<BodyEvents>;
+type ResolvableTemplateParams = {
+  separator?: '|' | '-' | '·' | string;
+} & Record<string, null | string | Record<string, string>> & TemplateParamsAugmentations;
+interface ResolvableHead {
+  /**
+   * The `<title>` HTML element defines the document's title that is shown in a browser's title bar or a page's tab.
+   * It only contains text; tags within the element are ignored.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/title
+   */
+  title?: ResolvableTitle$1;
+  /**
+   * The `<base>` HTML element specifies the base URL to use for all relative URLs in a document.
+   * There can be only one <base> element in a document.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/base
+   */
+  base?: ResolvableValue$1<ResolvableBase$1>;
+  /**
+   * The `<link>` HTML element specifies relationships between the current document and an external resource.
+   * This element is most commonly used to link to stylesheets, but is also used to establish site icons
+   * (both "favicon" style icons and icons for the home screen and apps on mobile devices) among other things.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-as
+   */
+  link?: ResolvableValue$1<ResolvableValue$1<ResolvableLink$1>[]>;
+  /**
+   * The `<meta>` element represents metadata that cannot be expressed in other HTML elements, like `<link>` or `<script>`.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/meta
+   */
+  meta?: ResolvableValue$1<ResolvableValue$1<ResolvableMeta$1>[]>;
+  /**
+   * The `<style>` HTML element contains style information for a document, or part of a document.
+   * It contains CSS, which is applied to the contents of the document containing the `<style>` element.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/style
+   */
+  style?: ResolvableValue$1<ResolvableValue$1<(ResolvableStyle$1)>[]>;
+  /**
+   * The `<script>` HTML element is used to embed executable code or data; this is typically used to embed or refer to JavaScript code.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script
+   */
+  script?: ResolvableValue$1<ResolvableValue$1<(ResolvableScript$1)>[]>;
+  /**
+   * The `<noscript>` HTML element defines a section of HTML to be inserted if a script type on the page is unsupported
+   * or if scripting is currently turned off in the browser.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/noscript
+   */
+  noscript?: ResolvableValue$1<ResolvableValue$1<(ResolvableNoscript$1)>[]>;
+  /**
+   * Attributes for the `<html>` HTML element.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/html
+   */
+  htmlAttrs?: ResolvableValue$1<ResolvableHtmlAttributes$1>;
+  /**
+   * Attributes for the `<body>` HTML element.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/body
+   */
+  bodyAttrs?: ResolvableValue$1<ResolvableBodyAttributes$1>;
+  /**
+   * Generate the title from a template.
+   *
+   * Should include a `%s` placeholder for the title, for example `%s - My Site`.
+   */
+  titleTemplate?: ResolvableTitleTemplate$1;
+  /**
+   * Variables used to substitute in the title and meta content.
+   */
+  templateParams?: ResolvableTemplateParams;
+}
+interface SerializableHead {
+  title?: string;
+  titleTemplate?: string;
+  base?: Base$1 & DataKeys & SchemaAugmentations['base'];
+  templateParams?: Record<string, any>;
+  link?: (Link & SchemaAugmentations['link'])[];
+  meta?: (Meta & SchemaAugmentations['meta'])[];
+  style?: (Style$1 & DataKeys & SchemaAugmentations['style'])[];
+  script?: (Script & SchemaAugmentations['script'])[];
+  noscript?: (Noscript$1 & DataKeys & SchemaAugmentations['noscript'])[];
+  htmlAttrs?: HtmlAttributes$1 & DataKeys & SchemaAugmentations['htmlAttrs'];
+  bodyAttrs?: BodyAttributesWithoutEvents & DataKeys & BodyEvents & SchemaAugmentations['bodyAttrs'];
+}
+type RawInput<K extends keyof SerializableHead> = Required<SerializableHead>[K] extends Array<infer T> ? T : Required<SerializableHead>[K];
+interface ResolvesDuplicates {
+  /**
+   * By default, tags which share the same unique key `name`, `property` are de-duped. To allow duplicates
+   * to be made you can provide a unique key for each entry.
+   */
+  key?: string;
+  /**
+   * The strategy to use when a duplicate tag is encountered.
+   *
+   * - `replace` - Replace the existing tag with the new tag
+   * - `merge` - Merge the existing tag with the new tag
+   *
+   * @default 'replace' (some tags will default to 'merge', such as htmlAttr)
+   */
+  tagDuplicateStrategy?: 'replace' | 'merge';
+}
+type ValidTagPositions = 'head' | 'bodyClose' | 'bodyOpen';
+interface TagPosition {
+  /**
+   * Specify where to render the tag.
+   *
+   * @default 'head'
+   */
+  tagPosition?: ValidTagPositions;
+}
+type InnerContentVal = string | Record<string, any>;
+interface InnerContent {
+  /**
+   * Text content of the tag.
+   *
+   * Warning: This is not safe for XSS. Do not use this with user input, use `textContent` instead.
+   */
+  innerHTML?: InnerContentVal;
+  /**
+   * Sets the textContent of an element. Safer for XSS.
+   */
+  textContent?: InnerContentVal;
+}
+/**
+ * String-only inner content for elements that don't support object serialization (style, noscript).
+ */
+interface StringInnerContent {
+  /**
+   * Text content of the tag.
+   *
+   * Warning: This is not safe for XSS. Do not use this with user input, use `textContent` instead.
+   */
+  innerHTML?: string;
+  /**
+   * Sets the textContent of an element. Safer for XSS.
+   */
+  textContent?: string;
+}
+interface TagPriority {
+  /**
+   * The priority for rendering the tag, without this all tags are rendered as they are registered
+   * (besides some special tags).
+   *
+   * The following special tags have default priorities:
+   * -2 `<meta charset ...>`
+   * -1 `<base>`
+   * 0 `<meta http-equiv="content-security-policy" ...>`
+   *
+   * All other tags have a default priority of 10: `<meta>`, `<script>`, `<link>`, `<style>`, etc
+   */
+  tagPriority?: number | 'critical' | 'high' | 'low' | `before:${string}` | `after:${string}`;
+}
+type TagKey = keyof ResolvableHead | InternalTagKey;
+/**
+ * Internal tag types used by plugins
+ * @internal
+ */
+type InternalTagKey = '_flatMeta';
+type TemplateParams = {
+  separator?: '|' | '-' | '·' | string;
+} & Record<string, null | string | Record<string, string>>;
+interface ProcessesTemplateParams {
+  processTemplateParams?: boolean;
+}
+interface HasTemplateParams {
+  templateParams?: TemplateParams;
+}
+interface HeadTag extends TagPriority, TagPosition, ResolvesDuplicates, HasTemplateParams {
+  tag: TagKey;
+  props: Record<string, string>;
+  processTemplateParams?: boolean;
+  innerHTML?: string;
+  textContent?: string;
+  /**
+   * @internal
+   */
+  _w?: number;
+  /**
+   * @internal
+   */
+  _p?: number;
+  /**
+   * @internal
+   */
+  _d?: string;
+  /**
+   * @internal
+   */
+  _h?: string;
+  /**
+   * Source file:line that created this tag (devtools only).
+   * @internal
+   */
+  _source?: string;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/unhead@3.3.2_@voidzero-dev+vite-plus-core@0.2.9_rollup@4.62.4/node_modules/unhead/dist/shared/unhead.DoGkYKkW.d.ts
+type UseScriptStatus = 'awaitingLoad' | 'loading' | 'loaded' | 'error' | 'removed';
+type BaseScriptApi = Record<symbol | string, any>;
+type HasDiscriminatedParameters<T> = T extends {
+  (first: infer A, ...rest1: any[]): any;
+  (first: infer B, ...rest2: any[]): any;
+} ? A extends B ? B extends A ? false : true : true : false;
+type HasDifferentParameterCounts<T> = T extends {
+  (...args: infer A): any;
+} & {
+  (...args: infer B): any;
+} ? A['length'] extends B['length'] ? B['length'] extends A['length'] ? false : true : true : false;
+type IsOverloadedFunction<T> = HasDiscriminatedParameters<T> extends true ? true : HasDifferentParameterCounts<T> extends true ? true : false;
+type AsVoidFunctions<T extends BaseScriptApi> = { [K in keyof T]: T[K] extends any[] ? T[K] : T[K] extends ((...args: infer A) => any) ? IsOverloadedFunction<T[K]> extends true ? T[K] : (...args: A) => void : T[K] extends Record<any, any> ? AsVoidFunctions<T[K]> : never; };
+type WarmupStrategy = false | 'preload' | 'preconnect' | 'dns-prefetch';
+interface UseScriptWaitForResolve<T = unknown> {
+  <V extends T>(value: V): V;
+  <V extends T>(value: PromiseLike<V>): PromiseLike<V>;
+  (value: T | PromiseLike<T>): T | PromiseLike<T>;
+}
+type UseScriptWaitForInferredResult<T> = [T] extends [void | (() => void)] ? unknown : NonNullable<Awaited<T>>;
+interface UseScriptWaitFor {
+  /**
+   * With an explicit result type, setup may use callback-style registration and
+   * return cleanup. Without one, `waitFor(resolve => resolve(value))` infers it.
+   */
+  <T = never, R = void>(setup: (resolve: UseScriptWaitForResolve<[T] extends [never] ? unknown : T>, reject: (reason?: unknown) => void) => R): Promise<[T] extends [never] ? UseScriptWaitForInferredResult<R> : T>;
+}
+interface UseScriptContextOptions {
+  /**
+   * Aborted when the script is removed or fails to load.
+   */
+  signal: AbortSignal;
+  /**
+   * Wait for an SDK-specific readiness callback. Abort rejection and returned
+   * cleanup are tied to the script lifecycle.
+   */
+  waitFor: UseScriptWaitFor;
+}
+type UseScriptResolver<T extends BaseScriptApi> = (ctx: UseScriptContextOptions) => T | PromiseLike<T | undefined | null> | undefined | null;
+/**
+ * Register a script load trigger. A returned function is treated as cleanup;
+ * other return values are ignored for backwards compatibility.
+ */
+type UseScriptTrigger = (load: () => void) => any;
+interface ScriptInstance<T extends BaseScriptApi> {
+  proxy: AsVoidFunctions<T>;
+  instance?: T;
+  id: string;
+  /**
+   * Aborted when the script is removed or fails to load.
+   */
+  signal: AbortSignal;
+  status: Readonly<UseScriptStatus>;
+  entry?: ActiveHeadEntry<any>;
+  load: () => Promise<T>;
+  warmup: (rel: WarmupStrategy) => ActiveHeadEntry<any>;
+  remove: () => boolean;
+  setupTriggerHandler: (trigger: UseScriptOptions['trigger']) => () => void;
+  onLoaded: (fn: (instance: T) => void | Promise<void>, options?: EventHandlerOptions) => () => void;
+  onError: (fn: (err?: Error) => void | Promise<void>, options?: EventHandlerOptions) => () => void;
+  /**
+   * @internal
+   */
+  _warmupStrategy?: string;
+  /**
+   * @internal
+   */
+  _loadPromise: Promise<T | false>;
+  /**
+   * @internal
+   */
+  _warmupEl: any;
+  /**
+   * @internal
+   */
+  _triggerAbortController?: AbortController | null;
+  /**
+   * @internal
+   */
+  _triggerAbortControllers?: Set<AbortController>;
+  /**
+   * @internal
+   */
+  _triggerPromises?: Promise<void>[];
+  /**
+   * @internal
+   */
+  _setupTriggerHandler: (trigger: UseScriptOptions['trigger'], removeOnError?: boolean) => () => void;
+  /**
+   * @internal
+   */
+  _cbs: {
+    loaded: null | ((instance: T) => void | Promise<void>)[];
+    error: null | ((err?: Error) => void | Promise<void>)[];
+  };
+}
+interface EventHandlerOptions {
+  /**
+   * Used to dedupe the event, allowing you to have an event run only a single time.
+   */
+  key?: string;
+}
+interface UseScriptOptions<T extends BaseScriptApi = Record<string, any>> extends HeadEntryOptions {
+  /**
+   * Create a consumer-owned handle without changing the shared script lifecycle.
+   * Existing callers receive the cached shared script unless this is enabled.
+   */
+  scope?: boolean;
+  /**
+   * Resolve the script instance from the window. This legacy callback is always
+   * called without arguments. It may return the API asynchronously.
+   */
+  use?: () => T | PromiseLike<T | undefined | null> | undefined | null;
+  /**
+   * Resolve the script API with lifecycle helpers. Prefer this over `use` when
+   * readiness needs an abort signal or `waitFor()` callback bridge.
+   */
+  resolve?: UseScriptResolver<T>;
+  /**
+   * The trigger to load the script:
+   * - `undefined` | `client` - (Default) Load the script on the client when this js is loaded.
+   * - `manual` - Load the script manually by calling `$script.load()`, exists only on the client.
+   * - `Promise` - Load the script when the promise resolves, exists only on the client.
+   * - `Function` - Register a callback function to load the script, exists only on the client. It may return a cleanup function.
+   * - `server` - Have the script injected on the server.
+   */
+  trigger?: 'client' | 'server' | 'manual' | Promise<boolean | void> | UseScriptTrigger | null;
+  /**
+   * Add a preload or preconnect link tag before the script is loaded.
+   */
+  warmupStrategy?: WarmupStrategy;
+  /**
+   * Context to run events with. This is useful in Vue to attach the current instance context before
+   * calling the event, allowing the event to be reactive.
+   */
+  eventContext?: any;
+  /**
+   * Called before the script is initialized. Will not be triggered when the script is already loaded. This means
+   * this is guaranteed to be called only once, unless the script is removed and re-added.
+   */
+  beforeInit?: () => void;
+}
+type HookResult = Promise<void> | void;
+type SyncHookResult = void;
+interface SSRHeadPayload {
+  headTags: string;
+  bodyTags: string;
+  bodyTagsOpen: string;
+  htmlAttrs: string;
+  bodyAttrs: string;
+}
+interface RenderSSRHeadOptions {
+  omitLineBreaks?: boolean;
+  resolvedTags?: HeadTag[];
+  tagWeight?: (tag: HeadTag) => number;
+}
+interface EntryResolveCtx<T> {
+  tags: HeadTag[];
+  entries: HeadEntry<T>[];
+}
+interface DomBeforeRenderCtx extends ShouldRenderContext {
+  tags: HeadTag[];
+}
+interface ShouldRenderContext {
+  shouldRender: boolean;
+}
+interface DomRenderTagContext {
+  tag: HeadTag;
+  id: string;
+  $el?: Element;
+  shouldRender: boolean;
+}
+interface SSRRenderContext {
+  tags: HeadTag[];
+  html: SSRHeadPayload;
+}
+interface TagResolveContext {
+  tagMap: Map<string, HeadTag>;
+  tags: HeadTag[];
+}
+interface CoreHeadHooks {
+  'entries:updated': (ctx: Unhead<any>) => HookResult;
+  'entries:resolve': (ctx: EntryResolveCtx<any>) => SyncHookResult;
+  'entries:normalize': (ctx: {
+    tags: HeadTag[];
+    entry: HeadEntry<any>;
+  }) => SyncHookResult;
+  'tag:normalise': (ctx: {
+    tag: HeadTag;
+    entry: HeadEntry<any>;
+    resolvedOptions: CreateClientHeadOptions;
+  }) => SyncHookResult;
+  'tags:beforeResolve': (ctx: TagResolveContext) => SyncHookResult;
+  'tags:resolve': (ctx: TagResolveContext) => SyncHookResult;
+  'tags:afterResolve': (ctx: TagResolveContext) => SyncHookResult;
+  'script:updated': (ctx: {
+    script: ScriptInstance<any>;
+  }) => void | Promise<void>;
+}
+interface DOMHeadHooks {
+  'dom:beforeRender': (ctx: DomBeforeRenderCtx) => SyncHookResult;
+  /** @deprecated Not called internally. Will be removed in v4. */
+  'dom:renderTag': (ctx: DomRenderTagContext, document: Document, track: (id: string, scope: string, fn: () => void) => void) => HookResult;
+  /** @deprecated Will be removed in v4. DOM rendering is synchronous; run post-render logic after calling `renderDOMHead()` directly. */
+  'dom:rendered': (ctx: {
+    renders: DomRenderTagContext[];
+  }) => HookResult;
+}
+interface SSRHeadHooks {
+  'ssr:beforeRender': (ctx: ShouldRenderContext) => HookResult;
+  'ssr:render': (ctx: {
+    tags: HeadTag[];
+    options: RenderSSRHeadOptions;
+  }) => HookResult;
+  'ssr:rendered': (ctx: SSRRenderContext) => HookResult;
+}
+type ClientHeadHooks = CoreHeadHooks & DOMHeadHooks;
+type ServerHeadHooks = CoreHeadHooks & SSRHeadHooks;
+type HeadHooks = CoreHeadHooks & DOMHeadHooks & SSRHeadHooks;
+/**
+ * Side effects are mapped with a key and their cleanup function.
+ *
+ * For example, `meta:data-h-4h46h465`: () => { document.querySelector('meta[data-h-4h46h465]').remove() }
+ */
+type SideEffectsRecord = Record<string, () => void>;
+interface HeadEntry<Input> {
+  /**
+   * User provided input for the entry.
+   */
+  input: Input;
+  options?: Omit<HeadEntryOptions, 'head' | 'onRendered'>;
+  /**
+   * Head entry index
+   *
+   * @internal
+   */
+  _i: number;
+  /**
+   * Resolved tags
+   *
+   * @internal
+   */
+  _tags?: HeadTag[];
+  /**
+   * Precomputed normalized tags shared across head instances (SSR default init
+   * entry). Only used when no entry hooks, tag weight overrides or entry
+   * options could observe or alter normalization, see `resolveTags`.
+   *
+   * @internal
+   */
+  _precomputedTags?: HeadTag[];
+  /**
+   * Pending patch to apply on next render (client-only)
+   * @internal
+   */
+  _pending?: Input;
+  /**
+   * @internal
+   */
+  _o?: Input;
+}
+interface HeadPluginOptions extends CreateHeadOptions {
+  hooks?: Record<string, (...args: any[]) => any>;
+}
+type HeadPluginInput = (HeadPluginOptions & {
+  key: string;
+}) | (((head: Unhead) => HeadPluginOptions & {
+  key: string;
+}) & {
+  key?: string;
+});
+type HeadPlugin = HeadPluginOptions & {
+  key: string;
+};
+/**
+ * An active head entry provides an API to manipulate it.
+ */
+interface ActiveHeadEntry<Input> {
+  /**
+   * Updates the entry with new input.
+   *
+   * Will first clear any side effects for previous input.
+   */
+  patch: (input: Input) => void;
+  /**
+   * Dispose the entry, removing it from the active head.
+   *
+   * Will queue side effects for removal.
+   */
+  dispose: () => void;
+  /**
+   * @internal
+   */
+  _i: number;
+}
+type PropResolver = ((key?: string, value?: any, tag?: HeadTag) => any) & {
+  /**
+   * Marks the resolver as the identity function for plain non-reactive JSON
+   * values (strings/numbers/booleans/plain objects/arrays). When every
+   * configured resolver is static, the SSR default init entry can use the
+   * precomputed fast path (see `server/createHead.ts`).
+   *
+   * @internal
+   */
+  _static?: boolean;
+};
+interface CreateHeadOptions {
+  document?: Document;
+  /**
+   * Initial head input that should be added.
+   *
+   * Any tags here are added with low priority.
+   */
+  init?: (ResolvableHead | undefined | false)[];
+  /**
+   * Prop resolvers for tags.
+   */
+  propResolvers?: PropResolver[];
+  /**
+   * @experimental
+   * Key used for window attachment during streaming SSR.
+   * Allows multiple Unhead instances on the same page.
+   * @default '__unhead__'
+   */
+  experimentalStreamKey?: string;
+  /**
+   * @internal
+   */
+  _tagWeight?: (tag: HeadTag) => number;
+}
+interface CreateServerHeadOptions extends CreateHeadOptions {
+  plugins?: HeadPluginInput[];
+  hooks?: Partial<ServerHeadHooks>;
+  /**
+   * Custom tag weight function for controlling `<head>` tag ordering.
+   *
+   * By default, tags are sorted using CAPO weights optimised for the browser preload scanner.
+   * Override this to change the ordering — for example, to prioritise SEO meta tags for bot requests.
+   *
+   * @example
+   * ```ts
+   * import { capoTagWeight } from 'unhead/server'
+   *
+   * createHead({
+   *   tagWeight(tag) {
+   *     // Promote SEO meta above styles for bots
+   *     if (isBot && tag.tag === 'meta' && tag.props.property?.startsWith('og:'))
+   *       return 55 // just above styles (60)
+   *     return capoTagWeight(tag)
+   *   }
+   * })
+   * ```
+   */
+  tagWeight?: (tag: HeadTag) => number;
+  /**
+   * Should default important tags be skipped.
+   *
+   * Adds the following tags with low priority:
+   * - <html lang="en">
+   * - <meta charset="utf-8">
+   * - <meta name="viewport" content="width=device-width, initial-scale=1">
+   */
+  disableDefaults?: boolean;
+  /**
+   * Omit line breaks between rendered tags, producing a single line of output.
+   *
+   * Only removes the separators *between* tags; newlines inside inline
+   * `<script>`/`<style>`/JSON-LD content are preserved.
+   *
+   * @deprecated Prefer `MinifyPlugin` from `unhead/plugins`, which minifies the
+   * inline content itself (where the real bytes are) rather than only dropping
+   * separators.
+   */
+  omitLineBreaks?: boolean;
+}
+interface CreateClientHeadOptions extends CreateHeadOptions {
+  plugins?: HeadPluginInput[];
+  hooks?: Partial<ClientHeadHooks>;
+  /**
+   * Custom render function for DOM updates.
+   */
+  render?: (head: Unhead<any>) => boolean | void;
+}
+interface HeadEntryOptions extends TagPosition, TagPriority, ProcessesTemplateParams, ResolvesDuplicates {
+  head?: Unhead;
+  /**
+   * Called after unhead has finished applying DOM updates.
+   *
+   * Useful for synchronising external tools (e.g. analytics) with the current document head.
+   *
+   * Only called on the client — ignored during SSR.
+   *
+   * @example
+   * useHead({ title: 'My Page' }, {
+   *   onRendered({ renders }) {
+   *     amplitude.track('Page View', { title: document.title })
+   *   }
+   * })
+   */
+  onRendered?: (ctx: {
+    renders: DomRenderTagContext[];
+  }) => void | Promise<void>;
+  /**
+   * @internal
+   */
+  _safe?: boolean;
+  /**
+   * @internal
+   */
+  _index?: number;
+  /**
+   * Source location for devtools tracing.
+   * @internal
+   */
+  _source?: string;
+}
+interface Unhead<Input = ResolvableHead, RenderResult = unknown> {
+  /**
+   * Render the head tags using the configured renderer.
+   */
+  render: () => RenderResult;
+  /**
+   * Registered plugins.
+   */
+  plugins: Map<string, HeadPlugin>;
+  /**
+   * The head entries.
+   */
+  entries: Map<number, HeadEntry<Input>>;
+  /**
+   * Create a new head entry.
+   */
+  push: (entry: Input, options?: HeadEntryOptions) => ActiveHeadEntry<Input>;
+  /**
+   * Exposed hooks for easier extension.
+   */
+  hooks?: HookableCore<HeadHooks>;
+  /**
+   * Resolved options
+   */
+  resolvedOptions: CreateHeadOptions;
+  /**
+   * Use a head plugin, loads the plugins hooks.
+   */
+  use: (plugin: HeadPluginInput) => void;
+  /**
+   * Is it a server-side render context.
+   */
+  ssr: boolean;
+  /**
+   * @internal
+   */
+  _entryCount: number;
+  /**
+   * Number of entry hooks included in cached normalization.
+   *
+   * @internal
+   */
+  _h: number;
+  /**
+   * @internal
+   */
+  dirty?: boolean;
+  /**
+   * Invalidate all entries and re-queue them for normalization.
+   * @internal
+   */
+  invalidate?: () => void;
+  /**
+   * @internal
+   */
+  _dom?: DomState;
+  /**
+   * @internal
+   */
+  _du?: boolean;
+  /**
+   * @internal
+   */
+  _scripts?: Record<string, any>;
+  /**
+   * @internal
+   */
+  _templateParams?: TemplateParams;
+  /**
+   * @internal
+   */
+  _separator?: string;
+  /**
+   * @internal
+   */
+  _title?: string;
+  /**
+   * @internal
+   */
+  _titleTemplate?: string;
+  /**
+   * @internal
+   */
+  _rootStreamedTags?: Record<string, HeadTag>;
+}
+interface DomState {
+  /**
+   * @internal
+   */
+  _t: string;
+  /**
+   * @internal
+   */
+  _p: SideEffectsRecord;
+  /**
+   * @internal
+   */
+  _s: SideEffectsRecord;
+  /**
+   * @internal
+   */
+  _e: Map<string, Element>;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/unhead@3.3.2_@voidzero-dev+vite-plus-core@0.2.9_rollup@4.62.4/node_modules/unhead/dist/shared/unhead.CrqY7gyY.d.ts
+type Base = RawInput<'base'>;
+type HtmlAttributes = RawInput<'htmlAttrs'>;
+type Noscript = RawInput<'noscript'>;
+type Style = RawInput<'style'>;
+//#endregion
+//#region ../../node_modules/.pnpm/@unhead+vue@3.3.2_@oxc-project+types@0.143.0_@vitejs+devtools-kit@0.4.12_@voidzero-dev+_9529223e8c649ac859b173200c2c7a75/node_modules/@unhead/vue/dist/shared/vue.B8YcFbNO.d.ts
+type Falsy = false | null | undefined;
+type MaybeFalsy<T> = T | Falsy;
+type ResolvableValue<T> = MaybeFalsy<T> | (() => MaybeFalsy<T>) | ComputedRef<MaybeFalsy<T>> | Ref<MaybeFalsy<T>>;
+type ResolvableArray<T> = ResolvableValue<ResolvableValue<T>[]>;
+type Prettify<T> = { [K in keyof T]: T[K]; } & {};
+type _ResolvablePropertiesRaw<T> = { [K in keyof T as {} extends Pick<T, K> ? never : K]: ResolvableValue<T[K]>; } & { [K in keyof T as {} extends Pick<T, K> ? K : never]?: ResolvableValue<T[K]>; };
+type ResolvableProperties<T> = Prettify<_ResolvablePropertiesRaw<T>>;
+interface HtmlAttr extends Omit<HtmlAttributes, 'class' | 'style'> {
+  /**
+   * The class global attribute is a space-separated list of the case-sensitive classes of the element.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/class
+   */
+  class?: MaybeArray<ResolvableValue<Stringable> | Record<string, ResolvableValue<boolean>>>;
+  /**
+   * The style attribute contains CSS styling declarations to be applied to the element.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/style
+   */
+  style?: MaybeArray<ResolvableValue<Stringable> | ResolvableProperties<CSSProperties>>;
+}
+interface BodyAttr extends Omit<BodyAttributesWithoutEvents, 'class' | 'style'> {
+  /**
+   * The class global attribute is a space-separated list of the case-sensitive classes of the element.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/class
+   */
+  class?: MaybeArray<ResolvableValue<Stringable> | Record<string, ResolvableValue<boolean>>>;
+  /**
+   * The style attribute contains CSS styling declarations to be applied to the element.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/style
+   */
+  style?: MaybeArray<ResolvableValue<Stringable> | ResolvableProperties<CSSProperties>>;
+}
+type ResolvableTitle = ResolvableValue<Stringable> | ResolvableProperties<({
+  textContent: Stringable;
+} & SchemaAugmentations['title'])>;
+type ResolvableTitleTemplate = ResolvableTitleTemplate$1 | Ref<string>;
+type ResolvableBase = DistributeResolvable<Base, SchemaAugmentations['base']>;
+type DistributeResolvable<T, Aug> = T extends any ? ResolvableProperties<T & Aug> : never;
+type DistributeResolvableWithEvents<T, Aug, Events> = T extends any ? T extends Events ? ResolvableProperties<Omit<T, keyof Events> & Aug> & MaybeEventFnHandlers<Events> : ResolvableProperties<T & Aug> : never;
+type ResolvableLink = DistributeResolvableWithEvents<Link, SchemaAugmentations['link'], LinkHttpEvents>;
+type ResolvableMeta = DistributeResolvable<UnheadMeta, SchemaAugmentations['meta']>;
+type ResolvableStyle = ResolvableProperties<Style & DataKeys & SchemaAugmentations['style']>;
+type ResolvableScript = DistributeResolvableWithEvents<Script, SchemaAugmentations['script'], ScriptHttpEvents>;
+type ResolvableNoscript = ResolvableProperties<Noscript & DataKeys & SchemaAugmentations['noscript']>;
+type ResolvableHtmlAttributes = ResolvableProperties<HtmlAttr & DataKeys & SchemaAugmentations['htmlAttrs']>;
+type ResolvableBodyAttributes = ResolvableProperties<BodyAttr & DataKeys & SchemaAugmentations['bodyAttrs']> & MaybeEventFnHandlers<BodyEvents>;
+interface ReactiveHead {
+  /**
+   * The `<title>` HTML element defines the document's title that is shown in a browser's title bar or a page's tab.
+   * It only contains text; tags within the element are ignored.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/title
+   */
+  title?: ResolvableTitle;
+  /**
+   * Generate the title from a template.
+   */
+  titleTemplate?: ResolvableTitleTemplate;
+  /**
+   * Variables used to substitute in the title and meta content.
+   */
+  templateParams?: ResolvableProperties<ResolvableTemplateParams>;
+  /**
+   * The `<base>` HTML element specifies the base URL to use for all relative URLs in a document.
+   * There can be only one <base> element in a document.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/base
+   */
+  base?: ResolvableBase;
+  /**
+   * The `<link>` HTML element specifies relationships between the current document and an external resource.
+   * This element is most commonly used to link to stylesheets, but is also used to establish site icons
+   * (both "favicon" style icons and icons for the home screen and apps on mobile devices) among other things.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-as
+   */
+  link?: ResolvableArray<ResolvableLink>;
+  /**
+   * The `<meta>` element represents metadata that cannot be expressed in other HTML elements, like `<link>` or `<script>`.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/meta
+   */
+  meta?: ResolvableArray<ResolvableMeta>;
+  /**
+   * The `<style>` HTML element contains style information for a document, or part of a document.
+   * It contains CSS, which is applied to the contents of the document containing the `<style>` element.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/style
+   */
+  style?: ResolvableArray<(ResolvableStyle | string)>;
+  /**
+   * The `<script>` HTML element is used to embed executable code or data; this is typically used to embed or refer to JavaScript code.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script
+   */
+  script?: ResolvableArray<(ResolvableScript | string)>;
+  /**
+   * The `<noscript>` HTML element defines a section of HTML to be inserted if a script type on the page is unsupported
+   * or if scripting is currently turned off in the browser.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/noscript
+   */
+  noscript?: ResolvableArray<(ResolvableNoscript | string)>;
+  /**
+   * Attributes for the `<html>` HTML element.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/html
+   */
+  htmlAttrs?: ResolvableHtmlAttributes;
+  /**
+   * Attributes for the `<body>` HTML element.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/body
+   */
+  bodyAttrs?: ResolvableBodyAttributes;
+}
+type UseHeadInput<_Deprecated = never> = ResolvableValue<ReactiveHead>;
+type VueHeadClient<I = UseHeadInput, R = unknown> = Unhead<I, R> & Plugin;
+//#endregion
+//#region ../../node_modules/.pnpm/@unhead+vue@3.3.2_@oxc-project+types@0.143.0_@vitejs+devtools-kit@0.4.12_@voidzero-dev+_9529223e8c649ac859b173200c2c7a75/node_modules/@unhead/vue/dist/server.d.ts
+declare function createHead(options?: Omit<CreateServerHeadOptions, 'propResolvers'>): VueHeadClient<UseHeadInput, SSRHeadPayload>;
+//#endregion
+export { createHead as createServerHead };