@league-of-foundry-developers/foundry-vtt-types 12.331.3-beta → 12.331.4-beta

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

@@ -1,21 +1,17 @@
-import type { ArrayOverlaps } from "../../../../../types/helperTypes.d.mts";
-import type { NullishProps } from "../../../../../types/utils.d.mts";
+import type { HandleEmptyObject, Identity, 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`
-     * @remarks Foundry marked \@private but accesses it from Canvas
+     * @remarks Foundry marked `@private` but sets it `null` in  {@link Canvas#_onDragRightMove}
      */
-    _tabIndex: number | null;
+    protected _tabIndex: number | null;
 
     /**
      * @privateRemarks This is not overridden in foundry but reflects the real behavior.
@@ -43,64 +39,72 @@ declare global {
     static override documentName: "Token";
 
     /**
-     * The set of tokens that trigger occlusion (a union of {@link CONST.TOKEN_OCCLUSION_MODES}).
+     * The set of tokens that trigger occlusion (a union of {@link CONST.TOKEN_OCCLUSION_MODES | `CONST.TOKEN_OCCLUSION_MODES`}).
      */
-    set occlusionMode(value: number);
+    set occlusionMode(value: foundry.CONST.OCCLUSION_MODES);
 
-    get occlusionMode(): number;
+    get occlusionMode();
 
-    override get hookName(): string;
+    override get hookName(): "TokenLayer";
 
     /**
      * Token objects on this layer utilize the TokenHUD
      */
-    get hud(): TokenHUD;
+    get hud(): NonNullable<Canvas["hud"]>["token"];
 
     /**
      * An Array of tokens which belong to actors which are owned
      */
-    get ownedTokens(): ReturnType<this["placeables"]["filter"]>;
+    get ownedTokens(): Token.Object[];
 
+    /** @remarks Forces top left corner snapping */
     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;
 
     protected override _deactivate(): void;
 
-    override _pasteObject(
-      copy: Token.ConfiguredInstance,
+    protected override _pasteObject(
+      copy: Token.Object,
       offset: Canvas.Point,
-      options?: NullishProps<{ hidden: boolean; snap: boolean }>,
-    ): Document.ConfiguredSourceForName<"Token">;
+      options?: PlaceablesLayer.PasteOptions, // not:null (destructured)
+    ): Omit<TokenDocument.Source, "_id">;
 
-    protected override _getMovableObjects<const T>(
-      ids?: ArrayOverlaps<T, string>,
-      includeLocked?: boolean,
-    ): Token.ConfiguredInstance[];
+    /** @remarks Returns `[]` if the ruler is currently measuring */
+    protected override _getMovableObjects(ids?: string[] | null, includeLocked?: boolean | null): Token.Object[];
 
     /**
      * Target all Token instances which fall within a coordinate rectangle.
      * @param rectangle - The selection rectangle.
-     * @param options - Additional options to configure targeting behaviour.
+     * @param options   - Additional options to configure targeting behaviour.
+     * @returns The number of Token instances which were targeted.
      */
-    targetObjects(rectangle: Canvas.Rectangle, options?: NullishProps<PlaceableObject.ControlOptions>): number;
+    targetObjects(
+      rectangle: Canvas.Rectangle,
+      options?: TokenLayer.TargetObjectsOptions, // not:null (destructured)
+    ): number;
 
     /**
      * Cycle the controlled token by rotating through the list of Owned Tokens that are available within the Scene
      * Tokens are currently sorted in order of their TokenID
      * @param forwards - Which direction to cycle. A truthy value cycles forward, while a false value cycles backwards.
      * @param reset    - Restart the cycle order back at the beginning?
+     * @returns The Token object which was cycled to, or null
+     * @remarks Neither parameter has a default, so a call with no arguments cycles backward without resetting
+     *
+     * Also selects the returned token if any, and pans the camera to its center
      */
-    cycleTokens(forwards: boolean, reset: boolean): Token.ConfiguredInstance | null;
+    cycleTokens(forwards?: boolean | null, reset?: boolean | null): Token.Object | null;
 
     /**
      * Get the tab cycle order for tokens by sorting observable tokens based on their distance from top-left.
+     * @remarks Foundry marked `@private`
      */
-    protected _getCycleOrder(): Token.ConfiguredInstance[];
+    protected _getCycleOrder(): Token.Object[];
 
     /**
      * Immediately conclude the animation of any/all tokens
@@ -116,29 +120,30 @@ declare global {
      * Provide an array of Tokens which are eligible subjects for overhead tile occlusion.
      * By default, only tokens which are currently controlled or owned by a player are included as subjects.
      */
-    protected _getOccludableTokens(): Token.ConfiguredInstance[];
+    protected _getOccludableTokens(): Token.Object[];
 
-    override storeHistory(
-      type: PlaceablesLayer.HistoryEventType,
-      data: Document.ConfiguredSourceForName<"Token">[],
+    /** @remarks "Clean actorData and delta updates from the history so changes to those fields are not undone" */
+    override storeHistory<Operation extends Document.Database.Operation>(
+      type: Operation,
+      data: PlaceablesLayer.HistoryDataFor<Operation, "Token">,
     ): void;
 
     /**
      * Handle dropping of Actor data onto the Scene canvas
+     * @remarks Foundry marked `@private`
      */
     protected _onDropActorData(
       event: DragEvent,
       data: TokenLayer.DropData,
-    ): Promise<ReturnType<Notifications["warn"]> | false | TokenDocument.ConfiguredInstance>;
+    ): Promise<number | false | TokenDocument.Implementation>;
 
-    //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;
 
-    protected override _onMouseWheel(event: WheelEvent): ReturnType<this["rotateMany"]>;
+    protected override _onMouseWheel(event: WheelEvent): Promise<Token.Object[] | void>;
 
     /**
      * @deprecated since v12 until v14
-     * @remarks "TokenLayer#toggleCombat is deprecated in favor of TokenDocument.implementation.createCombatants and TokenDocument.implementation.deleteCombatants"
+     * @remarks "TokenLayer#gridPrecision is deprecated. Use TokenLayer#getSnappedPoint instead of GridLayer#getSnappedPosition and TokenLayer#gridPrecision."
      */
     override get gridPrecision(): 1;
 
@@ -153,28 +158,21 @@ declare global {
      * @remarks "TokenLayer#toggleCombat is deprecated in favor of TokenDocument.implementation.createCombatants and TokenDocument.implementation.deleteCombatants"
      */
     toggleCombat(
-      state?: boolean,
-      combat?: Combat.ConfiguredInstance | null,
-      {
-        token,
-      }?: {
-        /**
-         * A specific Token which is the origin of the group toggle request
-         * @defaultValue `null`
-         */
-        token?: Token.ConfiguredInstance | null;
-      },
-    ): Promise<Combatant.ConfiguredInstance[]>;
+      state?: boolean | null,
+      combat?: Combat.Implementation | null,
+      options?: TokenLayer.ToggleCombatOptions, // not:null (destructured)
+    ): Promise<Combatant.Implementation[]>;
   }
 
   namespace TokenLayer {
-    type AnyConstructor = typeof AnyTokenLayer;
+    interface Any extends AnyTokenLayer {}
+    interface AnyConstructor extends Identity<typeof AnyTokenLayer> {}
 
     interface DrawOptions extends PlaceablesLayer.DrawOptions {}
 
     interface TearDownOptions extends PlaceablesLayer.TearDownOptions {}
 
-    interface LayerOptions extends PlaceablesLayer.LayerOptions<"Token"> {
+    interface LayerOptions extends PlaceablesLayer.LayerOptions<Token.ObjectClass> {
       name: "tokens";
       controllableObjects: true;
       rotatableObjects: true;
@@ -185,9 +183,25 @@ declare global {
       type: "Actor";
       uuid: string;
     }
+
+    /** @internal */
+    // TODO: the NP should probably be on the PO side, update once PO has been done
+    type _TargetObjectsOptions = NullishProps<PlaceableObject.ControlOptions>;
+
+    interface TargetObjectsOptions extends _TargetObjectsOptions {}
+
+    /** @internal */
+    type _ToggleCombatOptions = NullishProps<{
+      /**
+       * A specific Token which is the origin of the group toggle request
+       * @defaultValue `null`
+       */
+      token: Token.Object;
+    }>;
+    interface ToggleCombatOptions extends _ToggleCombatOptions {}
   }
 }
 
 declare abstract class AnyTokenLayer extends TokenLayer {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

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

@@ -1,17 +1,14 @@
-import type { ConstructorOf, NullishProps } from "../../../../../types/utils.d.mts";
-import type Document from "../../../../common/abstract/document.d.mts";
+import type { Coalesce, HandleEmptyObject, Identity, NullishProps } from "fvtt-types/utils";
 
 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`
+     * @remarks Only `null` prior to first draw
      */
     chain: PIXI.Graphics | null;
 
@@ -24,21 +21,17 @@ declare global {
     /**
      * Track the most recently created or updated wall data for use with the clone tool
      * @defaultValue `null`
-     * @remarks This is intentional `public` because it is accessed from Wall
+     * @remarks Foundry marked `@private`, is set via {@link Wall#_onCreate} and {@link Wall#_onUpdate}
      */
-    _cloneType: ReturnType<foundry.documents.BaseWall["toJSON"]> | null;
+    protected _cloneType: WallDocument.Source | null;
 
     /**
      * Reference the last interacted wall endpoint for the purposes of chaining
-     * @defaultValue
-     * ```
-     * {
-     *   point: null,
-     * }
-     * ```
+     * @defaultValue `{ point: null }`
+     * @remarks Foundry marked `@private`, is set via {@link Wall#_onHoverIn}, {@link Wall#_onHoverOut}, and {@link Wall#_prepareDragLeftDropUpdates}
      */
     protected last: {
-      point: Canvas.PointArray | null;
+      point: Canvas.PointTuple | null;
     };
 
     /**
@@ -58,25 +51,23 @@ declare global {
      */
     static override get layerOptions(): WallsLayer.LayerOptions;
 
-    /**
-     * @privateRemarks This is not overridden in foundry but reflects the real behavior.
-     */
+    /** @privateRemarks This is not overridden in foundry but reflects the real behavior. */
     override options: WallsLayer.LayerOptions;
 
     static override documentName: "Wall";
 
-    override get hookName(): string;
+    override get hookName(): "WallsLayer";
 
     /**
      * An Array of Wall instances in the current Scene which act as Doors.
      */
-    get doors(): Wall.ConfiguredInstance[];
+    get doors(): Wall.Object[];
 
     override getSnappedPoint(point: Canvas.Point): Canvas.Point;
 
-    override _draw(options?: DrawOptions): Promise<void>;
+    protected override _draw(options: HandleEmptyObject<WallsLayer.DrawOptions>): Promise<void>;
 
-    override _deactivate(): void;
+    protected override _deactivate(): void;
 
     /**
      * Given a point and the coordinates of a wall, determine which endpoint is closer to the point
@@ -84,64 +75,55 @@ 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.Object): Canvas.PointTuple;
 
     override releaseAll(options?: PlaceableObject.ReleaseOptions): number;
 
-    override _pasteObject(
-      copy: Wall.ConfiguredInstance,
+    /** @remarks `options` is unused */
+    protected override _pasteObject(
+      copy: Wall.Object,
       offset: Canvas.Point,
-      options?: NullishProps<{ hidden: boolean; snap: boolean }>,
-    ): Document.ConfiguredSourceForName<"Wall">;
+      options?: PlaceablesLayer.PasteOptions | null,
+    ): Omit<WallDocument.Source, "_id">;
 
     /**
      * Pan the canvas view when the cursor position gets close to the edge of the frame
      * @param event - The originating mouse movement event
      * @param x     - The x-coordinate
      * @param y     - The y-coordinate
+     * @remarks Foundry marked `@private`
      */
-    protected _panCanvasEdge(event: MouseEvent, x: number, y: number): void | ReturnType<Canvas["animatePan"]>;
+    protected _panCanvasEdge(event: MouseEvent, x: number, y: number): Promise<boolean> | void;
 
     /**
      * Get the wall endpoint coordinates for a given point.
      * @param  point - The candidate wall endpoint.
      * @returns The wall endpoint coordinates.
+     * @remarks Foundry marked `@internal`, is called externally in {@link Wall#_onDragLeftMove} and {@link Wall#_prepareDragLeftDropUpdates}
      */
     protected _getWallEndpointCoordinates(
       point: Canvas.Point,
-      options?: NullishProps<{
-        /**
-         * Snap to the grid?
-         * @defaultValue `true`
-         */
-        snap: boolean;
-      }>,
-    ): Canvas.PointArray;
+      options?: WallsLayer.GetWallEndpointCoordinatesOptions, // not:null (destructured)
+    ): Canvas.PointTuple;
 
     /**
      * The Scene Controls tools provide several different types of prototypical Walls to choose from
      * This method helps to translate each tool into a default wall data configuration for that type
      * @param tool - The active canvas tool
+     * @remarks If a tool is not provided, returns an object with `light`, `sight`, `sound`, and `move` keys, all with the value `CONST.WALL_SENSE_TYPES.NORMAL`
      */
-    protected _getWallDataFromActiveTool(tool: string):
-      | {
-          light: foundry.CONST.WALL_SENSE_TYPES;
-          sight: foundry.CONST.WALL_SENSE_TYPES;
-          sound: foundry.CONST.WALL_SENSE_TYPES;
-          move: foundry.CONST.WALL_SENSE_TYPES;
-          door?: foundry.CONST.WALL_DOOR_TYPES;
-        }
-      | this["_cloneType"];
+    protected _getWallDataFromActiveTool(tool?: WallsLayer.WallTools | null): WallDocument.Source;
 
     /**
      * Identify the interior enclosed by the given walls.
      * @param  walls - The walls that enclose the interior.
      * @returns The polygons of the interior.
-     * @remarks Marked \@license MIT
+     * @remarks Foundry marked `@license MIT`
      */
-    identifyInteriorArea(walls: Wall.ConfiguredInstance[]): PIXI.Polygon[];
+    identifyInteriorArea(walls: Wall.Object[]): 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.Object>;
 
     protected override _onDragLeftMove(event: PIXI.FederatedEvent): void;
 
@@ -155,7 +137,10 @@ declare global {
      * @deprecated since v11, will be removed in v13
      * @remarks "WallsLayer#checkCollision is obsolete. Prefer calls to testCollision from CONFIG.Canvas.polygonBackends[type]"
      */
-    checkCollision(ray: Ray, options: Parameters<(typeof PointSourcePolygon)["testCollision"]>[2]): boolean;
+    checkCollision<Mode extends PointSourcePolygon.CollisionModes | undefined = undefined>(
+      ray: Ray,
+      options: PointSourcePolygon.TestCollisionConfig<Mode>,
+    ): PointSourcePolygon.TestCollision<Coalesce<Mode, "all">>;
 
     /**
      * @deprecated since v11, will be removed in v13
@@ -188,22 +173,34 @@ declare global {
   }
 
   namespace WallsLayer {
-    type AnyConstructor = typeof AnyWallsLayer;
+    interface Any extends AnyWallsLayer {}
+    interface AnyConstructor extends Identity<typeof AnyWallsLayer> {}
 
     interface DrawOptions extends PlaceablesLayer.DrawOptions {}
 
-    interface LayerOptions extends PlaceablesLayer.LayerOptions<"Wall"> {
+    interface LayerOptions extends PlaceablesLayer.LayerOptions<Wall.ObjectClass> {
       name: "walls";
       controllableObjects: true;
-      objectClass: typeof Wall;
-      quadtree: true;
-      sheetClass: ConstructorOf<FormApplication>;
-      sortActiveTop: boolean;
-      zIndex: number;
+      objectClass: Wall.ObjectClass;
+      zIndex: 700;
     }
+
+    /** @internal */
+    type _Snap = NullishProps<{
+      /**
+       * Snap to the grid?
+       * @defaultValue `true`
+       */
+      snap: boolean;
+    }>;
+
+    /** @remarks The types handled by {@link Wall#_getWallDataFromActiveTool} */
+    type WallTools = "clone" | "invisible" | "terrain" | "ethereal" | "doors" | "secret" | "window";
+
+    interface GetWallEndpointCoordinatesOptions extends _Snap {}
   }
 }
 
 declare abstract class AnyWallsLayer extends WallsLayer {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

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

@@ -1,13 +1,11 @@
+import type { Identity, 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;
-  }
+  /**
+   * @deprecated {@link ClockwiseSweepPolygon.Ray | `ClockwiseSweepPolygon.Ray`}
+   */
+  type PolygonRay = ClockwiseSweepPolygon.Ray;
 
   /**
    * A PointSourcePolygon implementation that uses CCW (counter-clockwise) geometry orientation.
@@ -15,23 +13,29 @@ 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
      */
     // @ts-expect-error Getter/setter routine is deprecated functionality as of v11, removed in v13
-    rays: PolygonRay[];
+    rays: ClockwiseSweepPolygon.Ray[];
 
-    override initialize(origin: Canvas.Point, config: PointSourcePolygonConfig): void;
+    override initialize(origin: Canvas.Point, config: PointSourcePolygon.Config): void;
 
     clone(): this;
 
@@ -46,7 +50,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 +61,7 @@ declare global {
      */
     protected _testEdgeInclusion(
       edge: Edge,
-      edgeTypes: Record<Edge.EdgeTypes, 0 | 1 | 2>,
+      edgeTypes: ClockwiseSweepPolygon.DetermineEdgesReturn,
       bounds: PIXI.Rectangle,
     ): boolean;
 
@@ -75,25 +79,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 +109,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 +121,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 +139,54 @@ 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 {}
+    interface AnyConstructor extends Identity<typeof AnyClockwiseSweepPolygon> {}
+
+    interface StoredConfig extends PointSourcePolygon.StoredConfig {
+      /** The computed bounding box for the polygon */
+      boundingBox: PIXI.Rectangle;
+    }
+
+    /**
+     * @remarks 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>>;
+
+    interface Ray extends globalThis.Ray {
+      /**
+       * @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;
+    }
+  }
+}
+
+declare abstract class AnyClockwiseSweepPolygon extends ClockwiseSweepPolygon {
+  constructor(...args: never);
 }