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

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

@@ -0,0 +1,55 @@
+import type Document from "../../../common/abstract/document.d.mts";
+import type { DocumentDatabaseOperations } from "../../../common/abstract/document.d.mts";
+
+declare global {
+  namespace Item {
+    type ConfiguredClass = Document.ConfiguredClassForName<"Item">;
+    type ConfiguredInstance = Document.ConfiguredInstanceForName<"Item">;
+
+    interface DatabaseOperations extends DocumentDatabaseOperations<Item> {}
+  }
+
+  /**
+   * 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) {
+    /**
+     * 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,219 @@
+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";
+
+declare global {
+  namespace JournalEntryPage {
+    type ConfiguredClass = Document.ConfiguredClassForName<"JournalEntryPage">;
+    type ConfiguredInstance = Document.ConfiguredInstanceForName<"JournalEntryPage">;
+
+    interface DatabaseOperations extends DocumentDatabaseOperations<JournalEntryPage> {}
+
+    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) {
+    /**
+     * 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,71 @@
+import type { 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 ConfiguredClass = Document.ConfiguredClassForName<"JournalEntry">;
+    type ConfiguredInstance = Document.ConfiguredInstanceForName<"JournalEntry">;
+
+    interface DatabaseOperations extends DocumentDatabaseOperations<JournalEntry> {}
+  }
+
+  /**
+   * 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) {
+    /**
+     * 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,73 @@
+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";
+
+declare global {
+  namespace Macro {
+    type ConfiguredClass = Document.ConfiguredClassForName<"Macro">;
+    type ConfiguredInstance = Document.ConfiguredInstanceForName<"Macro">;
+
+    interface DatabaseOperations extends DocumentDatabaseOperations<Macro> {}
+
+    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) {
+    /**
+     * 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,29 @@
+import type Document from "../../../common/abstract/document.d.mts";
+import type { DocumentDatabaseOperations } from "../../../common/abstract/document.d.mts";
+
+declare global {
+  namespace MeasuredTemplateDocument {
+    type ConfiguredClass = Document.ConfiguredClassForName<"MeasuredTemplate">;
+    type ConfiguredInstance = Document.ConfiguredInstanceForName<"MeasuredTemplate">;
+
+    interface DatabaseOperations extends DocumentDatabaseOperations<MeasuredTemplateDocument> {}
+  }
+
+  /**
+   * 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) {
+    /**
+     * 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,35 @@
+import type Document from "../../../common/abstract/document.d.mts";
+import type { DocumentDatabaseOperations } from "../../../common/abstract/document.d.mts";
+
+declare global {
+  namespace NoteDocument {
+    type ConfiguredClass = Document.ConfiguredClassForName<"Note">;
+    type ConfiguredInstance = Document.ConfiguredInstanceForName<"Note">;
+
+    interface DatabaseOperations extends DocumentDatabaseOperations<NoteDocument> {}
+  }
+
+  /**
+   * 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) {
+    /**
+     * 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;
+  }
+}

package/src/foundry/client/data/documents/playlist-sound.d.mts

@@ -0,0 +1,114 @@
+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";
+
+declare global {
+  namespace PlaylistSound {
+    type ConfiguredClass = Document.ConfiguredClassForName<"PlaylistSound">;
+    type ConfiguredInstance = Document.ConfiguredInstanceForName<"PlaylistSound">;
+
+    interface DatabaseOperations extends DocumentDatabaseOperations<PlaylistSound> {}
+  }
+
+  /**
+   * The client-side PlaylistSound document which extends the common BasePlaylistSound model.
+   * Each PlaylistSound belongs to the sounds collection of a Playlist document.
+   *
+   * @see {@link Playlist}                       The Playlist document which contains PlaylistSound embedded documents
+   * @see {@link PlaylistSoundConfig}   The PlaylistSound configuration application
+   * @see {@link Sound}                          The Sound API which manages web audio playback
+   *
+   */
+  class PlaylistSound extends ClientDocumentMixin(foundry.documents.BasePlaylistSound) {
+    constructor(
+      data: ConstructorParameters<typeof foundry.documents.BasePlaylistSound>[0],
+      context?: ConstructorParameters<typeof foundry.documents.BasePlaylistSound>[1],
+    );
+
+    /**
+     * The debounce tolerance for processing rapid volume changes into database updates in milliseconds
+     * @defaultValue `100`
+     */
+    static VOLUME_DEBOUNCE_MS: number;
+
+    /**
+     * The Sound which manages playback for this playlist sound
+     */
+    sound: Sound | null;
+
+    /**
+     * A debounced function, accepting a single volume parameter to adjust the volume of this sound
+     * @param volume - The desired volume level
+     */
+    debounceVolume: (volume: number) => void;
+
+    /**
+     * Create a Sound used to play this PlaylistSound document
+     * @internal
+     */
+    protected _createSound(): Sound | null;
+
+    /**
+     * Determine the fade duration for this PlaylistSound based on its own configuration and that of its parent.
+     */
+    get fadeDuration(): number;
+
+    /**
+     * The audio context within which this sound is played.
+     * This will be undefined if the audio context is not yet active.
+     */
+    get context(): AudioContext | undefined;
+
+    /**
+     * Synchronize playback for this particular PlaylistSound instance
+     */
+    sync(): void | Promise<void> | Promise<Sound>;
+
+    /**
+     * Load the audio for this sound for the current client.
+     */
+    load(): Promise<void>;
+
+    toAnchor(
+      options?: InexactPartial<{
+        attrs: Record<string, string>;
+        dataset: Record<string, string>;
+        classes: string[];
+        name: string;
+        icon: string;
+      }>,
+    ): HTMLAnchorElement;
+
+    _onClickDocumentLink(event: MouseEvent): ReturnType<Playlist.ConfiguredInstance["stopSound" | "playSound"]>;
+
+    /**
+     * @privateRemarks _onCreate, _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.
+     */
+
+    /**
+     * Special handling that occurs when playback of a PlaylistSound is started.
+     * @internal
+     */
+    protected _onStart(): Promise<void>;
+
+    /**
+     * Special handling that occurs when a PlaylistSound reaches the natural conclusion of its playback.
+     * @internal
+     */
+    protected _onEnd(): Promise<void | Playlist.ConfiguredInstance | undefined>;
+
+    /**
+     * Special handling that occurs when a PlaylistSound is manually stopped before its natural conclusion.
+     * @internal
+     */
+    protected _onStop(): Promise<void>;
+
+    /**
+     * The effective volume at which this playlist sound is played, incorporating the global playlist volume setting.
+     * @deprecated PlaylistSound#effectiveVolume is deprecated in favor of using PlaylistSound#volume directly
+     *
+     */
+    get effectiveVolume(): number;
+  }
+}