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

package/src/foundry/common/utils/event-emitter.d.mts

@@ -1,12 +1,21 @@
-import type { InexactPartial, Mixin } from "fvtt-types/utils";
+import type {
+  AnyConstructor,
+  Coalesce,
+  FixedInstanceType,
+  Mixin,
+  PhantomConstructor,
+  NullishProps,
+} from "fvtt-types/utils";
 
 /**
  * A mixin class which implements the behavior of EventTarget.
  * This is useful in cases where a class wants EventTarget-like behavior but needs to extend some other class.
- * @see https://developer.mozilla.org/en-US/docs/Web/API/EventTarget
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/EventTarget}
  */
+// ESLint doesn't like this class "only being used as a type"
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
 declare class EventEmitter {
-  /** @privateRemarks All mixin classses should accept anything for its constructor. */
+  /** @privateRemarks All mixin classes should accept anything for its constructor. */
   constructor(...args: any[]);
 
   /**
@@ -16,21 +25,16 @@ declare class EventEmitter {
 
   /**
    * Add a new event listener for a certain type of event.
-   * @see https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener
+   * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener}
    * @param type     - The type of event being registered for
    * @param listener - The listener function called when the event occurs
    * @param options  - Options which configure the event listener
    */
+  // options: not null (destructured)
   addEventListener(
     type: string,
-    listener: EventEmitter.EmittedEventListener,
-    options?: InexactPartial<{
-      /**
-       * Should the event only be responded to once and then removed
-       * @defaultValue `false`
-       */
-      once: boolean;
-    }>,
+    listener: EventEmitterMixin.EventListener,
+    options?: EventEmitterMixin.AddListenerOptions,
   ): void;
 
   /**
@@ -38,25 +42,48 @@ declare class EventEmitter {
    * @param type     - The type of event being removed
    * @param listener - The listener function being removed
    */
-  removeEventListener(type: string, listener: EventEmitter.EmittedEventListener): void;
+  removeEventListener(type: string, listener: EventEmitterMixin.EventListener): void;
 
   /**
    * Dispatch an event on this target.
-   * @see https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/dispatchEvent
+   * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/dispatchEvent}
    * @param event - The Event to dispatch
    * @returns Was default behavior for the event prevented?
    */
   dispatchEvent(event: Event): boolean;
 }
 
-declare namespace EventEmitter {
-  type EmittedEventListener = (event: Event) => void;
+declare namespace EventEmitterMixin {
+  interface AnyMixedConstructor extends ReturnType<typeof EventEmitterMixin<BaseClass>> {}
+  interface AnyMixed extends FixedInstanceType<AnyMixedConstructor> {}
+
+  type Mix<BaseClass extends EventEmitterMixin.BaseClass | undefined> = Mixin<
+    typeof EventEmitter,
+    Coalesce<BaseClass, PhantomConstructor>
+  >;
+
+  type BaseClass = AnyConstructor;
+
+  /** @internal */
+  type _AddListenerOptions = NullishProps<{
+    /**
+     * Should the event only be responded to once and then removed
+     * @defaultValue `false`
+     */
+    once: boolean;
+  }>;
+
+  interface AddListenerOptions extends _AddListenerOptions {}
+
+  type EventListener = (event: Event) => void;
 }
 
 /**
  * Augment a base class with EventEmitter behavior.
  * @param BaseClass - Some base class augmented with event emitter functionality
  */
-export default function EventEmitterMixin<ExtendedClass extends abstract new (...args: any[]) => any>(
-  BaseClass: ExtendedClass,
-): Mixin<typeof EventEmitter, ExtendedClass>;
+declare function EventEmitterMixin<BaseClass extends EventEmitterMixin.BaseClass | undefined = undefined>(
+  BaseClass?: BaseClass,
+): EventEmitterMixin.Mix<BaseClass>;
+
+export default EventEmitterMixin;

package/src/foundry/common/utils/helpers.d.mts

@@ -48,7 +48,7 @@ export interface DeepCloneOptions {
   strict?: boolean;
   /**
    * An internal depth tracker
-   * @defaultValue 0
+   * @defaultValue `0`
    */
   _d?: number;
 }
@@ -80,7 +80,7 @@ export type DiffObjectOptions = InexactPartial<{
 
   /**
    * An internal depth tracker
-   * @defaultValue 0
+   * @defaultValue `0`
    */
   _d?: number;
 }>;
@@ -113,7 +113,7 @@ export function objectsEqual<B extends object>(a: object, b: B): a is B;
 export function duplicate<T>(original: T): Duplicated<T>;
 
 /**
- * The resulting type when using {@link duplicate} on some data of type `T`.
+ * The resulting type when using {@link duplicate | `duplicate`} on some data of type `T`.
  *
  * @typeParam T - Original type.
  * @internal
@@ -416,7 +416,7 @@ export interface MergeObjectOptions {
    * Control whether to perform deletions on the original object if deletion keys are present in the other object.
    * @defaultValue `false`
    */
-  performDeletions?: boolean | undefined; //TODO: implement this in the mergeObject return type
+  performDeletions?: boolean | undefined; // TODO: implement this in the mergeObject return type
 }
 
 /**
@@ -580,7 +580,7 @@ declare function _resolveRelativeUuid(uuid: string, relative: Document.Any): Res
  * @param g - The green color value
  * @param b - The blue color value
  * @returns The HSV representation
- * @deprecated since v10 until v12, rgbToHsv is deprecated in favor of {@link foundry.utils.Color#hsv}
+ * @deprecated since v10 until v12, rgbToHsv is deprecated in favor of {@link foundry.utils.Color.hsv | `foundry.utils.Color#hsv`}
  */
 export function rgbToHsv(r: number, g: number, b: number): [h: number, s: number, v: number];
 
@@ -591,7 +591,7 @@ export function rgbToHsv(r: number, g: number, b: number): [h: number, s: number
  * @param s - The saturation
  * @param v - The value
  * @returns The RGB representation
- * @deprecated since v10 until v12, hsvToRgb is deprecated in favor of {@link foundry.utils.Color.fromHSV}
+ * @deprecated since v10 until v12, hsvToRgb is deprecated in favor of {@link foundry.utils.Color.fromHSV | `foundry.utils.Color.fromHSV`}
  */
 export function hsvToRgb(h: number, s: number, v: number): [r: number, g: number, b: number];
 
@@ -599,7 +599,7 @@ export function hsvToRgb(h: number, s: number, v: number): [r: number, g: number
  * Converts a color as an [R, G, B] array of normalized floats to a hexadecimal number.
  * @param rgb - Array of numbers where all values are normalized floats from 0.0 to 1.0.
  * @returns The numeric color as hexadecimal
- * @deprecated since v10 until v12, rgbToHex is deprecated in favor of {@link foundry.utils.Color.fromRGB}
+ * @deprecated since v10 until v12, rgbToHex is deprecated in favor of {@link foundry.utils.Color.fromRGB | `foundry.utils.Color.fromRGB`}
  */
 export function rgbToHex(rgb: [r: number, g: number, b: number]): number;
 
@@ -607,7 +607,7 @@ export function rgbToHex(rgb: [r: number, g: number, b: number]): number;
  * Convert a hex color code to an RGB array
  * @param hex - A hex color number
  * @returns An array of [r,g,b] colors normalized on the range of [0,1]
- * @deprecated since v10 until v12, hexToRGB is deprecated in favor of {@link foundry.utils.Color#rgb}
+ * @deprecated since v10 until v12, hexToRGB is deprecated in favor of {@link foundry.utils.Color.rgb | `foundry.utils.Color#rgb`}
  */
 export function hexToRGB(hex: number): [r: number, g: number, b: number];
 
@@ -617,7 +617,7 @@ export function hexToRGB(hex: number): [r: number, g: number, b: number];
  * @param alpha - An optional level of transparency
  *                (default: `1.0`)
  * @returns An rgba style string
- * @deprecated since v10 until v12, hexToRGBAString is deprecated in favor of {@link foundry.utils.Color#toRGBA}
+ * @deprecated since v10 until v12, hexToRGBAString is deprecated in favor of {@link foundry.utils.Color.toRGBA | `foundry.utils.Color#toRGBA`}
  */
 export function hexToRGBAString(hex: number, alpha?: number): `rgba(${number}, ${number}, ${number})`;
 
@@ -625,19 +625,19 @@ export function hexToRGBAString(hex: number, alpha?: number): `rgba(${number}, $
  * Convert a string color to a hex integer
  * @param color - The string color
  * @returns The hexadecimal color code
- * @deprecated since v10 until v12, colorStringToHex is deprecated in favor of {@link foundry.utils.Color.from}
+ * @deprecated since v10 until v12, colorStringToHex is deprecated in favor of {@link foundry.utils.Color.from | `foundry.utils.Color.from`}
  */
 export function colorStringToHex(color: string): number | null;
 
 /**
- * Internal Helper for {@link Duplicated}. A union type of all types that do not have a JSON representation.
+ * Internal Helper for {@link Duplicated | `Duplicated`}. A union type of all types that do not have a JSON representation.
  *
  * @internal
  */
 type NonStringifiable = undefined | AnyFunction | AnyConstructor | symbol;
 
 /**
- * Internal helper for {@link InnerDuplicated}. Maps the properties of `T` to their duplicated types.
+ * Internal helper for {@link InnerDuplicated | `InnerDuplicated`}. Maps the properties of `T` to their duplicated types.
  *
  * @typeParam T - The object type that should have its properties mapped.
  * @internal
@@ -654,7 +654,7 @@ type MapToInnerDuplicated<T extends object> = { [k in keyof T]: InnerDuplicated<
 type OmitOfType<T extends object, U> = { [k in keyof T as T[k] extends U ? never : k]: T[k] };
 
 /**
- * Internal helper type for {@link Duplicated}. It is the main part of the implementation, which does the recursion.
+ * Internal helper type for {@link Duplicated | `Duplicated`}. It is the main part of the implementation, which does the recursion.
  *
  * @typeParam T - Type currently being converted.
  * @internal

package/src/foundry/common/utils/http.d.mts

@@ -1,11 +1,11 @@
 /**
  * A wrapper method around `fetch` that attaches an AbortController signal to the `fetch` call for clean timeouts
- * @see https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal#aborting_a_fetch_with_timeout_or_explicit_abort
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal#aborting_a_fetch_with_timeout_or_explicit_abort}
  * @param url            - The URL to make the Request to
  * @param data           - The data of the Request
  *                         (defalt: `{}`)
  * @param timeoutOptions - (default: `{}`)
- * @throws {@link HttpError}
+ * @throws {@link HttpError | `HttpError`}
  */
 export declare function fetchWithTimeout(
   url: string,

package/src/foundry/common/utils/string-tree.d.mts

@@ -1,9 +1,9 @@
-import type { InexactPartial } from "fvtt-types/utils";
+import type { AnyObject } from "fvtt-types/utils";
 
 /**
  * A data structure representing a tree of string nodes with arbitrary object leaves.
  */
-declare class StringTree<EntryType> {
+declare class StringTree<Leaf extends object = AnyObject, Key = string[]> {
   /**
    * The key symbol that stores the leaves of any given node.
    */
@@ -20,7 +20,7 @@ declare class StringTree<EntryType> {
    * @param entry    - The entry to store.
    * @returns   The node the entry was added to.
    */
-  addLeaf(strings: string[], entry: EntryType): StringTree.StringTreeNode;
+  addLeaf(strings: Key, entry: Leaf): StringTree.StringTreeNode<Leaf>;
 
   /**
    * Traverse the tree along the given string path and return any entries reachable from the node.
@@ -28,50 +28,32 @@ declare class StringTree<EntryType> {
    * @param options         - Additional options to configure behaviour.
    * @returns    The reachable entries
    */
-  lookup(
-    strings: string[],
-    options?: InexactPartial<{
-      /** The maximum number of items to retrieve. */
-      limit: number;
-      /** A filter function to apply to each candidate entry. */
-      filterEntries?: StringTree.StringTreeEntryFilter | undefined;
-    }>,
-  ): StringTree.StringTreeNode[];
+  lookup(strings: Key, options?: StringTree.LookupOptions): Leaf[];
 
   /**
    * Returns the node at the given path through the tree.
-   * @param strings                     - The string path to the desired node.
-   * @param options                     - Additional options to configure behaviour.
+   * @param strings - The string path to the desired node.
+   * @param options - Additional options to configure behaviour.
    * @returns The node at the path, if found
    */
-  nodeAtPrefix(
-    strings: string[],
-    options?: InexactPartial<{
-      /**
-       * Only return the most recently visited node that has
-       * leaves, otherwise return the exact node at the prefix,
-       * if it exists. Defaults to false.
-       */
-      hasLeaves: boolean;
-    }>,
-  ): StringTree.StringTreeNode | void;
+  nodeAtPrefix<Options extends StringTree.NodeAtPrefixOptions>(
+    strings: Key,
+    options?: Options,
+  ): StringTree.StringTreeNode<Leaf> | void;
 
   /**
    * Perform a breadth-first search starting from the given node and retrieving any entries reachable from that node,
    * until we reach the limit.
-   * @param node            - The starting node.
-   * @param entries         - The accumulated entries.
-   * @param queue           - The working queue of nodes to search.
-   * @param options         - Additional options to configure behaviour.
+   * @param node    - The starting node.
+   * @param entries - The accumulated entries.
+   * @param queue   - The working queue of nodes to search.
+   * @param options - Additional options to configure behaviour.
    */
   protected _breadthFirstSearch(
-    node: StringTree.StringTreeNode,
-    entries: EntryType[],
-    queue: StringTree.StringTreeNode[],
-    options?: InexactPartial<{
-      /** The maximum number of entries to retrieve before stopping. */
-      limit: number;
-    }>,
+    node: StringTree.StringTreeNode<Leaf>,
+    entries: Leaf[],
+    queue: StringTree.StringTreeNode<Leaf>[],
+    options?: StringTree.BreadthFirstSearchOptions,
   ): void;
 }
 
@@ -80,9 +62,9 @@ declare namespace StringTree {
    * A string tree node consists of zero-or-more string keys, and a leaves property that contains any objects that
    * terminate at the current node.
    */
-  interface StringTreeNode {
-    [StringTree.leaves]: Record<string, unknown>[];
-    [key: string]: StringTreeNode;
+  interface StringTreeNode<Leaf extends object> {
+    [StringTree.leaves]: Leaf[];
+    [key: string]: StringTreeNode<Leaf>;
   }
 
   /**
@@ -90,6 +72,30 @@ declare namespace StringTree {
    * @returns Whether the entry should be included in the result set.
    */
   type StringTreeEntryFilter = (entry: unknown) => boolean;
+
+  interface LookupOptions {
+    /** The maximum number of items to retrieve. */
+    limit?: number | undefined;
+
+    /** A filter function to apply to each candidate entry. */
+    filterEntries?: StringTree.StringTreeEntryFilter | undefined;
+  }
+
+  interface NodeAtPrefixOptions {
+    /**
+     * Only return the most recently visited node that has
+     * leaves, otherwise return the exact node at the prefix,
+     * if it exists. Defaults to false.
+     *
+     * @defaultValue `false`
+     */
+    hasLeaves?: boolean | undefined;
+  }
+
+  interface BreadthFirstSearchOptions {
+    /** The maximum number of entries to retrieve before stopping. */
+    limit?: number | undefined;
+  }
 }
 
 export default StringTree;

package/src/foundry/common/utils/word-tree.d.mts

@@ -1,4 +1,3 @@
-import type { InexactPartial } from "fvtt-types/utils";
 import type StringTree from "./string-tree.d.mts";
 
 /**
@@ -6,15 +5,14 @@ import type StringTree from "./string-tree.d.mts";
  * Note that this works well for languages with alphabets (latin, cyrillic, korean, etc.), but may need more nuanced
  * handling for languages that compose characters and letters.
  */
-declare class WordTree extends StringTree<WordTree.WordTreeEntry> {
+declare class WordTree<Key = string> extends StringTree<WordTree.WordTreeEntry, Key> {
   /**
    * Insert an entry into the tree.
    * @param string    - The string key for the entry.
    * @param entry     - The entry to store.
    * @returns         The node the entry was added to.
    */
-  addLeaf(string: string, entry: WordTree.WordTreeEntry): StringTree.StringTreeNode;
-  addLeaf(strings: string[], entry: any): StringTree.StringTreeNode;
+  addLeaf(key: Key, entry: WordTree.WordTreeEntry): StringTree.StringTreeNode<WordTree.WordTreeEntry>;
 
   /**
    * Return entries that match the given string prefix.
@@ -22,29 +20,14 @@ declare class WordTree extends StringTree<WordTree.WordTreeEntry> {
    * @param options             - Additional options to configure behaviour.
    * @returns                   A number of entries that have the given prefix.
    */
-  lookup(
-    prefix: string,
-    options?: InexactPartial<{
-      /**
-       * The maximum number of items to retrieve. It is important
-       * to set this value as very short prefixes will naturally match large numbers
-       * of entries.
-       * (default: `10`)
-       */
-      limit: number;
-      /** A filter function to apply to each candidate entry. */
-      filterEntries?: StringTree.StringTreeEntryFilter | undefined;
-    }>,
-  ): WordTree.WordTreeEntry[];
-  lookup(strings: string[], options?: InexactPartial<{ limit: number }>): StringTree.StringTreeNode[];
+  lookup(prefix: Key, options?: StringTree.LookupOptions): WordTree.WordTreeEntry[];
 
   /**
    * Returns the node at the given prefix.
-   * @param prefix        - The prefix.
+   * @param prefix - The prefix.
    * @returns The node
    */
-  nodeAtPrefix(strings: string[], options?: InexactPartial<{ hasLeaves: boolean }>): StringTree.StringTreeNode | void;
-  nodeAtPrefix(prefix: string): WordTree.WordTreeEntry;
+  nodeAtPrefix(prefix: Key): StringTree.StringTreeNode<WordTree.WordTreeEntry> | void;
 }
 
 declare namespace WordTree {
@@ -52,14 +35,18 @@ declare namespace WordTree {
    * A leaf entry in the tree.
    */
   interface WordTreeEntry {
+    // TODO(LukeAbby): This appears to be possible to be a compendium index entry.
     /** An object that this entry represents. */
     entry: foundry.abstract.Document.Any;
+
     /** The document type. */
     documentName: string;
+
     /** The document's UUID. */
     uuid: string;
+
     /** The (optional) pack ID. */
-    pack?: string;
+    pack?: string | undefined;
   }
 }
 

package/src/tsconfig.json

@@ -6,11 +6,7 @@
     "outDir": "../.typescript-build/src",
     "composite": true,
     "noEmit": false,
-    "emitDeclarationOnly": true,
-    "paths": {
-      "@client/*": ["./foundry/client/*"],
-      "@common/*": ["./foundry/common/*"]
-    }
+    "emitDeclarationOnly": true
   },
   // Note: `**/*` is used to work around a bug with `eslint`. This will be removed once it's fixed.
   "include": ["index.d.mts", "**/*"],

package/src/types/augments/pixi.d.mts

@@ -1,4 +1,4 @@
-import type { Brand } from "fvtt-types/utils";
+import type { Brand, Identity } from "fvtt-types/utils";
 import * as _PIXI from "pixi.js";
 
 // Note(LukeAbby): The `smooth.d.mts` and `smooth.d.mts` files exist to make it DRY to selectively tweak PIXI sub-namespaces.
@@ -272,7 +272,7 @@ declare global {
     /**
      * Configure whether filter textures are cleared after binding.
      *
-     * Filter textures need not be cleared if the filter does not use pixel blending. {@link PIXI.CLEAR_MODES.BLIT} will detect
+     * Filter textures need not be cleared if the filter does not use pixel blending. {@link PIXI.CLEAR_MODES.BLIT | `PIXI.CLEAR_MODES.BLIT`} will detect
      * this and skip clearing as an optimization.
      */
     const CLEAR_MODES: {
@@ -291,7 +291,7 @@ declare global {
       /** Always clear the filter texture. */
       CLEAR: 1 & CLEAR_MODES;
 
-      /** Clear only if {@link PIXI.FilterSystem.forceClear} is set or if the filter uses pixel blending. */
+      /** Clear only if {@link PIXI.FilterSystem.forceClear | `PIXI.FilterSystem.forceClear`} is set or if the filter uses pixel blending. */
       BLIT: 2 & CLEAR_MODES;
     };
 
@@ -440,7 +440,7 @@ declare global {
     /**
      * The gc modes that are supported by pixi.
      *
-     * The {@link PIXI.TextureGCSystem.defaultMode} Garbage Collection mode for PixiJS textures is AUTO
+     * The {@link PIXI.TextureGCSystem.defaultMode | `PIXI.TextureGCSystem.defaultMode`} Garbage Collection mode for PixiJS textures is AUTO
      * If set to GC_MODE, the renderer will occasionally check textures usage. If they are not
      * used for a specified period of time they will be removed from the GPU. They will of course
      * be uploaded again when they are required. This is a silent behind the scenes process that
@@ -573,8 +573,8 @@ declare global {
 
     /**
      * Supported line joints in `PIXI.LineStyle` for graphics.
-     * @see PIXI.Graphics#lineStyle
-     * @see https://graphicdesign.stackexchange.com/questions/59018/what-is-a-bevel-join-of-two-lines-exactly-illustrator
+     * @see {@link PIXI.Graphics.lineStyle | `PIXI.Graphics#lineStyle`}
+     * @see {@link https://graphicdesign.stackexchange.com/questions/59018/what-is-a-bevel-join-of-two-lines-exactly-illustrator}
      */
     const LINE_JOIN: {
       /** 'miter': make a sharp corner where outer part of lines meet */
@@ -633,7 +633,7 @@ declare global {
     /**
      * Mipmap filtering modes that are supported by pixi.
      *
-     * The {@link PIXI.BaseTexture.defaultOptions.mipmap} affects default texture filtering.
+     * The {@link PIXI.BaseTexture.defaultOptions.mipmap | `PIXI.BaseTexture.defaultOptions.mipmap`} affects default texture filtering.
      * Mipmaps are generated for a baseTexture if its `mipmap` field is `ON`,
      * or its `POW2` and texture dimensions are powers of 2.
      * Since WebGL 1 don't support mipmap for non-power-of-two textures,
@@ -736,7 +736,7 @@ declare global {
     /**
      * The scale modes that are supported by pixi.
      *
-     * The {@link PIXI.BaseTexture.defaultOptions.scaleMode} scale mode affects the default scaling mode of future operations.
+     * The {@link PIXI.BaseTexture.defaultOptions.scaleMode | `PIXI.BaseTexture.defaultOptions.scaleMode`} scale mode affects the default scaling mode of future operations.
      * It can be re-assigned to either LINEAR or NEAREST, depending upon suitability.
      */
     const SCALE_MODES: {
@@ -902,24 +902,24 @@ declare global {
 
     /**
      * Represents the update priorities used by internal PIXI classes when registered with
-     * the {@link PIXI.Ticker} object. Higher priority items are updated first and lower
+     * the {@link PIXI.Ticker | `PIXI.Ticker`} object. Higher priority items are updated first and lower
      * priority items, such as render, should go later.
      * @remarks Includes Foundry's additions of `OBJECTS`, `PRIMARY`, and `PERCEPTION`
      */
     const UPDATE_PRIORITY: {
-      /** Highest priority used for interaction events in {@link PIXI.EventSystem} */
+      /** Highest priority used for interaction events in {@link PIXI.EventSystem | `PIXI.EventSystem`} */
       INTERACTION: 50 & UPDATE_PRIORITY;
 
-      /** High priority updating, used by {@link PIXI.AnimatedSprite} */
+      /** High priority updating, used by {@link PIXI.AnimatedSprite | `PIXI.AnimatedSprite`} */
       HIGH: 25 & UPDATE_PRIORITY;
 
-      /** Default priority for ticker events, see {@link PIXI.Ticker#add}. */
+      /** Default priority for ticker events, see {@link PIXI.Ticker.add | `PIXI.Ticker#add`}. */
       NORMAL: 0 & UPDATE_PRIORITY;
 
-      /** Low priority used for {@link PIXI.Application} rendering. */
+      /** Low priority used for {@link PIXI.Application | `PIXI.Application`} rendering. */
       LOW: 25 & UPDATE_PRIORITY;
 
-      /** Lowest priority used for {@link PIXI.BasePrepare} utility. */
+      /** Lowest priority used for {@link PIXI.BasePrepare | `PIXI.BasePrepare`} utility. */
       UTILITY: 50 & UPDATE_PRIORITY;
 
       /** @remarks Foundry addition, defined as `HIGH - 2` */
@@ -973,42 +973,42 @@ declare global {
 
     namespace BatchGeometry {
       interface Any extends AnyPIXIBatchGeometry {}
-      type AnyConstructor = typeof AnyPIXIBatchGeometry;
+      interface AnyConstructor extends Identity<typeof AnyPIXIBatchGeometry> {}
     }
 
     export import BatchRenderer = _PIXI.BatchRenderer;
 
     namespace BatchRenderer {
       interface Any extends AnyPIXIBatchRenderer {}
-      type AnyConstructor = typeof AnyPIXIBatchRenderer;
+      interface AnyConstructor extends Identity<typeof AnyPIXIBatchRenderer> {}
     }
 
     export import Container = _PIXI.Container;
 
     namespace Container {
       interface Any extends AnyPIXIContainer {}
-      type AnyConstructor = typeof AnyPIXIContainer;
+      interface AnyConstructor extends Identity<typeof AnyPIXIContainer> {}
     }
 
     export import DisplayObject = _PIXI.DisplayObject;
 
     namespace DisplayObject {
       interface Any extends AnyPIXIDisplayObject {}
-      type AnyConstructor = typeof AnyPIXIDisplayObject;
+      interface AnyConstructor extends Identity<typeof AnyPIXIDisplayObject> {}
     }
 
     export import Filter = _PIXI.Filter;
 
     namespace Filter {
       interface Any extends AnyPIXIFilter {}
-      type AnyConstructor = typeof AnyPIXIFilter;
+      interface AnyConstructor extends Identity<typeof AnyPIXIFilter> {}
     }
 
     export import Shader = _PIXI.Shader;
 
     namespace Shader {
       interface Any extends AnyPIXIShader {}
-      type AnyConstructor = typeof AnyPIXIShader;
+      interface AnyConstructor extends Identity<typeof AnyPIXIShader> {}
     }
   }
 }
@@ -1019,7 +1019,7 @@ declare module "@pixi/events" {
      * The angle in radians of a pointer or stylus measuring the vertical angle between
      * the device's surface to the pointer or stylus.
      * A stylus at 0 degrees would be directly parallel whereas at π/2 degrees it would be perpendicular.
-     * @see https://developer.mozilla.org/docs/Web/API/PointerEvent/altitudeAngle)
+     * @see {@link https://developer.mozilla.org/docs/Web/API/PointerEvent/altitudeAngle}
      */
     altitudeAngle: number;
 
@@ -1027,7 +1027,7 @@ declare module "@pixi/events" {
      * The angle in radians of a pointer or stylus measuring an arc from the X axis of the device to
      * the pointer or stylus projected onto the screen's plane.
      * A stylus at 0 degrees would be pointing to the "0 o'clock" whereas at π/2 degrees it would be pointing at "6 o'clock".
-     * @see https://developer.mozilla.org/docs/Web/API/PointerEvent/azimuthAngle)
+     * @see {@link https://developer.mozilla.org/docs/Web/API/PointerEvent/azimuthAngle}
      */
     azimuthAngle: number;
   }
@@ -1078,25 +1078,25 @@ declare module "pixi.js" {
 }
 
 declare abstract class AnyPIXIBatchGeometry extends PIXI.BatchGeometry {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }
 
 declare abstract class AnyPIXIBatchRenderer extends PIXI.BatchRenderer {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }
 
 declare abstract class AnyPIXIContainer extends PIXI.Container {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }
 
 declare abstract class AnyPIXIDisplayObject extends PIXI.DisplayObject {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }
 
 declare abstract class AnyPIXIFilter extends PIXI.Filter {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }
 
 declare abstract class AnyPIXIShader extends PIXI.Shader {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }