@league-of-foundry-developers/foundry-vtt-types 13.346.0-beta.20250804084032 → 13.346.0-beta.20250805163236

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@league-of-foundry-developers/foundry-vtt-types",
-  "version": "13.346.0-beta.20250804084032",
+  "version": "13.346.0-beta.20250805163236",
   "description": "TypeScript type definitions for Foundry VTT",
   "type": "module",
   "types": "./src/index.d.mts",

package/src/configuration/configuration.d.mts

@@ -344,9 +344,9 @@ export interface SettingConfig {
       choices: InterfaceToObject<typeof CONFIG.Dice.rollModes>;
     },
     // Note(LukeAbby): This override is necessary because the `initial` wasn't removing `null`.
-    CONFIG.Dice.RollMode | null | undefined,
-    CONFIG.Dice.RollMode,
-    CONFIG.Dice.RollMode
+    foundry.dice.Roll.Mode | null | undefined,
+    foundry.dice.Roll.Mode,
+    foundry.dice.Roll.Mode
   >;
   "core.rtcClientSettings": typeof AVSettings.schemaFields.client;
   "core.rtcWorldSettings": typeof AVSettings.schemaFields.world;

package/src/configuration/hooks.d.mts

@@ -43,10 +43,12 @@ export interface DeprecatedHookConfig {
   /**
    * @deprecated This hook appears to have been deleted.
    */
-  getSceneNavigationContext: (
-    app: foundry.applications.ui.SceneNavigation,
-    contextOptions: foundry.applications.ux.ContextMenu.Entry<HTMLElement>[],
-  ) => boolean | void;
+  getSceneNavigationContext: (app: never, contextOptions: never) => never;
+
+  /**
+   * @deprecated Removed without replacement in v13. This warning will be removed in v14.
+   */
+  initializeDarknessSources: (group: never) => never;
 }
 
 /**

package/src/foundry/client/canvas/board.d.mts

@@ -414,7 +414,7 @@ declare class Canvas extends _InternalCanvas {
   /**
    * Create a SceneManager instance used for this Scene, if any.
    */
-  static getSceneManager(scene: Scene.Implementation): foundry.canvas.SceneManager | null;
+  static getSceneManager(scene: Scene.Implementation): foundry.canvas.SceneManager.Any | null;
 
   /**
    * Get the value of a GL parameter

package/src/foundry/client/canvas/containers/elements/door-control.d.mts

@@ -76,11 +76,19 @@ declare class DoorControl extends PIXI.Container {
 }
 
 declare namespace DoorControl {
-  interface Any extends AnyDoorControl {}
-  interface AnyConstructor extends Identity<typeof AnyDoorControl> {}
+  /** @deprecated There should only be a single implementation of this class in use at one time, use {@linkcode Implementation} instead */
+  type Any = Internal.Any;
 
-  type ImplementationClass = CONFIG["Canvas"]["doorControlClass"];
-  type Implementation = FixedInstanceType<ImplementationClass>;
+  /** @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 AnyDoorControl {}
+    interface AnyConstructor extends Identity<typeof AnyDoorControl> {}
+  }
+
+  interface ImplementationClass extends Identity<CONFIG["Canvas"]["doorControlClass"]> {}
+  interface Implementation extends FixedInstanceType<ImplementationClass> {}
 
   /**
    * @deprecated Replaced by {@linkcode DoorControl.ImplementationClass}.

package/src/foundry/client/canvas/groups/canvas-group-mixin.d.mts

@@ -1,22 +1,25 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
 import type { FixedInstanceType, HandleEmptyObject, Identity, PrettifyType, RemoveIndexSignatures } from "#utils";
 import type { Canvas } from "#client/canvas/_module.d.mts";
 import type { CanvasLayer } from "#client/canvas/layers/_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 const DynamicClass: new <_Computed extends object>(...args: never) => _Computed;
 
 // @ts-expect-error This is a workaround to allow for dynamic top level properties in a class.
 declare class LayersClass<
-  Group extends CanvasGroupMixin.LayerGroup | NoLayerGroup,
+  Group extends CanvasGroupMixin.ConfiguredGroupNames | NoLayerGroup,
   Instance extends object = RemoveIndexSignatures<CanvasGroupMixin.LayersFor<Group>>,
+  // TODO: include child groups https://github.com/League-of-Foundry-Developers/foundry-vtt-types/issues/3444
 > extends DynamicClass<Instance> {}
 
 // Note(LukeAbby): This interface has been separated out to simplify the constructor edge cases.
 // By avoiding having the instance side it makes the class more malleable and allows generics.
-interface CanvasGroupStatic<Group extends CanvasGroupMixin.LayerGroup | NoLayerGroup> {
+interface CanvasGroupStatic<Group extends CanvasGroupMixin.ConfiguredGroupNames | NoLayerGroup> {
   /**
    * The name of this canvas group
-   * @remarks Foundry marked as abstract
+   * @privateRemarks Foundry marked as abstract
    */
   groupName: Group extends NoLayerGroup ? undefined : Group;
 
@@ -28,30 +31,36 @@ interface CanvasGroupStatic<Group extends CanvasGroupMixin.LayerGroup | NoLayerG
 }
 
 declare class CanvasGroup<
-  Group extends CanvasGroupMixin.LayerGroup | NoLayerGroup,
+  Group extends CanvasGroupMixin.ConfiguredGroupNames | NoLayerGroup,
   DrawOptions extends CanvasGroupMixin.DrawOptions = CanvasGroupMixin.DrawOptions,
   TearDownOptions extends CanvasGroupMixin.TearDownOptions = CanvasGroupMixin.TearDownOptions,
 > extends LayersClass<Group> {
   /** @privateRemarks All mixin classes should accept anything for its constructor. */
   constructor(...args: any[]);
 
-  /** @defaultValue `true` */
+  /**
+   * @defaultValue `true`
+   * @remarks Actually an override of {@linkcode PIXI.Container.sortableChildren | PIXI.Container#sortableChildren}
+   */
   sortableChildren: boolean;
 
   /**
    * The canonical name of the canvas group is the name of the constructor that is the immediate child of the defined base class.
+   * @remarks For example, both `CanvasVisibility` and any user-provided subclasses would return `"CanvasVisibility"`, as that
+   * is the class in the chain that extends {@linkcode CanvasGroup | CanvasGroupMixin}
    */
   get name(): string;
 
   /**
    * The name used by hooks to construct their hook string.
    * Note: You should override this getter if hookName should not return the class constructor name.
+   * @remarks Just returns {@link name | this.name} in core's implementation
    */
   get hookName(): string;
 
   /**
    * A mapping of CanvasLayer classes which belong to this group.
-   * @remarks Default value defined by this._createLayers, which is called in the constructor, and   pulls from CONFIG.Canvas.layers
+   * @remarks Default value defined by this._createLayers, which is called in the constructor, and pulls from {@linkcode CONFIG.Canvas.layers}
    */
   layers: CanvasGroupMixin.LayersFor<Group>;
 
@@ -60,21 +69,27 @@ declare class CanvasGroup<
    */
   protected _createLayers(): CanvasGroupMixin.LayersFor<Group>;
 
-  /** Draw the canvas group and all its component layers. */
+  /**
+   * Draw the canvas group and all its component layers.
+   * @remarks Fires the {@linkcode Hooks.DrawGroup | drawGroupName} hook where `GroupName` is replaced with {@linkcode hookName | this.hookName}
+   */
   draw(options?: HandleEmptyObject<DrawOptions>): Promise<this>;
 
   /**
    * Draw the canvas group and all its component layers.
+   * @remarks Will always be passed an options object by {@linkcode draw}
    */
-  protected _draw(options?: HandleEmptyObject<DrawOptions>): Promise<void>;
+  protected _draw(options: HandleEmptyObject<DrawOptions>): Promise<void>;
 
   /**
    * Remove and destroy all layers from the base canvas.
+   * @remarks Fires the {@linkcode Hooks.TearDownGroup | tearDownGroupName} hook where `GroupName` is replaced with {@linkcode hookName | this.hookName}
    */
-  tearDown(options: HandleEmptyObject<TearDownOptions>): Promise<this>;
+  tearDown(options?: HandleEmptyObject<TearDownOptions>): Promise<this>;
 
   /**
    * Remove and destroy all layers from the base canvas.
+   * @remarks Will always be passed an options object by {@linkcode draw}
    */
   protected _tearDown(options: HandleEmptyObject<TearDownOptions>): Promise<void>;
 
@@ -86,7 +101,7 @@ type NoLayerGroup = typeof _NoLayerGroup;
 
 type ApplyGroup<
   BaseClass extends CanvasGroupMixin.BaseClass,
-  Group extends CanvasGroupMixin.LayerGroup | NoLayerGroup,
+  Group extends CanvasGroupMixin.ConfiguredGroupNames | NoLayerGroup,
 > = CanvasGroupStatic<Group> &
   (new <DrawOptions extends CanvasGroupMixin.DrawOptions, TearDownOptions extends CanvasGroupMixin.TearDownOptions>(
     ...args: ConstructorParameters<BaseClass>
@@ -99,8 +114,8 @@ type ApplyGroup<
 declare function CanvasGroupMixin<
   BaseClass extends CanvasGroupMixin.BaseClass,
   // In `_createLayers` the code assigns top level properties to the class.
-  // This is why Group exists.`
-  Group extends CanvasGroupMixin.LayerGroup | NoLayerGroup = NoLayerGroup,
+  // This is why the Group type param exists.
+  Group extends CanvasGroupMixin.ConfiguredGroupNames | NoLayerGroup = NoLayerGroup,
 >(ContainerClass: BaseClass): CanvasGroupMixin.Mix<BaseClass, Group>;
 
 declare global {
@@ -120,7 +135,7 @@ declare namespace CanvasGroupMixin {
 
   type Mix<
     BaseClass extends CanvasGroupMixin.BaseClass,
-    Group extends CanvasGroupMixin.LayerGroup | NoLayerGroup,
+    Group extends CanvasGroupMixin.ConfiguredGroupNames | NoLayerGroup,
   > = BaseClass & ApplyGroup<BaseClass, Group>;
 
   // eslint-disable-next-line @typescript-eslint/no-empty-object-type
@@ -129,13 +144,9 @@ declare namespace CanvasGroupMixin {
   // eslint-disable-next-line @typescript-eslint/no-empty-object-type
   interface TearDownOptions {}
 
-  interface Layers {
-    readonly [key: string]: CanvasLayer;
-  }
+  type ConfiguredGroupNames = keyof CONFIG["Canvas"]["groups"];
 
-  type LayerGroup = keyof CONFIG["Canvas"]["groups"];
-
-  type LayersFor<T extends LayerGroup | NoLayerGroup> = PrettifyType<
+  type LayersFor<T extends ConfiguredGroupNames | NoLayerGroup> = PrettifyType<
     _FilterOutNever<{
       readonly [K in keyof typeof Canvas.layers]: (typeof Canvas.layers)[K] extends {
         readonly layerClass?: abstract new (...args: infer _1) => infer LayerInstance extends CanvasLayer;
@@ -146,6 +157,17 @@ declare namespace CanvasGroupMixin {
     }>
   >;
 
+  // type ChildGroupsFor<Parent extends ConfiguredGroupNames | NoLayerGroup> = PrettifyType<
+  //   _FilterOutNever<{
+  //     readonly [K in ConfiguredGroupNames]: CONFIG.Canvas.Groups[K] extends {
+  //       readonly groupClass?: abstract new (...args: infer _1) => infer GroupInstance extends AnyMixed;
+  //       readonly parent?: Parent;
+  //     }
+  //       ? GroupInstance
+  //       : never;
+  //   }>
+  // >;
+
   /** @internal */
   type _FilterOutNever<T> = {
     [K in keyof T as [T[K]] extends [never] ? never : K]: T[K];
@@ -159,7 +181,7 @@ declare namespace CanvasGroupMixin {
 
 export default CanvasGroupMixin;
 
-declare abstract class InnerAnyCanvasGroup extends CanvasGroup<
+declare abstract class _InnerAnyCanvasGroup extends CanvasGroup<
   NoLayerGroup,
   CanvasGroupMixin.DrawOptions,
   CanvasGroupMixin.TearDownOptions
@@ -167,11 +189,11 @@ declare abstract class InnerAnyCanvasGroup extends CanvasGroup<
   constructor(...args: never);
 }
 
-declare class MixableContainer extends PIXI.Container {
+declare class _MixableContainer extends PIXI.Container {
   constructor(...args: any[]);
 }
 
-declare const MergedCanvasGroup: typeof MixableContainer & typeof InnerAnyCanvasGroup & CanvasGroupStatic<any>;
+declare const MergedCanvasGroup: typeof _MixableContainer & typeof _InnerAnyCanvasGroup & CanvasGroupStatic<any>;
 
 // Note(LukeAbby) It's more involved than typical to get a proper `AnyCanvasGroup` type because
 // static side and instance side have been split apart and mixing `PIXI.Container` has to be done

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

@@ -1,15 +1,18 @@
-import type { HandleEmptyObject, Identity, NullishProps } from "#utils";
-import type { Canvas } from "#client/canvas/_module.d.mts";
+import type { FixedInstanceType, HandleEmptyObject, Identity, InexactPartial } from "#utils";
+import type { Canvas, sources } from "#client/canvas/_module.d.mts";
 import type { CanvasAnimation } from "#client/canvas/animation/_module.d.mts";
 import type { AbstractBaseShader } from "#client/canvas/rendering/shaders/_module.d.mts";
 import type { VisualEffectsMaskingFilter } from "#client/canvas/rendering/filters/_module.d.mts";
-import type { CanvasGroupMixin } from "#client/canvas/groups/_module.d.mts";
+import type { CanvasGroupMixin, CanvasVisibility, EnvironmentCanvasGroup } from "#client/canvas/groups/_module.d.mts";
 import type * as layers from "#client/canvas/layers/_module.d.mts";
+// Only used for, and aliased to match, foundry's links
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+import type { AllHooks as hookEvents } from "#client/hooks.mjs";
 
 declare module "#configuration" {
   namespace Hooks {
     interface CanvasGroupConfig {
-      EffectsCanvasGroup: EffectsCanvasGroup.Any;
+      EffectsCanvasGroup: EffectsCanvasGroup.Implementation;
     }
   }
 }
@@ -21,7 +24,7 @@ declare module "#configuration" {
  *  The effects canvas group is now only performing shape initialization, logic that needs to happen at
  *  the placeable or object level is now their burden.
  *  - [DONE] Adding or removing a source from the EffectsCanvasGroup collection.
- *  - [TODO] A change in a darkness source should re-initialize all overlaping light and vision source.
+ *  - [TODO] A change in a darkness source should re-initialize all overlapping light and vision source.
  *
  * ### Hook Events
  * - {@linkcode hookEvents.lightingRefresh}
@@ -30,6 +33,8 @@ declare class EffectsCanvasGroup<
   DrawOptions extends EffectsCanvasGroup.DrawOptions = EffectsCanvasGroup.DrawOptions,
   TearDownOptions extends EffectsCanvasGroup.TearDownOptions = EffectsCanvasGroup.TearDownOptions,
 > extends CanvasGroupMixin(PIXI.Container)<DrawOptions, TearDownOptions> {
+  // static override groupName is handled by the CanvasGroupMixin type
+
   /**
    * Whether to currently animate light sources.
    * @defaultValue `true`
@@ -44,54 +49,68 @@ declare class EffectsCanvasGroup<
 
   /**
    * A mapping of light sources which are active within the rendered Scene.
+   * @remarks Foundry always initializes prior to adding to this collection
    */
-  lightSources: Collection<foundry.canvas.sources.PointLightSource>;
+  // TODO: Make .InitializedImplementation when https://github.com/League-of-Foundry-Developers/foundry-vtt-types/issues/3438 is completed
+  lightSources: Collection<sources.PointLightSource.Internal.Any>;
 
   /**
    * A mapping of darkness sources which are active within the rendered Scene.
+   * @remarks Foundry always initializes prior to adding to this collection
    */
-  darknessSources: Collection<foundry.canvas.sources.PointDarknessSource>;
+  // TODO: Make .InitializedImplementation
+  darknessSources: Collection<sources.PointDarknessSource.Internal.Any>;
 
   /**
    * A Collection of vision sources which are currently active within the rendered Scene.
+   * @remarks Foundry always initializes prior to adding to this collection
    */
-  visionSources: Collection<foundry.canvas.sources.PointVisionSource.Any>;
+  // TODO: Make .InitializedImplementation
+  visionSources: Collection<sources.PointVisionSource.Internal.Any>;
 
   /**
    * A set of vision mask filters used in visual effects group
    */
-  visualEffectsMaskingFilters: Set<VisualEffectsMaskingFilter>;
+  visualEffectsMaskingFilters: Set<VisualEffectsMaskingFilter.Implementation>;
 
   /**
    * Iterator for all light and darkness sources.
    */
+  // TODO: Make .InitializedImplementation
   allSources(): Generator<
-    foundry.canvas.sources.PointDarknessSource | foundry.canvas.sources.PointLightSource,
+    sources.PointDarknessSource.Internal.Any | sources.PointLightSource.Internal.Any,
     void,
     undefined
   >;
 
-  override _createLayers(): Record<string, layers.CanvasLayer>;
+  /**
+   * @remarks `EffectsCanvasGroup` doesn't use the same dynamic layer property assignment as other groups, instead this returns
+   * an object with known keys ({@linkcode background}, {@linkcode illumination}, {@linkcode coloration}, and {@linkcode darkness})
+   */
+  protected override _createLayers(): EffectsCanvasGroup.Layers;
+
+  /** @privateRemarks Fake override to sync with {@linkcode _createLayers} */
+  override layers: EffectsCanvasGroup.Layers;
 
   /**
    * A layer of background alteration effects which change the appearance of the primary group render texture.
    */
-  background: layers.CanvasBackgroundAlterationEffects;
+  background: layers.CanvasBackgroundAlterationEffects.Any;
 
   /**
    * A layer which adds illumination-based effects to the scene.
    */
-  illumination: layers.CanvasIlluminationEffects;
+  illumination: layers.CanvasIlluminationEffects.Any;
 
   /**
    * A layer which adds color-based effects to the scene.
    */
-  coloration: layers.CanvasColorationEffects;
+  coloration: layers.CanvasColorationEffects.Any;
 
   /**
    * A layer which adds darkness effects to the scene.
    */
-  darkness: layers.CanvasDarknessEffects;
+  darkness: layers.CanvasDarknessEffects.Any;
 
   /**
    * Clear all effects containers and animated sources.
@@ -107,12 +126,13 @@ declare class EffectsCanvasGroup<
   initializeLightSources(): void;
 
   /**
-   * Re-initialize the shapes of all darkness sources in the Scene.
-   * This happens before initialization of light sources because darkness sources contribute additional edges which
-   * limit perception.
-   * Packages can use the "initializeDarknessSources" hook to programmatically add darkness sources.
+   * Initialize all sources that generate edges (Darkness and certain Light sources).
+   * Darkness sources always generate edges. Light sources only do so if their priority is strictly greater than 0.
+   * The `edgesSources` array will be rebuilt and sorted by descending priority, in the case of a tie,
+   * DarknessSources take precedence. Otherwise, the existing array is used as-is.
+   * Regardless of whether the array is rebuilt, each source is re-initialized to ensure their geometry is refreshed.
    */
-  initializeDarknessSources(): void;
+  initializePriorityLightSources(): void;
 
   /**
    * Refresh the state and uniforms of all light sources and darkness sources objects.
@@ -129,37 +149,64 @@ declare class EffectsCanvasGroup<
    */
   refreshLighting(): void;
 
+  /**
+   * Test whether the point is inside light.
+   * @param point   - The point to test.
+   * @returns Is inside light?
+   */
+  testInsideLight(point: Canvas.ElevatedPoint, options?: EffectsCanvasGroup.TestInsideLightOptions): boolean;
+
   /**
    * Test whether the point is inside light.
    * @param point     - The point.
    * @param elevation - The elevation of the point.
    * @returns Is inside light?
+   * @deprecated "`EffectsCanvasGroup#testInsideLight(point: Point, elevation: number)` has been deprecated in favor of `EffectsCanvasGroup#testInsideLight(point: ElevatedPoint, options: object)`." (since v13, until v15)
    */
   testInsideLight(point: Canvas.Point, elevation: number): boolean;
 
+  /**
+   * Test whether the point is inside darkness.
+   * @param point   - The point to test.
+   * @returns Is inside darkness?
+   */
+  testInsideDarkness(point: Canvas.ElevatedPoint, options?: EffectsCanvasGroup.TestInsideDarknessOptions): boolean;
+
   /**
    * Test whether the point is inside darkness.
    * @param point     - The point.
    * @param elevation - The elevation of the point.
    * @returns Is inside darkness?
    * @remarks Foundry does not use the `elevation` parameter
+   * @deprecated "`EffectsCanvasGroup#testInsideDarkness(point: Point, elevation: number)` has been deprecated in favor of `EffectsCanvasGroup#testInsideDarkness(point: ElevatedPoint, options: object)`." (since v13, until v15)
+   *
    */
-  testInsideDarkness(point: Canvas.Point, _elevation?: number): boolean;
+  testInsideDarkness(point: Canvas.Point, _elevation: number): boolean;
+
+  /**
+   * Get the darkness level at the given point.
+   * @param point - The point.
+   * @returns The darkness level.
+   */
+  getDarknessLevel(point: Canvas.ElevatedPoint): number;
 
   /**
    * Get the darkness level at the given point.
    * @param point     - The point.
    * @param elevation - The elevation of the point.
    * @returns The darkness level.
+   * @deprecated "`EffectsCanvasGroup#getDarknessLevel(point: Point, elevation: number)` has been deprecated in favor of `EffectsCanvasGroup#getDarknessLevel(point: ElevatedPoint)`." (since v13, until v15)
    */
-  getDarknessLevel(point: Canvas.Point, elevation: number): number;
+  getDarknessLevel(point: Canvas.Point, _elevation: number): number;
 
-  override _tearDown(options: HandleEmptyObject<TearDownOptions>): Promise<void>;
+  protected override _tearDown(options: HandleEmptyObject<TearDownOptions>): Promise<void>;
 
   /**
    * Activate vision masking for visual effects
-   * @param enabled - Whether to enable or disable vision masking
-   *                  (default: `true`)
+   * @param enabled - Whether to enable or disable vision masking (default: `true`)
+   * @remarks Despite the name, this will not swap the existing state, just set it to the value of `enabled`.
+   *
+   * Ignores `enabled` and always sets `false` if {@linkcode Canvas.visibilityOptions.persistentVision | canvas.visibilityOptions.persistentVision} is truthy
    */
   toggleMaskingFilters(enabled?: boolean): void;
 
@@ -199,34 +246,66 @@ declare class EffectsCanvasGroup<
   animateDarkness(target?: number, options?: EffectsCanvasGroup.AnimateDarknessOptions): CanvasAnimation.AnimateReturn;
 
   /**
-   * @deprecated since v12, until v14
-   * @remarks "EffectsCanvasGroup#visibility has been deprecated and moved to Canvas#visibility."
+   * @deprecated "`EffectsCanvasGroup#visibility` has been deprecated and moved to {@linkcode foundry.canvas.Canvas.visibility | Canvas#visibility}." (since v12, until v14)
    */
-  get visibility(): Canvas["visibility"];
+  get visibility(): CanvasVisibility.Implementation;
 
   /**
-   * @deprecated since v12, until v14
-   * @remarks "EffectsCanvasGroup#globalLightSource has been deprecated and moved to EnvironmentCanvasGroup#globalLightSource."
+   * @deprecated "`EffectsCanvasGroup#globalLightSource` has been deprecated and moved to {@linkcode EnvironmentCanvasGroup.Implementation.globalLightSource | EnvironmentCanvasGroup#globalLightSource}." (since v12, until v14)
    */
-  get globalLightSource(): Canvas["environment"]["globalLightSource"];
+  get globalLightSource(): EnvironmentCanvasGroup.Implementation["globalLightSource"];
 
   /**
-   * @deprecated since v12
-   * @remarks "EffectsCanvasGroup#updateGlobalLightSource has been deprecated and is part of EnvironmentCanvasGroup#initialize workflow."
+   * @deprecated "`EffectsCanvasGroup#updateGlobalLightSource` has been deprecated and is part of {@linkcode EnvironmentCanvasGroup.Implementation.initialize | EnvironmentCanvasGroup#initialize} workflow." (since v12, until v14)
    */
   updateGlobalLightSource(): void;
+
+  /**
+   * @deprecated "`EffectsCanvasGroup#initializeDarknessSources` and its associated hook are now obsolete and have no replacement." (since v13, until v15)
+   */
+  initializeDarknessSources(): void;
+
+  #EffectsCanvasGroup: true;
 }
 
 declare namespace EffectsCanvasGroup {
-  interface Any extends AnyEffectsCanvasGroup {}
-  interface AnyConstructor extends Identity<typeof AnyEffectsCanvasGroup> {}
+  /** @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 AnyEffectsCanvasGroup {}
+    interface AnyConstructor extends Identity<typeof AnyEffectsCanvasGroup> {}
+  }
+
+  interface ImplementationClass extends Identity<typeof CONFIG.Canvas.groups.effects.groupClass> {}
+  interface Implementation extends FixedInstanceType<ImplementationClass> {}
+
+  /** @internal */
+  type _TestInsideLightOptions = InexactPartial<{
+    /** Optional condition a source must satisfy in order to be tested. */
+    // TODO: Make .InitializedImplementation
+    condition: (source: sources.PointLightSource.Internal.Any | sources.GlobalLightSource.Any) => boolean;
+  }>;
+
+  interface TestInsideLightOptions extends _TestInsideLightOptions {}
 
   /** @internal */
-  type _AnimateDarknessOptions = NullishProps<{
+  type _TestInsideDarknessOptions = InexactPartial<{
+    /** Optional condition a source must satisfy in order to be tested. */
+    // TODO: Make .InitializedImplementation
+    condition: (source: sources.PointDarknessSource.Internal.Any) => boolean;
+  }>;
+
+  interface TestInsideDarknessOptions extends _TestInsideLightOptions {}
+
+  /** @internal */
+  type _AnimateDarknessOptions = InexactPartial<{
     /**
      * The desired animation time in milliseconds. Default is 10 seconds
      * @defaultValue `10000`
-     * @remarks Only has a parameter default; `null` is effectively `0`, resulting in no animation, just instant darkness
      */
     duration: number;
   }>;
@@ -236,13 +315,29 @@ declare namespace EffectsCanvasGroup {
   interface DrawOptions extends CanvasGroupMixin.DrawOptions {}
 
   interface TearDownOptions extends CanvasGroupMixin.TearDownOptions {}
+
+  /**
+   * @remarks {@linkcode EffectsCanvasGroup} overrides {@linkcode CanvasGroupMixin.AnyMixed._createLayers | #_createLayers},
+   * returning a predefined object rather than something built from `CONFIG`. The layer classes are constructed by name,
+   * with no ability to override or extend by users, which is why `.Any` is not used here
+   */
+  interface Layers {
+    /** A layer of background alteration effects which change the appearance of the primary group render texture. */
+    background: layers.CanvasBackgroundAlterationEffects;
+
+    /** A layer which adds illumination-based effects to the scene. */
+    illumination: layers.CanvasIlluminationEffects;
+
+    /** A layer which adds color-based effects to the scene. */
+    coloration: layers.CanvasColorationEffects;
+
+    /** A layer which adds darkness effects to the scene. */
+    darkness: layers.CanvasDarknessEffects;
+  }
 }
 
 export default EffectsCanvasGroup;
 
-declare abstract class AnyEffectsCanvasGroup extends EffectsCanvasGroup<
-  EffectsCanvasGroup.DrawOptions,
-  EffectsCanvasGroup.TearDownOptions
-> {
+declare abstract class AnyEffectsCanvasGroup extends EffectsCanvasGroup {
   constructor(...args: never);
 }