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

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

@@ -1,110 +1,73 @@
-import type { FixedInstanceType } from "fvtt-types/utils";
-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 = FixedInstanceType<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<Wall.RenderFlags>;
-
-      /** @defaultValue `{ propagate: ["refreshState", "refreshLine"], alias: true }` */
-      refresh: RenderFlag<Wall.RenderFlags>;
-
-      /** @defaultValue `{ propagate: ["refreshEndpoints", "refreshHighlight"] }` */
-      refreshState: RenderFlag<Wall.RenderFlags>;
-
-      /** @defaultValue `{ propagate: ["refreshEndpoints", "refreshHighlight", "refreshDirection"] }` */
-      refreshLine: RenderFlag<Wall.RenderFlags>;
-
-      /** @defaultValue `{}` */
-      refreshEndpoints: RenderFlag<Wall.RenderFlags>;
+    static override RENDER_FLAGS: Wall.RENDER_FLAGS;
 
-      /** @defaultValue `{}` */
-      refreshDirection: RenderFlag<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 `{}` */
-      refreshHighlight: RenderFlag<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;
+    doorControl: DoorControl.ConfiguredInstance | null | undefined;
 
     /**
-     * A reference to an overhead Tile that is a roof, interior to which this wall is contained
-     * @defaultValue `undefined`
+     * The line segment that represents the Wall.
      */
-    roof: Tile.ConfiguredInstance | undefined;
+    line: PIXI.Graphics | undefined;
 
     /**
-     * A Graphics object used to highlight this wall segment. Only used when the wall is controlled.
-     */
-    highlight: PIXI.Graphics | undefined;
-
-    /**
-     * A set which tracks other Wall instances that this Wall intersects with (excluding shared endpoints)
-     */
-    intersectsWith: Map<Wall.ConfiguredInstance, LineIntersection>;
-
-    /**
-     * 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;
 
@@ -118,11 +81,6 @@ 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
      */
@@ -133,51 +91,46 @@ declare global {
     /**
      * 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
@@ -198,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;
 
@@ -266,12 +221,180 @@ declare global {
 
     protected override _onDragLeftMove(event: PIXI.FederatedEvent): void;
 
-    // eslint-disable-next-line @typescript-eslint/no-misused-promises
-    protected override _onDragLeftDrop(event: PIXI.FederatedEvent): Promise<unknown>;
+    protected override _prepareDragLeftDropUpdates(event: PIXI.FederatedEvent): Wall.DragLeftDropUpdate[] | null;
+
+    /**
+     * @deprecated since v12, until v14
+     * @remarks "`Wall#roof` has been deprecated. There's no replacement"
+     */
+    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 {
+    /**
+     * The implementation of the `Wall` placeable configured through `CONFIG.Wall.objectClass`
+     * in Foundry and {@link PlaceableObjectClassConfig | `PlaceableObjectClassConfig`} in fvtt-types.
+     *
+     * Not to be confused with {@link WallDocument.Implementation | `WallDocument.Implementation`}
+     * which refers to the implementation for the Wall document.
+     */
+    type Implementation = FixedInstanceType<ImplementationClass>;
+
+    /**
+     * The implementation of the `Wall` placeable configured through `CONFIG.Wall.objectClass`
+     * in Foundry and {@link PlaceableObjectClassConfig | `PlaceableObjectClassConfig`} in fvtt-types.
+     *
+     * Not to be confused with {@link WallDocument.ImplementationClass | `WallDocument.ImplementationClass`}
+     * which refers to the implementation for the Wall document.
+     */
+    // eslint-disable-next-line no-restricted-syntax
+    type ImplementationClass = ConfiguredObjectClassOrDefault<typeof Wall>;
+
+    /**
+     * @deprecated {@link ImplementationClass | `ImplementationClass`}
+     */
+    type ObjectClass = ImplementationClass;
+
+    /**
+     * @deprecated {@link Implementation | `Implementation`}
+     */
+    type Object = Implementation;
 
     /**
-     * @remarks Not used
+     * @deprecated {@link Wall.ImplementationClass | `Wall.ImplementationClass`}
      */
-    controlIcon: null;
+    type ConfiguredClass = ImplementationClass;
+
+    /**
+     * @deprecated {@link Wall.Implementation | `Wall.Implementation`}
+     */
+    type ConfiguredInstance = Implementation;
+
+    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.Implementation[];
+
+      /** @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,4 +1,4 @@
-import type { ToMethod, InexactPartial, IntentionalPartial } from "fvtt-types/utils";
+import type { ToMethod, InexactPartial, IntentionalPartial, Identity } from "fvtt-types/utils";
 import type { IBatchableElement, ViewableBuffer } from "pixi.js";
 
 declare global {
@@ -76,7 +76,7 @@ declare global {
 
   namespace BatchRenderer {
     interface Any extends AnyBatchRenderer {}
-    type AnyConstructor = typeof AnyBatchRenderer;
+    interface AnyConstructor extends Identity<typeof AnyBatchRenderer> {}
 
     type PackInterleavedGeometryFunction = ToMethod<
       (
@@ -97,16 +97,38 @@ declare global {
 
     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;
 
-    interface ShaderGeneratorOptions {
+    /** @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(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

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

@@ -1,4 +1,4 @@
-export {};
+import type { Identity } from "fvtt-types/utils";
 
 declare global {
   /**
@@ -22,10 +22,10 @@ declare global {
 
   namespace BatchShaderGenerator {
     interface Any extends AnyBatchShaderGenerator {}
-    type AnyConstructor = typeof AnyBatchShaderGenerator;
+    interface AnyConstructor extends Identity<typeof AnyBatchShaderGenerator> {}
   }
 }
 
 declare abstract class AnyBatchShaderGenerator extends BatchShaderGenerator {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

package/src/foundry/client/pixi/webgl/helpers/framebuffer-snapshot.d.mts

@@ -1,4 +1,4 @@
-export {};
+import type { Identity } from "fvtt-types/utils";
 
 declare global {
   /**
@@ -22,10 +22,10 @@ declare global {
 
   namespace FramebufferSnapshot {
     interface Any extends AnyFramebufferSnapshot {}
-    type AnyConstructor = typeof AnyFramebufferSnapshot;
+    interface AnyConstructor extends Identity<typeof AnyFramebufferSnapshot> {}
   }
 }
 
 declare abstract class AnyFramebufferSnapshot extends FramebufferSnapshot {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

package/src/foundry/client/pixi/webgl/helpers/smooth-noise.d.mts

@@ -1,4 +1,4 @@
-import type { InexactPartial } from "fvtt-types/utils";
+import type { Identity, InexactPartial } from "fvtt-types/utils";
 
 declare global {
   /**
@@ -43,30 +43,38 @@ declare global {
 
   namespace SmoothNoise {
     interface Any extends AnySmoothNoise {}
-    type AnyConstructor = typeof AnySmoothNoise;
+    interface AnyConstructor extends Identity<typeof AnySmoothNoise> {}
 
-    interface ConstructorOptions {
+    /** @internal */
+    type _ConstructorOptions = InexactPartial<{
       /**
        * The generated noise will be on the range [0, amplitude].
        * @defaultValue `1`
+       * @remarks Can't be null because it only has a signature-provided default
        */
       amplitude: number;
 
       /**
        * An adjustment factor for the input x values which place them on an appropriate range.
        * @defaultValue `1`
+       * @remarks Can't be null because it only has a signature-provided default
        */
       scale: number;
 
       /**
        * The number of pre-generated random numbers to generate.
        * @defaultValue `256`
+       * @remarks Must be a power of 2 or construction throws.
+       * Can't be null because it only has a signature-provided default
        */
       maxReferences: number;
-    }
+    }>;
+
+    /** Options for the {@link SmoothNoise} constructor */
+    interface ConstructorOptions extends _ConstructorOptions {}
   }
 }
 
 declare abstract class AnySmoothNoise extends SmoothNoise {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }