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

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

@@ -1,60 +1,44 @@
 import type { ConfiguredObjectClassOrDefault } from "../../config.d.mts";
-
-// TODO: Remove when the whole class is updated
-type LightSource = unknown;
+import type { FixedInstanceType, HandleEmptyObject, IntentionalPartial, NullishProps, RequiredProps } from "#utils";
+import PointDarknessSource = foundry.canvas.sources.PointDarknessSource;
+import PointLightSource = foundry.canvas.sources.PointLightSource;
 
 declare global {
-  namespace AmbientLight {
-    type ConfiguredClass = ConfiguredObjectClassOrDefault<typeof AmbientLight>;
-    type ConfiguredInstance = InstanceType<ConfiguredClass>;
-
-    interface RenderFlags extends PlaceableObject.RenderFlags {
-      refreshField: boolean;
-
-      refreshPosition: boolean;
-    }
-  }
-
   /**
    * An AmbientLight is an implementation of PlaceableObject which represents a dynamic light source within the Scene.
-   * @see {@link AmbientLightDocument}
-   * @see {@link LightingLayer}
+   * @see {@link AmbientLightDocument | `AmbientLightDocument`}
+   * @see {@link LightingLayer | `LightingLayer`}
    */
-  class AmbientLight extends PlaceableObject<AmbientLightDocument.ConfiguredInstance> {
-    constructor(document: AmbientLightDocument.ConfiguredInstance);
-
+  class AmbientLight extends PlaceableObject<AmbientLightDocument.Implementation> {
     /**
-     * A reference to the PointSource object which defines this light source area of effect
+     * The area that is affected by this light.
+     * @defaultValue `undefined`
+     * @remarks Only `undefined` prior to first draw.
      */
-    source: LightSource;
+    field: PIXI.Graphics | undefined;
 
     /**
-     * A reference to the ControlIcon used to configure this light
-     * @defaultValue `undefined`
+     * A reference to the PointSource object which defines this light or darkness area of effect.
+     * This is undefined if the AmbientLight does not provide an active source of light.
+     * @remarks This is not initialized to a value, but {@link AmbientLight._onCreate | `AmbientLight#_onCreate`}
+     * calls {@link AmbientLight.initializeLightSource | `AmbientLight#initializeLightSource`}, so it could be set immediately.
+     *
+     * Set `undefined` in {@link AmbientLight._destroy | `AmbientLight#_destroy`}.
      */
-    controlIcon: ControlIcon | undefined;
+    lightSource: PointLightSource.ConfiguredInstance | PointDarknessSource.ConfiguredInstance | undefined;
 
     static override embeddedName: "AmbientLight";
 
-    static override RENDER_FLAGS: {
-      /** @defaultValue `{ propagate: ["refresh"] }` */
-      redraw: RenderFlag<Partial<AmbientLight.RenderFlags>>;
-
-      /** @defaultValue `{ propagate: ["refreshField"], alias: true }` */
-      refresh: RenderFlag<Partial<AmbientLight.RenderFlags>>;
+    static override RENDER_FLAGS: AmbientLight.RENDER_FLAGS;
 
-      /** @defaultValue `{ propagate: ["refreshPosition", "refreshState"] }` */
-      refreshField: RenderFlag<Partial<AmbientLight.RenderFlags>>;
-
-      /** @defaultValue `{}` */
-      refreshPosition: RenderFlag<Partial<AmbientLight.RenderFlags>>;
-
-      /** @defaultValue `{}` */
-      refreshState: RenderFlag<Partial<AmbientLight.RenderFlags>>;
-    };
+    // Note: This isn't a "real" override but `renderFlags` is set corresponding to the
+    // `RENDER_FLAGS` and so it has to be adjusted here.
+    renderFlags: RenderFlags<AmbientLight.RENDER_FLAGS>;
 
     override get bounds(): PIXI.Rectangle;
 
+    override get sourceId(): string;
+
     /**
      * A convenience accessor to the LightData configuration object
      */
@@ -82,59 +66,204 @@ declare global {
 
     /**
      * Is this Ambient Light currently visible? By default, true only if the source actively emits light.
-     * @remarks Backwards-compatible wrapper for this.emitsLight
      */
     get isVisible(): boolean;
 
     /**
-     * Does this Ambient Light actively emit light given its properties and the current darkness level of the Scene?
+     * Check if the point source is a LightSource instance
+     * @remarks Checks via `instanceof` against the configured class, not simply PointLightSource
+     */
+    get isLightSource(): boolean;
+
+    /**
+     * Check if the point source is a DarknessSource instance
+     * @remarks Checks via `instanceof` against the configured class, not simply PointDarknessSource
+     */
+    get isDarknessSource(): boolean;
+
+    /**
+     * Is the source of this Ambient Light disabled?
+     */
+    protected _isLightSourceDisabled(): boolean;
+
+    /**
+     * Does this Ambient Light actively emit darkness light given its properties and the current darkness level of the Scene?
+     */
+    get emitsDarkness(): boolean;
+
+    /**
+     * Does this Ambient Light actively emit positive light given its properties and the current darkness level of the Scene?
      */
     get emitsLight(): boolean;
 
-    protected override _destroy(options?: PIXI.IDestroyOptions | boolean): void;
+    protected override _destroy(options: PIXI.IDestroyOptions | boolean | undefined): void;
+
+    protected override _draw(options: HandleEmptyObject<AmbientLight.DrawOptions>): Promise<void>;
 
-    protected override _draw(options?: Record<string, unknown>): Promise<void>;
+    // fake override; super has to account for misbehaving siblings returning void
+    override clear(): this;
 
     protected override _applyRenderFlags(flags: AmbientLight.RenderFlags): void;
 
+    /**
+     * Refresh the shape of the light field-of-effect. This is refreshed when the AmbientLight fov polygon changes.
+     */
+    protected _refreshField(): void;
+
+    /**
+     * Refresh the position of the AmbientLight. Called with the coordinates change.
+     */
+    protected _refreshPosition(): void;
+
+    /**
+     * Refresh the elevation of the control icon.
+     */
+    protected _refreshElevation(): void;
+
+    /**
+     * Refresh the state of the light. Called when the disabled state or darkness conditions change.
+     */
+    protected _refreshState(): void;
+
     /**
      * Refresh the display of the ControlIcon for this AmbientLight source
      */
     refreshControl(): void;
 
     /**
-     * Update the source object associated with this light
+     * Update the LightSource associated with this AmbientLight object.
      * @param options - Options which modify how the source is updated
      */
-    updateSource(options?: {
-      /**
-       * Defer updating perception to manually update it later
-       * @defaultValue `false`
-       */
-      defer?: boolean;
-
-      /**
-       * Indicate that this light source has been deleted
-       * @defaultValue `false`
-       */
-      deleted?: boolean;
-    }): void;
+    initializeLightSource(options?: AmbientLight.InitializeLightSourceOptions): void;
 
     /**
-     * @privateRemarks _onCreate, _onUpdate, and _onDelete are all overridden but with no signature changes.
-     * For type simplicity they are left off. These methods historically have been the source of a large amount of computation from tsc.
+     * Get the light source data.
      */
+    protected _getLightSourceData(): AmbientLight.LightSourceData;
 
-    protected override _canHUD(user: User.ConfiguredInstance, event?: any): boolean;
+    // _onCreate, _onUpdate, and _onDelete are all overridden but with no signature changes.
+    // For type simplicity they are left off. These methods historically have been the source of a large amount of computation from tsc.
 
-    protected override _canConfigure(user: User.ConfiguredInstance, event?: any): boolean;
+    protected override _canHUD(user: User.Implementation, event: PIXI.FederatedEvent): boolean;
 
-    protected override _onClickRight(event: PIXI.FederatedEvent): Promise<this>;
+    protected override _canConfigure(user: User.Implementation, event: PIXI.FederatedEvent): boolean;
 
-    protected override _onDragLeftStart(event: PIXI.FederatedEvent): void;
+    protected override _canDragLeftStart(user: User.Implementation, event: DragEvent): boolean;
+
+    // fake override to narrow the type from super, which had to account for this class's misbehaving siblings
+    // options: not null (destructured)
+    protected override _onHoverIn(event: PIXI.FederatedEvent, options?: PlaceableObject.HoverInOptions): void;
+
+    protected override _onClickRight(event: PIXI.FederatedEvent): void;
 
     protected override _onDragLeftMove(event: PIXI.FederatedEvent): void;
 
-    protected override _onDragLeftCancel(event: PIXI.FederatedEvent): void;
+    protected override _onDragEnd(): void;
+
+    // fake override to narrow the type from super, which had to account for this class's misbehaving siblings
+    protected override _prepareDragLeftDropUpdates(event: PIXI.FederatedEvent): PlaceableObject.DragLeftDropUpdate[];
+
+    /**
+     * @deprecated since v12, until v14
+     * @remarks "`AmbientLight#updateSource` has been deprecated in favor of {@link AmbientLight.initializeLightSource | `AmbientLight#initializeLightSource`}"
+     */
+    // options: not null (destructured)
+    updateSource(options?: AmbientLight.InitializeLightSourceOptions): void;
+
+    /**
+     * @deprecated since v12, until v14
+     * @remarks "`AmbientLight#source` has been deprecated in favor of {@link AmbientLight.lightSource | `AmbientLight#lightSource`}"
+     */
+    get source(): this["lightSource"];
+  }
+
+  namespace AmbientLight {
+    // eslint-disable-next-line no-restricted-syntax
+    interface ObjectClass extends ConfiguredObjectClassOrDefault<typeof AmbientLight> {}
+    interface Object extends FixedInstanceType<ObjectClass> {}
+
+    /**
+     * @deprecated {@link AmbientLight.ObjectClass | `AmbientLight.ObjectClass`}
+     */
+    type ConfiguredClass = ObjectClass;
+
+    /**
+     * @deprecated {@link AmbientLight.Object | `AmbientLight.Object`}
+     */
+    type ConfiguredInstance = Object;
+
+    /**
+     * This type will permanently exist but is marked deprecated. The reason it exists is because
+     * the confusion between `AmbientLight` (the `PlaceableObject` that appears on the canvas) and
+     * `AmbientLightDocument` (the `Document` that represents the data for a `AmbientLight`) is so common that
+     * it is useful to have a type to forward to `AmbientLightDocument`.
+     *
+     * @deprecated {@link AmbientLightDocument.Implementation | `AmbientLightDocument.Implementation`}
+     */
+    type Implementation = AmbientLightDocument.Implementation;
+
+    /**
+     * This type will permanently exist but is marked deprecated. The reason it exists is because
+     * the confusion between `AmbientLight` (the `PlaceableObject` that appears on the canvas) and
+     * `AmbientLightDocument` (the `Document` that represents the data for a `AmbientLight`) is so common that
+     * it is useful to have a type to forward to `AmbientLightDocument`.
+     *
+     * @deprecated {@link AmbientLightDocument.ImplementationClass | `AmbientLightDocument.ImplementationClass`}
+     */
+    type ImplementationClass = AmbientLightDocument.ImplementationClass;
+
+    interface RENDER_FLAGS extends PlaceableObject.RENDER_FLAGS {
+      /** @defaultValue `{ propagate: ["refresh"] }` */
+      redraw: RenderFlag<this, "redraw">;
+
+      /** @defaultValue `{ propagate: ["refreshState", "refreshField", "refreshElevation"], alias: true }` */
+      refresh: RenderFlag<this, "refresh">;
+
+      /** @defaultValue `{ propagate: ["refreshPosition"] }` */
+      refreshField: RenderFlag<this, "refreshField">;
+
+      /** @defaultValue `{}` */
+      refreshPosition: RenderFlag<this, "refreshPosition">;
+
+      /** @defaultValue `{}` */
+      refreshState: RenderFlag<this, "refreshState">;
+
+      /** @defaultValue `{}` */
+      refreshElevation: RenderFlag<this, "refreshElevation">;
+    }
+
+    interface RenderFlags extends RenderFlagsMixin.ToBooleanFlags<RENDER_FLAGS> {}
+
+    interface DrawOptions extends PlaceableObject.DrawOptions {}
+
+    interface RefreshOptions extends PlaceableObject.RefreshOptions {}
+
+    interface ControlOptions extends PlaceableObject.ControlOptions {}
+
+    interface ReleaseOptions extends PlaceableObject.ReleaseOptions {}
+
+    /**
+     * @internal */
+    type _InitializeLightSourceOptions = NullishProps<{
+      /**
+       * Indicate that this SoundSource has been deleted.
+       * @defaultValue `false`
+       */
+      deleted: boolean;
+    }>;
+
+    interface InitializeLightSourceOptions extends _InitializeLightSourceOptions {}
+
+    /**
+     * @remarks {@link AmbientLight._getLightSourceData | `AmbientLight#_getLightSourceData`} calls `mergeObject` on the return of
+     * {@link foundry.data.LightData.toObject | `LightData#toObject(false)`} and the enumerated properties below and
+     * returns the result. This gets passed to {@link foundry.canvas.sources.PointLightSource.initialize | `AmbientLight#lightSource#initialize()`},
+     * so this is a `RequiredProps<IntentionalPartial<>>` rather than a `Pick<>`
+     */
+    type LightSourceData = foundry.data.fields.SchemaField.InitializedData<foundry.data.LightData.Schema> &
+      RequiredProps<
+        IntentionalPartial<PointLightSource.SourceData>,
+        "x" | "y" | "elevation" | "rotation" | "walls" | "vision" | "dim" | "bright" | "seed" | "disabled" | "preview"
+      >;
   }
 }

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

@@ -1,69 +1,44 @@
 import type { ConfiguredObjectClassOrDefault } from "../../config.d.mts";
+import type { FixedInstanceType, HandleEmptyObject } from "#utils";
 
 declare global {
-  namespace Note {
-    type ConfiguredClass = ConfiguredObjectClassOrDefault<typeof Note>;
-    type ConfiguredInstance = InstanceType<ConfiguredClass>;
-
-    interface RenderFlags extends PlaceableObject.RenderFlags {
-      refreshPosition: boolean;
-
-      refreshVisibility: boolean;
-
-      refreshText: boolean;
-    }
-  }
-
   /**
    * A Note is an implementation of PlaceableObject which represents an annotated location within the Scene.
    * Each Note links to a JournalEntry document and represents its location on the map.
-   * @see {@link NoteDocument}
-   * @see {@link NotesLayer}
+   * @see {@link NoteDocument | `NoteDocument`}
+   * @see {@link NotesLayer | `NotesLayer`}
    */
-  class Note extends PlaceableObject<NoteDocument.ConfiguredInstance> {
+  class Note extends PlaceableObject<NoteDocument.Implementation> {
     static override embeddedName: "Note";
 
-    static override RENDER_FLAGS: {
-      /** @defaultValue `{ propagate: ["refresh"] }` */
-      redraw: RenderFlag<Partial<Note.RenderFlags>>;
+    static override RENDER_FLAGS: Note.RENDER_FLAGS;
 
-      /** @defaultValue `{ propagate: ["refreshState", "refreshPosition", "refreshText"], alias: true }` */
-      refresh: RenderFlag<Partial<Note.RenderFlags>>;
+    // Note: This isn't a "real" override but `renderFlags` is set corresponding to the
+    // `RENDER_FLAGS` and so it has to be adjusted here.
+    renderFlags: RenderFlags<Note.RENDER_FLAGS>;
 
-      /** @defaultValue `{ propagate: ["refreshVisibility"] }` */
-      refreshPosition: RenderFlag<Partial<Note.RenderFlags>>;
-
-      /** @defaultValue `{ propagate: ["refreshVisibility"] }` */
-      refreshState: RenderFlag<Partial<Note.RenderFlags>>;
+    // `controlIcon` is actually defined in the class body here (unlike in super or any of its siblings),
+    // but not initialized to a value. Since it's still set `null` at construction, and the Foundry
+    // comment here provides no additional info, it's been omitted as there's no change from PlaceableObject
 
-      /** @defaultValue `{}` */
-      refreshVisibility: RenderFlag<Partial<Note.RenderFlags>>;
-
-      /** @defaultValue `{}` */
-      refreshText: RenderFlag<Partial<Note.RenderFlags>>;
-    };
+    /**
+     * The tooltip.
+     * @defaultValue `undefined`
+     * @remarks Only `undefined` prior to first draw
+     */
+    tooltip: PreciseText | undefined;
 
     override get bounds(): PIXI.Rectangle;
 
     /**
      * The associated JournalEntry which is described by this note
      */
-    get entry(): JournalEntry.ConfiguredInstance;
+    get entry(): JournalEntry.Stored | undefined;
 
     /**
      * The specific JournalEntryPage within the associated JournalEntry referenced by this Note.
      */
-    get page(): JournalEntryPage;
-
-    /**
-     * The text label used to annotate this Note
-     */
-    get text(): string;
-
-    /**
-     * The Map Note icon size
-     */
-    get size(): number;
+    get page(): JournalEntryPage.Stored | undefined;
 
     /**
      * Determine whether the Note is visible to the current user based on their perspective of the Scene.
@@ -72,25 +47,31 @@ declare global {
      */
     get isVisible(): boolean;
 
-    protected override _draw(options?: Record<string, unknown>): Promise<void>;
+    protected override _draw(options: HandleEmptyObject<Note.DrawOptions>): Promise<void>;
 
     /**
-     * Draw the ControlIcon for the Map Note.
-     * This method replaces any prior controlIcon with the new one.
+     * Draw the control icon.
      */
     protected _drawControlIcon(): ControlIcon;
 
     /**
-     * Draw the map note Tooltip as a Text object.
-     * This method replaces any prior text with the new one.
+     * Draw the tooltip.
      */
     protected _drawTooltip(): PIXI.Text;
 
+    /**
+     * Refresh the tooltip.
+     */
+    protected _refreshTooltip(): void;
+
     /**
      * Define a PIXI TextStyle object which is used for the tooltip displayed for this Note
      */
     protected _getTextStyle(): PIXI.TextStyle;
 
+    // fake override; super has to account for misbehaving siblings returning void
+    override clear(): this;
+
     protected override _applyRenderFlags(flags: Note.RenderFlags): void;
 
     /**
@@ -99,16 +80,126 @@ declare global {
     protected _refreshVisibility(): void;
 
     /**
-     * @privateRemarks _onUpdate is overridden but with no signature changes.
-     * For type simplicity it is left off. These methods historically have been the source of a large amount of computation from tsc.
+     * Refresh the state of the Note. Called the Note enters a different interaction state.
      */
+    protected _refreshState(): void;
 
-    protected override _canHover(user: User.ConfiguredInstance): true;
+    /**
+     * Refresh the position of the Note. Called with the coordinates change.
+     */
+    protected _refreshPosition(): void;
 
-    protected override _canView(user: User.ConfiguredInstance): boolean;
+    /**
+     * Refresh the elevation of the control icon.
+     */
+    protected _refreshElevation(): void;
+
+    // `_onUpdate` is overridden but with no signature changes.
+    // For type simplicity it is left off. These methods historically have been the source of a large amount of computation from tsc.
+
+    /** @remarks Unconditionally returns `true` */
+    protected override _canHover(user: User.Implementation): boolean;
+
+    protected override _canView(user: User.Implementation): boolean;
 
-    protected override _onHoverIn(event: PIXI.FederatedEvent, options?: PlaceableObject.HoverInOptions): false | void;
+    protected override _canConfigure(user: User.Implementation): boolean;
+
+    // fake override to narrow the type from super, which had to account for this class's misbehaving siblings
+    // options: not null (destructured)
+    protected override _onHoverIn(event: PIXI.FederatedEvent, options?: PlaceableObject.HoverInOptions): void;
 
     protected override _onClickLeft2(event: PIXI.FederatedEvent): void;
+
+    // fake override to narrow the type from super, which had to account for this class's misbehaving siblings
+    protected override _prepareDragLeftDropUpdates(event: PIXI.FederatedEvent): PlaceableObject.DragLeftDropUpdate[];
+
+    /**
+     * The text label used to annotate this Note
+     * @deprecated since v12, until v14
+     * @remarks "`Note#text` has been deprecated. Use {@link NoteDocument.label | `Note#document#label`} instead."
+     */
+    get text(): string;
+
+    /**
+     * The Map Note icon size
+     * @deprecated since v12, until v14
+     * @remarks "`Note#size` has been deprecated. Use {@link NoteDocument.iconSize | `Note#document#iconSize`} instead."
+     */
+    get size(): number;
+  }
+
+  namespace Note {
+    // eslint-disable-next-line no-restricted-syntax
+    interface ObjectClass extends ConfiguredObjectClassOrDefault<typeof Note> {}
+    interface Object extends FixedInstanceType<ObjectClass> {}
+
+    /**
+     * @deprecated {@link Note.ObjectClass | `Note.ObjectClass`}
+     */
+    type ConfiguredClass = ObjectClass;
+
+    /**
+     * @deprecated {@link Note.Object | `Note.Object`}
+     */
+    type ConfiguredInstance = Object;
+
+    /**
+     * This type will permanently exist but is marked deprecated. The reason it exists is because
+     * the confusion between `Note` (the `PlaceableObject` that appears on the canvas) and
+     * `NoteDocument` (the `Document` that represents the data for a `Note`) is so common that
+     * it is useful to have a type to forward to `NoteDocument`.
+     *
+     * @deprecated {@link NoteDocument.Implementation | `NoteDocument.Implementation`}
+     */
+    type Implementation = NoteDocument.Implementation;
+
+    /**
+     * This type will permanently exist but is marked deprecated. The reason it exists is because
+     * the confusion between `Note` (the `PlaceableObject` that appears on the canvas) and
+     * `NoteDocument` (the `Document` that represents the data for a `Note`) is so common that
+     * it is useful to have a type to forward to `NoteDocument`.
+     *
+     * @deprecated {@link NoteDocument.ImplementationClass | `NoteDocument.ImplementationClass`}
+     */
+    type ImplementationClass = NoteDocument.ImplementationClass;
+
+    interface RENDER_FLAGS extends PlaceableObject.RENDER_FLAGS {
+      /** @defaultValue `{ propagate: ["refresh"] }` */
+      redraw: RenderFlag<this, "redraw">;
+
+      /** @defaultValue `{ propagate: ["refreshState", "refreshPosition", "refreshTooltip", "refreshElevation"], alias: true }` */
+      refresh: RenderFlag<this, "refresh">;
+
+      /** @defaultValue `{ propagate: ["refreshVisibility"] }` */
+      refreshState: RenderFlag<this, "refreshState">;
+
+      /** @defaultValue `{}` */
+      refreshVisibility: RenderFlag<this, "refreshVisibility">;
+
+      /** @defaultValue `{}` */
+      refreshPosition: RenderFlag<this, "refreshPosition">;
+
+      /** @defaultValue `{}` */
+      refreshTooltip: RenderFlag<this, "refreshTooltip">;
+
+      /** @defaultValue `{ propagate: ["refreshVisibility"] }` */
+      refreshElevation: RenderFlag<this, "refreshElevation">;
+
+      /**
+       * @defaultValue `{ propagate: ["refreshTooltip"], deprecated: { since: 12, until: 14 }, alias: true }`
+       * @deprecated since v12, until v14
+       */
+      refreshText: RenderFlag<this, "refreshText">;
+    }
+
+    interface RenderFlags extends RenderFlagsMixin.ToBooleanFlags<RENDER_FLAGS> {}
+
+    interface DrawOptions extends PlaceableObject.DrawOptions {}
+
+    interface RefreshOptions extends PlaceableObject.RefreshOptions {}
+
+    interface ControlOptions extends PlaceableObject.ControlOptions {}
+
+    interface ReleaseOptions extends PlaceableObject.ReleaseOptions {}
   }
 }

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 "#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 | `CanvasTransformMixinClass#updateCanvasTransform`} */
   updateCanvasTransform(): void;
 
-  _onCanvasBoundsUpdate(): void;
+  /** @see {@link CanvasTransformMixinClass._onCanvasBoundsUpdate | `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,34 @@ 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;
+    interface AnyMixedConstructor
+      extends 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;
+    interface AnyMixedConstructor extends ReturnType<typeof CanvasTransformMixin<CanvasTransformMixin.BaseClass>> {}
+    interface AnyMixed extends FixedInstanceType<AnyMixedConstructor> {}
+
+    type BaseClass = PIXI.Container.AnyConstructor;
   }
 }