@league-of-foundry-developers/foundry-vtt-types 12.331.3-beta → 12.331.4-beta

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

@@ -1,12 +1,8 @@
-import type { InexactPartial, NullishProps } from "../../../types/utils.d.mts";
-import type Document from "../../common/abstract/document.d.mts";
+import type { InexactPartial, NullishProps, FixedInstanceType } from "fvtt-types/utils";
 import type { CANVAS_PERFORMANCE_MODES } from "../../common/constants.d.mts";
 
-type InternalCanvas = new (
-  arg0: never,
-  ...args: never[]
-) => {
-  readonly [K in keyof CONFIG.Canvas.Groups]?: InstanceType<CONFIG.Canvas.Groups[K]["groupClass"]> | undefined;
+type InternalCanvas = new (...args: never) => {
+  readonly [K in keyof CONFIG.Canvas.Groups]?: FixedInstanceType<CONFIG.Canvas.Groups[K]["groupClass"]> | undefined;
 };
 
 declare const _InternalCanvas: InternalCanvas;
@@ -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?
@@ -167,7 +163,7 @@ declare global {
     /**
      * The singleton FogManager instance.
      */
-    fog: FogManager;
+    fog: FixedInstanceType<typeof CONFIG.Canvas.fogManager>;
 
     /**
      * A perception manager interface for batching lighting, sight, and sound updates
@@ -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
@@ -444,6 +440,8 @@ declare global {
 
     readonly notes?: NotesLayer;
 
+    readonly regions?: RegionLayer;
+
     readonly controls?: ControlsLayer;
 
     /**
@@ -528,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.
@@ -586,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.
@@ -650,8 +635,8 @@ declare global {
      * Track objects which have pending render flags.
      */
     readonly pendingRenderFlags: {
-      OBJECTS: Set<InstanceType<ReturnType<typeof RenderFlagsMixin>>>;
-      PERCEPTION: Set<InstanceType<ReturnType<typeof RenderFlagsMixin>>>;
+      OBJECTS: Set<FixedInstanceType<ReturnType<typeof RenderFlagsMixin>>>;
+      PERCEPTION: Set<FixedInstanceType<ReturnType<typeof RenderFlagsMixin>>>;
     };
 
     /**
@@ -681,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;
 
@@ -776,8 +719,12 @@ declare global {
     /**
      * A single point, expressed as an array \[x,y\]
      * @remarks Copied from `resources/app/common/types.mjs`
+     *
+     * Renamed from `PointArray` to avoid confusion (for `[{x,y},{x,y}]` for example)
      */
-    type PointArray = [x: number, y: number];
+    type PointTuple = [x: number, y: number];
+
+    type PairOfPointsTuple = [x0: number, y0: number, x1: number, y1: number];
 
     /**
      * A standard rectangle interface.
@@ -789,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,22 +1,39 @@
-import type { AnyObject, Mixin } from "../../../../../types/utils.d.mts";
+import type { FixedInstanceType, HandleEmptyObject, PrettifyType, RemoveIndexSignatures } from "fvtt-types/utils";
 
-declare class CanvasGroup {
-  /** @privateRemarks All mixin classses should accept anything for its constructor. */
-  constructor(...args: any[]);
+declare const DynamicClass: new <_Computed extends object>(...args: never) => _Computed;
 
-  /** @defaultValue `true` */
-  sortableChildren: boolean;
+// @ts-expect-error - This is a workaround to allow for dynamic top level properties in a class.
+declare class LayersClass<
+  Group extends CanvasGroupMixin.LayerGroup | NoLayerGroup,
+  Instance extends object = RemoveIndexSignatures<CanvasGroupMixin.LayersFor<Group>>,
+> extends DynamicClass<Instance> {}
 
+// Note(LukeAbby): This interface has been separated out to simplify the constructor edge cases.
+// By avoiding having the instance side it makes the class more malleable and allows generics.
+interface CanvasGroupStatic<Group extends CanvasGroupMixin.LayerGroup | NoLayerGroup> {
   /**
    * The name of this canvas group
    * @remarks Foundry marked as abstract
    */
-  static groupName: string;
+  groupName: Group extends NoLayerGroup ? undefined : Group;
 
   /**
    * If this canvas group should teardown non-layers children.
+   * @defaultValue `true`
    */
-  static tearDownChildren: boolean;
+  tearDownChildren: boolean;
+}
+
+declare class CanvasGroup<
+  Group extends CanvasGroupMixin.LayerGroup | NoLayerGroup,
+  DrawOptions extends CanvasGroupMixin.DrawOptions = CanvasGroupMixin.DrawOptions,
+  TearDownOptions extends CanvasGroupMixin.TearDownOptions = CanvasGroupMixin.TearDownOptions,
+> extends LayersClass<Group> {
+  /** @privateRemarks All mixin classses should accept anything for its constructor. */
+  constructor(...args: any[]);
+
+  /** @defaultValue `true` */
+  sortableChildren: boolean;
 
   /**
    * The canonical name of the canvas group is the name of the constructor that is the immediate child of the defined base class.
@@ -31,53 +48,108 @@ declare class CanvasGroup {
 
   /**
    * A mapping of CanvasLayer classes which belong to this group.
-   * @remarks Default value defined by this._createLayers, which pulls from CONFIG.Canvas.layers
+   * @remarks Default value defined by this._createLayers, which is called in the constructor, and   pulls from CONFIG.Canvas.layers
    */
-  layers: Record<string, CanvasLayer>;
+  layers: CanvasGroupMixin.LayersFor<Group>;
 
   /**
    * Create CanvasLayer instances which belong to the canvas group.
    */
-  _createLayers(): Record<string, CanvasLayer>;
+  protected _createLayers(): CanvasGroupMixin.LayersFor<Group>;
 
   /** Draw the canvas group and all its component layers. */
-  draw(options: CanvasGroupMixin.DrawOptions): Promise<void>;
+  draw(options?: HandleEmptyObject<DrawOptions>): Promise<this>;
 
   /**
    * Draw the canvas group and all its component layers.
    */
-  protected _draw(options: CanvasGroupMixin.DrawOptions): Promise<void>;
+  protected _draw(options?: HandleEmptyObject<DrawOptions>): Promise<void>;
 
   /**
    * Remove and destroy all layers from the base canvas.
    */
-  tearDown(options: CanvasGroupMixin.TearDownOptions): Promise<void>;
+  tearDown(options: HandleEmptyObject<TearDownOptions>): Promise<this>;
 
   /**
    * Remove and destroy all layers from the base canvas.
    */
-  protected _tearDown(options: CanvasGroupMixin.TearDownOptions): Promise<void>;
+  protected _tearDown(options: HandleEmptyObject<TearDownOptions>): Promise<void>;
 }
 
+declare const _NoLayerGroup: unique symbol;
+type NoLayerGroup = typeof _NoLayerGroup;
+
+type ApplyGroup<
+  BaseClass extends CanvasGroupMixin.BaseClass,
+  Group extends CanvasGroupMixin.LayerGroup | NoLayerGroup,
+> = CanvasGroupStatic<Group> &
+  (new <DrawOptions extends CanvasGroupMixin.DrawOptions, TearDownOptions extends CanvasGroupMixin.TearDownOptions>(
+    ...args: ConstructorParameters<BaseClass>
+  ) => CanvasGroup<Group, DrawOptions, TearDownOptions> & FixedInstanceType<BaseClass>);
+
 declare global {
   /**
    * A mixin which decorates any container with base canvas common properties.
    * @param ContainerClass - The parent Container class being mixed.
    * @returns A ContainerClass subclass mixed with BaseCanvasMixin features.
    */
-  function CanvasGroupMixin<BaseClass extends CanvasGroupMixin.BaseClass>(
-    ContainerClass: BaseClass,
-  ): Mixin<typeof CanvasGroup, BaseClass>;
+  function CanvasGroupMixin<
+    BaseClass extends CanvasGroupMixin.BaseClass,
+    // In `_createLayers` the code assigns top level properties to the class.
+    // This is why Group exists.`
+    Group extends CanvasGroupMixin.LayerGroup | NoLayerGroup = NoLayerGroup,
+  >(ContainerClass: BaseClass): CanvasGroupMixin.Mixed<BaseClass, Group>;
 
-  namespace CanvasGroupMixin {
-    type BaseClass = typeof AnyPIXIContainer;
-
-    type DrawOptions = AnyObject;
+  /**
+   * @deprecated since v12, until 14
+   * @remarks "BaseCanvasMixin is deprecated in favor of CanvasGroupMixin"
+   */
+  const BaseCanvasMixin: typeof CanvasGroupMixin;
 
-    type TearDownOptions = AnyObject;
+  namespace CanvasGroupMixin {
+    interface AnyMixedConstructor
+      extends ReturnType<
+        typeof CanvasGroupMixin<CanvasGroupMixin.BaseClass, CanvasGroupMixin.LayerGroup | NoLayerGroup>
+      > {}
+    interface AnyMixed extends FixedInstanceType<AnyMixedConstructor> {}
+
+    type BaseClass = PIXI.Container.AnyConstructor;
+
+    type Mixed<
+      BaseClass extends CanvasGroupMixin.BaseClass,
+      Group extends CanvasGroupMixin.LayerGroup | NoLayerGroup,
+    > = BaseClass & ApplyGroup<BaseClass, Group>;
+
+    // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+    interface DrawOptions {}
+
+    // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+    interface TearDownOptions {}
+
+    interface Layers {
+      readonly [key: string]: CanvasLayer;
+    }
+
+    type LayerGroup = keyof CONFIG["Canvas"]["groups"];
+
+    type LayersFor<T extends LayerGroup | NoLayerGroup> = PrettifyType<
+      _FilterOutNever<{
+        readonly [K in keyof typeof Canvas.layers]: (typeof Canvas.layers)[K] extends {
+          readonly layerClass?: abstract new (...args: infer _1) => infer LayerInstance extends CanvasLayer;
+          readonly group?: T;
+        }
+          ? LayerInstance
+          : never;
+      }>
+    >;
+
+    /** @internal */
+    type _FilterOutNever<T> = {
+      [K in keyof T as [T[K]] extends [never] ? never : K]: T[K];
+    };
   }
 }
 
-declare abstract class AnyPIXIContainer extends PIXI.Container<any> {
-  constructor(arg0: never, ...args: never[]);
+declare abstract class AnyCanvasGroup extends CanvasGroup<NoLayerGroup> {
+  constructor(...args: never);
 }

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

@@ -1,6 +1,4 @@
-import type { NullishProps } from "../../../../../types/utils.d.mts";
-
-export {};
+import type { Identity, NullishProps } from "fvtt-types/utils";
 
 declare global {
   /**
@@ -12,17 +10,13 @@ declare global {
      * Construct a CachedContainer.
      * @param sprite - A specific sprite to bind to this CachedContainer and its renderTexture.
      */
-    constructor(sprite: PIXI.Sprite | SpriteMesh);
+    constructor(sprite?: PIXI.Sprite | SpriteMesh);
 
     /**
      * The texture configuration to use for this cached container
-     * @remarks Foundry marked as abstract
+     * @remarks Foundry marked as `@abstract`
      */
-    static textureConfiguration: NullishProps<{
-      multisample: PIXI.MSAA_QUALITY;
-      scaleMode: PIXI.SCALE_MODES;
-      format: PIXI.FORMATS;
-    }>;
+    static textureConfiguration: CachedContainer.TextureConfiguration;
 
     /**
      * A map of render textures, linked to their render function and an optional RGBA clear color.
@@ -33,7 +27,7 @@ declare global {
      * An RGBA array used to define the clear color of the RenderTexture
      * @defaultValue `[0, 0, 0, 1]`
      */
-    clearColor: [r: number, g: number, b: number, a: number];
+    clearColor: Color.RGBAColorVector;
 
     /**
      * Should our Container also be displayed on screen, in addition to being drawn to the cached RenderTexture?
@@ -43,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;
@@ -65,10 +59,13 @@ declare global {
      */
     set alphaMode(mode: PIXI.ALPHA_MODES);
 
+    /** @remarks Foundry provides no getter, this is for accurate typing only, as without it Typescript would infer the type as `PIXI.ALPHA_MODES` */
+    get alphaMode(): undefined;
+
     /**
      * A bound Sprite which uses this container's render texture
      */
-    get sprite(): PIXI.Sprite | SpriteMesh;
+    get sprite(): PIXI.Sprite | SpriteMesh | undefined;
 
     set sprite(sprite: PIXI.Sprite | SpriteMesh);
 
@@ -85,7 +82,7 @@ declare global {
      * @param destroy - Should the render texture be destroyed?
      *                  (default: `true`)
      */
-    removeRenderTexture(renderTexture: PIXI.RenderTexture, destroy?: boolean): void;
+    removeRenderTexture(renderTexture: PIXI.RenderTexture, destroy?: boolean | null): void;
 
     /**
      * Clear the cached container, removing its current contents.
@@ -95,7 +92,7 @@ declare global {
      */
     clear(destroy?: boolean): CachedContainer | void;
 
-    override destroy(options?: boolean | PIXI.IDestroyOptions): void;
+    override destroy(options?: PIXI.IDestroyOptions | boolean): void;
 
     override render(renderer: PIXI.Renderer): void;
 
@@ -108,11 +105,32 @@ declare global {
   }
 
   namespace CachedContainer {
-    interface RenderOptions {
+    interface Any extends AnyCachedContainer {}
+    interface AnyConstructor extends Identity<typeof AnyCachedContainer> {}
+
+    /** @internal */
+    type _TextureConfiguration = NullishProps<{
+      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<{
       /** Render function that will be called to render into the RT. */
-      renderFunction?: (renderer: PIXI.Renderer) => void;
+      renderFunction: (renderer: PIXI.Renderer) => void;
+
       /** An optional clear color to clear the RT before rendering into it. */
-      clearColor?: number[];
-    }
+      clearColor: Color.RGBAColorVector;
+    }>;
+    interface RenderOptions extends _RenderOptions {}
   }
 }
+
+declare abstract class AnyCachedContainer extends CachedContainer {
+  constructor(...args: never);
+}

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

@@ -1,10 +1,10 @@
-import type { Mixin } from "../../../../../types/utils.d.mts";
+import type { FixedInstanceType, Mixin } from "fvtt-types/utils";
 
 declare class FullCanvasObject {
   /** @privateRemarks All mixin classses should accept anything for its constructor. */
   constructor(...args: any[]);
 
-  /** @remarks Overrides the mixed in class */
+  /** @remarks Overrides the mixed PIXI class's method, @see {@link PIXI.DisplayObject.calculateBounds | `PIXI.DisplayObject#calculateBounds`} */
   calculateBounds(): void;
 }
 
@@ -15,23 +15,20 @@ declare global {
    * @param Base - Any PIXI DisplayObject subclass
    * @returns The decorated subclass with full canvas bounds
    */
-  function FullCanvasObjectMixin<BaseClass extends FullCanvasObject.BaseClass>(
+  function FullCanvasObjectMixin<BaseClass extends FullCanvasObjectMixin.BaseClass>(
     Base: BaseClass,
   ): Mixin<typeof FullCanvasObject, BaseClass>;
 
-  namespace FullCanvasObject {
-    type AnyConstructor = typeof AnyFullCanvasObject;
+  namespace FullCanvasObjectMixin {
+    interface AnyMixedConstructor extends ReturnType<typeof FullCanvasObjectMixin<BaseClass>> {}
+    interface AnyMixed extends FixedInstanceType<AnyMixedConstructor> {}
 
     type BaseClass = PIXI.DisplayObject.AnyConstructor;
   }
 
   /**
    * @deprecated since v11, will be removed in v13
-   * @remarks You are using the FullCanvasContainer class which has been deprecated in favor of a more flexible FullCanvasObjectMixin which can augment any PIXI.DisplayObject subclass.
+   * @remarks "You are using the FullCanvasContainer class which has been deprecated in favor of a more flexible FullCanvasObjectMixin which can augment any PIXI.DisplayObject subclass."
    */
   class FullCanvasContainer extends FullCanvasObjectMixin(PIXI.Container) {}
 }
-
-declare abstract class AnyFullCanvasObject extends FullCanvasObject {
-  constructor(arg0: never, ...args: never[]);
-}