@league-of-foundry-developers/foundry-vtt-types 13.340.0 → 13.340.1

package/src/foundry/client/pixi/board.d.mts

@@ -1,11 +1,7 @@
 import type { InexactPartial, NullishProps, FixedInstanceType } from "fvtt-types/utils";
-import type Document from "../../common/abstract/document.d.mts";
-import type { CANVAS_PERFORMANCE_MODES } from "../../common/constants.d.mts";
+import type { CANVAS_PERFORMANCE_MODES } from "#common/constants.d.mts";
 
-type InternalCanvas = new (
-  arg0: never,
-  ...args: never[]
-) => {
+type InternalCanvas = new (...args: never) => {
   readonly [K in keyof CONFIG.Canvas.Groups]?: FixedInstanceType<CONFIG.Canvas.Groups[K]["groupClass"]> | undefined;
 };
 
@@ -18,11 +14,11 @@ declare global {
    * objects that are drawn on the canvas itself.
    *
    * ### Hook Events
-   * {@link hookEvents.canvasConfig}
-   * {@link hookEvents.canvasInit}
-   * {@link hookEvents.canvasReady}
-   * {@link hookEvents.canvasPan}
-   * {@link hookEvents.canvasTearDown}
+   * {@link hookEvents.canvasConfig | `hookEvents.canvasConfig`}
+   * {@link hookEvents.canvasInit | `hookEvents.canvasInit`}
+   * {@link hookEvents.canvasReady | `hookEvents.canvasReady`}
+   * {@link hookEvents.canvasPan | `hookEvents.canvasPan`}
+   * {@link hookEvents.canvasTearDown | `hookEvents.canvasTearDown`}
    *
    * @example Canvas State
    * ```typescript
@@ -111,12 +107,12 @@ declare global {
      * Configured performance settings which affect the behavior of the Canvas and its renderer.
      * @defaultValue `undefined`
      */
-    performance: CanvasPerformanceSettings | undefined;
+    performance: Canvas.PerformanceSettings | undefined;
 
     /**
      * A list of supported webGL capabilities and limitations.
      */
-    supported: CanvasSupportedComponents;
+    supported: Canvas.SupportedComponents;
 
     /**
      * Is the photosensitive mode enabled?
@@ -181,15 +177,15 @@ declare global {
 
     /**
      * The primary Canvas group which generally contains tangible physical objects which exist within the Scene.
-     * This group is a {@link CachedContainer} which is rendered to the Scene as a {@link SpriteMesh}.
-     * This allows the rendered result of the Primary Canvas Group to be affected by a {@link BaseSamplerShader}.
+     * This group is a {@link CachedContainer | `CachedContainer`} which is rendered to the Scene as a {@link SpriteMesh | `SpriteMesh`}.
+     * This allows the rendered result of the Primary Canvas Group to be affected by a {@link BaseSamplerShader | `BaseSamplerShader`}.
      * @defaultValue `undefined`
      */
     readonly primary: PrimaryCanvasGroup | undefined;
 
     /**
-     * The effects Canvas group which modifies the result of the {@link PrimaryCanvasGroup} by adding special effects.
-     * This includes lighting, vision, fog of war and related animations..
+     * The effects Canvas group which modifies the result of the {@link PrimaryCanvasGroup | `PrimaryCanvasGroup`} by adding special effects.
+     * This includes lighting, vision, fog of war and related animations.
      * @defaultValue `undefined`
      */
     readonly effects: EffectsCanvasGroup | undefined;
@@ -202,8 +198,8 @@ declare global {
 
     /**
      * The interface Canvas group which is rendered above other groups and contains all interactive elements.
-     * The various {@link InteractionLayer} instances of the interface group provide different control sets for
-     * interacting with different types of {@link Document}s which can be represented on the Canvas.
+     * The various {@link InteractionLayer | `InteractionLayer`} instances of the interface group provide different control sets for
+     * interacting with different types of {@link Document | `Document`}s which can be represented on the Canvas.
      * @defaultValue `undefined`
      */
     readonly interface: InterfaceCanvasGroup | undefined;
@@ -244,7 +240,7 @@ declare global {
     /**
      * A reference to the currently displayed Scene document, or null if the Canvas is currently blank.
      */
-    get scene(): Document.Stored<Scene.ConfiguredInstance> | null;
+    get scene(): Scene.Stored | null;
 
     /**
      * A SceneManager instance which adds behaviors to this Scene, or null if there is no manager.
@@ -388,14 +384,14 @@ declare global {
      * Configure performance settings for hte canvas application based on the selected performance mode.
      * @internal
      */
-    protected _configurePerformanceMode(): CanvasPerformanceSettings;
+    protected _configurePerformanceMode(): Canvas.PerformanceSettings;
 
     /**
      * Draw the game canvas.
      * @param scene - A specific Scene document to render on the Canvas
      * @returns A Promise which resolves once the Canvas is fully drawn
      */
-    draw(scene?: Scene.ConfiguredInstance): Promise<this>;
+    draw(scene?: Scene.Implementation): Promise<this>;
 
     /**
      * When re-drawing the canvas, first tear down or discontinue some existing processes
@@ -405,7 +401,7 @@ declare global {
     /**
      * Create a SceneManager instance used for this Scene, if any.
      */
-    static getSceneManager(scene: Scene.ConfiguredInstance): foundry.canvas.SceneManager | null;
+    static getSceneManager(scene: Scene.Implementation): foundry.canvas.SceneManager | null;
 
     /**
      * Get the value of a GL parameter
@@ -530,7 +526,7 @@ declare global {
      * @param origin  - Point to display Ping at
      * @param options - Additional options to configure how the ping is drawn.
      */
-    ping(origin: Canvas.Point, options?: PingOptions): Promise<boolean>;
+    ping(origin: Canvas.Point, options?: Ping.ConstructorOptions): Promise<boolean>;
 
     /**
      * Create a BlurFilter instance and register it to the array for updates when the zoom level changes.
@@ -588,20 +584,7 @@ declare global {
     /**
      * Get a texture with the required configuration and clear color.
      */
-    static getRenderTexture(
-      options?: InexactPartial<{
-        /**
-         * The clear color to use for this texture. Transparent by default.
-         */
-        clearColor: number[] | null;
-
-        /**
-         * The render texture configuration.
-         * @privateRemarks forwarded to `PIXI.RenderTexture.create`
-         */
-        textureConfiguration: Parameters<(typeof PIXI.RenderTexture)["create"]>[0];
-      }>,
-    ): PIXI.RenderTexture;
+    static getRenderTexture(options?: Canvas.GetRenderTextureOptions): PIXI.RenderTexture;
 
     /**
      * Handle right-mouse start drag events occurring on the Canvas.
@@ -683,60 +666,18 @@ declare global {
     get colorManager(): this["environment"];
   }
 
-  interface CanvasPerformanceSettings {
-    /** The performance mode in CONST.CANVAS_PERFORMANCE_MODES */
-    mode: CANVAS_PERFORMANCE_MODES;
-
-    /** Blur filter configuration */
-    blur: {
-      enabled: boolean;
-      illumination: boolean;
-    };
-
-    /** Whether to use mipmaps, "ON" or "OFF" */
-    mipmap: "ON" | "OFF";
-
-    /** Whether to apply MSAA at the overall canvas level */
-    msaa: boolean;
-
-    /** Maximum framerate which should be the render target */
-    fps: number;
-
-    /** Whether to display token movement animation */
-    tokenAnimation: boolean;
-
-    /** Whether to display light source animation */
-    lightAnimation: boolean;
-
-    /** Whether to render soft edges for light sources */
-    lightSoftEdges: boolean;
-
-    /** Texture configuration */
-    textures: {
-      enabled: boolean;
-
-      maxSize: number;
-
-      p2Steps: number;
-
-      /** @defaultValue `2` */
-      p2StepsMax: number;
-    };
-  }
-
-  interface CanvasSupportedComponents {
-    /** Is WebGL2 supported? */
-    webGL2: boolean;
-
-    /** Is reading pixels in RED format supported? */
-    readPixelsRED: boolean;
+  /**
+   * @deprecated {@link Canvas.PerformanceSettings | `Canvas.PerformanceSettings`}
+   */
+  type CanvasPerformanceSettings = Canvas.PerformanceSettings;
 
-    /** Is the OffscreenCanvas supported? */
-    offscreenCanvas: boolean;
-  }
+  /**
+   * @deprecated {@link Canvas.SupportedComponents | `Canvas.SupportedComponents`}
+   */
+  type CanvasSupportedComponents = Canvas.SupportedComponents;
 
   namespace Canvas {
-    interface Dimensions extends SceneDimensions {
+    interface Dimensions extends Scene.Dimensions {
       /** The canvas rectangle. */
       rect: PIXI.Rectangle;
 
@@ -795,6 +736,71 @@ declare global {
       width: number;
       height: number;
     }
+
+    interface PerformanceSettings {
+      /** The performance mode in CONST.CANVAS_PERFORMANCE_MODES */
+      mode: CANVAS_PERFORMANCE_MODES;
+
+      /** Blur filter configuration */
+      blur: {
+        enabled: boolean;
+        illumination: boolean;
+      };
+
+      /** Whether to use mipmaps, "ON" or "OFF" */
+      mipmap: "ON" | "OFF";
+
+      /** Whether to apply MSAA at the overall canvas level */
+      msaa: boolean;
+
+      /** Maximum framerate which should be the render target */
+      fps: number;
+
+      /** Whether to display token movement animation */
+      tokenAnimation: boolean;
+
+      /** Whether to display light source animation */
+      lightAnimation: boolean;
+
+      /** Whether to render soft edges for light sources */
+      lightSoftEdges: boolean;
+
+      /** Texture configuration */
+      textures: {
+        enabled: boolean;
+
+        maxSize: number;
+
+        p2Steps: number;
+
+        /** @defaultValue `2` */
+        p2StepsMax: number;
+      };
+    }
+
+    interface SupportedComponents {
+      /** Is WebGL2 supported? */
+      webGL2: boolean;
+
+      /** Is reading pixels in RED format supported? */
+      readPixelsRED: boolean;
+
+      /** Is the OffscreenCanvas supported? */
+      offscreenCanvas: boolean;
+    }
+
+    interface GetRenderTextureOptions {
+      /**
+       * The clear color to use for this texture. Transparent by default.
+       */
+      clearColor?: number[] | null | undefined;
+
+      /**
+       * The render texture configuration.
+       * @privateRemarks forwarded to {@link PIXI.RenderTexture.create | `PIXI.RenderTexture.create`}
+       */
+      textureConfiguration?: PIXI.IBaseTextureOptions | undefined;
+    }
   }
 }
 

package/src/foundry/client/pixi/core/containers/base-canvas-group.d.mts

@@ -1,6 +1,6 @@
 import type { FixedInstanceType, HandleEmptyObject, PrettifyType, RemoveIndexSignatures } from "fvtt-types/utils";
 
-declare const DynamicClass: new <_Computed extends object>(arg0: never, ...args: never[]) => _Computed;
+declare const DynamicClass: new <_Computed extends object>(...args: never) => _Computed;
 
 // @ts-expect-error - This is a workaround to allow for dynamic top level properties in a class.
 declare class LayersClass<
@@ -107,9 +107,10 @@ declare global {
   const BaseCanvasMixin: typeof CanvasGroupMixin;
 
   namespace CanvasGroupMixin {
-    type AnyMixedConstructor = ReturnType<
-      typeof CanvasGroupMixin<CanvasGroupMixin.BaseClass, CanvasGroupMixin.LayerGroup | NoLayerGroup>
-    >;
+    interface AnyMixedConstructor
+      extends ReturnType<
+        typeof CanvasGroupMixin<CanvasGroupMixin.BaseClass, CanvasGroupMixin.LayerGroup | NoLayerGroup>
+      > {}
     interface AnyMixed extends FixedInstanceType<AnyMixedConstructor> {}
 
     type BaseClass = PIXI.Container.AnyConstructor;
@@ -150,5 +151,5 @@ declare global {
 }
 
 declare abstract class AnyCanvasGroup extends CanvasGroup<NoLayerGroup> {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

package/src/foundry/client/pixi/core/containers/cached-container.d.mts

@@ -1,4 +1,4 @@
-import type { NullishProps } from "fvtt-types/utils";
+import type { Identity, NullishProps } from "fvtt-types/utils";
 
 declare global {
   /**
@@ -37,7 +37,7 @@ declare global {
 
     /**
      * If true, the Container is rendered every frame.
-     * If false, the Container is rendered only if {@link CachedContainer#renderDirty} is true.
+     * If false, the Container is rendered only if {@link CachedContainer.renderDirty | `CachedContainer#renderDirty`} is true.
      * @defaultValue `true`
      */
     autoRender: boolean;
@@ -106,14 +106,14 @@ declare global {
 
   namespace CachedContainer {
     interface Any extends AnyCachedContainer {}
-    type AnyConstructor = typeof AnyCachedContainer;
+    interface AnyConstructor extends Identity<typeof AnyCachedContainer> {}
 
     /** @internal */
     type _TextureConfiguration = NullishProps<{
       multisample: PIXI.MSAA_QUALITY;
       scaleMode: PIXI.SCALE_MODES;
       format: PIXI.FORMATS;
-      /** @privateRemarks Only exists on DarknessLevelContainer and is seemingly unused there */
+      /** @remarks Only exists on DarknessLevelContainer and is seemingly unused there */
       mipmap: PIXI.MIPMAP_MODES;
     }>;
 
@@ -132,5 +132,5 @@ declare global {
 }
 
 declare abstract class AnyCachedContainer extends CachedContainer {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

package/src/foundry/client/pixi/core/containers/full-canvas-container.d.mts

@@ -4,7 +4,7 @@ declare class FullCanvasObject {
   /** @privateRemarks All mixin classses should accept anything for its constructor. */
   constructor(...args: any[]);
 
-  /** @remarks Overrides the mixed PIXI class's method, @see {@link PIXI.DisplayObject#calculateBounds} */
+  /** @remarks Overrides the mixed PIXI class's method, @see {@link PIXI.DisplayObject.calculateBounds | `PIXI.DisplayObject#calculateBounds`} */
   calculateBounds(): void;
 }
 
@@ -20,7 +20,7 @@ declare global {
   ): Mixin<typeof FullCanvasObject, BaseClass>;
 
   namespace FullCanvasObjectMixin {
-    type AnyMixedConstructor = ReturnType<typeof FullCanvasObjectMixin<BaseClass>>;
+    interface AnyMixedConstructor extends ReturnType<typeof FullCanvasObjectMixin<BaseClass>> {}
     interface AnyMixed extends FixedInstanceType<AnyMixedConstructor> {}
 
     type BaseClass = PIXI.DisplayObject.AnyConstructor;

package/src/foundry/client/pixi/core/containers/point-source-mesh.d.mts

@@ -1,4 +1,4 @@
-export {};
+import type { Identity } from "fvtt-types/utils";
 
 declare global {
   /**
@@ -63,10 +63,10 @@ declare global {
 
   namespace PointSourceMesh {
     interface Any extends AnyPointSourceMesh {}
-    type AnyConstructor = typeof AnyPointSourceMesh;
+    interface AnyConstructor extends Identity<typeof AnyPointSourceMesh> {}
   }
 }
 
 declare abstract class AnyPointSourceMesh extends PointSourceMesh<PIXI.Shader.Any> {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

package/src/foundry/client/pixi/core/containers/quad-mesh.d.mts

@@ -1,4 +1,4 @@
-export {};
+import type { Identity } from "fvtt-types/utils";
 
 declare global {
   /**
@@ -44,10 +44,10 @@ declare global {
 
   namespace QuadMesh {
     interface Any extends AnyQuadMesh {}
-    type AnyConstructor = typeof AnyQuadMesh;
+    interface AnyConstructor extends Identity<typeof AnyQuadMesh> {}
   }
 }
 
 declare abstract class AnyQuadMesh extends QuadMesh {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

package/src/foundry/client/pixi/core/containers/quadtree.d.mts

@@ -1,15 +1,8 @@
-import type { Brand, InexactPartial, NullishProps } from "../../../../../utils/index.d.mts";
-
-/** @internal */
-interface _QuadtreeObjectBase<T> {
-  r: Canvas.Rectangle;
-  t: T;
-}
+import type { Brand, Identity, InexactPartial, NullishProps } from "fvtt-types/utils";
 
 declare global {
-  interface QuadtreeObject<T> extends _QuadtreeObjectBase<T> {
-    n: Set<Quadtree<T>>;
-  }
+  /** @deprecated {@link Quadtree.Object | `Quadtree.Object`} */
+  type QuadtreeObject<T> = Quadtree.Object<T>;
 
   /**
    * A Quadtree implementation that supports collision detection for rectangles.
@@ -50,7 +43,7 @@ declare global {
      * The objects contained at this level of the tree
      * @defaultValue `[]`
      */
-    objects: QuadtreeObject<T>[];
+    objects: Quadtree.Object<T>[];
 
     /**
      * Children of this node
@@ -71,7 +64,7 @@ declare global {
     /**
      * Return an array of all the objects in the Quadtree (recursive)
      */
-    get all(): QuadtreeObject<T>[];
+    get all(): Quadtree.Object<T>[];
 
     /**
      * Split this node into 4 sub-nodes.
@@ -90,7 +83,7 @@ declare global {
      * @param obj - The object being inserted
      * @returns The Quadtree nodes the object was added to.
      */
-    insert(obj: Quadtree.QuadtreeObject<T>): Quadtree<T>[];
+    insert(obj: Quadtree.Object<T>): Quadtree<T>[];
 
     /**
      * Remove an object from the quadtree
@@ -104,7 +97,7 @@ declare global {
      * @param obj - The object being inserted
      * @returns The Quadtree nodes the object was added to
      */
-    update(obj: Quadtree.QuadtreeObject<T>): Quadtree<T>[];
+    update(obj: Quadtree.Object<T>): Quadtree<T>[];
 
     /**
      * Get all the objects which could collide with the provided rectangle
@@ -143,7 +136,7 @@ declare global {
 
   namespace Quadtree {
     interface Any extends AnyQuadtree {}
-    type AnyConstructor = typeof AnyQuadtree;
+    interface AnyConstructor extends Identity<typeof AnyQuadtree> {}
 
     /** @internal */
     type _OptionalSet<T> = NullishProps<{
@@ -151,9 +144,18 @@ declare global {
       n?: Set<Quadtree<T>>;
     }>;
 
-    interface QuadtreeObject<T> extends _QuadtreeObjectBase<T>, _OptionalSet<T> {}
+    /** @internal */
+    interface _ObjectBase<T> {
+      r: Canvas.Rectangle;
+      t: T;
+    }
+
+    /** @deprecated {@link Quadtree.Object | `Quadtree.Object`} */
+    type QuadtreeObject<T> = Object<T>;
+
+    interface Object<T> extends _ObjectBase<T>, _OptionalSet<T> {}
 
-    type INDICES = Brand<number, "Quadtree.INDICIES">;
+    type INDICES = Brand<number, "Quadtree.INDICES">;
 
     interface Indices {
       tl: 0 & Quadtree.INDICES;
@@ -205,7 +207,7 @@ declare global {
        * after a potential collision is found. Parameters are the object and rect, and the
        * function should return true if the object should be added to the result set.
        */
-      collisionTest: (o: globalThis.QuadtreeObject<T>, rect: Canvas.Rectangle) => boolean;
+      collisionTest: (o: Quadtree.Object<T>, rect: Canvas.Rectangle) => boolean;
 
       /**
        * The existing result set, for internal use.
@@ -241,16 +243,16 @@ declare global {
 
   namespace CanvasQuadtree {
     interface Any extends AnyCanvasQuadtree {}
-    type AnyConstructor = typeof AnyCanvasQuadtree;
+    interface AnyConstructor extends Identity<typeof AnyCanvasQuadtree> {}
 
     type CanvasQuadtreeObject = PrimaryCanvasObjectMixin.AnyMixed | PlaceableObject.Any;
   }
 }
 
 declare abstract class AnyQuadtree extends Quadtree<unknown> {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }
 
 declare abstract class AnyCanvasQuadtree extends CanvasQuadtree<CanvasQuadtree.CanvasQuadtreeObject> {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

package/src/foundry/client/pixi/core/containers/sprite-mesh.d.mts

@@ -1,4 +1,4 @@
-export {};
+import type { Identity } from "fvtt-types/utils";
 
 declare global {
   /**
@@ -222,7 +222,7 @@ declare global {
     set texture(texture);
 
     /**
-     * The anchor sets the origin point of the sprite. The default value is taken from the {@link PIXI.Texture|Texture}
+     * The anchor sets the origin point of the sprite. The default value is taken from the {@link PIXI.Texture | `PIXI.Texture`}
      * and passed to the constructor.
      *
      * The default is `(0,0)`, this means the sprite's origin is the top left.
@@ -314,7 +314,7 @@ declare global {
      * Create a SpriteMesh from another source.
      * You can specify texture options and a specific shader class derived from BaseSamplerShader.
      * @param source         - Source to create texture from.
-     * @param textureOptions - See {@link PIXI.BaseTexture}'s constructor for options.
+     * @param textureOptions - See {@link PIXI.BaseTexture | `PIXI.BaseTexture`}'s constructor for options.
      * @param shaderClass    - The shader class to use. BaseSamplerShader by default.
      */
     static from(
@@ -326,7 +326,7 @@ declare global {
 
   namespace SpriteMesh {
     interface Any extends AnySpriteMesh {}
-    type AnyConstructor = typeof AnySpriteMesh;
+    interface AnyConstructor extends Identity<typeof AnySpriteMesh> {}
 
     /** Snapshot of some parameters of this display object to render in batched mode. */
     interface BatchData {
@@ -365,5 +365,5 @@ declare global {
 }
 
 declare abstract class AnySpriteMesh extends SpriteMesh {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

package/src/foundry/client/pixi/core/containers/unbound-container.d.mts

@@ -1,4 +1,4 @@
-export {};
+import type { Identity } from "fvtt-types/utils";
 
 declare global {
   /**
@@ -11,7 +11,7 @@ declare global {
 
   namespace UnboundContainer {
     interface Any extends AnyUnboundContainer {}
-    type AnyConstructor = typeof AnyUnboundContainer;
+    interface AnyConstructor extends Identity<typeof AnyUnboundContainer> {}
   }
 
   /**
@@ -26,14 +26,14 @@ declare global {
 
   namespace UnboundTransform {
     interface Any extends AnyUnboundTransform {}
-    type AnyConstructor = typeof AnyUnboundTransform;
+    interface AnyConstructor extends Identity<typeof AnyUnboundTransform> {}
   }
 }
 
 declare abstract class AnyUnboundContainer extends UnboundContainer {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }
 
 declare abstract class AnyUnboundTransform extends UnboundTransform {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }