@league-of-foundry-developers/foundry-vtt-types 9.280.1 → 12.331.2-beta

package/src/foundry/common/primitives/set.d.mts

@@ -0,0 +1,105 @@
+export {};
+
+declare global {
+  interface Set<T> {
+    /**
+     * Return the difference of two sets.
+     * @param other - Some other set to compare against
+     * @returns The difference defined as objects in this which are not present in other
+     */
+    difference(other: Set<T>): Set<T>;
+
+    /**
+     * Test whether this set is equal to some other set.
+     * Sets are equal if they share the same members, independent of order
+     * @param other - Some other set to compare against
+     * @returns Are the sets equal?
+     */
+    equals(other: Set<T>): boolean;
+
+    /**
+     * Return the first value from the set.
+     * @returns The first element in the set, or undefined
+     */
+    first(): T | undefined;
+
+    /**
+     * Return the intersection of two sets.
+     * @param other - Some other set to compare against
+     * @returns The intersection of both sets
+     */
+    intersection(other: Set<T>): Set<T>;
+
+    /**
+     * Test whether this set has an intersection with another set.
+     * @param other - Another set to compare against
+     * @returns Do the sets intersect?
+     */
+    intersects(other: Set<T>): boolean;
+
+    /**
+     * Test whether this set is a subset of some other set.
+     * A set is a subset if all its members are also present in the other set.
+     * @param other - Some other set that may be a subset of this one
+     * @returns Is the other set a subset of this one?
+     */
+    isSubset(other: Set<T>): boolean;
+
+    /**
+     * Convert a set to a JSON object by mapping its contents to an array
+     * @returns The set elements as an array.
+     */
+    toObject(): T[];
+
+    /**
+     * Test whether every element in this Set satisfies a certain test criterion.
+     * @see {@link Array#every}
+     * @param test - The test criterion to apply. Positional arguments are the value, the index of iteration, and the set being tested.
+     * @returns Does every element in the set satisfy the test criterion?
+     */
+    every(test: (value: T, index: number, set: Set<T>) => boolean): boolean;
+
+    /**
+     * Filter this set to create a subset of elements which satisfy a certain test criterion.
+     * @see {@link Array#filter}
+     * @param test - The test criterion to apply. Positional arguments are the value, the index of iteration, and the set being filtered.
+     * @returns A new Set containing only elements which satisfy the test criterion.
+     */
+    filter<F extends T>(test: (value: T, index: number, set: Set<T>) => value is F): Set<F>;
+    filter(test: (value: T, index: number, set: Set<T>) => boolean): Set<T>;
+
+    /**
+     * Find the first element in this set which satisfies a certain test criterion.
+     * @see {@link Array#find}
+     * @param test - The test criterion to apply. Positional arguments are the value, the index of iteration, and the set being searched.
+     * @returns The first element in the set which satisfies the test criterion, or undefined.
+     */
+    find<F extends T>(test: (value: T, index: number, set: Set<T>) => value is F): F | undefined;
+    find(test: (value: T, index: number, set: Set<T>) => boolean): T | undefined;
+
+    /**
+     * Create a new Set where every element is modified by a provided transformation function.
+     * @see {@link Array#map}
+     * @param transform - The transformation function to apply.Positional arguments are the value, the index of iteration, and the set being transformed.
+     * @returns A new Set of equal size containing transformed elements.
+     */
+    map<V>(transform: (value: T, index: number, set: Set<T>) => V): Set<V>;
+
+    /**
+     * Create a new Set with elements that are filtered and transformed by a provided reducer function.
+     * @see {@link Array#reduce}
+     * @param reducer - A reducer function applied to each value. Positional arguments are the accumulator, the value, the index of iteration, and the set being reduced.
+     * @param accumulator - The initial value of the returned accumulator.
+     * @returns The final value of the accumulator.
+     */
+    reduce<V>(reducer: (accumulator: V, value: T, index: number, set: Set<T>) => V, accumulator: V): V;
+
+    /**
+     * Test whether any element in this Set satisfies a certain test criterion.
+     * @see {@link Array#some}
+     * @param test - The test criterion to apply. Positional arguments are the value, the index of iteration, and the set being tested.
+     * @returns Does any element in the set satisfy the test criterion?
+     */
+    some(test: (value: T, index: number, set: Set<T>) => boolean): boolean;
+  }
+}

package/src/foundry/common/primitives/string.d.mts

@@ -0,0 +1,58 @@
+import type { Titlecase } from "../../../types/utils.d.mts";
+
+declare global {
+  interface String {
+    /**
+     * Capitalize a string, transforming it's first character to a capital letter
+     */
+    capitalize<S extends string>(this: S): Capitalize<S>;
+
+    /**
+     * Compare this string (x) with the other string (y) by comparing each character's Unicode code point value.
+     * This is the same comparison function that used by Array#sort if the compare function argument is omitted.
+     * The result is host/locale-independent.
+     * @param other - The other string to compare this string to.
+     * @returns A negative Number if x \< y, a positive Number if x \> y, or a zero otherwise.
+     */
+    compare<S extends string>(this: S, other: string): number;
+
+    /**
+     * Convert a string to Title Case where the first letter of each word is capitalized
+     */
+    titleCase<S extends string>(this: S): Titlecase<S>;
+
+    /**
+     * Strip any <script> tags which were included within a provided string
+     */
+    stripScripts(): string;
+
+    /**
+     * Transform any string into a url-viable slug string
+     * @param options - Optional arguments which customize how the slugify operation is performed
+     * @returns The slugified input string
+     */
+    slugify(options?: String.SlugifyOptions): string;
+  }
+
+  namespace String {
+    interface SlugifyOptions {
+      /**
+       * The replacement character to separate terms
+       * @defaultValue `"-"`
+       */
+      replacement?: string | undefined;
+
+      /**
+       * Replace all non-alphanumeric characters, or allow them?
+       * @defaultValue `false`
+       */
+      strict?: boolean | undefined;
+
+      /**
+       * Lowercase the string.
+       * @defaultValue `true`
+       */
+      lowercase?: boolean | undefined;
+    }
+  }
+}

package/src/foundry/common/primitives/url.d.mts

@@ -0,0 +1,18 @@
+export {};
+
+declare global {
+  // Non-functional due to upstream
+  // https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1379
+  // declare const URL: {
+  //   prototype: URL;
+  //   new (url: string | URL, base?: string | URL): URL;
+  //   createObjectURL(obj: Blob | MediaSource): string;
+  //   revokeObjectURL(url: string): void;
+  //   /**
+  //    * Attempt to parse a URL without throwing an error.
+  //    * @param url - The string to parse.
+  //    * @returns The parsed URL if successful, otherwise null.
+  //    */
+  //   parseSafe(url: string): URL | null;
+  // };
+}

package/src/foundry/common/prosemirror/_module.d.mts

@@ -0,0 +1,82 @@
+import { EditorState, AllSelection, TextSelection, Plugin, PluginKey } from "prosemirror-state";
+import { EditorView } from "prosemirror-view";
+import { Schema, DOMSerializer } from "prosemirror-model";
+// eslint-disable-next-line import/no-named-as-default
+import type ProseMirrorInputRules from "./input-rules.d.mts";
+import { keymap } from "prosemirror-keymap";
+// eslint-disable-next-line import/no-named-as-default
+import type ProseMirrorKeyMaps from "./keymaps.d.mts";
+// eslint-disable-next-line import/no-named-as-default
+import type ProseMirrorMenu from "./menu.d.mts";
+import "./extensions.d.mts";
+import * as collab from "prosemirror-collab";
+import type { Step } from "prosemirror-transform";
+import type { parseHTMLString, serializeHTMLString } from "./util.d.mts";
+
+// A const is being imported here. It can't be `import type`.
+// eslint-disable-next-line import/extensions
+import { schema as defaultSchema } from "./schema.mjs";
+import type ProseMirrorPlugin from "./plugin.d.mts";
+import type ProseMirrorImagePlugin from "./image-plugin.d.mts";
+import type ProseMirrorDirtyPlugin from "./dirty-plugin.d.mts";
+import type ProseMirrorContentLinkPlugin from "./content-link-plugin.d.mts";
+import type ProseMirrorHighlightMatchesPlugin from "./highlight-matches-plugin.d.mts";
+import type ProseMirrorClickHandler from "./click-handler.d.mts";
+import type DOMParser from "./dom-parser.d.mts";
+
+declare const dom: {
+  parser: DOMParser;
+  serializer: DOMSerializer;
+  parseString: typeof parseHTMLString;
+  serializeString: typeof serializeHTMLString;
+};
+
+declare const defaultPlugins: Record<
+  | "inputRules"
+  | "keyMaps"
+  | "menu"
+  | "isDirty"
+  | "clickHandler"
+  | "pasteTransformer"
+  | "baseKeyMap"
+  | "dropCursor"
+  | "gapCursor"
+  | "history"
+  | "columnResizing"
+  | "tables",
+  Plugin
+>;
+
+export * as commands from "prosemirror-commands";
+export * as transform from "prosemirror-transform";
+export * as list from "prosemirror-schema-list";
+export * as tables from "prosemirror-tables";
+export * as input from "prosemirror-inputrules";
+export * as state from "prosemirror-state";
+
+export {
+  AllSelection,
+  TextSelection,
+  DOMParser,
+  DOMSerializer,
+  EditorState,
+  EditorView,
+  Schema,
+  Step,
+  Plugin,
+  PluginKey,
+  ProseMirrorPlugin,
+  ProseMirrorContentLinkPlugin,
+  ProseMirrorHighlightMatchesPlugin,
+  ProseMirrorDirtyPlugin,
+  ProseMirrorImagePlugin,
+  ProseMirrorClickHandler,
+  ProseMirrorInputRules,
+  ProseMirrorKeyMaps,
+  ProseMirrorMenu,
+  collab,
+  defaultPlugins,
+  defaultSchema,
+  dom,
+  keymap,
+};

package/src/foundry/common/prosemirror/click-handler.d.mts

@@ -0,0 +1,34 @@
+import type { EditorView } from "prosemirror-view";
+import type { Plugin } from "prosemirror-state";
+import type ProseMirrorPlugin from "./plugin.d.mts";
+import type { Node, Schema } from "prosemirror-model";
+
+export default ProseMirrorClickHandler;
+/**
+ * A class responsible for managing click events inside a ProseMirror editor.
+ */
+declare class ProseMirrorClickHandler extends ProseMirrorPlugin {
+  static override build(schema: Schema, options?: Record<string, unknown>): Plugin;
+
+  /* -------------------------------------------- */
+
+  /**
+   * Handle a click on the editor.
+   * @param view    - The ProseMirror editor view.
+   * @param pos     - The position in the ProseMirror document that the click occurred at.
+   * @param node    - The current ProseMirror Node that the click has bubbled to.
+   * @param nodePos - The position of the click within this Node.
+   * @param event   - The click event.
+   * @param direct  - Whether this Node is the one that was directly clicked on.
+   * @returns A return value of true indicates the event has been handled, it will not propagate to
+   *          other plugins, and ProseMirror will call preventDefault on it.
+   */
+  protected _onClick(
+    view: EditorView,
+    pos: number,
+    node: Node,
+    nodePos: number,
+    event: JQuery.ClickEvent,
+    direct: boolean,
+  ): boolean | void;
+}

package/src/foundry/common/prosemirror/content-link-plugin.d.mts

@@ -0,0 +1,47 @@
+import type { Schema, Slice } from "prosemirror-model";
+import type { Plugin } from "prosemirror-state";
+import type { EditorView } from "prosemirror-view";
+import type ProseMirrorPlugin from "./plugin.d.mts";
+
+/**
+ * A class responsible for handling the dropping of Documents onto the editor and creating content links for them.
+ */
+declare class ProseMirrorContentLinkPlugin extends ProseMirrorPlugin {
+  /**
+   * @param schema  - The ProseMirror schema.
+   * @param options - Additional options to configure the plugin's behaviour.
+   */
+  constructor(schema: Schema, options?: ProseMirrorContentLinkPlugin.ProseMirrorContentLinkOptions);
+
+  /**
+   * The parent document housing this editor.
+   */
+  readonly document: foundry.abstract.Document.Any;
+
+  /**
+   * Whether to generate links relative to the parent document.
+   */
+  readonly relativeLinks: boolean;
+
+  static override build(schema: Schema, options?: ProseMirrorContentLinkPlugin.ProseMirrorContentLinkOptions): Plugin;
+
+  /**
+   * Handle a drop onto the editor.
+   * @param view  - The ProseMirror editor view.
+   * @param event - The drop event.
+   * @param slice - A slice of editor content.
+   * @param moved - Whether the slice has been moved from a different part of the editor.
+   */
+  protected _onDrop(view: EditorView, event: DragEvent, slice: Slice, moved: boolean): void | true;
+}
+
+declare namespace ProseMirrorContentLinkPlugin {
+  interface ProseMirrorContentLinkOptions {
+    /** The parent document housing this editor. */
+    document?: foundry.abstract.Document.Any | undefined;
+    /** @defaultValue `false` */
+    relativeLinks?: boolean | undefined;
+  }
+}
+
+export default ProseMirrorContentLinkPlugin;

package/src/foundry/common/prosemirror/dirty-plugin.d.mts

@@ -0,0 +1,13 @@
+import type { Schema } from "prosemirror-model";
+import type { Plugin } from "prosemirror-state";
+import type ProseMirrorPlugin from "./plugin.d.mts";
+import type { EmptyObject } from "../../../types/utils.d.mts";
+
+export default ProseMirrorDirtyPlugin;
+
+/**
+ * A simple plugin that records the dirty state of the editor.
+ */
+declare class ProseMirrorDirtyPlugin extends ProseMirrorPlugin {
+  static override build(schema: Schema, options?: EmptyObject): Plugin;
+}

package/src/foundry/common/prosemirror/dom-parser.d.mts

@@ -0,0 +1,9 @@
+import { DOMParser as BaseDOMParser, Node, ParseOptions, Schema } from "prosemirror-model";
+
+export default DOMParser;
+
+declare class DOMParser extends BaseDOMParser {
+  override parse(dom: InstanceType<typeof window.Node>, options?: ParseOptions | undefined): Node;
+
+  static override fromSchema(schema: Schema): BaseDOMParser;
+}

package/src/foundry/common/prosemirror/dropdown.d.mts

@@ -0,0 +1,65 @@
+import type { ProseMirrorDropDown as ProseMirrorDropDownMenu } from "./menu.d.mts";
+
+interface Options {
+  /** The menu CSS class name. Required if providing an action. */
+  cssClass?: string;
+  /** Use an icon for the dropdown rather than a text label. */
+  icon?: string;
+  /** A callback to fire when a menu item is clicked. */
+  onAction?: (event: MouseEvent) => void;
+}
+
+export default ProseMirrorDropDown;
+declare class ProseMirrorDropDown {
+  /**
+   * A class responsible for rendering a menu drop-down.
+   * @param title - The default title.
+   * @param items - The configured menu items.
+   */
+  constructor(title: string, items: ProseMirrorDropDownMenu.Entry[], options?: Options);
+
+  // placeholder private attribute to limit what can count as a subtype at compile time
+  #proseMirrorDropDown: true;
+
+  /**
+   * The default title for this drop-down.
+   */
+  readonly title: string;
+
+  /**
+   * The items configured for this drop-down.
+   */
+  readonly items: ProseMirrorDropDownMenu.Entry[];
+
+  /**
+   * Attach event listeners.
+   * @param html - The root menu element.
+   */
+  activateListeners(html: HTMLMenuElement): void;
+
+  /**
+   * Construct the drop-down menu's HTML.
+   * @returns HTML contents as a string.
+   */
+  render(): string;
+
+  /**
+   * Recurse through the menu structure and apply a function to each item in it.
+   * @param fn - The function to call on each item. Return false to prevent iterating over any further items.
+   */
+  forEachItem(fn: (entry: ProseMirrorDropDownMenu.Entry) => boolean): void;
+
+  /**
+   * Render a list of drop-down menu items.
+   * @param entries - The menu items.
+   * @returns HTML contents as a string.
+   */
+  protected static _renderMenu(entries: ProseMirrorDropDownMenu.Entry[]): string;
+
+  /**
+   * Render an individual drop-down menu item.
+   * @param item - The menu item.
+   * @returns HTML contents as a string.
+   */
+  protected static _renderMenuItem(item: ProseMirrorDropDownMenu.Entry): string;
+}

package/src/foundry/common/prosemirror/extensions.d.mts

@@ -0,0 +1,12 @@
+import type { NodeType } from "prosemirror-model";
+
+declare module "prosemirror-model" {
+  interface ResolvedPos {
+    /**
+     * Determine whether a given position has an ancestor node of the given type.
+     * @param other - The other node type.
+     * @param attrs - An object of attributes that must also match, if provided.
+     */
+    hasAncestor(other: NodeType, attrs?: ReturnType<ResolvedPos["node"]>["attrs"]): boolean;
+  }
+}

package/src/foundry/common/prosemirror/highlight-matches-plugin.d.mts

@@ -0,0 +1,82 @@
+import { Schema } from "prosemirror-model";
+import type ProseMirrorPlugin from "./plugin.d.mts";
+import type { ProseMirrorMenu } from "./menu.d.mts";
+import { EditorState, Plugin } from "prosemirror-state";
+import { EditorView } from "prosemirror-view";
+import type { EmptyObject, InexactPartial } from "../../../types/utils.d.mts";
+
+declare namespace ProseMirrorHighlightMatchesPlugin {
+  /**
+   * A class responsible for handling the display of automated link recommendations when a user highlights text in a
+   * ProseMirror editor.
+   */
+  class PossibleMatchesTooltip {
+    /**
+     * @param view - The editor view
+     */
+    constructor(view: EditorView);
+
+    /**
+     * A reference to any existing tooltip that has been generated as part of a highlight match.
+     */
+    tooltip: HTMLElement;
+
+    update(view: EditorView, lastState: EditorState): Promise<void>;
+
+    /**
+     * Create a locked tooltip at the given position
+     * @param position - A position object with coordinates for where the tooltip should be placed
+     * @param text     - Explicit tooltip text or HTML to display.
+     * @param options  - Additional options which can override tooltip behavior.
+     */
+    _createTooltip(
+      position: InexactPartial<{
+        /** Explicit top position for the tooltip */
+        top?: string;
+        /** Explicit right position for the tooltip */
+        right?: string;
+        /** Explicit bottom position for the tooltip */
+        bottom?: string;
+        /** Explicit left position for the tooltip */
+        left?: string;
+      }>,
+      text: string,
+      options?: {
+        /** An optional, space-separated list of CSS classes to apply to the activated tooltip. */
+        cssClass: string;
+      },
+    ): void;
+
+    /**
+     * Update the tooltip with new HTML
+     * @param html - The HTML to be included in the tooltip
+     */
+    _updateTooltip(html: string): void;
+
+    /**
+     * Dismiss all locked tooltips and set this tooltip to undefined.
+     */
+    _deactivateTooltip(): void;
+
+    /**
+     * Find all Documents in the world/compendia with names that match the selection insensitive to case.
+     * @param text - A string which will be matched against document names
+     */
+    _findMatches(text: string): string;
+  }
+}
+
+/**
+ * A ProseMirrorPlugin wrapper around the {@link PossibleMatchesTooltip} class.
+ */
+declare class ProseMirrorHighlightMatchesPlugin extends ProseMirrorPlugin {
+  /**
+   * @param schema  - The ProseMirror schema.
+   * @param options - Additional options to configure the plugin's behaviour.
+   */
+  constructor(schema: Schema, options: ProseMirrorMenu.ProseMirrorMenuOptions);
+
+  static override build(schema: Schema, options?: EmptyObject): Plugin;
+}
+
+export default ProseMirrorHighlightMatchesPlugin;

package/src/foundry/common/prosemirror/image-plugin.d.mts

@@ -0,0 +1,82 @@
+import type { Schema, Slice } from "prosemirror-model";
+import type { Plugin } from "prosemirror-state";
+import type { EditorView } from "prosemirror-view";
+import type ProseMirrorPlugin from "./plugin.d.mts";
+import type { EmptyObject } from "../../../types/utils.d.mts";
+
+export default ProseMirrorImagePlugin;
+/**
+ * A class responsible for handle drag-and-drop and pasting of image content. Ensuring no base64 data is injected
+ * directly into the journal content and it is instead uploaded to the user's data directory.
+ */
+declare class ProseMirrorImagePlugin<RelatedDocument extends foundry.abstract.Document.Any> extends ProseMirrorPlugin {
+  /**
+   * @param schema   - The ProseMirror schema.
+   * @param options  - Additional options to configure the plugin's behaviour.
+   */
+  constructor(
+    schema: Schema,
+    options?: {
+      /** A related Document to store extract base64 images for. */
+      document?: RelatedDocument;
+    },
+  );
+
+  /**
+   * The related Document to store extracted base64 images for.
+   */
+  readonly document: RelatedDocument;
+
+  static override build(schema: Schema, options?: EmptyObject): Plugin;
+
+  /**
+   * Handle a drop onto the editor.
+   * @param view  - The ProseMirror editor view.
+   * @param event - The drop event.
+   * @param slice - A slice of editor content.
+   * @param moved - Whether the slice has been moved from a different part of the editor.
+   */
+  protected _onDrop(view: EditorView, event: DragEvent, slice: Slice, moved: boolean): void | true;
+
+  /**
+   * Handle a paste into the editor.
+   * @param view  - The ProseMirror editor view.
+   * @param event - The paste event.
+   */
+  protected _onPaste(view: EditorView, event: ClipboardEvent): void | true;
+
+  /**
+   * Upload any image files encountered in the drop.
+   * @param view  - The ProseMirror editor view.
+   * @param files - The files to upload.
+   * @param pos   - The position in the document to insert at. If not provided, the current
+   *                selection will be replaced instead.
+   */
+  protected _uploadImages(view: EditorView, files: FileList, pos?: number): Promise<void>;
+
+  /**
+   * Capture any base64-encoded images embedded in the rich text paste and upload them.
+   * @param view   - The ProseMirror editor view.
+   * @param html   - The HTML data as a string.
+   * @param images - An array of extracted base64 image data.
+   */
+  protected _replaceBase64Images(
+    view: EditorView,
+    html: string,
+    images: [full: string, mime: string, data: string][],
+  ): Promise<void>;
+
+  /**
+   * Detect base64 image data embedded in an HTML string and extract it.
+   * @param html - The HTML data as a string.
+   */
+  protected _extractBase64Images(html: string): [full: string, mime: string, data: string][];
+
+  /**
+   * Convert a base64 string into a File object.
+   * @param data     - Base64 encoded data.
+   * @param filename - The filename.
+   * @param mimetype - The file's mimetype.
+   */
+  static base64ToFile(data: string, filename: string, mimetype: string): File;
+}

package/src/foundry/common/prosemirror/index.d.mts

@@ -0,0 +1,22 @@
+import "./click-handler.d.mts";
+import "./content-link-plugin.d.mts";
+import "./dirty-plugin.d.mts";
+import "./dom-parser.d.mts";
+import "./dropdown.d.mts";
+import "./extensions.d.mts";
+import "./highlight-matches-plugin.d.mts";
+import "./image-plugin.d.mts";
+import "./input-rules.d.mts";
+import "./keymaps.d.mts";
+import "./menu.d.mts";
+import "./paste-transformer.d.mts";
+import "./plugin.d.mts";
+import type * as ProseMirrorObject from "./_module.d.mts";
+import "./schema/index.d.mts";
+import "./schema.d.mts";
+import "./string-serializer.d.mts";
+import "./util.d.mts";
+
+declare global {
+  let ProseMirror: typeof ProseMirrorObject;
+}

package/src/foundry/common/prosemirror/input-rules.d.mts

@@ -0,0 +1,34 @@
+import type { InputRule } from "prosemirror-inputrules";
+import type { Schema } from "prosemirror-model";
+import type { Plugin } from "prosemirror-state";
+import type ProseMirrorPlugin from "./plugin.d.mts";
+
+export declare namespace ProseMirrorInputRules {
+  export interface ProseMirrorInputRulesOptions {
+    /**
+     * The minimum heading level to start from when generating heading input rules.
+     * The resulting heading level for a heading rule is equal to the number of
+     * leading hashes minus this number.
+     * @defaultValue `0`
+     */
+    minHeadingLevel?: number;
+  }
+}
+
+export default ProseMirrorInputRules;
+/**
+ * A class responsible for building the input rules for the ProseMirror editor.
+ */
+declare class ProseMirrorInputRules extends ProseMirrorPlugin {
+  /**
+   * Build the plugin.
+   * @param schema  - The ProseMirror schema to build the plugin against.
+   * @param options - Additional options to pass to the plugin.
+   * */
+  static build(schema: Schema, options?: ProseMirrorInputRules.ProseMirrorInputRulesOptions): Plugin;
+
+  /**
+   * Build input rules for node types present in the schema.
+   */
+  buildRules(): InputRule[];
+}