@league-of-foundry-developers/foundry-vtt-types 13.346.0-beta.20250718083608 → 13.346.0-beta.20250720082736

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,

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

@@ -1,26 +1,27 @@
-import type { Identity, NullishProps } from "#utils";
+import type { Identity, InexactPartial } from "#utils";
 import type { PrimaryCanvasObjectMixin } from "./_module.d.mts";
 import type { PlaceableObject } from "#client/canvas/placeables/_module.d.mts";
 
 /**
  * A basic PCO which is handling drawings of any shape.
  */
-declare class PrimaryGraphics extends PrimaryCanvasObjectMixin(PIXI.Graphics) {
+declare class PrimaryGraphics extends PrimaryCanvasObjectMixin(PIXI.smooth.SmoothGraphics) {
   /**
    * @param options - A config object
+   * @remarks Passing a {@linkcode PIXI.smooth.SmoothGraphicsGeometry} instead of an `options` should be supported here,
+   * but has been disabled due to a core bug: {@link https://github.com/foundryvtt/foundryvtt/issues/13170}
+   *
+   * If you need to pass a specific geometry instead of using a default `new SmoothGraphicsGeometry`, pass it as `options.geometry`.
    */
-  constructor(
-    /**
-     * @remarks Passing `null`, or an object where the `geometry` property is either missing or nullish, will result in an effective default of `new PIXI.GraphicsGeometry()`
-     */
-    options?: PIXI.GraphicsGeometry | PrimaryGraphics.ConstructorOptions | null,
-  );
+  constructor(options?: PrimaryGraphics.ConstructorOptions);
 
-  override _calculateCanvasBounds(): void;
+  protected override _calculateCanvasBounds(): void;
 
   override updateCanvasTransform(): void;
 
   override containsCanvasPoint(point: PIXI.IPointData): boolean;
+
+  #PrimaryGraphics: true;
 }
 
 declare namespace PrimaryGraphics {
@@ -28,28 +29,31 @@ declare namespace PrimaryGraphics {
   interface AnyConstructor extends Identity<typeof AnyPrimaryGraphics> {}
 
   /** @internal */
-  type _ConstructorOptions = NullishProps<{
+  type _ConstructorOptions = InexactPartial<{
     /**
      * A geometry passed to the graphics.
-     * @defaultValue `new PIXI.GraphicsGeometry()`
-     * @remarks Default via calling `super(geometry)` with a falsey value
+     * @defaultValue {@linkcode PIXI.smooth.SmoothGraphicsGeometry | new PIXI.smooth.SmoothGraphicsGeometry()}
+     * @remarks Default applied in the {@linkcode PIXI.smooth.SmoothGraphics} constructor.
+     *
+     * @privateRemarks Foundry types this incorrectly because they didn't update it when they switched base classes:
+     * {@link https://github.com/foundryvtt/foundryvtt/issues/13170}
      */
-    geometry: PIXI.GraphicsGeometry;
+    geometry: PIXI.smooth.SmoothGraphicsGeometry;
 
     /**
      * The name of the PCO.
      * @defaultValue `null`
-     * @remarks Default via `?? null` in function body
      */
-    name: string;
+    name: string | null;
 
     /**
      * Any object that owns this PCO.
      * @defaultValue `null`
-     * @remarks Default via `?? null` in function body
-     * @privateRemarks Foundry types as `*`, but the only place they use this class is for `Drawing`s
+     * @remarks Foundry types as `*`, but the only place this class sees core use it's in {@linkcode PrimaryCanvasGroup.addDrawing | PrimaryCanvasGroup#addDrawing}
+     *
+     * See {@linkcode PrimaryCanvasObjectMixin.AnyMixed.object | PrimaryCanvasObject#object}
      */
-    object: PlaceableObject.Any;
+    object: PlaceableObject.Any | null;
   }>;
 
   interface ConstructorOptions extends _ConstructorOptions {}

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

@@ -1,4 +1,4 @@
-import type { FixedInstanceType, Mixin, NullishProps } from "#utils";
+import type { FixedInstanceType, InexactPartial, Mixin } from "#utils";
 import type { PrimaryCanvasObjectMixin } from "./_module.d.mts";
 import type { Token } from "#client/canvas/placeables/_module.d.mts";
 
@@ -21,7 +21,7 @@ declare class PrimaryOccludableObject {
 
   /**
    * The occlusion mode of this occludable object.
-   * @defaultValue `CONST.OCCLUSION_MODES.NONE`
+   * @defaultValue {@linkcode CONST.OCCLUSION_MODES.NONE}
    */
   occlusionMode: CONST.OCCLUSION_MODES;
 
@@ -39,7 +39,6 @@ declare class PrimaryOccludableObject {
 
   /**
    * Fade this object on hover?
-   * @defaultValue `true`
    */
   get hoverFade(): boolean;
 
@@ -55,9 +54,11 @@ declare class PrimaryOccludableObject {
    *   vision: 0.0
    * }
    * ```
-   * @privateRemarks Foundry marked `@internal`
+   * @internal
+   * @remarks Accessed externally in {@linkcode foundry.canvas.rendering.shaders.DepthSamplerShader._preRender | DepthSamplerShader#_preRender}
+   * and {@linkcode foundry.canvas.rendering.shaders.OccludableSamplerShader._preRender | OccludableSamplerShader#_preRender}
    */
-  _occlusionState: PrimaryOccludableObjectMixin.OcclusionState;
+  protected _occlusionState: PrimaryOccludableObjectMixin.OcclusionState;
 
   /**
    * The state of hover-fading.
@@ -66,21 +67,24 @@ declare class PrimaryOccludableObject {
    * {
    *   hovered: false,
    *   hoveredTime: 0,
+   *   _hoveredTime: 0,
    *   faded: false,
    *   fading: false,
    *   fadingTime: 0,
    *   occlusion: 0.0
    * }
    * ```
-   * @privateRemarks Foundry marked `@internal`
+   * @internal
+   * @remarks Properties accessed and set remotely in {@linkcode foundry.canvas.groups.PrimaryCanvasGroup._onMouseMove | PrimaryCanvasGroup#_onMouseMove}
+   * and `##updateHoveredObjects`
    */
-  _hoverFadeState: PrimaryOccludableObjectMixin.HoverFadeState;
+  protected _hoverFadeState: PrimaryOccludableObjectMixin.HoverFadeState;
 
   /**
    * Get the blocking option bitmask value.
-   * @privateRemarks Foundry marked `@internal`
+   * @internal
    */
-  get _restrictionState(): number;
+  protected get _restrictionState(): number;
 
   /**
    * Is this object blocking light?
@@ -106,13 +110,19 @@ declare class PrimaryOccludableObject {
    * change PCO appearance.
    * Uses a 50ms debounce threshold.
    * Objects which are in the hovered state remain occluded until their hovered state ends.
-   * @remarks Actually the return value of an arrow function passed to `foundry.utils.debounce` with a timeout of 50ms
+   * @remarks Actually the return value of an arrow function passed to {@linkcode foundry.utils.debounce} with a timeout of 50ms
    */
   debounceSetOcclusion: (occluded: boolean) => boolean;
 
+  /**
+   * @remarks Actually an override of {@linkcode foundry.canvas.primary.CanvasTransformMixin.AnyMixed.updateCanvasTransform | CanvasTransformMixin#updateCanvasTransform}
+   */
   updateCanvasTransform(): void;
 
-  _shouldRenderDepth(): boolean;
+  /**
+   * @remarks Actually an override of {@linkcode foundry.canvas.primary.PrimaryCanvasObjectMixin.AnyMixed._shouldRenderDepth | PrimaryCanvasObjectMixin#_shouldRenderDepth}
+   */
+  protected _shouldRenderDepth(): boolean;
 
   /**
    * Test whether a specific Token occludes this PCO.
@@ -124,28 +134,24 @@ declare class PrimaryOccludableObject {
   testOcclusion(token: Token.Implementation, options?: PrimaryOccludableObjectMixin.TestOcclusionOptions): boolean;
 
   /**
-   * @deprecated since v12, will be removed in v14
-   * @remarks "`#roof` is deprecated in favor of more granular options: `#restrictsLight` and `#restrictsWeather`"
+   * @deprecated "`#roof` is deprecated in favor of more granular options: {@linkcode PrimaryOccludableObject.restrictsLight | #restrictsLight}
+   * and {@linkcode PrimaryOccludableObject.restrictsWeather | #restrictsWeather}" (since v12, until v14)
    */
   get roof(): boolean;
 
   /**
-   * @deprecated since v12, until v14
-   * @remarks "#roof is deprecated in favor of more granular options: #restrictsLight and #restrictsWeather"
+   * @deprecated "`#roof` is deprecated in favor of more granular options: {@linkcode PrimaryOccludableObject.restrictsLight | #restrictsLight}
+   * and {@linkcode PrimaryOccludableObject.restrictsWeather | #restrictsWeather}" (since v12, until v14)
    */
   set roof(enabled);
 
   /**
    * @deprecated since v12, will be removed in v14
-   * @remarks "#containsPixel is deprecated. Use #containsCanvasPoint instead."
+   * @remarks "`#containsPixel` is deprecated. Use {@linkcode PrimaryOccludableObject.containsCanvasPoint | #containsCanvasPoint} instead."
    */
   containsPixel(x: number, y: number, alphaThreshold?: number): boolean;
 
-  /**
-   * @deprecated since v11, will be removed in v13
-   * @remarks "PrimaryCanvasObject#renderOcclusion is deprecated in favor of PrimaryCanvasObject#renderDepth"
-   */
-  renderOcclusion(renderer: PIXI.Renderer): void;
+  #PrimaryOccludableObject: true;
 }
 
 declare function PrimaryOccludableObjectMixin<BaseClass extends PrimaryOccludableObjectMixin.BaseClass>(
@@ -159,10 +165,10 @@ declare namespace PrimaryOccludableObjectMixin {
   type BaseClass = PIXI.Container.AnyConstructor;
 
   /** @internal */
-  type _TestOcclusionOptions = NullishProps<{
+  type _TestOcclusionOptions = InexactPartial<{
     /**
      * Test corners of the hit-box in addition to the token center?
-     * @defaultValue `0`
+     * @defaultValue `true`
      */
     corners: boolean;
   }>;
@@ -182,22 +188,46 @@ declare namespace PrimaryOccludableObjectMixin {
   }
 
   interface HoverFadeState {
-    /** The hovered state */
+    /**
+     * The hovered state
+     * @defaultValue `false`
+     */
     hovered: boolean;
 
-    /** The last time when a mouse event was hovering this object */
+    /**
+     * The last time when a mouse event was hovering this object
+     * @defaultValue `0`
+     */
     hoveredTime: number;
 
-    /** The faded state */
+    /**
+     * @defaultValue `0`
+     * @remarks Gets set to the previous `hoveredTime` in {@linkcode foundry.canvas.groups.PrimaryCanvasGroup._onMouseMove | PrimaryCanvasGroup#_onMouseMove}
+     */
+    _hoveredTime: number;
+
+    /**
+     * The faded state
+     * @defaultValue `false`
+     */
     faded: boolean;
 
-    /** The fading state */
+    /**
+     * The fading state
+     * @defaultValue `false`
+     */
     fading: boolean;
 
-    /** The time the fade animation started */
+    /**
+     * The time the fade animation started
+     * @defaultValue `0`
+     */
     fadingTime: number;
 
-    /** The amount of occlusion */
+    /**
+     * The amount of occlusion
+     * @defaultValue `0`
+     */
     occlusion: number;
   }
 }