@league-of-foundry-developers/foundry-vtt-types 12.331.2-beta → 13.340.0

package/src/foundry/client/pixi/placeables/region.d.mts

@@ -0,0 +1,177 @@
+import type { ConfiguredObjectClassOrDefault } from "../../config.d.mts";
+import type { Brand, FixedInstanceType } from "fvtt-types/utils";
+import type RegionShape from "../../../client-esm/canvas/regions/shape.d.mts";
+import type RegionPolygonTree from "../../../client-esm/canvas/regions/polygon-tree.d.mts";
+import type RegionGeometry from "../../../client-esm/canvas/regions/geometry.d.mts";
+import type { Point } from "../../../common/_types.d.mts";
+
+declare global {
+  namespace Region {
+    type ConfiguredClass = ConfiguredObjectClassOrDefault<typeof Region>;
+    type ConfiguredInstance = FixedInstanceType<ConfiguredClass>;
+
+    interface RenderFlags extends PlaceableObject.RenderFlags {}
+
+    interface RegionMovementWaypoint {
+      /** The x-coordinates in pixels (integer) */
+      x: number;
+
+      /** The y-coordinates in pixels (integer) */
+      y: number;
+
+      /** The elevation in grid units. */
+      elevation: number;
+    }
+
+    interface RegionMovementSegment {
+      /** The type of htis segment (see {@link Region.MovementSegmentTypes}) */
+      type: number;
+
+      /** The waypoint that this segment starts from */
+      from: RegionMovementWaypoint;
+
+      /** The waypoint that this segment goes to */
+      to: RegionMovementWaypoint;
+    }
+
+    type MOVEMENT_SEGMENT_TYPES = Brand<number, "Region.MOVEMENT_SEGMENT_TYPES">;
+
+    interface MovementSegmentTypes
+      extends Readonly<{
+        /**
+         * The segment crosses the boundary of the region and exits it.
+         */
+        EXIT: -1 & MOVEMENT_SEGMENT_TYPES;
+
+        /**
+         * The segment does not cross the boundary of the region and is contained within it.
+         */
+        MOVE: 0 & MOVEMENT_SEGMENT_TYPES;
+
+        /**
+         * The segment crosses the boundary of the region and enters it.
+         */
+        ENTER: 1 & MOVEMENT_SEGMENT_TYPES;
+      }> {}
+  }
+
+  class Region extends PlaceableObject<RegionDocument.ConfiguredInstance> {
+    #region: true;
+
+    constructor(document: RegionDocument.ConfiguredInstance);
+
+    static override embeddedName: "Region";
+
+    static override RENDER_FLAGS: {
+      /** @defaultValue `{ propagate: ["refresh"] }` */
+      redraw: RenderFlag<Region.RenderFlags>;
+
+      /** @defaultValue `{ propagate: ["refreshState", "refreshBorder"], alias: true }` */
+      refresh: RenderFlag<Region.RenderFlags>;
+
+      /** @defaultValue `{}` */
+      refreshState: RenderFlag<Region.RenderFlags>;
+
+      /** @defaultValue `{}` */
+      refreshBorder: RenderFlag<Region.RenderFlags>;
+    };
+
+    static CLIPPER_SCALING_FACTOR: number;
+    static MOVEMENT_SEGMENT_TYPES: Region.MOVEMENT_SEGMENT_TYPES;
+
+    get shapes(): ReadonlyArray<RegionShape.Any>;
+
+    /** The bottom elevation of this Region. */
+    get bottom(): number;
+
+    /** The top elevation of this Region. */
+    get top(): number;
+
+    /** The polygons of this Region. */
+    get polygons(): ReadonlyArray<PIXI.Polygon>;
+
+    /** The polygon tree of this Region. */
+    get polygonTree(): RegionPolygonTree;
+
+    /** The Clipper paths of this Region. */
+    get clipperPaths(): ReadonlyArray<ReadonlyArray<ClipperLib.IntPoint>>;
+
+    /** The triangulation of this Region */
+    get triangulation(): ReadonlyArray<{ vertices: Float32Array; indices: Uint16Array | Uint32Array }>;
+
+    /** The geometry of this Region */
+    get geometry(): RegionGeometry;
+
+    override get bounds(): PIXI.Rectangle;
+
+    override get center(): PIXI.Point;
+
+    /** Is this Region currently visible on the Canvas? */
+    get isVisible(): boolean;
+
+    /**
+     * @throws      - Region#getSnappedPosition is not supported: RegionDocument does not have a (x, y) position
+     */
+    override getSnappedPosition(position?: Canvas.Point): never;
+
+    protected override _draw(options?: Record<string, unknown>): Promise<void>;
+
+    protected override _applyRenderFlags(flags: PlaceableObject.RenderFlags): void;
+
+    /** Refresh the state of the Region. */
+    protected _refreshState(): void;
+
+    /** Refreshes the border of the Region. */
+    protected _refreshBorder(): void;
+
+    protected override _canDrag(user: User.ConfiguredInstance, event?: PIXI.FederatedEvent | null): boolean;
+
+    protected override _canHUD(user: User.ConfiguredInstance, event?: PIXI.FederatedEvent | null): boolean;
+
+    protected override _onControl(options?: PlaceableObject.ControlOptions | null): void;
+
+    protected override _onRelease(options?: PlaceableObject.ReleaseOptions | null): void;
+
+    /** @remarks options cannot accept null because defaults are provided with `options={}` in the parameters  */
+    protected override _onHoverIn(event: PIXI.FederatedEvent, options?: PlaceableObject.HoverInOptions): false | void;
+
+    protected override _onHoverOut(event: PIXI.FederatedEvent): boolean | void;
+
+    protected override _overlapsSelection(rectangle: PIXI.Rectangle): boolean;
+
+    /**
+     * Test whether the given point (at the given elevation) is inside this Region.
+     * @param point       - The point.
+     * @param elevation   - The elevation of the point.
+     * @returns           - Is the point (at the given elevation) inside this Region?
+     * @remarks elevation cannot be null because it is explicitly checked against undefined (===) in function body.
+     */
+    testPoint(point: Point, elevation?: number): boolean;
+
+    /**
+     * Split the movement into its segments.
+     * @param waypoints                     - The waypoints of movement.
+     * @param samples                       - The points relative to the waypoints that are tested.
+     *                                        Whenever one of them is inside the region, the moved object
+     *                                        is considered to be inside the region.
+     * @returns                             - The movement split into its segments.
+     */
+    segmentizeMovement(
+      waypoints: Region.RegionMovementWaypoint[],
+      samples: Point[],
+      options?: {
+        /**
+         * Is it teleportation?
+         * @remarks options cannot accept null because defaults are provided with `options={}` in the parameters.
+         * @defaultValue `false`
+         */
+        teleport?: boolean | undefined;
+      },
+    ): Region.RegionMovementSegment[];
+
+    /**
+     * @privateRemarks _onUpdate is overridden but with no signature changes.
+     * For type simplicity it is left off. These methods historically have been the source of a large amount of computation from tsc.
+     */
+  }
+}

package/src/foundry/client/pixi/placeables/sound.d.mts

@@ -1,10 +1,11 @@
 import type Sound from "../../../client-esm/audio/sound.d.mts";
 import type { ConfiguredObjectClassOrDefault } from "../../config.d.mts";
+import type { FixedInstanceType } from "fvtt-types/utils";
 
 declare global {
   namespace AmbientSound {
     type ConfiguredClass = ConfiguredObjectClassOrDefault<typeof AmbientSound>;
-    type ConfiguredInstance = InstanceType<ConfiguredClass>;
+    type ConfiguredInstance = FixedInstanceType<ConfiguredClass>;
 
     interface RenderFlags extends PlaceableObject.RenderFlags {
       refreshField: boolean;
@@ -57,19 +58,19 @@ declare global {
 
     static override RENDER_FLAGS: {
       /** @defaultValue `{ propagate: ["refresh"] }` */
-      redraw: RenderFlag<Partial<AmbientSound.RenderFlags>>;
+      redraw: RenderFlag<AmbientSound.RenderFlags>;
 
       /** @defaultValue `{ propagate: ["refreshField"], alias: true }` */
-      refresh: RenderFlag<Partial<AmbientSound.RenderFlags>>;
+      refresh: RenderFlag<AmbientSound.RenderFlags>;
 
       /** @defaultValue `{ propagate: ["refreshPosition", "refreshState"] }` */
-      refreshField: RenderFlag<Partial<AmbientSound.RenderFlags>>;
+      refreshField: RenderFlag<AmbientSound.RenderFlags>;
 
       /** @defaultValue `{}` */
-      refreshPosition: RenderFlag<Partial<AmbientSound.RenderFlags>>;
+      refreshPosition: RenderFlag<AmbientSound.RenderFlags>;
 
       /** @defaultValue `{}` */
-      refreshState: RenderFlag<Partial<AmbientSound.RenderFlags>>;
+      refreshState: RenderFlag<AmbientSound.RenderFlags>;
     };
 
     /**

package/src/foundry/client/pixi/placeables/template.d.mts

@@ -1,10 +1,10 @@
-import type { RequiredProps } from "../../../../types/utils.d.mts";
+import type { RequiredProps, FixedInstanceType } from "fvtt-types/utils";
 import type { ConfiguredObjectClassOrDefault } from "../../config.d.mts";
 
 declare global {
   namespace MeasuredTemplate {
     type ConfiguredClass = ConfiguredObjectClassOrDefault<typeof MeasuredTemplate>;
-    type ConfiguredInstance = InstanceType<ConfiguredClass>;
+    type ConfiguredInstance = FixedInstanceType<ConfiguredClass>;
 
     interface RenderFlags extends PlaceableObject.RenderFlags {
       refreshShape: boolean;
@@ -18,7 +18,8 @@ declare global {
       refreshText: boolean;
     }
 
-    interface ObjectHUD extends globalThisObjectHUD {
+    // TODO: Fix globalThis.ObjectHUD #2962
+    interface ObjectHUD {
       /**
        * Template control icon
        */
@@ -76,28 +77,28 @@ declare global {
 
     static override RENDER_FLAGS: {
       /** @defaultValue `{ propagate: ["refresh"] }` */
-      redraw: RenderFlag<Partial<MeasuredTemplate.RenderFlags>>;
+      redraw: RenderFlag<MeasuredTemplate.RenderFlags>;
 
       /** @defaultValue `{ propagate: ["refreshState", "refreshShape"], alias: true }` */
-      refresh: RenderFlag<Partial<MeasuredTemplate.RenderFlags>>;
+      refresh: RenderFlag<MeasuredTemplate.RenderFlags>;
 
       /** @defaultValue `{}` */
-      refreshState: RenderFlag<Partial<MeasuredTemplate.RenderFlags>>;
+      refreshState: RenderFlag<MeasuredTemplate.RenderFlags>;
 
       /** @defaultValue `{ propagate: ["refreshPosition", "refreshGrid", "refreshText", "refreshTemplate"] }` */
-      refreshShape: RenderFlag<Partial<MeasuredTemplate.RenderFlags>>;
+      refreshShape: RenderFlag<MeasuredTemplate.RenderFlags>;
 
       /** @defaultValue `{}` */
-      refreshTemplate: RenderFlag<Partial<MeasuredTemplate.RenderFlags>>;
+      refreshTemplate: RenderFlag<MeasuredTemplate.RenderFlags>;
 
       /** @defaultValue `{ propagate: ["refreshGrid"] }` */
-      refreshPosition: RenderFlag<Partial<MeasuredTemplate.RenderFlags>>;
+      refreshPosition: RenderFlag<MeasuredTemplate.RenderFlags>;
 
       /** @defaultValue `{}` */
-      refreshGrid: RenderFlag<Partial<MeasuredTemplate.RenderFlags>>;
+      refreshGrid: RenderFlag<MeasuredTemplate.RenderFlags>;
 
       /** @defaultValue `{}` */
-      refreshText: RenderFlag<Partial<MeasuredTemplate.RenderFlags>>;
+      refreshText: RenderFlag<MeasuredTemplate.RenderFlags>;
     };
 
     override get bounds(): PIXI.Rectangle;

package/src/foundry/client/pixi/placeables/tile.d.mts

@@ -1,9 +1,10 @@
 import type { ConfiguredObjectClassOrDefault } from "../../config.d.mts";
+import type { FixedInstanceType } from "fvtt-types/utils";
 
 declare global {
   namespace Tile {
     type ConfiguredClass = ConfiguredObjectClassOrDefault<typeof Tile>;
-    type ConfiguredInstance = InstanceType<ConfiguredClass>;
+    type ConfiguredInstance = FixedInstanceType<ConfiguredClass>;
 
     interface RenderFlags extends PlaceableObject.RenderFlags {
       refreshShape: boolean;
@@ -71,31 +72,31 @@ declare global {
 
     static override RENDER_FLAGS: {
       /** @defaultValue `{ propagate: ["refresh"] }` */
-      redraw: RenderFlag<Partial<Tile.RenderFlags>>;
+      redraw: RenderFlag<Tile.RenderFlags>;
 
       /** @defaultValue `{ propagate: ["refreshState", "refreshShape", "refreshElevation", "refreshVideo"], alias: true }` */
-      refresh: RenderFlag<Partial<Tile.RenderFlags>>;
+      refresh: RenderFlag<Tile.RenderFlags>;
 
       /** @defaultValue `{ propagate: ["refreshFrame"] }` */
-      refreshState: RenderFlag<Partial<Tile.RenderFlags>>;
+      refreshState: RenderFlag<Tile.RenderFlags>;
 
       /** @defaultValue `{ propagate: ["refreshMesh", "refreshPerception", "refreshFrame"] }` */
-      refreshShape: RenderFlag<Partial<Tile.RenderFlags>>;
+      refreshShape: RenderFlag<Tile.RenderFlags>;
 
       /** @defaultValue `{}` */
-      refreshMesh: RenderFlag<Partial<Tile.RenderFlags>>;
+      refreshMesh: RenderFlag<Tile.RenderFlags>;
 
       /** @defaultValue `{}` */
-      refreshFrame: RenderFlag<Partial<Tile.RenderFlags>>;
+      refreshFrame: RenderFlag<Tile.RenderFlags>;
 
       /** @defaultValue `{ propagate: ["refreshMesh"] }` */
-      refreshElevation: RenderFlag<Partial<Tile.RenderFlags>>;
+      refreshElevation: RenderFlag<Tile.RenderFlags>;
 
       /** @defaultValue `{}` */
-      refreshPerception: RenderFlag<Partial<Tile.RenderFlags>>;
+      refreshPerception: RenderFlag<Tile.RenderFlags>;
 
       /** @defaultValue `{}` */
-      refreshVideo: RenderFlag<Partial<Tile.RenderFlags>>;
+      refreshVideo: RenderFlag<Tile.RenderFlags>;
     };
 
     /**
@@ -207,6 +208,7 @@ declare global {
 
     protected override _onDragLeftMove(event: PIXI.FederatedEvent): void;
 
+    // eslint-disable-next-line @typescript-eslint/no-misused-promises
     protected override _onDragLeftDrop(event: PIXI.FederatedEvent): Promise<unknown>;
 
     protected override _onDragLeftCancel(event: PIXI.FederatedEvent): void;

package/src/foundry/client/pixi/placeables/token.d.mts

@@ -1,10 +1,22 @@
-import type { RequiredProps } from "../../../../types/utils.d.mts";
+import type { NullishProps, RequiredProps, FixedInstanceType } from "fvtt-types/utils";
+import type BaseToken from "../../../common/documents/token.d.mts";
 import type { ConfiguredObjectClassOrDefault } from "../../config.d.mts";
 
 declare global {
   namespace Token {
     type ConfiguredClass = ConfiguredObjectClassOrDefault<typeof Token>;
-    type ConfiguredInstance = InstanceType<ConfiguredClass>;
+    type ConfiguredInstance = FixedInstanceType<ConfiguredClass>;
+
+    type Schema = BaseToken.Schema;
+    type Parent = BaseToken.Parent;
+
+    type Metadata = BaseToken.Metadata;
+
+    type SchemaField = BaseToken.SchemaField;
+    type ConstructorData = BaseToken.ConstructorData;
+    type UpdateData = BaseToken.UpdateData;
+    type Properties = BaseToken.Properties;
+    type Source = BaseToken.Source;
 
     interface RenderFlags extends PlaceableObject.RenderFlags {
       redrawEffects: boolean;
@@ -87,7 +99,8 @@ declare global {
     }
 
     /** The UI frame container which depicts Token metadata and status, displayed in the ControlsLayer. */
-    interface ObjectHUD extends globalThis.ObjectHUD {
+    // TODO: Fix globalThis.ObjectHUD #2962
+    interface ObjectHUD {
       /** Token health bars */
       bars?: PIXI.Container;
 
@@ -213,6 +226,110 @@ declare global {
       /** @defaultValue `false` */
       pan?: boolean;
     }
+
+    interface AnimationContext {
+      /** The name of the animation */
+      name: string | symbol;
+
+      /** The final animation state */
+      to: NullishProps<Token.AnimationData>;
+
+      /** The duration of the animation */
+      duration: number;
+
+      /** The current time of the animation */
+      time: number;
+
+      /** Asynchronous functions that are executed before the animation starts */
+      preAnimate: ((context: Token.AnimationContext) => Promise<void>)[];
+
+      /** Synchronous functions that are executed after the animation ended */
+      postAnimate: ((context: Token.AnimationContext) => void)[];
+
+      /** Synchronous functions that are executed each frame after `ontick` and before {@link Token#_onAnimationUpdate} */
+      onAnimate: ((context: Token.AnimationContext) => void)[];
+
+      /**
+       * The promise of the animation, which resolves to true if the animation
+       * completed, to false if it was terminated, and rejects if an error occurred.
+       * Undefined in the first frame (at time 0) of the animation.
+       */
+      promise?: Promise<boolean> | undefined;
+    }
+
+    /**
+     * The texture data for a token animation.
+     */
+    interface TextureData {
+      /** The texture file path. */
+      src: string;
+
+      /** The texture anchor X. */
+      anchorX: number;
+
+      /** The texture anchor Y. */
+      anchorY: number;
+
+      /** The texture scale X. */
+      scaleX: number;
+
+      /** The texture scale Y. */
+      scaleY: number;
+
+      /** The texture tint. */
+      tint: Color;
+    }
+
+    /**
+     * The ring subject data.
+     */
+    interface RingSubjectData {
+      /** The ring subject texture. */
+      texture: string;
+
+      /** The ring subject scale. */
+      scale: number;
+    }
+
+    /**
+     * The ring data.
+     */
+    interface RingData {
+      /** The ring subject data. */
+      subject: RingSubjectData;
+    }
+
+    /**
+     * Token animation data.
+     */
+    interface AnimationData {
+      /** The x position in pixels. */
+      x: number;
+
+      /** The y position in pixels. */
+      y: number;
+
+      /** The width in grid spaces. */
+      width: number;
+
+      /** The height in grid spaces. */
+      height: number;
+
+      /** The alpha value. */
+      alpha: number;
+
+      /** The rotation in degrees. */
+      rotation: number;
+
+      /** The texture data. */
+      texture: TextureData;
+
+      /** The ring data. */
+      ring: RingData;
+
+      /** The elevation in grid units */
+      elevation?: number | undefined;
+    }
   }
 
   /**
@@ -225,49 +342,49 @@ declare global {
 
     static override RENDER_FLAGS: {
       /** @defaultValue `{ propagate: ["refresh"] }` */
-      redraw: RenderFlag<Partial<Token.RenderFlags>>;
+      redraw: RenderFlag<Token.RenderFlags>;
 
       /** @defaultValue `{}` */
-      redrawEffects: RenderFlag<Partial<Token.RenderFlags>>;
+      redrawEffects: RenderFlag<Token.RenderFlags>;
 
       /** @defaultValue `{ propagate: ["refreshState", "refreshSize", "refreshPosition", "refreshElevation", "refreshBars", "refreshNameplate", "refreshBorder", "refreshShader"], alias: true }` */
-      refresh: RenderFlag<Partial<Token.RenderFlags>>;
+      refresh: RenderFlag<Token.RenderFlags>;
 
       /** @defaultValue `{ propagate: ["refreshVisibility", "refreshBorder"] }` */
-      refreshState: RenderFlag<Partial<Token.RenderFlags>>;
+      refreshState: RenderFlag<Token.RenderFlags>;
 
       /** @defaultValue `{ propagate: ["refreshMesh", "refreshBorder", "refreshBars", "refreshPosition", "refreshTarget", "refreshEffects"] }` */
-      refreshSize: RenderFlag<Partial<Token.RenderFlags>>;
+      refreshSize: RenderFlag<Token.RenderFlags>;
 
       /** @defaultValue `{ propagate: ["refreshMesh", "refreshVisibility"] }` */
-      refreshPosition: RenderFlag<Partial<Token.RenderFlags>>;
+      refreshPosition: RenderFlag<Token.RenderFlags>;
 
       /** @defaultValue `{ propagate: ["refreshMesh"] }` */
-      refreshElevation: RenderFlag<Partial<Token.RenderFlags>>;
+      refreshElevation: RenderFlag<Token.RenderFlags>;
 
       /** @defaultValue `{}` */
-      refreshVisibility: RenderFlag<Partial<Token.RenderFlags>>;
+      refreshVisibility: RenderFlag<Token.RenderFlags>;
 
       /** @defaultValue `{}` */
-      refreshEffects: RenderFlag<Partial<Token.RenderFlags>>;
+      refreshEffects: RenderFlag<Token.RenderFlags>;
 
       /** @defaultValue `{}` */
-      refreshMesh: RenderFlag<Partial<Token.RenderFlags>>;
+      refreshMesh: RenderFlag<Token.RenderFlags>;
 
       /** @defaultValue `{}` */
-      refreshShader: RenderFlag<Partial<Token.RenderFlags>>;
+      refreshShader: RenderFlag<Token.RenderFlags>;
 
       /** @defaultValue `{}` */
-      refreshBars: RenderFlag<Partial<Token.RenderFlags>>;
+      refreshBars: RenderFlag<Token.RenderFlags>;
 
       /** @defaultValue `{}` */
-      refreshNameplate: RenderFlag<Partial<Token.RenderFlags>>;
+      refreshNameplate: RenderFlag<Token.RenderFlags>;
 
       /** @defaultValue `{}` */
-      refreshBorder: RenderFlag<Partial<Token.RenderFlags>>;
+      refreshBorder: RenderFlag<Token.RenderFlags>;
 
       /** @defaultValue `{}` */
-      refreshTarget: RenderFlag<Partial<Token.RenderFlags>>;
+      refreshTarget: RenderFlag<Token.RenderFlags>;
     };
 
     /**
@@ -301,6 +418,11 @@ declare global {
      */
     light: foundry.canvas.sources.PointLightSource;
 
+    /**
+     * The current animations of this Token.
+     */
+    get animationContexts(): Map<string, Token.AnimationContext>;
+
     /**
      * A reference to an animation that is currently in progress for this Token, if any
      * @internal
@@ -572,6 +694,12 @@ declare global {
      */
     protected _drawEffect(src: string, tint: number | null): Promise<PIXI.Sprite | undefined>;
 
+    /**
+     * Draw the effect icons for ActiveEffect documents which apply to the Token's Actor.
+     * Called by {@link Token#drawEffects}.
+     */
+    protected _drawEffects(): Promise<void>;
+
     /**
      * Draw the overlay effect icon
      */
@@ -741,6 +869,7 @@ declare global {
 
     protected override _onControl(options?: Token.ControlOptions): void;
 
+    // eslint-disable-next-line @typescript-eslint/no-misused-promises
     protected override _onRelease(
       options: PlaceableObject.ReleaseOptions,
     ): Promise<TokenDocument.ConfiguredInstance> | undefined;
@@ -767,7 +896,8 @@ declare global {
 
     protected override _onClickRight2(event: PIXI.FederatedEvent): void;
 
-    protected override _onDragLeftDrop(event: PIXI.FederatedEvent): Promise<any>;
+    // eslint-disable-next-line @typescript-eslint/no-misused-promises
+    protected override _onDragLeftDrop(event: PIXI.FederatedEvent): Promise<unknown>;
 
     protected override _onDragLeftMove(event: PIXI.FederatedEvent): void;
 

package/src/foundry/client/pixi/placeables/wall.d.mts

@@ -1,10 +1,11 @@
+import type { FixedInstanceType } from "fvtt-types/utils";
 import type { LineIntersection } from "../../../common/utils/geometry.d.mts";
 import type { ConfiguredObjectClassOrDefault } from "../../config.d.mts";
 
 declare global {
   namespace Wall {
     type ConfiguredClass = ConfiguredObjectClassOrDefault<typeof Wall>;
-    type ConfiguredInstance = InstanceType<ConfiguredClass>;
+    type ConfiguredInstance = FixedInstanceType<ConfiguredClass>;
 
     interface RenderFlags extends PlaceableObject.RenderFlags {
       refreshLine: boolean;
@@ -37,25 +38,25 @@ declare global {
 
     static override RENDER_FLAGS: {
       /** @defaultValue `{ propagate: ["refresh"] }` */
-      redraw: RenderFlag<Partial<Wall.RenderFlags>>;
+      redraw: RenderFlag<Wall.RenderFlags>;
 
       /** @defaultValue `{ propagate: ["refreshState", "refreshLine"], alias: true }` */
-      refresh: RenderFlag<Partial<Wall.RenderFlags>>;
+      refresh: RenderFlag<Wall.RenderFlags>;
 
       /** @defaultValue `{ propagate: ["refreshEndpoints", "refreshHighlight"] }` */
-      refreshState: RenderFlag<Partial<Wall.RenderFlags>>;
+      refreshState: RenderFlag<Wall.RenderFlags>;
 
       /** @defaultValue `{ propagate: ["refreshEndpoints", "refreshHighlight", "refreshDirection"] }` */
-      refreshLine: RenderFlag<Partial<Wall.RenderFlags>>;
+      refreshLine: RenderFlag<Wall.RenderFlags>;
 
       /** @defaultValue `{}` */
-      refreshEndpoints: RenderFlag<Partial<Wall.RenderFlags>>;
+      refreshEndpoints: RenderFlag<Wall.RenderFlags>;
 
       /** @defaultValue `{}` */
-      refreshDirection: RenderFlag<Partial<Wall.RenderFlags>>;
+      refreshDirection: RenderFlag<Wall.RenderFlags>;
 
       /** @defaultValue `{}` */
-      refreshHighlight: RenderFlag<Partial<Wall.RenderFlags>>;
+      refreshHighlight: RenderFlag<Wall.RenderFlags>;
     };
 
     /**
@@ -125,7 +126,7 @@ declare global {
     /**
      * Return the coordinates [x,y] at the midpoint of the wall segment
      */
-    get midpoint(): Canvas.PointArray;
+    get midpoint(): Canvas.PointTuple;
 
     override get center(): PIXI.Point;
 
@@ -265,6 +266,7 @@ declare global {
 
     protected override _onDragLeftMove(event: PIXI.FederatedEvent): void;
 
+    // eslint-disable-next-line @typescript-eslint/no-misused-promises
     protected override _onDragLeftDrop(event: PIXI.FederatedEvent): Promise<unknown>;
 
     /**