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

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

@@ -0,0 +1,110 @@
+import type { HandleEmptyObject, Identity, InexactPartial, NullishProps } 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";
+import type { Drawing } from "#client/canvas/placeables/_module.d.mts";
+
+declare module "#configuration" {
+  namespace Hooks {
+    interface CanvasGroupConfig {
+      InterfaceCanvasGroup: InterfaceCanvasGroup.Any;
+    }
+  }
+}
+
+/**
+ * A container group which displays interface elements rendered above other canvas groups.
+ */
+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> {
+  /**
+   * Add a PrimaryGraphics to the group.
+   * @param drawing - The Drawing being added
+   * @returns The created Graphics instance
+   * @remarks
+   */
+  addDrawing(drawing: Drawing.Implementation): PIXI.Graphics;
+
+  /**
+   * Remove a PrimaryGraphics from the group.
+   * @param drawing - The Drawing being removed
+   */
+  removeDrawing(drawing: Drawing.Implementation): void;
+
+  protected override _draw(options: HandleEmptyObject<DrawOptions>): Promise<void>;
+
+  /**
+   * Display scrolling status text originating from this ObjectHUD container.
+   * @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
+   */
+  createScrollingText(
+    origin: Canvas.Point,
+    content: string,
+    options?: InterfaceCanvasGroup.CreateScrollingTextOptions,
+  ): Promise<PreciseText | null>;
+}
+
+declare namespace InterfaceCanvasGroup {
+  interface Any extends AnyInterfaceCanvasGroup {}
+  interface AnyConstructor extends Identity<typeof AnyInterfaceCanvasGroup> {}
+
+  /** @internal */
+  type _CreateScrollingTextOptions = NullishProps<{
+    /**
+     * 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`
+     */
+    anchor: foundry.CONST.TEXT_ANCHOR_POINTS;
+
+    /**
+     * The direction in which the text scrolls
+     * @defaultValue `CONST.TEXT_ANCHOR_POINTS.TOP`
+     */
+    direction: foundry.CONST.TEXT_ANCHOR_POINTS;
+
+    /**
+     * An amount of randomization between [0, 1] applied to the initial position
+     * @defaultValue `0`
+     * @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
+     */
+    InexactPartial<PIXI.ITextStyle>;
+
+  interface CreateScrollingTextOptions extends _CreateScrollingTextOptions {}
+
+  interface DrawOptions extends CanvasGroupMixin.DrawOptions {}
+
+  interface TearDownOptions extends CanvasGroupMixin.TearDownOptions {}
+}
+
+export default InterfaceCanvasGroup;
+
+declare abstract class AnyInterfaceCanvasGroup extends InterfaceCanvasGroup {
+  constructor(...args: never);
+}

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

@@ -0,0 +1,40 @@
+import type { 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;
+    }
+  }
+}
+
+/**
+ * A container group which is not bound to the stage world transform.
+ */
+declare class OverlayCanvasGroup<
+  DrawOptions extends OverlayCanvasGroup.DrawOptions = OverlayCanvasGroup.DrawOptions,
+  TearDownOptions extends OverlayCanvasGroup.TearDownOptions = OverlayCanvasGroup.TearDownOptions,
+> extends CanvasGroupMixin<typeof UnboundContainer, "overlay">(UnboundContainer)<DrawOptions, TearDownOptions> {
+  /**
+   * Should this group tear down its non-layer children?
+   * @defaultValue `false`
+   */
+  static override tearDownChildren: boolean;
+}
+
+declare namespace OverlayCanvasGroup {
+  interface Any extends AnyOverlayCanvasGroup {}
+  interface AnyConstructor extends Identity<typeof AnyOverlayCanvasGroup> {}
+
+  interface DrawOptions extends CanvasGroupMixin.DrawOptions {}
+
+  interface TearDownOptions extends CanvasGroupMixin.TearDownOptions {}
+}
+
+export default OverlayCanvasGroup;
+
+declare abstract class AnyOverlayCanvasGroup extends OverlayCanvasGroup {
+  constructor(...args: never);
+}

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

@@ -0,0 +1,237 @@
+import type { Brand, HandleEmptyObject, Identity } from "#utils";
+import type { PrimaryCanvasGroupAmbienceFilter } from "#client/canvas/rendering/filters/_module.d.mts";
+import type { CachedContainer, SpriteMesh } from "#client/canvas/containers/_module.d.mts";
+import type { CanvasGroupMixin } from "#client/canvas/groups/_module.d.mts";
+import type { CanvasQuadtree } from "#client/canvas/geometry/quad-tree.d.mts";
+import type { Drawing, Tile, Token } from "#client/canvas/placeables/_module.d.mts";
+import type {
+  PrimaryCanvasObjectMixin,
+  PrimaryGraphics,
+  PrimarySpriteMesh,
+} from "#client/canvas/primary/_module.d.mts";
+
+declare module "#configuration" {
+  namespace Hooks {
+    interface CanvasGroupConfig {
+      PrimaryCanvasGroup: PrimaryCanvasGroup.Any;
+    }
+  }
+}
+
+/**
+ * The primary Canvas group which generally contains tangible physical objects which exist within the Scene.
+ * This group is a {@linkcode CachedContainer} which is rendered to the Scene as a {@linkcode SpriteMesh}.
+ * This allows the rendered result of the Primary Canvas Group to be affected by a {@linkcode BaseSamplerShader}.
+ */
+declare class PrimaryCanvasGroup<
+  DrawOptions extends PrimaryCanvasGroup.DrawOptions = PrimaryCanvasGroup.DrawOptions,
+  TearDownOptions extends PrimaryCanvasGroup.TearDownOptions = PrimaryCanvasGroup.TearDownOptions,
+> extends CanvasGroupMixin<typeof CachedContainer, "primary">(CachedContainer)<DrawOptions, TearDownOptions> {
+  /**
+   * @param sprite - (default: `new SpriteMesh(undefined, BaseSamplerShader)`)
+   */
+  constructor(sprite?: SpriteMesh);
+
+  /**
+   * Sort order to break ties on the group/layer level.
+   */
+  static SORT_LAYERS: PrimaryCanvasGroup.Sort_Layers;
+
+  /**
+   * @defaultValue
+   * ```js
+   * {
+   *   scaleMode: PIXI.SCALE_MODES.NEAREST,
+   *   format: PIXI.FORMATS.RGB,
+   *   multisample: PIXI.MSAA_QUALITY.NONE
+   * }
+   * ```
+   */
+  static override textureConfiguration: CachedContainer.TextureConfiguration;
+
+  /**
+   * @defaultValue `"none"`
+   */
+  override eventMode: PIXI.EventMode;
+
+  /**
+   * @defaultValue `[0, 0, 0, 0]`
+   */
+  override clearColor: Color.RGBAColorVector;
+
+  /**
+   * The background color in RGB.
+   */
+  _backgroundColor: Color.RGBColorVector | undefined;
+
+  /**
+   * Track the set of HTMLVideoElements which are currently playing as part of this group.
+   */
+  videoMeshes: Set<SpriteMesh>;
+
+  /**
+   * Occludable objects above this elevation are faded on hover.
+   * @defaultValue `0`
+   */
+  hoverFadeElevation: number;
+
+  /**
+   * Allow API users to override the default elevation of the background layer.
+   * This is a temporary solution until more formal support for scene levels is added in a future release.
+   */
+  static BACKGROUND_ELEVATION: number;
+
+  /**
+   * The primary background image configured for the Scene, rendered as a SpriteMesh.
+   */
+  background: SpriteMesh | undefined;
+
+  /**
+   * The primary foreground image configured for the Scene, rendered as a SpriteMesh.
+   */
+  foreground: SpriteMesh | undefined;
+
+  /**
+   * A Quadtree which partitions and organizes primary canvas objects.
+   */
+  quadtree: CanvasQuadtree<PrimaryCanvasObjectMixin.AnyMixed>;
+
+  /**
+   * The collection of PrimaryDrawingContainer objects which are rendered in the Scene.
+   * @privateRemarks Foundry types this as `Collection<PrimaryDrawingContainer>`, which doesn't exist. It's `PrimaryGraphics` in practice.
+   */
+  drawings: Collection<PrimaryGraphics>;
+
+  /**
+   * The collection of SpriteMesh objects which are rendered in the Scene.
+   * @privateRemarks Foundry types this as `Collection<TokenMesh>`, which doesn't exist. In practice it's `PrimarySpriteMesh`
+   */
+  tokens: Collection<PrimarySpriteMesh>;
+
+  /**
+   * The collection of SpriteMesh objects which are rendered in the Scene.
+   * @privateRemarks Foundry types this as `Collection<PrimarySpriteMesh | TileSprite>`, but `TileSprite` doens't exist. In practice it's all `PrimarySpriteMesh`.
+   */
+  tiles: Collection<PrimarySpriteMesh>;
+
+  /**
+   * The ambience filter which is applying post-processing effects.
+   */
+  _ambienceFilter: PrimaryCanvasGroupAmbienceFilter | undefined;
+
+  /**
+   * Return the base HTML image or video element which provides the background texture.
+   * @privateRemarks Foundry does not indicate the possibility of a null return
+   */
+  get backgroundSource(): HTMLImageElement | HTMLVideoElement | null;
+
+  /**
+   * Return the base HTML image or video element which provides the foreground texture.
+   * @privateRemarks Foundry does not indicate the possibility of a null return
+   */
+  get foregroundSource(): HTMLImageElement | HTMLVideoElement | null;
+
+  /**
+   * Refresh the primary mesh.
+   */
+  refreshPrimarySpriteMesh(): void;
+
+  /**
+   * Update this group. Calculates the canvas transform and bounds of all its children and updates the quadtree.
+   */
+  update(): void;
+
+  protected override _draw(options: HandleEmptyObject<DrawOptions>): Promise<void>;
+
+  protected override _render(_renderer: PIXI.Renderer): void;
+
+  protected override _tearDown(options: HandleEmptyObject<TearDownOptions>): Promise<void>;
+
+  /**
+   * Draw the SpriteMesh for a specific Token object.
+   * @param token - The Token being added
+   * @returns The added PrimarySpriteMesh
+   */
+  addToken(token: Token.Implementation): PrimarySpriteMesh;
+
+  /**
+   * Remove a TokenMesh from the group.
+   * @param token - The Token being removed
+   */
+  removeToken(token: Token.Implementation): void;
+
+  /**
+   * Draw the SpriteMesh for a specific Token object.
+   * @param tile - The Tile being added
+   * @returns The added PrimarySpriteMesh
+   */
+  addTile(tile: Tile.Implementation): PrimarySpriteMesh;
+
+  /**
+   * Remove a TokenMesh from the group.
+   * @param tile - The Tile being removed
+   */
+  removeTile(tile: Tile.Implementation): void;
+
+  /**
+   * Add a PrimaryGraphics to the group.
+   * @param drawing - The Drawing being added
+   * @returns The created PrimaryGraphics instance
+   */
+  addDrawing(drawing: Drawing.Implementation): PrimaryGraphics;
+
+  /**
+   * Remove a PrimaryGraphics from the group.
+   * @param drawing - The Drawing being removed
+   */
+  removeDrawing(drawing: Drawing.Implementation): void;
+
+  /**
+   * Override the default PIXI.Container behavior for how objects in this container are sorted.
+   * @remarks Actually an override of `PIXI.Container#sortChildren`
+   */
+  sortChildren(): void;
+
+  /**
+   * Handle mousemove events on the primary group to update the hovered state of its children.
+   * @remarks Foundry marked `@internal`
+   */
+  _onMouseMove(): void;
+
+  /**
+   * @deprecated since v12, will be removed in v14
+   * @remarks `"PrimaryCanvasGroup#mapElevationAlpha is deprecated. Use canvas.masks.depth.mapElevation(elevation) instead."`
+   */
+  mapElevationToDepth(elevation: number): number;
+
+  /**
+   * @deprecated since v11, will be removed in v13
+   * @remarks "PrimaryCanvasGroup#mapElevationAlpha is deprecated in favor of PrimaryCanvasGroup#mapElevationToDepth"
+   */
+  mapElevationAlpha(elevation: number): number;
+}
+
+declare namespace PrimaryCanvasGroup {
+  interface Any extends AnyPrimaryCanvasGroup {}
+  interface AnyConstructor extends Identity<typeof AnyPrimaryCanvasGroup> {}
+
+  interface DrawOptions extends CanvasGroupMixin.DrawOptions {}
+
+  interface TearDownOptions extends CanvasGroupMixin.TearDownOptions {}
+
+  type SORT_LAYERS = Brand<number, "PrimaryCanvasGroup.SORT_LAYERS">;
+
+  interface Sort_Layers {
+    readonly SCENE: 0 & SORT_LAYERS;
+    readonly TILES: 500 & SORT_LAYERS;
+    readonly DRAWINGS: 600 & SORT_LAYERS;
+    readonly TOKENS: 700 & SORT_LAYERS;
+    readonly WEATHER: 1000 & SORT_LAYERS;
+  }
+}
+
+export default PrimaryCanvasGroup;
+
+declare abstract class AnyPrimaryCanvasGroup extends PrimaryCanvasGroup {
+  constructor(...args: never);
+}

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

@@ -0,0 +1,39 @@
+import type { Identity } from "#utils";
+import type { CanvasGroupMixin } from "#client/canvas/groups/_module.d.mts";
+
+declare module "#configuration" {
+  namespace Hooks {
+    interface CanvasGroupConfig {
+      RenderedCanvasGroup: RenderedCanvasGroup.Any;
+    }
+  }
+}
+
+/**
+ * A container group which contains the environment canvas group and the interface canvas group.
+ */
+declare class RenderedCanvasGroup<
+  DrawOptions extends RenderedCanvasGroup.DrawOptions = RenderedCanvasGroup.DrawOptions,
+  TearDownOptions extends RenderedCanvasGroup.TearDownOptions = RenderedCanvasGroup.TearDownOptions,
+> extends CanvasGroupMixin<typeof PIXI.Container, "rendered">(PIXI.Container)<DrawOptions, TearDownOptions> {
+  /**
+   * Should this group tear down its non-layer children?
+   * @defaultValue `false`
+   */
+  static override tearDownChildren: boolean;
+}
+
+declare namespace RenderedCanvasGroup {
+  interface Any extends AnyRenderedCanvasGroup {}
+  interface AnyConstructor extends Identity<typeof AnyRenderedCanvasGroup> {}
+
+  interface DrawOptions extends CanvasGroupMixin.DrawOptions {}
+
+  interface TearDownOptions extends CanvasGroupMixin.TearDownOptions {}
+}
+
+export default RenderedCanvasGroup;
+
+declare abstract class AnyRenderedCanvasGroup extends RenderedCanvasGroup {
+  constructor(...args: never);
+}

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

@@ -0,0 +1,263 @@
+import type { HandleEmptyObject, Identity, InexactPartial, IntentionalPartial, NullishProps } from "#utils";
+import type { Canvas } from "#client/canvas/_module.mjs";
+import type { VisibilityFilter } from "#client/canvas/rendering/filters/_module.mjs";
+import type { CanvasGroupMixin } from "#client/canvas/groups/_module.d.mts";
+import type { CanvasVisionMask } from "#client/canvas/layers/_module.d.mts";
+import type { VisionMode } from "#client/canvas/perception/_module.d.mts";
+import type { PlaceableObject } from "#client/canvas/placeables/_module.d.mts";
+
+declare module "#configuration" {
+  namespace Hooks {
+    interface CanvasGroupConfig {
+      CanvasVisibility: CanvasVisibility.Any;
+    }
+  }
+}
+
+/**
+ * The visibility Layer which implements dynamic vision, lighting, and fog of war
+ * This layer uses an event-driven workflow to perform the minimal required calculation in response to changes.
+ * @see {@linkcode PointSource}
+ */
+declare class CanvasVisibility<
+  DrawOptions extends CanvasVisibility.DrawOptions = CanvasVisibility.DrawOptions,
+  TearDownOptions extends CanvasVisibility.TearDownOptions = CanvasVisibility.TearDownOptions,
+> extends CanvasGroupMixin<typeof PIXI.Container, "visibility">(PIXI.Container)<DrawOptions, TearDownOptions> {
+  /**
+   * The currently revealed vision.
+   * @remarks Only `undefined` prior to first draw
+   */
+  vision: CanvasVisionMask.CanvasVisionContainer | undefined;
+
+  /**
+   * The exploration container which tracks exploration progress.
+   * @remarks Only `undefined` prior to first draw
+   */
+  explored: PIXI.Container | undefined;
+
+  /**
+   * The optional visibility overlay sprite that should be drawn instead of the unexplored color in the fog of war.
+   */
+  visibilityOverlay: PIXI.Sprite | undefined;
+
+  /** @remarks Doesn't exist until it's set on draw */
+  filter?: VisibilityFilter.Implementation;
+
+  /**
+   * The active vision source data object
+   * @defaultValue
+   * ```js
+   * {
+   *    source: undefined,
+   *    activeLightingOptions: {}
+   * }
+   * ```
+   */
+  visionModeData: CanvasVisibility.VisionModeData;
+
+  /**
+   * Define whether each lighting layer is enabled, required, or disabled by this vision mode.
+   * The value for each lighting channel is a number in LIGHTING_VISIBILITY
+   * ```js
+   * {
+   *   background: VisionMode.LIGHTING_VISIBILITY.ENABLED,
+   *    illumination: VisionMode.LIGHTING_VISIBILITY.ENABLED,
+   *    coloration: VisionMode.LIGHTING_VISIBILITY.ENABLED,
+   *    darkness: VisionMode.LIGHTING_VISIBILITY.ENABLED,
+   *    any: true
+   * }
+   * ```
+   */
+  lightingVisibility: CanvasVisibility.LightingVisibility;
+
+  /**
+   * A status flag for whether the layer initialization workflow has succeeded.
+   */
+  get initialized(): boolean;
+
+  /**
+   * Indicates whether containment filtering is required when rendering vision into a texture
+   * @remarks Foundry marked `@internal`
+   */
+  get needsContainment(): boolean;
+
+  /**
+   * Does the currently viewed Scene support Token field of vision?
+   */
+  get tokenVision(): Scene.Implementation["tokenVision"];
+
+  /**
+   * The configured options used for the saved fog-of-war texture.
+   * @remarks Only `undefined` before first `#draw()`
+   */
+  get textureConfiguration(): CanvasVisibility.TextureConfiguration | undefined;
+
+  /**
+   * Optional overrides for exploration sprite dimensions.
+   *
+   * @privateRemarks Foundry types this parameter as `FogTextureConfiguration` in v12.331 which is plainly wrong even if it didn't not exist
+   * v13.335 types as `PIXI.Rectangle | undefined`, but only x/y/width/height are ever accessed, and only then if this has been set to something
+   * other than `undefined`, and in fact nothing in core ever does.
+   */
+  set explorationRect(rect: Canvas.Rectangle | undefined);
+
+  /** @remarks This getter doesn't actually exist, it's only here to correct the type inferred from the setter */
+  get explorationRect(): undefined;
+
+  /**
+   * Initialize all Token vision sources which are present on this layer
+   */
+  initializeSources(): void;
+
+  /**
+   * Initialize the vision mode.
+   */
+  initializeVisionMode(): void;
+
+  protected override _draw(options?: HandleEmptyObject<DrawOptions>): Promise<void>;
+
+  protected override _tearDown(options: HandleEmptyObject<TearDownOptions>): Promise<void>;
+
+  /**
+   * Update the display of the sight layer.
+   * Organize sources into rendering queues and draw lighting containers for each source
+   */
+  refresh(): void;
+
+  /**
+   * Update vision (and fog if necessary)
+   */
+  refreshVisibility(): void;
+
+  /**
+   * Reset the exploration container with the fog sprite
+   */
+  resetExploration(): void;
+
+  /**
+   * Restrict the visibility of certain canvas assets (like Tokens or DoorControls) based on the visibility polygon
+   * These assets should only be displayed if they are visible given the current player's field of view
+   */
+  restrictVisibility(): void;
+
+  /**
+   * Test whether a target point on the Canvas is visible based on the current vision and LOS polygons.
+   * @param point   - The point in space to test, an object with coordinates x and y.
+   * @param options - Additional options which modify visibility testing.
+   * @returns Whether the point is currently visible.
+   */
+  testVisibility(
+    point: Canvas.Point,
+    options?: CanvasVisibility.TestVisibilityOptions, // not:null (destructured when passed to _createVisibilityTestConfig)
+  ): boolean;
+
+  /**
+   * Create the visibility test config.
+   * @param point   - The point in space to test, an object with coordinates x and y.
+   * @param options - Additional options which modify visibility testing.
+   * @remarks Foundry marked `@internal`
+   */
+  protected _createVisibilityTestConfig(
+    point: Canvas.Point,
+    options?: CanvasVisibility.CreateTestConfigOptions, // not:null (destructured)
+  ): CanvasVisibility.TestConfig;
+
+  /**
+   * @deprecated since v11, will be removed in v13
+   * @remarks `"fogOverlay is deprecated in favor of visibilityOverlay"`
+   */
+  get fogOverlay(): this["visibilityOverlay"];
+}
+
+declare namespace CanvasVisibility {
+  interface Any extends AnyCanvasVisibility {}
+  interface AnyConstructor extends Identity<typeof AnyCanvasVisibility> {}
+
+  interface DrawOptions extends CanvasGroupMixin.DrawOptions {}
+
+  interface TearDownOptions extends CanvasGroupMixin.TearDownOptions {}
+
+  type TestObject = PlaceableObject.Any | null;
+
+  interface VisionModeData {
+    source: foundry.canvas.sources.PointVisionSource.Any | null | undefined;
+    activeLightingOptions: IntentionalPartial<VisionMode["lighting"]>;
+  }
+
+  interface LightingVisibility {
+    illumination: VisionMode.LIGHTING_VISIBILITY;
+    background: VisionMode.LIGHTING_VISIBILITY;
+    coloration: VisionMode.LIGHTING_VISIBILITY;
+    darkness: VisionMode.LIGHTING_VISIBILITY;
+
+    /** @remarks Only set `false` if all other keys are `VisionMode.LIGHTING_VISIBILITY.DISABLED` */
+    any: boolean;
+  }
+
+  interface TestVisibilityOptions extends CreateTestConfigOptions {}
+
+  /** @internal */
+  type _CreateTestConfigOptions = InexactPartial<{
+    /**
+     * A numeric radial offset which allows for a non-exact match.
+     * For example, if tolerance is 2 then the test will pass if the point
+     * is within 2px of a vision polygon
+     * @defaultValue `2`
+     * @remarks Can't be `null` because it only has a parameter default
+     */
+    tolerance: number;
+
+    /**
+     * An optional reference to the object whose visibility is being tested
+     * @defaultValue `null`
+     */
+    object: TestObject;
+  }>;
+
+  interface CreateTestConfigOptions extends _CreateTestConfigOptions {}
+
+  /** @internal */
+  type _TestConfigOptional = NullishProps<{
+    /**
+     * The target object
+     * @defaultValue `null`
+     * @remarks Only checked in `#_canDetect` for `instanceof Token`
+     */
+    object: TestObject;
+  }>;
+
+  /** @internal */
+  interface _TestConfigRequired {
+    /** An array of visibility tests */
+    tests: CanvasVisibility.Test[];
+  }
+
+  interface TestConfig extends _TestConfigRequired, _TestConfigOptional {}
+
+  interface Test {
+    point: Canvas.Point;
+    elevation: number;
+    los: Map<foundry.canvas.sources.PointVisionSource.Any, boolean>;
+  }
+
+  /**
+   * @privateRemarks This is a fixed subset of `PIXI.IBaseTextureOptions` that `CanvasVisibility##createTextureConfiguration` produces.
+   * Since it's generated by a private method and stored in a private property, it's not meaningfully extensible (`canvas.visibility.textureConfiguration.foo = "bar"` doesn't count)
+   */
+  interface TextureConfiguration {
+    resolution: number;
+    width: number;
+    height: number;
+    mipmap: PIXI.MIPMAP_MODES;
+    multisample: PIXI.MSAA_QUALITY;
+    scaleMode: PIXI.SCALE_MODES;
+    alphaMode: PIXI.ALPHA_MODES;
+    format: PIXI.FORMATS;
+  }
+}
+
+export default CanvasVisibility;
+
+declare abstract class AnyCanvasVisibility extends CanvasVisibility {
+  constructor(...args: never);
+}