@xyd-js/plugins 0.0.0-build-2acf05c-20251207022018 → 0.0.0-build-83b15db-20251213220910

package/dist/index.d.ts

@@ -1,8 +1,3457 @@
-import { Plugin as Plugin$1 } from 'vite';
+import { Plugin as Plugin$2 } from 'vite';
 import * as React from 'react';
 import React__default from 'react';
+import * as unist from 'unist';
+import { Node as Node$1, Point, Position } from 'unist';
 import { UniformPlugin } from '@xyd-js/uniform';
 
+/**
+ * Message.
+ */
+declare class VFileMessage extends Error {
+    /**
+     * Create a message for `reason`.
+     *
+     * > 🪦 **Note**: also has obsolete signatures.
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Options | null | undefined} [options]
+     * @returns
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns
+     *
+     * @overload
+     * @param {string} reason
+     * @param {string | null | undefined} [origin]
+     * @returns
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {string | null | undefined} [origin]
+     * @returns
+     *
+     * @param {Error | VFileMessage | string} causeOrReason
+     *   Reason for message, should use markdown.
+     * @param {Node | NodeLike | Options | Point | Position | string | null | undefined} [optionsOrParentOrPlace]
+     *   Configuration (optional).
+     * @param {string | null | undefined} [origin]
+     *   Place in code where the message originates (example:
+     *   `'my-package:my-rule'` or `'my-rule'`).
+     * @returns
+     *   Instance of `VFileMessage`.
+     */
+    constructor(reason: string, options?: Options$3 | null | undefined);
+    /**
+     * Create a message for `reason`.
+     *
+     * > 🪦 **Note**: also has obsolete signatures.
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Options | null | undefined} [options]
+     * @returns
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns
+     *
+     * @overload
+     * @param {string} reason
+     * @param {string | null | undefined} [origin]
+     * @returns
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {string | null | undefined} [origin]
+     * @returns
+     *
+     * @param {Error | VFileMessage | string} causeOrReason
+     *   Reason for message, should use markdown.
+     * @param {Node | NodeLike | Options | Point | Position | string | null | undefined} [optionsOrParentOrPlace]
+     *   Configuration (optional).
+     * @param {string | null | undefined} [origin]
+     *   Place in code where the message originates (example:
+     *   `'my-package:my-rule'` or `'my-rule'`).
+     * @returns
+     *   Instance of `VFileMessage`.
+     */
+    constructor(reason: string, parent: Node$1 | NodeLike$1 | null | undefined, origin?: string | null | undefined);
+    /**
+     * Create a message for `reason`.
+     *
+     * > 🪦 **Note**: also has obsolete signatures.
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Options | null | undefined} [options]
+     * @returns
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns
+     *
+     * @overload
+     * @param {string} reason
+     * @param {string | null | undefined} [origin]
+     * @returns
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {string | null | undefined} [origin]
+     * @returns
+     *
+     * @param {Error | VFileMessage | string} causeOrReason
+     *   Reason for message, should use markdown.
+     * @param {Node | NodeLike | Options | Point | Position | string | null | undefined} [optionsOrParentOrPlace]
+     *   Configuration (optional).
+     * @param {string | null | undefined} [origin]
+     *   Place in code where the message originates (example:
+     *   `'my-package:my-rule'` or `'my-rule'`).
+     * @returns
+     *   Instance of `VFileMessage`.
+     */
+    constructor(reason: string, place: Point | Position | null | undefined, origin?: string | null | undefined);
+    /**
+     * Create a message for `reason`.
+     *
+     * > 🪦 **Note**: also has obsolete signatures.
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Options | null | undefined} [options]
+     * @returns
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns
+     *
+     * @overload
+     * @param {string} reason
+     * @param {string | null | undefined} [origin]
+     * @returns
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {string | null | undefined} [origin]
+     * @returns
+     *
+     * @param {Error | VFileMessage | string} causeOrReason
+     *   Reason for message, should use markdown.
+     * @param {Node | NodeLike | Options | Point | Position | string | null | undefined} [optionsOrParentOrPlace]
+     *   Configuration (optional).
+     * @param {string | null | undefined} [origin]
+     *   Place in code where the message originates (example:
+     *   `'my-package:my-rule'` or `'my-rule'`).
+     * @returns
+     *   Instance of `VFileMessage`.
+     */
+    constructor(reason: string, origin?: string | null | undefined);
+    /**
+     * Create a message for `reason`.
+     *
+     * > 🪦 **Note**: also has obsolete signatures.
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Options | null | undefined} [options]
+     * @returns
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns
+     *
+     * @overload
+     * @param {string} reason
+     * @param {string | null | undefined} [origin]
+     * @returns
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {string | null | undefined} [origin]
+     * @returns
+     *
+     * @param {Error | VFileMessage | string} causeOrReason
+     *   Reason for message, should use markdown.
+     * @param {Node | NodeLike | Options | Point | Position | string | null | undefined} [optionsOrParentOrPlace]
+     *   Configuration (optional).
+     * @param {string | null | undefined} [origin]
+     *   Place in code where the message originates (example:
+     *   `'my-package:my-rule'` or `'my-rule'`).
+     * @returns
+     *   Instance of `VFileMessage`.
+     */
+    constructor(cause: Error | VFileMessage, parent: Node$1 | NodeLike$1 | null | undefined, origin?: string | null | undefined);
+    /**
+     * Create a message for `reason`.
+     *
+     * > 🪦 **Note**: also has obsolete signatures.
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Options | null | undefined} [options]
+     * @returns
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns
+     *
+     * @overload
+     * @param {string} reason
+     * @param {string | null | undefined} [origin]
+     * @returns
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {string | null | undefined} [origin]
+     * @returns
+     *
+     * @param {Error | VFileMessage | string} causeOrReason
+     *   Reason for message, should use markdown.
+     * @param {Node | NodeLike | Options | Point | Position | string | null | undefined} [optionsOrParentOrPlace]
+     *   Configuration (optional).
+     * @param {string | null | undefined} [origin]
+     *   Place in code where the message originates (example:
+     *   `'my-package:my-rule'` or `'my-rule'`).
+     * @returns
+     *   Instance of `VFileMessage`.
+     */
+    constructor(cause: Error | VFileMessage, place: Point | Position | null | undefined, origin?: string | null | undefined);
+    /**
+     * Create a message for `reason`.
+     *
+     * > 🪦 **Note**: also has obsolete signatures.
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Options | null | undefined} [options]
+     * @returns
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns
+     *
+     * @overload
+     * @param {string} reason
+     * @param {string | null | undefined} [origin]
+     * @returns
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {string | null | undefined} [origin]
+     * @returns
+     *
+     * @param {Error | VFileMessage | string} causeOrReason
+     *   Reason for message, should use markdown.
+     * @param {Node | NodeLike | Options | Point | Position | string | null | undefined} [optionsOrParentOrPlace]
+     *   Configuration (optional).
+     * @param {string | null | undefined} [origin]
+     *   Place in code where the message originates (example:
+     *   `'my-package:my-rule'` or `'my-rule'`).
+     * @returns
+     *   Instance of `VFileMessage`.
+     */
+    constructor(cause: Error | VFileMessage, origin?: string | null | undefined);
+    /**
+     * Stack of ancestor nodes surrounding the message.
+     *
+     * @type {Array<Node> | undefined}
+     */
+    ancestors: Array<Node$1> | undefined;
+    /**
+     * Starting column of message.
+     *
+     * @type {number | undefined}
+     */
+    column: number | undefined;
+    /**
+     * State of problem.
+     *
+     * * `true` — error, file not usable
+     * * `false` — warning, change may be needed
+     * * `undefined` — change likely not needed
+     *
+     * @type {boolean | null | undefined}
+     */
+    fatal: boolean | null | undefined;
+    /**
+     * Path of a file (used throughout the `VFile` ecosystem).
+     *
+     * @type {string | undefined}
+     */
+    file: string | undefined;
+    /**
+     * Starting line of error.
+     *
+     * @type {number | undefined}
+     */
+    line: number | undefined;
+    /**
+     * Place of message.
+     *
+     * @type {Point | Position | undefined}
+     */
+    place: Point | Position | undefined;
+    /**
+     * Reason for message, should use markdown.
+     *
+     * @type {string}
+     */
+    reason: string;
+    /**
+     * Category of message (example: `'my-rule'`).
+     *
+     * @type {string | undefined}
+     */
+    ruleId: string | undefined;
+    /**
+     * Namespace of message (example: `'my-package'`).
+     *
+     * @type {string | undefined}
+     */
+    source: string | undefined;
+    /**
+     * Specify the source value that’s being reported, which is deemed
+     * incorrect.
+     *
+     * @type {string | undefined}
+     */
+    actual: string | undefined;
+    /**
+     * Suggest acceptable values that can be used instead of `actual`.
+     *
+     * @type {Array<string> | undefined}
+     */
+    expected: Array<string> | undefined;
+    /**
+     * Long form description of the message (you should use markdown).
+     *
+     * @type {string | undefined}
+     */
+    note: string | undefined;
+    /**
+     * Link to docs for the message.
+     *
+     * > 👉 **Note**: this must be an absolute URL that can be passed as `x`
+     * > to `new URL(x)`.
+     *
+     * @type {string | undefined}
+     */
+    url: string | undefined;
+}
+type NodeLike$1 = object & {
+    type: string;
+    position?: Position | undefined;
+};
+/**
+ * Configuration.
+ */
+type Options$3 = {
+    /**
+     * Stack of (inclusive) ancestor nodes surrounding the message (optional).
+     */
+    ancestors?: Array<Node$1> | null | undefined;
+    /**
+     * Original error cause of the message (optional).
+     */
+    cause?: Error | null | undefined;
+    /**
+     * Place of message (optional).
+     */
+    place?: Point | Position | null | undefined;
+    /**
+     * Category of message (optional, example: `'my-rule'`).
+     */
+    ruleId?: string | null | undefined;
+    /**
+     * Namespace of who sent the message (optional, example: `'my-package'`).
+     */
+    source?: string | null | undefined;
+};
+
+type Options$2 = Options$3;
+
+// See: <https://github.com/sindresorhus/type-fest/blob/main/source/empty-object.d.ts>
+declare const emptyObjectSymbol$3: unique symbol
+
+
+/**
+ * Things that can be passed to the constructor.
+ */
+type Compatible$2 = Options$1 | URL | VFile | Value$2
+
+/**
+ * Raw source map.
+ *
+ * See:
+ * <https://github.com/mozilla/source-map/blob/60adcb0/source-map.d.ts#L15-L23>.
+ */
+interface Map {
+  /**
+   * The generated file this source map is associated with.
+   */
+  file: string
+  /**
+   * A string of base64 VLQs which contain the actual mappings.
+   */
+  mappings: string
+  /**
+   * An array of identifiers which can be referenced by individual mappings.
+   */
+  names: Array<string>
+  /**
+   * An array of contents of the original source files.
+   */
+  sourcesContent?: Array<string> | undefined
+  /**
+   * The URL root from which all sources are relative.
+   */
+  sourceRoot?: string | undefined
+  /**
+   * An array of URLs to the original source files.
+   */
+  sources: Array<string>
+  /**
+   * Which version of the source map spec this map is following.
+   */
+  version: number
+}
+
+/**
+ * This map registers the type of the `data` key of a `VFile`.
+ *
+ * This type can be augmented to register custom `data` types.
+ *
+ * @example
+ * declare module 'vfile' {
+ *   interface DataMap {
+ *     // `file.data.name` is typed as `string`
+ *     name: string
+ *   }
+ * }
+ */
+interface DataMap$1 {
+  [emptyObjectSymbol$3]?: never
+}
+
+/**
+ * Custom info.
+ *
+ * Known attributes can be added to {@linkcode DataMap}
+ */
+type Data$4 = Record<string, unknown> & Partial<DataMap$1>
+
+/**
+ * Configuration.
+ */
+interface Options$1 {
+  /**
+   * Arbitrary fields that will be shallow copied over to the new file.
+   */
+  [key: string]: unknown
+  /**
+   * Set `basename` (name).
+   */
+  basename?: string | null | undefined
+  /**
+   * Set `cwd` (working directory).
+   */
+  cwd?: string | null | undefined
+  /**
+   * Set `data` (associated info).
+   */
+  data?: Data$4 | null | undefined
+  /**
+   * Set `dirname` (path w/o basename).
+   */
+  dirname?: string | null | undefined
+  /**
+   * Set `extname` (extension with dot).
+   */
+  extname?: string | null | undefined
+  /**
+   * Set `history` (paths the file moved between).
+   */
+  history?: Array<string> | null | undefined
+  /**
+   * Set `path` (current path).
+   */
+  path?: URL | string | null | undefined
+  /**
+   * Set `stem` (name without extension).
+   */
+  stem?: string | null | undefined
+  /**
+   * Set `value` (the contents of the file).
+   */
+  value?: Value$2 | null | undefined
+}
+
+/**
+ * Contents of the file.
+ *
+ * Can either be text or a `Uint8Array` structure.
+ */
+type Value$2 = Uint8Array | string
+
+declare class VFile {
+    /**
+     * Create a new virtual file.
+     *
+     * `options` is treated as:
+     *
+     * *   `string` or `Uint8Array` — `{value: options}`
+     * *   `URL` — `{path: options}`
+     * *   `VFile` — shallow copies its data over to the new file
+     * *   `object` — all fields are shallow copied over to the new file
+     *
+     * Path related fields are set in the following order (least specific to
+     * most specific): `history`, `path`, `basename`, `stem`, `extname`,
+     * `dirname`.
+     *
+     * You cannot set `dirname` or `extname` without setting either `history`,
+     * `path`, `basename`, or `stem` too.
+     *
+     * @param {Compatible | null | undefined} [value]
+     *   File value.
+     * @returns
+     *   New instance.
+     */
+    constructor(value?: Compatible$2 | null | undefined);
+    /**
+     * Base of `path` (default: `process.cwd()` or `'/'` in browsers).
+     *
+     * @type {string}
+     */
+    cwd: string;
+    /**
+     * Place to store custom info (default: `{}`).
+     *
+     * It’s OK to store custom data directly on the file but moving it to
+     * `data` is recommended.
+     *
+     * @type {Data}
+     */
+    data: Data$4;
+    /**
+     * List of file paths the file moved between.
+     *
+     * The first is the original path and the last is the current path.
+     *
+     * @type {Array<string>}
+     */
+    history: Array<string>;
+    /**
+     * List of messages associated with the file.
+     *
+     * @type {Array<VFileMessage>}
+     */
+    messages: Array<VFileMessage>;
+    /**
+     * Raw value.
+     *
+     * @type {Value}
+     */
+    value: Value$2;
+    /**
+     * Source map.
+     *
+     * This type is equivalent to the `RawSourceMap` type from the `source-map`
+     * module.
+     *
+     * @type {Map | null | undefined}
+     */
+    map: Map | null | undefined;
+    /**
+     * Custom, non-string, compiled, representation.
+     *
+     * This is used by unified to store non-string results.
+     * One example is when turning markdown into React nodes.
+     *
+     * @type {unknown}
+     */
+    result: unknown;
+    /**
+     * Whether a file was saved to disk.
+     *
+     * This is used by vfile reporters.
+     *
+     * @type {boolean}
+     */
+    stored: boolean;
+    /**
+     * Set basename (including extname) (`'index.min.js'`).
+     *
+     * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'`
+     * on windows).
+     * Cannot be nullified (use `file.path = file.dirname` instead).
+     *
+     * @param {string} basename
+     *   Basename.
+     * @returns {undefined}
+     *   Nothing.
+     */
+    set basename(basename: string);
+    /**
+     * Get the basename (including extname) (example: `'index.min.js'`).
+     *
+     * @returns {string | undefined}
+     *   Basename.
+     */
+    get basename(): string | undefined;
+    /**
+     * Set the full path (example: `'~/index.min.js'`).
+     *
+     * Cannot be nullified.
+     * You can set a file URL (a `URL` object with a `file:` protocol) which will
+     * be turned into a path with `url.fileURLToPath`.
+     *
+     * @param {URL | string} path
+     *   Path.
+     * @returns {undefined}
+     *   Nothing.
+     */
+    set path(path: string | URL);
+    /**
+     * Get the full path (example: `'~/index.min.js'`).
+     *
+     * @returns {string}
+     *   Path.
+     */
+    get path(): string;
+    /**
+     * Set the parent path (example: `'~'`).
+     *
+     * Cannot be set if there’s no `path` yet.
+     *
+     * @param {string | undefined} dirname
+     *   Dirname.
+     * @returns {undefined}
+     *   Nothing.
+     */
+    set dirname(dirname: string | undefined);
+    /**
+     * Get the parent path (example: `'~'`).
+     *
+     * @returns {string | undefined}
+     *   Dirname.
+     */
+    get dirname(): string | undefined;
+    /**
+     * Set the extname (including dot) (example: `'.js'`).
+     *
+     * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'`
+     * on windows).
+     * Cannot be set if there’s no `path` yet.
+     *
+     * @param {string | undefined} extname
+     *   Extname.
+     * @returns {undefined}
+     *   Nothing.
+     */
+    set extname(extname: string | undefined);
+    /**
+     * Get the extname (including dot) (example: `'.js'`).
+     *
+     * @returns {string | undefined}
+     *   Extname.
+     */
+    get extname(): string | undefined;
+    /**
+     * Set the stem (basename w/o extname) (example: `'index.min'`).
+     *
+     * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'`
+     * on windows).
+     * Cannot be nullified (use `file.path = file.dirname` instead).
+     *
+     * @param {string} stem
+     *   Stem.
+     * @returns {undefined}
+     *   Nothing.
+     */
+    set stem(stem: string);
+    /**
+     * Get the stem (basename w/o extname) (example: `'index.min'`).
+     *
+     * @returns {string | undefined}
+     *   Stem.
+     */
+    get stem(): string | undefined;
+    /**
+     * Create a fatal message for `reason` associated with the file.
+     *
+     * The `fatal` field of the message is set to `true` (error; file not usable)
+     * and the `file` field is set to the current file path.
+     * The message is added to the `messages` field on `file`.
+     *
+     * > 🪦 **Note**: also has obsolete signatures.
+     *
+     * @overload
+     * @param {string} reason
+     * @param {MessageOptions | null | undefined} [options]
+     * @returns {never}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns {never}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns {never}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {string | null | undefined} [origin]
+     * @returns {never}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns {never}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns {never}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {string | null | undefined} [origin]
+     * @returns {never}
+     *
+     * @param {Error | VFileMessage | string} causeOrReason
+     *   Reason for message, should use markdown.
+     * @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]
+     *   Configuration (optional).
+     * @param {string | null | undefined} [origin]
+     *   Place in code where the message originates (example:
+     *   `'my-package:my-rule'` or `'my-rule'`).
+     * @returns {never}
+     *   Never.
+     * @throws {VFileMessage}
+     *   Message.
+     */
+    fail(reason: string, options?: Options$2 | null | undefined): never;
+    /**
+     * Create a fatal message for `reason` associated with the file.
+     *
+     * The `fatal` field of the message is set to `true` (error; file not usable)
+     * and the `file` field is set to the current file path.
+     * The message is added to the `messages` field on `file`.
+     *
+     * > 🪦 **Note**: also has obsolete signatures.
+     *
+     * @overload
+     * @param {string} reason
+     * @param {MessageOptions | null | undefined} [options]
+     * @returns {never}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns {never}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns {never}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {string | null | undefined} [origin]
+     * @returns {never}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns {never}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns {never}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {string | null | undefined} [origin]
+     * @returns {never}
+     *
+     * @param {Error | VFileMessage | string} causeOrReason
+     *   Reason for message, should use markdown.
+     * @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]
+     *   Configuration (optional).
+     * @param {string | null | undefined} [origin]
+     *   Place in code where the message originates (example:
+     *   `'my-package:my-rule'` or `'my-rule'`).
+     * @returns {never}
+     *   Never.
+     * @throws {VFileMessage}
+     *   Message.
+     */
+    fail(reason: string, parent: Node$1 | NodeLike | null | undefined, origin?: string | null | undefined): never;
+    /**
+     * Create a fatal message for `reason` associated with the file.
+     *
+     * The `fatal` field of the message is set to `true` (error; file not usable)
+     * and the `file` field is set to the current file path.
+     * The message is added to the `messages` field on `file`.
+     *
+     * > 🪦 **Note**: also has obsolete signatures.
+     *
+     * @overload
+     * @param {string} reason
+     * @param {MessageOptions | null | undefined} [options]
+     * @returns {never}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns {never}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns {never}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {string | null | undefined} [origin]
+     * @returns {never}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns {never}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns {never}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {string | null | undefined} [origin]
+     * @returns {never}
+     *
+     * @param {Error | VFileMessage | string} causeOrReason
+     *   Reason for message, should use markdown.
+     * @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]
+     *   Configuration (optional).
+     * @param {string | null | undefined} [origin]
+     *   Place in code where the message originates (example:
+     *   `'my-package:my-rule'` or `'my-rule'`).
+     * @returns {never}
+     *   Never.
+     * @throws {VFileMessage}
+     *   Message.
+     */
+    fail(reason: string, place: Point | Position | null | undefined, origin?: string | null | undefined): never;
+    /**
+     * Create a fatal message for `reason` associated with the file.
+     *
+     * The `fatal` field of the message is set to `true` (error; file not usable)
+     * and the `file` field is set to the current file path.
+     * The message is added to the `messages` field on `file`.
+     *
+     * > 🪦 **Note**: also has obsolete signatures.
+     *
+     * @overload
+     * @param {string} reason
+     * @param {MessageOptions | null | undefined} [options]
+     * @returns {never}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns {never}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns {never}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {string | null | undefined} [origin]
+     * @returns {never}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns {never}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns {never}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {string | null | undefined} [origin]
+     * @returns {never}
+     *
+     * @param {Error | VFileMessage | string} causeOrReason
+     *   Reason for message, should use markdown.
+     * @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]
+     *   Configuration (optional).
+     * @param {string | null | undefined} [origin]
+     *   Place in code where the message originates (example:
+     *   `'my-package:my-rule'` or `'my-rule'`).
+     * @returns {never}
+     *   Never.
+     * @throws {VFileMessage}
+     *   Message.
+     */
+    fail(reason: string, origin?: string | null | undefined): never;
+    /**
+     * Create a fatal message for `reason` associated with the file.
+     *
+     * The `fatal` field of the message is set to `true` (error; file not usable)
+     * and the `file` field is set to the current file path.
+     * The message is added to the `messages` field on `file`.
+     *
+     * > 🪦 **Note**: also has obsolete signatures.
+     *
+     * @overload
+     * @param {string} reason
+     * @param {MessageOptions | null | undefined} [options]
+     * @returns {never}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns {never}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns {never}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {string | null | undefined} [origin]
+     * @returns {never}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns {never}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns {never}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {string | null | undefined} [origin]
+     * @returns {never}
+     *
+     * @param {Error | VFileMessage | string} causeOrReason
+     *   Reason for message, should use markdown.
+     * @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]
+     *   Configuration (optional).
+     * @param {string | null | undefined} [origin]
+     *   Place in code where the message originates (example:
+     *   `'my-package:my-rule'` or `'my-rule'`).
+     * @returns {never}
+     *   Never.
+     * @throws {VFileMessage}
+     *   Message.
+     */
+    fail(cause: Error | VFileMessage, parent: Node$1 | NodeLike | null | undefined, origin?: string | null | undefined): never;
+    /**
+     * Create a fatal message for `reason` associated with the file.
+     *
+     * The `fatal` field of the message is set to `true` (error; file not usable)
+     * and the `file` field is set to the current file path.
+     * The message is added to the `messages` field on `file`.
+     *
+     * > 🪦 **Note**: also has obsolete signatures.
+     *
+     * @overload
+     * @param {string} reason
+     * @param {MessageOptions | null | undefined} [options]
+     * @returns {never}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns {never}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns {never}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {string | null | undefined} [origin]
+     * @returns {never}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns {never}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns {never}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {string | null | undefined} [origin]
+     * @returns {never}
+     *
+     * @param {Error | VFileMessage | string} causeOrReason
+     *   Reason for message, should use markdown.
+     * @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]
+     *   Configuration (optional).
+     * @param {string | null | undefined} [origin]
+     *   Place in code where the message originates (example:
+     *   `'my-package:my-rule'` or `'my-rule'`).
+     * @returns {never}
+     *   Never.
+     * @throws {VFileMessage}
+     *   Message.
+     */
+    fail(cause: Error | VFileMessage, place: Point | Position | null | undefined, origin?: string | null | undefined): never;
+    /**
+     * Create a fatal message for `reason` associated with the file.
+     *
+     * The `fatal` field of the message is set to `true` (error; file not usable)
+     * and the `file` field is set to the current file path.
+     * The message is added to the `messages` field on `file`.
+     *
+     * > 🪦 **Note**: also has obsolete signatures.
+     *
+     * @overload
+     * @param {string} reason
+     * @param {MessageOptions | null | undefined} [options]
+     * @returns {never}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns {never}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns {never}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {string | null | undefined} [origin]
+     * @returns {never}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns {never}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns {never}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {string | null | undefined} [origin]
+     * @returns {never}
+     *
+     * @param {Error | VFileMessage | string} causeOrReason
+     *   Reason for message, should use markdown.
+     * @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]
+     *   Configuration (optional).
+     * @param {string | null | undefined} [origin]
+     *   Place in code where the message originates (example:
+     *   `'my-package:my-rule'` or `'my-rule'`).
+     * @returns {never}
+     *   Never.
+     * @throws {VFileMessage}
+     *   Message.
+     */
+    fail(cause: Error | VFileMessage, origin?: string | null | undefined): never;
+    /**
+     * Create an info message for `reason` associated with the file.
+     *
+     * The `fatal` field of the message is set to `undefined` (info; change
+     * likely not needed) and the `file` field is set to the current file path.
+     * The message is added to the `messages` field on `file`.
+     *
+     * > 🪦 **Note**: also has obsolete signatures.
+     *
+     * @overload
+     * @param {string} reason
+     * @param {MessageOptions | null | undefined} [options]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @param {Error | VFileMessage | string} causeOrReason
+     *   Reason for message, should use markdown.
+     * @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]
+     *   Configuration (optional).
+     * @param {string | null | undefined} [origin]
+     *   Place in code where the message originates (example:
+     *   `'my-package:my-rule'` or `'my-rule'`).
+     * @returns {VFileMessage}
+     *   Message.
+     */
+    info(reason: string, options?: Options$2 | null | undefined): VFileMessage;
+    /**
+     * Create an info message for `reason` associated with the file.
+     *
+     * The `fatal` field of the message is set to `undefined` (info; change
+     * likely not needed) and the `file` field is set to the current file path.
+     * The message is added to the `messages` field on `file`.
+     *
+     * > 🪦 **Note**: also has obsolete signatures.
+     *
+     * @overload
+     * @param {string} reason
+     * @param {MessageOptions | null | undefined} [options]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @param {Error | VFileMessage | string} causeOrReason
+     *   Reason for message, should use markdown.
+     * @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]
+     *   Configuration (optional).
+     * @param {string | null | undefined} [origin]
+     *   Place in code where the message originates (example:
+     *   `'my-package:my-rule'` or `'my-rule'`).
+     * @returns {VFileMessage}
+     *   Message.
+     */
+    info(reason: string, parent: Node$1 | NodeLike | null | undefined, origin?: string | null | undefined): VFileMessage;
+    /**
+     * Create an info message for `reason` associated with the file.
+     *
+     * The `fatal` field of the message is set to `undefined` (info; change
+     * likely not needed) and the `file` field is set to the current file path.
+     * The message is added to the `messages` field on `file`.
+     *
+     * > 🪦 **Note**: also has obsolete signatures.
+     *
+     * @overload
+     * @param {string} reason
+     * @param {MessageOptions | null | undefined} [options]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @param {Error | VFileMessage | string} causeOrReason
+     *   Reason for message, should use markdown.
+     * @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]
+     *   Configuration (optional).
+     * @param {string | null | undefined} [origin]
+     *   Place in code where the message originates (example:
+     *   `'my-package:my-rule'` or `'my-rule'`).
+     * @returns {VFileMessage}
+     *   Message.
+     */
+    info(reason: string, place: Point | Position | null | undefined, origin?: string | null | undefined): VFileMessage;
+    /**
+     * Create an info message for `reason` associated with the file.
+     *
+     * The `fatal` field of the message is set to `undefined` (info; change
+     * likely not needed) and the `file` field is set to the current file path.
+     * The message is added to the `messages` field on `file`.
+     *
+     * > 🪦 **Note**: also has obsolete signatures.
+     *
+     * @overload
+     * @param {string} reason
+     * @param {MessageOptions | null | undefined} [options]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @param {Error | VFileMessage | string} causeOrReason
+     *   Reason for message, should use markdown.
+     * @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]
+     *   Configuration (optional).
+     * @param {string | null | undefined} [origin]
+     *   Place in code where the message originates (example:
+     *   `'my-package:my-rule'` or `'my-rule'`).
+     * @returns {VFileMessage}
+     *   Message.
+     */
+    info(reason: string, origin?: string | null | undefined): VFileMessage;
+    /**
+     * Create an info message for `reason` associated with the file.
+     *
+     * The `fatal` field of the message is set to `undefined` (info; change
+     * likely not needed) and the `file` field is set to the current file path.
+     * The message is added to the `messages` field on `file`.
+     *
+     * > 🪦 **Note**: also has obsolete signatures.
+     *
+     * @overload
+     * @param {string} reason
+     * @param {MessageOptions | null | undefined} [options]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @param {Error | VFileMessage | string} causeOrReason
+     *   Reason for message, should use markdown.
+     * @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]
+     *   Configuration (optional).
+     * @param {string | null | undefined} [origin]
+     *   Place in code where the message originates (example:
+     *   `'my-package:my-rule'` or `'my-rule'`).
+     * @returns {VFileMessage}
+     *   Message.
+     */
+    info(cause: Error | VFileMessage, parent: Node$1 | NodeLike | null | undefined, origin?: string | null | undefined): VFileMessage;
+    /**
+     * Create an info message for `reason` associated with the file.
+     *
+     * The `fatal` field of the message is set to `undefined` (info; change
+     * likely not needed) and the `file` field is set to the current file path.
+     * The message is added to the `messages` field on `file`.
+     *
+     * > 🪦 **Note**: also has obsolete signatures.
+     *
+     * @overload
+     * @param {string} reason
+     * @param {MessageOptions | null | undefined} [options]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @param {Error | VFileMessage | string} causeOrReason
+     *   Reason for message, should use markdown.
+     * @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]
+     *   Configuration (optional).
+     * @param {string | null | undefined} [origin]
+     *   Place in code where the message originates (example:
+     *   `'my-package:my-rule'` or `'my-rule'`).
+     * @returns {VFileMessage}
+     *   Message.
+     */
+    info(cause: Error | VFileMessage, place: Point | Position | null | undefined, origin?: string | null | undefined): VFileMessage;
+    /**
+     * Create an info message for `reason` associated with the file.
+     *
+     * The `fatal` field of the message is set to `undefined` (info; change
+     * likely not needed) and the `file` field is set to the current file path.
+     * The message is added to the `messages` field on `file`.
+     *
+     * > 🪦 **Note**: also has obsolete signatures.
+     *
+     * @overload
+     * @param {string} reason
+     * @param {MessageOptions | null | undefined} [options]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @param {Error | VFileMessage | string} causeOrReason
+     *   Reason for message, should use markdown.
+     * @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]
+     *   Configuration (optional).
+     * @param {string | null | undefined} [origin]
+     *   Place in code where the message originates (example:
+     *   `'my-package:my-rule'` or `'my-rule'`).
+     * @returns {VFileMessage}
+     *   Message.
+     */
+    info(cause: Error | VFileMessage, origin?: string | null | undefined): VFileMessage;
+    /**
+     * Create a message for `reason` associated with the file.
+     *
+     * The `fatal` field of the message is set to `false` (warning; change may be
+     * needed) and the `file` field is set to the current file path.
+     * The message is added to the `messages` field on `file`.
+     *
+     * > 🪦 **Note**: also has obsolete signatures.
+     *
+     * @overload
+     * @param {string} reason
+     * @param {MessageOptions | null | undefined} [options]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @param {Error | VFileMessage | string} causeOrReason
+     *   Reason for message, should use markdown.
+     * @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]
+     *   Configuration (optional).
+     * @param {string | null | undefined} [origin]
+     *   Place in code where the message originates (example:
+     *   `'my-package:my-rule'` or `'my-rule'`).
+     * @returns {VFileMessage}
+     *   Message.
+     */
+    message(reason: string, options?: Options$2 | null | undefined): VFileMessage;
+    /**
+     * Create a message for `reason` associated with the file.
+     *
+     * The `fatal` field of the message is set to `false` (warning; change may be
+     * needed) and the `file` field is set to the current file path.
+     * The message is added to the `messages` field on `file`.
+     *
+     * > 🪦 **Note**: also has obsolete signatures.
+     *
+     * @overload
+     * @param {string} reason
+     * @param {MessageOptions | null | undefined} [options]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @param {Error | VFileMessage | string} causeOrReason
+     *   Reason for message, should use markdown.
+     * @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]
+     *   Configuration (optional).
+     * @param {string | null | undefined} [origin]
+     *   Place in code where the message originates (example:
+     *   `'my-package:my-rule'` or `'my-rule'`).
+     * @returns {VFileMessage}
+     *   Message.
+     */
+    message(reason: string, parent: Node$1 | NodeLike | null | undefined, origin?: string | null | undefined): VFileMessage;
+    /**
+     * Create a message for `reason` associated with the file.
+     *
+     * The `fatal` field of the message is set to `false` (warning; change may be
+     * needed) and the `file` field is set to the current file path.
+     * The message is added to the `messages` field on `file`.
+     *
+     * > 🪦 **Note**: also has obsolete signatures.
+     *
+     * @overload
+     * @param {string} reason
+     * @param {MessageOptions | null | undefined} [options]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @param {Error | VFileMessage | string} causeOrReason
+     *   Reason for message, should use markdown.
+     * @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]
+     *   Configuration (optional).
+     * @param {string | null | undefined} [origin]
+     *   Place in code where the message originates (example:
+     *   `'my-package:my-rule'` or `'my-rule'`).
+     * @returns {VFileMessage}
+     *   Message.
+     */
+    message(reason: string, place: Point | Position | null | undefined, origin?: string | null | undefined): VFileMessage;
+    /**
+     * Create a message for `reason` associated with the file.
+     *
+     * The `fatal` field of the message is set to `false` (warning; change may be
+     * needed) and the `file` field is set to the current file path.
+     * The message is added to the `messages` field on `file`.
+     *
+     * > 🪦 **Note**: also has obsolete signatures.
+     *
+     * @overload
+     * @param {string} reason
+     * @param {MessageOptions | null | undefined} [options]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @param {Error | VFileMessage | string} causeOrReason
+     *   Reason for message, should use markdown.
+     * @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]
+     *   Configuration (optional).
+     * @param {string | null | undefined} [origin]
+     *   Place in code where the message originates (example:
+     *   `'my-package:my-rule'` or `'my-rule'`).
+     * @returns {VFileMessage}
+     *   Message.
+     */
+    message(reason: string, origin?: string | null | undefined): VFileMessage;
+    /**
+     * Create a message for `reason` associated with the file.
+     *
+     * The `fatal` field of the message is set to `false` (warning; change may be
+     * needed) and the `file` field is set to the current file path.
+     * The message is added to the `messages` field on `file`.
+     *
+     * > 🪦 **Note**: also has obsolete signatures.
+     *
+     * @overload
+     * @param {string} reason
+     * @param {MessageOptions | null | undefined} [options]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @param {Error | VFileMessage | string} causeOrReason
+     *   Reason for message, should use markdown.
+     * @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]
+     *   Configuration (optional).
+     * @param {string | null | undefined} [origin]
+     *   Place in code where the message originates (example:
+     *   `'my-package:my-rule'` or `'my-rule'`).
+     * @returns {VFileMessage}
+     *   Message.
+     */
+    message(cause: Error | VFileMessage, parent: Node$1 | NodeLike | null | undefined, origin?: string | null | undefined): VFileMessage;
+    /**
+     * Create a message for `reason` associated with the file.
+     *
+     * The `fatal` field of the message is set to `false` (warning; change may be
+     * needed) and the `file` field is set to the current file path.
+     * The message is added to the `messages` field on `file`.
+     *
+     * > 🪦 **Note**: also has obsolete signatures.
+     *
+     * @overload
+     * @param {string} reason
+     * @param {MessageOptions | null | undefined} [options]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @param {Error | VFileMessage | string} causeOrReason
+     *   Reason for message, should use markdown.
+     * @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]
+     *   Configuration (optional).
+     * @param {string | null | undefined} [origin]
+     *   Place in code where the message originates (example:
+     *   `'my-package:my-rule'` or `'my-rule'`).
+     * @returns {VFileMessage}
+     *   Message.
+     */
+    message(cause: Error | VFileMessage, place: Point | Position | null | undefined, origin?: string | null | undefined): VFileMessage;
+    /**
+     * Create a message for `reason` associated with the file.
+     *
+     * The `fatal` field of the message is set to `false` (warning; change may be
+     * needed) and the `file` field is set to the current file path.
+     * The message is added to the `messages` field on `file`.
+     *
+     * > 🪦 **Note**: also has obsolete signatures.
+     *
+     * @overload
+     * @param {string} reason
+     * @param {MessageOptions | null | undefined} [options]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {string} reason
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Node | NodeLike | null | undefined} parent
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {Point | Position | null | undefined} place
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @overload
+     * @param {Error | VFileMessage} cause
+     * @param {string | null | undefined} [origin]
+     * @returns {VFileMessage}
+     *
+     * @param {Error | VFileMessage | string} causeOrReason
+     *   Reason for message, should use markdown.
+     * @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]
+     *   Configuration (optional).
+     * @param {string | null | undefined} [origin]
+     *   Place in code where the message originates (example:
+     *   `'my-package:my-rule'` or `'my-rule'`).
+     * @returns {VFileMessage}
+     *   Message.
+     */
+    message(cause: Error | VFileMessage, origin?: string | null | undefined): VFileMessage;
+    /**
+     * Serialize the file.
+     *
+     * > **Note**: which encodings are supported depends on the engine.
+     * > For info on Node.js, see:
+     * > <https://nodejs.org/api/util.html#whatwg-supported-encodings>.
+     *
+     * @param {string | null | undefined} [encoding='utf8']
+     *   Character encoding to understand `value` as when it’s a `Uint8Array`
+     *   (default: `'utf-8'`).
+     * @returns {string}
+     *   Serialized file.
+     */
+    toString(encoding?: string | null | undefined): string;
+}
+type NodeLike = object & {
+    type: string;
+    position?: Position | undefined;
+};
+
+// See: <https://github.com/sindresorhus/type-fest/blob/main/source/empty-object.d.ts>
+declare const emptyObjectSymbol$2: unique symbol
+
+
+/**
+ * Things that can be passed to the constructor.
+ */
+type Compatible$1 = Options | URL | VFile | Value$1
+
+/**
+ * This map registers the type of the `data` key of a `VFile`.
+ *
+ * This type can be augmented to register custom `data` types.
+ *
+ * @example
+ * declare module 'vfile' {
+ *   interface DataMap {
+ *     // `file.data.name` is typed as `string`
+ *     name: string
+ *   }
+ * }
+ */
+interface DataMap {
+  [emptyObjectSymbol$2]?: never
+}
+
+/**
+ * Custom info.
+ *
+ * Known attributes can be added to {@linkcode DataMap}
+ */
+type Data$3 = Record<string, unknown> & Partial<DataMap>
+
+/**
+ * Configuration.
+ */
+interface Options {
+  /**
+   * Arbitrary fields that will be shallow copied over to the new file.
+   */
+  [key: string]: unknown
+  /**
+   * Set `basename` (name).
+   */
+  basename?: string | null | undefined
+  /**
+   * Set `cwd` (working directory).
+   */
+  cwd?: string | null | undefined
+  /**
+   * Set `data` (associated info).
+   */
+  data?: Data$3 | null | undefined
+  /**
+   * Set `dirname` (path w/o basename).
+   */
+  dirname?: string | null | undefined
+  /**
+   * Set `extname` (extension with dot).
+   */
+  extname?: string | null | undefined
+  /**
+   * Set `history` (paths the file moved between).
+   */
+  history?: Array<string> | null | undefined
+  /**
+   * Set `path` (current path).
+   */
+  path?: URL | string | null | undefined
+  /**
+   * Set `stem` (name without extension).
+   */
+  stem?: string | null | undefined
+  /**
+   * Set `value` (the contents of the file).
+   */
+  value?: Value$1 | null | undefined
+}
+
+/**
+ * Contents of the file.
+ *
+ * Can either be text or a `Uint8Array` structure.
+ */
+type Value$1 = Uint8Array | string
+
+// See: <https://github.com/sindresorhus/type-fest/blob/main/source/empty-object.d.ts>
+declare const emptyObjectSymbol$1: unique symbol
+
+/**
+ * Interface of known results from compilers.
+ *
+ * Normally, compilers result in text ({@linkcode Value} of `vfile`).
+ * When you compile to something else, such as a React node (as in,
+ * `rehype-react`), you can augment this interface to include that type.
+ *
+ * ```ts
+ * import type {ReactNode} from 'somewhere'
+ *
+ * declare module 'unified' {
+ *   interface CompileResultMap {
+ *     // Register a new result (value is used, key should match it).
+ *     ReactNode: ReactNode
+ *   }
+ * }
+ *
+ * export {} // You may not need this, but it makes sure the file is a module.
+ * ```
+ *
+ * Use {@linkcode CompileResults} to access the values.
+ */
+interface CompileResultMap$1 {
+  // Note: if `Value` from `VFile` is changed, this should too.
+  Uint8Array: Uint8Array
+  string: string
+}
+
+/**
+ * Interface of known data that can be supported by all plugins.
+ *
+ * Typically, options can be given to a specific plugin, but sometimes it makes
+ * sense to have information shared with several plugins.
+ * For example, a list of HTML elements that are self-closing, which is needed
+ * during all phases.
+ *
+ * To type this, do something like:
+ *
+ * ```ts
+ * declare module 'unified' {
+ *   interface Data {
+ *     htmlVoidElements?: Array<string> | undefined
+ *   }
+ * }
+ *
+ * export {} // You may not need this, but it makes sure the file is a module.
+ * ```
+ */
+interface Data$2 {
+  settings?: Settings$3 | undefined
+}
+
+/**
+ * Interface of known extra options, that can be supported by parser and
+ * compilers.
+ *
+ * This exists so that users can use packages such as `remark`, which configure
+ * both parsers and compilers (in this case `remark-parse` and
+ * `remark-stringify`), and still provide options for them.
+ *
+ * When you make parsers or compilers, that could be packaged up together,
+ * you should support `this.data('settings')` as input and merge it with
+ * explicitly passed `options`.
+ * Then, to type it, using `remark-stringify` as an example, do something like:
+ *
+ * ```ts
+ * declare module 'unified' {
+ *   interface Settings {
+ *     bullet: '*' | '+' | '-'
+ *     // …
+ *   }
+ * }
+ *
+ * export {} // You may not need this, but it makes sure the file is a module.
+ * ```
+ */
+interface Settings$3 {
+  [emptyObjectSymbol$1]?: never
+}
+
+/**
+ * Ware.
+ */
+type Middleware = (...input: Array<any>) => any;
+/**
+ * Pipeline.
+ */
+type Pipeline$2 = {
+    /**
+     *   Run the pipeline.
+     */
+    run: Run;
+    /**
+     *   Add middleware.
+     */
+    use: Use;
+};
+/**
+ * Call all middleware.
+ *
+ * Calls `done` on completion with either an error or the output of the
+ * last middleware.
+ *
+ * > 👉 **Note**: as the length of input defines whether async functions get a
+ * > `next` function,
+ * > it’s recommended to keep `input` at one value normally.
+ */
+type Run = (...input: Array<any>) => void;
+/**
+ * Add middleware.
+ */
+type Use = (fn: Middleware) => Pipeline$2;
+
+type Pipeline$1 = Pipeline$2;
+
+// See: <https://github.com/sindresorhus/type-fest/blob/main/source/empty-object.d.ts>
+declare const emptyObjectSymbol: unique symbol
+
+/**
+ * Interface of known data that can be supported by all plugins.
+ *
+ * Typically, options can be given to a specific plugin, but sometimes it makes
+ * sense to have information shared with several plugins.
+ * For example, a list of HTML elements that are self-closing, which is needed
+ * during all phases.
+ *
+ * To type this, do something like:
+ *
+ * ```ts
+ * declare module 'unified' {
+ *   interface Data {
+ *     htmlVoidElements?: Array<string> | undefined
+ *   }
+ * }
+ *
+ * export {} // You may not need this, but it makes sure the file is a module.
+ * ```
+ */
+interface Data$1 {
+  settings?: Settings$2 | undefined
+}
+
+/**
+ * Interface of known extra options, that can be supported by parser and
+ * compilers.
+ *
+ * This exists so that users can use packages such as `remark`, which configure
+ * both parsers and compilers (in this case `remark-parse` and
+ * `remark-stringify`), and still provide options for them.
+ *
+ * When you make parsers or compilers, that could be packaged up together,
+ * you should support `this.data('settings')` as input and merge it with
+ * explicitly passed `options`.
+ * Then, to type it, using `remark-stringify` as an example, do something like:
+ *
+ * ```ts
+ * declare module 'unified' {
+ *   interface Settings {
+ *     bullet: '*' | '+' | '-'
+ *     // …
+ *   }
+ * }
+ *
+ * export {} // You may not need this, but it makes sure the file is a module.
+ * ```
+ */
+interface Settings$2 {
+  [emptyObjectSymbol]?: never
+}
+
+declare const CallableInstance: new <Parameters extends unknown[], Result>(property: string | symbol) => (...parameters: Parameters) => Result;
+
+/**
+ * @template {Node | undefined} [ParseTree=undefined]
+ *   Output of `parse` (optional).
+ * @template {Node | undefined} [HeadTree=undefined]
+ *   Input for `run` (optional).
+ * @template {Node | undefined} [TailTree=undefined]
+ *   Output for `run` (optional).
+ * @template {Node | undefined} [CompileTree=undefined]
+ *   Input of `stringify` (optional).
+ * @template {CompileResults | undefined} [CompileResult=undefined]
+ *   Output of `stringify` (optional).
+ * @extends {CallableInstance<[], Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>>}
+ */
+declare class Processor<ParseTree extends unist.Node | undefined = undefined, HeadTree extends unist.Node | undefined = undefined, TailTree extends unist.Node | undefined = undefined, CompileTree extends unist.Node | undefined = undefined, CompileResult extends CompileResults | undefined = undefined> extends CallableInstance<[], Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>> {
+    /**
+     * Create a processor.
+     */
+    constructor();
+    /**
+     * Compiler to use (deprecated).
+     *
+     * @deprecated
+     *   Use `compiler` instead.
+     * @type {(
+     *   Compiler<
+     *     CompileTree extends undefined ? Node : CompileTree,
+     *     CompileResult extends undefined ? CompileResults : CompileResult
+     *   > |
+     *   undefined
+     * )}
+     */
+    Compiler: (Compiler<CompileTree extends undefined ? Node : CompileTree, CompileResult extends undefined ? CompileResults : CompileResult> | undefined);
+    /**
+     * Parser to use (deprecated).
+     *
+     * @deprecated
+     *   Use `parser` instead.
+     * @type {(
+     *   Parser<ParseTree extends undefined ? Node : ParseTree> |
+     *   undefined
+     * )}
+     */
+    Parser: (Parser<ParseTree extends undefined ? Node : ParseTree> | undefined);
+    /**
+     * Internal list of configured plugins.
+     *
+     * @deprecated
+     *   This is a private internal property and should not be used.
+     * @type {Array<PluginTuple<Array<unknown>>>}
+     */
+    attachers: Array<[plugin: Plugin$1<unknown[], undefined, undefined>, ...parameters: unknown[]]>;
+    /**
+     * Compiler to use.
+     *
+     * @type {(
+     *   Compiler<
+     *     CompileTree extends undefined ? Node : CompileTree,
+     *     CompileResult extends undefined ? CompileResults : CompileResult
+     *   > |
+     *   undefined
+     * )}
+     */
+    compiler: (Compiler<CompileTree extends undefined ? Node : CompileTree, CompileResult extends undefined ? CompileResults : CompileResult> | undefined);
+    /**
+     * Internal state to track where we are while freezing.
+     *
+     * @deprecated
+     *   This is a private internal property and should not be used.
+     * @type {number}
+     */
+    freezeIndex: number;
+    /**
+     * Internal state to track whether we’re frozen.
+     *
+     * @deprecated
+     *   This is a private internal property and should not be used.
+     * @type {boolean | undefined}
+     */
+    frozen: boolean | undefined;
+    /**
+     * Internal state.
+     *
+     * @deprecated
+     *   This is a private internal property and should not be used.
+     * @type {Data}
+     */
+    namespace: Data;
+    /**
+     * Parser to use.
+     *
+     * @type {(
+     *   Parser<ParseTree extends undefined ? Node : ParseTree> |
+     *   undefined
+     * )}
+     */
+    parser: (Parser<ParseTree extends undefined ? Node : ParseTree> | undefined);
+    /**
+     * Internal list of configured transformers.
+     *
+     * @deprecated
+     *   This is a private internal property and should not be used.
+     * @type {Pipeline}
+     */
+    transformers: Pipeline;
+    /**
+     * Copy a processor.
+     *
+     * @deprecated
+     *   This is a private internal method and should not be used.
+     * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}
+     *   New *unfrozen* processor ({@linkcode Processor}) that is
+     *   configured to work the same as its ancestor.
+     *   When the descendant processor is configured in the future it does not
+     *   affect the ancestral processor.
+     */
+    copy(): Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>;
+    /**
+     * Configure the processor with info available to all plugins.
+     * Information is stored in an object.
+     *
+     * Typically, options can be given to a specific plugin, but sometimes it
+     * makes sense to have information shared with several plugins.
+     * For example, a list of HTML elements that are self-closing, which is
+     * needed during all phases.
+     *
+     * > **Note**: setting information cannot occur on *frozen* processors.
+     * > Call the processor first to create a new unfrozen processor.
+     *
+     * > **Note**: to register custom data in TypeScript, augment the
+     * > {@linkcode Data} interface.
+     *
+     * @example
+     *   This example show how to get and set info:
+     *
+     *   ```js
+     *   import {unified} from 'unified'
+     *
+     *   const processor = unified().data('alpha', 'bravo')
+     *
+     *   processor.data('alpha') // => 'bravo'
+     *
+     *   processor.data() // => {alpha: 'bravo'}
+     *
+     *   processor.data({charlie: 'delta'})
+     *
+     *   processor.data() // => {charlie: 'delta'}
+     *   ```
+     *
+     * @template {keyof Data} Key
+     *
+     * @overload
+     * @returns {Data}
+     *
+     * @overload
+     * @param {Data} dataset
+     * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}
+     *
+     * @overload
+     * @param {Key} key
+     * @returns {Data[Key]}
+     *
+     * @overload
+     * @param {Key} key
+     * @param {Data[Key]} value
+     * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}
+     *
+     * @param {Data | Key} [key]
+     *   Key to get or set, or entire dataset to set, or nothing to get the
+     *   entire dataset (optional).
+     * @param {Data[Key]} [value]
+     *   Value to set (optional).
+     * @returns {unknown}
+     *   The current processor when setting, the value at `key` when getting, or
+     *   the entire dataset when getting without key.
+     */
+    data<Key extends keyof Data$1>(): Data;
+    /**
+     * Configure the processor with info available to all plugins.
+     * Information is stored in an object.
+     *
+     * Typically, options can be given to a specific plugin, but sometimes it
+     * makes sense to have information shared with several plugins.
+     * For example, a list of HTML elements that are self-closing, which is
+     * needed during all phases.
+     *
+     * > **Note**: setting information cannot occur on *frozen* processors.
+     * > Call the processor first to create a new unfrozen processor.
+     *
+     * > **Note**: to register custom data in TypeScript, augment the
+     * > {@linkcode Data} interface.
+     *
+     * @example
+     *   This example show how to get and set info:
+     *
+     *   ```js
+     *   import {unified} from 'unified'
+     *
+     *   const processor = unified().data('alpha', 'bravo')
+     *
+     *   processor.data('alpha') // => 'bravo'
+     *
+     *   processor.data() // => {alpha: 'bravo'}
+     *
+     *   processor.data({charlie: 'delta'})
+     *
+     *   processor.data() // => {charlie: 'delta'}
+     *   ```
+     *
+     * @template {keyof Data} Key
+     *
+     * @overload
+     * @returns {Data}
+     *
+     * @overload
+     * @param {Data} dataset
+     * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}
+     *
+     * @overload
+     * @param {Key} key
+     * @returns {Data[Key]}
+     *
+     * @overload
+     * @param {Key} key
+     * @param {Data[Key]} value
+     * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}
+     *
+     * @param {Data | Key} [key]
+     *   Key to get or set, or entire dataset to set, or nothing to get the
+     *   entire dataset (optional).
+     * @param {Data[Key]} [value]
+     *   Value to set (optional).
+     * @returns {unknown}
+     *   The current processor when setting, the value at `key` when getting, or
+     *   the entire dataset when getting without key.
+     */
+    data<Key extends keyof Data$1>(dataset: Data): Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>;
+    /**
+     * Configure the processor with info available to all plugins.
+     * Information is stored in an object.
+     *
+     * Typically, options can be given to a specific plugin, but sometimes it
+     * makes sense to have information shared with several plugins.
+     * For example, a list of HTML elements that are self-closing, which is
+     * needed during all phases.
+     *
+     * > **Note**: setting information cannot occur on *frozen* processors.
+     * > Call the processor first to create a new unfrozen processor.
+     *
+     * > **Note**: to register custom data in TypeScript, augment the
+     * > {@linkcode Data} interface.
+     *
+     * @example
+     *   This example show how to get and set info:
+     *
+     *   ```js
+     *   import {unified} from 'unified'
+     *
+     *   const processor = unified().data('alpha', 'bravo')
+     *
+     *   processor.data('alpha') // => 'bravo'
+     *
+     *   processor.data() // => {alpha: 'bravo'}
+     *
+     *   processor.data({charlie: 'delta'})
+     *
+     *   processor.data() // => {charlie: 'delta'}
+     *   ```
+     *
+     * @template {keyof Data} Key
+     *
+     * @overload
+     * @returns {Data}
+     *
+     * @overload
+     * @param {Data} dataset
+     * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}
+     *
+     * @overload
+     * @param {Key} key
+     * @returns {Data[Key]}
+     *
+     * @overload
+     * @param {Key} key
+     * @param {Data[Key]} value
+     * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}
+     *
+     * @param {Data | Key} [key]
+     *   Key to get or set, or entire dataset to set, or nothing to get the
+     *   entire dataset (optional).
+     * @param {Data[Key]} [value]
+     *   Value to set (optional).
+     * @returns {unknown}
+     *   The current processor when setting, the value at `key` when getting, or
+     *   the entire dataset when getting without key.
+     */
+    data<Key extends keyof Data$1>(key: Key): Data$1[Key];
+    /**
+     * Configure the processor with info available to all plugins.
+     * Information is stored in an object.
+     *
+     * Typically, options can be given to a specific plugin, but sometimes it
+     * makes sense to have information shared with several plugins.
+     * For example, a list of HTML elements that are self-closing, which is
+     * needed during all phases.
+     *
+     * > **Note**: setting information cannot occur on *frozen* processors.
+     * > Call the processor first to create a new unfrozen processor.
+     *
+     * > **Note**: to register custom data in TypeScript, augment the
+     * > {@linkcode Data} interface.
+     *
+     * @example
+     *   This example show how to get and set info:
+     *
+     *   ```js
+     *   import {unified} from 'unified'
+     *
+     *   const processor = unified().data('alpha', 'bravo')
+     *
+     *   processor.data('alpha') // => 'bravo'
+     *
+     *   processor.data() // => {alpha: 'bravo'}
+     *
+     *   processor.data({charlie: 'delta'})
+     *
+     *   processor.data() // => {charlie: 'delta'}
+     *   ```
+     *
+     * @template {keyof Data} Key
+     *
+     * @overload
+     * @returns {Data}
+     *
+     * @overload
+     * @param {Data} dataset
+     * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}
+     *
+     * @overload
+     * @param {Key} key
+     * @returns {Data[Key]}
+     *
+     * @overload
+     * @param {Key} key
+     * @param {Data[Key]} value
+     * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}
+     *
+     * @param {Data | Key} [key]
+     *   Key to get or set, or entire dataset to set, or nothing to get the
+     *   entire dataset (optional).
+     * @param {Data[Key]} [value]
+     *   Value to set (optional).
+     * @returns {unknown}
+     *   The current processor when setting, the value at `key` when getting, or
+     *   the entire dataset when getting without key.
+     */
+    data<Key extends keyof Data$1>(key: Key, value: Data$1[Key]): Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>;
+    /**
+     * Freeze a processor.
+     *
+     * Frozen processors are meant to be extended and not to be configured
+     * directly.
+     *
+     * When a processor is frozen it cannot be unfrozen.
+     * New processors working the same way can be created by calling the
+     * processor.
+     *
+     * It’s possible to freeze processors explicitly by calling `.freeze()`.
+     * Processors freeze automatically when `.parse()`, `.run()`, `.runSync()`,
+     * `.stringify()`, `.process()`, or `.processSync()` are called.
+     *
+     * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}
+     *   The current processor.
+     */
+    freeze(): Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>;
+    /**
+     * Parse text to a syntax tree.
+     *
+     * > **Note**: `parse` freezes the processor if not already *frozen*.
+     *
+     * > **Note**: `parse` performs the parse phase, not the run phase or other
+     * > phases.
+     *
+     * @param {Compatible | undefined} [file]
+     *   file to parse (optional); typically `string` or `VFile`; any value
+     *   accepted as `x` in `new VFile(x)`.
+     * @returns {ParseTree extends undefined ? Node : ParseTree}
+     *   Syntax tree representing `file`.
+     */
+    parse(file?: Compatible | undefined): ParseTree extends undefined ? Node : ParseTree;
+    /**
+     * Process the given file as configured on the processor.
+     *
+     * > **Note**: `process` freezes the processor if not already *frozen*.
+     *
+     * > **Note**: `process` performs the parse, run, and stringify phases.
+     *
+     * @overload
+     * @param {Compatible | undefined} file
+     * @param {ProcessCallback<VFileWithOutput<CompileResult>>} done
+     * @returns {undefined}
+     *
+     * @overload
+     * @param {Compatible | undefined} [file]
+     * @returns {Promise<VFileWithOutput<CompileResult>>}
+     *
+     * @param {Compatible | undefined} [file]
+     *   File (optional); typically `string` or `VFile`]; any value accepted as
+     *   `x` in `new VFile(x)`.
+     * @param {ProcessCallback<VFileWithOutput<CompileResult>> | undefined} [done]
+     *   Callback (optional).
+     * @returns {Promise<VFile> | undefined}
+     *   Nothing if `done` is given.
+     *   Otherwise a promise, rejected with a fatal error or resolved with the
+     *   processed file.
+     *
+     *   The parsed, transformed, and compiled value is available at
+     *   `file.value` (see note).
+     *
+     *   > **Note**: unified typically compiles by serializing: most
+     *   > compilers return `string` (or `Uint8Array`).
+     *   > Some compilers, such as the one configured with
+     *   > [`rehype-react`][rehype-react], return other values (in this case, a
+     *   > React tree).
+     *   > If you’re using a compiler that doesn’t serialize, expect different
+     *   > result values.
+     *   >
+     *   > To register custom results in TypeScript, add them to
+     *   > {@linkcode CompileResultMap}.
+     *
+     *   [rehype-react]: https://github.com/rehypejs/rehype-react
+     */
+    process(file: Compatible | undefined, done: ProcessCallback<VFileWithOutput<CompileResult>>): undefined;
+    /**
+     * Process the given file as configured on the processor.
+     *
+     * > **Note**: `process` freezes the processor if not already *frozen*.
+     *
+     * > **Note**: `process` performs the parse, run, and stringify phases.
+     *
+     * @overload
+     * @param {Compatible | undefined} file
+     * @param {ProcessCallback<VFileWithOutput<CompileResult>>} done
+     * @returns {undefined}
+     *
+     * @overload
+     * @param {Compatible | undefined} [file]
+     * @returns {Promise<VFileWithOutput<CompileResult>>}
+     *
+     * @param {Compatible | undefined} [file]
+     *   File (optional); typically `string` or `VFile`]; any value accepted as
+     *   `x` in `new VFile(x)`.
+     * @param {ProcessCallback<VFileWithOutput<CompileResult>> | undefined} [done]
+     *   Callback (optional).
+     * @returns {Promise<VFile> | undefined}
+     *   Nothing if `done` is given.
+     *   Otherwise a promise, rejected with a fatal error or resolved with the
+     *   processed file.
+     *
+     *   The parsed, transformed, and compiled value is available at
+     *   `file.value` (see note).
+     *
+     *   > **Note**: unified typically compiles by serializing: most
+     *   > compilers return `string` (or `Uint8Array`).
+     *   > Some compilers, such as the one configured with
+     *   > [`rehype-react`][rehype-react], return other values (in this case, a
+     *   > React tree).
+     *   > If you’re using a compiler that doesn’t serialize, expect different
+     *   > result values.
+     *   >
+     *   > To register custom results in TypeScript, add them to
+     *   > {@linkcode CompileResultMap}.
+     *
+     *   [rehype-react]: https://github.com/rehypejs/rehype-react
+     */
+    process(file?: Compatible | undefined): Promise<VFileWithOutput<CompileResult>>;
+    /**
+     * Process the given file as configured on the processor.
+     *
+     * An error is thrown if asynchronous transforms are configured.
+     *
+     * > **Note**: `processSync` freezes the processor if not already *frozen*.
+     *
+     * > **Note**: `processSync` performs the parse, run, and stringify phases.
+     *
+     * @param {Compatible | undefined} [file]
+     *   File (optional); typically `string` or `VFile`; any value accepted as
+     *   `x` in `new VFile(x)`.
+     * @returns {VFileWithOutput<CompileResult>}
+     *   The processed file.
+     *
+     *   The parsed, transformed, and compiled value is available at
+     *   `file.value` (see note).
+     *
+     *   > **Note**: unified typically compiles by serializing: most
+     *   > compilers return `string` (or `Uint8Array`).
+     *   > Some compilers, such as the one configured with
+     *   > [`rehype-react`][rehype-react], return other values (in this case, a
+     *   > React tree).
+     *   > If you’re using a compiler that doesn’t serialize, expect different
+     *   > result values.
+     *   >
+     *   > To register custom results in TypeScript, add them to
+     *   > {@linkcode CompileResultMap}.
+     *
+     *   [rehype-react]: https://github.com/rehypejs/rehype-react
+     */
+    processSync(file?: Compatible | undefined): VFileWithOutput<CompileResult>;
+    /**
+     * Run *transformers* on a syntax tree.
+     *
+     * > **Note**: `run` freezes the processor if not already *frozen*.
+     *
+     * > **Note**: `run` performs the run phase, not other phases.
+     *
+     * @overload
+     * @param {HeadTree extends undefined ? Node : HeadTree} tree
+     * @param {RunCallback<TailTree extends undefined ? Node : TailTree>} done
+     * @returns {undefined}
+     *
+     * @overload
+     * @param {HeadTree extends undefined ? Node : HeadTree} tree
+     * @param {Compatible | undefined} file
+     * @param {RunCallback<TailTree extends undefined ? Node : TailTree>} done
+     * @returns {undefined}
+     *
+     * @overload
+     * @param {HeadTree extends undefined ? Node : HeadTree} tree
+     * @param {Compatible | undefined} [file]
+     * @returns {Promise<TailTree extends undefined ? Node : TailTree>}
+     *
+     * @param {HeadTree extends undefined ? Node : HeadTree} tree
+     *   Tree to transform and inspect.
+     * @param {(
+     *   RunCallback<TailTree extends undefined ? Node : TailTree> |
+     *   Compatible
+     * )} [file]
+     *   File associated with `node` (optional); any value accepted as `x` in
+     *   `new VFile(x)`.
+     * @param {RunCallback<TailTree extends undefined ? Node : TailTree>} [done]
+     *   Callback (optional).
+     * @returns {Promise<TailTree extends undefined ? Node : TailTree> | undefined}
+     *   Nothing if `done` is given.
+     *   Otherwise, a promise rejected with a fatal error or resolved with the
+     *   transformed tree.
+     */
+    run(tree: HeadTree extends undefined ? Node : HeadTree, done: RunCallback<TailTree extends undefined ? Node : TailTree>): undefined;
+    /**
+     * Run *transformers* on a syntax tree.
+     *
+     * > **Note**: `run` freezes the processor if not already *frozen*.
+     *
+     * > **Note**: `run` performs the run phase, not other phases.
+     *
+     * @overload
+     * @param {HeadTree extends undefined ? Node : HeadTree} tree
+     * @param {RunCallback<TailTree extends undefined ? Node : TailTree>} done
+     * @returns {undefined}
+     *
+     * @overload
+     * @param {HeadTree extends undefined ? Node : HeadTree} tree
+     * @param {Compatible | undefined} file
+     * @param {RunCallback<TailTree extends undefined ? Node : TailTree>} done
+     * @returns {undefined}
+     *
+     * @overload
+     * @param {HeadTree extends undefined ? Node : HeadTree} tree
+     * @param {Compatible | undefined} [file]
+     * @returns {Promise<TailTree extends undefined ? Node : TailTree>}
+     *
+     * @param {HeadTree extends undefined ? Node : HeadTree} tree
+     *   Tree to transform and inspect.
+     * @param {(
+     *   RunCallback<TailTree extends undefined ? Node : TailTree> |
+     *   Compatible
+     * )} [file]
+     *   File associated with `node` (optional); any value accepted as `x` in
+     *   `new VFile(x)`.
+     * @param {RunCallback<TailTree extends undefined ? Node : TailTree>} [done]
+     *   Callback (optional).
+     * @returns {Promise<TailTree extends undefined ? Node : TailTree> | undefined}
+     *   Nothing if `done` is given.
+     *   Otherwise, a promise rejected with a fatal error or resolved with the
+     *   transformed tree.
+     */
+    run(tree: HeadTree extends undefined ? Node : HeadTree, file: Compatible | undefined, done: RunCallback<TailTree extends undefined ? Node : TailTree>): undefined;
+    /**
+     * Run *transformers* on a syntax tree.
+     *
+     * > **Note**: `run` freezes the processor if not already *frozen*.
+     *
+     * > **Note**: `run` performs the run phase, not other phases.
+     *
+     * @overload
+     * @param {HeadTree extends undefined ? Node : HeadTree} tree
+     * @param {RunCallback<TailTree extends undefined ? Node : TailTree>} done
+     * @returns {undefined}
+     *
+     * @overload
+     * @param {HeadTree extends undefined ? Node : HeadTree} tree
+     * @param {Compatible | undefined} file
+     * @param {RunCallback<TailTree extends undefined ? Node : TailTree>} done
+     * @returns {undefined}
+     *
+     * @overload
+     * @param {HeadTree extends undefined ? Node : HeadTree} tree
+     * @param {Compatible | undefined} [file]
+     * @returns {Promise<TailTree extends undefined ? Node : TailTree>}
+     *
+     * @param {HeadTree extends undefined ? Node : HeadTree} tree
+     *   Tree to transform and inspect.
+     * @param {(
+     *   RunCallback<TailTree extends undefined ? Node : TailTree> |
+     *   Compatible
+     * )} [file]
+     *   File associated with `node` (optional); any value accepted as `x` in
+     *   `new VFile(x)`.
+     * @param {RunCallback<TailTree extends undefined ? Node : TailTree>} [done]
+     *   Callback (optional).
+     * @returns {Promise<TailTree extends undefined ? Node : TailTree> | undefined}
+     *   Nothing if `done` is given.
+     *   Otherwise, a promise rejected with a fatal error or resolved with the
+     *   transformed tree.
+     */
+    run(tree: HeadTree extends undefined ? Node : HeadTree, file?: Compatible | undefined): Promise<TailTree extends undefined ? Node : TailTree>;
+    /**
+     * Run *transformers* on a syntax tree.
+     *
+     * An error is thrown if asynchronous transforms are configured.
+     *
+     * > **Note**: `runSync` freezes the processor if not already *frozen*.
+     *
+     * > **Note**: `runSync` performs the run phase, not other phases.
+     *
+     * @param {HeadTree extends undefined ? Node : HeadTree} tree
+     *   Tree to transform and inspect.
+     * @param {Compatible | undefined} [file]
+     *   File associated with `node` (optional); any value accepted as `x` in
+     *   `new VFile(x)`.
+     * @returns {TailTree extends undefined ? Node : TailTree}
+     *   Transformed tree.
+     */
+    runSync(tree: HeadTree extends undefined ? Node : HeadTree, file?: Compatible | undefined): TailTree extends undefined ? Node : TailTree;
+    /**
+     * Compile a syntax tree.
+     *
+     * > **Note**: `stringify` freezes the processor if not already *frozen*.
+     *
+     * > **Note**: `stringify` performs the stringify phase, not the run phase
+     * > or other phases.
+     *
+     * @param {CompileTree extends undefined ? Node : CompileTree} tree
+     *   Tree to compile.
+     * @param {Compatible | undefined} [file]
+     *   File associated with `node` (optional); any value accepted as `x` in
+     *   `new VFile(x)`.
+     * @returns {CompileResult extends undefined ? Value : CompileResult}
+     *   Textual representation of the tree (see note).
+     *
+     *   > **Note**: unified typically compiles by serializing: most compilers
+     *   > return `string` (or `Uint8Array`).
+     *   > Some compilers, such as the one configured with
+     *   > [`rehype-react`][rehype-react], return other values (in this case, a
+     *   > React tree).
+     *   > If you’re using a compiler that doesn’t serialize, expect different
+     *   > result values.
+     *   >
+     *   > To register custom results in TypeScript, add them to
+     *   > {@linkcode CompileResultMap}.
+     *
+     *   [rehype-react]: https://github.com/rehypejs/rehype-react
+     */
+    stringify(tree: CompileTree extends undefined ? Node : CompileTree, file?: Compatible | undefined): CompileResult extends undefined ? Value : CompileResult;
+    /**
+     * Configure the processor to use a plugin, a list of usable values, or a
+     * preset.
+     *
+     * If the processor is already using a plugin, the previous plugin
+     * configuration is changed based on the options that are passed in.
+     * In other words, the plugin is not added a second time.
+     *
+     * > **Note**: `use` cannot be called on *frozen* processors.
+     * > Call the processor first to create a new unfrozen processor.
+     *
+     * @example
+     *   There are many ways to pass plugins to `.use()`.
+     *   This example gives an overview:
+     *
+     *   ```js
+     *   import {unified} from 'unified'
+     *
+     *   unified()
+     *     // Plugin with options:
+     *     .use(pluginA, {x: true, y: true})
+     *     // Passing the same plugin again merges configuration (to `{x: true, y: false, z: true}`):
+     *     .use(pluginA, {y: false, z: true})
+     *     // Plugins:
+     *     .use([pluginB, pluginC])
+     *     // Two plugins, the second with options:
+     *     .use([pluginD, [pluginE, {}]])
+     *     // Preset with plugins and settings:
+     *     .use({plugins: [pluginF, [pluginG, {}]], settings: {position: false}})
+     *     // Settings only:
+     *     .use({settings: {position: false}})
+     *   ```
+     *
+     * @template {Array<unknown>} [Parameters=[]]
+     * @template {Node | string | undefined} [Input=undefined]
+     * @template [Output=Input]
+     *
+     * @overload
+     * @param {Preset | null | undefined} [preset]
+     * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}
+     *
+     * @overload
+     * @param {PluggableList} list
+     * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}
+     *
+     * @overload
+     * @param {Plugin<Parameters, Input, Output>} plugin
+     * @param {...(Parameters | [boolean])} parameters
+     * @returns {UsePlugin<ParseTree, HeadTree, TailTree, CompileTree, CompileResult, Input, Output>}
+     *
+     * @param {PluggableList | Plugin | Preset | null | undefined} value
+     *   Usable value.
+     * @param {...unknown} parameters
+     *   Parameters, when a plugin is given as a usable value.
+     * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}
+     *   Current processor.
+     */
+    use<Parameters_1 extends unknown[] = [], Input extends string | unist.Node | undefined = undefined, Output = Input>(preset?: Preset | null | undefined): Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>;
+    /**
+     * Configure the processor to use a plugin, a list of usable values, or a
+     * preset.
+     *
+     * If the processor is already using a plugin, the previous plugin
+     * configuration is changed based on the options that are passed in.
+     * In other words, the plugin is not added a second time.
+     *
+     * > **Note**: `use` cannot be called on *frozen* processors.
+     * > Call the processor first to create a new unfrozen processor.
+     *
+     * @example
+     *   There are many ways to pass plugins to `.use()`.
+     *   This example gives an overview:
+     *
+     *   ```js
+     *   import {unified} from 'unified'
+     *
+     *   unified()
+     *     // Plugin with options:
+     *     .use(pluginA, {x: true, y: true})
+     *     // Passing the same plugin again merges configuration (to `{x: true, y: false, z: true}`):
+     *     .use(pluginA, {y: false, z: true})
+     *     // Plugins:
+     *     .use([pluginB, pluginC])
+     *     // Two plugins, the second with options:
+     *     .use([pluginD, [pluginE, {}]])
+     *     // Preset with plugins and settings:
+     *     .use({plugins: [pluginF, [pluginG, {}]], settings: {position: false}})
+     *     // Settings only:
+     *     .use({settings: {position: false}})
+     *   ```
+     *
+     * @template {Array<unknown>} [Parameters=[]]
+     * @template {Node | string | undefined} [Input=undefined]
+     * @template [Output=Input]
+     *
+     * @overload
+     * @param {Preset | null | undefined} [preset]
+     * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}
+     *
+     * @overload
+     * @param {PluggableList} list
+     * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}
+     *
+     * @overload
+     * @param {Plugin<Parameters, Input, Output>} plugin
+     * @param {...(Parameters | [boolean])} parameters
+     * @returns {UsePlugin<ParseTree, HeadTree, TailTree, CompileTree, CompileResult, Input, Output>}
+     *
+     * @param {PluggableList | Plugin | Preset | null | undefined} value
+     *   Usable value.
+     * @param {...unknown} parameters
+     *   Parameters, when a plugin is given as a usable value.
+     * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}
+     *   Current processor.
+     */
+    use<Parameters_1 extends unknown[] = [], Input extends string | unist.Node | undefined = undefined, Output = Input>(list: PluggableList): Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>;
+    /**
+     * Configure the processor to use a plugin, a list of usable values, or a
+     * preset.
+     *
+     * If the processor is already using a plugin, the previous plugin
+     * configuration is changed based on the options that are passed in.
+     * In other words, the plugin is not added a second time.
+     *
+     * > **Note**: `use` cannot be called on *frozen* processors.
+     * > Call the processor first to create a new unfrozen processor.
+     *
+     * @example
+     *   There are many ways to pass plugins to `.use()`.
+     *   This example gives an overview:
+     *
+     *   ```js
+     *   import {unified} from 'unified'
+     *
+     *   unified()
+     *     // Plugin with options:
+     *     .use(pluginA, {x: true, y: true})
+     *     // Passing the same plugin again merges configuration (to `{x: true, y: false, z: true}`):
+     *     .use(pluginA, {y: false, z: true})
+     *     // Plugins:
+     *     .use([pluginB, pluginC])
+     *     // Two plugins, the second with options:
+     *     .use([pluginD, [pluginE, {}]])
+     *     // Preset with plugins and settings:
+     *     .use({plugins: [pluginF, [pluginG, {}]], settings: {position: false}})
+     *     // Settings only:
+     *     .use({settings: {position: false}})
+     *   ```
+     *
+     * @template {Array<unknown>} [Parameters=[]]
+     * @template {Node | string | undefined} [Input=undefined]
+     * @template [Output=Input]
+     *
+     * @overload
+     * @param {Preset | null | undefined} [preset]
+     * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}
+     *
+     * @overload
+     * @param {PluggableList} list
+     * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}
+     *
+     * @overload
+     * @param {Plugin<Parameters, Input, Output>} plugin
+     * @param {...(Parameters | [boolean])} parameters
+     * @returns {UsePlugin<ParseTree, HeadTree, TailTree, CompileTree, CompileResult, Input, Output>}
+     *
+     * @param {PluggableList | Plugin | Preset | null | undefined} value
+     *   Usable value.
+     * @param {...unknown} parameters
+     *   Parameters, when a plugin is given as a usable value.
+     * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}
+     *   Current processor.
+     */
+    use<Parameters_1 extends unknown[] = [], Input extends string | unist.Node | undefined = undefined, Output = Input>(plugin: Plugin$1<Parameters_1, Input, Output>, ...parameters: Parameters_1 | [boolean]): UsePlugin<ParseTree, HeadTree, TailTree, CompileTree, CompileResult, Input, Output>;
+}
+type Pipeline = Pipeline$1;
+type Node = unist.Node;
+type Compatible = Compatible$1;
+type Value = Value$1;
+type CompileResultMap = CompileResultMap$1;
+type Data = Data$2;
+type Settings$1 = Settings$3;
+/**
+ * Acceptable results from compilers.
+ *
+ * To register custom results, add them to
+ * {@linkcode CompileResultMap }.
+ */
+type CompileResults = CompileResultMap[keyof CompileResultMap];
+/**
+ * A **compiler** handles the compiling of a syntax tree to something else
+ * (in most cases, text) (TypeScript type).
+ *
+ * It is used in the stringify phase and called with a {@linkcode Node }
+ * and {@linkcode VFile } representation of the document to compile.
+ * It should return the textual representation of the given tree (typically
+ * `string`).
+ *
+ * > **Note**: unified typically compiles by serializing: most compilers
+ * > return `string` (or `Uint8Array`).
+ * > Some compilers, such as the one configured with
+ * > [`rehype-react`][rehype-react], return other values (in this case, a
+ * > React tree).
+ * > If you’re using a compiler that doesn’t serialize, expect different
+ * > result values.
+ * >
+ * > To register custom results in TypeScript, add them to
+ * > {@linkcode CompileResultMap }.
+ *
+ * [rehype-react]: https://github.com/rehypejs/rehype-react
+ */
+type Compiler<Tree extends unist.Node = unist.Node, Result extends CompileResults = CompileResults> = (tree: Tree, file: VFile) => Result;
+/**
+ * A **parser** handles the parsing of text to a syntax tree.
+ *
+ * It is used in the parse phase and is called with a `string` and
+ * {@linkcode VFile } of the document to parse.
+ * It must return the syntax tree representation of the given file
+ * ({@linkcode Node }).
+ */
+type Parser<Tree extends unist.Node = unist.Node> = (document: string, file: VFile) => Tree;
+/**
+ * Union of the different ways to add plugins and settings.
+ */
+type Pluggable = (Plugin$1<Array<any>, any, any> | PluginTuple<Array<any>, any, any> | Preset);
+/**
+ * List of plugins and presets.
+ */
+type PluggableList = Array<Pluggable>;
+/**
+ * Single plugin.
+ *
+ * Plugins configure the processors they are applied on in the following
+ * ways:
+ *
+ * *   they change the processor, such as the parser, the compiler, or by
+ *   configuring data
+ * *   they specify how to handle trees and files
+ *
+ * In practice, they are functions that can receive options and configure the
+ * processor (`this`).
+ *
+ * > **Note**: plugins are called when the processor is *frozen*, not when
+ * > they are applied.
+ */
+type Plugin$1<PluginParameters extends unknown[] = [], Input extends string | unist.Node | undefined = unist.Node, Output = Input> = ((this: Processor, ...parameters: PluginParameters) => Input extends string ? Output extends Node | undefined ? undefined | void : never : Output extends CompileResults ? Input extends Node | undefined ? undefined | void : never : Transformer<Input extends Node ? Input : Node, Output extends Node ? Output : Node> | undefined | void);
+/**
+ * Tuple of a plugin and its configuration.
+ *
+ * The first item is a plugin, the rest are its parameters.
+ */
+type PluginTuple<TupleParameters extends unknown[] = [], Input extends string | unist.Node | undefined = undefined, Output = undefined> = ([
+    plugin: Plugin$1<TupleParameters, Input, Output>,
+    ...parameters: TupleParameters
+]);
+/**
+ * Sharable configuration.
+ *
+ * They can contain plugins and settings.
+ */
+type Preset = {
+    /**
+     * List of plugins and presets (optional).
+     */
+    plugins?: PluggableList | undefined;
+    /**
+     * Shared settings for parsers and compilers (optional).
+     */
+    settings?: Settings$1 | undefined;
+};
+/**
+ * Callback called when the process is done.
+ *
+ * Called with either an error or a result.
+ */
+type ProcessCallback<File extends VFile = VFile> = (error?: Error | undefined, file?: File | undefined) => undefined;
+/**
+ * Callback called when transformers are done.
+ *
+ * Called with either an error or results.
+ */
+type RunCallback<Tree extends unist.Node = unist.Node> = (error?: Error | undefined, tree?: Tree | undefined, file?: VFile | undefined) => undefined;
+/**
+ * Callback passed to transforms.
+ *
+ * If the signature of a `transformer` accepts a third argument, the
+ * transformer may perform asynchronous operations, and must call it.
+ */
+type TransformCallback<Output extends unist.Node = unist.Node> = (error?: Error | undefined, tree?: Output | undefined, file?: VFile | undefined) => undefined;
+/**
+ * Transformers handle syntax trees and files.
+ *
+ * They are functions that are called each time a syntax tree and file are
+ * passed through the run phase.
+ * When an error occurs in them (either because it’s thrown, returned,
+ * rejected, or passed to `next`), the process stops.
+ *
+ * The run phase is handled by [`trough`][trough], see its documentation for
+ * the exact semantics of these functions.
+ *
+ * > **Note**: you should likely ignore `next`: don’t accept it.
+ * > it supports callback-style async work.
+ * > But promises are likely easier to reason about.
+ *
+ * [trough]: https://github.com/wooorm/trough#function-fninput-next
+ */
+type Transformer<Input extends unist.Node = unist.Node, Output extends unist.Node = Input> = (tree: Input, file: VFile, next: TransformCallback<Output>) => (Promise<Output | undefined | void> | Promise<never> | // For some reason this is needed separately.
+Output | Error | undefined | void);
+/**
+ * Create a processor based on the input/output of a {@link Plugin plugin}.
+ */
+type UsePlugin<ParseTree extends unist.Node | undefined, HeadTree extends unist.Node | undefined, TailTree extends unist.Node | undefined, CompileTree extends unist.Node | undefined, CompileResult extends CompileResults | undefined, Input extends string | unist.Node | undefined, Output> = (Input extends string ? Output extends Node | undefined ? Processor<Output extends undefined ? ParseTree : Output, HeadTree, TailTree, CompileTree, CompileResult> : Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult> : Output extends CompileResults ? Input extends Node | undefined ? Processor<ParseTree, HeadTree, TailTree, Input extends undefined ? CompileTree : Input, Output extends undefined ? CompileResult : Output> : Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult> : Input extends Node | undefined ? Output extends Node | undefined ? Processor<ParseTree, HeadTree extends undefined ? Input : HeadTree, Output extends undefined ? TailTree : Output, CompileTree, CompileResult> : Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult> : Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>);
+/**
+ * Type to generate a {@linkcode VFile } corresponding to a compiler result.
+ *
+ * If a result that is not acceptable on a `VFile` is used, that will
+ * be stored on the `result` field of {@linkcode VFile }.
+ */
+type VFileWithOutput<Result extends CompileResults | undefined> = (Result extends Value | undefined ? VFile : VFile & {
+    result: Result;
+});
+
+/**
+ * @todo rename to PageMeta
+ *
+ * Represents metadata for a content page.
+ * Usually used as md/mdx frontmatter.
+ *
+ */
+interface Metadata<P = void> {
+    /** The main title of the content - by default visible in navigation and page title */
+    title: string;
+    /** Title to display in the sidebar navigation */
+    sidebarTitle?: string;
+    /** Display description for SEO/llms.txt purposes */
+    description?: string;
+    /**  Icon identifier for the navigation item */
+    icon?: string;
+    /** Layout type for the content display */
+    layout?: PageLayout;
+    /** Max depth for table of contents */
+    maxTocDepth?: number;
+    /** External URL for the content */
+    url?: string;
+    /**
+     * If false, hide the copy page button
+     */
+    copyPage?: boolean;
+    /**
+     * @internal
+     *
+     * The type of component to render this content with
+     */
+    component?: "docs" | "atlas" | "home" | "firstslide" | "bloghome" | "blogpost";
+    /**
+     * @internal
+     *
+     * Properties specific to the component type
+     */
+    componentProps?: P;
+    /**
+     * @internal
+     *
+     * Group for sidebar navigation
+    */
+    group?: string[];
+    /**
+     * Uniform for API Docs references
+     */
+    uniform?: PageMetaUniform;
+    /**
+     * @internal
+     *
+     * used for graphql references
+     */
+    graphql?: string;
+    /**
+     * @internal
+     *
+     * used for openapi references
+     */
+    openapi?: string;
+    /**
+     * If true, hide from navigation
+     */
+    hidden?: boolean;
+    /**
+     * Optional 'tocCard' for custom cards in the table of contents
+     *
+     * @example
+     * ```
+     * tocCard: {
+     *     link: "https://github.com/livesession/livesession-browser",
+     *     title: "Checkout the code",
+     *     description: "Check how to use the LiveSession Browser SDK",
+     *     icon: "github"
+     * }
+     * ```
+     */
+    tocCard?: TocCard | TocCard[];
+}
+interface TocCard {
+    /** 'link' to the card */
+    link: string;
+    /** 'title' of the card */
+    title: string;
+    /** 'description' of the card */
+    description: string;
+    /** 'icon' of the card */
+    icon?: string;
+}
+type PageMetaUniform = string | PageMetaUniformDetails;
+/**
+ * Uniform details allows to specify more options than just the path, for example eager loading
+ */
+type PageMetaUniformDetails = {
+    /**
+     * Path to the uniform file / url
+     */
+    path: string;
+    /**
+     * If true, the uniform will be eagerly loaded
+     */
+    eager?: boolean;
+};
+type PageLayout = "wide" | "page" | "reader";
+
 type RawTheme = {
     name?: string;
     type?: string;
@@ -1205,27 +4654,48 @@ type PluginComponents = {
     component: React__default.ComponentType<any>;
     name?: string;
     dist?: string;
+    isInline?: boolean;
 }[] | {
     [component: string]: React__default.ComponentType<any>;
 };
+interface HookCallbackArgs {
+    metadata: Metadata<any>;
+}
 /**
  * Plugin interface
  *
  * @example
  * ```ts
  * function myPlugin(): Plugin {
- *     return {
- *         name: "my-plugin",
- *         vite: [
- *             {
- *                 name: "my-vite-plugin",
- *             }
- *         ],
- *         uniform: [
- *             pluginOpenAIMeta,
- *         ],
- *         atlas: {
- *             components: {
+ *     return (settings) => {
+ *         return {
+ *             name: "my-plugin",
+ *             vite: [
+ *                 {
+ *                     name: "my-vite-plugin",
+ *                 }
+ *             ],
+ *             uniform: [
+ *                 pluginOpenAIMeta,
+ *             ],
+ *             components: [
+ *                 {
+ *                     component: MyComponent,
+ *                     name: "MyComponent",
+ *                     dist: "./dist/MyComponent.js"
+ *                 }
+ *             ],
+ *             head: [
+ *                 ["style", {}, "body { margin: 0; }"]
+ *             ],
+ *             markdown: {
+ *                 remark: [remarkPlugin],
+ *                 rehype: [rehypePlugin],
+ *             },
+ *             hooks: {
+ *                 applyComponents(cfg) {
+ *                     return cfg?.metadata?.component === "my-plugin";
+ *                 }
  *             }
  *         }
  *     }
@@ -1234,15 +4704,19 @@ type PluginComponents = {
  */
 interface PluginConfig {
     name: string;
-    vite?: Plugin$1[];
+    vite?: Plugin$2[];
     uniform?: UniformPlugin<any>[];
     components?: PluginComponents;
     head?: HeadConfig[];
     markdown?: {
-        remark: any[];
-        rehype: any[];
+        remark?: Plugin$1[];
+        rehype?: Plugin$1[];
+        remarkRehypeHandlers?: any;
+    };
+    hooks?: {
+        applyComponents?: (cfg: HookCallbackArgs) => boolean;
     };
 }
 type Plugin = (settings: Readonly<Settings>) => PluginConfig;
 
-export type { Plugin, PluginComponents, PluginConfig };
+export type { HookCallbackArgs, Plugin, PluginComponents, PluginConfig };