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

package/src/foundry/client/pixi/perception/clockwise-sweep.d.mts

@@ -1,12 +1,15 @@
+import type { IntentionalPartial } from "fvtt-types/utils";
 import type Edge from "../../../client-esm/canvas/edges/edge.d.mts";
 
 declare global {
-  type VertexMap = Map<number, foundry.canvas.edges.PolygonVertex>;
-
-  type EdgeSet = Set<Edge>;
-
   interface PolygonRay extends Ray {
-    result: foundry.canvas.edges.CollisionResult;
+    /**
+     * @remarks Only set in `ClockwiseSweepPolygon#_switchEdge` and only consumed in `#visualize`,
+     * despite unrelated method(s) having parameters claiming to want a `PolygonRay`
+     *
+     * Tested for truthiness in `#visualize` before use, so a nullish value is fine but never attains in core
+     */
+    result?: foundry.canvas.edges.CollisionResult | undefined | null;
   }
 
   /**
@@ -15,15 +18,21 @@ declare global {
    * This algorithm was created with valuable contributions from https://github.com/caewok
    */
   class ClockwiseSweepPolygon extends PointSourcePolygon {
+    // This does not appear in Foundry code, it's a necessary type override
+    static override create(origin: Canvas.Point, config: PointSourcePolygon.Config): ClockwiseSweepPolygon;
+
+    // This does not appear in foundry code, it's a necessary type override
+    override config: ClockwiseSweepPolygon.StoredConfig;
+
     /**
      * A mapping of vertices which define potential collision points
      */
-    vertices: VertexMap;
+    vertices: Map<number, foundry.canvas.edges.PolygonVertex>;
 
     /**
      * The set of edges which define potential boundaries of the polygon
      */
-    edges: EdgeSet;
+    edges: Set<Edge>;
 
     /**
      * A collection of rays which are fired at vertices
@@ -31,7 +40,7 @@ declare global {
     // @ts-expect-error Getter/setter routine is deprecated functionality as of v11, removed in v13
     rays: PolygonRay[];
 
-    override initialize(origin: Canvas.Point, config: PointSourcePolygonConfig): void;
+    override initialize(origin: Canvas.Point, config?: PointSourcePolygon.Config): void;
 
     clone(): this;
 
@@ -46,7 +55,7 @@ declare global {
     /**
      * Determine the edge types and their manner of inclusion for this polygon instance
      */
-    protected _determineEdgeTypes(): Record<Edge.EdgeTypes, 0 | 1 | 2>;
+    protected _determineEdgeTypes(): ClockwiseSweepPolygon.DetermineEdgesReturn;
 
     /**
      * Test whether a wall should be included in the computed polygon for a given origin and type
@@ -57,7 +66,7 @@ declare global {
      */
     protected _testEdgeInclusion(
       edge: Edge,
-      edgeTypes: Record<Edge.EdgeTypes, 0 | 1 | 2>,
+      edgeTypes: ClockwiseSweepPolygon.DetermineEdgesReturn,
       bounds: PIXI.Rectangle,
     ): boolean;
 
@@ -75,25 +84,25 @@ declare global {
     /**
      * Add additional vertices for intersections between edges.
      */
-    protected _identifyIntersections(wallEdgeMap: Map<string, Edge>): void;
+    protected _identifyIntersections(edgeMap: Map<string, Edge>): void;
 
     /**
      * Execute the sweep over wall vertices
-     * @internal
+     * @privateRemarks Foundry marked `@private`
      */
     protected _executeSweep(): void;
 
     /**
      * Determine the initial set of active edges as those which intersect with the initial ray
      * @returns A set of initially active edges
-     * @internal
+     * @privateRemarks Foundry marked `@private`
      */
-    protected _initializeActiveEdges(): EdgeSet;
+    protected _initializeActiveEdges(): Set<Edge>;
 
     /**
      * Sort vertices clockwise from the initial ray (due west).
      * @returns The array of sorted vertices
-     * @internal
+     * @privateRemarks Foundry marked `@private`
      */
     protected _sortVertices(): foundry.canvas.edges.PolygonVertex[];
 
@@ -105,11 +114,11 @@ declare global {
      * @param vertex      - The target vertex
      * @param activeEdges - The set of active edges
      * @returns Is the target vertex behind some closer edge?
-     * @internal
+     * @privateRemarks Foundry marked `@private`
      */
     protected _isVertexBehindActiveEdges(
       vertex: foundry.canvas.edges.PolygonVertex,
-      activeEdges: EdgeSet,
+      activeEdges: Set<Edge>,
     ): { isBehind: boolean; wasLimited: boolean };
 
     /**
@@ -117,12 +126,13 @@ declare global {
      * @param vertex        - The target vertex
      * @param activeEdges   - The set of active edges
      * @param hasCollinear  - Are there collinear vertices behind the target vertex?
-     * @internal
+     *                        default: `false`
+     * @privateRemarks Foundry marked `@private`
      */
     protected _determineSweepResult(
       vertex: foundry.canvas.edges.PolygonVertex,
-      activeEdges: EdgeSet,
-      hasCollinear: boolean,
+      activeEdges: Set<Edge>,
+      hasCollinear?: boolean,
     ): void;
 
     /**
@@ -134,24 +144,43 @@ declare global {
      *
      * If neither side is blocked and the ray internally collides with a non-limited edge, n skip without adding polygon
      * endpoints. Sight is unaffected before this edge, and the internal collision can be ignored.
-     * @internal
      *
      * @param result      - The pending collision result
      * @param activeEdges - The set of currently active edges
+     * @privateRemarks Foundry marked `@private`
      */
-    _switchEdge(result: foundry.canvas.edges.CollisionResult, activeEdges: EdgeSet): void;
+    protected _switchEdge(result: foundry.canvas.edges.CollisionResult, activeEdges: Set<Edge>): void;
 
     protected override _testCollision<Mode extends PointSourcePolygon.CollisionModes>(
       ray: Ray,
       mode: Mode,
     ): PointSourcePolygon.TestCollision<Mode>;
 
-    override visualize(): PIXI.Graphics | undefined;
+    override visualize(): PIXI.Graphics;
 
     /**
      * Visualize the polygon, displaying its computed area, rays, and collision points
-     * @internal
+     * @privateRemarks Foundry marked `@private`
      */
     protected _visualizeCollision(ray: Ray, collisions: foundry.canvas.edges.PolygonVertex[]): void;
   }
+
+  namespace ClockwiseSweepPolygon {
+    interface Any extends AnyClockwiseSweepPolygon {}
+    type AnyConstructor = typeof AnyClockwiseSweepPolygon;
+
+    interface StoredConfig extends PointSourcePolygon.StoredConfig {
+      /** The computed bounding box for the polygon */
+      boundingBox: PIXI.Rectangle;
+    }
+    /**
+     * @privateRemarks Foundry types this as `Record<Edge.EdgeTypes, 0 | 1 | 2>`, but some keys are mutually exclusive,
+     * and none are ever set to `0`, they're simply omitted and then tested for truthiness in `#_testEdgeInclusion`
+     */
+    type DetermineEdgesReturn = IntentionalPartial<Record<Edge.EdgeTypes, 1 | 2>>;
+  }
+}
+
+declare abstract class AnyClockwiseSweepPolygon extends ClockwiseSweepPolygon {
+  constructor(arg0: never, ...args: never[]);
 }

package/src/foundry/client/pixi/perception/detection-mode.d.mts

@@ -1,7 +1,9 @@
-import type { InexactPartial, ValueOf } from "../../../../types/utils.d.mts";
-import type { fields } from "../../../common/data/module.d.mts";
+import type { InexactPartial, ValueOf } from "fvtt-types/utils";
+import type { fields } from "../../../common/data/_module.d.mts";
 import type { TokenDetectionMode } from "../../../common/documents/_types.d.mts";
 
+type DataSchema = foundry.data.fields.DataSchema;
+
 declare global {
   namespace DetectionMode {
     interface Schema extends DataSchema {

package/src/foundry/client/pixi/perception/fog.d.mts

@@ -127,4 +127,13 @@ declare global {
      */
     get resolution(): CanvasVisibility["textureConfiguration"];
   }
+
+  namespace FogManager {
+    type Any = AnyFogManager;
+    type AnyConstructor = typeof AnyFogManager;
+  }
+}
+
+declare abstract class AnyFogManager extends FogManager {
+  constructor(arg0: never, ...args: never[]);
 }

package/src/foundry/client/pixi/perception/vision-mode.d.mts

@@ -1,5 +1,8 @@
-import type { AnyObject, InexactPartial, SimpleMerge, ValueOf } from "../../../../types/utils.d.mts";
-import type { fields } from "../../../common/data/module.d.mts";
+import type { AnyObject, InexactPartial, SimpleMerge, ValueOf } from "fvtt-types/utils";
+import type { fields } from "../../../common/data/_module.d.mts";
+import DataField = foundry.data.fields.DataField;
+
+type DataSchema = foundry.data.fields.DataSchema;
 
 declare global {
   class ShaderField<
@@ -97,10 +100,10 @@ declare global {
   }
 
   namespace ShaderField {
-    type Options = DataFieldOptions<typeof AbstractBaseShader>;
+    type Options = DataField.Options<typeof AbstractBaseShader>;
 
     type DefaultOptions = SimpleMerge<
-      foundry.data.fields.DataField.DefaultOptions,
+      DataField.DefaultOptions,
       {
         nullable: true;
         initial: undefined;

package/src/foundry/client/pixi/perception/weiler-atherton-clipping.d.mts

@@ -1,5 +1,4 @@
-import type { Brand } from "../../../../types/helperTypes.d.mts";
-import type { NullishProps } from "../../../../types/utils.d.mts";
+import type { Brand, NullishProps } from "fvtt-types/utils";
 
 declare global {
   /**
@@ -16,6 +15,9 @@ declare global {
    * https://en.wikipedia.org/wiki/Weiler%E2%80%93Atherton_clipping_algorithm
    * https://www.geeksforgeeks.org/weiler-atherton-polygon-clipping-algorithm
    * https://h-educate.in/weiler-atherton-polygon-clipping-algorithm/
+   *
+   * @throws If `!Polygon.isPositive`
+   * @remarks In practice the only thing that uses the constructor is the class's static methods
    */
   class WeilerAthertonClipper {
     /**
@@ -38,14 +40,12 @@ declare global {
      * The supported clip types.
      * Values are equivalent to those in ClipperLib.ClipType.
      */
-    static CLIP_TYPES: Readonly<Record<"INTERSECT" | "UNION", WeilerAthertonClipper.CLIP_TYPES>>;
+    static CLIP_TYPES: WeilerAthertonClipper.ClipTypes;
 
     /**
      * The supported intersection types.
      */
-    static INTERSECTION_TYPES: Readonly<
-      Record<"OUT_IN" | "IN_OUT" | "TANGENT", WeilerAthertonClipper.INTERSECTION_TYPES>
-    >;
+    static INTERSECTION_TYPES: WeilerAthertonClipper.IntersectionTypes;
 
     polygon: PIXI.Polygon;
 
@@ -53,14 +53,8 @@ declare global {
 
     /**
      * Configuration settings
-     * @param clipType  - One of CLIP_TYPES (default: `WeilerAthertonClipper.CLIP_TYPES.INTERSECT`)
-     * @param clipOpts  - Object passed to the clippingObject methods toPolygon and pointsBetween
-     *                    (default: `{}`)
      */
-    config: {
-      clipType: WeilerAthertonClipper.CLIP_TYPES;
-      clipOpts: WeilerAthertonClipper.ClipOpts;
-    };
+    config: WeilerAthertonClipper.Config;
 
     /**
      * Union a polygon and clipObject using the Weiler Atherton algorithm.
@@ -127,13 +121,47 @@ declare global {
   }
 
   namespace WeilerAthertonClipper {
+    interface Any extends AnyWeilerAthertonClipper {}
     type AnyConstructor = typeof AnyWeilerAthertonClipper;
 
     type CLIP_TYPES = Brand<number, "WeilerAthertonClipper.CLIP_TYPES">;
 
+    interface ClipTypes {
+      readonly INTERSECT: 0 & CLIP_TYPES;
+      readonly UNION: 1 & CLIP_TYPES;
+    }
+
     type INTERSECTION_TYPES = Brand<number, "WeilerAthertonClipper.INTERSECTION_TYPES">;
 
-    /** @internal Helper type to simplify use of optionality- and nullish-permissiveness-modifying helpers */
+    interface IntersectionTypes {
+      readonly OUT_IN: -1 & INTERSECTION_TYPES;
+      readonly IN_OUT: 1 & INTERSECTION_TYPES;
+      readonly TANGENT: 0 & INTERSECTION_TYPES;
+    }
+
+    /** Configuration settings */
+    interface Config {
+      /**
+       * One of CLIP_TYPES
+       * @defaultValue `WeilerAthertonClipper.CLIP_TYPES.INTERSECT`
+       * @remarks Set to the value of the equivalent constructor parameter. Default provided by `??=` in the constructor body
+       */
+      clipType: WeilerAthertonClipper.CLIP_TYPES;
+
+      /**
+       * Object passed to the clippingObject methods `toPolygon` and `pointsBetween`
+       * @defaultValue `{}`
+       * @remarks Set to the value of the equivalent constructor parameter. Default provided by `??=` in the constructor body
+       */
+      clipOpts: WeilerAthertonClipper.ClipOpts;
+    }
+
+    /**
+     * @internal
+     * @privateRemarks does *not* contain:
+     * - a `scalingFactor` property, despite one being passed in `PIXI.Rectangle#intersectPolygon` in v12
+     * - a `density` property, despite one being passed in `PIXI.Circle#intersectPolygon` in v12
+     */
     type _CombineOptions = NullishProps<{
       /**
        * If the WeilerAtherton constructor could mutate or not the subject polygon points

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

@@ -1,7 +1,6 @@
-import type { MakeConform } from "../../../types/helperTypes.d.mts";
-import type { ValueOf } from "../../../types/utils.d.mts";
+import type { MakeConform, ValueOf } from "fvtt-types/utils";
 import type ApplicationV2 from "../../client-esm/applications/api/application.d.mts";
-import type { Document } from "../../common/abstract/module.d.mts";
+import type { Document } from "../../common/abstract/_module.d.mts";
 
 // Gets a key with a required shape to conform to which is also used as a fallback when the key doesn't exist.
 type GetKeyWithShape<T, K, S> = K extends keyof T ? MakeConform<T[K], S> : S;
@@ -350,10 +349,7 @@ declare global {
      * @param action - The named action being attempted
      * @returns Does the User have rights to perform the action?
      */
-    can(
-      user: User.ConfiguredInstance,
-      action: "HUD" | "configure" | "control" | "view" | "create" | "drag" | "hover" | "update" | "delete" | string,
-    ): boolean;
+    can(user: User.ConfiguredInstance, action: PlaceableObject.Action): boolean;
 
     /**
      * Can the User access the HUD for this Placeable Object?
@@ -609,6 +605,18 @@ declare global {
        */
       hoverOutOthers: boolean;
     }
+
+    type Action =
+      | "HUD"
+      | "configure"
+      | "control"
+      | "view"
+      | "create"
+      | "drag"
+      | "hover"
+      | "update"
+      | "delete"
+      | (string & {});
   }
 }
 

package/src/foundry/client/pixi/placeables/drawing.d.mts

@@ -1,10 +1,10 @@
-import type { ValueOf } from "../../../../types/utils.d.mts";
+import type { ValueOf, FixedInstanceType } from "fvtt-types/utils";
 import type { ConfiguredObjectClassOrDefault } from "../../config.d.mts";
 
 declare global {
   namespace Drawing {
     type ConfiguredClass = ConfiguredObjectClassOrDefault<typeof Drawing>;
-    type ConfiguredInstance = InstanceType<ConfiguredClass>;
+    type ConfiguredInstance = FixedInstanceType<ConfiguredClass>;
 
     interface RenderFlags extends PlaceableObject.RenderFlags {
       refreshShape: boolean;
@@ -72,25 +72,25 @@ declare global {
 
     static override RENDER_FLAGS: {
       /** @defaultValue `{ propagate: ["refresh"] }` */
-      redraw: RenderFlag<Partial<Drawing.RenderFlags>>;
+      redraw: RenderFlag<Drawing.RenderFlags>;
 
       /** @defaultValue `{ propagate: ["refreshState", "refreshShape"], alias: true }` */
-      refresh: RenderFlag<Partial<Drawing.RenderFlags>>;
+      refresh: RenderFlag<Drawing.RenderFlags>;
 
       /** @defaultValue `{ propagate: ["refreshFrame"] }` */
-      refreshState: RenderFlag<Partial<Drawing.RenderFlags>>;
+      refreshState: RenderFlag<Drawing.RenderFlags>;
 
       /** @defaultValue `{ propagate: ["refreshFrame", "refreshText", "refreshMesh"] }` */
-      refreshShape: RenderFlag<Partial<Drawing.RenderFlags>>;
+      refreshShape: RenderFlag<Drawing.RenderFlags>;
 
       /** @defaultValue `{}` */
-      refreshFrame: RenderFlag<Partial<Drawing.RenderFlags>>;
+      refreshFrame: RenderFlag<Drawing.RenderFlags>;
 
       /** @defaultValue `{}` */
-      refreshText: RenderFlag<Partial<Drawing.RenderFlags>>;
+      refreshText: RenderFlag<Drawing.RenderFlags>;
 
       /** @defaultValue `{}` */
-      refreshMesh: RenderFlag<Partial<Drawing.RenderFlags>>;
+      refreshMesh: RenderFlag<Drawing.RenderFlags>;
     };
 
     /**
@@ -214,6 +214,7 @@ declare global {
 
     protected override _onDragLeftMove(event: PIXI.FederatedEvent): void;
 
+    // eslint-disable-next-line @typescript-eslint/no-misused-promises
     protected override _onDragLeftDrop(event: PIXI.FederatedEvent): Promise<unknown>;
 
     protected override _onDragLeftCancel(event: PIXI.FederatedEvent): void;

package/src/foundry/client/pixi/placeables/index.d.mts

@@ -2,6 +2,7 @@ import "./drawing.d.mts";
 import "./light.d.mts";
 import "./note.d.mts";
 import "./primary-canvas-objects/index.d.mts";
+import "./region.d.mts";
 import "./sound.d.mts";
 import "./template.d.mts";
 import "./tile.d.mts";

package/src/foundry/client/pixi/placeables/light.d.mts

@@ -1,4 +1,5 @@
 import type { ConfiguredObjectClassOrDefault } from "../../config.d.mts";
+import type { FixedInstanceType } from "fvtt-types/utils";
 
 // TODO: Remove when the whole class is updated
 type LightSource = unknown;
@@ -6,7 +7,7 @@ type LightSource = unknown;
 declare global {
   namespace AmbientLight {
     type ConfiguredClass = ConfiguredObjectClassOrDefault<typeof AmbientLight>;
-    type ConfiguredInstance = InstanceType<ConfiguredClass>;
+    type ConfiguredInstance = FixedInstanceType<ConfiguredClass>;
 
     interface RenderFlags extends PlaceableObject.RenderFlags {
       refreshField: boolean;
@@ -38,19 +39,19 @@ declare global {
 
     static override RENDER_FLAGS: {
       /** @defaultValue `{ propagate: ["refresh"] }` */
-      redraw: RenderFlag<Partial<AmbientLight.RenderFlags>>;
+      redraw: RenderFlag<AmbientLight.RenderFlags>;
 
       /** @defaultValue `{ propagate: ["refreshField"], alias: true }` */
-      refresh: RenderFlag<Partial<AmbientLight.RenderFlags>>;
+      refresh: RenderFlag<AmbientLight.RenderFlags>;
 
       /** @defaultValue `{ propagate: ["refreshPosition", "refreshState"] }` */
-      refreshField: RenderFlag<Partial<AmbientLight.RenderFlags>>;
+      refreshField: RenderFlag<AmbientLight.RenderFlags>;
 
       /** @defaultValue `{}` */
-      refreshPosition: RenderFlag<Partial<AmbientLight.RenderFlags>>;
+      refreshPosition: RenderFlag<AmbientLight.RenderFlags>;
 
       /** @defaultValue `{}` */
-      refreshState: RenderFlag<Partial<AmbientLight.RenderFlags>>;
+      refreshState: RenderFlag<AmbientLight.RenderFlags>;
     };
 
     override get bounds(): PIXI.Rectangle;
@@ -129,6 +130,7 @@ declare global {
 
     protected override _canConfigure(user: User.ConfiguredInstance, event?: any): boolean;
 
+    // eslint-disable-next-line @typescript-eslint/no-misused-promises
     protected override _onClickRight(event: PIXI.FederatedEvent): Promise<this>;
 
     protected override _onDragLeftStart(event: PIXI.FederatedEvent): void;

package/src/foundry/client/pixi/placeables/note.d.mts

@@ -1,9 +1,10 @@
 import type { ConfiguredObjectClassOrDefault } from "../../config.d.mts";
+import type { FixedInstanceType } from "fvtt-types/utils";
 
 declare global {
   namespace Note {
     type ConfiguredClass = ConfiguredObjectClassOrDefault<typeof Note>;
-    type ConfiguredInstance = InstanceType<ConfiguredClass>;
+    type ConfiguredInstance = FixedInstanceType<ConfiguredClass>;
 
     interface RenderFlags extends PlaceableObject.RenderFlags {
       refreshPosition: boolean;
@@ -25,22 +26,22 @@ declare global {
 
     static override RENDER_FLAGS: {
       /** @defaultValue `{ propagate: ["refresh"] }` */
-      redraw: RenderFlag<Partial<Note.RenderFlags>>;
+      redraw: RenderFlag<Note.RenderFlags>;
 
       /** @defaultValue `{ propagate: ["refreshState", "refreshPosition", "refreshText"], alias: true }` */
-      refresh: RenderFlag<Partial<Note.RenderFlags>>;
+      refresh: RenderFlag<Note.RenderFlags>;
 
       /** @defaultValue `{ propagate: ["refreshVisibility"] }` */
-      refreshPosition: RenderFlag<Partial<Note.RenderFlags>>;
+      refreshPosition: RenderFlag<Note.RenderFlags>;
 
       /** @defaultValue `{ propagate: ["refreshVisibility"] }` */
-      refreshState: RenderFlag<Partial<Note.RenderFlags>>;
+      refreshState: RenderFlag<Note.RenderFlags>;
 
       /** @defaultValue `{}` */
-      refreshVisibility: RenderFlag<Partial<Note.RenderFlags>>;
+      refreshVisibility: RenderFlag<Note.RenderFlags>;
 
       /** @defaultValue `{}` */
-      refreshText: RenderFlag<Partial<Note.RenderFlags>>;
+      refreshText: RenderFlag<Note.RenderFlags>;
     };
 
     override get bounds(): PIXI.Rectangle;

package/src/foundry/client/pixi/placeables/primary-canvas-objects/primary-canvas-object.d.mts

@@ -1,16 +1,25 @@
-import type { Mixin } from "../../../../../types/utils.d.mts";
+import type { FixedInstanceType, Mixin } from "fvtt-types/utils";
 import type Document from "../../../../common/abstract/document.d.mts";
 
 declare class PrimaryCanvasObject {
   /** @privateRemarks All mixin classses should accept anything for its constructor. */
   constructor(...args: any[]);
 
+  /**
+   * @defaultValue `true`
+   * @privateRemarks Actually an override of the property on `PIXI.DisplayObject`
+   */
+  cullable: boolean;
+
   /**
    * An optional reference to the object that owns this PCO.
    * This property does not affect the behavior of the PCO itself.
    * @defaultValue `null`
+   * @privateRemarks Foundry types as `*`, but in practice, it will only ever be a `Drawing` (via `PrimaryGraphics`),
+   * or a `Token`, `Tile`, or the `PrimaryCanvasGroup` (via `PrimarySpriteMesh`), or its default value `null`
    */
-  object: PlaceableObject | null;
+  //TODO: (esheyw) Revisit the "any canvas group" type when groups are done
+  object: PlaceableObject.Any | CanvasGroupMixin.AnyMixed | null;
 
   /**
    * The elevation of this object.
@@ -44,6 +53,7 @@ declare class PrimaryCanvasObject {
   /**
    * Event fired when this display object is added to a parent.
    * @param parent - The new parent container.
+   * @throws If `parent` is not `=== canvas.primary`
    */
   protected _onAdded(parent: PIXI.Container): void;
 
@@ -53,9 +63,11 @@ declare class PrimaryCanvasObject {
    */
   protected _onRemoved(parent: PIXI.Container): void;
 
+  /** @see {@link CanvasTransformMixinClass#updateCanvasTransform} */
   updateCanvasTransform(): void;
 
-  _onCanvasBoundsUpdate(): void;
+  /** @see {@link CanvasTransformMixinClass#_onCanvasBoundsUpdate} */
+  protected _onCanvasBoundsUpdate(): void;
 
   /**
    * Does this object render to the depth buffer?
@@ -65,7 +77,7 @@ declare class PrimaryCanvasObject {
   /**
    * Does this object render to the depth buffer?
    */
-  _shouldRenderDepth(): boolean;
+  protected _shouldRenderDepth(): boolean;
 
   /**
    * Render the depth of this object.
@@ -102,6 +114,7 @@ declare class CanvasTransformMixinClass {
 
   /**
    * The update ID of canvas transform matrix.
+   * @privateRemarks Foundry marked `@internal`, technically accessed externally via `this.parent._convasTranformID` in `updateCanvasTransform`
    */
   protected _canvasTransformID: number;
 
@@ -153,25 +166,33 @@ declare global {
    * A mixin which decorates a DisplayObject with additional properties expected for rendering in the PrimaryCanvasGroup.
    * @param DisplayObject - The parent DisplayObject class being mixed
    * @returns A DisplayObject subclass mixed with PrimaryCanvasObject features
+   * @privateRemarks Despite naming the argument "DisplayObject", it's typed as only taking `PIXI.Container`s, which matches core's usage
    */
-  function PrimaryCanvasObjectMixin<BaseClass extends PIXI.DisplayObject.AnyConstructor>(
+  function PrimaryCanvasObjectMixin<BaseClass extends PrimaryCanvasObjectMixin.BaseClass>(
     DisplayObject: BaseClass,
   ): Mixin<typeof PrimaryCanvasObject, ReturnType<typeof CanvasTransformMixin<BaseClass>>>;
 
   namespace PrimaryCanvasObjectMixin {
-    type MixinClass = typeof PrimaryCanvasObject;
+    type AnyMixedConstructor = ReturnType<typeof PrimaryCanvasObjectMixin<PrimaryCanvasObjectMixin.BaseClass>>;
+    interface AnyMixed extends FixedInstanceType<AnyMixedConstructor> {}
+
+    type BaseClass = PIXI.Container.AnyConstructor;
   }
 
   /**
    * A mixin which decorates a DisplayObject with additional properties for canvas transforms and bounds.
    * @param DisplayObject - The parent DisplayObject class being mixed
    * @returns A DisplayObject subclass mixed with CanvasTransformMixin features
+   * @privateRemarks Despite naming the argument "DisplayObject", it's typed as only taking `PIXI.Container`s, which matches core's usage
    */
-  function CanvasTransformMixin<BaseClass extends PIXI.DisplayObject.AnyConstructor>(
+  function CanvasTransformMixin<BaseClass extends CanvasTransformMixin.BaseClass>(
     DisplayObject: BaseClass,
   ): Mixin<typeof CanvasTransformMixinClass, BaseClass>;
 
   namespace CanvasTransformMixin {
-    type MixinClass = typeof CanvasTransformMixinClass;
+    type AnyMixedConstructor = ReturnType<typeof CanvasTransformMixin<CanvasTransformMixin.BaseClass>>;
+    interface AnyMixed extends FixedInstanceType<AnyMixedConstructor> {}
+
+    type BaseClass = PIXI.Container.AnyConstructor;
   }
 }