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

package/src/foundry/client/data/documents/index.d.mts

@@ -0,0 +1,30 @@
+import "./active-effect.d.mts";
+import "./actor-delta.d.mts";
+import "./actor.d.mts";
+import "./adventure.d.mts";
+import "./ambient-light.d.mts";
+import "./ambient-sound.d.mts";
+import "./card.d.mts";
+import "./cards.d.mts";
+import "./chat-message.d.mts";
+import "./combat.d.mts";
+import "./combatant.d.mts";
+import "./drawing.d.mts";
+import "./fog-exploration.d.mts";
+import "./folder.d.mts";
+import "./item.d.mts";
+import "./journal-entry.d.mts";
+import "./journal-entry-page.d.mts";
+import "./macro.d.mts";
+import "./measured-template.d.mts";
+import "./note.d.mts";
+import "./playlist-sound.d.mts";
+import "./playlist.d.mts";
+import "./scene.d.mts";
+import "./setting.d.mts";
+import "./table-result.d.mts";
+import "./table.d.mts";
+import "./tile.d.mts";
+import "./token.d.mts";
+import "./user.d.mts";
+import "./wall.d.mts";

package/src/foundry/client/data/documents/item.d.mts

@@ -0,0 +1,67 @@
+import type Document from "../../../common/abstract/document.d.mts";
+import type { DocumentDatabaseOperations } from "../../../common/abstract/document.d.mts";
+import type BaseItem from "../../../common/documents/item.d.mts";
+
+declare global {
+  namespace Item {
+    type Metadata = Document.MetadataFor<Item>;
+
+    type ConfiguredClass = Document.ConfiguredClassForName<"Item">;
+    type ConfiguredInstance = Document.ConfiguredInstanceForName<"Item">;
+
+    interface DatabaseOperations extends DocumentDatabaseOperations<Item> {}
+
+    // Helpful aliases
+    type TypeNames = BaseItem.TypeNames;
+    type ConstructorData = BaseItem.ConstructorData;
+    type UpdateData = BaseItem.UpdateData;
+    type Schema = BaseItem.Schema;
+    type Source = BaseItem.Source;
+  }
+
+  /**
+   * The client-side Item document which extends the common BaseItem abstraction.
+   * Each Item document contains ItemData which defines its data schema.
+   *
+   * @see {@link Items}            The world-level collection of Item documents
+   * @see {@link ItemSheet}     The Item configuration application
+   *
+   * @param data    - Initial data provided to construct the Item document
+   * @param context - The document context, see {@link foundry.abstract.Document}
+   */
+  class Item extends ClientDocumentMixin(foundry.documents.BaseItem) {
+    static override metadata: Item.Metadata;
+
+    /**
+     * A convenience alias of Item#parent which is more semantically intuitive
+     */
+    get actor(): this["parent"];
+
+    /**
+     * Provide a thumbnail image path used to represent this document.
+     */
+    get thumbnail(): this["img"];
+
+    /**
+     * A convenience alias of Item#isEmbedded which is preserves legacy support
+     */
+    get isOwned(): this["isEmbedded"];
+
+    /**
+     * Return an array of the Active Effect instances which originated from this Item.
+     * The returned instances are the ActiveEffect instances which exist on the Item itself.
+     */
+    get transferredEffects(): ReturnType<this["effects"]["filter"]>;
+
+    /**
+     * Prepare a data object which defines the data schema used by dice roll commands against this Item
+     * @remarks defaults to this.system, but provided as object for flexible overrides
+     */
+    getRollData(): Record<string, unknown>;
+
+    /**
+     * @privateRemarks _preCreate, _onCreateDocuments and _onDeleteDocuments are all overridden but with no signature changes.
+     * For type simplicity they are left off. These methods historically have been the source of a large amount of computation from tsc.
+     */
+  }
+}

package/src/foundry/client/data/documents/journal-entry-page.d.mts

@@ -0,0 +1,231 @@
+import type { InexactPartial } from "../../../../types/utils.d.mts";
+import type Document from "../../../common/abstract/document.d.mts";
+import type { DocumentDatabaseOperations } from "../../../common/abstract/document.d.mts";
+import type BaseJournalEntryPage from "../../../common/documents/journal-entry-page.d.mts";
+
+declare global {
+  namespace JournalEntryPage {
+    type Metadata = Document.MetadataFor<JournalEntryPage>;
+
+    type ConfiguredClass = Document.ConfiguredClassForName<"JournalEntryPage">;
+    type ConfiguredInstance = Document.ConfiguredInstanceForName<"JournalEntryPage">;
+
+    interface DatabaseOperations extends DocumentDatabaseOperations<JournalEntryPage> {}
+
+    // Helpful aliases
+    type TypeNames = BaseJournalEntryPage.TypeNames;
+    type ConstructorData = BaseJournalEntryPage.ConstructorData;
+    type UpdateData = BaseJournalEntryPage.UpdateData;
+    type Schema = BaseJournalEntryPage.Schema;
+    type Source = BaseJournalEntryPage.Source;
+
+    interface JournalEntryPageHeading {
+      /** The heading level, 1-6. */
+      level: number;
+
+      /** The raw heading text with any internal tags omitted. */
+      text: string;
+
+      /** The generated slug for this heading. */
+      slug: string;
+
+      /** The currently rendered element for this heading, if it exists. */
+      element?: HTMLHeadingElement;
+
+      /** Any child headings of this one. */
+      children: string[];
+
+      /** The linear ordering of the heading in the table of contents. */
+      order: number;
+    }
+  }
+
+  /**
+   * The client-side JournalEntryPage document which extends the common BaseJournalEntryPage document model.
+   *
+   * @see {@link JournalEntry}  The JournalEntry document type which contains JournalEntryPage embedded documents.
+   */
+  class JournalEntryPage extends ClientDocumentMixin(foundry.documents.BaseJournalEntryPage) {
+    static override metadata: JournalEntryPage.Metadata;
+
+    /**
+     * The cached table of contents for this JournalEntryPage.
+     */
+    protected _toc: Record<string, JournalEntryPage.JournalEntryPageHeading>;
+
+    /**
+     * The table of contents for this JournalEntryPage.
+     */
+    get toc(): Record<string, JournalEntryPage.JournalEntryPageHeading>;
+
+    override get permission(): foundry.CONST.DOCUMENT_OWNERSHIP_LEVELS;
+
+    /**
+     * Return a reference to the Note instance for this Journal Entry Page in the current Scene, if any.
+     * If multiple notes are placed for this Journal Entry, only the first will be returned.
+     */
+    get sceneNote(): Note | null;
+
+    /**
+     * Convert a heading into slug suitable for use as an identifier.
+     * @param heading - The heading element or some text content.
+     */
+    static slugifyHeading(heading: HTMLHeadingElement | string): string;
+
+    /**
+     * Build a table of contents for the given HTML content.
+     * @param html    - The HTML content to generate a ToC outline for.
+     * @param options - Additional options to configure ToC generation.
+     */
+    static buildTOC(
+      html: HTMLElement[],
+      options: InexactPartial<{
+        /**
+         * Include references to the heading DOM elements in the returned ToC.
+         * @defaultValue `true`
+         */
+        includeElement: boolean;
+      }>,
+    ): Record<string, JournalEntryPage.JournalEntryPageHeading>;
+
+    /**
+     * Flatten the tree structure into a single object with each node's slug as the key.
+     * @param nodes - The root ToC nodes.
+     */
+    protected static _flattenTOC(
+      nodes: JournalEntryPage.JournalEntryPageHeading[],
+    ): Record<string, JournalEntryPage.JournalEntryPageHeading>;
+
+    /**
+     * Construct a table of contents node from a heading element.
+     * @param heading - The heading element.
+     * @param options - Additional options to configure the returned node.
+     */
+    protected static _makeHeadingNode(
+      heading: HTMLHeadingElement,
+      options: InexactPartial<{
+        /**
+         * Whether to include the DOM element in the returned ToC node.
+         * @defaultValue `true`
+         */
+        includeElement: boolean;
+      }>,
+    ): JournalEntryPage.JournalEntryPageHeading;
+
+    protected override _createDocumentLink(
+      eventData: unknown,
+      options?: InexactPartial<{
+        /**
+         * A document to generate a link relative to.
+         */
+        relativeTo: ClientDocument;
+        /**
+         * A custom label to use instead of the document's name.
+         */
+        label: string;
+      }>,
+    ): string;
+
+    override _onClickDocumentLink(event: MouseEvent): this;
+
+    /**
+     * @privateRemarks _onUpdate is overridden but with no signature changes.
+     * For type simplicity it is left off. These methods historically have been the source of a large amount of computation from tsc.
+     */
+
+    protected override _buildEmbedHTML(
+      config: TextEditor.DocumentHTMLEmbedConfig,
+    ): Promise<HTMLCollection | HTMLElement | null>;
+
+    protected override _createFigureEmbed(
+      content: HTMLElement | HTMLCollection,
+      config: TextEditor.DocumentHTMLEmbedConfig,
+      options?: TextEditor.EnrichmentOptions,
+    ): Promise<HTMLElement | null>;
+
+    /**
+     * Embed text page content.
+     * @param config        - Configuration for embedding behavior. This can include
+     *                        enrichment options to override those passed as part of
+     *                        the root enrichment process.
+     * @param options       - The original enrichment options to propagate to the embedded text page's
+     *                        enrichment.
+     * @returns
+     *
+     * @example Embed the content of the Journal Entry Page as a figure.
+     * ```
+     * @Embed[.yDbDF1ThSfeinh3Y classes="small right"]{Special caption}
+     * ```
+     * becomes
+     * ```html
+     * <figure class="content-embed small right" data-content-embed
+     *         data-uuid="JournalEntry.ekAeXsvXvNL8rKFZ.JournalEntryPage.yDbDF1ThSfeinh3Y">
+     *   <p>The contents of the page</p>
+     *   <figcaption>
+     *     <strong class="embed-caption">Special caption</strong>
+     *     <cite>
+     *       <a class="content-link" draggable="true" data-link
+     *          data-uuid="JournalEntry.ekAeXsvXvNL8rKFZ.JournalEntryPage.yDbDF1ThSfeinh3Y"
+     *          data-id="yDbDF1ThSfeinh3Y" data-type="JournalEntryPage" data-tooltip="Text Page">
+     *         <i class="fas fa-file-lines"></i> Text Page
+     *       </a>
+     *     </cite>
+     *   <figcaption>
+     * </figure>
+     * ```
+     *
+     * @example Embed the content of the Journal Entry Page into the main content flow.
+     * ```
+     * @Embed[.yDbDF1ThSfeinh3Y inline]
+     * ```
+     * becomes
+     * ```html
+     * <section class="content-embed" data-content-embed
+     *          data-uuid="JournalEntry.ekAeXsvXvNL8rKFZ.JournalEntryPage.yDbDF1ThSfeinh3Y">
+     *   <p>The contents of the page</p>
+     * </section>
+     * ```
+     */
+    protected _embedTextPage(
+      config: TextEditor.DocumentHTMLEmbedConfig & TextEditor.EnrichmentOptions,
+      options?: TextEditor.EnrichmentOptions,
+    ): Promise<HTMLCollection>;
+
+    /**
+     * Embed image page content.
+     * @param config            - Configuration for embedding behavior.
+     * @param options           - The original enrichment options for cases where the Document embed content
+     *                            also contains text that must be enriched.
+     * @returns
+     *
+     * @example Create an embedded image from a sibling journal entry page.
+     * ```
+     * @Embed[.QnH8yGIHy4pmFBHR classes="small right"]{Special caption}
+     * ```
+     * becomes
+     * ```html
+     * <figure class="content-embed small right" data-content-embed
+     *         data-uuid="JournalEntry.xFNPjbSEDbWjILNj.JournalEntryPage.QnH8yGIHy4pmFBHR">
+     *   <img src="path/to/image.webp" alt="Special caption">
+     *   <figcaption>
+     *     <strong class="embed-caption">Special caption</strong>
+     *     <cite>
+     *       <a class="content-link" draggable="true" data-link
+     *          data-uuid="JournalEntry.xFNPjbSEDbWjILNj.JournalEntryPage.QnH8yGIHy4pmFBHR"
+     *          data-id="QnH8yGIHy4pmFBHR" data-type="JournalEntryPage" data-tooltip="Image Page">
+     *         <i class="fas fa-file-image"></i> Image Page
+     *       </a>
+     *     </cite>
+     *   </figcaption>
+     * </figure>
+     * ```
+     */
+    protected _embedImagePage(
+      config: TextEditor.DocumentHTMLEmbedConfig & {
+        /** Alt text for the image, otherwise the caption will be used. **/
+        alt?: string | unknown;
+      },
+      options?: InexactPartial<TextEditor.EnrichmentOptions>,
+    ): Promise<HTMLElement | HTMLCollection | null>;
+  }
+}

package/src/foundry/client/data/documents/journal-entry.d.mts

@@ -0,0 +1,81 @@
+import type { BaseJournalEntry, BaseUser } from "../../../common/documents/_module.d.mts";
+import type { DocumentDatabaseOperations } from "../../../common/abstract/document.d.mts";
+import type Document from "../../../common/abstract/document.d.mts";
+
+declare global {
+  namespace JournalEntry {
+    type Metadata = Document.MetadataFor<JournalEntry>;
+
+    type ConfiguredClass = Document.ConfiguredClassForName<"JournalEntry">;
+    type ConfiguredInstance = Document.ConfiguredInstanceForName<"JournalEntry">;
+
+    interface DatabaseOperations extends DocumentDatabaseOperations<JournalEntry> {}
+
+    // Helpful aliases
+    type ConstructorData = BaseJournalEntry.ConstructorData;
+    type UpdateData = BaseJournalEntry.UpdateData;
+    type Schema = BaseJournalEntry.Schema;
+    type Source = BaseJournalEntry.Source;
+  }
+
+  /**
+   * The client-side JournalEntry document which extends the common BaseJournalEntry model.
+   *
+   * @see {@link Journal}                  The world-level collection of JournalEntry documents
+   * @see {@link JournalSheet}          The JournalEntry configuration application
+   */
+  class JournalEntry extends ClientDocumentMixin(foundry.documents.BaseJournalEntry) {
+    static override metadata: JournalEntry.Metadata;
+
+    /**
+     * A boolean indicator for whether or not the JournalEntry is visible to the current user in the directory sidebar
+     */
+    get visible(): boolean;
+
+    override getUserLevel(user: BaseUser): foundry.CONST.DOCUMENT_OWNERSHIP_LEVELS | null;
+
+    /**
+     * Return a reference to the Note instance for this Journal Entry in the current Scene, if any.
+     * If multiple notes are placed for this Journal Entry, only the first will be returned.
+     */
+    get sceneNote(): Note | null;
+
+    /**
+     * Show the JournalEntry to connected players.
+     * By default the entry will only be shown to players who have permission to observe it.
+     * If the parameter force is passed, the entry will be shown to all players regardless of normal permission.
+     *
+     * @param force - Display the entry to all players regardless of normal permissions
+     *                (default: `false`)
+     * @returns A Promise that resolves back to the shown entry once the request is processed
+     */
+    show(force?: boolean): Promise<this>;
+
+    /**
+     * If the JournalEntry has a pinned note on the canvas, this method will animate to that note
+     * The note will also be highlighted as if hovered upon by the mouse
+     * @param options - Options which modify the pan operation
+     * @returns A Promise which resolves once the pan animation has concluded
+     */
+    panToNote(options?: PanToNoteOptions): Promise<void>;
+
+    /**
+     * @privateRemarks _onUpdate and _onDelete are all overridden but with no signature changes.
+     * For type simplicity they are left off. These methods historically have been the source of a large amount of computation from tsc.
+     */
+  }
+}
+
+interface PanToNoteOptions {
+  /**
+   * The speed of the pan animation in milliseconds
+   * @defaultValue `250`
+   */
+  duration?: number;
+
+  /**
+   * The resulting zoom level
+   * @defaultValue `1.5`
+   */
+  scale?: number;
+}

package/src/foundry/client/data/documents/macro.d.mts

@@ -0,0 +1,87 @@
+import type { InexactPartial } from "../../../../types/utils.d.mts";
+import type Document from "../../../common/abstract/document.d.mts";
+import type { DocumentDatabaseOperations } from "../../../common/abstract/document.d.mts";
+import type BaseMacro from "../../../common/documents/macro.d.mts";
+
+type RegionEvent = unknown;
+
+declare global {
+  namespace Macro {
+    type Metadata = Document.MetadataFor<Macro>;
+
+    type ConfiguredClass = Document.ConfiguredClassForName<"Macro">;
+    type ConfiguredInstance = Document.ConfiguredInstanceForName<"Macro">;
+
+    interface DatabaseOperations extends DocumentDatabaseOperations<Macro> {}
+
+    // Helpful aliases
+    type TypeNames = BaseMacro.TypeNames;
+    type ConstructorData = BaseMacro.ConstructorData;
+    type UpdateData = BaseMacro.UpdateData;
+    type Schema = BaseMacro.Schema;
+    type Source = BaseMacro.Source;
+
+    interface Scope {
+      /** An Actor who is the protagonist of the executed action. */
+      actor: Actor;
+
+      /**  A Token which is the protagonist of the executed action. */
+      token: Token;
+
+      /** An optional event passed to the executed macro. */
+      event: Event | RegionEvent;
+
+      /**
+       * @remarks Additional arguments passed as part of the scope
+       */
+      [arg: string]: unknown;
+    }
+  }
+
+  /**
+   * The client-side Macro document which extends the common BaseMacro model.
+   *
+   * @see {@link Macros}            The world-level collection of Macro documents
+   * @see {@link MacroConfig}       The Macro configuration application
+   *
+   * @param data - Initial data provided to construct the Macro document
+   */
+  class Macro extends ClientDocumentMixin(foundry.documents.BaseMacro) {
+    static override metadata: Macro.Metadata;
+
+    /**
+     * Is the current User the author of this macro?
+     */
+    get isAuthor(): boolean;
+
+    /**
+     * Test whether the current user is capable of executing a Macro script
+     */
+    get canExecute(): boolean;
+
+    /**
+     * Provide a thumbnail image path used to represent this document.
+     */
+    get thumbnail(): string | null;
+
+    /**
+     * Test whether the given User is capable of executing this Macro.
+     * @param user - The User to test.
+     * @returns Can this User execute this Macro?
+     */
+    canUserExecute(user: User): boolean;
+
+    /**
+     * Execute the Macro command.
+     * @param scope - Macro execution scope which is passed to script macros
+     * @returns A promising containing a created {@link ChatMessage} (or `undefined`) if a chat
+     *          macro or the return value if a script macro. A void return is possible if the user
+     *          is not permitted to execute macros or a script macro execution fails.
+     */
+    execute(scope?: InexactPartial<Macro.Scope>): Promise<ChatMessage | void> | Promise<unknown> | void;
+
+    #executeScript();
+
+    _onClickDocumentLink(event: MouseEvent): ReturnType<this["execute"]>;
+  }
+}

package/src/foundry/client/data/documents/measured-template.d.mts

@@ -0,0 +1,40 @@
+import type Document from "../../../common/abstract/document.d.mts";
+import type { DocumentDatabaseOperations } from "../../../common/abstract/document.d.mts";
+import type BaseMeasuredTemplate from "../../../common/documents/measured-template.d.mts";
+
+declare global {
+  namespace MeasuredTemplateDocument {
+    type Metadata = Document.MetadataFor<MeasuredTemplateDocument>;
+
+    type ConfiguredClass = Document.ConfiguredClassForName<"MeasuredTemplate">;
+    type ConfiguredInstance = Document.ConfiguredInstanceForName<"MeasuredTemplate">;
+
+    interface DatabaseOperations extends DocumentDatabaseOperations<MeasuredTemplateDocument> {}
+
+    // Helpful aliases
+    type ConstructorData = BaseMeasuredTemplate.ConstructorData;
+    type UpdateData = BaseMeasuredTemplate.UpdateData;
+    type Schema = BaseMeasuredTemplate.Schema;
+    type Source = BaseMeasuredTemplate.Source;
+  }
+
+  /**
+   * The client-side MeasuredTemplate document which extends the common BaseMeasuredTemplate document model.
+   *
+   * @see {@link Scene}                     The Scene document type which contains MeasuredTemplate documents
+   * @see {@link MeasuredTemplateConfig}    The MeasuredTemplate configuration application
+   */
+  class MeasuredTemplateDocument extends CanvasDocumentMixin(foundry.documents.BaseMeasuredTemplate) {
+    static override metadata: MeasuredTemplateDocument.Metadata;
+
+    /**
+     * Rotation is an alias for direction
+     */
+    get rotation(): this["direction"];
+
+    /**
+     * Is the current User the author of this template?
+     */
+    get isAuthor(): boolean;
+  }
+}

package/src/foundry/client/data/documents/note.d.mts

@@ -0,0 +1,46 @@
+import type Document from "../../../common/abstract/document.d.mts";
+import type { DocumentDatabaseOperations } from "../../../common/abstract/document.d.mts";
+import type BaseNote from "../../../common/documents/note.d.mts";
+
+declare global {
+  namespace NoteDocument {
+    type Metadata = Document.MetadataFor<NoteDocument>;
+
+    type ConfiguredClass = Document.ConfiguredClassForName<"Note">;
+    type ConfiguredInstance = Document.ConfiguredInstanceForName<"Note">;
+
+    interface DatabaseOperations extends DocumentDatabaseOperations<NoteDocument> {}
+
+    // Helpful aliases
+    type ConstructorData = BaseNote.ConstructorData;
+    type UpdateData = BaseNote.UpdateData;
+    type Schema = BaseNote.Schema;
+    type Source = BaseNote.Source;
+  }
+
+  /**
+   * The client-side Note document which extends the common BaseNote model.
+   * Each Note document contains NoteData which defines its data schema.
+   *
+   * @see {@link Scene}               The Scene document type which contains Note embedded documents
+   * @see {@link NoteConfig}          The Note configuration application
+   */
+  class NoteDocument extends CanvasDocumentMixin(foundry.documents.BaseNote) {
+    static override metadata: NoteDocument.Metadata;
+
+    /**
+     * The associated JournalEntry which is referenced by this Note
+     */
+    get entry(): JournalEntry.ConfiguredInstance | undefined;
+
+    /**
+     * The specific JournalEntryPage within the associated JournalEntry referenced by this Note.
+     */
+    get page(): JournalEntryPage.ConfiguredInstance | undefined;
+
+    /**
+     * The text label used to annotate this Note
+     */
+    get label(): string;
+  }
+}