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

package/src/foundry/client/pixi/layers/placeables/templates.d.mts

@@ -1,14 +1,11 @@
-export {};
+import type { HandleEmptyObject } from "fvtt-types/utils";
 
 /**
  * This Canvas Layer provides a container for MeasuredTemplate objects.
  * @see {@link MeasuredTemplate}
  */
 declare global {
-  class TemplateLayer<
-    DrawOptions extends TemplateLayer.DrawOptions = TemplateLayer.DrawOptions,
-    TearDownOptions extends PlaceablesLayer.TearDownOptions = PlaceablesLayer.TearDownOptions,
-  > extends PlaceablesLayer<"MeasuredTemplate", DrawOptions, TearDownOptions> {
+  class TemplateLayer extends PlaceablesLayer<"MeasuredTemplate"> {
     /**
      * @privateRemarks This is not overridden in foundry but reflects the real behavior.
      */
@@ -37,7 +34,7 @@ declare global {
 
     override _deactivate(): void;
 
-    override _draw(options?: DrawOptions): Promise<void>;
+    override _draw(options: HandleEmptyObject<TemplateLayer.DrawOptions>): Promise<void>;
 
     /**
      * Register game settings used by the TemplatesLayer

package/src/foundry/client/pixi/layers/placeables/tiles.d.mts

@@ -1,13 +1,11 @@
+import type { HandleEmptyObject } from "../../../../../utils/index.d.mts";
 import type BaseTile from "../../../../common/documents/tile.d.mts";
 
 declare global {
   /**
    * A PlaceablesLayer designed for rendering the visual Scene for a specific vertical cross-section.
    */
-  class TilesLayer<
-    DrawOptions extends PlaceablesLayer.DrawOptions = PlaceablesLayer.DrawOptions,
-    TearDownOptions extends TilesLayer.TearDownOptions = TilesLayer.TearDownOptions,
-  > extends PlaceablesLayer<"Tile", DrawOptions, TearDownOptions> {
+  class TilesLayer extends PlaceablesLayer<"Tile"> {
     /**
      * @privateRemarks This is not overridden in foundry but reflects the real behavior.
      */
@@ -43,7 +41,7 @@ declare global {
 
     override getSnappedPoint(point: Canvas.Point): Canvas.Point;
 
-    protected override _tearDown(options?: TearDownOptions): Promise<void>;
+    protected override _tearDown(options: HandleEmptyObject<TilesLayer.TearDownOptions>): Promise<void>;
 
     protected override _onDragLeftStart(event: PIXI.FederatedEvent): void;
 

package/src/foundry/client/pixi/layers/placeables/tokens.d.mts

@@ -1,15 +1,11 @@
-import type { ArrayOverlaps } from "../../../../../types/helperTypes.d.mts";
-import type { NullishProps } from "../../../../../types/utils.d.mts";
+import type { ArrayOverlaps, HandleEmptyObject, NullishProps } from "fvtt-types/utils";
 import type Document from "../../../../common/abstract/document.d.mts";
 
 declare global {
   /**
    * The Tokens Container
    */
-  class TokenLayer<
-    DrawOptions extends TokenLayer.DrawOptions = TokenLayer.DrawOptions,
-    TearDownOptions extends TokenLayer.TearDownOptions = TokenLayer.TearDownOptions,
-  > extends PlaceablesLayer<"Token", DrawOptions, TearDownOptions> {
+  class TokenLayer extends PlaceablesLayer<"Token"> {
     /**
      * The current index position in the tab cycle
      * @defaultValue `null`
@@ -63,9 +59,9 @@ declare global {
 
     override getSnappedPoint(point: Canvas.Point): Canvas.Point;
 
-    protected override _draw(options?: DrawOptions): Promise<void>;
+    protected override _draw(options: HandleEmptyObject<TokenLayer.DrawOptions>): Promise<void>;
 
-    protected override _tearDown(options?: TearDownOptions): Promise<void>;
+    protected override _tearDown(options: HandleEmptyObject<TokenLayer.TearDownOptions>): Promise<void>;
 
     protected override _activate(): void;
 
@@ -129,10 +125,10 @@ declare global {
     protected _onDropActorData(
       event: DragEvent,
       data: TokenLayer.DropData,
-    ): Promise<ReturnType<Notifications["warn"]> | false | TokenDocument.ConfiguredInstance>;
+    ): Promise<ReturnType<foundry.applications.ui.Notifications["warn"]> | false | TokenDocument.ConfiguredInstance>;
 
     //TODO: use configured ruler type once it exists
-    protected override _onClickLeft(event: PIXI.FederatedEvent): ReturnType<Ruler["_onClickLeft"]> | void; // ReturnType<CONFIG.Canvas["rulerClass"]["_onClickLeft"]>;
+    protected override _onClickLeft(event: PIXI.FederatedEvent): void; // ReturnType<CONFIG.Canvas["rulerClass"]["_onClickLeft"]>;
 
     protected override _onMouseWheel(event: WheelEvent): ReturnType<this["rotateMany"]>;
 

package/src/foundry/client/pixi/layers/placeables/walls.d.mts

@@ -1,14 +1,11 @@
-import type { ConstructorOf, NullishProps } from "../../../../../types/utils.d.mts";
+import type { HandleEmptyObject, NullishProps } from "fvtt-types/utils";
 import type Document from "../../../../common/abstract/document.d.mts";
 
 declare global {
   /**
    * The Walls canvas layer which provides a container for Wall objects within the rendered Scene.
    */
-  class WallsLayer<
-    DrawOptions extends WallsLayer.DrawOptions = WallsLayer.DrawOptions,
-    TearDownOptions extends PlaceablesLayer.TearDownOptions = PlaceablesLayer.TearDownOptions,
-  > extends PlaceablesLayer<"Wall", DrawOptions, TearDownOptions> {
+  class WallsLayer extends PlaceablesLayer<"Wall"> {
     /**
      * A graphics layer used to display chained Wall selection
      * @defaultValue `null`
@@ -38,7 +35,7 @@ declare global {
      * ```
      */
     protected last: {
-      point: Canvas.PointArray | null;
+      point: Canvas.PointTuple | null;
     };
 
     /**
@@ -74,7 +71,7 @@ declare global {
 
     override getSnappedPoint(point: Canvas.Point): Canvas.Point;
 
-    override _draw(options?: DrawOptions): Promise<void>;
+    override _draw(options: HandleEmptyObject<WallsLayer.DrawOptions>): Promise<void>;
 
     override _deactivate(): void;
 
@@ -84,7 +81,7 @@ declare global {
      * @param wall  - The existing Wall object being chained to
      * @returns The [x,y] coordinates of the starting endpoint
      */
-    static getClosestEndpoint(point: Canvas.Point, wall: Wall.ConfiguredInstance): Canvas.PointArray;
+    static getClosestEndpoint(point: Canvas.Point, wall: Wall.ConfiguredInstance): Canvas.PointTuple;
 
     override releaseAll(options?: PlaceableObject.ReleaseOptions): number;
 
@@ -116,7 +113,7 @@ declare global {
          */
         snap: boolean;
       }>,
-    ): Canvas.PointArray;
+    ): Canvas.PointTuple;
 
     /**
      * The Scene Controls tools provide several different types of prototypical Walls to choose from
@@ -141,7 +138,8 @@ declare global {
      */
     identifyInteriorArea(walls: Wall.ConfiguredInstance[]): PIXI.Polygon[];
 
-    protected override _onDragLeftStart(event: PIXI.FederatedEvent): ReturnType<Wall.ConfiguredInstance["draw"]>;
+    // eslint-disable-next-line @typescript-eslint/no-misused-promises
+    protected override _onDragLeftStart(event: PIXI.FederatedEvent): Promise<Wall.ConfiguredInstance>;
 
     protected override _onDragLeftMove(event: PIXI.FederatedEvent): void;
 
@@ -197,7 +195,7 @@ declare global {
       controllableObjects: true;
       objectClass: typeof Wall;
       quadtree: true;
-      sheetClass: ConstructorOf<FormApplication>;
+      sheetClass: FormApplication.AnyConstructor;
       sortActiveTop: boolean;
       zIndex: number;
     }

package/src/foundry/client/pixi/perception/clockwise-sweep.d.mts

@@ -1,12 +1,15 @@
+import type { IntentionalPartial } from "fvtt-types/utils";
 import type Edge from "../../../client-esm/canvas/edges/edge.d.mts";
 
 declare global {
-  type VertexMap = Map<number, foundry.canvas.edges.PolygonVertex>;
-
-  type EdgeSet = Set<Edge>;
-
   interface PolygonRay extends Ray {
-    result: foundry.canvas.edges.CollisionResult;
+    /**
+     * @remarks Only set in `ClockwiseSweepPolygon#_switchEdge` and only consumed in `#visualize`,
+     * despite unrelated method(s) having parameters claiming to want a `PolygonRay`
+     *
+     * Tested for truthiness in `#visualize` before use, so a nullish value is fine but never attains in core
+     */
+    result?: foundry.canvas.edges.CollisionResult | undefined | null;
   }
 
   /**
@@ -15,15 +18,21 @@ declare global {
    * This algorithm was created with valuable contributions from https://github.com/caewok
    */
   class ClockwiseSweepPolygon extends PointSourcePolygon {
+    // This does not appear in Foundry code, it's a necessary type override
+    static override create(origin: Canvas.Point, config: PointSourcePolygon.Config): ClockwiseSweepPolygon;
+
+    // This does not appear in foundry code, it's a necessary type override
+    override config: ClockwiseSweepPolygon.StoredConfig;
+
     /**
      * A mapping of vertices which define potential collision points
      */
-    vertices: VertexMap;
+    vertices: Map<number, foundry.canvas.edges.PolygonVertex>;
 
     /**
      * The set of edges which define potential boundaries of the polygon
      */
-    edges: EdgeSet;
+    edges: Set<Edge>;
 
     /**
      * A collection of rays which are fired at vertices
@@ -31,7 +40,7 @@ declare global {
     // @ts-expect-error Getter/setter routine is deprecated functionality as of v11, removed in v13
     rays: PolygonRay[];
 
-    override initialize(origin: Canvas.Point, config: PointSourcePolygonConfig): void;
+    override initialize(origin: Canvas.Point, config?: PointSourcePolygon.Config): void;
 
     clone(): this;
 
@@ -46,7 +55,7 @@ declare global {
     /**
      * Determine the edge types and their manner of inclusion for this polygon instance
      */
-    protected _determineEdgeTypes(): Record<Edge.EdgeTypes, 0 | 1 | 2>;
+    protected _determineEdgeTypes(): ClockwiseSweepPolygon.DetermineEdgesReturn;
 
     /**
      * Test whether a wall should be included in the computed polygon for a given origin and type
@@ -57,7 +66,7 @@ declare global {
      */
     protected _testEdgeInclusion(
       edge: Edge,
-      edgeTypes: Record<Edge.EdgeTypes, 0 | 1 | 2>,
+      edgeTypes: ClockwiseSweepPolygon.DetermineEdgesReturn,
       bounds: PIXI.Rectangle,
     ): boolean;
 
@@ -75,25 +84,25 @@ declare global {
     /**
      * Add additional vertices for intersections between edges.
      */
-    protected _identifyIntersections(wallEdgeMap: Map<string, Edge>): void;
+    protected _identifyIntersections(edgeMap: Map<string, Edge>): void;
 
     /**
      * Execute the sweep over wall vertices
-     * @internal
+     * @privateRemarks Foundry marked `@private`
      */
     protected _executeSweep(): void;
 
     /**
      * Determine the initial set of active edges as those which intersect with the initial ray
      * @returns A set of initially active edges
-     * @internal
+     * @privateRemarks Foundry marked `@private`
      */
-    protected _initializeActiveEdges(): EdgeSet;
+    protected _initializeActiveEdges(): Set<Edge>;
 
     /**
      * Sort vertices clockwise from the initial ray (due west).
      * @returns The array of sorted vertices
-     * @internal
+     * @privateRemarks Foundry marked `@private`
      */
     protected _sortVertices(): foundry.canvas.edges.PolygonVertex[];
 
@@ -105,11 +114,11 @@ declare global {
      * @param vertex      - The target vertex
      * @param activeEdges - The set of active edges
      * @returns Is the target vertex behind some closer edge?
-     * @internal
+     * @privateRemarks Foundry marked `@private`
      */
     protected _isVertexBehindActiveEdges(
       vertex: foundry.canvas.edges.PolygonVertex,
-      activeEdges: EdgeSet,
+      activeEdges: Set<Edge>,
     ): { isBehind: boolean; wasLimited: boolean };
 
     /**
@@ -117,12 +126,13 @@ declare global {
      * @param vertex        - The target vertex
      * @param activeEdges   - The set of active edges
      * @param hasCollinear  - Are there collinear vertices behind the target vertex?
-     * @internal
+     *                        default: `false`
+     * @privateRemarks Foundry marked `@private`
      */
     protected _determineSweepResult(
       vertex: foundry.canvas.edges.PolygonVertex,
-      activeEdges: EdgeSet,
-      hasCollinear: boolean,
+      activeEdges: Set<Edge>,
+      hasCollinear?: boolean,
     ): void;
 
     /**
@@ -134,24 +144,43 @@ declare global {
      *
      * If neither side is blocked and the ray internally collides with a non-limited edge, n skip without adding polygon
      * endpoints. Sight is unaffected before this edge, and the internal collision can be ignored.
-     * @internal
      *
      * @param result      - The pending collision result
      * @param activeEdges - The set of currently active edges
+     * @privateRemarks Foundry marked `@private`
      */
-    _switchEdge(result: foundry.canvas.edges.CollisionResult, activeEdges: EdgeSet): void;
+    protected _switchEdge(result: foundry.canvas.edges.CollisionResult, activeEdges: Set<Edge>): void;
 
     protected override _testCollision<Mode extends PointSourcePolygon.CollisionModes>(
       ray: Ray,
       mode: Mode,
     ): PointSourcePolygon.TestCollision<Mode>;
 
-    override visualize(): PIXI.Graphics | undefined;
+    override visualize(): PIXI.Graphics;
 
     /**
      * Visualize the polygon, displaying its computed area, rays, and collision points
-     * @internal
+     * @privateRemarks Foundry marked `@private`
      */
     protected _visualizeCollision(ray: Ray, collisions: foundry.canvas.edges.PolygonVertex[]): void;
   }
+
+  namespace ClockwiseSweepPolygon {
+    interface Any extends AnyClockwiseSweepPolygon {}
+    type AnyConstructor = typeof AnyClockwiseSweepPolygon;
+
+    interface StoredConfig extends PointSourcePolygon.StoredConfig {
+      /** The computed bounding box for the polygon */
+      boundingBox: PIXI.Rectangle;
+    }
+    /**
+     * @privateRemarks Foundry types this as `Record<Edge.EdgeTypes, 0 | 1 | 2>`, but some keys are mutually exclusive,
+     * and none are ever set to `0`, they're simply omitted and then tested for truthiness in `#_testEdgeInclusion`
+     */
+    type DetermineEdgesReturn = IntentionalPartial<Record<Edge.EdgeTypes, 1 | 2>>;
+  }
+}
+
+declare abstract class AnyClockwiseSweepPolygon extends ClockwiseSweepPolygon {
+  constructor(arg0: never, ...args: never[]);
 }

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

@@ -1,7 +1,9 @@
-import type { InexactPartial, ValueOf } from "../../../../types/utils.d.mts";
-import type { fields } from "../../../common/data/module.d.mts";
+import type { InexactPartial, ValueOf } from "fvtt-types/utils";
+import type { fields } from "../../../common/data/_module.d.mts";
 import type { TokenDetectionMode } from "../../../common/documents/_types.d.mts";
 
+type DataSchema = foundry.data.fields.DataSchema;
+
 declare global {
   namespace DetectionMode {
     interface Schema extends DataSchema {

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

@@ -127,4 +127,13 @@ declare global {
      */
     get resolution(): CanvasVisibility["textureConfiguration"];
   }
+
+  namespace FogManager {
+    type Any = AnyFogManager;
+    type AnyConstructor = typeof AnyFogManager;
+  }
+}
+
+declare abstract class AnyFogManager extends FogManager {
+  constructor(arg0: never, ...args: never[]);
 }

package/src/foundry/client/pixi/perception/perception-manager.d.mts

@@ -1,4 +1,4 @@
-export {}
+export {};
 
 declare global {
   interface PerceptionManagerFlags {

package/src/foundry/client/pixi/perception/vision-mode.d.mts

@@ -1,5 +1,8 @@
-import type { AnyObject, InexactPartial, SimpleMerge, ValueOf } from "../../../../types/utils.d.mts";
-import type { fields } from "../../../common/data/module.d.mts";
+import type { AnyObject, InexactPartial, SimpleMerge, ValueOf } from "fvtt-types/utils";
+import type { fields } from "../../../common/data/_module.d.mts";
+import DataField = foundry.data.fields.DataField;
+
+type DataSchema = foundry.data.fields.DataSchema;
 
 declare global {
   class ShaderField<
@@ -97,10 +100,10 @@ declare global {
   }
 
   namespace ShaderField {
-    type Options = DataFieldOptions<typeof AbstractBaseShader>;
+    type Options = DataField.Options<typeof AbstractBaseShader>;
 
     type DefaultOptions = SimpleMerge<
-      foundry.data.fields.DataField.DefaultOptions,
+      DataField.DefaultOptions,
       {
         nullable: true;
         initial: undefined;
@@ -144,10 +147,7 @@ declare global {
       uniforms: fields.ObjectField;
     }>;
 
-    type LightingLevels = Record<
-      ValueOf<typeof CONST.LIGHTING_LEVELS>,
-      ValueOf<typeof CONST.LIGHTING_LEVELS>
-    >;
+    type LightingLevels = Record<ValueOf<typeof CONST.LIGHTING_LEVELS>, ValueOf<typeof CONST.LIGHTING_LEVELS>>;
     type LightingMultipliers = Record<ValueOf<typeof VisionMode.LIGHTING_LEVELS>, number>;
 
     interface Schema extends DataSchema {
@@ -189,11 +189,29 @@ declare global {
           adaptive: fields.BooleanField<{ initial: true }>;
         }>;
         defaults: fields.SchemaField<{
-          color: fields.ColorField<{required: false, initial: undefined}>;
-          attenuation: fields.AlphaField<{required: false, initial: undefined}>;
-          brightness: fields.NumberField<{required: false, initial: undefined, nullable: false, min: number, max: number}>;
-          saturation: fields.NumberField<{required: false, initial: undefined, nullable: false, min: number, max: number}>;
-          contrast: fields.NumberField<{required: false, initial: undefined, nullable: false, min: number, max: number}>;
+          color: fields.ColorField<{ required: false; initial: undefined }>;
+          attenuation: fields.AlphaField<{ required: false; initial: undefined }>;
+          brightness: fields.NumberField<{
+            required: false;
+            initial: undefined;
+            nullable: false;
+            min: number;
+            max: number;
+          }>;
+          saturation: fields.NumberField<{
+            required: false;
+            initial: undefined;
+            nullable: false;
+            min: number;
+            max: number;
+          }>;
+          contrast: fields.NumberField<{
+            required: false;
+            initial: undefined;
+            nullable: false;
+            min: number;
+            max: number;
+          }>;
         }>;
         preferred: fields.BooleanField<{ initial: false }>;
       }>;

package/src/foundry/client/pixi/perception/weiler-atherton-clipping.d.mts

@@ -1,4 +1,4 @@
-import type { InexactPartial, ValueOf } from "../../../../types/utils.d.mts";
+import type { Brand, NullishProps } from "fvtt-types/utils";
 
 declare global {
   /**
@@ -15,6 +15,9 @@ declare global {
    * https://en.wikipedia.org/wiki/Weiler%E2%80%93Atherton_clipping_algorithm
    * https://www.geeksforgeeks.org/weiler-atherton-polygon-clipping-algorithm
    * https://h-educate.in/weiler-atherton-polygon-clipping-algorithm/
+   *
+   * @throws If `!Polygon.isPositive`
+   * @remarks In practice the only thing that uses the constructor is the class's static methods
    */
   class WeilerAthertonClipper {
     /**
@@ -29,7 +32,7 @@ declare global {
     constructor(
       polygon: PIXI.Polygon,
       clipObject: PIXI.Rectangle | PIXI.Circle,
-      clipType?: ValueOf<(typeof WeilerAthertonClipper)["CLIP_TYPES"]>,
+      clipType?: WeilerAthertonClipper.CLIP_TYPES,
       clipOpts?: WeilerAthertonClipper.ClipOpts,
     );
 
@@ -37,19 +40,12 @@ declare global {
      * The supported clip types.
      * Values are equivalent to those in ClipperLib.ClipType.
      */
-    static readonly CLIP_TYPES: Readonly<{
-      INTERSECT: 0;
-      UNION: 1;
-    }>;
+    static CLIP_TYPES: WeilerAthertonClipper.ClipTypes;
 
     /**
      * The supported intersection types.
      */
-    static readonly INTERSECTION_TYPES: Readonly<{
-      OUT_IN: -1;
-      IN_OUT: 1;
-      TANGENT: 0;
-    }>;
+    static INTERSECTION_TYPES: WeilerAthertonClipper.IntersectionTypes;
 
     polygon: PIXI.Polygon;
 
@@ -57,15 +53,8 @@ declare global {
 
     /**
      * Configuration settings
-     * @param clipType  - One of CLIP_TYPES
-     * @param clipOpts  - Object passed to the clippingObject methods
-     *                    toPolygon and pointsBetween
-     * @defaultValue `{}`
      */
-    config: {
-      clipType?: typeof WeilerAthertonClipper.CLIP_TYPES;
-      clipOpts?: WeilerAthertonClipper.ClipOpts;
-    };
+    config: WeilerAthertonClipper.Config;
 
     /**
      * Union a polygon and clipObject using the Weiler Atherton algorithm.
@@ -77,7 +66,7 @@ declare global {
     static union(
       polygon: PIXI.Polygon,
       clipObject: PIXI.Rectangle | PIXI.Circle,
-      clipOpts: WeilerAthertonClipper.ClipOpts,
+      clipOpts?: WeilerAthertonClipper.ClipOpts,
     ): PIXI.Polygon[];
 
     /**
@@ -90,7 +79,7 @@ declare global {
     static intersect(
       polygon: PIXI.Polygon,
       clipObject: PIXI.Rectangle | PIXI.Circle,
-      clipOpts: WeilerAthertonClipper.ClipOpts,
+      clipOpts?: WeilerAthertonClipper.ClipOpts,
     ): PIXI.Polygon[];
 
     /**
@@ -108,23 +97,8 @@ declare global {
     static combine(
       polygon: PIXI.Polygon,
       clipObject: PIXI.Rectangle | PIXI.Circle,
-      options?: InexactPartial<{
-        /**
-         * One of CLIP_TYPES
-         * @defaultValue `0`
-         */
-        clipType: ValueOf<typeof WeilerAthertonClipper.CLIP_TYPES>;
-
-        /**
-         * If the WeilerAtherton constructor could mutate or not the subject polygon points
-         */
-        canMutate: boolean;
-
-        /**
-         * Options passed to the WeilerAthertonClipper constructor
-         */
-        clipOpts: WeilerAthertonClipper.ClipOpts;
-      }>,
+      /** @remarks Despite foundry marking this parameter optional, if an object with a valid `clipType` property is not passed, this will throw */
+      options: WeilerAthertonClipper.CombineOptions,
     ): PIXI.Polygon[];
 
     /**
@@ -141,12 +115,76 @@ declare global {
     static testForEnvelopment(
       polygon: PIXI.Polygon,
       clipObject: PIXI.Rectangle | PIXI.Circle,
-      clipType: typeof WeilerAthertonClipper.CLIP_TYPES,
+      clipType: WeilerAthertonClipper.CLIP_TYPES,
       clipOpts: WeilerAthertonClipper.ClipOpts,
     ): PIXI.Polygon[];
   }
 
   namespace WeilerAthertonClipper {
+    interface Any extends AnyWeilerAthertonClipper {}
+    type AnyConstructor = typeof AnyWeilerAthertonClipper;
+
+    type CLIP_TYPES = Brand<number, "WeilerAthertonClipper.CLIP_TYPES">;
+
+    interface ClipTypes {
+      readonly INTERSECT: 0 & CLIP_TYPES;
+      readonly UNION: 1 & CLIP_TYPES;
+    }
+
+    type INTERSECTION_TYPES = Brand<number, "WeilerAthertonClipper.INTERSECTION_TYPES">;
+
+    interface IntersectionTypes {
+      readonly OUT_IN: -1 & INTERSECTION_TYPES;
+      readonly IN_OUT: 1 & INTERSECTION_TYPES;
+      readonly TANGENT: 0 & INTERSECTION_TYPES;
+    }
+
+    /** Configuration settings */
+    interface Config {
+      /**
+       * One of CLIP_TYPES
+       * @defaultValue `WeilerAthertonClipper.CLIP_TYPES.INTERSECT`
+       * @remarks Set to the value of the equivalent constructor parameter. Default provided by `??=` in the constructor body
+       */
+      clipType: WeilerAthertonClipper.CLIP_TYPES;
+
+      /**
+       * Object passed to the clippingObject methods `toPolygon` and `pointsBetween`
+       * @defaultValue `{}`
+       * @remarks Set to the value of the equivalent constructor parameter. Default provided by `??=` in the constructor body
+       */
+      clipOpts: WeilerAthertonClipper.ClipOpts;
+    }
+
+    /**
+     * @internal
+     * @privateRemarks does *not* contain:
+     * - a `scalingFactor` property, despite one being passed in `PIXI.Rectangle#intersectPolygon` in v12
+     * - a `density` property, despite one being passed in `PIXI.Circle#intersectPolygon` in v12
+     */
+    type _CombineOptions = NullishProps<{
+      /**
+       * If the WeilerAtherton constructor could mutate or not the subject polygon points
+       */
+      canMutate: boolean;
+    }>;
+
+    interface CombineOptions extends _CombineOptions, ClipOpts {
+      /**
+       * One of CLIP_TYPES
+       */
+      clipType: WeilerAthertonClipper.CLIP_TYPES;
+    }
+
+    /**
+     * @remarks These are ultimately only consumed by the `#toPolygon` and `#pointsBetween` methods
+     * of `PIXI.Rectangle` or `PIXI.Circle`. Only the `Circle` methods actually take options and those are
+     * only passed on to `#pointsForArc`.
+     */
     type ClipOpts = PIXI.Circle.PointsForArcOptions;
   }
 }
+
+declare abstract class AnyWeilerAthertonClipper extends WeilerAthertonClipper {
+  constructor(arg0: never, ...args: never[]);
+}

package/src/foundry/client/pixi/placeable.d.mts

@@ -1,7 +1,6 @@
-import type { MakeConform } from "../../../types/helperTypes.d.mts";
-import type { ValueOf } from "../../../types/utils.d.mts";
+import type { MakeConform, ValueOf } from "fvtt-types/utils";
 import type ApplicationV2 from "../../client-esm/applications/api/application.d.mts";
-import type { Document } from "../../common/abstract/module.d.mts";
+import type { Document } from "../../common/abstract/_module.d.mts";
 
 // Gets a key with a required shape to conform to which is also used as a fallback when the key doesn't exist.
 type GetKeyWithShape<T, K, S> = K extends keyof T ? MakeConform<T[K], S> : S;
@@ -350,10 +349,7 @@ declare global {
      * @param action - The named action being attempted
      * @returns Does the User have rights to perform the action?
      */
-    can(
-      user: User.ConfiguredInstance,
-      action: "HUD" | "configure" | "control" | "view" | "create" | "drag" | "hover" | "update" | "delete" | string,
-    ): boolean;
+    can(user: User.ConfiguredInstance, action: PlaceableObject.Action): boolean;
 
     /**
      * Can the User access the HUD for this Placeable Object?
@@ -609,6 +605,18 @@ declare global {
        */
       hoverOutOthers: boolean;
     }
+
+    type Action =
+      | "HUD"
+      | "configure"
+      | "control"
+      | "view"
+      | "create"
+      | "drag"
+      | "hover"
+      | "update"
+      | "delete"
+      | (string & {});
   }
 }