@league-of-foundry-developers/foundry-vtt-types 13.340.0 → 13.340.1

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

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

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

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

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

@@ -1,5 +1,5 @@
 import type { FixedInstanceType, Mixin } from "fvtt-types/utils";
-import type Document from "../../../../common/abstract/document.d.mts";
+import type Document from "#common/abstract/document.d.mts";
 
 declare class PrimaryCanvasObject {
   /** @privateRemarks All mixin classses should accept anything for its constructor. */
@@ -18,7 +18,7 @@ declare class PrimaryCanvasObject {
    * @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`
    */
-  //TODO: (esheyw) Revisit the "any canvas group" type when groups are done
+  // TODO: (esheyw) Revisit the "any canvas group" type when groups are done
   object: PlaceableObject.Any | CanvasGroupMixin.AnyMixed | null;
 
   /**
@@ -63,10 +63,10 @@ declare class PrimaryCanvasObject {
    */
   protected _onRemoved(parent: PIXI.Container): void;
 
-  /** @see {@link CanvasTransformMixinClass#updateCanvasTransform} */
+  /** @see {@link CanvasTransformMixinClass.updateCanvasTransform | `CanvasTransformMixinClass#updateCanvasTransform`} */
   updateCanvasTransform(): void;
 
-  /** @see {@link CanvasTransformMixinClass#_onCanvasBoundsUpdate} */
+  /** @see {@link CanvasTransformMixinClass._onCanvasBoundsUpdate | `CanvasTransformMixinClass#_onCanvasBoundsUpdate`} */
   protected _onCanvasBoundsUpdate(): void;
 
   /**
@@ -173,7 +173,8 @@ declare global {
   ): Mixin<typeof PrimaryCanvasObject, ReturnType<typeof CanvasTransformMixin<BaseClass>>>;
 
   namespace PrimaryCanvasObjectMixin {
-    type AnyMixedConstructor = ReturnType<typeof PrimaryCanvasObjectMixin<PrimaryCanvasObjectMixin.BaseClass>>;
+    interface AnyMixedConstructor
+      extends ReturnType<typeof PrimaryCanvasObjectMixin<PrimaryCanvasObjectMixin.BaseClass>> {}
     interface AnyMixed extends FixedInstanceType<AnyMixedConstructor> {}
 
     type BaseClass = PIXI.Container.AnyConstructor;
@@ -190,7 +191,7 @@ declare global {
   ): Mixin<typeof CanvasTransformMixinClass, BaseClass>;
 
   namespace CanvasTransformMixin {
-    type AnyMixedConstructor = ReturnType<typeof CanvasTransformMixin<CanvasTransformMixin.BaseClass>>;
+    interface AnyMixedConstructor extends 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 { NullishProps } from "fvtt-types/utils";
+import type { Identity, NullishProps } from "fvtt-types/utils";
 
 declare global {
   /**
@@ -24,7 +24,7 @@ declare global {
 
   namespace PrimaryGraphics {
     interface Any extends AnyPrimaryGraphics {}
-    type AnyConstructor = typeof AnyPrimaryGraphics;
+    interface AnyConstructor extends Identity<typeof AnyPrimaryGraphics> {}
 
     /** @internal */
     type _ConstructorOptions = NullishProps<{
@@ -56,5 +56,5 @@ declare global {
 }
 
 declare abstract class AnyPrimaryGraphics extends PrimaryGraphics {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

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

@@ -118,7 +118,7 @@ declare class PrimaryOccludableObject {
    * @param options - Additional options that affect testing
    * @returns Is the Token occluded by the PCO?
    */
-  testOcclusion(token: Token.ConfiguredInstance, options?: PrimaryOccludableObjectMixin.TestOcclusionOptions): boolean;
+  testOcclusion(token: Token.Implementation, options?: PrimaryOccludableObjectMixin.TestOcclusionOptions): boolean;
 
   /**
    * @deprecated since v12, will be removed in v14
@@ -151,7 +151,7 @@ declare global {
   ): Mixin<typeof PrimaryOccludableObject, ReturnType<typeof PrimaryCanvasObjectMixin<BaseClass>>>;
 
   namespace PrimaryOccludableObjectMixin {
-    type AnyMixedConstructor = ReturnType<typeof PrimaryOccludableObjectMixin<BaseClass>>;
+    interface AnyMixedConstructor extends ReturnType<typeof PrimaryOccludableObjectMixin<BaseClass>> {}
     interface AnyMixed extends FixedInstanceType<AnyMixedConstructor> {}
 
     type BaseClass = PIXI.Container.AnyConstructor;