@league-of-foundry-developers/foundry-vtt-types 13.346.0-beta.20250718083253 → 13.346.0-beta.20250719181625

package/src/foundry/client/canvas/containers/elements/point-source-mesh.d.mts

@@ -2,7 +2,7 @@ import type { Identity } from "#utils";
 import type { AdaptiveLightingShader } from "#client/canvas/rendering/shaders/_module.d.mts";
 
 /**
- * Extension of a PIXI.Mesh, with the capabilities to provide a snapshot of the framebuffer.
+ * Extension of a PIXI.Mesh for PointEffectSources.
  * @remarks Foundry only uses this with `AdaptiveLightingShader` subclasses, thus the type param default
  */
 declare class PointSourceMesh<Shader extends PIXI.Shader = AdaptiveLightingShader> extends PIXI.Mesh<Shader> {
@@ -12,40 +12,36 @@ declare class PointSourceMesh<Shader extends PIXI.Shader = AdaptiveLightingShade
   constructor(geometry: PIXI.Geometry, shader: Shader, state?: PIXI.State, drawMode?: PIXI.DRAW_MODES);
 
   /**
-   * To store the previous blend mode of the last renderer PointSourceMesh.
-   * @privateRemarks Despite being `protected`, this is accessed externally in `CanvasIlluminationEffects#render`
+   * @deprecated Removed without replacement in v13 (this warning will be removed in v14)
    */
-  protected static _priorBlendMode: PIXI.BLEND_MODES | undefined;
+  protected static _priorBlendMode: never;
 
-  /**
-   * The current texture used by the mesh.
-   * @privateRemarks Despite being `protected`, this is accessed externally in `CanvasIlluminationEffects#render`
-   */
-  protected static _currentTexture: PIXI.Texture | undefined;
+  protected static _currentTexture: never;
 
   /**
-   * The transform world ID of the bounds.
-   * @defaultValue `-1`
+   * @deprecated Made hard private in v13 (this warning will be removed in v14)
    */
-  _worldID: number;
+  _worldID: never;
 
   /**
-   * The geometry update ID of the bounds.
-   * @defaultValue `-1`
+   * @deprecated Made hard private in v13 (this warning will be removed in v14)
    */
-  _updateID: number;
+  _updateID: never;
 
   override get geometry(): PIXI.Geometry;
 
-  set geometry(value: PIXI.Geometry);
+  override set geometry(value: PIXI.Geometry);
 
-  /** @throws You can't add children to a PointSourceMesh. */
+  /** @throws You can't add children to a {@linkcode PointSourceMesh}. */
   override addChild(): never;
 
-  /** @throws You can't add children to a PointSourceMesh. */
+  /** @throws You can't add children to a {@linkcode PointSourceMesh}. */
   override addChildAt(): never;
 
-  protected override _render(renderer: PIXI.Renderer): void;
+  /**
+   * @deprecated Removed without replacement in v13 (this warning will be removed in v14)
+   */
+  protected override _render(renderer: never): never;
 
   override calculateBounds(): void;
 
@@ -53,12 +49,11 @@ declare class PointSourceMesh<Shader extends PIXI.Shader = AdaptiveLightingShade
 
   /** The local bounds need to be drawn from the underlying geometry. */
   override getLocalBounds(
-    /**
-     * @defaultValue `new PIXI.Rectangle()`
-     * @remarks Default provided by `??=` in function body. `null` would be allowable here but breaks inheritance
-     */
+    /** @defaultValue `new PIXI.Rectangle()` */
     rect?: PIXI.Rectangle,
   ): PIXI.Rectangle;
+
+  #PointSourceMesh: true;
 }
 
 declare namespace PointSourceMesh {

package/src/foundry/client/canvas/containers/elements/precise-text.d.mts

@@ -1,4 +1,4 @@
-import type { Identity, InexactPartial, NullishProps } from "#utils";
+import type { Identity, InexactPartial } from "#utils";
 
 /**
  * An extension of the default PIXI.Text object which forces double resolution.
@@ -15,7 +15,7 @@ declare class PreciseText extends PIXI.Text {
 
   /**
    * Prepare a TextStyle object which merges the canvas defaults with user-provided options
-   * @param anchor  - A text anchor point from CONST.TEXT_ANCHOR_POINTS
+   * @param anchor  - A text anchor point from {@linkcode CONST.TEXT_ANCHOR_POINTS}
    * @param options - Additional options merged with the default TextStyle
    * @returns The prepared TextStyle
    */
@@ -27,16 +27,15 @@ declare namespace PreciseText {
   interface AnyConstructor extends Identity<typeof AnyPreciseText> {}
 
   /** @internal */
-  type _GetTextStyleOptions = NullishProps<{
+  type _GetTextStyleOptions = InexactPartial<{
     /**
-     * A text anchor point from CONST.TEXT_ANCHOR_POINTS
-     * @remarks Only checked againt `.RIGHT` and `.LEFT`, and only if an `align` key is omitted
+     * A text anchor point from {@linkcode CONST.TEXT_ANCHOR_POINTS}
+     * @remarks Only checked against `.RIGHT` and `.LEFT`, and only if an `align` key is omitted
      */
-    anchor: foundry.CONST.TEXT_ANCHOR_POINTS;
-  }> &
-    // Can't be NullishProps because keys are only checked for `!== undefined` in PIXI
-    InexactPartial<PIXI.ITextStyle>;
-  interface GetTextStyleOptions extends _GetTextStyleOptions {}
+    anchor: CONST.TEXT_ANCHOR_POINTS;
+  }>;
+
+  interface GetTextStyleOptions extends _GetTextStyleOptions, InexactPartial<PIXI.ITextStyle> {}
 }
 
 export default PreciseText;

package/src/foundry/client/canvas/containers/elements/quad-mesh.d.mts

@@ -4,7 +4,6 @@ import type { AbstractBaseShader } from "#client/canvas/rendering/shaders/_modul
 /**
  * A basic rectangular mesh with a shader only. Does not natively handle textures (but a bound shader can).
  * Bounds calculations are simplified and the geometry does not need to handle texture coords.
- * @privateRemarks Ideally the `shaderClass` passed to the constructor and `get shader()` could be synced up, but `setShaderClass` removes that option
  */
 declare class QuadMesh extends PIXI.Container {
   /**
@@ -26,7 +25,7 @@ declare class QuadMesh extends PIXI.Container {
 
   /**
    * Initialize shader based on the shader class type.
-   * @param shaderClass - Shader class used. Must inherit from AbstractBaseShader.
+   * @param shaderClass - Shader class used. Must inherit from {@linkcode AbstractBaseShader}.
    */
   setShaderClass(shaderClass: AbstractBaseShader.AnyConstructor): void;
 

package/src/foundry/client/canvas/containers/elements/resize-handle.d.mts

@@ -1,9 +1,13 @@
-import type { Identity, NullishProps } from "#utils";
+import type { Identity, InexactPartial } from "#utils";
 import type { Canvas } from "#client/canvas/_module.d.mts";
 
-declare class ResizeHandle extends PIXI.Graphics {
+/**
+ * A class based on PIXI.Graphics, that allows to create a resize handle in the desired area.
+ */
+declare class ResizeHandle extends PIXI.smooth.SmoothGraphics {
   /**
-   * @param handlers - (default: `{}`)
+   * @param offset   - A two-element array [xFactor, yFactor] which defines the normalized position of this handle relative to the bounding box.
+   * @param handlers - An object of optional handler functions.
    */
   constructor(offset: ResizeHandle.Offsets, handlers?: ResizeHandle.Handlers);
 
@@ -17,18 +21,30 @@ declare class ResizeHandle extends PIXI.Graphics {
    */
   active: boolean;
 
+  /**
+   * Refresh the position and hit area of this handle based on the provided bounding box.
+   * @param bounds - The bounding box in which this handle operates.
+   */
   refresh(bounds: Canvas.Rectangle): void;
 
   /**
-   * @param aspectRatio - (default: `null`)
+   * Compute updated dimensions for an object being resized, respecting optional constraints.
+   * @param current     - The current geometric state of the object
+   * @param origin      - The original position and dimensions used for reference
+   * @param destination - The mouse (or pointer) destination coordinates.
+   * @param options     - Additional options.
+   * @returns An object containing the adjusted `{x, y, width, height}`.
    */
   updateDimensions(
     current: Canvas.Rectangle,
     origin: Canvas.Rectangle,
-    destination: Canvas.Rectangle,
+    destination: ResizeHandle.Destination,
     options?: ResizeHandle.UpdateDimensionsOptions,
   ): Canvas.Rectangle;
 
+  /**
+   * Activate listeners for pointer events, enabling hover and mouse-down behavior on the resize handle.
+   */
   activateListeners(): void;
 
   /**
@@ -44,7 +60,7 @@ declare class ResizeHandle extends PIXI.Graphics {
   protected _onHoverOut(event: PIXI.FederatedEvent<PointerEvent>): void;
 
   /**
-   * When we start a drag event - create a preview copy of the Tile for re-positioning
+   * When we start a drag event - create a preview copy of the `Tile` for re-positioning
    * @param event - The mousedown event
    */
   protected _onMouseDown(event: PIXI.FederatedEvent<PointerEvent>): void;
@@ -57,20 +73,30 @@ declare namespace ResizeHandle {
   type Offsets = [widthOffset: number, heightOffset: number];
 
   /** @internal */
-  type _Handlers = NullishProps<{
-    canDrag: () => boolean | null | void;
+  type _Handlers = InexactPartial<{
+    /** A function determining if this handle can initiate a drag. */
+    canDrag: () => boolean;
   }>;
 
   interface Handlers extends _Handlers {}
 
+  /** @privateRemarks {@linkcode ResizeHandle.updateDimensions | #updateDimensions} is too cool to just use a Point */
+  interface Destination {
+    /** The x-coordinate where the pointer was released. */
+    x: number;
+
+    /** The y-coordinate where the pointer was released. */
+    y: number;
+  }
+
   /** @internal */
-  type _UpdateDimensionsOptions = NullishProps<{
+  type _UpdateDimensionsOptions = InexactPartial<{
     /**
-     * Constrain the aspect ratio
+     * If provided, a numeric aspect ratio to maintain (width/height).
      * @defaultValue `null`
      * @remarks If truthy, will enforce the passed ratio, landscape if `width >= height`, portrait otherwise
      */
-    aspectRatio: number;
+    aspectRatio: number | null;
   }>;
 
   interface UpdateDimensionsOptions extends _UpdateDimensionsOptions {}

package/src/foundry/client/canvas/containers/elements/sprite-mesh.d.mts

@@ -6,12 +6,10 @@ import type { BaseSamplerShader } from "#client/canvas/rendering/shaders/_module
  */
 declare class SpriteMesh extends PIXI.Container {
   /**
-   * @param texture   - Texture bound to this sprite mesh.
-   *                    (default: `PIXI.Texture.EMPTY`)
-   * @param shaderCls - Shader class used by this sprite mesh.
-   *                    (default: `BaseSamplerShader`)
+   * @param texture   - Texture bound to this sprite mesh. (default: {@linkcode PIXI.Texture.EMPTY})
+   * @param shaderCls - Shader class used by this sprite mesh. (default: {@linkcode foundry.canvas.rendering.shaders.BaseSamplerShader | BaseSamplerShader})
    */
-  constructor(texture?: PIXI.Texture | null, shaderClass?: BaseSamplerShader.AnyConstructor);
+  constructor(texture?: PIXI.Texture, shaderClass?: BaseSamplerShader.AnyConstructor);
 
   /** @defaultValue `true` */
   override isSprite: boolean;
@@ -40,6 +38,7 @@ declare class SpriteMesh extends PIXI.Container {
 
   /**
    * The texture that the sprite is using.
+   * @remarks Set `null` in {@linkcode destroy | #destroy}, or if this mesh was constructed with no texture
    */
   protected _texture: PIXI.Texture | null;
 
@@ -81,7 +80,7 @@ declare class SpriteMesh extends PIXI.Container {
    *
    * {@link https://docs.cocos2d-x.org/cocos2d-x/en/sprites/manipulation.html}
    */
-  protected _anchor: PIXI.ObservablePoint;
+  protected _anchor: PIXI.ObservablePoint<SpriteMesh.Any>;
 
   /**
    * This is used to store the vertex data of the sprite (basically a quad).
@@ -119,7 +118,7 @@ declare class SpriteMesh extends PIXI.Container {
   protected _tintRGB: number;
 
   /**
-   * An instance of a texture uvs used for padded SpriteMesh.
+   * An instance of a texture uvs used for padded `SpriteMesh`.
    * Instanced only when padding becomes non-zero.
    * @defaultValue `null`
    */
@@ -160,7 +159,10 @@ declare class SpriteMesh extends PIXI.Container {
    */
   get padding(): number;
 
-  /** @throws If `value < 0` */
+  /**
+   * @remarks
+   * @throws If `value < 0`
+   */
   set padding(value);
 
   /**
@@ -175,7 +177,7 @@ declare class SpriteMesh extends PIXI.Container {
 
   /**
    * The blend mode applied to the SpriteMesh.
-   * @defaultValue `PIXI.BLEND_MODES.NORMAL`
+   * @defaultValue {@linkcode PIXI.BLEND_MODES.NORMAL}
    */
   set blendMode(value: PIXI.BLEND_MODES);
 
@@ -185,7 +187,7 @@ declare class SpriteMesh extends PIXI.Container {
    * If true PixiJS will Math.round() x/y values when rendering, stopping pixel interpolation.
    * Advantages can include sharper image quality (like text) and faster rendering on canvas.
    * The main disadvantage is movement of objects may appear less smooth.
-   * To set the global default, change PIXI.settings.ROUND_PIXELS
+   * To set the global default, change {@linkcode PIXI.settings.ROUND_PIXELS}
    * @defaultValue `PIXI.settings.ROUND_PIXELS`
    */
   set roundPixels(value: boolean);
@@ -195,18 +197,19 @@ declare class SpriteMesh extends PIXI.Container {
   /**
    * Used to force an alpha mode on this sprite mesh.
    * If this property is non null, this value will replace the texture alphaMode when computing color channels.
-   * Affects how tint, worldAlpha and alpha are computed each others.
+   * Affects how `tint`, `worldAlpha` and `alpha` are computed each others.
    */
   get alphaMode(): PIXI.ALPHA_MODES;
 
   set alphaMode(mode);
 
   /**
-   * Returns the SpriteMesh associated batch plugin. By default the returned plugin is that of the associated shader.
-   * If a plugin is forced, it will returns the forced plugin.
-   * @defaultValue `this._shader.pluginName`
+   * Returns the {@linkcode SpriteMesh} associated batch plugin. By default the returned plugin is that of the associated shader.
+   * If a plugin is forced, it will returns the forced plugin. A null value means that this `SpriteMesh` has no associated
+   * plugin.
+   * @defaultValue {@linkcode BaseSamplerShader.pluginName | this._shader.pluginName}
    */
-  get pluginName(): string;
+  get pluginName(): string | null;
 
   set pluginName(name);
 
@@ -222,7 +225,7 @@ declare class SpriteMesh extends PIXI.Container {
   set texture(texture);
 
   /**
-   * The anchor sets the origin point of the sprite. The default value is taken from the {@linkcode PIXI.Texture}
+   * The anchor sets the origin point of the sprite. The default value is taken from the texture
    * and passed to the constructor.
    *
    * The default is `(0,0)`, this means the sprite's origin is the top left.
@@ -241,7 +244,7 @@ declare class SpriteMesh extends PIXI.Container {
   /**
    * The tint applied to the sprite. This is a hex value.
    *
-   * A value of 0xFFFFFF will remove any tint effect.
+   * A value of `0xFFFFFF` will remove any tint effect.
    * @defaultValue `0xFFFFFF`
    */
   get tint(): number;
@@ -249,10 +252,9 @@ declare class SpriteMesh extends PIXI.Container {
   set tint(tint);
 
   /**
-   * The HTML source element for this SpriteMesh texture.
-   * @privateRemarks This could possibly be `PIXI.ImageSource | null`, but the below is Foundry's typing, which I think is accurate in practice
+   * The HTML source element for this `SpriteMesh` texture.
    */
-  get sourceElement(): HTMLImageElement | HTMLVideoElement | null;
+  get sourceElement(): PIXI.ImageSource | null;
 
   /**
    * Is this SpriteMesh rendering a video texture?
@@ -270,7 +272,7 @@ declare class SpriteMesh extends PIXI.Container {
   protected _onAnchorUpdate(): void;
 
   /**
-   * Update uvs and push vertices and uv buffers on GPU if necessary.
+   * Update `uvs` and push `vertices` and uv buffers on GPU if necessary.
    */
   updateUvs(): void;
 
@@ -283,29 +285,33 @@ declare class SpriteMesh extends PIXI.Container {
   override updateTransform(): void;
 
   /**
-   * Calculates the worldTransform * vertices, store it in vertexData
+   * Calculates the `worldTransform * vertices`, store it in `vertexData`
    */
   calculateVertices(): void;
 
   /**
-   * Calculates worldTransform * vertices for a non texture with a trim. store it in vertexTrimmedData.
+   * Calculates `worldTransform * vertices` for a non texture with a trim. store it in `vertexTrimmedData`.
    *
    * This is used to ensure that the true width and height of a trimmed texture is respected.
    */
   calculateTrimmedVertices(): void;
 
-  override _render(renderer: PIXI.Renderer): void;
+  protected override _render(renderer: PIXI.Renderer): void;
 
   /**
    * Update the batch data object.
    */
   protected _updateBatchData(): void;
 
-  override _calculateBounds(): void;
+  protected override _calculateBounds(): void;
 
   override getLocalBounds(rect: PIXI.Rectangle): PIXI.Rectangle;
 
-  /** @privateRemarks Foundry still marks this `@override` from when this class used to extend `PIXI.Mesh` */
+  /**
+   * Check to see if a point is contained within this SpriteMesh Quad.
+   * @param point - Point to check if it's contained.
+   * @returns `true` if the point is contained within geometry.
+   */
   containsPoint(point: PIXI.IPointData): boolean;
 
   override destroy(options?: PIXI.IDestroyOptions | boolean): void;
@@ -322,6 +328,8 @@ declare class SpriteMesh extends PIXI.Container {
     textureOptions?: PIXI.IBaseTextureOptions,
     shaderClass?: BaseSamplerShader.AnyConstructor,
   ): SpriteMesh;
+
+  #SpriteMesh: true;
 }
 
 declare namespace SpriteMesh {

package/src/foundry/client/canvas/layers/masks/depth.d.mts

@@ -53,7 +53,7 @@ declare class CanvasDepthMask extends CachedContainer {
   /**
    * Clear the depth mask.
    */
-  clear(): void;
+  override clear(): this;
 }
 
 declare namespace CanvasDepthMask {

package/src/foundry/client/canvas/layers/masks/occlusion.d.mts

@@ -46,7 +46,7 @@ declare class CanvasOcclusionMask extends CachedContainer {
   /**
    * Clear the occlusion mask.
    */
-  clear(): void;
+  override clear(): this;
 
   /**
    * Map an elevation to a value in the range [0, 1] with 8-bit precision.

package/src/foundry/client/canvas/primary/primary-canvas-container.d.mts

@@ -1,7 +1,39 @@
+import type { PIXI } from "#configuration";
 import type { Identity } from "#utils";
 import type { CanvasTransformMixin } from "./primary-canvas-object.d.mts";
 
+/**
+ * Primary canvas container are reserved for advanced usage.
+ * They allow to group PrimarySpriteMesh in a single Container.
+ * The container elevation is replacing individual sprite elevation.
+ * @remarks This class is not used for anything by core as of 13.346
+ */
 declare class PrimaryCanvasContainer extends CanvasTransformMixin(PIXI.Container) {
+  /**
+   * A key which resolves ties amongst objects at the same elevation within the same layer.
+   */
+  get sort(): number;
+
+  set sort(value);
+
+  /**
+   * The elevation of this container.
+   */
+  get elevation(): number;
+
+  set elevation(value);
+
+  /**
+   * To know if this container has at least one children that should render its depth.
+   */
+  get shouldRenderDepth(): boolean;
+
+  override sortChildren(): void;
+
+  override updateCanvasTransform(): void;
+
+  renderDepthData(renderer: PIXI.Renderer): void;
+
   #PrimaryCanvasContainer: true;
 }
 

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

@@ -1,28 +1,26 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 import type { FixedInstanceType, Mixin } from "#utils";
 import type Document from "#common/abstract/document.d.mts";
-import type { CanvasGroupMixin } from "#client/canvas/groups/_module.d.mts";
-import type { PlaceableObject } from "#client/canvas/placeables/_module.d.mts";
+import type { CanvasGroupMixin, PrimaryCanvasGroup } from "#client/canvas/groups/_module.d.mts";
+import type { placeables, primary } from "#client/canvas/_module.d.mts";
 
 declare class PrimaryCanvasObject {
   /** @privateRemarks All mixin classes 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`
+   * @remarks Foundry types as `*`, but in core usage, it is only ever:
+   * - {@linkcode placeables.Drawing | Drawing} ({@linkcode PrimaryCanvasGroup.addDrawing | PrimaryCanvasGroup#addDrawing} creates a {@linkcode primary.PrimaryGraphics | PrimaryGraphics})
+   * - {@linkcode placeables.Token | Token} (`Token##handleTransitionChanges` and {@linkcode PrimaryCanvasGroup.addToken | PrimaryCanvasGroup#addToken} create {@linkcode primary.PrimarySpriteMesh | PrimarySpriteMesh}es)
+   * - {@linkcode placeables.Tile | Tile} ({@linkcode PrimaryCanvasGroup.addTile | PrimaryCanvasGroup#addTile} creates a `PrimarySpriteMesh`)
+   * - {@linkcode placeables.Wall | Wall} ({@linkcode placeables.Wall.createDoorMeshes | Wall#createDoorMeshes} creates various {@linkcode foundry.canvas.containers.DoorMesh | DoorMesh}es)
+   * - {@linkcode PrimaryCanvasGroup} (`PrimaryCanvasGroup##drawBackground` and `##drawForeground` create `PrimarySpriteMesh`es)
+   * - `null`, its default
    */
-  // TODO: (esheyw) Revisit the "any canvas group" type when groups are done
-  object: PlaceableObject.Any | CanvasGroupMixin.AnyMixed | null;
+  object: PrimaryCanvasObjectMixin.OwningObject | null;
 
   /**
    * The elevation of this object.
@@ -56,20 +54,21 @@ 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`
+   * @remarks Foundry types this as taking a {@linkcode PIXI.Container} but then is more specific internally
+   * @throws Unless `parent` is either `=== canvas.primary` or a {@linkcode foundry.canvas.primary.PrimaryCanvasContainer | PrimaryCanvasContainer}
    */
-  protected _onAdded(parent: PIXI.Container): void;
+  protected _onAdded(parent: PrimaryCanvasObjectMixin.Parent): void;
 
   /**
    * Event fired when this display object is removed from its parent.
    * @param parent - Parent from which the PCO is removed.
    */
-  protected _onRemoved(parent: PIXI.Container): void;
+  protected _onRemoved(parent: PrimaryCanvasObjectMixin.Parent): void;
 
-  /** @see {@link CanvasTransformMixinClass.updateCanvasTransform | `CanvasTransformMixinClass#updateCanvasTransform`} */
+  /** @remarks See {@linkcode CanvasTransformMixinClass.updateCanvasTransform | CanvasTransformMixinClass#updateCanvasTransform} */
   updateCanvasTransform(): void;
 
-  /** @see {@link CanvasTransformMixinClass._onCanvasBoundsUpdate | `CanvasTransformMixinClass#_onCanvasBoundsUpdate`} */
+  /** @remarks See {@linkcode CanvasTransformMixinClass._onCanvasBoundsUpdate | CanvasTransformMixinClass#_onCanvasBoundsUpdate} */
   protected _onCanvasBoundsUpdate(): void;
 
   /**
@@ -88,26 +87,20 @@ declare class PrimaryCanvasObject {
   renderDepthData(renderer: PIXI.Renderer): void;
 
   /**
-   * @deprecated since v11, will be removed in v13
-   * @remarks `"PrimaryCanvasObject#renderOcclusion is deprecated in favor of PrimaryCanvasObject#renderDepthData"`
-   */
-  renderOcclusion(renderer: PIXI.Renderer): void;
-
-  /**
-   * @deprecated since v12, will be removed in v14
-   * @remarks `"PrimaryCanvasObject#document is deprecated."`
+   * @deprecated "`PrimaryCanvasObject#document` is deprecated." (since v12, until v14)
    */
-  get document(): Document.Any | null;
+  get document(): placeables.PlaceableObject.AnyCanvasDocument | null;
 
   /**
-   * @deprecated since v12, will be removed in v14
-   * @remarks `"PrimaryCanvasObject#updateBounds is deprecated and has no effect."`
+   * @deprecated "`PrimaryCanvasObject#updateBounds` is deprecated and has no effect." (since v12, until v14)
    */
   updateBounds(): void;
+
+  #PrimaryCanvasObject: true;
 }
 
 declare class CanvasTransformMixinClass {
-  /** @privateRemarks All mixin classses should accept anything for its constructor. */
+  /** @privateRemarks All mixin classes should accept anything for its constructor. */
   constructor(...args: any[]);
 
   /**
@@ -117,7 +110,8 @@ declare class CanvasTransformMixinClass {
 
   /**
    * The update ID of canvas transform matrix.
-   * @privateRemarks Foundry marked `@internal`, technically accessed externally via `this.parent._convasTranformID` in `updateCanvasTransform`
+   * @internal
+   * @remarks Accessed externally via `this.parent._canvasTransformID` in {@linkcode updateCanvasTransform}
    */
   protected _canvasTransformID: number;
 
@@ -165,10 +159,9 @@ declare class CanvasTransformMixinClass {
 }
 
 /**
- * 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
+ * A mixin which decorates a {@linkcode PIXI.DisplayObject | DisplayObject} with additional properties expected for rendering in the {@linkcode PrimaryCanvasGroup}.
+ * @param  DisplayObject - The parent `DisplayObject` class being mixed
+ * @privateRemarks Despite naming the argument `DisplayObject`, it's typed as only taking `PIXI.Container`s, which matches core's usage
  */
 declare function PrimaryCanvasObjectMixin<BaseClass extends PrimaryCanvasObjectMixin.BaseClass>(
   DisplayObject: BaseClass,
@@ -180,13 +173,21 @@ declare namespace PrimaryCanvasObjectMixin {
   interface AnyMixed extends FixedInstanceType<AnyMixedConstructor> {}
 
   type BaseClass = PIXI.Container.AnyConstructor;
+
+  /**
+   * @remarks {@linkcode PrimaryCanvasObject._onAdded | PrimaryCanvasObject#_onAdded} throws if not passed a either {@linkcode PrimaryCanvasContainer}
+   * or whatever {@linkcode canvas.primary} currently is, which presumably will be a {@linkcode PrimaryCanvasGroup}
+   */
+  type Parent = PrimaryCanvasGroup.Any | primary.PrimaryCanvasContainer.Any;
+
+  /** @remarks See {@linkcode PrimaryCanvasObject.object | PrimaryCanvasObject#object} remarks */
+  type OwningObject = placeables.PlaceableObject.Any | CanvasGroupMixin.AnyMixed;
 }
 
 /**
- * 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
+ * A mixin which decorates a {@linkcode PIXI.DisplayObject | DisplayObject} with additional properties for canvas transforms and bounds.
+ * @param DisplayObject - The parent `DisplayObject` class being mixed
+ * @privateRemarks Despite naming the argument `DisplayObject`, it's typed as only taking `PIXI.Container`s, which matches core's usage
  */
 declare function CanvasTransformMixin<BaseClass extends CanvasTransformMixin.BaseClass>(
   DisplayObject: BaseClass,