@league-of-foundry-developers/foundry-vtt-types 13.340.0 → 13.345.1-beta.20250704.94554

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

@@ -0,0 +1,878 @@
+import type { InexactPartial, NullishProps, FixedInstanceType } from "#utils";
+import type { CANVAS_PERFORMANCE_MODES } from "#common/constants.d.mts";
+import type { CanvasAnimation } from "#client/canvas/animation/_module.d.mts";
+import type { MouseInteractionManager, RenderFlagsMixin, Ping } from "#client/canvas/interaction/_module.d.mts";
+import type * as groups from "#client/canvas/groups/_module.d.mts";
+import type * as layers from "#client/canvas/layers/_module.d.mts";
+import type { PerceptionManager } from "#client/canvas/perception/_module.d.mts";
+
+type InternalCanvas = new (...args: never) => {
+  readonly [K in keyof CONFIG.Canvas.Groups]?: FixedInstanceType<CONFIG.Canvas.Groups[K]["groupClass"]> | undefined;
+};
+
+declare const _InternalCanvas: InternalCanvas;
+
+/**
+ * The virtual tabletop environment is implemented using a WebGL powered HTML 5 canvas using the powerful PIXI.js
+ * library. The canvas is comprised by an ordered sequence of layers which define rendering groups and collections of
+ * objects that are drawn on the canvas itself.
+ *
+ * ### Hook Events
+ * {@linkcode hookEvents.canvasConfig}
+ * {@linkcode hookEvents.canvasInit}
+ * {@linkcode hookEvents.canvasReady}
+ * {@linkcode hookEvents.canvasPan}
+ * {@linkcode hookEvents.canvasTearDown}
+ *
+ * @example Canvas State
+ * ```typescript
+ * canvas.ready; // Is the canvas ready for use?
+ * canvas.scene; // The currently viewed Scene document.
+ * canvas.dimensions; // The dimensions of the current Scene.
+ * ```
+ *
+ * @example Canvas Methods
+ * ```typescript
+ * canvas.draw(); // Completely re-draw the game canvas (this is usually unnecessary).
+ * canvas.pan(x, y, zoom); // Pan the canvas to new coordinates and scale.
+ * canvas.recenter(); // Re-center the canvas on the currently controlled Token.
+ * ```
+ */
+declare class Canvas extends _InternalCanvas {
+  constructor();
+
+  /**
+   * A set of blur filter instances which are modified by the zoom level and the "soft shadows" setting
+   * @defaultValue `[]`
+   */
+  blurFilters: Set<PIXI.BlurFilter>;
+
+  /**
+   * A reference to the MouseInteractionManager that is currently controlling pointer-based interaction, or null.
+   */
+  currentMouseManager: MouseInteractionManager<PIXI.Container> | null;
+
+  /**
+   * Configure options passed to the texture loaded for the Scene.
+   * This object can be configured during the canvasInit hook before textures have been loaded.
+   */
+  loadTexturesOptions: { expireCache: boolean; additionalSources: string[] };
+
+  /**
+   * Configure options used by the visibility framework for special effects
+   * This object can be configured during the canvasInit hook before visibility is initialized.
+   */
+  visibilityOptions: { persistentVision: boolean };
+
+  /**
+   * Configure options passed to initialize blur for the Scene and override normal behavior.
+   * This object can be configured during the canvasInit hook before blur is initialized.
+   */
+  blurOptions:
+    | {
+        enabled: boolean;
+        blurClass: typeof PIXI.BlurFilter;
+        strength: number;
+        passes: number;
+        kernels: number;
+      }
+    | undefined;
+
+  /**
+   * Configure the Textures to apply to the Scene.
+   * Textures registered here will be automatically loaded as part of the TextureLoader.loadSceneTextures workflow.
+   * Textures which need to be loaded should be configured during the "canvasInit" hook.
+   */
+  sceneTextures: { background?: string; foreground?: string; fogOverlay?: string };
+
+  /**
+   * Record framerate performance data
+   */
+  fps: {
+    /** @defaultValue `0` */
+    average: number;
+
+    /** @defaultValue `[]` */
+    values: number[];
+
+    /** @defaultValue `0` */
+    render: number;
+
+    /** @defaultValue `document.getElementById("fps")` */
+    element: HTMLElement;
+  };
+
+  /**
+   * The singleton interaction manager instance which handles mouse interaction on the Canvas.
+   */
+  mouseInteractionManager: MouseInteractionManager<PIXI.Container> | undefined;
+
+  /**
+   * Configured performance settings which affect the behavior of the Canvas and its renderer.
+   * @defaultValue `undefined`
+   */
+  performance: Canvas.PerformanceSettings | undefined;
+
+  /**
+   * A list of supported webGL capabilities and limitations.
+   */
+  supported: Canvas.SupportedComponents;
+
+  /**
+   * Is the photosensitive mode enabled?
+   * @remarks Cached from core settings
+   */
+  readonly photosensitiveMode: boolean;
+
+  /**
+   * The renderer screen dimensions.
+   * @defaultValue `[0, 0]`
+   */
+  screenDimensions: [x: number, y: number];
+
+  /**
+   * A flag to indicate whether a new Scene is currently being drawn.
+   * @defaultValue `false`
+   */
+  loading: boolean;
+
+  /**
+   * A promise that resolves when the canvas is first initialized and ready.
+   * @defaultValue `null`
+   */
+  initializing: Promise<void> | null;
+
+  /**
+   * The singleton PIXI.Application instance rendered on the Canvas.
+   * @defaultValue `undefined`
+   */
+  readonly app: PIXI.Application<HTMLCanvasElement> | undefined;
+
+  /**
+   * The primary stage container of the PIXI.Application.
+   * @defaultValue `undefined`
+   */
+  readonly stage: PIXI.Container | undefined;
+
+  /**
+   * The rendered canvas group which render the environment canvas group and the interface canvas group.
+   */
+  rendered: groups.RenderedCanvasGroup;
+
+  /**
+   * A singleton CanvasEdges instance.
+   */
+  edges: foundry.canvas.geometry.edges.CanvasEdges;
+
+  /**
+   * The singleton FogManager instance.
+   */
+  fog: FixedInstanceType<typeof CONFIG.Canvas.fogManager>;
+
+  /**
+   * A perception manager interface for batching lighting, sight, and sound updates
+   */
+  perception: PerceptionManager;
+
+  /**
+   * The environment canvas group which render the primary canvas group and the effects canvas group.
+   */
+  environment: groups.EnvironmentCanvasGroup;
+
+  /**
+   * 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}.
+   * @defaultValue `undefined`
+   */
+  readonly primary: groups.PrimaryCanvasGroup | undefined;
+
+  /**
+   * The effects Canvas group which modifies the result of the {@linkcode PrimaryCanvasGroup} by adding special effects.
+   * This includes lighting, vision, fog of war and related animations.
+   * @defaultValue `undefined`
+   */
+  readonly effects: groups.EffectsCanvasGroup | undefined;
+
+  /**
+   * The visibility Canvas group which handles the fog of war overlay by consolidating multiple render textures,
+   * and applying a filter with special effects and blur.
+   */
+  visibility: groups.CanvasVisibility;
+
+  /**
+   * The interface Canvas group which is rendered above other groups and contains all interactive elements.
+   * The various {@linkcode InteractionLayer} instances of the interface group provide different control sets for
+   * interacting with different types of {@linkcode Document}s which can be represented on the Canvas.
+   * @defaultValue `undefined`
+   */
+  readonly interface: groups.InterfaceCanvasGroup | undefined;
+
+  /**
+   * The overlay Canvas group which is rendered above other groups and contains elements not bound to stage transform.
+   */
+  readonly overlay: groups.OverlayCanvasGroup;
+
+  /**
+   * The singleton HeadsUpDisplay container which overlays HTML rendering on top of this Canvas.
+   * @defaultValue `undefined`
+   */
+  readonly hud: foundry.applications.hud.HeadsUpDisplayContainer | undefined;
+
+  /**
+   * Position of the mouse on stage.
+   */
+  mousePosition: PIXI.Point;
+
+  /**
+   * Track the last automatic pan time to throttle
+   * @defaultValue `0`
+   */
+  protected _panTime: number;
+
+  /**
+   * Force snapping to grid vertices?
+   * @defaultValue `false`
+   */
+  forceSnapVertices: boolean;
+
+  /**
+   * A flag for whether the game Canvas is fully initialized and ready for additional content to be drawn.
+   */
+  get initialized(): boolean;
+
+  /**
+   * A reference to the currently displayed Scene document, or null if the Canvas is currently blank.
+   */
+  get scene(): Scene.Stored | null;
+
+  /**
+   * A SceneManager instance which adds behaviors to this Scene, or null if there is no manager.
+   * @defaultValue `null`
+   */
+  get manager(): foundry.canvas.SceneManager | null;
+
+  /**
+   * The current pixel dimensions of the displayed Scene, or null if the Canvas is blank.
+   */
+  get dimensions(): Canvas.Dimensions | null;
+
+  /**
+   * A reference to the grid of the currently displayed Scene document, or null if the Canvas is currently blank.
+   */
+  get grid(): foundry.grid.BaseGrid | null;
+
+  /**
+   * A flag for whether the game Canvas is ready to be used. False if the canvas is not yet drawn, true otherwise.
+   */
+  get ready(): boolean;
+
+  /**
+   * The colors bound to this scene and handled by the color manager.
+   */
+  get colors(): this["environment"]["colors"];
+
+  /**
+   * Shortcut to get the masks container from HiddenCanvasGroup.
+   */
+  get masks(): PIXI.Container;
+
+  /**
+   * The id of the currently displayed Scene.
+   */
+  get id(): string | null;
+
+  /**
+   * A mapping of named CanvasLayer classes which defines the layers which comprise the Scene.
+   */
+  static get layers(): typeof CONFIG.Canvas.layers;
+
+  /**
+   * An Array of all CanvasLayer instances which are active on the Canvas board
+   */
+  get layers(): layers.CanvasLayer[];
+
+  /**
+   * Return a reference to the active Canvas Layer
+   */
+  get activeLayer(): layers.CanvasLayer | null;
+
+  /**
+   * The currently displayed darkness level, which may override the saved Scene value.
+   */
+  get darknessLevel(): number;
+
+  /**
+   * Initialize the Canvas by creating the HTML element and PIXI application.
+   * This step should only ever be performed once per client session.
+   * Subsequent requests to reset the canvas should go through Canvas#draw
+   */
+  initialize(): void;
+
+  /**
+   * Configure the usage of WebGL for the PIXI.Application that will be created.
+   * @throws an Error if WebGL is not supported by this browser environment.
+   */
+  static #configureWebGL(): void;
+
+  /**
+   * Create the Canvas element which will be the render target for the PIXI.Application instance.
+   * Replace the template element which serves as a placeholder in the initially served HTML response.
+   */
+  static #createHTMLCanvas(): HTMLCanvasElement;
+
+  /**
+   * Configure the settings used to initialize the PIXI.Application instance.
+   * @returns Options passed to the PIXI.Application constructor.
+   */
+  static #configureCanvasSettings(): ConstructorParameters<typeof PIXI.Application>[0];
+
+  /**
+   * Initialize custom pixi plugins.
+   */
+  #initializePlugins(): void;
+
+  /**
+   * Create the PIXI.Application and update references to the created app and stage.
+   * @param canvas - The target canvas view element
+   * @param config - Desired PIXI.Application configuration options
+   */
+  #createApplication(canvas: HTMLCanvasElement, config: ConstructorParameters<typeof PIXI.Application>[0]): void;
+
+  readonly snapshot?: foundry.canvas.FramebufferSnapshot;
+
+  /**
+   * Remap premultiplied blend modes/non premultiplied blend modes to fix PIXI bug with custom BM.
+   */
+  #mapPremultipliedBlendModes(): void;
+
+  /**
+   * Initialize the group containers of the game Canvas.
+   */
+  #createGroups(parentName: string, parent: PIXI.DisplayObject): void;
+
+  // Group properties are determined by the CanvasGroups type
+
+  /**
+   * TODO: Add a quality parameter
+   * Compute the blur parameters according to grid size and performance mode.
+   * @param options - Blur options.
+   * @remarks The TODO is foundry internal
+   */
+  protected _initializeBlur(
+    options?: InexactPartial<{
+      enabled: boolean;
+
+      /**
+       * @defaultValue `AlphaBlurFilter`
+       */
+      blurClass: typeof PIXI.Filter;
+
+      /**
+       * @defaultValue `AlphaBlurFilterPass`
+       */
+      blurPassClass: typeof PIXI.Filter;
+
+      /**
+       * @defaultValue `this.grid.size / 25`
+       */
+      strength: number;
+
+      passes: number;
+
+      kernels: number;
+    }>,
+  ): void;
+
+  /**
+   * Configure performance settings for hte canvas application based on the selected performance mode.
+   * @internal
+   */
+  protected _configurePerformanceMode(): Canvas.PerformanceSettings;
+
+  /**
+   * Draw the game canvas.
+   * @param scene - A specific Scene document to render on the Canvas
+   * @returns A Promise which resolves once the Canvas is fully drawn
+   * @privateRemarks Foundry calls this with `null` in `Scene#_onDelete` and `Scene#_onActivate`
+   */
+  draw(scene?: Scene.Implementation | null): Promise<this>;
+
+  /**
+   * When re-drawing the canvas, first tear down or discontinue some existing processes
+   */
+  tearDown(): Promise<void>;
+
+  /**
+   * Create a SceneManager instance used for this Scene, if any.
+   */
+  static getSceneManager(scene: Scene.Implementation): foundry.canvas.SceneManager | null;
+
+  /**
+   * Get the value of a GL parameter
+   * @param parameter - The GL parameter to retrieve
+   * @returns The returned value type depends of the parameter to retrieve
+   */
+  getGLParameter(parameter: string): unknown;
+
+  /**
+   * Initialize the starting view of the canvas stage
+   * If we are re-drawing a scene which was previously rendered, restore the prior view position
+   * Otherwise set the view to the top-left corner of the scene at standard scale
+   */
+  initializeCanvasPosition(): void;
+
+  // Layers are added to the global `canvas` object via `CanvasGroupMixin#_createLayers()`
+  // TODO: Revisit after updating CONFIG in #2911
+
+  readonly weather?: layers.WeatherEffects;
+
+  // GridLayer is not assigned due to conflicting `Canvas#grid` property pointing to the BaseGrid subclass
+
+  readonly drawings?: layers.DrawingsLayer;
+
+  readonly templates?: layers.TemplateLayer;
+
+  readonly tiles?: layers.TilesLayer;
+
+  readonly walls?: layers.WallsLayer;
+
+  readonly tokens?: layers.TokenLayer;
+
+  readonly sounds?: layers.SoundsLayer;
+
+  readonly lighting?: layers.LightingLayer;
+
+  readonly notes?: layers.NotesLayer;
+
+  readonly regions?: layers.RegionLayer;
+
+  readonly controls?: layers.ControlsLayer;
+
+  /**
+   * Given an embedded object name, get the canvas layer for that object
+   */
+  getLayerByEmbeddedName<T extends string>(
+    embeddedName: T,
+  ): T extends keyof EmbeddedEntityNameToLayerMap ? Exclude<EmbeddedEntityNameToLayerMap[T], undefined> | null : null;
+
+  /**
+   * Get the InteractionLayer of the canvas which manages Documents of a certain collection within the Scene.
+   * @param collectionName - The collection name
+   * @returns The canvas layer
+   */
+  getCollectionLayer<T extends string>(
+    collectionName: T,
+  ): T extends keyof CollectionNameToLayerMap ? Exclude<CollectionNameToLayerMap[T], undefined> : undefined;
+
+  /**
+   * Activate framerate tracking by adding an HTML element to the display and refreshing it every frame.
+   */
+  activateFPSMeter(): void;
+
+  /**
+   * Deactivate framerate tracking by canceling ticker updates and removing the HTML element.
+   */
+  deactivateFPSMeter(): void;
+
+  /**
+   * Measure average framerate per second over the past 30 frames
+   */
+  #measureFPS(): void;
+
+  /**
+   * Pan the canvas to a certain \{x,y\} coordinate and a certain zoom level
+   */
+  pan({ x, y, scale }?: Canvas.ViewPosition): void;
+
+  /**
+   * Animate panning the canvas to a certain destination coordinate and zoom scale
+   * Customize the animation speed with additional options
+   * Returns a Promise which is resolved once the animation has completed
+   *
+   * @param view - The desired view parameters
+   *               (default: `{}`)
+   * @returns A Promise which resolves once the animation has been completed
+   */
+  animatePan(
+    view: Canvas.ViewPosition & {
+      /**
+       * The total duration of the animation in milliseconds; used if speed is not set
+       * @defaultValue `250`
+       */
+      duration?: number;
+
+      /** The speed of animation in pixels per second; overrides duration if set */
+      speed?: number;
+
+      /** An easing function passed to CanvasAnimation animate */
+      easing?: CanvasAnimation.EasingFunction;
+    },
+  ): ReturnType<typeof CanvasAnimation.animate>;
+
+  /**
+   * Recenter the canvas with a pan animation that ends in the center of the canvas rectangle.
+   * @param initial - A desired initial position from which to begin the animation
+   * @returns A Promise which resolves once the animation has been completed
+   */
+  recenter(initial?: Canvas.ViewPosition): ReturnType<this["animatePan"]>;
+
+  /**
+   * Highlight objects on any layers which are visible
+   */
+  highlightObjects(active: boolean): void;
+
+  /**
+   * Displays a Ping both locally and on other connected client, following these rules:
+   * 1) Displays on the current canvas Scene
+   * 2) If ALT is held, becomes an ALERT ping
+   * 3) Else if the user is GM and SHIFT is held, becomes a PULL ping
+   * 4) Else is a PULSE ping
+   * @param origin  - Point to display Ping at
+   * @param options - Additional options to configure how the ping is drawn.
+   */
+  ping(origin: Canvas.Point, options?: Ping.ConstructorOptions): Promise<boolean>;
+
+  /**
+   * Create a BlurFilter instance and register it to the array for updates when the zoom level changes.
+   * @param blurStrength - The desired blur strength to use for this filter
+   *                       (default: `CONFIG.Canvas.blurStrength`)
+   * @param blurQuality  - The desired quality to use for this filter
+   *                       (default: `CONFIG.Canvas.blurQuality`)
+   */
+  createBlurFilter(blurStrength?: number, blurQuality?: number): PIXI.BlurFilter;
+
+  /**
+   * Add a filter to the blur filter list. The filter must have the blur property
+   * @param filter - The Filter instance to add
+   * @returns The added filter for method chaining
+   */
+  addBlurFilter(filter: PIXI.BlurFilter): PIXI.BlurFilter;
+
+  /**
+   * Update the blur strength depending on the scale of the canvas stage
+   * @param strength - Optional blur strength to apply
+   *                   (default: `this.blur.strength`)
+   */
+  protected updateBlur(strength?: number): void;
+
+  /**
+   * Convert canvas coordinates to the client's viewport.
+   * @param origin - The canvas coordinates.
+   * @returns The corresponding coordinates relative to the client's viewport.
+   */
+  clientCoordinatesFromCanvas(origin: Canvas.Point): Canvas.Point;
+
+  /**
+   * Convert client viewport coordinates to canvas coordinates.
+   * @param origin - The client coordinates.
+   * @returns The corresponding canvas co-ordinates.
+   */
+  canvasCoordinatesFromClient(origin: Canvas.Point): Canvas.Point;
+
+  /**
+   * Determine whether given canvas coordinates are off-screen.
+   * @param position - The canvas coordinates.
+   * @returns Is the coordinate outside the screen bounds?
+   */
+  isOffscreen(position: Canvas.Point): boolean;
+
+  /**
+   * Remove all children of the display object and call one cleaning method:
+   * clean first, then tearDown, and destroy if no cleaning method is found.
+   * @param displayObject - The display object to clean.
+   * @param destroy       - If textures should be destroyed.
+   *                        (default: `true`)
+   */
+  static clearContainer(displayObject: PIXI.DisplayObject, destroy?: boolean): void;
+
+  /**
+   * Get a texture with the required configuration and clear color.
+   */
+  static getRenderTexture(options?: Canvas.GetRenderTextureOptions): PIXI.RenderTexture;
+
+  /**
+   * Handle right-mouse start drag events occurring on the Canvas.
+   */
+  protected _onDragRightStart(event: Canvas.Event.Pointer): void;
+
+  /**
+   * Handle right-mouse drag events occurring on the Canvas.
+   */
+  protected _onDragRightMove(event: Canvas.Event.Pointer): void;
+
+  /**
+   * Handle the conclusion of a right-mouse drag workflow the Canvas stage.
+   */
+  protected _onDragRightDrop(event: Canvas.Event.Pointer): void;
+
+  /**
+   * Handle the cancellation of a right-mouse drag workflow the Canvas stage.
+   */
+  protected _onDragRightCancel(event: Canvas.Event.Pointer): void;
+
+  /**
+   * Pan the canvas view when the cursor position gets close to the edge of the frame
+   * @param event - The originating mouse movement event
+   */
+  protected _onDragCanvasPan(event: Canvas.Event.Pointer): ReturnType<this["animatePan"]> | void;
+
+  /**
+   * Handle window resizing with the dimensions of the window viewport change
+   * @param event - The Window resize event
+   *                (default: `null`)
+   */
+  protected _onResize(event?: UIEvent | null): false | void;
+
+  /**
+   * Handle mousewheel events which adjust the scale of the canvas
+   * @param event - The mousewheel event that zooms the canvas
+   */
+  protected _onMouseWheel(event: Canvas.Event.Wheel): void;
+
+  /**
+   * Track objects which have pending render flags.
+   */
+  readonly pendingRenderFlags: Canvas.PendingRenderFlags;
+
+  /**
+   * @deprecated since v11, will be removed in v13
+   * @remarks "Canvas#addPendingOperation is deprecated without replacement in v11.
+   * The callback that you have passed as a pending operation has been executed immediately.
+   * We recommend switching your code to use a debounce operation or RenderFlags to de-duplicate overlapping requests."
+   */
+  addPendingOperation<S, A>(name: string, fn: (this: S, args: A) => void, scope: S, args: A): void;
+
+  /**
+   * @deprecated since v11, will be removed in v13
+   * @remarks "Canvas#triggerPendingOperations is deprecated without replacement in v11 and performs no action."
+   */
+  triggerPendingOperations(): void;
+
+  /**
+   * @deprecated since v11, will be removed in v13
+   * @remarks `"Canvas#pendingOperations is deprecated without replacement in v11."`
+   */
+  get pendingOperations(): [];
+
+  /**
+   * @deprecated since v12, will be removed in v14
+   * @remarks `"Canvas#colorManager is deprecated and replaced by Canvas#environment"`
+   */
+  get colorManager(): this["environment"];
+}
+
+declare namespace Canvas {
+  interface Dimensions extends Scene.Dimensions {
+    /** The canvas rectangle. */
+    rect: PIXI.Rectangle;
+
+    /** The scene rectangle. */
+    sceneRect: PIXI.Rectangle;
+  }
+
+  /** @internal */
+  type _ViewPosition = NullishProps<{
+    /**
+     * The x-coordinate which becomes stage.pivot.x
+     */
+    x: number;
+
+    /**
+     * The y-coordinate which becomes stage.pivot.y
+     */
+    y: number;
+
+    /**
+     * The zoom level up to CONFIG.Canvas.maxZoom which becomes stage.scale.x and y
+     */
+    scale: number;
+  }>;
+
+  interface ViewPosition extends _ViewPosition {}
+
+  interface DropPosition {
+    x: number;
+    y: number;
+  }
+
+  /**
+   * A 2D point, expressed as `{x, y}`
+   * @remarks Copied from `common/_types.mjs`
+   */
+  interface Point {
+    x: number;
+    y: number;
+  }
+
+  /**
+   * A 3D point, expressed as `{x, y, elevation}`.
+   * @remarks Copied from `common/_types.mjs`
+   */
+  interface ElevatedPoint {
+    x: number;
+    y: number;
+    elevation: number;
+  }
+
+  /**
+   * A 3D point, expressed as `{x, y, elevation}`.
+   * @remarks Copied from `common/_types.mjs`
+   */
+  interface ElevatedPoint {
+    x: number;
+    y: number;
+    elevation: number;
+  }
+
+  type PossiblyElevatedPoint = Point | ElevatedPoint;
+
+  /**
+   * A single point, expressed as an array `[x,y]`
+   * @remarks Copied from `resources/app/common/types.mjs`
+   *
+   * Renamed from `PointArray` to avoid confusion (for `[{x,y},{x,y}]` for example)
+   */
+  type PointTuple = [x: number, y: number];
+
+  type PairOfPointsTuple = [x0: number, y0: number, x1: number, y1: number];
+
+  /**
+   * A 3D point, expessed as \{x, y, elevation\}.
+   */
+  interface ElevatedPoint {
+    /** The x-coordinate in pixels */
+    x: number;
+
+    /** The y-coordinate in pixels */
+    y: number;
+
+    /** The elevation in grid units */
+    elevation: number;
+  }
+
+  /**
+   * A standard rectangle interface.
+   * @remarks Copied from `resources/app/common/types.mjs`
+   */
+  interface Rectangle {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+  }
+
+  interface PerformanceSettings {
+    /** The performance mode in CONST.CANVAS_PERFORMANCE_MODES */
+    mode: CANVAS_PERFORMANCE_MODES;
+
+    /** Blur filter configuration */
+    blur: {
+      enabled: boolean;
+      illumination: boolean;
+    };
+
+    /** Whether to use mipmaps, "ON" or "OFF" */
+    mipmap: "ON" | "OFF";
+
+    /** Whether to apply MSAA at the overall canvas level */
+    msaa: boolean;
+
+    /** Maximum framerate which should be the render target */
+    fps: number;
+
+    /** Whether to display token movement animation */
+    tokenAnimation: boolean;
+
+    /** Whether to display light source animation */
+    lightAnimation: boolean;
+
+    /** Whether to render soft edges for light sources */
+    lightSoftEdges: boolean;
+
+    /** Texture configuration */
+    textures: {
+      enabled: boolean;
+
+      maxSize: number;
+
+      p2Steps: number;
+
+      /** @defaultValue `2` */
+      p2StepsMax: number;
+    };
+  }
+
+  interface SupportedComponents {
+    /** Is WebGL2 supported? */
+    webGL2: boolean;
+
+    /** Is reading pixels in RED format supported? */
+    readPixelsRED: boolean;
+
+    /** Is the OffscreenCanvas supported? */
+    offscreenCanvas: boolean;
+  }
+
+  interface GetRenderTextureOptions {
+    /**
+     * The clear color to use for this texture. Transparent by default.
+     */
+    clearColor?: number[] | null | undefined;
+
+    /**
+     * The render texture configuration.
+     * @privateRemarks forwarded to {@linkcode PIXI.RenderTexture.create}
+     */
+    textureConfiguration?: PIXI.IBaseTextureOptions | undefined;
+  }
+
+  namespace Event {
+    /** @internal */
+    interface _Base<Original extends UIEvent | PIXI.PixiTouch = UIEvent | PIXI.PixiTouch>
+      extends PIXI.FederatedEvent<Original> {
+      interactionData: MouseInteractionManager.InteractionData<PIXI.DisplayObject>;
+    }
+
+    interface Pointer extends _Base<PointerEvent> {}
+    interface Wheel extends WheelEvent {}
+    interface DeleteKey extends KeyboardEvent {}
+
+    interface DarknessChange extends PIXI.FederatedEvent {
+      type: "darknessChange";
+      environmentData: {
+        darknessLevel: number;
+        priorDarknessLevel: number;
+      };
+    }
+  }
+
+  interface PendingRenderFlags {
+    OBJECTS: Set<FixedInstanceType<ReturnType<typeof RenderFlagsMixin>>>;
+    PERCEPTION: Set<FixedInstanceType<ReturnType<typeof RenderFlagsMixin>>>;
+  }
+}
+
+export default Canvas;
+
+interface EmbeddedEntityNameToLayerMap {
+  AmbientLight: Canvas["lighting"];
+  AmbientSound: Canvas["sounds"];
+  Drawing: Canvas["drawings"];
+  Note: Canvas["notes"];
+  MeasuredTemplate: Canvas["templates"];
+  Tile: Canvas["tiles"];
+  Token: Canvas["tokens"];
+  Wall: Canvas["walls"];
+}
+
+interface CollectionNameToLayerMap {
+  lights: Canvas["lighting"];
+  sounds: Canvas["sounds"];
+  drawings: Canvas["drawings"];
+  notes: Canvas["notes"];
+  templates: Canvas["templates"];
+  tiles: Canvas["tiles"];
+  tokens: Canvas["tokens"];
+  walls: Canvas["walls"];
+}