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

package/src/foundry/client/documents/collections/actors.d.mts

@@ -29,8 +29,16 @@ declare class Actors extends foundry.documents.abstract.WorldCollection<"Actor",
 }
 
 declare namespace Actors {
-  interface Any extends AnyActors {}
-  interface AnyConstructor extends Identity<typeof AnyActors> {}
+  /** @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 AnyActors {}
+    interface AnyConstructor extends Identity<typeof AnyActors> {}
+  }
 
   interface ImplementationClass extends Document.Internal.ConfiguredCollectionClass<"Actor"> {}
   interface Implementation extends Document.Internal.ConfiguredCollection<"Actor"> {}

package/src/foundry/client/documents/collections/card-stacks.d.mts

@@ -11,8 +11,16 @@ declare class CardStacks extends foundry.documents.abstract.WorldCollection<"Car
 }
 
 declare namespace CardStacks {
-  interface Any extends AnyCardStacks {}
-  interface AnyConstructor extends Identity<typeof AnyCardStacks> {}
+  /** @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 AnyCardStacks {}
+    interface AnyConstructor extends Identity<typeof AnyCardStacks> {}
+  }
 
   interface ImplementationClass extends Document.Internal.ConfiguredCollectionClass<"Cards"> {}
   interface Implementation extends Document.Internal.ConfiguredCollection<"Cards"> {}

package/src/foundry/client/documents/collections/chat-messages.d.mts

@@ -34,8 +34,16 @@ declare class ChatMessages extends foundry.documents.abstract.WorldCollection<"C
 }
 
 declare namespace ChatMessages {
-  interface Any extends AnyMessages {}
-  interface AnyConstructor extends Identity<typeof AnyMessages> {}
+  /** @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 AnyChatMessages {}
+    interface AnyConstructor extends Identity<typeof AnyChatMessages> {}
+  }
 
   interface ImplementationClass extends Document.Internal.ConfiguredCollectionClass<"ChatMessage"> {}
   interface Implementation extends Document.Internal.ConfiguredCollection<"ChatMessage"> {}
@@ -51,7 +59,7 @@ declare namespace ChatMessages {
   type Configured = Implementation;
 }
 
-declare abstract class AnyMessages extends ChatMessages {
+declare abstract class AnyChatMessages extends ChatMessages {
   constructor(...args: never);
 }
 

package/src/foundry/client/documents/collections/combat-encounters.d.mts

@@ -42,8 +42,16 @@ declare class CombatEncounters extends foundry.documents.abstract.WorldCollectio
 }
 
 declare namespace CombatEncounters {
-  interface Any extends AnyCombatEncounters {}
-  interface AnyConstructor extends Identity<typeof AnyCombatEncounters> {}
+  /** @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 AnyCombatEncounters {}
+    interface AnyConstructor extends Identity<typeof AnyCombatEncounters> {}
+  }
 
   interface ImplementationClass extends Document.Internal.ConfiguredCollectionClass<"Combat"> {}
   interface Implementation extends Document.Internal.ConfiguredCollection<"Combat"> {}

package/src/foundry/client/documents/collections/fog-explorations.d.mts

@@ -18,8 +18,16 @@ declare class FogExplorations extends foundry.documents.abstract.WorldCollection
 }
 
 declare namespace FogExplorations {
-  interface Any extends AnyFogExplorations {}
-  interface AnyConstructor extends Identity<typeof AnyFogExplorations> {}
+  /** @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 AnyFogExplorations {}
+    interface AnyConstructor extends Identity<typeof AnyFogExplorations> {}
+  }
 
   interface ImplementationClass extends Document.Internal.ConfiguredCollectionClass<"FogExploration"> {}
   interface Implementation extends Document.Internal.ConfiguredCollection<"FogExploration"> {}

package/src/foundry/client/documents/collections/folders.d.mts

@@ -35,8 +35,16 @@ declare class Folders extends foundry.documents.abstract.WorldCollection<"Folder
 }
 
 declare namespace Folders {
-  interface Any extends AnyFolders {}
-  interface AnyConstructor extends Identity<typeof AnyFolders> {}
+  /** @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 AnyFolders {}
+    interface AnyConstructor extends Identity<typeof AnyFolders> {}
+  }
 
   interface ImplementationClass extends Document.Internal.ConfiguredCollectionClass<"Folder"> {}
   interface Implementation extends Document.Internal.ConfiguredCollection<"Folder"> {}

package/src/foundry/client/documents/collections/items.d.mts

@@ -13,8 +13,16 @@ declare class Items extends foundry.documents.abstract.WorldCollection<"Item", "
 }
 
 declare namespace Items {
-  interface Any extends AnyItems {}
-  interface AnyConstructor extends Identity<typeof AnyItems> {}
+  /** @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 AnyItems {}
+    interface AnyConstructor extends Identity<typeof AnyItems> {}
+  }
 
   interface ImplementationClass extends Document.Internal.ConfiguredCollectionClass<"Item"> {}
   interface Implementation extends Document.Internal.ConfiguredCollection<"Item"> {}

package/src/foundry/client/documents/collections/journal.d.mts

@@ -64,8 +64,16 @@ declare class Journal extends foundry.documents.abstract.WorldCollection<"Journa
 }
 
 declare namespace Journal {
-  interface Any extends AnyJournal {}
-  interface AnyConstructor extends Identity<typeof AnyJournal> {}
+  /** @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 AnyJournal {}
+    interface AnyConstructor extends Identity<typeof AnyJournal> {}
+  }
 
   interface ImplementationClass extends Document.Internal.ConfiguredCollectionClass<"JournalEntry"> {}
   interface Implementation extends Document.Internal.ConfiguredCollection<"JournalEntry"> {}

package/src/foundry/client/documents/collections/macros.d.mts

@@ -20,8 +20,16 @@ declare class Macros extends foundry.documents.abstract.WorldCollection<"Macro",
 }
 
 declare namespace Macros {
-  interface Any extends AnyMacros {}
-  interface AnyConstructor extends Identity<typeof AnyMacros> {}
+  /** @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 AnyMacros {}
+    interface AnyConstructor extends Identity<typeof AnyMacros> {}
+  }
 
   interface ImplementationClass extends Document.Internal.ConfiguredCollectionClass<"Macro"> {}
   interface Implementation extends Document.Internal.ConfiguredCollection<"Macro"> {}

package/src/foundry/client/documents/collections/playlists.d.mts

@@ -31,8 +31,16 @@ declare class Playlists extends foundry.documents.abstract.WorldCollection<"Play
 }
 
 declare namespace Playlists {
-  interface Any extends AnyPlaylists {}
-  interface AnyConstructor extends Identity<typeof AnyPlaylists> {}
+  /** @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 AnyPlaylists {}
+    interface AnyConstructor extends Identity<typeof AnyPlaylists> {}
+  }
 
   interface ImplementationClass extends Document.Internal.ConfiguredCollectionClass<"Playlist"> {}
   interface Implementation extends Document.Internal.ConfiguredCollection<"Playlist"> {}

package/src/foundry/client/documents/collections/roll-tables.d.mts

@@ -20,8 +20,16 @@ declare class RollTables extends foundry.documents.abstract.WorldCollection<"Rol
 }
 
 declare namespace RollTables {
-  interface Any extends AnyRollTables {}
-  interface AnyConstructor extends Identity<typeof AnyRollTables> {}
+  /** @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 AnyRollTables {}
+    interface AnyConstructor extends Identity<typeof AnyRollTables> {}
+  }
 
   interface ImplementationClass extends Document.Internal.ConfiguredCollectionClass<"RollTable"> {}
   interface Implementation extends Document.Internal.ConfiguredCollection<"RollTable"> {}

package/src/foundry/client/documents/collections/scenes.d.mts

@@ -49,8 +49,16 @@ declare class Scenes extends foundry.documents.abstract.WorldCollection<"Scene",
 }
 
 declare namespace Scenes {
-  interface Any extends AnyScenes {}
-  interface AnyConstructor extends Identity<typeof AnyScenes> {}
+  /** @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 AnyScenes {}
+    interface AnyConstructor extends Identity<typeof AnyScenes> {}
+  }
 
   interface ImplementationClass extends Document.Internal.ConfiguredCollectionClass<"Scene"> {}
   interface Implementation extends Document.Internal.ConfiguredCollection<"Scene"> {}

package/src/foundry/client/documents/collections/users.d.mts

@@ -58,8 +58,16 @@ declare class Users extends foundry.documents.abstract.WorldCollection<"User", "
 }
 
 declare namespace Users {
-  interface Any extends AnyUsers {}
-  interface AnyConstructor extends Identity<typeof AnyUsers> {}
+  /** @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 AnyUsers {}
+    interface AnyConstructor extends Identity<typeof AnyUsers> {}
+  }
 
   interface ImplementationClass extends Document.Internal.ConfiguredCollectionClass<"User"> {}
   interface Implementation extends Document.Internal.ConfiguredCollection<"User"> {}

package/src/foundry/client/documents/collections/world-settings.d.mts

@@ -30,8 +30,16 @@ declare class WorldSettings extends foundry.documents.abstract.WorldCollection<"
 }
 
 declare namespace WorldSettings {
-  interface Any extends AnyWorldSettings {}
-  interface AnyConstructor extends Identity<typeof AnyWorldSettings> {}
+  /** @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 AnyWorldSettings {}
+    interface AnyConstructor extends Identity<typeof AnyWorldSettings> {}
+  }
 
   interface ImplementationClass extends Document.Internal.ConfiguredCollectionClass<"Setting"> {}
   interface Implementation extends Document.Internal.ConfiguredCollection<"Setting"> {}

package/src/foundry/client/documents/scene.d.mts

@@ -528,42 +528,7 @@ declare namespace Scene {
     /**
      * Fog-exploration settings and other data
      */
-    fog: fields.SchemaField<{
-      /**
-       * Should fog exploration progress be tracked for this Scene?
-       * @defaultValue `true`
-       */
-      exploration: fields.BooleanField<{ initial: true }>;
-
-      /**
-       * The timestamp at which fog of war was last reset for this Scene.
-       * @defaultValue `undefined`
-       */
-      reset: fields.NumberField<{ required: false; initial: undefined }>;
-
-      /**
-       * A special overlay image or video texture which is used for fog of war
-       * @defaultValue `null`
-       */
-      overlay: fields.FilePathField<{ categories: ["IMAGE", "VIDEO"]; virtual: true }>;
-
-      /**
-       * Fog-exploration coloration data
-       */
-      colors: fields.SchemaField<{
-        /**
-         * A color tint applied to explored regions of fog of war
-         * @defaultValue `null`
-         */
-        explored: fields.ColorField;
-
-        /**
-         * A color tint applied to unexplored regions of fog of war
-         * @defaultValue `null`
-         */
-        unexplored: fields.ColorField;
-      }>;
-    }>;
+    fog: fields.SchemaField<FogSchema>;
 
     /**
      * The environment data applied to the Scene.
@@ -689,6 +654,49 @@ declare namespace Scene {
     _stats: fields.DocumentStatsField;
   }
 
+  interface FogSchema extends DataSchema {
+    /**
+     * Should fog exploration progress be tracked for this Scene?
+     * @defaultValue `true`
+     */
+    exploration: fields.BooleanField<{ initial: true }>;
+
+    /**
+     * The timestamp at which fog of war was last reset for this Scene.
+     * @defaultValue `undefined`
+     */
+    reset: fields.NumberField<{ required: false; initial: undefined }>;
+
+    /**
+     * A special overlay image or video texture which is used for fog of war
+     * @defaultValue `null`
+     */
+    overlay: fields.FilePathField<{ categories: ["IMAGE", "VIDEO"]; virtual: true }>;
+
+    /**
+     * Fog-exploration coloration data
+     */
+    colors: fields.SchemaField<FogColorSchema>;
+  }
+
+  interface FogData extends fields.SchemaField.InitializedData<FogSchema> {}
+
+  interface FogColorSchema extends DataSchema {
+    /**
+     * A color tint applied to explored regions of fog of war
+     * @defaultValue `null`
+     */
+    explored: fields.ColorField;
+
+    /**
+     * A color tint applied to unexplored regions of fog of war
+     * @defaultValue `null`
+     */
+    unexplored: fields.ColorField;
+  }
+
+  interface FogColorData extends fields.SchemaField.InitializedData<FogColorSchema> {}
+
   interface EnvironmentSchema extends DataSchema {
     /**
      * The environment darkness level.
@@ -794,7 +802,7 @@ declare namespace Scene {
   interface GridSchema extends DataSchema {
     /**
      * The type of grid, a number from CONST.GRID_TYPES.
-     * @defaultValue `game.system.grid.type`
+     * @defaultValue {@linkcode foundry.packages.BaseSystem.grid | game.system.grid.type}
      */
     type: fields.NumberField<
       {

package/src/foundry/client/hooks.d.mts

@@ -3,15 +3,18 @@ import type { AnyMutableObject, DeepPartial, EmptyObject, ValueOf } from "#utils
 import type Document from "#common/abstract/document.d.mts";
 import type { ProseMirrorDropDown } from "#common/prosemirror/_module.d.mts";
 import type ProseMirrorMenu from "#common/prosemirror/menu.d.mts";
-import type PointVisionSource from "#client/canvas/sources/point-vision-source.d.mts";
 import type RenderedEffectSource from "#client/canvas/sources/rendered-effect-source.d.mts";
 import type { DatabaseUpdateOperation } from "#common/abstract/_types.d.mts";
 import type CompendiumArt from "#client/helpers/media/compendium-art.d.mts";
 import type { Hooks as HookConfigs } from "#configuration";
 import type Hooks from "./helpers/hooks.d.mts";
-import type { Canvas } from "#client/canvas/_module.d.mts";
-import type { CanvasGroupMixin, CanvasVisibility, EffectsCanvasGroup } from "#client/canvas/groups/_module.d.mts";
-import type * as layers from "#client/canvas/layers/_module.d.mts";
+import type { Canvas, layers } from "#client/canvas/_module.d.mts";
+import type {
+  CanvasGroupMixin,
+  CanvasVisibility,
+  EffectsCanvasGroup,
+  EnvironmentCanvasGroup,
+} from "#client/canvas/groups/_module.d.mts";
 
 import type { Note, PlaceableObject, Token } from "#client/canvas/placeables/_module.d.mts";
 import type { TokenRingConfig } from "#client/canvas/placeables/tokens/_module.d.mts";
@@ -633,6 +636,26 @@ export interface AllHooks extends DynamicHooks {
     data: foundry.appv1.sheets.ActorSheet.DropData,
   ) => boolean | void;
 
+  /** EnvironmentCanvasGroup */
+
+  /**
+   * A hook event that fires at the beginning of {@linkcode EnvironmentCanvasGroup.initialize | EnvironmentCanvasGroup#initialize} which
+   * allows the environment configuration to be altered by hook functions.
+   * The provided config param should be mutated to make any desired changes.
+   * A method subscribing to this hook may return false to prevent further configuration.
+   * @remarks This is called by {@linkcode Hooks.call}.
+   */
+  configureCanvasEnvironment: (config: EnvironmentCanvasGroup.Config) => boolean | void;
+
+  /* -------------------------------------------- */
+
+  /**
+   * A hook event that fires at the end of {@linkcode EnvironmentCanvasGroup.initialize | EnvironmentCanvasGroup#initialize} which
+   * allows the environment configuration to be altered by hook functions.
+   * @remarks This is called by {@linkcode Hooks.callAll}.
+   */
+  initializeCanvasEnvironment: () => void;
+
   /** CanvasVisibility */
 
   /**
@@ -640,46 +663,45 @@ export interface AllHooks extends DynamicHooks {
    * @param visibility - The CanvasVisibility instance
    * @remarks This is called by {@linkcode Hooks.callAll}.
    */
-  initializeVisionMode: (visibility: CanvasVisibility.Any) => void;
+  initializeVisionMode: (visibility: CanvasVisibility.Implementation) => void;
 
   /**
    * A hook event that fires when the set of vision sources are initialized.
    * @param sources - The collection of current vision sources
    * @remarks This is called by {@linkcode Hooks.call}.
    */
-  initializeVisionSources: (sources: Collection<PointVisionSource.Any>) => void;
+  initializeVisionSources: (sources: EffectsCanvasGroup.Implementation["visionSources"]) => void;
 
   /**
    * A hook event that fires when the LightingLayer is refreshed.
-   * @param layer - the LightingLayer
+   * @param group - The EffectsCanvasGroup instance
    * @remarks This is called by {@linkcode Hooks.callAll}.
-   * @see {@link LightingLayer.refresh | `LightingLayer#refresh`}
    */
-  lightingRefresh: (layer: layers.LightingLayer) => void;
+  lightingRefresh: (group: EffectsCanvasGroup.Implementation) => void;
 
   /**
    * A hook event that fires when visibility is refreshed.
-   * @param visibility - The CanvasVisibility instance
+   * @param visibility - The {@linkcode CanvasVisibility} instance
    * @remarks This is called by {@linkcode Hooks.callAll}.
    */
-  visibilityRefresh: (visibility: CanvasVisibility) => void;
+  visibilityRefresh: (visibility: CanvasVisibility.Implementation) => void;
 
   /**
    * A hook event that fires during light source initialization.
    * This hook can be used to add programmatic light sources to the Scene.
-   * @param source - The EffectsCanvasGroup where light sources are initialized
+   * @param source - The {@linkcode EffectsCanvasGroup} where light sources are initialized
    * @remarks This is called by {@linkcode Hooks.callAll}.
-   * @see {@link EffectsCanvasGroup.initializeLightSources | `EffectsCanvasGroup#initializeLightSources`}
+   * @see {@link EffectsCanvasGroup.Implementation.initializeLightSources | `EffectsCanvasGroup#initializeLightSources`}
    */
-  initializeLightSources: (group: EffectsCanvasGroup) => void;
+  initializeLightSources: (group: EffectsCanvasGroup.Implementation) => void;
 
   /**
-   * A hook event that fires during darkness source initialization.
-   * This hook can be used to add programmatic darkness sources to the Scene.
-   * @param group - The EffectsCanvasGroup where darkness sources are initialized
+   * A hook event that fires after priority light sources initialization.
+   * This hook can be used to add specific behaviors when for edges sources to the Scene.
+   * @param group - The {@linkcode EffectsCanvasGroup} where priority sources are initialized
    * @remarks This is called by {@linkcode Hooks.callAll}.
    */
-  initializeDarknessSources: (group: EffectsCanvasGroup) => void;
+  initializePriorityLightSources: (group: EffectsCanvasGroup.Implementation) => void;
 
   /**
    * A hook event that fires when the CanvasVisibility layer has been refreshed.
@@ -687,7 +709,7 @@ export interface AllHooks extends DynamicHooks {
    * @remarks This is called by {@linkcode Hooks.callAll}.
    * @see {@link CanvasVisibility.restrictVisibility | `CanvasVisibility#restrictVisibility`}
    */
-  sightRefresh: (visibility: CanvasVisibility) => void;
+  sightRefresh: (visibility: CanvasVisibility.Implementation) => void;
 
   /** Weather */