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

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.20250719181625",
   "description": "TypeScript type definitions for Foundry VTT",
   "type": "module",
   "types": "./src/index.d.mts",

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;
 

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

@@ -1,12 +1,224 @@
-import type { Identity } from "#utils";
+import type { ConcreteKeys, Identity, InexactPartial, ValueOf } from "#utils";
 import type { PrimarySpriteMesh } from "#client/canvas/primary/_module.d.mts";
+import type { CanvasAnimation } from "#client/canvas/animation/_module.d.mts";
+import type { Wall } from "#client/canvas/placeables/_module.d.mts";
 
-// TODO: whole class
-declare class DoorMesh extends PrimarySpriteMesh {}
+/**
+ * A special subclass of {@linkcode PrimarySpriteMesh} used to render an interactive door.
+ */
+declare class DoorMesh extends PrimarySpriteMesh {
+  /**
+   * Construct a DoorMesh by providing {@linkcode PrimarySpriteMesh} constructor options and specific door configuration.
+   * @remarks `options` is required, `texture` and `object` must be passed or construction will throw.
+   *
+   * If no door configuration options are passed, the `"swing"` animation config will be loaded
+   */
+  constructor(options: DoorMesh.ConstructorOptions);
+
+  /**
+   * The possible rendering styles for a door mesh.
+   * @remarks Frozen.
+   */
+  static DOOR_STYLES: Readonly<DoorMesh.DoorStyles>;
+
+  /**
+   * The original position of the door in its resting CLOSED state.
+   * @internal
+   */
+  protected _closedPosition: DoorMesh.StateSnapshot;
+
+  /**
+   * The currently rendered position of the door.
+   * @internal
+   */
+  protected _animatedPosition: DoorMesh.StateSnapshot;
+
+  /**
+   * An amount of pixel padding surrounding the door texture.
+   */
+  texturePadding: number;
+
+  /**
+   * The identifier for this door animation.
+   */
+  get animationId(): string;
+
+  /**
+   * Configure and initialize the DoorMesh.
+   * This is called automatically upon construction, but may be called manually later to update the DoorMesh.
+   * @remarks Despite all properties of {@linkcode DoorMesh.AnimationConfiguration} being optional, `options`
+   * lacks a `={}` default, so you must pass at least an empty object
+   */
+  initialize(animation: DoorMesh.AnimationConfiguration): void;
+
+  /**
+   * Animate the door to its current rendered state.
+   * @param open - Is the door now open or closed? (default: {@linkcode Wall.isOpen | this.object.isOpen})
+   */
+  animate(open?: boolean): Promise<void>;
+
+  /**
+   * Configure the `"swing"` animation.
+   * @remarks A valid {@linkcode CONFIG.Wall.DoorAnimationFunction}
+   */
+  static animateSwing(this: DoorMesh, open: boolean): CanvasAnimation.Attribute[];
+
+  /**
+   * Configure the `"ascend"` animation.
+   * @remarks A valid {@linkcode CONFIG.Wall.DoorAnimationFunction}
+   */
+  static animateAscend(this: DoorMesh, open: boolean): CanvasAnimation.Attribute[];
+
+  /**
+   * Special initialization needed for descending door types.
+   * @remarks A valid {@linkcode CONFIG.Wall.DoorAnimationHook}
+   */
+  static initializeDescend(this: DoorMesh, open: boolean): void;
+
+  /**
+   * When closing a descending door, shift its elevation to the foreground before animation.
+   * @remarks A valid {@linkcode CONFIG.Wall.DoorAnimationHook}
+   */
+  static preAnimateDescend(this: DoorMesh, open: boolean): Promise<void>;
+
+  /**
+   * Configure the `"descend"` animation.
+   * @remarks A valid {@linkcode CONFIG.Wall.DoorAnimationFunction}
+   */
+  static animateDescend(this: DoorMesh, open: boolean): CanvasAnimation.Attribute[];
+
+  /**
+   * When opening a descending door, shift its elevation to the background after animation.
+   * @remarks A valid {@linkcode CONFIG.Wall.DoorAnimationHook}
+   */
+  static postAnimateDescend(this: DoorMesh, open: boolean): Promise<void>;
+
+  /**
+   * Configure the `"slide"` animation.
+   * @remarks A valid {@linkcode CONFIG.Wall.DoorAnimationFunction}
+   */
+  static animateSlide(this: DoorMesh, open: boolean): CanvasAnimation.Attribute[];
+
+  #DoorMesh: true;
+}
 
 declare namespace DoorMesh {
   interface Any extends AnyDoorMesh {}
   interface AnyConstructor extends Identity<typeof AnyDoorMesh> {}
+
+  /**
+   * @remarks Foundry types {@linkcode AnimationConfiguration.style | style} as required at construction, but it gets passed
+   * to `##configure` via {@linkcode DoorMesh.initialize | #initialize}, where it has a default applied
+   */
+  interface ConstructorOptions
+    extends Omit<PrimarySpriteMesh.ConstructorOptions, "object" | "texture">,
+      AnimationConfiguration {
+    /**
+     * Texture passed to the SpriteMesh.
+     * @remarks Required for {@linkcode DoorMesh}, as the constructor calls `##configure` which calls `##getClosedPosition`
+     * which assumes a valid {@linkcode DoorMesh.texture | this.texture}
+     */
+    texture: PIXI.Texture;
+
+    /**
+     * @remarks This is technically inherited from {@linkcode PrimarySpriteMesh.ConstructorOptions.object}, which is much wider,
+     * but by usage this class requires {@linkcode Wall}s. Required because `##configure` assumes it can call its
+     * {@linkcode Wall.isOpen | isOpen} method.
+     *
+     * See {@linkcode foundry.canvas.primary.PrimaryCanvasObjectMixin.AnyMixed.object | PrimaryCanvasObject#object}
+     */
+    object: Wall.Implementation;
+  }
+
+  type ConfiguredAnimationType = ConcreteKeys<typeof CONFIG.Wall.animationTypes>;
+
+  /** @internal */
+  type _AnimationConfiguration = InexactPartial<{
+    /**
+     * @defaultValue `1`
+     * @remarks
+     * - For `swing` and `swivel` this is rotation direction: `1` for clockwise, `-1` counter-clockwise (pivoting from the
+     * {@linkcode Wall.edge.a | a} endpoint of the edge for `swing`, and the midpoint for `swivel`)
+     * - For `slide`, `1` slides towards `a` , `-1` away
+     * - For `ascend` and `descend` it has no effect
+     */
+    direction: -1 | 1;
+
+    /**
+     * @defaultValue `false`
+     * @remarks Is this mesh part of a double door pair?
+     */
+    double: boolean;
+
+    /**
+     * @defaultValue `500`
+     * @remarks Animation time in milliseconds
+     *
+     * The claimed default is the value in the configs for `swivel`, `slide`, and `swing` in {@linkcode CONFIG.Wall.animationTypes},
+     * but the default of the {@linkcode WallDocument.AnimationData.duration | WallDocument#animation#duration} field is `750`
+     */
+    duration: number;
+
+    /**
+     * @defaultValue `false`
+     * @remarks Flip the texture along the axis of the door?
+     */
+    flip: boolean;
+
+    /**
+     * A multiplier between 0 and 2 that modifies how much the door moves when animating.
+     * For example for a swinging door, more strength produces a wider open angle. For a
+     * sliding door, more strength causes the door to slide farther.
+     * @defaultValue `1.0`
+     * @remarks
+     * - For `swing` and `swivel` it's a linear scale from 0 (no movement) to 2 (180 degrees)
+     * - For `slide` it's door-lengths shifted
+     * - For `ascend` and `descend` it affects how much the texture grows/shrinks. For `ascend` there's also code in place that implies it should
+     * affect the texture `alpha` (down to a minimum of `0.6` at strength `2.0`), but it's non-functional as of 13.346: {@link https://github.com/foundryvtt/foundryvtt/issues/13157}
+     */
+    strength: number;
+
+    /**
+     * @defaultValue `"swing"`
+     * @remarks Will also use `"swing"` as fallback if an invalid value is passed at runtime; {@linkcode WallDocument.AnimationData.type | Wall#animation#type}
+     * is not constrained by `choices`, so it will persist currently-invalid `type`s until updated
+     */
+    type: ConfiguredAnimationType;
+
+    /** @remarks Default depends on the value of `double`; `"doubleL"` if truthy, `"single"` otherwise */
+    style: DoorStyle;
+  }>;
+
+  /**
+   * @remarks The Foundry typedef has `config` and `style` as required properties, but that is for the type of `DoorMesh##animation`,
+   * after the object's passed through `##configure` and had defaults applied. Since there's no public access to that property, this
+   * interface is typed for input, with everything optional.
+   *
+   * `config` always gets set to {@linkcode CONFIG.Wall.animationTypes | CONFIG.Wall.animationTypes[type]}, regardless of input, so it
+   * is not included here.
+   *
+   * See {@linkcode WallDocument.AnimationData}
+   */
+  interface AnimationConfiguration extends _AnimationConfiguration {}
+
+  interface DoorStyles {
+    SINGLE: "single";
+    DOUBLE_LEFT: "doubleL";
+    DOUBLE_RIGHT: "doubleR";
+  }
+
+  type DoorStyle = ValueOf<DoorStyles>;
+
+  interface StateSnapshot {
+    x: number;
+    y: number;
+    elevation: number;
+    sort: number;
+    rotation: number;
+    scaleX: number;
+    scaleY: number;
+    tint: number;
+  }
 }
 
 export default DoorMesh;

package/src/foundry/client/canvas/containers/elements/grid-highlight.d.mts

@@ -3,13 +3,13 @@ import type { Identity } from "#utils";
 /**
  * A special Graphics class which handles Grid layer highlighting
  */
-declare class GridHighlight extends PIXI.Graphics {
-  constructor(name: string, ...args: ConstructorParameters<typeof PIXI.Graphics>);
+declare class GridHighlight extends PIXI.smooth.SmoothGraphics {
+  constructor(name: string, ...args: ConstructorParameters<typeof PIXI.smooth.SmoothGraphics>);
 
   /**
    * Track the Grid Highlight name
    */
-  name: string;
+  override name: string;
 
   /**
    * Track distinct positions which have already been highlighted

package/src/foundry/client/canvas/containers/elements/grid-mesh.d.mts

@@ -8,9 +8,9 @@ import { QuadMesh } from "#client/canvas/containers/_module.mjs";
 declare class GridMesh extends QuadMesh {
   /**
    * The grid mesh constructor.
-   * @param shaderClass - The shader class
+   * @param shaderClass - The shader class (default: {@linkcode GridShader})
    */
-  constructor(shaderClass: GridShader.AnyConstructor);
+  constructor(shaderClass?: GridShader.AnyConstructor);
 
   /**
    * The data of this mesh.
@@ -52,9 +52,9 @@ declare namespace GridMesh {
   interface MeshData {
     /**
      * The type of the grid (see {@linkcode CONST.GRID_TYPES})
-     * @defaultValue `CONST.GRID_TYPES.GRIDLESS`
+     * @defaultValue {@linkcode CONST.GRID_TYPES.GRIDLESS}
      */
-    type: foundry.CONST.GRID_TYPES;
+    type: CONST.GRID_TYPES;
 
     /**
      * The width of the grid in pixels

package/src/foundry/client/canvas/containers/elements/particles/leaves.d.mts

@@ -6,9 +6,10 @@ import { ParticleEffect } from "#client/canvas/containers/_module.mjs";
  */
 declare class AutumnLeavesWeatherEffect extends ParticleEffect {
   /**
-   * @remarks `options` is completely unused in this subclass, as it gets passed to `#getParticleEmitters`, which, unlike super's method, takes no arguments
+   * @remarks `options` is completely unused in this subclass, as it gets passed to {@linkcode AutumnLeavesWeatherEffect.getParticleEmitters | #getParticleEmitters},
+   * which, unlike {@linkcode ParticleEffect | super}'s method, takes no arguments
    */
-  constructor(options?: PIXI.particles.EmitterConfigV3 | null);
+  constructor(options?: PIXI.particles.EmitterConfigV3);
 
   /**
    * @defaultValue `"WEATHER.AutumnLeaves"`
@@ -19,13 +20,13 @@ declare class AutumnLeavesWeatherEffect extends ParticleEffect {
 
   /**
    * Configuration for the particle emitter for falling leaves
-   * @remarks Not a complete EmitterConfigV3; the `frequency` and `pos` required keys are omitted. `frequency` is set
-   * up in `#getParticleEmitters`, but `pos` is not; it is erroneously marked as required in the interface,
-   * see https://github.com/pixijs-userland/particle-emitter/issues/219
+   * @remarks Not a complete {@linkcode PIXI.particles.EmitterConfigV3}; the `frequency` and `pos` required keys are omitted. `frequency` is set
+   * up in {@linkcode AutumnLeavesWeatherEffect.getParticleEmitters | #getParticleEmitters}, but `pos` is not; it is erroneously marked as required
+   * in the interface, see https://github.com/pixijs-userland/particle-emitter/issues/219
    */
   static LEAF_CONFIG: AutumnLeavesWeatherEffect.LeafConfig;
 
-  /** @remarks This does not take a config paramater, unlike its parent class; uses `static LEAF_CONFIG` on this class instead */
+  /** @remarks This does not take a config parameter, unlike its parent class; uses {@linkcode AutumnLeavesWeatherEffect.LEAF_CONFIG} instead */
   override getParticleEmitters(): PIXI.particles.Emitter[];
 }
 

package/src/foundry/client/canvas/containers/elements/particles/particle-effect.d.mts

@@ -6,8 +6,7 @@ import { FullCanvasObjectMixin } from "#client/canvas/containers/_module.mjs";
  */
 declare class ParticleEffect extends FullCanvasObjectMixin(PIXI.Container) {
   /**
-   * @param options - Options passed to the getParticleEmitters method which can be used to customize values of the emitter configuration.
-   *                  (default: `{}`)
+   * @param options - Options passed to the getParticleEmitters method which can be used to customize values of the emitter configuration. (default: `{}`)
    * @remarks Despite being an `={}` parameter, construction will throw if it is passed (or defaults to via omission) an empty object
    */
   constructor(options: PIXI.particles.EmitterConfigV3);
@@ -15,7 +14,7 @@ declare class ParticleEffect extends FullCanvasObjectMixin(PIXI.Container) {
   emitters: PIXI.particles.Emitter[];
 
   /**
-   * Create an emitter instance which automatically updates using the shared PIXI.Ticker
+   * Create an emitter instance which automatically updates using the shared {@linkcode PIXI.Ticker}
    * @param config - The emitter configuration
    * @returns The created Emitter instance
    */
@@ -26,9 +25,9 @@ declare class ParticleEffect extends FullCanvasObjectMixin(PIXI.Container) {
    * This base class creates a single emitter using the explicitly provided configuration.
    * Subclasses can override this method for more advanced configurations.
    * @param options - Options provided to the ParticleEffect constructor which can be used to customize
-   *                  configuration values for created emitters. (default: `{}`)
-   * @throws If `options` is passed as (or defaults to via omission) an empty object
+   * configuration values for created emitters. (default: `{}`)
    * @remarks Despite its name, this method only takes a single config object and only returns a single-element array.
+   * @throws If `options` is passed as (or defaults to via omission) an empty object
    */
   getParticleEmitters(options: PIXI.particles.EmitterConfigV3): PIXI.particles.Emitter[];