@league-of-foundry-developers/foundry-vtt-types 13.346.0-beta.20250803190002 → 13.346.0-beta.20250804213559

package/src/foundry/client/canvas/groups/environment.d.mts

@@ -1,10 +1,14 @@
-import type { HandleEmptyObject, Identity, InexactPartial, NullishProps } from "#utils";
+import type { DeepPartial, FixedInstanceType, HandleEmptyObject, Identity, InexactPartial } from "#utils";
 import type { CanvasGroupMixin } from "#client/canvas/groups/_module.d.mts";
+import type { GlobalLightSource } from "#client/canvas/sources/_module.d.mts";
+// Hooks only used for links
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+import type { AllHooks } from "#client/hooks.mjs";
 
 declare module "#configuration" {
   namespace Hooks {
     interface CanvasGroupConfig {
-      EnvironmentCanvasGroup: EnvironmentCanvasGroup.Any;
+      EnvironmentCanvasGroup: EnvironmentCanvasGroup.Implementation;
     }
   }
 }
@@ -16,11 +20,18 @@ declare class EnvironmentCanvasGroup<
   DrawOptions extends EnvironmentCanvasGroup.DrawOptions = EnvironmentCanvasGroup.DrawOptions,
   TearDownOptions extends EnvironmentCanvasGroup.TearDownOptions = EnvironmentCanvasGroup.TearDownOptions,
 > extends CanvasGroupMixin<typeof PIXI.Container, "environment">(PIXI.Container)<DrawOptions, TearDownOptions> {
+  // static override groupName is handled by the CanvasGroupMixin type
+
+  /** @defaultValue `"static"` */
+  override eventMode: PIXI.EventMode;
+
   /**
    * The global light source attached to the environment
-   * @remarks This is `defineProperty`'d as non-writable and non-configurable at construction
+   * @remarks This is `defineProperty`'d at construction with `configurable: false, enumerable: true, writable: false`
+   *
+   * Is {@linkcode GlobalLightSource.initialize | initialized} as part of {@linkcode initialize | GlobalLightSource#initialize}
    */
-  readonly globalLightSource: foundry.canvas.sources.GlobalLightSource.Implementation;
+  readonly globalLightSource: GlobalLightSource.Implementation;
 
   /**
    * Should this group tear down its non-layer children?
@@ -30,65 +41,197 @@ declare class EnvironmentCanvasGroup<
 
   /**
    * Colors exposed by the manager.
-   * @remarks Properties here are only `undefined` prior to `#initialize`ation
+   * @remarks Properties here are only `undefined` prior to {@linkcode EnvironmentCanvasGroup.initialize | initialization}
    */
   colors: EnvironmentCanvasGroup.Colors;
 
   /**
    * Weights used by the manager to compute colors.
-   * @remarks Properties here are only `undefined` prior to `#initialize`ation
+   * @remarks Properties here are only `undefined` prior to {@linkcode EnvironmentCanvasGroup.initialize | initialization}
    */
   weights: EnvironmentCanvasGroup.Weights;
 
   /**
    * Get the darkness level of this scene.
+   * @remarks Only `undefined` prior to initialization
    */
-  get darknessLevel(): number;
+  get darknessLevel(): number | undefined;
 
   protected override _draw(options: HandleEmptyObject<DrawOptions>): Promise<void>;
 
   /**
    * Initialize the scene environment options.
-   * @remarks `@fires PIXI.FederatedEvent type: "darknessChange" - event: {environmentData: {darknessLevel, priorDarknessLevel}}`
+   * @remarks Fires two hooks ({@linkcode AllHooks.configureCanvasEnvironment | configureCanvasEnvironment},
+   * {@linkcode AllHooks.initializeCanvasEnvironment | initializeCanvasEnvironment}) and dispatches a
+   * {@linkcode Canvas.Event.DarknessChange | DarknessChange} PIXI event.
    */
-  initialize(config?: EnvironmentCanvasGroup.InitializeOptions): void;
+  initialize(config?: EnvironmentCanvasGroup.Config): void;
 
   /**
-   * @deprecated since v12, will be removed in v14
-   * @remarks `"EnvironmentCanvasGroup#darknessPenalty is deprecated without replacement. The darkness penalty is no longer applied on light and vision sources."`
+   * @deprecated "`EnvironmentCanvasGroup#darknessPenalty` is deprecated without replacement. The darkness penalty is no longer applied on light and vision sources." (since v12, will be removed in v14)
    */
   get darknessPenalty(): 0;
+
+  #EnvironmentCanvasGroup: true;
 }
 
 declare namespace EnvironmentCanvasGroup {
-  interface Any extends AnyEnvironmentCanvasGroup {}
-  interface AnyConstructor extends Identity<typeof AnyEnvironmentCanvasGroup> {}
+  /** @deprecated There should only be a single implementation of this class in use at one time, use {@linkcode Implementation} instead */
+  type Any = Internal.Any;
+
+  /** @deprecated There should only be a single implementation of this class in use at one time, use {@linkcode ImplementationClass} instead */
+  type AnyConstructor = Internal.AnyConstructor;
+
+  namespace Internal {
+    interface Any extends AnyEnvironmentCanvasGroup {}
+    interface AnyConstructor extends Identity<typeof AnyEnvironmentCanvasGroup> {}
+  }
+
+  interface ImplementationClass extends Identity<typeof CONFIG.Canvas.groups.environment.groupClass> {}
+  interface Implementation extends FixedInstanceType<ImplementationClass> {}
 
   interface DrawOptions extends CanvasGroupMixin.DrawOptions {}
 
   interface TearDownOptions extends CanvasGroupMixin.TearDownOptions {}
 
-  type ColorKeys =
-    | "darkness"
-    | "halfdark"
-    | "background"
-    | "dim"
-    | "bright"
-    | "ambientBrightest"
-    | "ambientDaylight"
-    | "ambientDarkness"
-    | "sceneBackground"
-    | "fogExplored"
-    | "fogUnexplored";
+  /** @privateRemarks Properties sorted in order of initialization */
+  interface Colors {
+    /**
+     * @remarks Only `undefined` prior to {@linkcode EnvironmentCanvasGroup.initialize | initialization}.
+     *
+     * Once initialized, the default value is {@linkcode CONFIG.Canvas.darknessColor}`?? EnvironmentCanvasGroup.#fallbackColors.darknessColor`.
+     * Foundry provides different values for these, so if `CONFIG.Canvas.darknessColor` becomes nullish for whatever reason, the default would
+     * be `0x242448` instead of `0x303030`.
+     */
+    ambientDarkness: Color | undefined;
+
+    /**
+     * @remarks Only `undefined` prior to {@linkcode EnvironmentCanvasGroup.initialize | initialization}.
+     *
+     * Once initialized, the default value if the current scene has token vision enabled is {@linkcode CONFIG.Canvas.daylightColor}
+     * `?? EnvironmentCanvasGroup.#fallbackColors.daylightColor`, both of which are `0xEEEEE`. If token vision is disabled, then
+     * the default is `0xFFFFFF`
+     */
+    ambientDaylight: Color | undefined;
+
+    /**
+     * @remarks Only `undefined` prior to {@linkcode EnvironmentCanvasGroup.initialize | initialization}.
+     *
+     * Once initialized, the default value is {@linkcode CONFIG.Canvas.brightestColor}` ?? EnvironmentCanvasGroup.#fallbackColors.daylightColor`,
+     * both of which are `0xFFFFFF` (the `CONFIG` property by default, the fallback always).
+     */
+    ambientBrightest: Color | undefined;
+
+    /**
+     * @remarks Only `undefined` prior to {@linkcode EnvironmentCanvasGroup.initialize | initialization}.
+     *
+     * Computed by {@linkcode Color.mix | mixing} {@linkcode ambientDarkness} with {@linkcode ambientDaylight} using a
+     * weight of `1.0 - `{@linkcode EnvironmentCanvasGroup.darknessLevel | darknessLevel}
+     */
+    background: Color | undefined;
+
+    /**
+     * @remarks Only `undefined` prior to {@linkcode EnvironmentCanvasGroup.initialize | initialization}.
+     *
+     * Computed by {@linkcode Color.mix | mixing} {@linkcode ambientDarkness} with {@linkcode background} using a
+     * weight of {@linkcode EnvironmentCanvasGroup.Weights.dark | weights.dark}
+     */
+    darkness: Color | undefined;
+
+    /**
+     * @remarks Only `undefined` prior to {@linkcode EnvironmentCanvasGroup.initialize | initialization}.
+     *
+     * Computed by {@linkcode Color.mix | mixing} {@linkcode darkness} with {@linkcode background} using a
+     * weight of {@linkcode EnvironmentCanvasGroup.Weights.halfdark | weights.halfdark}
+     */
+    halfdark: Color | undefined;
+
+    /**
+     * @remarks Only `undefined` prior to {@linkcode EnvironmentCanvasGroup.initialize | initialization}.
+     *
+     * Computed by {@linkcode Color.mix | mixing} {@linkcode background} with {@linkcode ambientBrightest} using a
+     * weight of {@linkcode EnvironmentCanvasGroup.Weights.bright | weights.bright}
+     */
+    bright: Color | undefined;
+
+    /**
+     * @remarks Only `undefined` prior to {@linkcode EnvironmentCanvasGroup.initialize | initialization}.
+     *
+     * Computed by {@linkcode Color.mix | mixing} {@linkcode background} with {@linkcode bright} using a
+     * weight of {@linkcode EnvironmentCanvasGroup.Weights.dim | weights.dim}
+     */
+    dim: Color | undefined;
+
+    /**
+     * @remarks Only `undefined` prior to {@linkcode EnvironmentCanvasGroup.initialize | initialization}.
+     *
+     * Computed by {@linkcode Color.multiply | multiplying} {@linkcode background} by {@linkcode Config.fogUnexploredColor | fogUnexploredColor}
+     * `?? `{@linkcode Scene.FogColorData.unexplored | canvas.scene.fog.colors.unexplored}` ?? `{@linkcode CONFIG.Canvas.unexploredColor}
+     * `?? EnvironmentCanvasGroup.#fallbackColors.fogUnexplored` (that last being `0x000000`)
+     */
+    fogUnexplored: Color | undefined;
 
-  interface Colors extends Record<EnvironmentCanvasGroup.ColorKeys, Color | undefined> {}
+    /**
+     * @remarks Only `undefined` prior to {@linkcode EnvironmentCanvasGroup.initialize | initialization}.
+     *
+     * Computed by {@linkcode Color.multiply | multiplying} {@linkcode background} by {@linkcode Config.fogExploredColor | fogExploredColor}
+     * `?? `{@linkcode Scene.FogColorData.explored | canvas.scene.fog.colors.explored}` ?? `{@linkcode CONFIG.Canvas.exploredColor}
+     * `?? EnvironmentCanvasGroup.#fallbackColors.fogExplored` (that last being `0x000000`)
+     */
+    fogExplored: Color | undefined;
 
-  type WeightKeys = "dark" | "halfdark" | "dim" | "bright";
+    /**
+     * @remarks Only `undefined` prior to {@linkcode EnvironmentCanvasGroup.initialize | initialization}.
+     *
+     * Once initialized, the default is {@linkcode Config.backgroundColor | backgroundColor}` ?? `{@linkcode Scene.backgroundColor | canvas.scene.backgroundColor}
+     * `?? EnvironmentCanvasGroup.#fallbackColors.backgroundColor` (that last being `0x999999`, matching the field's `initial`)
+     */
+    sceneBackground: Color | undefined;
 
-  interface Weights extends Record<EnvironmentCanvasGroup.WeightKeys, number | undefined> {}
+    /**
+     * @remarks Not set to `undefined` at construction, unlike the other properties. Only exists after {@linkcode EnvironmentCanvasGroup.initialize | initialization}.
+     *
+     * Computed by {@linkcode Color.multiply | multiplying} {@linkcode sceneBackground} by {@linkcode background}
+     */
+    rendererBackground?: Color | undefined;
+  }
+
+  interface Weights {
+    /**
+     * @remarks Only `undefined` prior to {@linkcode EnvironmentCanvasGroup.initialize | initialization}.
+     *
+     * Once initialized, the default is {@linkcode CONFIG.Canvas.lightLevels.dark}`?? 0`, mostly. The `??` left operand is the entire `CONFIG.Canvas.lightLevels` object,
+     * and the default is by `Object.assign`.
+     */
+    dark: number | undefined;
+
+    /**
+     * @remarks Only `undefined` prior to {@linkcode EnvironmentCanvasGroup.initialize | initialization}.
+     *
+     * Once initialized, the default is {@linkcode CONFIG.Canvas.lightLevels.halfdark}`?? 0.5`, mostly. The `??` left operand is the entire `CONFIG.Canvas.lightLevels` object,
+     * and the default is by `Object.assign`.
+     */
+    halfdark: number | undefined;
+
+    /**
+     * @remarks Only `undefined` prior to {@linkcode EnvironmentCanvasGroup.initialize | initialization}.
+     *
+     * Once initialized, the default is {@linkcode CONFIG.Canvas.lightLevels.halfdark}`?? 0.25`, mostly. The `??` left operand is the entire `CONFIG.Canvas.lightLevels` object,
+     * and the default is by `Object.assign`.
+     */
+    dim: number | undefined;
+
+    /**
+     * @remarks Only `undefined` prior to {@linkcode EnvironmentCanvasGroup.initialize | initialization}.
+     *
+     * Once initialized, the default is {@linkcode CONFIG.Canvas.lightLevels.halfdark}`?? 1`, mostly. The `??` left operand is the entire `CONFIG.Canvas.lightLevels` object,
+     * and the default is by `Object.assign`.
+     */
+    bright: number | undefined;
+  }
 
   /** @internal */
-  type _InitializeOptions = NullishProps<{
+  type _Config = InexactPartial<{
     /** The background canvas color */
     backgroundColor: Color.Source;
 
@@ -108,30 +251,30 @@ declare namespace EnvironmentCanvasGroup {
     fogUnexploredColor: Color.Source;
 
     /**
-     * @deprecated since v12 until v14
-     * @remarks "config.darknessLevel parameter into EnvironmentCanvasGroup#initialize is deprecated.
-     * You should pass the darkness level into config.environment.darknessLevel"
-     * @privateRemarks [sic]
+     * The scene environment data
+     * @defaultValue `{}`
+     * @remarks Default applied during destructuring assignment inside {@linkcode EnvironmentCanvasGroup.initialize | #initialize}
+     *
+     * Any values not provided will be filled in via {@linkcode foundry.utils.mergeObject} with this as the `original` and `canvas.scene.toObject().environment`
+     * as the `other`, with `overwrite: false`, so values here should not be `undefined` unless otherwise allowed by the Scene schema.
+     */
+    environment: DeepPartial<Scene.EnvironmentData>;
+
+    /**
+     * @deprecated "`config.darknessLevel` parameter into {@linkcode EnvironmentCanvasGroup.initialize | EnvironmentCanvasGroup#initialize} is deprecated.
+     * You should pass the darkness level into {@linkcode this.environment | config.environment.darknessLevel}" (since v12 until v14)
      */
     darknessLevel: number;
-  }> &
-    InexactPartial<{
-      /**
-       * The scene environment data
-       * @defaultValue `{}`
-       * @remarks Can't be `null` as it only has a parameter default and has properties accessed
-       */
-      environment: NullishProps<Scene.EnvironmentData>;
-    }>;
-
-  interface InitializeOptions extends _InitializeOptions {}
+  }>;
+
+  interface Config extends _Config {}
+
+  /** @deprecated Use {@linkcode EnvironmentCanvasGroup.Config} instead */
+  interface InitializeOptions extends Config {}
 }
 
 export default EnvironmentCanvasGroup;
 
-declare abstract class AnyEnvironmentCanvasGroup extends EnvironmentCanvasGroup<
-  EnvironmentCanvasGroup.DrawOptions,
-  EnvironmentCanvasGroup.TearDownOptions
-> {
+declare abstract class AnyEnvironmentCanvasGroup extends EnvironmentCanvasGroup {
   constructor(...args: never);
 }

package/src/foundry/client/canvas/groups/hidden.d.mts

@@ -1,10 +1,11 @@
-import type { HandleEmptyObject, Identity } from "#utils";
+import type { FixedInstanceType, HandleEmptyObject, Identity } from "#utils";
 import type { CanvasGroupMixin } from "#client/canvas/groups/_module.d.mts";
+import type { CanvasVisionMask, CanvasOcclusionMask, CanvasDepthMask } from "#client/canvas/layers/_module.d.mts";
 
 declare module "#configuration" {
   namespace Hooks {
     interface CanvasGroupConfig {
-      HiddenCanvasGroup: foundry.canvas.groups.HiddenCanvasGroup.Any;
+      HiddenCanvasGroup: HiddenCanvasGroup.Implementation;
     }
   }
 }
@@ -16,25 +17,26 @@ declare class HiddenCanvasGroup<
   DrawOptions extends HiddenCanvasGroup.DrawOptions = HiddenCanvasGroup.DrawOptions,
   TearDownOptions extends HiddenCanvasGroup.TearDownOptions = HiddenCanvasGroup.TearDownOptions,
 > extends CanvasGroupMixin<typeof PIXI.Container, "hidden">(PIXI.Container)<DrawOptions, TearDownOptions> {
-  /**
-   * @defaultValue `"none"`
-   */
+  // static override groupName is handled by the CanvasGroupMixin type
+
+  /** @defaultValue `"none"` */
   override eventMode: PIXI.EventMode;
 
   /**
    * The container which hold masks.
    */
-  masks: PIXI.Container;
+  masks: HiddenCanvasGroup.MasksContainer;
 
   /**
    * Add a mask to this group.
    * @param name          - Name of the mask.
    * @param displayObject - Display object to add.
    * @param position      - Position of the mask.
-   * @throws If `displayObject` doesn't implement a `clear` method, or if `name` is an empty string
-   * @remarks `position` is not used if fasley
+   * @remarks If `position` is passed, uses {@linkcode PIXI.Container.addChildAt | PIXI.Container#addChildAt},
+   * replacing an existing child, otherwise simply appends with `addChild`
+   * @throws If `name` is an empty string
    */
-  addMask(name: string, displayObject: PIXI.DisplayObject, position?: number | null): void;
+  addMask(name: string, displayObject: HiddenCanvasGroup.ObjectWithClear, position?: number): void;
 
   /**
    * Invalidate the masks: flag them for rerendering.
@@ -44,11 +46,40 @@ declare class HiddenCanvasGroup<
   protected override _draw(options: HandleEmptyObject<DrawOptions>): Promise<void>;
 
   protected override _tearDown(options: HandleEmptyObject<TearDownOptions>): Promise<void>;
+
+  #HiddenCanvasGroup: true;
 }
 
 declare namespace HiddenCanvasGroup {
-  interface Any extends AnyHiddenCanvasGroup {}
-  interface AnyConstructor extends Identity<typeof AnyHiddenCanvasGroup> {}
+  /** @deprecated There should only be a single implementation of this class in use at one time, use {@linkcode Implementation} instead */
+  type Any = Internal.Any;
+
+  /** @deprecated There should only be a single implementation of this class in use at one time, use {@linkcode ImplementationClass} instead */
+  type AnyConstructor = Internal.AnyConstructor;
+
+  namespace Internal {
+    interface Any extends AnyHiddenCanvasGroup {}
+    interface AnyConstructor extends Identity<typeof AnyHiddenCanvasGroup> {}
+  }
+
+  interface ImplementationClass extends Identity<typeof CONFIG.Canvas.groups.hidden.groupClass> {}
+  interface Implementation extends FixedInstanceType<ImplementationClass> {}
+
+  /**
+   * @remarks {@linkcode HiddenCanvasGroup.addMask | addMask} throws if the provided object lacks a
+   * `clear` property, and by usage it wants a `() => void` method
+   */
+  interface ObjectWithClear extends PIXI.DisplayObject {
+    clear(): void;
+  }
+
+  interface MasksContainer extends PIXI.Container {
+    canvas: PIXI.LegacyGraphics;
+    scene: PIXI.LegacyGraphics;
+    vision: CanvasVisionMask;
+    occlusion: CanvasOcclusionMask;
+    depth: CanvasDepthMask;
+  }
 
   interface DrawOptions extends CanvasGroupMixin.DrawOptions {}
 
@@ -57,9 +88,6 @@ declare namespace HiddenCanvasGroup {
 
 export default HiddenCanvasGroup;
 
-declare abstract class AnyHiddenCanvasGroup extends HiddenCanvasGroup<
-  HiddenCanvasGroup.DrawOptions,
-  HiddenCanvasGroup.TearDownOptions
-> {
+declare abstract class AnyHiddenCanvasGroup extends HiddenCanvasGroup {
   constructor(...args: never);
 }

package/src/foundry/client/canvas/groups/interface.d.mts

@@ -1,4 +1,4 @@
-import type { HandleEmptyObject, Identity, InexactPartial, NullishProps } from "#utils";
+import type { FixedInstanceType, HandleEmptyObject, Identity, InexactPartial } from "#utils";
 import type { Canvas } from "#client/canvas/_module.d.mts";
 import type { PreciseText } from "#client/canvas/containers/_module.mjs";
 import type { CanvasGroupMixin } from "#client/canvas/groups/_module.d.mts";
@@ -7,7 +7,7 @@ import type { Drawing } from "#client/canvas/placeables/_module.d.mts";
 declare module "#configuration" {
   namespace Hooks {
     interface CanvasGroupConfig {
-      InterfaceCanvasGroup: InterfaceCanvasGroup.Any;
+      InterfaceCanvasGroup: InterfaceCanvasGroup.Implementation;
     }
   }
 }
@@ -19,6 +19,8 @@ declare class InterfaceCanvasGroup<
   DrawOptions extends InterfaceCanvasGroup.DrawOptions = InterfaceCanvasGroup.DrawOptions,
   TearDownOptions extends InterfaceCanvasGroup.TearDownOptions = InterfaceCanvasGroup.TearDownOptions,
 > extends CanvasGroupMixin<typeof PIXI.Container, "interface">(PIXI.Container)<DrawOptions, TearDownOptions> {
+  // static override groupName is handled by the CanvasGroupMixin type
+
   /**
    * Add a PrimaryGraphics to the group.
    * @param drawing - The Drawing being added
@@ -36,44 +38,56 @@ declare class InterfaceCanvasGroup<
   protected override _draw(options: HandleEmptyObject<DrawOptions>): Promise<void>;
 
   /**
-   * Display scrolling status text originating from this ObjectHUD container.
+   * Display scrolling status text originating from an origin point on the Canvas.
    * @param origin  - An origin point where the text should first emerge
    * @param content - The text content to display
-   * @param options - Options which customize the text animation
-   * @returns The created PreciseText object which is scrolling
-   * @remarks Only returns `null` if the core `scrollingStatusText` setting is falsey
+   * @param options - Options which customize the text animation (default: `{}`)
+   * @returns The created {@linkcode PreciseText} object which is scrolling
+   * @remarks Only returns `undefined` if the core `scrollingStatusText` setting is falsey
    */
   createScrollingText(
     origin: Canvas.Point,
     content: string,
     options?: InterfaceCanvasGroup.CreateScrollingTextOptions,
-  ): Promise<PreciseText | null>;
+  ): Promise<PreciseText | undefined>;
+
+  #InterfaceCanvasGroup: true;
 }
 
 declare namespace InterfaceCanvasGroup {
-  interface Any extends AnyInterfaceCanvasGroup {}
-  interface AnyConstructor extends Identity<typeof AnyInterfaceCanvasGroup> {}
+  /** @deprecated There should only be a single implementation of this class in use at one time, use {@linkcode Implementation} instead */
+  type Any = Internal.Any;
+
+  /** @deprecated There should only be a single implementation of this class in use at one time, use {@linkcode ImplementationClass} instead */
+  type AnyConstructor = Internal.AnyConstructor;
+
+  namespace Internal {
+    interface Any extends AnyInterfaceCanvasGroup {}
+    interface AnyConstructor extends Identity<typeof AnyInterfaceCanvasGroup> {}
+  }
+
+  interface ImplementationClass extends Identity<typeof CONFIG.Canvas.groups.interface.groupClass> {}
+  interface Implementation extends FixedInstanceType<ImplementationClass> {}
 
   /** @internal */
-  type _CreateScrollingTextOptions = NullishProps<{
+  type _CreateScrollingTextOptions = InexactPartial<{
     /**
      * The distance in pixels that the scrolling text should travel
      * @defaultValue Double the width or height of the text, depending on direction
-     * @remarks Default provided by `??`
      */
     distance: number;
 
     /**
      * The original anchor point where the text appears
-     * @defaultValue `CONST.TEXT_ANCHOR_POINTS.CENTER`
+     * @defaultValue {@linkcode CONST.TEXT_ANCHOR_POINTS.CENTER}
      */
-    anchor: foundry.CONST.TEXT_ANCHOR_POINTS;
+    anchor: CONST.TEXT_ANCHOR_POINTS;
 
     /**
      * The direction in which the text scrolls
-     * @defaultValue `CONST.TEXT_ANCHOR_POINTS.TOP`
+     * @defaultValue {@linkcode CONST.TEXT_ANCHOR_POINTS.TOP}
      */
-    direction: foundry.CONST.TEXT_ANCHOR_POINTS;
+    direction: CONST.TEXT_ANCHOR_POINTS;
 
     /**
      * An amount of randomization between [0, 1] applied to the initial position
@@ -81,19 +95,16 @@ declare namespace InterfaceCanvasGroup {
      * @remarks Only used if truthy
      */
     jitter: number;
-  }> &
-    InexactPartial<{
-      /**
-       * The duration of the scrolling effect in milliseconds
-       * @defaultValue `2000`
-       * @remarks Can't be `null` as it only has a parameter default and a duration of `0` is not appropriate
-       */
-      duration: number;
-    }> &
-    /*
-     * Additional parameters of PIXI.TextStyle which are applied to the text
-     * Excess keys are collected as `{...textStyle}` and passed to {@linkcode PreciseText.getTextStyle} which checks for `!== undefined`, so this can't be NullishProps
+
+    /**
+     * The duration of the scrolling effect in milliseconds
+     * @defaultValue `2000`
      */
+    duration: number;
+  }> &
+    // Additional parameters of PIXI.TextStyle which are applied to the text
+    // Excess keys are collected as `{...textStyle}` and passed to {@linkcode PreciseText.getTextStyle} which checks for `!== undefined`,
+    // so this doesn't fall under the usual 'no InexactPartial on external interfaces' rule
     InexactPartial<PIXI.ITextStyle>;
 
   interface CreateScrollingTextOptions extends _CreateScrollingTextOptions {}

package/src/foundry/client/canvas/groups/overlay.d.mts

@@ -1,11 +1,11 @@
-import type { Identity } from "#utils";
+import type { FixedInstanceType, Identity } from "#utils";
 import type { CanvasGroupMixin } from "#client/canvas/groups/_module.d.mts";
 import type { UnboundContainer } from "#client/canvas/containers/_module.d.mts";
 
 declare module "#configuration" {
   namespace Hooks {
     interface CanvasGroupConfig {
-      OverlayCanvasGroup: OverlayCanvasGroup.Any;
+      OverlayCanvasGroup: OverlayCanvasGroup.Implementation;
     }
   }
 }
@@ -17,6 +17,8 @@ declare class OverlayCanvasGroup<
   DrawOptions extends OverlayCanvasGroup.DrawOptions = OverlayCanvasGroup.DrawOptions,
   TearDownOptions extends OverlayCanvasGroup.TearDownOptions = OverlayCanvasGroup.TearDownOptions,
 > extends CanvasGroupMixin<typeof UnboundContainer, "overlay">(UnboundContainer)<DrawOptions, TearDownOptions> {
+  // static override groupName is handled by the CanvasGroupMixin type
+
   /**
    * Should this group tear down its non-layer children?
    * @defaultValue `false`
@@ -25,8 +27,19 @@ declare class OverlayCanvasGroup<
 }
 
 declare namespace OverlayCanvasGroup {
-  interface Any extends AnyOverlayCanvasGroup {}
-  interface AnyConstructor extends Identity<typeof AnyOverlayCanvasGroup> {}
+  /** @deprecated There should only be a single implementation of this class in use at one time, use {@linkcode Implementation} instead */
+  type Any = Internal.Any;
+
+  /** @deprecated There should only be a single implementation of this class in use at one time, use {@linkcode ImplementationClass} instead */
+  type AnyConstructor = Internal.AnyConstructor;
+
+  namespace Internal {
+    interface Any extends AnyOverlayCanvasGroup {}
+    interface AnyConstructor extends Identity<typeof AnyOverlayCanvasGroup> {}
+  }
+
+  interface ImplementationClass extends Identity<typeof CONFIG.Canvas.groups.overlay.groupClass> {}
+  interface Implementation extends FixedInstanceType<ImplementationClass> {}
 
   interface DrawOptions extends CanvasGroupMixin.DrawOptions {}