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

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;
   }
 }

package/src/foundry/client/canvas/primary/primary-particle-effect.d.mts

@@ -1,7 +1,58 @@
 import type { Identity } from "#utils";
+import type { IDestroyOptions } from "pixi.js";
 import type { CanvasTransformMixin } from "./primary-canvas-object.d.mts";
 
+/**
+ * A configurable particle effect meant to be used in the PrimaryCanvasGroup.
+ * You must provide a full configuration object.
+ * @remarks "full configuration object" meaning something valid for passing to the {@linkcode PIXI.particles.Emitter} constructor.
+ * Any properties optional on the {@linkcode PIXI.particles.EmitterConfigV3 | EmitterConfigV3} interface remain optional.
+ * The {@linkcode PIXI.particles.EmitterConfigV3.autoUpdate | autoUpdate} and {@linkcode PIXI.particles.EmitterConfigV3.emit | emit}
+ * properties are forced `true` and `false`, respectively, before the emitter is created.
+ *
+ * This class is entirely unused as of 13.346
+ */
 declare class PrimaryParticleEffect extends CanvasTransformMixin(PIXI.Container) {
+  constructor(config: PIXI.particles.EmitterConfigV3);
+
+  /**
+   * 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);
+
+  /**
+   * Always false for a Primary Particle Effect.
+   */
+  get shouldRenderDepth(): boolean;
+
+  override destroy(options?: IDestroyOptions | boolean): void;
+
+  /**
+   * Initialize the emitter with optional configuration.
+   * @param config - Optional config object.
+   * @param play   - Should we play immediately? False by default. (default: `false`)
+   */
+  initialize(config: PIXI.particles.EmitterConfigV3, play?: boolean): void;
+
+  /**
+   * Begin animation for the configured emitter.
+   */
+  play(): void;
+
+  /**
+   * Stop animation for the configured emitter.
+   */
+  stop(): void;
+
   #PrimaryParticleEffect: true;
 }
 

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

@@ -1,4 +1,4 @@
-import type { Identity, InexactPartial, NullishProps } from "#utils";
+import type { Identity, InexactPartial } from "#utils";
 import type { PrimaryBaseSamplerShader } from "#client/canvas/rendering/shaders/_module.d.mts";
 import type { TextureLoader } from "#client/canvas/_module.d.mts";
 import type { SpriteMesh } from "#client/canvas/containers/_module.mjs";
@@ -10,37 +10,33 @@ import type { PlaceableObject } from "#client/canvas/placeables/_module.d.mts";
  * A basic PCO sprite mesh which is handling occlusion and depth.
  */
 declare class PrimarySpriteMesh extends PrimaryOccludableObjectMixin(SpriteMesh) {
+  /**
+   * @param options     - Constructor options or a Texture
+   * @param shaderClass - A shader class for the sprite (default: {@linkcode foundry.canvas.rendering.shaders.PrimaryBaseSamplerShader | PrimaryBaseSamplerShader})
+   * @remarks If `options` is an object, `options.shaderClass` takes precedence over the `shaderClass` argument.
+   */
   constructor(
-    /**
-     * The constructor options.
-     * @defaultValue `{}`
-     * @remarks Default is applied if `options` is `instanceof PIXI.Texture`, or neither that nor `instanceof Object`
-     */
-    options?: PrimarySpriteMesh.ConstructorOptions | PIXI.Texture | null,
-
-    /**
-     * The shader class used to render this sprite.
-     * @defaultValue `PrimaryBaseSamplerShader`
-     * @remarks If `options` is an object, `options.shaderClass` takes precedence. If omitted,
-     * or if `options` is a `PIXI.Texture`, default is provided by `??` in function body.
-     */
-    shaderClass?: PrimaryBaseSamplerShader.AnyConstructor | null,
+    options?: PrimarySpriteMesh.ConstructorOptions | PIXI.Texture,
+    shaderClass?: PrimaryBaseSamplerShader.AnyConstructor,
   );
 
+  /** @privateRemarks Fake type override, {@linkcode _updateBatchData} dumps a bunch of extra properties in with no documentation */
+  protected override _batchData: PrimarySpriteMesh.BatchData;
+
   /**
    * The texture alpha data.
+   * @defaultValue `null`
    */
-  protected _textureAlphaData: TextureLoader.TextureAlphaData | null;
+  protected _textureAlphaData: TextureLoader.TextureAlphaData | null | undefined;
 
   /**
-   * The texture alpha threshold used for point containment tests.
-   * If set to a value larger than 0, the texture alpha data is
+   * The texture alpha threshold used for point containment tests. If set to a value larger than 0, the texture alpha data is
    * extracted from the texture at 25% resolution.
    * @defaultValue `0`
    */
   textureAlphaThreshold: number;
 
-  override _onTextureUpdate(): void;
+  protected override _onTextureUpdate(): void;
 
   override setShaderClass(shaderClass: PrimaryBaseSamplerShader.AnyConstructor): void;
 
@@ -53,13 +49,13 @@ declare class PrimarySpriteMesh extends PrimaryOccludableObjectMixin(SpriteMesh)
    *
    * Additionally, It takes into account the desired fit options:
    *
-   * - (default) "fill" computes the exact width and height ratio.
-   * - "cover" takes the maximum ratio of width and height and applies it to both.
-   * - "contain" takes the minimum ratio of width and height and applies it to both.
-   * - "width" applies the width ratio to both width and height.
-   * - "height" applies the height ratio to both width and height.
+   * - (default) `"fill"` computes the exact width and height ratio.
+   * - `"cover"` takes the maximum ratio of width and height and applies it to both.
+   * - `"contain"` takes the minimum ratio of width and height and applies it to both.
+   * - `"width"` applies the width ratio to both width and height.
+   * - `"height"` applies the height ratio to both width and height.
    *
-   * You can also apply optional scaleX and scaleY options to both width and height. The scale is applied after fitting.
+   * You can also apply optional `scaleX` and `scaleY` options to both width and height. The scale is applied after fitting.
    *
    * **Important**: By using this helper, you don't need to set the height, width, and scale properties of the DisplayObject.
    *
@@ -67,7 +63,8 @@ declare class PrimarySpriteMesh extends PrimaryOccludableObjectMixin(SpriteMesh)
    * @param baseWidth  - The base width used for computations.
    * @param baseHeight - The base height used for computations.
    * @param options    - The options.
-   * @throws If either `baseWidth` or `baseHeight` are less than 0, or if `options.fit` is not a FitType
+   * @remarks
+   * @throws If either `baseWidth` or `baseHeight` are `>= 0`
    */
   resize(baseWidth: number, baseHeight: number, options?: PrimarySpriteMesh.ResizeOptions): void;
 
@@ -78,53 +75,43 @@ declare class PrimarySpriteMesh extends PrimaryOccludableObjectMixin(SpriteMesh)
   /**
    * Is the given point in canvas space contained in this object?
    * @param point                 - The point in canvas space
-   * @param textureAlphaThreshold - The minimum texture alpha required for containment
+   * @param textureAlphaThreshold - The minimum texture alpha required for containment (default: {@linkcode PrimarySpriteMesh.textureAlphaThreshold | this.textureAlphaThreshold})
    */
-  containsCanvasPoint(
-    point: PIXI.IPointData,
-
-    /** @defaultValue `this.textureAlphaThreshold` */
-    textureAlphaThreshold?: number,
-  ): boolean;
+  containsCanvasPoint(point: PIXI.IPointData, textureAlphaThreshold?: number): boolean;
 
   /**
    * Is the given point in world space contained in this object?
    * @param point                 - The point in world space
-   * @param textureAlphaThreshold - The minimum texture alpha required for containment
+   * @param textureAlphaThreshold - The minimum texture alpha required for containment (default: {@linkcode PrimarySpriteMesh.textureAlphaThreshold | this.textureAlphaThreshold})
    */
-  containsPoint(
-    point: PIXI.IPointData,
-
-    /** @defaultValue `this.textureAlphaThreshold` */
-    textureAlphaThreshold?: number,
-  ): boolean;
+  containsPoint(point: PIXI.IPointData, textureAlphaThreshold?: number): boolean;
 
   override renderDepthData(renderer: PIXI.Renderer): void;
 
   /**
-   * Render the sprite with ERASE blending.
+   * Render the sprite with {@linkcode PIXI.BLEND_MODES.ERASE | ERASE} blending.
    * Note: The sprite must not have visible/renderable children.
    * @param renderer - The renderer
+   * @internal
    */
   protected _renderVoid(renderer: PIXI.Renderer): void;
 
   /**
-   * @deprecated since v12, will be removed in v14
-   * @remarks "#getPixelAlpha is deprecated without replacement."
+   * @deprecated "`#getPixelAlpha `is deprecated without replacement." (since v12, until v14)
    */
   getPixelAlpha(x: number, y: number): number;
 
   /**
-   * @deprecated since v12, until v14
-   * @remarks "#_getAlphaBounds is deprecated without replacement."
+   * @deprecated "`#_getAlphaBounds` is deprecated without replacement." (since v12, until v14)
    */
   _getAlphaBounds(): PIXI.Rectangle;
 
   /**
-   * @deprecated since v12, until v14
-   * @remarks "#_getTextureCoordinate is deprecated without replacement."
+   * @deprecated "`#_getTextureCoordinate` is deprecated without replacement." (since v12, until v14)
    */
   _getTextureCoordinate(testX: number, testY: number): PIXI.IPointData;
+
+  #PrimarySpriteMesh: true;
 }
 
 declare namespace PrimarySpriteMesh {
@@ -134,36 +121,29 @@ declare namespace PrimarySpriteMesh {
   type FitType = "fill" | "cover" | "contain" | "width" | "height";
 
   /** @internal */
-  type _ConstructorOptions = NullishProps<{
+  type _ConstructorOptions = InexactPartial<{
     /**
      * Texture passed to the SpriteMesh.
-     * @defaultValue `null`
-     * @remarks Default ultimately provided by the `SpriteMesh` constructor
      */
     texture: PIXI.Texture;
 
     /**
-     * The shader class used to render this sprite.
-     * @defaultValue `PrimaryBaseSamplerShader`
-     * @remarks Default provided by `??=` in function body
+     * The name of this sprite.
      */
-    shaderClass: PrimaryBaseSamplerShader.AnyConstructor;
+    name: string | null;
 
     /**
-     * The name of this sprite.
+     * Any object that owns this PCO.
      * @defaultValue `null`
-     * @remarks Default provided by `?? null` in function body
+     * @remarks See {@linkcode foundry.canvas.primary.PrimaryCanvasObjectMixin.AnyMixed.object | PrimaryCanvasObject#object}
      */
-    name: string;
+    object: PlaceableObject.Any | CanvasGroupMixin.AnyMixed | null;
 
     /**
-     * Any object that owns this PCO.
-     * @defaultValue `null`
-     * @remarks Default via `?? null` in function body
-     * @privateRemarks Foundry types as `*`, but the only things passed in practice are `Tile`s, `Token`s, and the `PrimaryCanvasGroup`
+     * The shader class used to render this sprite.
+     * @defaultValue {@linkcode foundry.canvas.rendering.shaders.PrimaryBaseSamplerShader | PrimaryBaseSamplerShader}
      */
-    // TODO: (esheyw) Revisit the "any canvas group" type when groups are done
-    object: PlaceableObject.Any | CanvasGroupMixin.AnyMixed;
+    shaderClass: PrimaryBaseSamplerShader.AnyConstructor;
   }>;
 
   /** The constructor options */
@@ -174,26 +154,52 @@ declare namespace PrimarySpriteMesh {
     /**
      * The fit type.
      * @defaultValue `"fill"`
-     * @remarks Can't be `null` because it only has a parameter default, and is then fed into a switch statement where the default is throw
      */
     fit: FitType;
 
     /**
      * The scale on X axis.
      * @defaultValue `1`
-     * @remarks Can't be `null` because it only has a parameter default and a width scale of 0 is, if not nonsensical, not to be done by accident.
      */
     scaleX: number;
 
     /**
      * The scale on Y axis.
      * @defaultValue `1`
-     * @remarks Can't be `null` because it only has a parameter default and a height scale of 0 is, if not nonsensical, not to be done by accident.
      */
     scaleY: number;
   }>;
 
   interface ResizeOptions extends _ResizeOptions {}
+
+  /** @internal */
+  type _BatchData = InexactPartial<{
+    /** @remarks Doesn't exist prior to first render, set in {@linkcode PrimarySpriteMesh._updateBatchData | PrimarySpriteMesh#_updateBatchData} */
+    elevation: PrimarySpriteMesh["elevation"];
+
+    /** @remarks Doesn't exist prior to first render, set in {@linkcode PrimarySpriteMesh._updateBatchData | PrimarySpriteMesh#_updateBatchData} */
+    textureAlphaThreshold: PrimarySpriteMesh["textureAlphaThreshold"];
+
+    /** @remarks Doesn't exist prior to first render, set in {@linkcode PrimarySpriteMesh._updateBatchData | PrimarySpriteMesh#_updateBatchData} */
+    unoccludedAlpha: PrimarySpriteMesh["unoccludedAlpha"];
+
+    /** @remarks Doesn't exist prior to first render, set in {@linkcode PrimarySpriteMesh._updateBatchData | PrimarySpriteMesh#_updateBatchData} */
+    occludedAlpha: PrimarySpriteMesh["occludedAlpha"];
+
+    /** @remarks Doesn't exist prior to first render, set in {@linkcode PrimarySpriteMesh._updateBatchData | PrimarySpriteMesh#_updateBatchData} */
+    fadeOcclusion: PrimaryOccludableObjectMixin.OcclusionState["fade"];
+
+    /** @remarks Doesn't exist prior to first render, set in {@linkcode PrimarySpriteMesh._updateBatchData | PrimarySpriteMesh#_updateBatchData} */
+    radialOcclusion: PrimaryOccludableObjectMixin.OcclusionState["radial"];
+
+    /** @remarks Doesn't exist prior to first render, set in {@linkcode PrimarySpriteMesh._updateBatchData | PrimarySpriteMesh#_updateBatchData} */
+    visionOcclusion: PrimaryOccludableObjectMixin.OcclusionState["vision"];
+
+    /** @remarks Doesn't exist prior to first render, set in {@linkcode PrimarySpriteMesh._updateBatchData | PrimarySpriteMesh#_updateBatchData} */
+    restrictionState: PrimarySpriteMesh["_restrictionState"];
+  }>;
+
+  interface BatchData extends SpriteMesh.BatchData, _BatchData {}
 }
 
 export default PrimarySpriteMesh;