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

package/src/foundry/client/canvas/geometry/shapes/source-polygon.d.mts

@@ -0,0 +1,368 @@
+import type { Brand, Coalesce, Identity, InexactPartial } from "#utils";
+import type PointEffectSourceMixin from "#client/canvas/sources/point-effect-source.d.mts";
+import type { Canvas } from "#client/canvas/_module.d.mts";
+import type { Ray } from "#client/canvas/geometry/_module.d.mts";
+import type { PolygonVertex } from "#client/canvas/geometry/edges/_module.d.mts";
+
+/**
+ * An extension of the default PIXI.Polygon which is used to represent the line of sight for a point source.
+ * @remarks Methods and types that need subclass overrides to account for expanded Configs:
+ * - {@linkcode PointSourcePolygon.Config}
+ * - {@linkcode PointSourcePolygon.StoredConfig}
+ * - {@linkcode PointSourcePolygon.config | PointSourcePolygon#config}
+ * - {@linkcode PointSourcePolygon.benchmark}
+ * - {@linkcode PointSourcePolygon.create}
+ * - {@linkcode PointSourcePolygon.testCollision}
+ * - {@linkcode PointSourcePolygon.TestCollisionOptions}
+ * - {@linkcode PointSourcePolygon.TestCollisionConfig}
+ *
+ * See {@linkcode foundry.canvas.geometry.ClockwiseSweepPolygon | ClockwiseSweepPolygon} for examples (and probably
+ * use it as your base class, since Foundry is assuming the availability of its APIs in more places as time goes on)
+ */
+declare abstract class PointSourcePolygon extends PIXI.Polygon {
+  /**
+   * @remarks This is protected because `new PointSourcePolygon` does not sufficiently initialize the class; Use the static `create` method instead.
+   */
+  protected constructor(...args: ConstructorParameters<typeof PIXI.Polygon>);
+
+  /**
+   * Customize how wall direction of one-way walls is applied
+   */
+  static WALL_DIRECTION_MODES: PointSourcePolygon.WallDirectionModes;
+
+  /**
+   * The rectangular bounds of this polygon
+   * @defaultValue `new PIXI.Rectangle(0, 0, 0, 0)`
+   */
+  bounds: PIXI.Rectangle;
+
+  /**
+   * The origin point of the source polygon.
+   * @privateRemarks Not initialized to any value, but immediately set by {@linkcode PointSourcePolygon.initialize | #initialize}
+   */
+  origin: Canvas.ElevatedPoint;
+
+  /**
+   * The configuration of this polygon.
+   * @remarks Initialized as `{}` but immediately filled by  {@linkcode PointSourcePolygon.initialize | #initialize}
+   */
+  config: PointSourcePolygon.StoredConfig;
+
+  /**
+   * An indicator for whether this polygon is constrained by some boundary shape?
+   */
+  get isConstrained(): boolean;
+
+  /**
+   * Benchmark the performance of polygon computation for this source
+   * @param iterations - The number of test iterations to perform
+   * @param origin     - The origin point to benchmark
+   * @param config     - The polygon configuration to benchmark
+   */
+  static benchmark(
+    iterations: number,
+    origin: Canvas.PossiblyElevatedPoint,
+    config: PointSourcePolygon.Config,
+  ): Promise<void>;
+
+  /**
+   * Compute the polygon given a point origin and radius
+   * @param origin - The origin source point. The elevation defaults to the elevation of `config.source` if passed and otherwise `0`.
+   * @param config - Configuration options which customize the polygon computation
+   * @returns The computed polygon instance
+   * @remarks Subclasses must implement a `.create` override to accurately type the return.
+   *
+   * Despite being a `={}` parameter, a `config` object with a valid `type` property must be passed
+   */
+  static create(origin: Canvas.PossiblyElevatedPoint, config: PointSourcePolygon.Config): unknown;
+
+  /**
+   * Create a clone of this polygon.
+   * This overrides the default PIXI.Polygon#clone behavior.
+   * @returns A cloned instance
+   */
+  override clone(): this;
+
+  /**
+   * Compute the polygon using the origin and configuration options.
+   * @returns The computed polygon
+   */
+  compute(): this;
+
+  /**
+   * Perform the implementation-specific computation
+   */
+  protected abstract _compute(): void;
+
+  /**
+   * Customize the provided configuration object for this polygon type.
+   * @param origin - The provided polygon origin. The elevation defaults to the elevation of `config.source` if passed and otherwise `0`.
+   * @param config - The provided configuration object
+   */
+  initialize(origin: Canvas.PossiblyElevatedPoint, config: PointSourcePolygon.Config): void;
+
+  /**
+   * Apply a constraining boundary shape to an existing PointSourcePolygon.
+   * Return a new instance of the polygon with the constraint applied.
+   * The new instance is only a "shallow clone", as it shares references to component properties with the original.
+   * @param constraint          - The constraining boundary shape
+   * @param intersectionOptions - Options passed to the shape intersection method
+   * @returns A new constrained polygon
+   */
+  applyConstraint(constraint: PIXI.Polygon, intersectionOptions?: PIXI.Polygon.IntersectPolygonOptions): this;
+  applyConstraint(constraint: PIXI.Circle, intersectionOptions?: PIXI.Circle.WACIntersectPolygonOptions): this;
+  applyConstraint(constraint: PIXI.Circle, intersectionOptions?: PIXI.Circle.ClipperLibIntersectPolygonOptions): this;
+  applyConstraint(constraint: PIXI.Rectangle, intersectionOptions?: PIXI.Rectangle.WACIntersectPolygonOptions): this;
+  applyConstraint(
+    constraint: PIXI.Rectangle,
+    intersectionOptions?: PIXI.Rectangle.ClipperLibIntersectPolygonOptions,
+  ): this;
+
+  override contains(x: number, y: number): boolean;
+
+  /**
+   * Constrain polygon points by applying boundary shapes.
+   */
+  protected _constrainBoundaryShapes(): void;
+
+  /**
+   * Test whether a Ray between the origin and destination points would collide with a boundary of this Polygon.
+   * A valid wall restriction type is compulsory and must be passed into the config options.
+   * @param origin      - An origin point. The elevation defaults to the elevation of `config.source` if passed and otherwise `0`.
+   * @param destination - A destination point. The elevation defaults to the elevation of the origin.
+   * @param config      - The configuration that defines a certain Polygon type
+   * @param mode        - The collision mode to test: "any", "all", or "closest" (default: "all")
+   * @returns The collision result depends on the mode of the test:
+   * - `any`: returns a boolean for whether any collision occurred
+   * - `all`: returns a sorted array of PolygonVertex instances
+   * - `closest`: returns a PolygonVertex instance or null
+   * @remarks Despite being an `={}` parameter, `options` is required as it must be a valid
+   * `PointSourcePolygon.Config`, which has a required property (`type`)
+   */
+  static testCollision<Mode extends PointSourcePolygon.CollisionModes | undefined = undefined>(
+    origin: Canvas.PossiblyElevatedPoint,
+    destination: Canvas.PossiblyElevatedPoint,
+    { mode, ...config }: PointSourcePolygon.TestCollisionOptions<Mode>,
+  ): PointSourcePolygon.TestCollision<Mode>;
+
+  /**
+   * Determine the set of collisions which occurs for a Ray.
+   * @param ray         - The Ray to test
+   * @param mode        - The collision mode being tested
+   * @param destination - The destination
+   * @returns The collision test result
+   */
+  protected abstract _testCollision<Mode extends PointSourcePolygon.CollisionModes>(
+    ray: Ray,
+    mode: Mode,
+    destination: Canvas.ElevatedPoint,
+  ): PointSourcePolygon.TestCollision<Mode>;
+
+  /**
+   * Visualize the polygon, displaying its computed area, rays, and collision points
+   * @returns The rendered debugging shape
+   */
+  visualize(): PIXI.Graphics | undefined;
+
+  /**
+   * Determine if the shape is a complete circle.
+   * The config object must have an angle and a radius properties.
+   */
+  isCompleteCircle(): boolean;
+
+  /**
+   * Augment a PointSourcePolygon by adding additional coverage for shapes permitted by threshold walls.
+   * @param polygon - The computed polygon
+   * @returns The augmented polygon
+   * @remarks Mutates and returns the same reference it's passed, not a new polygon
+   */
+  static applyThresholdAttenuation<PolyType extends PointSourcePolygon>(polygon: PolyType): PolyType;
+}
+
+declare namespace PointSourcePolygon {
+  interface Any extends AnyPointSourcePolygon {}
+  interface AnyConstructor extends Identity<typeof AnyPointSourcePolygon> {}
+
+  type WALL_DIRECTION_MODES = Brand<number, "PointSourcePolygon.WALL_DIRECTION_MODES">;
+
+  /** @remarks {@linkcode PointSourcePolygon.WALL_DIRECTION_MODES} is frozen*/
+  interface WallDirectionModes {
+    readonly NORMAL: 0 & WALL_DIRECTION_MODES;
+    readonly REVERSED: 1 & WALL_DIRECTION_MODES;
+    readonly BOTH: 2 & WALL_DIRECTION_MODES;
+  }
+
+  /**
+   * Properties of the config that get set with no respect to their passed value
+   * @internal
+   */
+  interface _ComputedConfig {
+    /**
+     * Does this polygon have a limited radius?
+     * @defaultValue `(cfg.radius > 0) && (cfg.radius < canvas.dimensions.maxR)`
+     * @remarks Set by {@linkcode PointSourcePolygon.initialize | PointSourcePolygon#initialize}
+     */
+    hasLimitedRadius: boolean;
+
+    /**
+     * Does this polygon have a limited angle?
+     * @defaultValue `cfg.angle !== 360`
+     * @remarks Set by {@linkcode PointSourcePolygon.initialize | PointSourcePolygon#initialize}
+     */
+    hasLimitedAngle: boolean;
+  }
+
+  /**
+   * Properties of the config that might be omitted but can't be explicitly `undefined`
+   * @internal
+   */
+  interface _OptionalOnlyConfig {
+    /**
+     * The external radius of the source
+     * @remarks Can't be `undefined` or its use in math would produce `NaN`s.
+     *
+     * Not guaranteed by {@linkcode PointSourcePolygon.initialize | PointSourcePolygon#initialize} but will exist in all configs created by {@linkcode PointEffectSourceMixin} subclasses.
+     */
+    externalRadius?: number;
+  }
+
+  /**
+   * Properties not guaranteed to exist by {@linkcode PointSourcePolygon.initialize | PointSourcePolygon#initialize}, without restrictions on nullishness
+   */
+  type _InexactConfig = InexactPartial<{
+    /**
+     * The object (if any) that spawned this polygon.
+     * @remarks Not guaranteed by {@linkcode PointSourcePolygon.initialize | PointSourcePolygon#initialize} but will exist in all configs created by {@linkcode PointEffectSourceMixin} subclasses.
+     * @privateRemarks Foundry types this as `PointEffectSource` which is the mixin class name, which isn't exported. The type here matches usage and tracks with what they probably meant.
+     */
+    source: PointEffectSourceMixin.AnyMixed;
+
+    /**
+     * Display debugging visualization and logging for the polygon
+     * @remarks Overridden `true` if `CONFIG.debug.polygons` is truthy
+     */
+    debug: boolean;
+  }>;
+
+  /**
+   * Properties of the config that have defaults for nullish values in {@linkcode PointSourcePolygon.initialize | PointSourcePolygon#initialize}, and thus are guaranteed in the stored config
+   * @internal
+   */
+  interface _BaseConfig {
+    /**
+     * A limited radius of the resulting polygon
+     * @defaultValue {@linkcode Canvas.Dimensions.maxR | canvas.dimensions.maxR}
+     * @remarks Will be replaced with `maxR` if passed value is larger
+     */
+    radius: number;
+
+    /**
+     * The desired density of padding rays, a number per PI
+     * @defaultValue {@linkcode PIXI.Circle.approximateVertexDensity | PIXI.Circle.approximateVertexDensity(cfg.radius)}
+     */
+    density: number;
+
+    /**
+     * The angle of emission, if limited
+     * @defaultValue `360`
+     */
+    angle: number;
+
+    /**
+     * The direction of facing, required if the angle is limited
+     * @defaultValue `0`
+     */
+    rotation: number;
+
+    /**
+     * Customize how wall direction of one-way walls is applied
+     * @defaultValue {@linkcode PointSourcePolygon.WALL_DIRECTION_MODES.NORMAL}
+     */
+    wallDirectionMode: PointSourcePolygon.WALL_DIRECTION_MODES;
+
+    /**
+     * Compute the polygon with threshold wall constraints applied
+     * @defaultValue `false`
+     */
+    useThreshold: boolean;
+
+    /**
+     * Limiting polygon boundary shapes
+     * @defaultValue `[]`
+     */
+    boundaryShapes: Array<BoundaryShapes>;
+  }
+
+  /**
+   * The only property required in all configs
+   * @internal
+   */
+  interface _RequiredConfig {
+    /** The type of polygon being computed */
+    type: PolygonType;
+  }
+
+  /**
+   * @remarks The interface stored in {@link PointSourcePolygon.config | PointSourcePolygon#config}, with defaults applied
+   */
+  interface StoredConfig extends _RequiredConfig, _BaseConfig, _OptionalOnlyConfig, _InexactConfig, _ComputedConfig {}
+
+  /**
+   * @remarks The interface passed to {@linkcode PointSourcePolygon.create}, etc. All properties are optional other than `type`
+   */
+  interface Config extends _RequiredConfig, InexactPartial<_BaseConfig>, _OptionalOnlyConfig, _InexactConfig {}
+
+  type BoundaryShapes = PIXI.Rectangle | PIXI.Circle | PIXI.Polygon;
+
+  /**
+   * @remarks Foundry comments 'TODO: "universal" will be deprecated in v14'
+   *
+   * @privateRemarks This is provided as a union of literals, but after the removal of universal, it will also match the provided
+   * keys of {@linkcode CONFIG.Canvas.polygonBackends}, or {@linkcode CONST.WALL_RESTRICTION_TYPES} plus `"darkness"`
+   */
+  type PolygonType = "light" | "darkness" | "sight" | "sound" | "move" | "universal";
+
+  type CollisionModes = "any" | "all" | "closest";
+
+  interface _TestCollisionConfig {
+    /**
+     * The type of polygon being computed
+     * @remarks {@linkcode PointSourcePolygon.testCollision} supports only those polygon types that are
+     * also a type of collision, and so far (v13) there's no such thing as a darkness-blocking wall.
+     */
+    type: CONST.WALL_RESTRICTION_TYPES;
+  }
+
+  interface TestCollisionConfig extends _TestCollisionConfig, Omit<Config, "type"> {}
+
+  /** @internal */
+  type _TestCollisionOptions<Mode extends CollisionModes | undefined> = InexactPartial<{
+    /**
+     * The collision mode to test: "any", "all", or "closest"
+     * @defaultValue `"all"`
+     */
+    mode: Mode;
+  }>;
+
+  interface TestCollisionOptions<Mode extends CollisionModes | undefined = undefined>
+    extends _TestCollisionOptions<Mode>,
+      TestCollisionConfig {}
+
+  /** @internal */
+  interface _CollisionTypesReturnMap {
+    any: boolean;
+    closest: PolygonVertex | null;
+    all: PolygonVertex[];
+  }
+
+  type TestCollision<
+    Mode extends CollisionModes | undefined = undefined,
+    Default extends keyof _CollisionTypesReturnMap = "all",
+  > = _CollisionTypesReturnMap[Coalesce<Mode, Default>];
+}
+
+export default PointSourcePolygon;
+
+declare abstract class AnyPointSourcePolygon extends PointSourcePolygon {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/geometry/unbound-transform.d.mts

@@ -0,0 +1,22 @@
+import type { Identity } from "#utils";
+
+/**
+ * A custom Transform class which is not bound to the parent worldTransform.
+ * localTransform are working as usual.
+ */
+declare class UnboundTransform extends PIXI.Transform {
+  static override IDENTITY: UnboundTransform;
+
+  override updateTransform(parentTransform: PIXI.Transform): void;
+}
+
+declare namespace UnboundTransform {
+  interface Any extends AnyUnboundTransform {}
+  interface AnyConstructor extends Identity<typeof AnyUnboundTransform> {}
+}
+
+export default UnboundTransform;
+
+declare abstract class AnyUnboundTransform extends UnboundTransform {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/geometry/weiler-atherton-clipping.d.mts

@@ -0,0 +1,203 @@
+import type { Brand, Identity, InexactPartial } from "#utils";
+
+/**
+ * An implementation of the Weiler Atherton algorithm for clipping polygons.
+ * This currently only handles combinations that will not result in any holes.
+ * Support may be added for holes in the future.
+ *
+ * This algorithm is faster than the Clipper library for this task because it relies on the unique properties of the
+ * circle, ellipse, or convex simple clip object.
+ * It is also more precise in that it uses the actual intersection points between the circle/ellipse and polygon,
+ * instead of relying on the polygon approximation of the circle/ellipse to find the intersection points.
+ *
+ * For more explanation of the underlying algorithm, see:
+ * {@link https://en.wikipedia.org/wiki/Weiler%E2%80%93Atherton_clipping_algorithm}
+ * {@link https://www.geeksforgeeks.org/weiler-atherton-polygon-clipping-algorithm}
+ * {@link https://h-educate.in/weiler-atherton-polygon-clipping-algorithm/}
+ *
+ * @throws If `!polygon.isPositive`
+ * @remarks In Foundry usage the only thing that calls `new WeilerAthertonClipper` is the class's static methods
+ */
+declare class WeilerAthertonClipper {
+  /**
+   * Construct a WeilerAthertonClipper instance used to perform the calculation.
+   * @param polygon    - Polygon to clip
+   * @param clipObject - Object used to clip the polygon
+   * @param clipType   - Type of clip to use (default: `0`)
+   * @param clipOpts   - Object passed to the {@linkcode WeilerAthertonClipper.ClipObject | clipObject} methods
+   * {@linkcode WeilerAthertonClipper.ClipObject.toPolygon | toPolygon} and
+   * {@linkcode WeilerAthertonClipper.ClipObject.pointsBetween | pointsBetween} (default: `{}`)
+   */
+  constructor(
+    polygon: PIXI.Polygon,
+    clipObject: WeilerAthertonClipper.ClipObject,
+    clipType?: WeilerAthertonClipper.CLIP_TYPES,
+    clipOpts?: WeilerAthertonClipper.ClipOpts,
+  );
+
+  /**
+   * The supported clip types.
+   * Values are equivalent to those in {@linkcode ClipperLib.ClipType}.
+   */
+  static CLIP_TYPES: WeilerAthertonClipper.ClipTypes;
+
+  /**
+   * The supported intersection types.
+   */
+  static INTERSECTION_TYPES: WeilerAthertonClipper.IntersectionTypes;
+
+  polygon: PIXI.Polygon;
+
+  clipObject: WeilerAthertonClipper.ClipObject;
+
+  /**
+   * Configuration settings
+   */
+  config: WeilerAthertonClipper.Config;
+
+  /**
+   * Union a polygon and clipObject using the Weiler Atherton algorithm.
+   * @param polygon    - Polygon to clip
+   * @param clipObject - Object to clip against the polygon
+   * @param clipOpts   - Object passed to the {@linkcode WeilerAthertonClipper.ClipObject | clipObject} methods
+   * {@linkcode WeilerAthertonClipper.ClipObject.toPolygon | toPolygon} and
+   * {@linkcode WeilerAthertonClipper.ClipObject.pointsBetween | pointsBetween} (default: `{}`)
+   */
+  static union(
+    polygon: PIXI.Polygon,
+    clipObject: WeilerAthertonClipper.ClipObject,
+    clipOpts?: WeilerAthertonClipper.ClipOpts,
+  ): PIXI.Polygon[];
+
+  /**
+   * Intersect a polygon and clipObject using the Weiler Atherton algorithm.
+   * @param polygon    - Polygon to clip
+   * @param clipObject - Object to clip against the polygon
+   * @param clipOpts   - Object passed to the {@linkcode WeilerAthertonClipper.ClipObject | clipObject} methods
+   * {@linkcode WeilerAthertonClipper.ClipObject.toPolygon | toPolygon} and
+   * {@linkcode WeilerAthertonClipper.ClipObject.pointsBetween | pointsBetween} (default: `{}`)
+   */
+  static intersect(
+    polygon: PIXI.Polygon,
+    clipObject: WeilerAthertonClipper.ClipObject,
+    clipOpts?: WeilerAthertonClipper.ClipOpts,
+  ): PIXI.Polygon[];
+
+  /**
+   * Clip a given clipObject using the Weiler-Atherton algorithm.
+   *
+   * At the moment, this will return a single PIXI.Polygon in the array unless clipType is a union and the polygon
+   * and clipObject do not overlap, in which case the [polygon, clipObject.toPolygon()] array will be returned.
+   * If this algorithm is expanded in the future to handle holes, an array of polygons may be returned.
+   *
+   * @param polygon    - Polygon to clip
+   * @param clipObject - Object to clip against the polygon
+   * @param options    - Options which configure how the union or intersection is computed. Any additional properties
+   * in `options` (besides `clipType` and `canMutate`) are captured by the rest operator (`...clipOpts`) and passed
+   * to the {@linkcode WeilerAthertonClipper} constructor.
+   * @returns Array of polygons and clipObjects
+   */
+  static combine(
+    polygon: PIXI.Polygon,
+    clipObject: WeilerAthertonClipper.ClipObject,
+    options: WeilerAthertonClipper.CombineOptions,
+  ): PIXI.Polygon[];
+
+  /**
+   * Test if one shape envelops the other. Assumes the shapes do not intersect.
+   *  1. Polygon is contained within the clip object. Union: clip object; Intersect: polygon
+   *  2. Clip object is contained with polygon. Union: polygon; Intersect: clip object
+   *  3. Polygon and clip object are outside one another. Union: both; Intersect: null
+   * @param polygon    - Polygon to clip
+   * @param clipObject - Object to clip against the polygon
+   * @param clipType   - One of {@linkcode WeilerAthertonClipper.ClipTypes | CLIP_TYPES}
+   * @param clipOpts   - Clip options which are forwarded to toPolygon methods
+   * @returns Returns the polygon, the clipObject.toPolygon(), both, or neither.
+   */
+  static testForEnvelopment(
+    polygon: PIXI.Polygon,
+    clipObject: WeilerAthertonClipper.ClipObject,
+    clipType: WeilerAthertonClipper.CLIP_TYPES,
+    clipOpts?: WeilerAthertonClipper.ClipOpts,
+  ): PIXI.Polygon[];
+
+  #WeilerAthertonClipper: true;
+}
+
+declare namespace WeilerAthertonClipper {
+  interface Any extends AnyWeilerAthertonClipper {}
+  interface AnyConstructor extends Identity<typeof AnyWeilerAthertonClipper> {}
+
+  type ClipObject = PIXI.Rectangle | PIXI.Circle;
+
+  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 {@linkcode WeilerAthertonClipper.ClipTypes | CLIP_TYPES}
+     * @defaultValue {@linkcode WeilerAthertonClipper.CLIP_TYPES.INTERSECT}
+     * @remarks Set to the value of the equivalent constructor parameter if provided, or the above default
+     */
+    clipType: WeilerAthertonClipper.CLIP_TYPES;
+
+    /**
+     * Object passed to the Object passed to the {@linkcode WeilerAthertonClipper.ClipObject | clipObject} methods
+     * {@linkcode WeilerAthertonClipper.ClipObject.toPolygon | toPolygon} and
+     * {@linkcode WeilerAthertonClipper.ClipObject.pointsBetween | pointsBetween}
+     * @defaultValue `{}`
+     * @remarks Set to the value of the equivalent constructor parameter if provided, or the above default
+     */
+    clipOpts: WeilerAthertonClipper.ClipOpts;
+  }
+
+  /** @internal */
+  type _CombineOptions = InexactPartial<{
+    /**
+     * If the WeilerAtherton constructor could mutate or not the subject polygon points
+     */
+    canMutate: boolean;
+  }>;
+
+  /**
+   * @remarks See {@linkcode WeilerAthertonClipper.combine}'s `options` parameter description
+   * @privateRemarks This interface does *not* contain:
+   * - a `scalingFactor` property, despite one being passed in {@linkcode PIXI.Rectangle.intersectPolygon | PIXI.Rectangle#intersectPolygon} as of 13.1346
+   * - a `density` property, despite one being passed in {@linkcode PIXI.Circle.intersectPolygon | PIXI.Circle#intersectPolygon} as of 13.346
+   * as those are not used by {@linkcode WeilerAthertonClipper.combine}
+   */
+  interface CombineOptions extends _CombineOptions, ClipOpts {
+    /**
+     * One of {@linkcode WeilerAthertonClipper.ClipTypes | CLIP_TYPES}
+     * @privateRemarks This *could* have been optional, as it gets passed to `new WAC()`, where it has a default, but Foundry has a pair of `!==` checks in
+     * {@linkcode WeilerAthertonClipper.combine} before that happens which make it required
+     */
+    clipType: WeilerAthertonClipper.CLIP_TYPES;
+  }
+
+  /**
+   * @remarks These are ultimately passed to {@linkcode PIXI.Rectangle.toPolygon | PIXI.Rectangle#toPolygon}, {@linkcode PIXI.Circle.toPolygon | PIXI.Circle#toPolygon},
+   * {@linkcode PIXI.Rectangle.pointsBetween | PIXI.Rectangle#pointsBetween}, or {@linkcode PIXI.Circle.pointsBetween | PIXI.Circle#pointsBetween}. Only the `Circle`
+   * methods actually take options and those are only passed on to {@linkcode PIXI.Circle.pointsForArc | PIXI.Circle#pointsForArc}.
+   */
+  type ClipOpts = PIXI.Circle.PointsForArcOptions;
+}
+
+export default WeilerAthertonClipper;
+
+declare abstract class AnyWeilerAthertonClipper extends WeilerAthertonClipper {
+  constructor(...args: never);
+}

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

@@ -0,0 +1,14 @@
+// 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 { default as CanvasGroupMixin } from "./canvas-group-mixin.mjs";
+export { default as EffectsCanvasGroup } from "./effects.mjs";
+export { default as EnvironmentCanvasGroup } from "./environment.mjs";
+export { default as HiddenCanvasGroup } from "./hidden.mjs";
+export { default as InterfaceCanvasGroup } from "./interface.mjs";
+export { default as OverlayCanvasGroup } from "./overlay.mjs";
+export { default as PrimaryCanvasGroup } from "./primary.mjs";
+export { default as RenderedCanvasGroup } from "./rendered.mjs";
+export { default as CanvasVisibility } from "./visibility.mjs";