@league-of-foundry-developers/foundry-vtt-types 13.346.0-beta.20250801022737 → 13.346.0-beta.20250801172911

package/src/foundry/client/canvas/layers/masks/vision.d.mts

@@ -59,14 +59,6 @@ declare class CanvasVisionMask extends CachedContainer {
    * @returns The detached vision container.
    */
   detachVision(): CanvasVisionMask.CanvasVisionContainer;
-
-  /**
-   * @deprecated since v11, will be removed in v13
-   * @remarks "CanvasVisionMask#filter has been renamed to blurFilter."
-   */
-  get filter(): this["blurFilter"];
-
-  set filter(f: AlphaBlurFilter);
 }
 
 declare namespace CanvasVisionMask {
@@ -75,18 +67,18 @@ declare namespace CanvasVisionMask {
 
   /**
    * The sight part of {@linkcode CanvasVisionContainer}.
-   * The blend mode is MAX_COLOR.
+   * The blend mode is {@linkcode PIXI.BLEND_MODES.MAX_COLOR | MAX_COLOR}.
    */
   interface CanvasVisionContainerSight extends PIXI.LegacyGraphics {
     /**
      * FOV that should not be committed to fog exploration.
-     * @remarks `blendMode` set to `PIXI.BLEND_MODES.MAX_COLOR`
+     * @remarks `blendMode` set to {@linkcode PIXI.BLEND_MODES.MAX_COLOR}
      */
     preview: PIXI.LegacyGraphics;
   }
 
   interface GlobalLightContainer extends PIXI.Container {
-    /** @remarks `blendMode` set to `PIXI.BLEND_MODES.MAX_COLOR` */
+    /** @remarks `blendMode` set to {@linkcode PIXI.BLEND_MODES.MAX_COLOR} */
     source: PIXI.LegacyGraphics;
 
     meshes: PIXI.Container;
@@ -98,22 +90,24 @@ declare namespace CanvasVisionMask {
 
   /**
    * The light part of {@linkcode CanvasVisionContainer}.
-   * The blend mode is MAX_COLOR.
+   * The blend mode is {@linkcode PIXI.BLEND_MODES.MAX_COLOR | MAX_COLOR}.
    */
   interface CanvasVisionContainerLight extends PIXI.LegacyGraphics {
     /**
      * FOV that should not be committed to fog exploration.
-     * @remarks `blendMode` set to `PIXI.BLEND_MODES.MAX_COLOR`
+     * @remarks `blendMode` set to {@linkcode PIXI.BLEND_MODES.MAX_COLOR}
      */
     preview: PIXI.LegacyGraphics;
 
     /**
      * The sprite with the texture of FOV of cached light sources.
-     * @remarks `blendMode` set to `PIXI.BLEND_MODES.MAX_COLOR`
+     * @remarks `blendMode` set to {@linkcode PIXI.BLEND_MODES.MAX_COLOR}
      */
     cached: SpriteMesh;
 
-    /** The light perception polygons of vision sources and the FOV of vision sources that provide vision. */
+    /**
+     * The light perception polygons of vision sources and the FOV of vision sources that provide vision.
+     */
     mask: LightMaskGraphics;
 
     /**
@@ -123,32 +117,30 @@ declare namespace CanvasVisionMask {
 
     /**
      * The light sources
-     * @remarks `blendMode` set to `PIXI.BLEND_MODES.MAX_COLOR`
+     * @remarks `blendMode` set to {@linkcode PIXI.BLEND_MODES.MAX_COLOR}
      */
     sources: PIXI.LegacyGraphics;
 
     /**
-     * @deprecated since v12, until 14
-     * @remarks "CanvasVisibility#vision#fov#lights is deprecated without replacement."
+     * @deprecated "`CanvasVisibility#vision#fov#lights` is deprecated without replacement." (since v12, until v14)
+     * @privateRemarks Returns `CanvasVisibility##cachedLights`
      */
-    readonly lights: PIXI.LegacyGraphics;
+    get lights(): PIXI.LegacyGraphics;
 
     /**
-     * @deprecated since v12, until 14
-     * @remarks "CanvasVisibility#vision#fov#lightsSprite is deprecated in favor of CanvasVisibility#vision#light#cached."
+     * @deprecated "`CanvasVisibility#vision#fov#lightsSprite` is deprecated in favor of {@linkcode CanvasVisionContainerLight.cached | CanvasVisibility#vision#light#cached}." (since v12, until v14)
      */
-    readonly lightsSprite: SpriteMesh;
+    get lightsSprite(): this["cached"];
 
     /**
-     * @deprecated since v12, until 14
-     * @remarks "CanvasVisibility#vision#fov#tokens is deprecated in favor of CanvasVisibility#vision#light."d
+     * @deprecated "`CanvasVisibility#vision#fov#tokens` is deprecated in favor of {@linkcode CanvasVisionContainer.light | CanvasVisibility#vision#light}." (since v12, until v14)
      */
-    readonly tokens: this;
+    get tokens(): this;
   }
 
   /**
    * The sight part of {@linkcode CanvasVisionContainer}.
-   * The blend mode is ERASE.
+   * The blend mode is {@linkcode PIXI.BLEND_MODES.ERASE | ERASE}.
    */
   interface CanvasVisionContainerDarkness extends PIXI.LegacyGraphics {
     /** Darkness source erasing fog of war. */
@@ -158,9 +150,8 @@ declare namespace CanvasVisionMask {
   /** The currently visible areas. */
   interface CanvasVisionContainer extends PIXI.Container {
     /**
-     * @remarks A void filter necessary when committing fog on a texture for dynamic illumination; disabled by default
-     *
-     * `blendMode` set to `PIXI.BLEND_MODES.MAX_COLOR`
+     * A void filter necessary when committing fog on a texture for dynamic illumination; disabled by default, used only when writing on textures
+     * @remarks `blendMode` set to {@linkcode PIXI.BLEND_MODES.MAX_COLOR}
      */
     containmentFilter: VoidFilter;
 
@@ -169,33 +160,30 @@ declare namespace CanvasVisionMask {
 
     /**
      * Areas visible because of FOV of vision sources.
-     * @remarks `blendMode` set to `PIXI.BLEND_MODES.MAX_COLOR`
+     * @remarks `blendMode` set to {@linkcode PIXI.BLEND_MODES.MAX_COLOR}
      */
     sight: CanvasVisionContainerSight;
 
     /**
      * Areas erased by darkness sources.
-     * @remarks `blendMode` set to `PIXI.BLEND_MODES.ERASE`
+     * @remarks `blendMode` set to {@linkcode PIXI.BLEND_MODES.ERASE}
      */
     darkness: CanvasVisionContainerDarkness;
 
     /**
-     * @deprecated since v12, until 14
-     * @remarks "CanvasVisibility#vision#base is deprecated in favor of CanvasVisibility#vision#light#preview."
+     * @deprecated "`CanvasVisibility#vision#base` is deprecated in favor of {@linkcode CanvasVisionContainerLight.preview | CanvasVisibility#vision#light#preview}." (since v12, until v14)
      */
-    readonly base: CanvasVisionContainerLight["preview"];
+    get base(): this["light"]["preview"];
 
     /**
-     * @deprecated since v12, until 14
-     * @remarks "CanvasVisibility#vision#fov is deprecated in favor of CanvasVisibility#vision#light."
+     * @deprecated "`CanvasVisibility#vision#fov` is deprecated in favor of {@linkcode CanvasVisionContainer.light | CanvasVisibility#vision#light}." (since v12, until v14)
      */
-    readonly fov: CanvasVisionContainerLight;
+    get fov(): this["light"];
 
     /**
-     * @deprecated since v12, until 14
-     * @remarks "CanvasVisibility#vision#los is deprecated in favor of CanvasVisibility#vision#light#mask."
+     * @deprecated "`CanvasVisibility#vision#los` is deprecated in favor of {@linkcode CanvasVisionContainerLight.mask | CanvasVisibility#vision#light#mask}." (since v12, until v14)
      */
-    readonly los: CanvasVisionContainerLight["mask"];
+    get los(): this["light"]["mask"];
   }
 }
 

package/src/foundry/client/canvas/perception/detection-mode.d.mts

@@ -1,61 +1,68 @@
-import type { Brand, Identity, NullishProps } from "#utils";
+import type { Brand, Identity } from "#utils";
 import type { fields } from "#common/data/_module.d.mts";
 import type { DataSchema } from "#common/data/fields.d.mts";
+import type { DataModel } from "#common/abstract/_module.d.mts";
 import type { CanvasVisibility } from "#client/canvas/groups/_module.d.mts";
+import type { PointVisionSource } from "../sources/_module.d.mts";
 
 /**
  * A Detection Mode which can be associated with any kind of sense/vision/perception.
  * A token could have multiple detection modes.
  */
-declare class DetectionMode extends foundry.abstract.DataModel<DetectionMode.Schema> {
+declare class DetectionMode extends DataModel<DetectionMode.Schema> {
   static override defineSchema(): DetectionMode.Schema;
 
   /**
    * Get the detection filter pertaining to this mode.
+   * @remarks Always `undefined` in {@linkcode DetectionMode}
    */
   static getDetectionFilter(): PIXI.Filter | undefined;
 
   /**
    * An optional filter to apply on the target when it is detected with this mode.
+   * @remarks Never set in {@linkcode DetectionMode}; Core subclasses that use one set it in {@linkcode getDetectionFilter} overrides.
    */
-  static _detectionFilter: PIXI.Filter | undefined;
+  protected static _detectionFilter: PIXI.Filter | undefined;
 
   /**
    * The type of the detection mode.
    * @see {@linkcode CONST.WALL_RESTRICTION_TYPES}
-   * @remarks Set via `Object.defineProperty` with a frozen object, so `readonly` is justified both here and for the interface properties
+   * @remarks Returns a reference to a private, frozen object
    */
-  static readonly DETECTION_TYPES: DetectionMode.DetectionTypes;
+  static get DETECTION_TYPES(): DetectionMode.DetectionTypes;
 
   /**
    * The identifier of the basic sight detection mode.
+   * @remarks A subclass could override this in reality, but `"basicSight"` is used as a magic string without checking here in both
+   * {@linkcode foundry.canvas.placeables.Token._prepareDetectionModes | Token#_prepareDetectionModes} and
+   * {@linkcode foundry.canvas.groups.CanvasVisibility.testVisibility | CanvasVisibility#testVisibility}, so it's been typed as the
+   * literal to avoid accidental breakage.
    */
-  static readonly BASIC_MODE_ID: "basicSight";
+  static get BASIC_MODE_ID(): "basicSight";
 
   /**
    * Test visibility of a target object or array of points for a specific vision source.
    * @param visionSource  - The vision source being tested
    * @param mode          - The detection mode configuration
    * @param config        - The visibility test configuration
-   * @returns   Is the test target visible?
+   * @returns Is the test target visible?
    */
   testVisibility(
-    visionSource: foundry.canvas.sources.PointVisionSource.Any,
+    visionSource: PointVisionSource.Any,
     mode: TokenDocument.DetectionModeData,
-    { object, tests }: DetectionMode.TestConfig, // not:null (destructured)
+    config: CanvasVisibility.TestConfig,
   ): boolean;
 
   /**
-   * Can this VisionSource theoretically detect a certain object based on its properties?
+   * Can this {@linkcode PointVisionSource} theoretically detect a certain object based on its properties?
    * This check should not consider the relative positions of either object, only their state.
    * @param visionSource - The vision source being tested
    * @param target       - The target object being tested
    * @returns Can the target object theoretically be detected by this vision source?
+   * @remarks Will always be passed a `target` when called by {@linkcode testVisibility | DetectionMode#testVisibility}, it just might possibly be `undefined`.
+   * All use is gated behind an `instanceof Token` check, so that's fine.
    */
-  protected _canDetect(
-    visionSource: foundry.canvas.sources.PointVisionSource.Any,
-    target: CanvasVisibility.TestObject,
-  ): boolean;
+  protected _canDetect(visionSource: PointVisionSource.Any, target: CanvasVisibility.TestObject | undefined): boolean;
 
   /**
    * Evaluate a single test point to confirm whether it is visible.
@@ -64,11 +71,15 @@ declare class DetectionMode extends foundry.abstract.DataModel<DetectionMode.Sch
    * @param mode         - The detection mode configuration
    * @param target       - The target object being tested
    * @param test         - The test case being evaluated
+   * @remarks As of 13.346, Foundry's implementation does not use `target` at all, neither directly, because the whole method is calling two subsidiary methods, nor in said
+   * subsidiary methods.
+   *
+   * See {@linkcode _canDetect} remarks.
    */
   protected _testPoint(
-    visionSource: foundry.canvas.sources.PointVisionSource.Any,
+    visionSource: PointVisionSource.Any,
     mode: TokenDocument.DetectionModeData,
-    target: CanvasVisibility.TestObject,
+    target: CanvasVisibility.TestObject | undefined,
     test: CanvasVisibility.Test,
   ): boolean;
 
@@ -81,11 +92,14 @@ declare class DetectionMode extends foundry.abstract.DataModel<DetectionMode.Sch
    * @param target          - The target object being tested
    * @param test            - The test case being evaluated
    * @returns Is the LOS requirement satisfied for this test?
+   * @remarks As of 13.346, Foundry's implementation does not use `target` at all.
+   *
+   * See {@linkcode _canDetect} remarks.
    */
   protected _testLOS(
-    visionSource: foundry.canvas.sources.PointVisionSource.Any,
+    visionSource: PointVisionSource.Any,
     mode: TokenDocument.DetectionModeData,
-    target: CanvasVisibility.TestObject,
+    target: CanvasVisibility.TestObject | undefined,
     test: CanvasVisibility.Test,
   ): boolean;
 
@@ -96,11 +110,14 @@ declare class DetectionMode extends foundry.abstract.DataModel<DetectionMode.Sch
    * @param target          - The target object being tested
    * @param test            - The test case being evaluated
    * @returns Is the point within the vision angle?
+   * @remarks As of 13.346, Foundry's implementation does not use `target` at all
+   *
+   * See {@linkcode _canDetect} remarks.
    */
   protected _testAngle(
-    visionSource: foundry.canvas.sources.PointVisionSource.Any,
+    visionSource: PointVisionSource.Any,
     mode: TokenDocument.DetectionModeData,
-    target: CanvasVisibility.TestObject,
+    target: CanvasVisibility.TestObject | undefined,
     test: CanvasVisibility.Test,
   ): boolean;
 
@@ -111,13 +128,22 @@ declare class DetectionMode extends foundry.abstract.DataModel<DetectionMode.Sch
    * @param target          - The target object being tested
    * @param test            - The test case being evaluated
    * @returns Is the target within range?
+   * @remarks As of 13.346, Foundry's implementation does not use `target` at all
+   *
+   * See {@linkcode _canDetect} remarks.
    */
   protected _testRange(
-    visionSource: foundry.canvas.sources.PointVisionSource.Any,
+    visionSource: PointVisionSource.Any,
     mode: TokenDocument.DetectionModeData,
-    target: CanvasVisibility.TestObject,
+    target: CanvasVisibility.TestObject | undefined,
     test: CanvasVisibility.Test,
   ): boolean;
+
+  /**
+   * @deprecated "`DetectionMode#BASIC_MODE_ID` is deprecated. Please use {@linkcode DetectionMode.BASIC_MODE_ID} instead." (since v13, until v15)
+   * @privateRemarks This was not previously typed by us, as it had been erroneously marked static in v12
+   */
+  get BASIC_MODE_ID(): typeof DetectionMode.BASIC_MODE_ID;
 }
 
 declare namespace DetectionMode {
@@ -138,16 +164,22 @@ declare namespace DetectionMode {
     /** If this DM is constrained by the vision angle */
     angle: fields.BooleanField<{ initial: true }>;
 
-    type: fields.NumberField<{
-      initial: DetectionMode.DETECTION_TYPES;
-      choices: DetectionMode.DETECTION_TYPES[];
-    }>;
+    type: fields.NumberField<
+      {
+        initial: typeof DetectionMode.DETECTION_TYPES.SIGHT;
+        choices: DetectionMode.DETECTION_TYPES[];
+      },
+      DetectionMode.DETECTION_TYPES,
+      DetectionMode.DETECTION_TYPES,
+      DetectionMode.DETECTION_TYPES
+    >;
   }
 
-  /** @see CanvasVisibility.TestConfig */
-  interface TestConfig
-    extends CanvasVisibility._TestConfigRequired,
-      NullishProps<CanvasVisibility._TestConfigOptional> {}
+  interface CreateData extends fields.SchemaField.CreateData<Schema> {}
+
+  interface UpdateData extends fields.SchemaField.UpdateData<Schema> {}
+
+  interface SourceData extends fields.SchemaField.SourceData<Schema> {}
 
   type DETECTION_TYPES = Brand<number, "DetectionMode.DETECTION_TYPES">;
 

package/src/foundry/client/canvas/perception/detection-modes/darkvision.d.mts

@@ -1,6 +1,7 @@
 import type { Identity } from "#utils";
 import type { DetectionMode } from "../_module.d.mts";
 import type { CanvasVisibility } from "#client/canvas/groups/_module.d.mts";
+import type { PointVisionSource } from "#client/canvas/sources/_module.d.mts";
 
 /**
  * A special detection mode which models a form of darkvision (night vision).
@@ -9,8 +10,8 @@ import type { CanvasVisibility } from "#client/canvas/groups/_module.d.mts";
  */
 declare class DetectionModeDarkvision extends DetectionMode {
   protected override _canDetect(
-    visionSource: foundry.canvas.sources.PointVisionSource.Any,
-    target: CanvasVisibility.TestObject,
+    visionSource: PointVisionSource.Any,
+    target: CanvasVisibility.TestObject | undefined,
   ): boolean;
 }
 

package/src/foundry/client/canvas/perception/detection-modes/invisibility-perception.d.mts

@@ -1,6 +1,8 @@
 import type { Identity } from "#utils";
 import type { DetectionMode } from "../_module.d.mts";
 import type { CanvasVisibility } from "#client/canvas/groups/_module.d.mts";
+import type { PointVisionSource } from "#client/canvas/sources/_module.d.mts";
+import type { GlowOverlayFilter } from "#client/canvas/rendering/filters/_module.d.mts";
 
 /**
  * Detection mode that see invisible creatures.
@@ -9,11 +11,14 @@ import type { CanvasVisibility } from "#client/canvas/groups/_module.d.mts";
  * - The "See" version needs sight and is affected by blindness
  */
 declare class DetectionModeInvisibility extends DetectionMode {
-  static override getDetectionFilter(): PIXI.Filter;
+  static override getDetectionFilter(): GlowOverlayFilter;
+
+  /** @privateRemarks Fake override */
+  protected static override _detectionFilter: GlowOverlayFilter | undefined;
 
   protected override _canDetect(
-    visionSource: foundry.canvas.sources.PointVisionSource.Any,
-    target: CanvasVisibility.TestObject,
+    visionSource: PointVisionSource.Any,
+    target: CanvasVisibility.TestObject | undefined,
   ): boolean;
 }
 

package/src/foundry/client/canvas/perception/detection-modes/light-perception.d.mts

@@ -1,22 +1,23 @@
 import type { Identity } from "#utils";
 import type { DetectionMode } from "../_module.d.mts";
 import type { CanvasVisibility } from "#client/canvas/groups/_module.d.mts";
+import type { PointVisionSource } from "#client/canvas/sources/_module.d.mts";
 
 /**
  * This detection mode tests whether the target is visible due to being illuminated by a light source.
- * By default tokens have light perception with an infinite range if light perception isn't explicitely
+ * By default tokens have light perception with an infinite range if light perception isn't explicitly
  * configured.
  */
 declare class DetectionModeLightPerception extends DetectionMode {
   protected override _canDetect(
-    visionSource: foundry.canvas.sources.PointVisionSource.Any,
-    target: CanvasVisibility.TestObject,
+    visionSource: PointVisionSource.Any,
+    target: CanvasVisibility.TestObject | undefined,
   ): boolean;
 
   protected override _testPoint(
-    visionSource: foundry.canvas.sources.PointVisionSource.Any,
+    visionSource: PointVisionSource.Any,
     mode: TokenDocument.DetectionModeData,
-    target: CanvasVisibility.TestObject,
+    target: CanvasVisibility.TestObject | undefined,
     test: CanvasVisibility.Test,
   ): boolean;
 }

package/src/foundry/client/canvas/perception/detection-modes/super-perception.d.mts

@@ -1,17 +1,22 @@
 import type { Identity } from "#utils";
 import type { DetectionMode } from "../_module.d.mts";
 import type { CanvasVisibility } from "#client/canvas/groups/_module.d.mts";
+import type { PointVisionSource } from "#client/canvas/sources/_module.d.mts";
+import type { OutlineOverlayFilter } from "#client/canvas/rendering/filters/_module.d.mts";
 
 /**
  * Detection mode that see ALL creatures (no blockers).
  * If not constrained by walls, see everything within the range.
  */
 declare class DetectionModeAll extends DetectionMode {
-  static override getDetectionFilter(): PIXI.Filter;
+  static override getDetectionFilter(): OutlineOverlayFilter;
+
+  /** @privateRemarks Fake override */
+  protected static override _detectionFilter: OutlineOverlayFilter | undefined;
 
   protected override _canDetect(
-    visionSource: foundry.canvas.sources.PointVisionSource.Any,
-    target: CanvasVisibility.TestObject,
+    visionSource: PointVisionSource.Any,
+    target: CanvasVisibility.TestObject | undefined,
   ): boolean;
 }
 

package/src/foundry/client/canvas/perception/detection-modes/tremor-perception.d.mts

@@ -1,16 +1,21 @@
 import type { Identity } from "#utils";
 import type { DetectionMode } from "../_module.d.mts";
 import type { CanvasVisibility } from "#client/canvas/groups/_module.d.mts";
+import type { PointVisionSource } from "#client/canvas/sources/_module.d.mts";
+import type { OutlineOverlayFilter } from "#client/canvas/rendering/filters/_module.d.mts";
 
 /**
  * Detection mode that see creatures in contact with the ground.
  */
 declare class DetectionModeTremor extends DetectionMode {
-  static override getDetectionFilter(): PIXI.Filter;
+  static override getDetectionFilter(): OutlineOverlayFilter;
+
+  /** @privateRemarks Fake override */
+  protected static override _detectionFilter: OutlineOverlayFilter | undefined;
 
   protected override _canDetect(
-    visionSource: foundry.canvas.sources.PointVisionSource.Any,
-    target: CanvasVisibility.TestObject,
+    visionSource: PointVisionSource.Any,
+    target: CanvasVisibility.TestObject | undefined,
   ): boolean;
 }
 

package/src/foundry/client/canvas/perception/fog.d.mts

@@ -1,13 +1,19 @@
 import type EventEmitterMixin from "#common/utils/event-emitter.mjs";
 import type { FixedInstanceType, Identity } from "#utils";
-import type TextureExtractor from "#client/canvas/texture-extractor.d.mts";
 import type { SpriteMesh } from "#client/canvas/containers/_module.mjs";
 import type { CanvasVisibility } from "#client/canvas/groups/_module.d.mts";
+import type { Canvas, TextureExtractor } from "#client/canvas/_module.d.mts";
 
 /**
- * A fog of war management class which is the singleton canvas.fog instance.
+ * A fog of war management class which is the singleton {@linkcode Canvas.fog | canvas.fog} instance.
  */
 declare class FogManager extends EventEmitterMixin() {
+  /**
+   * @defaultValue `["explored"]`
+   * @remarks Frozen
+   */
+  static override emittedEvents: readonly string[];
+
   /**
    * The FogExploration document which applies to this canvas view
    * @defaultValue `null`
@@ -17,13 +23,13 @@ declare class FogManager extends EventEmitterMixin() {
   /**
    * Track whether we have pending fog updates which have not yet been saved to the database
    * @defaultValue `false`
-   * @remarks Foundry marked `@internal`
+   * @internal
    */
   protected _updated: boolean;
 
   /**
    * Texture extractor
-   * @remarks Only `undefined` before first `#initialize()`ation. Set to `null` if {@linkcode TextureExtractor} creation fails, and will not retry from that state.
+   * @remarks Only `undefined` before first {@linkcode initialize} call. Set to `null` if {@linkcode TextureExtractor} creation fails, and will not retry from that state.
    */
   get extractor(): TextureExtractor | undefined | null;
 
@@ -42,25 +48,29 @@ declare class FogManager extends EventEmitterMixin() {
    * The configured options used for the saved fog-of-war texture.
    * @remarks Only `undefined` prior to the first time the canvas visibility layer is `#draw()`n
    */
-  get textureConfiguration(): CanvasVisibility.TextureConfiguration | undefined;
+  get textureConfiguration(): CanvasVisibility["textureConfiguration"];
 
   /**
    * Does the currently viewed Scene support Token field of vision?
    */
-  // TODO: make `Scene.Implementation["tokenVision"]` when docsv2 is done
-  get tokenVision(): boolean;
+  get tokenVision(): Scene.Implementation["tokenVision"];
 
   /**
    * Does the currently viewed Scene support fog of war exploration?
    */
-  // TODO: make `Scene.Implementation["fog"]["exploration"]` when docsv2 is done
-  get fogExploration(): boolean;
+  get fogExploration(): Scene.Implementation["fog"]["exploration"];
+
+  /**
+   * Is this position explored?
+   * @param position - The position to be tested
+   * @returns Is this position explored?
+   */
+  isPointExplored(position: Canvas.Point): boolean;
 
   /**
    * Create the exploration display object with or without a provided texture.
-   * @privateRemarks Despite Foundry only typing this as returning `DisplayObject` in 12.331, it always returns a `SpriteMesh`
    */
-  protected _createExplorationObject(tex?: PIXI.Texture | PIXI.RenderTexture | null): SpriteMesh;
+  protected _createExplorationObject(tex?: PIXI.Texture | PIXI.RenderTexture): SpriteMesh;
 
   /**
    * Initialize fog of war - resetting it when switching scenes or re-drawing the canvas
@@ -72,9 +82,14 @@ declare class FogManager extends EventEmitterMixin() {
    */
   clear(): Promise<void>;
 
+  /**
+   * Destroy this FogManager.
+   */
+  destroy(): void;
+
   /**
    * Once a new Fog of War location is explored, composite the explored container with the current staging sprite.
-   * Once the number of refresh is \> to the commit threshold, save the fog texture to the database.
+   * Once the number of refresh is greater than the commit threshold, save the fog texture to the database.
    */
   commit(): void;
 
@@ -84,8 +99,8 @@ declare class FogManager extends EventEmitterMixin() {
   load(): Promise<PIXI.Texture | void>;
 
   /**
-   * Dispatch a request to reset the fog of war exploration status for all users within this Scene.
-   * Once the server has deleted existing FogExploration documents, the _onReset handler will re-draw the canvas.
+   * Dispatch a request to reset the fog of war exploration status for all users within this {@linkcode Scene}. Once the server has deleted
+   * existing {@linkcode FogExploration} documents, the {@linkcode _handleReset} handler will re-draw the canvas.
    */
   reset(): Promise<void>;
 
@@ -95,6 +110,17 @@ declare class FogManager extends EventEmitterMixin() {
    */
   save(): Promise<void>;
 
+  /**
+   * Synchronize one user's version of the Fog of War for this scene to other users.
+   * Note: This API is experimental and may be removed in later versions *without deprecation*. It is intended for
+   * one-time corrections of users' fog explorations, and should not be used for real-time synchronization of fog
+   * exploration.
+   * @param from - The user whose Fog of War to use as the source of truth.
+   * @param to   - A list of users that should have their Fog of War synced. If none are specified then all users will be synced.
+   * @returns A promise that resolves when synchronization has been completed.
+   */
+  sync(from: User.Implementation, to?: User.Implementation[]): Promise<void>;
+
   /**
    * Extract fog data as a base64 string
    */
@@ -109,37 +135,12 @@ declare class FogManager extends EventEmitterMixin() {
 
   /**
    * If fog of war data is reset from the server, deactivate the current fog and initialize the exploration.
-   * @remarks Foundry marked `@internal`, called externally in the `fogReset` socket handler
+   * @internal
+   * @remarks Called externally in the `fogReset` socket handler
    */
   protected _handleReset(): Promise<void>;
 
-  /**
-   * @deprecated since v11, will be removed in v13
-   * @remarks "pending is deprecated and redirected to the exploration container"
-   */
-  get pending(): CanvasVisibility["explored"];
-
-  /**
-   * @deprecated since v11, will be removed in v13
-   * @remarks "revealed is deprecated and redirected to the exploration container"
-   */
-  get revealed(): CanvasVisibility["explored"];
-
-  /**
-   * @deprecated since v11, will be removed in v13
-   * @remarks "update is obsolete and always returns true. The fog exploration does not record position anymore."
-   *
-   * Both parameters are unused
-   */
-  update(source: any, force?: boolean | null): true;
-
-  /**
-   * @deprecated since v11, will be removed in v13
-   * @remarks "resolution is deprecated and redirected to CanvasVisibility#textureConfiguration"
-   *
-   * Probable Bug Note: Returns the entire `textureConfiguration` object, not just its `resolution` property
-   */
-  get resolution(): CanvasVisibility["textureConfiguration"];
+  #FogManager: true;
 }
 
 declare namespace FogManager {