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

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

@@ -0,0 +1,319 @@
+import type { Identity, InexactPartial, NullishProps } from "#utils";
+import type { TranscoderWorker } from "@pixi/basis";
+
+/**
+ * A Loader class which helps with loading video and image textures
+ */
+declare class TextureLoader {
+  /**
+   * A global reference to the singleton texture loader
+   * @privateRemarks This is set outside the class via `TextureLoader.loader = new TextureLoader();`
+   */
+  static loader: TextureLoader;
+
+  /**
+   * The duration in milliseconds for which a texture will remain cached
+   * @defaultValue `1000 * 60 * 15`
+   */
+  static CACHE_TTL: number;
+
+  /**
+   * Initialize the basis/ktx2 transcoder for PIXI.Assets
+   * @remarks Foundry provides an `@license` attributing the `pixi-basis-ktx2` package to Kristof Van Der Haeghen.
+   * The full text of the MIT license is omitted here.
+   */
+  static initializeBasisTranscoder(): TextureLoader.InitializeBasisTranscoderReturn;
+
+  /**
+   * Check if a source has a text file extension.
+   * @param src - The source.
+   * @returns If the source has a text extension or not.
+   */
+  static hasTextExtension(src: string): boolean;
+
+  /**
+   * Use the texture to create a cached mapping of pixel alpha and cache it.
+   * Cache the bounding box of non-transparent pixels for the un-rotated shape.
+   * @param texture    - The provided texture
+   * @param resolution - Resolution of the texture data output (default: `1`)
+   * @returns The texture data if the texture is valid, else undefined.
+   */
+  static getTextureAlphaData(texture: PIXI.Texture, resolution?: number): TextureLoader.TextureAlphaData | void;
+
+  /**
+   * Load all the textures which are required for a particular Scene
+   * @param scene   - The Scene to load
+   * @param options - Additional options that configure texture loading (default: `{}`)
+   */
+  static loadSceneTextures(
+    scene: Scene.Implementation,
+    options?: TextureLoader.LoadSceneTexturesOptions,
+  ): Promise<void>;
+
+  /**
+   * Load an Array of provided source URL paths.
+   * Paths which begin with a special character "#" are ignored as texture references
+   * @param sources - The source URLs to load
+   * @param options - Additional options which modify loading (default: `{}`)
+   * @returns A Promise which resolves once all textures are loaded
+   */
+  load(sources: string[], options?: TextureLoader.LoadOptions): Promise<void>;
+
+  /**
+   * Load a single texture on-demand from a given source URL path
+   * @param src - The source texture path to load
+   * @returns The loaded texture object
+   */
+  loadTexture(src: string): Promise<TextureLoader.LoadTextureReturn>;
+
+  /**
+   * Use the Fetch API to retrieve a resource and return a Blob instance for it.
+   * @param src     - The resource URL
+   * @param options - Options to configure the loading behaviour.
+   * @returns A Blob containing the loaded data
+   * @remarks As of v13, simply forwards to {@linkcode foundry.utils.fetchResource}; Foundry comments `TODO @deprecated in v14`
+   */
+  static fetchResource(src: string, options?: TextureLoader.FetchResourceOptions): Promise<Blob>;
+
+  /**
+   * Add an image or a sprite sheet url to the assets cache. Include an approximate memory size in the stored data.
+   * @param src - The source URL
+   * @param tex - The readied texture
+   */
+  setCache(src: string, asset: PIXI.BaseTexture | PIXI.Spritesheet): void;
+
+  /**
+   * Retrieve a texture or a sprite sheet from the assets cache
+   * @param src - The source URL
+   * @returns The cached texture, a sprite sheet or `null`
+   */
+  getCache(src: string): TextureLoader.LoadTextureReturn;
+
+  /**
+   * Expire and unload assets from the cache which have not been used for more than CACHE_TTL milliseconds.
+   */
+  expireCache(options?: TextureLoader.ExpireCacheOptions): Promise<void>;
+
+  /**
+   * Return a URL with a cache-busting query parameter appended.
+   * @param src - The source URL being attempted
+   * @returns The new URL, or false on a failure.
+   * @remarks As of v13, simply forwards to {@linkcode foundry.utils.getCacheBustURL}; Foundry comments `TODO @deprecated in v14`
+   */
+  static getCacheBustURL(src: string): string | false;
+
+  /**
+   * A public getter to expose the total approximate memory usage.
+   * @returns The total usage in bytes.
+   */
+  static get approximateTotalMemoryUsage(): number;
+
+  /**
+   * Pin a source URL so it cannot be evicted.
+   * @param src - The source URL to pin
+   */
+  static pinSource(src: string): void;
+
+  /**
+   * Unpin a source URL that was previously pinned.
+   * @param src - The source URL to unpin
+   */
+  static unpinSource(src: string): void;
+
+  /**
+   * @deprecated "`TextureLoader.textureBufferDataMap` is deprecated without replacement.
+   * Use {@linkcode TextureLoader.getTextureAlphaData} to create a texture data map and
+   * cache it automatically, or create your own caching system" (since v12, will be removed in v14)
+   */
+  static get textureBufferDataMap(): Map<unknown, unknown>;
+
+  static #TextureLoader: true;
+}
+
+declare namespace TextureLoader {
+  interface Any extends AnyTextureLoader {}
+  interface AnyConstructor extends Identity<typeof AnyTextureLoader> {}
+
+  /** @remarks This is effectively [[void, void], [void, void], [void, void]] */
+  type InitializeBasisTranscoderReturn = Promise<
+    | [
+        Awaited<ReturnType<typeof TranscoderWorker.loadTranscoder>>,
+        Awaited<ReturnType<typeof PixiBasisKTX2.KTX2Parser.loadTranscoder>>,
+        Awaited<ReturnType<typeof PixiBasisKTX2.BasisParser.loadTranscoder>>,
+      ]
+    | void
+  >;
+
+  /** @remarks Differs from {@linkcode loadTexture.Return} in that it includes `PIXI.BaseTexture` in place of `PIXI.Texture` */
+  type LoadTextureReturn = PIXI.BaseTexture | PIXI.Spritesheet | null;
+
+  interface TextureAlphaData {
+    /** The width of the (downscaled) texture. */
+    width: number;
+
+    /** The height of the (downscaled) texture. */
+    height: number;
+
+    /** The minimum x-coordinate with alpha \> 0. */
+    minX: number;
+
+    /** The minimum y-coordinate with alpha \> 0. */
+    minY: number;
+
+    /** The maximum x-coordinate with alpha \> 0 plus 1. */
+    maxX: number;
+
+    /** The maximum y-coordinate with alpha \> 0 plus 1. */
+    maxY: number;
+
+    /** The array containing the texture alpha values (0-255) with the dimensions (maxX-minX)×(maxY-minY). */
+    data: Uint8Array;
+  }
+
+  /** @internal */
+  type _LoadSceneTexturesOptions = InexactPartial<{
+    /**
+     * Destroy other expired textures
+     * @defaultValue `true`
+     */
+    expireCache: boolean;
+
+    /**
+     * Additional sources to load during canvas initialize
+     * @defaultValue `[]`
+     */
+    additionalSources: string[];
+
+    /**
+     * The maximum number of textures that can be loaded concurrently
+     */
+    maxConcurrent: number;
+  }>;
+
+  /** Options for {@linkcode TextureLoader.loadSceneTextures}*/
+  interface LoadSceneTexturesOptions extends _LoadSceneTexturesOptions {}
+
+  /** @internal */
+  type _LoadOptions = InexactPartial<{
+    /**
+     * The status message to display in the load bar
+     * @defaultValue `""`
+     */
+    message: string;
+
+    /**
+     * Whether to localize the message content before displaying it
+     * @defaultValue `false`
+     */
+    localize: boolean;
+
+    /**
+     * Whether to escape the values of `format`
+     * @defaultValue `true`
+     */
+    escape: boolean;
+
+    /**
+     * Whether to clean the provided message string as untrusted user input.
+     * No cleaning is applied if `format` is passed and `escape` is true or `localize` is true and `format` is not passed.
+     * @defaultValue `true`
+     */
+    clean: boolean;
+
+    /**
+     * A mapping of formatting strings passed to {@linkcode foundry.helpers.Localization.format | Localization#format}
+     */
+    format: string;
+
+    /**
+     * Expire other cached textures?
+     * @defaultValue `false`
+     */
+    expireCache: boolean;
+
+    /**
+     * Display loading progress bar?
+     * @defaultValue `true`
+     */
+    displayProgress: boolean;
+  }> &
+    // Can't Pick `expireCache`, despite it existing on `LoadSceneTexturesOptions`, as it has a different default here
+    Pick<LoadSceneTexturesOptions, "maxConcurrent">;
+
+  /** Options for {@link TextureLoader.load | `TextureLoader#load`} */
+  interface LoadOptions extends _LoadOptions {}
+
+  /** @internal */
+  type _FetchResourceOptions = NullishProps<{
+    /**
+     * Append a cache-busting query parameter to the request.
+     * @defaultValue `false`
+     */
+    bustCache: boolean;
+  }>;
+
+  interface FetchResourceOptions extends _FetchResourceOptions {}
+
+  /** @internal */
+  type _ExpireCacheOptions = InexactPartial<{
+    /**
+     * A set of source URLs to *skip* from eviction checks.
+     */
+    exclude: Set<string>;
+  }>;
+
+  interface ExpireCacheOptions extends _ExpireCacheOptions {}
+}
+
+/**
+ * Test whether a file source exists by performing a HEAD request against it
+ * @param src - The source URL or path to test
+ * @returns Does the file exist at the provided url?
+ * @remarks As of v13, simply forwards to {@linkcode foundry.utils.srcExists}; Foundry comments `TODO @deprecated in v14`
+ */
+export declare function srcExists(src: string): Promise<boolean>;
+
+/**
+ * Get a single texture or sprite sheet from the cache.
+ * @param src - The texture path to load.
+ * @returns A texture, a sprite sheet or null if not found in cache.
+ */
+export declare function getTexture(src: string): loadTexture.Return;
+
+/**
+ * Load a single asset and return a Promise which resolves once the asset is ready to use
+ * @param src      - The requested texture source. This may be a standard texture path or a "virtual texture" beginning with
+ *                   the "#" character that is retrieved from canvas.sceneTextures.
+ * @param options  - Additional options which modify asset loading
+ * @returns The loaded Texture or sprite sheet, or null if loading failed with no fallback
+ */
+declare function loadTexture(src: string, options?: loadTexture.Options): Promise<loadTexture.Return>;
+
+declare namespace loadTexture {
+  type Return = PIXI.Texture | PIXI.Spritesheet | null;
+
+  /** @internal */
+  type _Options = InexactPartial<{
+    /** A fallback texture URL to use if the requested source is unavailable */
+    fallback: string;
+  }>;
+
+  interface Options extends _Options {}
+}
+
+declare global {
+  namespace LoadTexture {
+    /** @deprecated Use {@linkcode foundry.canvas.loadTexture.Return} instead */
+    export import Return = loadTexture.Return;
+
+    /** @deprecated Use {@linkcode foundry.canvas.loadTexture.Options} instead */
+    export import Options = loadTexture.Options;
+  }
+}
+
+// loadTexture exported here to include namespace
+export { TextureLoader as default, loadTexture };
+
+declare abstract class AnyTextureLoader extends TextureLoader {
+  constructor(...args: never);
+}

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

@@ -0,0 +1,19 @@
+// In Foundry itself this file contains re-exports of these other modules.
+// Therefore it has a runtime effect and uses `.mjs` instead of `.d.mts`.
+// While `.mts` could work, to avoid `import-x/no-unresolved` from erroring `.mjs` is used.
+/* eslint-disable import-x/extensions */
+
+export * as types from "./_types.mjs";
+
+export { default as FogManager } from "./fog.mjs";
+export { default as PerceptionManager } from "./perception-manager.mjs";
+export { default as VisionMode } from "./vision-mode.mjs";
+// Note: ShaderField not re-exported from vision-mode
+
+// Detection modes
+export { default as DetectionMode } from "./detection-mode.mjs";
+export { default as DetectionModeAll } from "./detection-modes/super-perception.mjs";
+export { default as DetectionModeLightPerception } from "./detection-modes/light-perception.mjs";
+export { default as DetectionModeInvisibility } from "./detection-modes/invisibility-perception.mjs";
+export { default as DetectionModeTremor } from "./detection-modes/tremor-perception.mjs";
+export { default as DetectionModeDarkvision } from "./detection-modes/darkvision.mjs";

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

@@ -0,0 +1,12 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+
+// After seeing that none of these types add anything or are even exported a
+// very reasonable question may be: Why on earth does this file exist?
+//
+// Well this is the file in which Foundry defines these types. We don't house
+// them here because it has poor discoverability. It's also just nice to
+// have as reference to keep us synced with the latest version of Foundry.
+
+export {};
+
+type PerceptionManagerFlags = foundry.canvas.perception.PerceptionManager.RenderFlags;

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

@@ -0,0 +1,173 @@
+import type { Brand, Identity, NullishProps } from "#utils";
+import type { fields } from "#common/data/_module.d.mts";
+import type { DataSchema } from "#common/data/fields.d.mts";
+import type { CanvasVisibility } from "#client/canvas/groups/_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> {
+  static override defineSchema(): DetectionMode.Schema;
+
+  /**
+   * Get the detection filter pertaining to this mode.
+   */
+  static getDetectionFilter(): PIXI.Filter | undefined;
+
+  /**
+   * An optional filter to apply on the target when it is detected with this mode.
+   */
+  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
+   */
+  static readonly DETECTION_TYPES: DetectionMode.DetectionTypes;
+
+  /**
+   * The identifier of the basic sight detection mode.
+   */
+  static readonly 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?
+   */
+  testVisibility(
+    visionSource: foundry.canvas.sources.PointVisionSource.Any,
+    mode: TokenDocument.DetectionModeData,
+    { object, tests }: DetectionMode.TestConfig, // not:null (destructured)
+  ): boolean;
+
+  /**
+   * Can this VisionSource 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?
+   */
+  protected _canDetect(
+    visionSource: foundry.canvas.sources.PointVisionSource.Any,
+    target: CanvasVisibility.TestObject,
+  ): boolean;
+
+  /**
+   * Evaluate a single test point to confirm whether it is visible.
+   * Standard detection rules require that the test point be both within LOS and within range.
+   * @param visionSource - The vision source being tested
+   * @param mode         - The detection mode configuration
+   * @param target       - The target object being tested
+   * @param test         - The test case being evaluated
+   */
+  protected _testPoint(
+    visionSource: foundry.canvas.sources.PointVisionSource.Any,
+    mode: TokenDocument.DetectionModeData,
+    target: CanvasVisibility.TestObject,
+    test: CanvasVisibility.Test,
+  ): boolean;
+
+  /**
+   * Test whether the line-of-sight requirement for detection is satisfied.
+   * Always true if the detection mode bypasses walls, otherwise the test point must be contained by the LOS polygon.
+   * The result of is cached for the vision source so that later checks for other detection modes do not repeat it.
+   * @param visionSource    - The vision source being tested
+   * @param mode            - The detection mode configuration
+   * @param target          - The target object being tested
+   * @param test            - The test case being evaluated
+   * @returns Is the LOS requirement satisfied for this test?
+   */
+  protected _testLOS(
+    visionSource: foundry.canvas.sources.PointVisionSource.Any,
+    mode: TokenDocument.DetectionModeData,
+    target: CanvasVisibility.TestObject,
+    test: CanvasVisibility.Test,
+  ): boolean;
+
+  /**
+   * Test whether the target is within the vision angle.
+   * @param visionSource    - The vision source being tested
+   * @param mode            - The detection mode configuration
+   * @param target          - The target object being tested
+   * @param test            - The test case being evaluated
+   * @returns Is the point within the vision angle?
+   */
+  protected _testAngle(
+    visionSource: foundry.canvas.sources.PointVisionSource.Any,
+    mode: TokenDocument.DetectionModeData,
+    target: CanvasVisibility.TestObject,
+    test: CanvasVisibility.Test,
+  ): boolean;
+
+  /**
+   * Verify that a target is in range of a source.
+   * @param visionSource    - The vision source being tested
+   * @param mode            - The detection mode configuration
+   * @param target          - The target object being tested
+   * @param test            - The test case being evaluated
+   * @returns Is the target within range?
+   */
+  protected _testRange(
+    visionSource: foundry.canvas.sources.PointVisionSource.Any,
+    mode: TokenDocument.DetectionModeData,
+    target: CanvasVisibility.TestObject,
+    test: CanvasVisibility.Test,
+  ): boolean;
+}
+
+declare namespace DetectionMode {
+  interface Any extends AnyDetectionMode {}
+  interface AnyConstructor extends Identity<typeof AnyDetectionMode> {}
+
+  interface Schema extends DataSchema {
+    id: fields.StringField<{ blank: false }>;
+
+    label: fields.StringField<{ blank: false }>;
+
+    /** If this DM is available in Token Config UI */
+    tokenConfig: fields.BooleanField<{ initial: true }>;
+
+    /** If this DM is constrained by walls */
+    walls: fields.BooleanField<{ initial: true }>;
+
+    /** 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[];
+    }>;
+  }
+
+  /** @see CanvasVisibility.TestConfig */
+  interface TestConfig
+    extends CanvasVisibility._TestConfigRequired,
+      NullishProps<CanvasVisibility._TestConfigOptional> {}
+
+  type DETECTION_TYPES = Brand<number, "DetectionMode.DETECTION_TYPES">;
+
+  interface DetectionTypes {
+    /** Sight, and anything depending on light perception */
+    readonly SIGHT: 0 & DETECTION_TYPES;
+
+    /** What you can hear. Includes echolocation for bats per example */
+    readonly SOUND: 1 & DETECTION_TYPES;
+
+    /** This is mostly a sense for touch and vibration, like tremorsense, movement detection, etc. */
+    readonly MOVE: 2 & DETECTION_TYPES;
+
+    /** Can't fit in other types (smell, life sense, trans-dimensional sense, sense of humor...) */
+    readonly OTHER: 3 & DETECTION_TYPES;
+  }
+}
+
+export default DetectionMode;
+
+declare abstract class AnyDetectionMode extends DetectionMode {
+  constructor(...args: never);
+}

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

@@ -0,0 +1,26 @@
+import type { Identity } from "#utils";
+import type { DetectionMode } from "../_module.d.mts";
+import type { CanvasVisibility } from "#client/canvas/groups/_module.d.mts";
+
+/**
+ * A special detection mode which models a form of darkvision (night vision).
+ * This mode is the default case which is tested first when evaluating visibility of objects.
+ * It is also a special case, in that it is the only detection mode which considers the area of distant light sources.
+ */
+declare class DetectionModeDarkvision extends DetectionMode {
+  protected override _canDetect(
+    visionSource: foundry.canvas.sources.PointVisionSource.Any,
+    target: CanvasVisibility.TestObject,
+  ): boolean;
+}
+
+declare namespace DetectionModeDarkvision {
+  interface Any extends AnyDetectionModeDarkvision {}
+  interface AnyConstructor extends Identity<typeof AnyDetectionModeDarkvision> {}
+}
+
+export default DetectionModeDarkvision;
+
+declare abstract class AnyDetectionModeDarkvision extends DetectionModeDarkvision {
+  constructor(...args: never);
+}

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

@@ -0,0 +1,29 @@
+import type { Identity } from "#utils";
+import type { DetectionMode } from "../_module.d.mts";
+import type { CanvasVisibility } from "#client/canvas/groups/_module.d.mts";
+
+/**
+ * Detection mode that see invisible creatures.
+ * This detection mode allows the source to:
+ * - See/Detect the invisible target as if visible.
+ * - The "See" version needs sight and is affected by blindness
+ */
+declare class DetectionModeInvisibility extends DetectionMode {
+  static override getDetectionFilter(): PIXI.Filter;
+
+  protected override _canDetect(
+    visionSource: foundry.canvas.sources.PointVisionSource.Any,
+    target: CanvasVisibility.TestObject,
+  ): boolean;
+}
+
+declare namespace DetectionModeInvisibility {
+  interface Any extends AnyDetectionModeInvisibility {}
+  interface AnyConstructor extends Identity<typeof AnyDetectionModeInvisibility> {}
+}
+
+export default DetectionModeInvisibility;
+
+declare abstract class AnyDetectionModeInvisibility extends DetectionModeInvisibility {
+  constructor(...args: never);
+}

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

@@ -0,0 +1,33 @@
+import type { Identity } from "#utils";
+import type { DetectionMode } from "../_module.d.mts";
+import type { CanvasVisibility } from "#client/canvas/groups/_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
+ * configured.
+ */
+declare class DetectionModeLightPerception extends DetectionMode {
+  protected override _canDetect(
+    visionSource: foundry.canvas.sources.PointVisionSource.Any,
+    target: CanvasVisibility.TestObject,
+  ): boolean;
+
+  protected override _testPoint(
+    visionSource: foundry.canvas.sources.PointVisionSource.Any,
+    mode: TokenDocument.DetectionModeData,
+    target: CanvasVisibility.TestObject,
+    test: CanvasVisibility.Test,
+  ): boolean;
+}
+
+declare namespace DetectionModeLightPerception {
+  interface Any extends AnyDetectionModeLightPerception {}
+  interface AnyConstructor extends Identity<typeof AnyDetectionModeLightPerception> {}
+}
+
+export default DetectionModeLightPerception;
+
+declare abstract class AnyDetectionModeLightPerception extends DetectionModeLightPerception {
+  constructor(...args: never);
+}

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

@@ -0,0 +1,27 @@
+import type { Identity } from "#utils";
+import type { DetectionMode } from "../_module.d.mts";
+import type { CanvasVisibility } from "#client/canvas/groups/_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;
+
+  protected override _canDetect(
+    visionSource: foundry.canvas.sources.PointVisionSource.Any,
+    target: CanvasVisibility.TestObject,
+  ): boolean;
+}
+
+declare namespace DetectionModeAll {
+  interface Any extends AnyDetectionModeAll {}
+  interface AnyConstructor extends Identity<typeof AnyDetectionModeAll> {}
+}
+
+export default DetectionModeAll;
+
+declare abstract class AnyDetectionModeAll extends DetectionModeAll {
+  constructor(...args: never);
+}

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

@@ -0,0 +1,26 @@
+import type { Identity } from "#utils";
+import type { DetectionMode } from "../_module.d.mts";
+import type { CanvasVisibility } from "#client/canvas/groups/_module.d.mts";
+
+/**
+ * Detection mode that see creatures in contact with the ground.
+ */
+declare class DetectionModeTremor extends DetectionMode {
+  static override getDetectionFilter(): PIXI.Filter;
+
+  protected override _canDetect(
+    visionSource: foundry.canvas.sources.PointVisionSource.Any,
+    target: CanvasVisibility.TestObject,
+  ): boolean;
+}
+
+declare namespace DetectionModeTremor {
+  interface Any extends AnyDetectionModeTremor {}
+  interface AnyConstructor extends Identity<typeof AnyDetectionModeTremor> {}
+}
+
+export default DetectionModeTremor;
+
+declare abstract class AnyDetectionModeTremor extends DetectionModeTremor {
+  constructor(...args: never);
+}