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

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

@@ -1,109 +1,73 @@
-import type { LineIntersection } from "../../../common/utils/geometry.d.mts";
+import type { FixedInstanceType, HandleEmptyObject, NullishProps } from "fvtt-types/utils";
 import type { ConfiguredObjectClassOrDefault } from "../../config.d.mts";
+import Edge = foundry.canvas.edges.Edge;
 
 declare global {
-  namespace Wall {
-    type ConfiguredClass = ConfiguredObjectClassOrDefault<typeof Wall>;
-    type ConfiguredInstance = InstanceType<ConfiguredClass>;
-
-    interface RenderFlags extends PlaceableObject.RenderFlags {
-      refreshLine: boolean;
-
-      refreshEndpoints: boolean;
-
-      refreshDirection: boolean;
-
-      refreshHighlight: boolean;
-    }
-
-    interface ControlOptions extends PlaceableObject.ControlOptions {
-      /** @defaultValue `false` */
-      chain: boolean;
-    }
-
-    type DoorInteraction = "open" | "close" | "lock" | "unlock" | "test";
-  }
-
   /**
    * A Wall is an implementation of PlaceableObject which represents a physical or visual barrier within the Scene.
    * Walls are used to restrict Token movement or visibility as well as to define the areas of effect for ambient lights
    * and sounds.
    *
-   * @see {@link WallDocument}
-   * @see {@link WallsLayer}
+   * @see {@link WallDocument | `WallDocument`}
+   * @see {@link WallsLayer | `WallsLayer`}
    */
-  class Wall extends PlaceableObject<WallDocument.ConfiguredInstance> {
+  class Wall extends PlaceableObject<WallDocument.Implementation> {
     static override embeddedName: "Wall";
 
-    static override RENDER_FLAGS: {
-      /** @defaultValue `{ propagate: ["refresh"] }` */
-      redraw: RenderFlag<Partial<Wall.RenderFlags>>;
-
-      /** @defaultValue `{ propagate: ["refreshState", "refreshLine"], alias: true }` */
-      refresh: RenderFlag<Partial<Wall.RenderFlags>>;
+    static override RENDER_FLAGS: Wall.RENDER_FLAGS;
 
-      /** @defaultValue `{ propagate: ["refreshEndpoints", "refreshHighlight"] }` */
-      refreshState: RenderFlag<Partial<Wall.RenderFlags>>;
+    // Note: This isn't a "real" override but `renderFlags` is set corresponding to the
+    // `RENDER_FLAGS` and so it has to be adjusted here.
+    renderFlags: RenderFlags<Wall.RENDER_FLAGS>;
 
-      /** @defaultValue `{ propagate: ["refreshEndpoints", "refreshHighlight", "refreshDirection"] }` */
-      refreshLine: RenderFlag<Partial<Wall.RenderFlags>>;
-
-      /** @defaultValue `{}` */
-      refreshEndpoints: RenderFlag<Partial<Wall.RenderFlags>>;
-
-      /** @defaultValue `{}` */
-      refreshDirection: RenderFlag<Partial<Wall.RenderFlags>>;
-
-      /** @defaultValue `{}` */
-      refreshHighlight: RenderFlag<Partial<Wall.RenderFlags>>;
-    };
+    // fake override; super has to type as if this could be a ControlIcon, but Walls don't use one
+    override controlIcon: null;
 
     /**
      * A reference the Door Control icon associated with this Wall, if any
      * @defaultValue `undefined`
+     * @remarks Only `undefined` prior to first draw. {@link Wall.clearDoorControl | `Wall#clearDoorControl`} sets it `null`.
      */
-    protected doorControl: DoorControl | undefined | null;
-
-    /**
-     * A reference to an overhead Tile that is a roof, interior to which this wall is contained
-     * @defaultValue `undefined`
-     */
-    roof: Tile.ConfiguredInstance | undefined;
-
-    /**
-     * A Graphics object used to highlight this wall segment. Only used when the wall is controlled.
-     */
-    highlight: PIXI.Graphics | undefined;
+    doorControl: DoorControl.ConfiguredInstance | null | undefined;
 
     /**
-     * A set which tracks other Wall instances that this Wall intersects with (excluding shared endpoints)
+     * The line segment that represents the Wall.
      */
-    intersectsWith: Map<Wall.ConfiguredInstance, LineIntersection>;
+    line: PIXI.Graphics | undefined;
 
     /**
-     * A convenience reference to the coordinates Array for the Wall endpoints, [x0,y0,x1,y1].
+     * The endpoints of the Wall line segment.
+     * @defaultValue `undefined`
+     * @remarks Only `undefined` prior to first draw.
      */
-    get coords(): Wall["document"]["c"];
+    endpoints: PIXI.Graphics | undefined;
 
     /**
-     * The endpoints of the wall expressed as {@link foundry.canvas.edges.PolygonVertex} instances.
+     * The icon that indicates the direction of the Wall.
+     * @defaultValue `undefined`
+     * @remarks Only `undefined` prior to first draw.
+     * @privateRemarks Foundry types this as `| null` as well, but it is never set that in practice
      */
-    get vertices(): { a: foundry.canvas.edges.PolygonVertex; b: foundry.canvas.edges.PolygonVertex };
+    directionIcon: PIXI.Sprite | undefined;
 
     /**
-     * The initial endpoint of the Wall
+     * A Graphics object used to highlight this wall segment. Only used when the wall is controlled.
+     * @defaultValue `undefined`
+     * @remarks This is both not initialized to a value at construction *and* conditionally set
+     * explicitly `undefined` in {@link Wall._refreshHighlight | `Wall#_refreshHighlight`}
      */
-    get A(): Canvas.Point;
+    highlight: PIXI.Graphics | undefined;
 
     /**
-     * The second endpoint of the Wall
+     * A convenience reference to the coordinates Array for the Wall endpoints, [x0,y0,x1,y1].
      */
-    get B(): Canvas.Point;
+    get coords(): Wall.Coordinates;
 
     /**
-     * A set of vertex sort keys which identify this Wall's endpoints.
+     * The Edge instance which represents this Wall.
+     * The Edge is re-created when data for the Wall changes.
      */
-    get wallKeys(): Set<number>;
+    get edge(): Edge;
 
     override get bounds(): PIXI.Rectangle;
 
@@ -117,66 +81,56 @@ declare global {
      */
     get isOpen(): boolean;
 
-    /**
-     * Is this Wall interior to a non-occluded roof Tile?
-     */
-    get hasActiveRoof(): boolean;
-
     /**
      * 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;
 
     /**
      * Get the direction of effect for a directional Wall
      * @returns The angle of wall effect
+     * @remarks In radians. Returns `null` if the document's `dir` is falsey/not set
      */
     get direction(): number | null;
 
+    /**
+     * @throws "`Wall#getSnappedPosition` is not supported: WallDocument does not have a (x, y) position"
+     */
+    override getSnappedPosition(position: never): never;
+
+    /**
+     * Initialize the edge which represents this Wall.
+     * @param options - Options which modify how the edge is initialized
+     */
+    // options: not null (destructured)
+    initializeEdge(options?: Wall.InitializeEdgeOptions): void;
+
     /**
      * This helper converts the wall segment to a Ray
      * @returns The wall in Ray representation
      */
     toRay(): Ray;
 
-    protected override _draw(): Promise<void>;
+    protected override _draw(options: HandleEmptyObject<Wall.DrawOptions>): Promise<void>;
 
     override clear(): this;
 
     /**
      * Draw a control icon that is used to manipulate the door's open/closed state
      */
-    createDoorControl(): DoorControl;
+    createDoorControl(): DoorControl.ConfiguredInstance;
 
     /**
      * Clear the door control if it exists.
      */
     clearDoorControl(): void;
 
-    /**
-     * Determine the orientation of this wall with respect to a reference point
-     * @param point - Some reference point, relative to which orientation is determined
-     * @returns An orientation in CONST.WALL_DIRECTIONS which indicates whether the Point is left,
-     *          right, or collinear (both) with the Wall
-     */
-    orientPoint(point: Canvas.Point): number;
-
-    /**
-     * Test whether to apply a configured threshold of this wall.
-     * When the proximity threshold is met, this wall is excluded as an edge in perception calculations.
-     * @param sourceType     - Sense type for the source
-     * @param sourceOrigin   - The origin or position of the source on the canvas
-     * @param externalRadius - The external radius of the source
-     *                         (default: `0`)
-     * @returns True if the wall has a threshold greater than 0 for the source type, and the source type is within that distance.
-     */
-    applyThreshold(sourceType: string, sourceOrigin: Canvas.Point, externalRadius: number): boolean;
-
+    // options: not null (destructured)
     override control(options?: Wall.ControlOptions): boolean;
 
-    protected override _destroy(options?: PIXI.IDestroyOptions | boolean): void;
+    protected override _destroy(options: PIXI.IDestroyOptions | boolean | undefined): void;
 
     /**
      * Test whether the Wall direction lies between two provided angles
@@ -197,63 +151,65 @@ declare global {
      * Get an Array of Wall objects which are linked by a common coordinate
      * @returns An object reporting ids and endpoints of the linked segments
      */
-    getLinkedSegments(): {
-      ids: string[];
-      walls: WallsLayer["placeables"];
-      endpoints: Array<[x: number, y: number]>;
-    };
+    getLinkedSegments(): Wall.GetLinkedSegmentsReturn;
+
+    protected override _applyRenderFlags(flags: Wall.RenderFlags): void;
 
     /**
-     * Determine whether this wall is beneath a roof tile, and is considered "interior", or not.
+     * Refresh the displayed position of the wall which refreshes when the wall coordinates or type changes.
      */
-    identifyInteriorState(): void;
+    protected _refreshLine(): void;
 
     /**
-     * Update any intersections with this wall.
+     * Refresh the display of wall endpoints which refreshes when the wall position or state changes.
      */
-    updateIntersections(): void;
+    protected _refreshEndpoints(): void;
 
     /**
-     * Record the intersection points between this wall and another, if any.
-     * @param other - The other wall.
+     * Draw a directional prompt icon for one-way walls to illustrate their direction of effect.
      */
-    protected _identifyIntersectionsWith(other: WallDocument.ConfiguredInstance): void;
+    protected _refreshDirection(): void;
 
-    protected override _applyRenderFlags(flags: Wall.RenderFlags): void;
+    /**
+     * Refresh the appearance of the wall control highlight graphic. Occurs when wall control or position changes.
+     */
+    protected _refreshHighlight(): void;
 
     /**
-     * Given the properties of the wall - decide upon a color to render the wall for display on the WallsLayer
+     * Refresh the displayed state of the Wall.
      */
-    protected _getWallColor(): number;
+    protected _refreshState(): void;
 
     /**
-     * @privateRemarks _onCreate, _onUpdate, and _onDelete are all overridden but with no signature changes.
-     * For type simplicity they are left off. These methods historically have been the source of a large amount of computation from tsc.
+     * Given the properties of the wall - decide upon a color to render the wall for display on the WallsLayer
      */
+    protected _getWallColor(): number;
+
+    // _onCreate, _onUpdate, and _onDelete are all overridden but with no signature changes.
+    // For type simplicity they are left off. These methods historically have been the source of a large amount of computation from tsc.
 
     /**
      * Play a door interaction sound.
      * This plays locally, each client independently applies this workflow.
      * @param interaction - The door interaction: "open", "close", "lock", "unlock", or "test".
-     * @internal
+     * @remarks Foundry marked `@internal`
      */
     protected _playDoorSound(interaction: Wall.DoorInteraction): void;
 
-    protected override _createInteractionManager(): NonNullable<this["mouseInteractionManager"]>;
-
-    override activateListeners(): void;
+    /**
+     * Customize the audible radius of sounds emitted by this wall, for example when a door opens or closes.
+     * @defaultValue `canvas.dimensions.distance * 12; // 60 feet on a 5ft grid`
+     */
+    get soundRadius(): number;
 
-    protected override _canControl(user: User.ConfiguredInstance, event?: any): boolean;
+    protected override _canControl(user: User.Implementation, event: PIXI.FederatedEvent): boolean;
 
+    // options: not null (destructured in super)
     protected override _onHoverIn(event: PIXI.FederatedEvent, options?: PlaceableObject.HoverInOptions): false | void;
 
-    protected override _onHoverOut(event: PIXI.FederatedEvent): false | void;
+    protected override _onHoverOut(event: PIXI.FederatedEvent): void;
 
-    /**
-     * Handle mouse-hover events on the line segment itself, pulling the Wall to the front of the container stack
-     * @internal
-     */
-    protected _onMouseOverLine(event: PIXI.FederatedEvent): void;
+    protected override _overlapsSelection(rectangle: PIXI.Rectangle): boolean;
 
     protected override _onClickLeft(event: PIXI.FederatedEvent): boolean;
 
@@ -265,11 +221,175 @@ declare global {
 
     protected override _onDragLeftMove(event: PIXI.FederatedEvent): void;
 
-    protected override _onDragLeftDrop(event: PIXI.FederatedEvent): Promise<unknown>;
+    protected override _prepareDragLeftDropUpdates(event: PIXI.FederatedEvent): Wall.DragLeftDropUpdate[] | null;
 
     /**
-     * @remarks Not used
+     * @deprecated since v12, until v14
+     * @remarks "`Wall#roof` has been deprecated. There's no replacement"
      */
-    controlIcon: null;
+    get roof(): null;
+
+    /**
+     * @deprecated since v12, until v14
+     * @remarks "`Wall#hasActiveRoof` has been deprecated. There's no replacement"
+     */
+    get hasActiveRoof(): boolean;
+
+    /**
+     * @deprecated since v12, until v14
+     * @remarks "`Wall#identifyInteriorState` has been deprecated. It has no effect anymore and there's no replacement."
+     */
+    identifyInteriorState(): void;
+
+    /**
+     * Determine the orientation of this wall with respect to a reference point
+     * @param point - Some reference point, relative to which orientation is determined
+     * @returns An orientation in CONST.WALL_DIRECTIONS which indicates whether the Point is left, right, or collinear (both) with the Wall
+     * @deprecated since v12, until v14
+     * @remarks "`Wall#orientPoint` has been moved to {@link Edge.orientPoint | `foundry.canvas.edges.Edge#orientPoint`}"
+     */
+    orientPoint(point: Canvas.Point): CONST.WALL_DIRECTIONS;
+
+    /**
+     * Test whether to apply a configured threshold of this wall.
+     * When the proximity threshold is met, this wall is excluded as an edge in perception calculations.
+     * @param sourceType     - Sense type for the source
+     * @param sourceOrigin   - The origin or position of the source on the canvas
+     * @param externalRadius - The external radius of the source (default: `0`)
+     * @returns `true` if the wall has a threshold greater than 0 for the source type, and the source type is within that distance.
+     * @deprecated since v12, until v14
+     * @remarks "Wall#applyThreshold has been moved to {@link Edge.applyThreshold | `foundry.canvas.edges.Edge#applyThreshold`}"
+     */
+    applyThreshold(
+      sourceType: Edge.AttenuationTypes,
+      sourceOrigin: Canvas.Point,
+      externalRadius?: number | null,
+    ): boolean;
+
+    /**
+     * @deprecated since v12, until v14
+     * @remarks "`Wall#vertices` is replaced by {@link Wall.edge | `Wall#edge`}"
+     */
+    get vertices(): Edge;
+
+    /**
+     * The initial endpoint of the Wall
+     * @deprecated since v12, until v14
+     * @remarks "`Wall#A` is replaced by {@link Edge.a | `Wall#edge#a`}"
+     */
+    get A(): Edge["a"];
+
+    /**
+     * The second endpoint of the Wall
+     * @deprecated since v12, until v14
+     * @remarks "`Wall#B` is replaced by {@link Edge.b | `Wall#edge#b`}"
+     */
+    get B(): Edge["b"];
+  }
+
+  namespace Wall {
+    // eslint-disable-next-line no-restricted-syntax
+    interface ObjectClass extends ConfiguredObjectClassOrDefault<typeof Wall> {}
+    interface Object extends FixedInstanceType<ObjectClass> {}
+
+    /**
+     * @deprecated {@link Wall.ObjectClass | `Wall.ObjectClass`}
+     */
+    type ConfiguredClass = ObjectClass;
+
+    /**
+     * @deprecated {@link Wall.Object | `Wall.Object`}
+     */
+    type ConfiguredInstance = Object;
+
+    /**
+     * This type will permanently exist but is marked deprecated. The reason it exists is because
+     * the confusion between `Wall` (the `PlaceableObject` that appears on the canvas) and
+     * `WallDocument` (the `Document` that represents the data for a `Wall`) is so common that
+     * it is useful to have a type to forward to `WallDocument`.
+     *
+     * @deprecated {@link WallDocument.Implementation | `WallDocument.Implementation`}
+     */
+    type Implementation = WallDocument.Implementation;
+
+    /**
+     * This type will permanently exist but is marked deprecated. The reason it exists is because
+     * the confusion between `Wall` (the `PlaceableObject` that appears on the canvas) and
+     * `WallDocument` (the `Document` that represents the data for a `Wall`) is so common that
+     * it is useful to have a type to forward to `WallDocument`.
+     *
+     * @deprecated {@link WallDocument.ImplementationClass | `WallDocument.ImplementationClass`}
+     */
+    type ImplementationClass = WallDocument.ImplementationClass;
+
+    interface RENDER_FLAGS {
+      /** @defaultValue `{ propagate: ["refresh"] }` */
+      redraw: RenderFlag<this, "redraw">;
+
+      /** @defaultValue `{ propagate: ["refreshState", "refreshLine"], alias: true }` */
+      refresh: RenderFlag<this, "refresh">;
+
+      /** @defaultValue `{ propagate: ["refreshEndpoints", "refreshHighlight"] }` */
+      refreshState: RenderFlag<this, "refreshState">;
+
+      /** @defaultValue `{ propagate: ["refreshEndpoints", "refreshHighlight", "refreshDirection"] }` */
+      refreshLine: RenderFlag<this, "refreshLine">;
+
+      /** @defaultValue `{}` */
+      refreshEndpoints: RenderFlag<this, "refreshEndpoints">;
+
+      /** @defaultValue `{}` */
+      refreshDirection: RenderFlag<this, "refreshDirection">;
+
+      /** @defaultValue `{}` */
+      refreshHighlight: RenderFlag<this, "refreshHighlight">;
+    }
+
+    interface RenderFlags extends RenderFlagsMixin.ToBooleanFlags<RENDER_FLAGS> {}
+
+    type Coordinates = WallDocument.Coordinates;
+
+    type DoorInteraction = "open" | "close" | "lock" | "unlock" | "test";
+
+    interface DrawOptions extends PlaceableObject.DrawOptions {}
+
+    interface RefreshOptions extends PlaceableObject.RefreshOptions {}
+
+    /** @internal */
+    type _ControlOptions = NullishProps<{
+      /** @defaultValue `false` */
+      chain: boolean;
+    }>;
+
+    interface ControlOptions extends _ControlOptions, PlaceableObject.ControlOptions {}
+
+    interface ReleaseOptions extends PlaceableObject.ReleaseOptions {}
+
+    /** @internal */
+    type _InitializeEdgeOptions = NullishProps<{
+      /**
+       * Has the edge been deleted?
+       * @defaultValue `false`
+       */
+      deleted: boolean;
+    }>;
+
+    interface InitializeEdgeOptions extends _InitializeEdgeOptions {}
+
+    interface GetLinkedSegmentsReturn {
+      /** @remarks IDs of the Walls in `walls` */
+      ids: string[];
+
+      /** @remarks All the Walls connected to this one */
+      walls: Wall.Object[];
+
+      /** @remarks `walls.length + 1` endpoints */
+      endpoints: Canvas.PointTuple[];
+    }
+
+    interface DragLeftDropUpdate {
+      _id: string;
+      c: WallDocument.Coordinates;
+    }
   }
 }

package/src/foundry/client/pixi/webgl/extensions/batch-renderer.d.mts

@@ -1,37 +1,7 @@
-import type { ToMethod } from "../../../../../types/helperTypes.d.mts";
-import type { InexactPartial } from "../../../../../types/utils.d.mts";
-
-declare abstract class AnyBatchRenderer extends BatchRenderer {
-  constructor(arg0: never, ...args: never[]);
-}
+import type { ToMethod, InexactPartial, IntentionalPartial, Identity } from "fvtt-types/utils";
+import type { IBatchableElement, ViewableBuffer } from "pixi.js";
 
 declare global {
-  namespace BatchRenderer {
-    type AnyConstructor = typeof AnyBatchRenderer;
-
-    type PackInterleavedGeometryFunction = ToMethod<
-      (
-        element: PIXI.IBatchableElement,
-        attributeBuffer: PIXI.ViewableBuffer,
-        indexBuffer: Uint16Array,
-        aIndex: number,
-        iIndex: number,
-      ) => void
-    >;
-
-    type PreRenderBatchFunction = ToMethod<(batchRenderer: typeof BatchRenderer) => void>;
-
-    type BatchDefaultUniformsFunction = ToMethod<(maxTextures: number) => AbstractBaseShader.Uniforms>;
-
-    type ReservedTextureUnits = 0 | 1 | 2 | 3 | 4;
-
-    interface ShaderGeneratorOptions {
-      vertex: typeof BatchRenderer.defaultVertexSrc;
-      fragment: typeof BatchRenderer.defaultFragmentTemplate;
-      uniforms: typeof BatchRenderer.defaultUniforms;
-    }
-  }
-
   /**
    * A batch renderer with a customizable data transfer function to packed geometries.
    */
@@ -83,7 +53,18 @@ declare global {
 
     override start(): void;
 
-    override packInterleavedGeometry: BatchRenderer.PackInterleavedGeometryFunction;
+    /**
+     * @privateRemarks This signature must match `PIXI.BatchRenderer#packInterleavedGeometry`, as opposed to being
+     * a `PackInterleavedGeometryFunction`, as these params will be piped there if the subclass in question
+     * doesn't implement `_packInterleavedGeometry`
+     */
+    override packInterleavedGeometry(
+      element: IBatchableElement,
+      attributeBuffer: ViewableBuffer,
+      indexBuffer: Uint16Array,
+      aIndex: number,
+      iIndex: number,
+    ): void;
 
     /**
      * Verify if a PIXI plugin exists. Check by name.
@@ -92,4 +73,62 @@ declare global {
      */
     static hasPlugin(name: string): boolean;
   }
+
+  namespace BatchRenderer {
+    interface Any extends AnyBatchRenderer {}
+    interface AnyConstructor extends Identity<typeof AnyBatchRenderer> {}
+
+    type PackInterleavedGeometryFunction = ToMethod<
+      (
+        /**
+         * @privateRemarks The `element` param is `Partial`'d here because at least one `_packInterleavedGeometry` implementation (`DepthSampleShader`'s)
+         * omits properties from the parent PIXI interface. Neither `PIXI.BatchRenderer` nor any Foundry implementations provide any default vaules for
+         * properties of this interface, so no `InexactPartial` or `NullishProps`.
+         */
+        element: IntentionalPartial<PIXI.IBatchableElement>,
+        attributeBuffer: PIXI.ViewableBuffer,
+        indexBuffer: Uint16Array,
+        aIndex: number,
+        iIndex: number,
+      ) => void
+    >;
+
+    type PreRenderBatchFunction = ToMethod<(batchRenderer: typeof BatchRenderer) => void>;
+
+    type BatchDefaultUniformsFunction = ToMethod<(maxTextures: number) => AbstractBaseShader.Uniforms>;
+
+    /** @remarks The `BatchRenderer#reservedTextureUnits` setter throws if passed a value outside of 0-4, and by usage wants an integer */
+    type ReservedTextureUnits = 0 | 1 | 2 | 3 | 4;
+
+    /** @internal */
+    type _ShaderGeneratorOptions = InexactPartial<{
+      /**
+       * The vertex shader source
+       * @remarks Can't be null as only a signature default is provided
+       */
+      vertex: typeof BatchRenderer.defaultVertexSrc;
+
+      /**
+       * The fragment shader source template
+       * @remarks Can't be null as only a signature default is provided
+       */
+      fragment: typeof BatchRenderer.defaultFragmentTemplate;
+
+      /**
+       * Additional Uniforms
+       * @remarks Can't be null as only a signature default is provided
+       */
+      uniforms: typeof BatchRenderer.defaultUniforms;
+    }>;
+
+    /**
+     * Options for {@link BatchRenderer#setShaderGenerator} (and ultimately the
+     * constructor of whatever's set as {@link BatchRenderer.shaderGeneratorClass})
+     */
+    interface ShaderGeneratorOptions extends _ShaderGeneratorOptions {}
+  }
+}
+
+declare abstract class AnyBatchRenderer extends BatchRenderer {
+  constructor(...args: never);
 }

package/src/foundry/client/pixi/webgl/extensions/batch-shader-generator.d.mts

@@ -1,14 +1,6 @@
-export {};
-
-declare abstract class AnyBatchShaderGenerator extends BatchShaderGenerator {
-  constructor(arg0: never, ...args: never[]);
-}
+import type { Identity } from "fvtt-types/utils";
 
 declare global {
-  namespace BatchShaderGenerator {
-    type AnyConstructor = typeof AnyBatchShaderGenerator;
-  }
-
   /**
    * A batch shader generator that could handle extra uniforms during initialization.
    * @param vertexSrc    - The vertex shader source
@@ -27,4 +19,13 @@ declare global {
 
     override generateShader(maxTextures: number): PIXI.Shader;
   }
+
+  namespace BatchShaderGenerator {
+    interface Any extends AnyBatchShaderGenerator {}
+    interface AnyConstructor extends Identity<typeof AnyBatchShaderGenerator> {}
+  }
+}
+
+declare abstract class AnyBatchShaderGenerator extends BatchShaderGenerator {
+  constructor(...args: never);
 }

package/src/foundry/client/pixi/webgl/helpers/{framebugger-snapshot.d.mts → framebuffer-snapshot.d.mts}

@@ -1,14 +1,6 @@
-export {};
-
-declare abstract class AnyFramebufferSnapshot extends FramebufferSnapshot {
-  constructor(arg0: never, ...args: never[]);
-}
+import type { Identity } from "fvtt-types/utils";
 
 declare global {
-  namespace FramebufferSnapshot {
-    type AnyConstructor = typeof AnyFramebufferSnapshot;
-  }
-
   /**
    * Provide the necessary methods to get a snapshot of the framebuffer into a render texture.
    * Class meant to be used as a singleton.
@@ -27,4 +19,13 @@ declare global {
      */
     getFramebufferTexture(renderer: PIXI.Renderer): PIXI.RenderTexture;
   }
+
+  namespace FramebufferSnapshot {
+    interface Any extends AnyFramebufferSnapshot {}
+    interface AnyConstructor extends Identity<typeof AnyFramebufferSnapshot> {}
+  }
+}
+
+declare abstract class AnyFramebufferSnapshot extends FramebufferSnapshot {
+  constructor(...args: never);
 }