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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,4 +1,4 @@
-import type { InexactPartial } from "../../../../../types/utils.d.mts";
+import type { NullishProps } from "fvtt-types/utils";
 
 declare global {
   /**
@@ -9,16 +9,10 @@ declare global {
      * @param options - A config object
      */
     constructor(
-      options?: InexactPartial<{
-        /** A geometry passed to the graphics. */
-        geometry: PIXI.GraphicsGeometry;
-
-        /** The name of the PCO. */
-        name: string;
-
-        /** Any object that owns this PCO. */
-        object: PlaceableObject;
-      }>,
+      /**
+       * @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,
     );
 
     override _calculateCanvasBounds(): void;
@@ -27,4 +21,40 @@ declare global {
 
     override containsCanvasPoint(point: PIXI.IPointData): boolean;
   }
+
+  namespace PrimaryGraphics {
+    interface Any extends AnyPrimaryGraphics {}
+    type AnyConstructor = typeof AnyPrimaryGraphics;
+
+    /** @internal */
+    type _ConstructorOptions = NullishProps<{
+      /**
+       * A geometry passed to the graphics.
+       * @defaultValue `new PIXI.GraphicsGeometry()`
+       * @remarks Default via calling `super(geometry)` with a falsey value
+       */
+      geometry: PIXI.GraphicsGeometry;
+
+      /**
+       * The name of the PCO.
+       * @defaultValue `null`
+       * @remarks Default via `?? null` in function body
+       * */
+      name: string;
+
+      /**
+       * 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
+       */
+      object: PlaceableObject.Any;
+    }>;
+
+    interface ConstructorOptions extends _ConstructorOptions {}
+  }
+}
+
+declare abstract class AnyPrimaryGraphics extends PrimaryGraphics {
+  constructor(arg0: never, ...args: never[]);
 }

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

@@ -1,4 +1,4 @@
-import type { InexactPartial, Mixin } from "../../../../../types/utils.d.mts";
+import type { FixedInstanceType, Mixin, NullishProps } from "fvtt-types/utils";
 
 declare class PrimaryOccludableObject {
   /** @privateRemarks All mixin classses should accept anything for its constructor. */
@@ -20,7 +20,7 @@ declare class PrimaryOccludableObject {
    * The occlusion mode of this occludable object.
    * @defaultValue `CONST.OCCLUSION_MODES.NONE`
    */
-  occlusionMode: typeof CONST.OCCLUSION_MODES;
+  occlusionMode: CONST.OCCLUSION_MODES;
 
   /**
    * The unoccluded alpha of this object.
@@ -44,18 +44,40 @@ declare class PrimaryOccludableObject {
 
   /**
    * The amount of rendered FADE, RADIAL, and VISION occlusion.
+   * @defaultValue
+   * ```js
+   * {
+   *   fade: 0.0,
+   *   radial: 0.0,
+   *   vision: 0.0
+   * }
+   * ```
+   * @privateRemarks Foundry marked `@internal`
    */
-  protected _occlusionState: PrimaryOccludableObjectMixin.OcclusionState;
+  _occlusionState: PrimaryOccludableObjectMixin.OcclusionState;
 
   /**
    * The state of hover-fading.
-   */
-  protected _hoverFadeState: PrimaryOccludableObjectMixin.HoverFadeState;
+   * @defaultValue
+   * ```js
+   * {
+   *   hovered: false,
+   *   hoveredTime: 0,
+   *   faded: false,
+   *   fading: false,
+   *   fadingTime: 0,
+   *   occlusion: 0.0
+   * }
+   * ```
+   * @privateRemarks Foundry marked `@internal`
+   */
+  _hoverFadeState: PrimaryOccludableObjectMixin.HoverFadeState;
 
   /**
    * Get the blocking option bitmask value.
+   * @privateRemarks Foundry marked `@internal`
    */
-  protected get _restrictionState(): number;
+  get _restrictionState(): number;
 
   /**
    * Is this object blocking light?
@@ -81,12 +103,13 @@ 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
    */
-  debounceSetOcclusion: (occluded: boolean) => void;
+  debounceSetOcclusion: (occluded: boolean) => boolean;
 
   updateCanvasTransform(): void;
 
-  _shouldRenderDepth: boolean;
+  _shouldRenderDepth(): boolean;
 
   /**
    * Test whether a specific Token occludes this PCO.
@@ -95,37 +118,55 @@ declare class PrimaryOccludableObject {
    * @param options - Additional options that affect testing
    * @returns Is the Token occluded by the PCO?
    */
-  testOcclusion(
-    token: Token,
-    options?: InexactPartial<{
-      /** Test corners of the hit-box in addition to the token center? */
-      corners: boolean;
-    }>,
-  ): boolean;
+  testOcclusion(token: Token.ConfiguredInstance, 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`"
    */
   get roof(): boolean;
 
+  /**
+   * @deprecated since v12, until v14
+   * @remarks "#roof is deprecated in favor of more granular options: #restrictsLight and #restrictsWeather"
+   */
+  set roof(enabled);
+
   /**
    * @deprecated since v12, will be removed in v14
+   * @remarks "#containsPixel is deprecated. Use #containsCanvasPoint instead."
    */
-  containsPixel(x: number, y: number, alphaThreshold: number): boolean;
+  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;
 }
 
 declare global {
-  function PrimaryOccludableObjectMixin<BaseClass extends PIXI.DisplayObject.AnyConstructor>(
+  function PrimaryOccludableObjectMixin<BaseClass extends PrimaryOccludableObjectMixin.BaseClass>(
     DisplayObject: BaseClass,
   ): Mixin<typeof PrimaryOccludableObject, ReturnType<typeof PrimaryCanvasObjectMixin<BaseClass>>>;
 
   namespace PrimaryOccludableObjectMixin {
-    type MixinClass = typeof PrimaryOccludableObject;
+    type AnyMixedConstructor = ReturnType<typeof PrimaryOccludableObjectMixin<BaseClass>>;
+    interface AnyMixed extends FixedInstanceType<AnyMixedConstructor> {}
+
+    type BaseClass = PIXI.Container.AnyConstructor;
+
+    /** @internal */
+    type _TestOcclusionOptions = NullishProps<{
+      /**
+       * Test corners of the hit-box in addition to the token center?
+       * @defaultValue `0`
+       */
+      corners: boolean;
+    }>;
+
+    /** Additional options that affect testing */
+    interface TestOcclusionOptions extends _TestOcclusionOptions {}
 
     interface OcclusionState {
       /** The amount of FADE occlusion */

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

@@ -1,11 +1,4 @@
-import type { InexactPartial } from "../../../../../types/utils.d.mts";
-
-// TODO: Remove when #2570 is completed
-declare const PrimaryBaseSamplerShader: BaseSamplerShader;
-
-declare namespace PrimaryBaseSamplerShader {
-  type AnyConstructor = unknown;
-}
+import type { InexactPartial, NullishProps } from "fvtt-types/utils";
 
 declare global {
   /**
@@ -13,30 +6,31 @@ declare global {
    */
   class PrimarySpriteMesh extends PrimaryOccludableObjectMixin(SpriteMesh) {
     constructor(
-      options?:
-        | InexactPartial<{
-            /** Texture passed to the SpriteMesh. */
-            texture: PIXI.Texture;
-
-            /** The shader class used to render this sprite. */
-            shaderClass: PrimaryBaseSamplerShader.AnyConstructor;
-
-            /** The name of this sprite. */
-            name: string;
-          }>
-        | PIXI.Texture,
-      shaderClass?: PrimaryBaseSamplerShader.AnyConstructor,
+      /**
+       * 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,
     );
 
     /**
      * The texture alpha data.
      */
-    _textureAlphaData: TextureLoader.TextureAlphaData | null;
+    protected _textureAlphaData: TextureLoader.TextureAlphaData | null;
 
     /**
      * 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;
 
@@ -67,21 +61,9 @@ declare global {
      * @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
      */
-    resize(
-      baseWidth: number,
-      baseHeight: number,
-      options?: InexactPartial<{
-        /** The fit type. */
-        fit: "fill" | "cover" | "contain" | "width" | "height";
-
-        /** The scale on X axis. */
-        scaleX: number;
-
-        /** The scale on Y axis. */
-        scaleY: number;
-      }>,
-    ): void;
+    resize(baseWidth: number, baseHeight: number, options?: PrimarySpriteMesh.ResizeOptions): void;
 
     protected override _updateBatchData(): void;
 
@@ -92,7 +74,22 @@ declare global {
      * @param point                 - The point in canvas space
      * @param textureAlphaThreshold - The minimum texture alpha required for containment
      */
-    containsCanvasPoint(point: PIXI.IPointData, textureAlphaThreshold?: number): boolean;
+    containsCanvasPoint(
+      point: PIXI.IPointData,
+      /** @defaultValue `this.textureAlphaThreshold` */
+      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
+     */
+    containsPoint(
+      point: PIXI.IPointData,
+      /** @defaultValue `this.textureAlphaThreshold` */
+      textureAlphaThreshold?: number,
+    ): boolean;
 
     override renderDepthData(renderer: PIXI.Renderer): void;
 
@@ -105,7 +102,93 @@ declare global {
 
     /**
      * @deprecated since v12, will be removed in v14
+     * @remarks "#getPixelAlpha is deprecated without replacement."
      */
     getPixelAlpha(x: number, y: number): number;
+
+    /**
+     * @deprecated since v12, until v14
+     * @remarks "#_getAlphaBounds is deprecated without replacement."
+     */
+    _getAlphaBounds(): PIXI.Rectangle;
+
+    /**
+     * @deprecated since v12, until v14
+     * @remarks "#_getTextureCoordinate is deprecated without replacement."
+     */
+    _getTextureCoordinate(testX: number, testY: number): PIXI.IPointData;
   }
+
+  namespace PrimarySpriteMesh {
+    interface Any extends AnyPrimarySpriteMesh {}
+    type AnyConstructor = typeof AnyPrimarySpriteMesh;
+
+    type FitType = "fill" | "cover" | "contain" | "width" | "height";
+
+    /** @internal */
+    type _ConstructorOptions = NullishProps<{
+      /**
+       * 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
+       */
+      shaderClass: PrimaryBaseSamplerShader.AnyConstructor;
+
+      /**
+       * The name of this sprite.
+       * @defaultValue `null`
+       * @remarks Default provided by `?? null` in function body
+       */
+      name: string;
+
+      /**
+       * 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`
+       */
+      //TODO: (esheyw) Revisit the "any canvas group" type when groups are done
+      object: PlaceableObject.Any | CanvasGroupMixin.AnyMixed;
+    }>;
+
+    /** The constructor options */
+    interface ConstructorOptions extends _ConstructorOptions {}
+
+    /** @internal */
+    type _ResizeOptions = InexactPartial<{
+      /**
+       * 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 {}
+  }
+}
+
+declare abstract class AnyPrimarySpriteMesh extends PrimarySpriteMesh {
+  constructor(arg0: never, ...args: never[]);
 }