@league-of-foundry-developers/foundry-vtt-types 13.346.0-beta.20250718083608 → 13.346.0-beta.20250720082736

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@league-of-foundry-developers/foundry-vtt-types",
-  "version": "13.346.0-beta.20250718083608",
+  "version": "13.346.0-beta.20250720082736",
   "description": "TypeScript type definitions for Foundry VTT",
   "type": "module",
   "types": "./src/index.d.mts",

package/src/foundry/client/applications/ui/game-pause.d.mts

@@ -11,15 +11,28 @@ declare module "#configuration" {
 
 /**
  * The Game Paused banner.
- * @remarks TODO: Stub
  */
 declare class GamePause<
   RenderContext extends GamePause.RenderContext = GamePause.RenderContext,
   Configuration extends GamePause.Configuration = GamePause.Configuration,
   RenderOptions extends GamePause.RenderOptions = GamePause.RenderOptions,
 > extends ApplicationV2<RenderContext, Configuration, RenderOptions> {
-  // Fake override.
   static override DEFAULT_OPTIONS: GamePause.DefaultOptions;
+
+  protected override _prepareContext(
+    options: DeepPartial<RenderOptions> & { isFirstRender: boolean },
+  ): Promise<RenderContext>;
+
+  protected override _renderHTML(
+    _context: RenderContext,
+    _options: DeepPartial<RenderOptions>,
+  ): Promise<GamePause.RenderHTMLReturn>;
+
+  protected override _replaceHTML(
+    result: GamePause.RenderHTMLReturn,
+    content: HTMLElement,
+    _options: DeepPartial<RenderOptions>,
+  ): void;
 }
 
 declare namespace GamePause {
@@ -37,6 +50,8 @@ declare namespace GamePause {
     spin: boolean;
   }
 
+  type RenderHTMLReturn = [HTMLImageElement, HTMLElement];
+
   interface Configuration<GamePause extends GamePause.Any = GamePause.Any>
     extends ApplicationV2.Configuration<GamePause> {}
 

package/src/foundry/client/applications/ui/hotbar.d.mts

@@ -1,6 +1,7 @@
 import type { DeepPartial, Identity } from "#utils";
 import type ApplicationV2 from "../api/application.d.mts";
 import type HandlebarsApplicationMixin from "../api/handlebars-application.d.mts";
+import type Document from "#common/abstract/document.d.mts";
 
 declare module "#configuration" {
   namespace Hooks {
@@ -16,15 +17,102 @@ declare module "#configuration" {
  * Left-clicking a Macro button triggers its effect.
  * Right-clicking the button displays a context menu of Macro options.
  * The number keys 1 through 0 activate numbered hotbar slots.
- * @remarks TODO: Stub
  */
 declare class Hotbar<
   RenderContext extends object = Hotbar.RenderContext,
   Configuration extends Hotbar.Configuration = Hotbar.Configuration,
   RenderOptions extends Hotbar.RenderOptions = Hotbar.RenderOptions,
 > extends HandlebarsApplicationMixin(ApplicationV2)<RenderContext, Configuration, RenderOptions> {
-  // Fake override.
   static override DEFAULT_OPTIONS: Hotbar.DefaultOptions;
+  static override PARTS: Record<string, HandlebarsApplicationMixin.HandlebarsTemplatePart>;
+
+  /**
+   * The current hotbar page number.
+   */
+  get page(): number;
+
+  /**
+   * The currently rendered macro data.
+   */
+  get slots(): Hotbar.SlotData[];
+
+  /**
+   * Whether the hotbar is locked.
+   */
+  get locked(): boolean;
+
+  protected override _prepareContext(
+    options: DeepPartial<RenderOptions> & { isFirstRender: boolean },
+  ): Promise<RenderContext>;
+
+  protected override _onFirstRender(
+    context: DeepPartial<RenderContext>,
+    options: DeepPartial<RenderOptions>,
+  ): Promise<void>;
+
+  protected override _onRender(context: DeepPartial<RenderContext>, options: DeepPartial<RenderOptions>): Promise<void>;
+
+  /**
+   * Get the set of ContextMenu options which should be applied for Macros in the hotbar.
+   */
+  protected _getContextMenuOptions(): foundry.applications.ux.ContextMenu.Entry<HTMLElement>[];
+
+  /**
+   * Change to a specific numbered page from 1 to 5
+   * @param page - The page number to change to
+   */
+  changePage(page: number): Promise<void>;
+
+  /**
+   * Change the page of the hotbar by cycling up (positive) or down (negative).
+   * @param direction - The direction to cycle
+   */
+  cyclePage(direction: number): Promise<void>;
+
+  /**
+   * A reusable helper that can be used for toggling display of a document sheet.
+   * @param uuid - The Document UUID to display
+   */
+  static toggleDocumentSheet(uuid: string): Promise<void>;
+
+  /**
+   * Update hotbar display based on viewport size.
+   * @internal
+   */
+  protected _onResize(): void;
+
+  /**
+   * Create a Macro which rolls a RollTable when executed
+   * @param table - The RollTable document
+   */
+  protected _createRollTableRollMacro(table: Document.Any): Promise<Macro.Implementation>;
+
+  /**
+   * Create a Macro document which can be used to toggle display of a Journal Entry.
+   * @param doc - A Document which should be toggled
+   */
+  protected _createDocumentSheetToggle(doc: Document.Any): Promise<Macro.Implementation>;
+
+  /**
+   * @deprecated "{@linkcode Hotbar#macros} is deprecated in favor of {@linkcode Hotbar#slots}." (since v13, until v15)
+   * @ignore
+   */
+  get macros(): Hotbar.SlotData[];
+
+  /**
+   * @deprecated "{@linkcode Hotbar#collapse} is no longer a supported feature." (since v13, until v15)
+   * @ignore
+   */
+  collapse(): void;
+
+  /**
+   * @deprecated "{@linkcode Hotbar#expand} is no longer a supported feature." (since v13, until v15)
+   * @ignore
+   */
+  expand(): void;
+
+  static #HotbarStatic: true;
+  #Hotbar: true;
 }
 
 declare namespace Hotbar {
@@ -33,6 +121,12 @@ declare namespace Hotbar {
 
   interface SlotData {
     slot: number;
+    macro: Macro.Implementation | null;
+    key: number;
+    img: Macro.Implementation["img"] | null;
+    cssClass: "full" | "open";
+    tooltip: string | null;
+    ariaLabel: string;
   }
 
   /**

package/src/foundry/client/applications/ui/main-menu.d.mts

@@ -12,15 +12,42 @@ declare module "#configuration" {
 
 /**
  * The main menu application which is toggled via the ESC key.
- * @remarks TODO: Stub
  */
 declare class MainMenu<
   RenderContext extends object = MainMenu.RenderContext,
   Configuration extends MainMenu.Configuration = MainMenu.Configuration,
   RenderOptions extends MainMenu.RenderOptions = MainMenu.RenderOptions,
 > extends HandlebarsApplicationMixin(ApplicationV2)<RenderContext, Configuration, RenderOptions> {
-  // Fake override.
   static override DEFAULT_OPTIONS: MainMenu.DefaultOptions;
+  static override PARTS: Record<string, HandlebarsApplicationMixin.HandlebarsTemplatePart>;
+
+  /**
+   * Configuration of Main Menu items.
+   */
+  static ITEMS: Record<string, MainMenu.MainMenuItem>;
+
+  /**
+   * A record of menu items which are currently enabled.
+   */
+  get items(): Record<string, MainMenu.MainMenuItem>;
+
+  protected override _insertElement(element: HTMLElement): void;
+
+  protected override _onFirstRender(
+    context: DeepPartial<RenderContext>,
+    options: DeepPartial<RenderOptions>,
+  ): Promise<void>;
+
+  protected override _prepareContext(
+    options: DeepPartial<RenderOptions> & { isFirstRender: boolean },
+  ): Promise<RenderContext>;
+
+  /**
+   * Toggle display of the menu, or render it in the first place.
+   */
+  toggle(): Promise<void>;
+
+  static #MainMenuStatic: true;
 }
 
 declare namespace MainMenu {

package/src/foundry/client/applications/ui/players.d.mts

@@ -13,15 +13,82 @@ declare module "#configuration" {
 /**
  * A UI element which displays the Users defined for this world.
  * Currently active users are always displayed, while inactive users can be displayed on toggle.
- * @remarks TODO: Stub
  */
 declare class Players<
   RenderContext extends Players.RenderContext = Players.RenderContext,
   Configuration extends Players.Configuration = Players.Configuration,
   RenderOptions extends Players.RenderOptions = Players.RenderOptions,
 > extends HandlebarsApplicationMixin(ApplicationV2)<RenderContext, Configuration, RenderOptions> {
-  // Fake override.
   static override DEFAULT_OPTIONS: Players.DefaultOptions;
+  static override PARTS: Record<string, HandlebarsApplicationMixin.HandlebarsTemplatePart>;
+
+  /**
+   * How often latency is refreshed.
+   * @defaultValue `60 * 1000`
+   */
+  static REFRESH_LATENCY_FREQUENCY_MS: number;
+
+  /**
+   * A threshold of time in milliseconds after which a player is considered idle if they have no observed activity.
+   * @defaultValue `5 * 60 * 1000`
+   */
+  static IDLE_THRESHOLD_MS: number;
+
+  /**
+   * Is the application currently expanded?
+   */
+  get expanded(): boolean;
+
+  protected override _prepareContext(
+    options: DeepPartial<RenderOptions> & { isFirstRender: boolean },
+  ): Promise<RenderContext>;
+
+  /**
+   * Format the display of a user's name using their name, pronouns (if defined), and character name (if defined).
+   */
+  protected _formatName(user: User.Implementation): string;
+
+  protected override _onFirstRender(
+    context: DeepPartial<RenderContext>,
+    options: DeepPartial<RenderOptions>,
+  ): Promise<void>;
+
+  protected override _onRender(context: DeepPartial<RenderContext>, options: DeepPartial<RenderOptions>): Promise<void>;
+
+  /**
+   * Collapse the players list.
+   */
+  collapse(): void;
+
+  /**
+   * Expand the players list.
+   */
+  expand(): void;
+
+  /**
+   * Update the display which reports average latency.
+   */
+  refreshLatency(): void;
+
+  /**
+   * Update the display which reports average framerate.
+   * @param options - Options which customize FPS reporting (default: `{}`)
+   */
+  refreshFPS({ deactivate }?: Players.RefreshFPSOptions): void;
+
+  /**
+   * Toggle the expanded state of scene navigation.
+   * @param expanded - Force the expanded state to the provided value, otherwise toggle the state.
+   */
+  toggleExpanded(expanded?: boolean): void;
+
+  /**
+   * Get the set of ContextMenu options which should be applied to each User in the Players UI.
+   */
+  protected _getContextMenuOptions(): foundry.applications.ux.ContextMenu.Entry<HTMLElement>[];
+
+  static #PlayersStatic: true;
+  #Players: true;
 }
 
 declare namespace Players {
@@ -48,6 +115,14 @@ declare namespace Players {
     border: string;
   }
 
+  interface RefreshFPSOptions {
+    /**
+     * Deactivate tracking
+     * @defaultValue `false`
+     */
+    deactivate?: boolean | undefined;
+  }
+
   interface Configuration<Players extends Players.Any = Players.Any>
     extends HandlebarsApplicationMixin.Configuration,
       ApplicationV2.Configuration<Players> {}

package/src/foundry/client/applications/ui/region-legend.d.mts

@@ -19,6 +19,7 @@ declare class RegionLegend<
   RenderOptions extends RegionLegend.RenderOptions = RegionLegend.RenderOptions,
 > extends HandlebarsApplicationMixin(ApplicationV2)<RenderContext, Configuration, RenderOptions> {
   #RegionLegend: true;
+  static #RegionLegendStatic: true;
 
   static override DEFAULT_OPTIONS: RegionLegend.DefaultOptions;
   static override PARTS: Record<string, HandlebarsApplicationMixin.HandlebarsTemplatePart>;

package/src/foundry/client/applications/ui/scene-navigation.d.mts

@@ -59,7 +59,7 @@ declare class SceneNavigation<
   toggleExpanded(expanded?: boolean): void;
 
   /**
-   * @deprecated "SceneNavigation.displayProgressBar is deprecated in favor of {@linkcode Notifications#notify} using the \{progress: true\} option" (since v13, until v15)
+   * @deprecated "{@linkcode SceneNavigation.displayProgressBar} is deprecated in favor of {@linkcode Notifications#notify} using the `{progress: true}` option" (since v13, until v15)
    * @ignore
    */
   static displayProgressBar({ label, pct }?: SceneNavigation.DisplayProgressBarOptions): void;

package/src/foundry/client/canvas/containers/advanced/cached-container.d.mts

@@ -1,20 +1,20 @@
-import type { Identity, NullishProps } from "#utils";
+import type { Identity, InexactPartial } from "#utils";
 import { SpriteMesh } from "#client/canvas/containers/_module.mjs";
 
 /**
- * A special type of PIXI.Container which draws its contents to a cached RenderTexture.
- * This is accomplished by overriding the Container#render method to draw to our own special RenderTexture.
+ * A special type of {@linkcode PIXI.Container} which draws its contents to a cached {@linkcode PIXI.RenderTexture | RenderTexture}.
+ * This is accomplished by overriding the {@linkcode PIXI.Container.render | Container#render} method to draw to our own special `RenderTexture`.
  */
 declare class CachedContainer extends PIXI.Container {
   /**
    * Construct a CachedContainer.
-   * @param sprite - A specific sprite to bind to this CachedContainer and its renderTexture.
+   * @param sprite - A specific sprite to bind to this `CachedContainer` and its renderTexture.
    */
   constructor(sprite?: PIXI.Sprite | SpriteMesh);
 
   /**
    * The texture configuration to use for this cached container
-   * @remarks Foundry marked as `@abstract`
+   * @abstract
    */
   static textureConfiguration: CachedContainer.TextureConfiguration;
 
@@ -37,7 +37,7 @@ declare class CachedContainer extends PIXI.Container {
 
   /**
    * If true, the Container is rendered every frame.
-   * If false, the Container is rendered only if {@link CachedContainer.renderDirty | `CachedContainer#renderDirty`} is true.
+   * If false, the Container is rendered only if {@linkcode CachedContainer.renderDirty | CachedContainer#renderDirty} is true.
    * @defaultValue `true`
    */
   autoRender: boolean;
@@ -79,18 +79,17 @@ declare class CachedContainer extends PIXI.Container {
   /**
    * Remove a previously created render texture.
    * @param renderTexture - The render texture to remove.
-   * @param destroy - Should the render texture be destroyed?
-   *                  (default: `true`)
+   * @param destroy - Should the render texture be destroyed? (default: `true`)
    */
-  removeRenderTexture(renderTexture: PIXI.RenderTexture, destroy?: boolean | null): void;
+  removeRenderTexture(renderTexture: PIXI.RenderTexture, destroy?: boolean): void;
 
   /**
    * Clear the cached container, removing its current contents.
-   * @param destroy - Tell children that we should destroy texture as well.
+   * @param destroy - Tell children that we should destroy texture as well. (default: `true`)
    * @returns A reference to the cleared container for chaining.
    * @remarks Added possibility of void return due to child classes
    */
-  clear(destroy?: boolean): CachedContainer | void;
+  clear(destroy?: boolean): this;
 
   override destroy(options?: PIXI.IDestroyOptions | boolean): void;
 
@@ -102,6 +101,8 @@ declare class CachedContainer extends PIXI.Container {
    * @param rt       - The render texture to resize.
    */
   static resizeRenderTexture(renderer: PIXI.Renderer, rt: PIXI.RenderTexture): void;
+
+  #CachedContainer: true;
 }
 
 declare namespace CachedContainer {
@@ -109,25 +110,24 @@ declare namespace CachedContainer {
   interface AnyConstructor extends Identity<typeof AnyCachedContainer> {}
 
   /** @internal */
-  type _TextureConfiguration = NullishProps<{
+  type _TextureConfiguration = InexactPartial<{
     multisample: PIXI.MSAA_QUALITY;
     scaleMode: PIXI.SCALE_MODES;
     format: PIXI.FORMATS;
-
-    /** @remarks Only exists on DarknessLevelContainer and is seemingly unused there */
     mipmap: PIXI.MIPMAP_MODES;
   }>;
 
   interface TextureConfiguration extends _TextureConfiguration {}
 
   /** @internal */
-  type _RenderOptions = NullishProps<{
+  type _RenderOptions = InexactPartial<{
     /** Render function that will be called to render into the RT. */
     renderFunction: (renderer: PIXI.Renderer) => void;
 
     /** An optional clear color to clear the RT before rendering into it. */
     clearColor: Color.RGBAColorVector;
   }>;
+
   interface RenderOptions extends _RenderOptions {}
 }
 

package/src/foundry/client/canvas/containers/advanced/full-canvas-mixin.d.mts

@@ -5,12 +5,12 @@ declare class FullCanvasObject {
   /** @privateRemarks All mixin classes should accept anything for its constructor. */
   constructor(...args: any[]);
 
-  /** @remarks Overrides the mixed PIXI class's method, @see {@link PIXI.DisplayObject.calculateBounds | `PIXI.DisplayObject#calculateBounds`} */
+  /** @remarks Overrides the mixed PIXI class's method, see {@linkcode PIXI.DisplayObject.calculateBounds | PIXI.DisplayObject#calculateBounds} */
   calculateBounds(): void;
 }
 
 /**
- * Augment any PIXI.DisplayObject to assume bounds that are always aligned with the full visible screen.
+ * Augment any {@linkcode PIXI.DisplayObject} to assume bounds that are always aligned with the full visible screen.
  * The bounds of this container do not depend on its children but always fill the entire canvas.
  * @param Base - Any PIXI DisplayObject subclass
  */

package/src/foundry/client/canvas/containers/elements/control-icon.d.mts

@@ -25,18 +25,15 @@ declare class ControlIcon extends PIXI.Container {
    */
   tintColor: number | null;
 
-  /**
-   * @defaultValue `static`
-   */
+  /** @defaultValue `"static"` */
   override eventMode: PIXI.EventMode;
 
-  /**
-   * @defaultValue `false`
-   */
+  /** @defaultValue `false` */
   override interactiveChildren: boolean;
 
   override hitArea: PIXI.Rectangle;
 
+  /** @defaultValue `"pointer"` */
   override cursor: string;
 
   bg: PIXI.Graphics;
@@ -48,22 +45,23 @@ declare class ControlIcon extends PIXI.Container {
   tooltip: PreciseText;
 
   /**
-   * The elevation of the ControlIcon, which is displayed in its tooltip text.
-   * @throws If a set is attempted with anything but a finite number
+   * The elevation of the `ControlIcon`, which is displayed in its tooltip text.
+   * @remarks
+   * @throws If passed `NaN` or `+`/`-Infinity`
    */
   get elevation(): number;
 
   set elevation(value);
 
   /**
-   * Initial drawing of the ControlIcon
+   * Initial drawing of the `ControlIcon`
    */
   draw(): Promise<this>;
 
   /**
-   * Incremental refresh for ControlIcon appearance.
+   * Incremental refresh for `ControlIcon` appearance.
    */
-  refresh({ visible, iconColor, borderColor, borderVisible }?: ControlIcon.RefreshOptions): this;
+  refresh(options?: ControlIcon.RefreshOptions): this;
 }
 
 declare namespace ControlIcon {
@@ -72,17 +70,10 @@ declare namespace ControlIcon {
 
   /** @internal */
   type _Options = InexactPartial<{
-    /**
-     * @defaultValue `40`
-     * @remarks Can't be `null` as it only has a parameter default, and `null` coerced to `0` is a nonsensical size value
-     */
+    /** @defaultValue `40` */
     size: number;
 
-    /**
-     * @defaultValue `0xFF5500`
-     * @remarks Can't be `null` as that's not a valid value for the `PIXI.Color` constructor,
-     * and it only has a parameter default
-     */
+    /** @defaultValue `0xFF5500` */
     borderColor: number;
 
     /**
@@ -91,11 +82,7 @@ declare namespace ControlIcon {
      */
     tint: number | null;
 
-    /**
-     * @defaultValue `number`
-     * @remarks Can't be null as the `ControlIcon#elevation` setter throws if passed anything but a finite number,
-     * and it only has a parameter default
-     */
+    /** @defaultValue `number` */
     elevation: number;
   }>;
 
@@ -106,16 +93,9 @@ declare namespace ControlIcon {
 
   /** @internal */
   type _RefreshOptions = InexactPartial<{
-    /** @remarks Can't be `null` because of an explicit `!== undefined` check */
     visible: boolean;
-
-    /** @remarks Can't be `null` because of an explicit `!== undefined` check */
     iconColor: number;
-
-    /** @remarks Can't be `null` because of an explicit `!== undefined` check */
     borderColor: number;
-
-    /** @remarks Can't be `null` because of an explicit `!== undefined` check */
     borderVisible: boolean;
   }>;
 

package/src/foundry/client/canvas/containers/elements/cursor.d.mts

@@ -7,10 +7,20 @@ declare class Cursor extends PIXI.Container {
   constructor(user: User.Implementation);
 
   /**
+   * The target cursor position.
    * @defaultValue `{x: 0, y: 0}`
    */
   target: PIXI.IPointData;
 
+  /**
+   * Update the position of this cursor based on the current position?
+   * @defaultValue `true`
+   * @internal
+   */
+  protected _updatePosition: boolean;
+
+  override updateTransform(): void;
+
   /**
    * Update visibility and animations
    * @param user - The user
@@ -24,10 +34,13 @@ declare class Cursor extends PIXI.Container {
 
   /**
    * Move an existing cursor to a new position smoothly along the animation loop
+   * @deprecated Made hard private in v13 (this warning will be removed in v14)
    */
-  protected _animate(): void;
+  protected _animate(): never;
 
   override destroy(options?: PIXI.IDestroyOptions | boolean): void;
+
+  #Cursor: true;
 }
 
 declare namespace Cursor {

package/src/foundry/client/canvas/containers/elements/door-control.d.mts

@@ -11,7 +11,7 @@ declare class DoorControl extends PIXI.Container {
 
   /**
    * @defaultValue `false`
-   * @remarks "Door controls are not visible by default"
+   * @remarks Foundry comments "Door controls are not visible by default"
    */
   override visible: boolean;
 
@@ -44,7 +44,7 @@ declare class DoorControl extends PIXI.Container {
   /**
    * Determine whether the DoorControl is visible to the calling user's perspective.
    * The control is always visible if the user is a GM and no Tokens are controlled.
-   * @see {@link foundry.canvas.groups.CanvasVisibility.testVisibility | `CanvasVisibility#testVisibility`}
+   * @see {@linkcode foundry.canvas.groups.CanvasVisibility.testVisibility | CanvasVisibility#testVisibility}
    */
   get isVisible(): boolean;