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

package/src/foundry/client-esm/canvas/sources/global-light-source.d.mts

@@ -1,9 +1,15 @@
+import type { FixedInstanceType, Identity } from "fvtt-types/utils";
 import type BaseLightSource from "./base-light-source.d.mts";
+import type RenderedEffectSource from "./rendered-effect-source.d.mts";
 
 /**
  * A specialized subclass of the BaseLightSource which is used to render global light source linked to the scene.
  */
-declare class GlobalLightSource extends BaseLightSource {
+declare class GlobalLightSource<
+  SourceData extends GlobalLightSource.SourceData = GlobalLightSource.SourceData,
+  SourceShape extends PIXI.Polygon = PIXI.Polygon,
+  RenderingLayers extends Record<string, RenderedEffectSource.SourceLayer> = RenderedEffectSource.Layers,
+> extends BaseLightSource<SourceData, SourceShape, RenderingLayers> {
   /** @defaultValue `"GlobalLight"` */
   static override sourceType: string;
 
@@ -14,23 +20,26 @@ declare class GlobalLightSource extends BaseLightSource {
    * @defaultValue
    * ```js
    * {
-   * ...super.defaultData,
-   * rotation: 0,
-   * angle: 360,
-   * attenuation: 0,
-   * priority: -Infinity,
-   * vision: false,
-   * walls: false,
-   * elevation: Infinity,
-   * darkness: {min: 0, max: 0}
+   *   ...super.defaultData,
+   *   rotation: 0,
+   *   angle: 360,
+   *   attenuation: 0,
+   *   priority: -Infinity,
+   *   vision: false,
+   *   walls: false,
+   *   elevation: Infinity,
+   *   darkness: {min: 0, max: 0}
    * }
    * ```
    */
-  static override defaultData: BaseLightSource.SourceData;
+  static override defaultData: GlobalLightSource.SourceData;
+
+  /** @privateRemarks This class implements `#_createShapes`, so it's shape property will 'never' be undefined (after initialization) */
+  shape: SourceShape;
 
   /**
    * Name of this global light source.
-   * @defaultValue `GlobalLightSource.sourceType`
+   * @defaultValue `this.constructor.sourceType` (`"GlobalLight"`)
    */
   name: string;
 
@@ -41,22 +50,72 @@ declare class GlobalLightSource extends BaseLightSource {
    */
   customPolygon: PIXI.Polygon | number[] | null;
 
-  override _createShapes(): void;
+  protected override _createShapes(): void;
 
-  override _initializeSoftEdges(): void;
+  protected override _initializeSoftEdges(): void;
 
-  override _updateGeometry(): void;
+  protected override _updateGeometry(): void;
 
-  override _updateCommonUniforms(shader: AbstractBaseShader): void;
+  protected override _updateCommonUniforms(shader: AbstractBaseShader): void;
 }
 
 declare namespace GlobalLightSource {
-  type Any = AnyGlobalLightSource;
-  type AnyConstructor = typeof AnyGlobalLightSource;
+  interface Any extends AnyGlobalLightSource {}
+  interface AnyConstructor extends Identity<typeof AnyGlobalLightSource> {}
+
+  /**
+   * @privateRemarks `attenuation`, `priority`, and `elevation` exist in the parent interface,
+   * but are here for defaultValue overrides
+   */
+  interface SourceData extends BaseLightSource.SourceData {
+    /** @privateRemarks Type override only, the global light is not going to use a `darknessShader` */
+    animation: RenderedEffectSource.StoredLightAnimationConfig;
+
+    /**
+     * @defaultValue `0`
+     * @remarks Seemingly unused here, since `GlobalLightSource` does not inherit from `PointEffectSourceMixin`
+     */
+    rotation: number;
+
+    /**
+     * @defaultValue `360`
+     * @remarks Seemingly unused here, since `GlobalLightSource` does not inherit from `PointEffectSourceMixin`
+     */
+    angle: number;
+
+    /** @defaultValue `0` */
+    attenuation: number;
+
+    /** @defaultValue `-Infinity` */
+    priority: number;
+
+    // `vision` override omitted as it doesn't change the default
+
+    /**
+     * @defaultValue `false`
+     * @remarks Seemingly unused here, since `GlobalLightSource` does not inherit from `PointEffectSourceMixin`
+     */
+    walls: boolean;
+
+    /** @defaultValue `Infinity` */
+    elevation: number;
+
+    /** @remarks Threshold values for what darkness level the global light should be enabled for */
+    darkness: {
+      /** @defaultValue `0` */
+      min: number;
+
+      /** @defaultValue `0` */
+      max: number;
+    };
+  }
+
+  type ConfiguredClass = CONFIG["Canvas"]["globalLightSourceClass"];
+  type ConfiguredInstance = FixedInstanceType<ConfiguredClass>;
 }
 
 declare abstract class AnyGlobalLightSource extends GlobalLightSource {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }
 
 export default GlobalLightSource;

package/src/foundry/client-esm/canvas/sources/point-darkness-source.d.mts

@@ -1,4 +1,4 @@
-import type { IntentionalPartial } from "fvtt-types/utils";
+import type { AnyObject, FixedInstanceType, Identity, IntentionalPartial, RequiredProps } from "fvtt-types/utils";
 import type BaseLightSource from "./base-light-source.d.mts";
 import type PointEffectSourceMixin from "./point-effect-source.d.mts";
 import type RenderedEffectSource from "./rendered-effect-source.d.mts";
@@ -9,20 +9,21 @@ import type RenderedEffectSource from "./rendered-effect-source.d.mts";
 declare class PointDarknessSource<
   SourceData extends PointDarknessSource.SourceData = PointDarknessSource.SourceData,
   SourceShape extends PointSourcePolygon = PointSourcePolygon,
-> extends PointEffectSourceMixin(BaseLightSource)<SourceData, SourceShape, PointDarknessSource.Layers> {
+  RenderingLayers extends Record<string, RenderedEffectSource.SourceLayer> = PointDarknessSource.Layers,
+> extends PointEffectSourceMixin(BaseLightSource)<SourceData, SourceShape, RenderingLayers> {
   /** @defaultValue `"darknessSources"` */
   static override effectsCollection: string;
 
   /** @defaultValue `foundry.CONST.LIGHTING_LEVELS.HALFDARK` */
-  static override _dimLightingLevel: foundry.CONST.LIGHTING_LEVELS;
+  protected static override _dimLightingLevel: foundry.CONST.LIGHTING_LEVELS;
 
   /** @defaultValue `foundry.CONST.LIGHTING_LEVELS.DARKNESS` */
-  static override _brightLightingLevel: foundry.CONST.LIGHTING_LEVELS;
+  protected static override _brightLightingLevel: foundry.CONST.LIGHTING_LEVELS;
 
   /** @defaultValue `CONFIG.Canvas.darknessAnimations` */
-  static get ANIMATIONS(): typeof CONFIG.Canvas.darknessAnimations;
+  protected static get ANIMATIONS(): typeof CONFIG.Canvas.darknessAnimations;
 
-  static override get _layers(): Record<string, foundry.canvas.sources.RenderedEffectSource.LayerConfig>;
+  protected static override get _layers(): Record<string, RenderedEffectSource.LayerConfig>;
 
   /** @privateRemarks This is not in Foundry's code, but accounts for the mixin class's static property's inability to be generic */
   static override defaultData: PointDarknessSource.SourceData;
@@ -54,48 +55,64 @@ declare class PointDarknessSource<
   /**
    * A convenience accessor to the darkness layer mesh.
    */
-  get darkness(): this["layers"]["darkness"]["mesh"];
+  get darkness(): PointSourceMesh;
 
-  override _initialize(data: IntentionalPartial<SourceData>): void;
+  protected override _initialize(data: IntentionalPartial<SourceData>): void;
 
-  override _createShapes(): void;
+  protected override _createShapes(): void;
 
-  override _configure(changes: IntentionalPartial<SourceData>): void;
+  // TODO: Flatten<IntentionalPartial<SourceData>>
+  protected override _configure(changes: AnyObject): void;
 
-  override _getPolygonConfiguration(): PointSourcePolygon.Config;
+  protected override _getPolygonConfiguration(): PointDarknessSource.PolygonConfig;
 
-  override _drawMesh(layerId: string): PIXI.Mesh | null;
+  protected override _drawMesh(layerId: string): PointSourceMesh | null;
 
-  override _updateGeometry(): void;
+  protected override _updateGeometry(): void;
 
   /**
    * Update the uniforms of the shader on the darkness layer.
    */
-  _updateDarknessUniforms(): void;
+  protected _updateDarknessUniforms(): void;
 
-  override _destroy(): void;
+  protected override _destroy(): void;
 
   /**
    * @deprecated since v12, until v14
    * @remarks `"BaseLightSource#isDarkness is now obsolete. Use DarknessSource instead."`
+   *
+   * Always returns `true`
    */
-  get isDarkness(): boolean;
+  get isDarkness(): true;
 }
 
 declare namespace PointDarknessSource {
-  type AnyConstructor = typeof AnyPointDarknessSource;
+  interface Any extends AnyPointDarknessSource {}
+  interface AnyConstructor extends Identity<typeof AnyPointDarknessSource> {}
 
-  type SourceData = BaseLightSource.SourceData & PointEffectSourceMixin.SourceData;
+  interface SourceData extends BaseLightSource.SourceData, PointEffectSourceMixin.SourceData {
+    animation: RenderedEffectSource.StoredDarknessAnimationConfig;
+  }
+
+  interface PolygonConfig
+    extends RequiredProps<PointEffectSourceMixin.PolygonConfig, "useThreshold" | "includeDarkness" | "radius"> {}
 
   // Interface would require `RenderingLayers extends ... = InterfaceToObject<Layers>` in every subclass signature
   // eslint-disable-next-line @typescript-eslint/consistent-type-definitions
   type Layers = {
     darkness: RenderedEffectSource.SourceLayer;
   };
+
+  type ConfiguredClass = CONFIG["Canvas"]["darknessSourceClass"];
+  type ConfiguredInstance = FixedInstanceType<ConfiguredClass>;
 }
 
-declare abstract class AnyPointDarknessSource extends PointDarknessSource {
-  constructor(arg0: never, ...args: never[]);
+declare abstract class AnyPointDarknessSource extends PointDarknessSource<
+  PointDarknessSource.SourceData,
+  PointSourcePolygon,
+  PointDarknessSource.Layers
+> {
+  constructor(...args: never);
 }
 
 export default PointDarknessSource;

package/src/foundry/client-esm/canvas/sources/point-effect-source.d.mts

@@ -1,28 +1,34 @@
-import type { Mixin, IntentionalPartial, FixedInstanceType } from "fvtt-types/utils";
+import type { Mixin, IntentionalPartial, FixedInstanceType, RequiredProps } from "fvtt-types/utils";
 import type BaseEffectSource from "./base-effect-source.d.mts";
 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
 declare class PointEffectSource {
-  /** @privateRemarks All mixin classses should accept anything for its constructor. */
+  /** @privateRemarks All mixin classes should accept anything for its constructor. */
   constructor(...args: any[]);
 
   /**
    * @defaultValue
    * ```js
    * {
-   * ...super.defaultData,
-   * radius: 0,
-   * externalRadius: 0,
-   * rotation: 0,
-   * angle: 360,
-   * walls: true
+   *   ...super.defaultData,
+   *   radius: 0,
+   *   externalRadius: 0,
+   *   rotation: 0,
+   *   angle: 360,
+   *   walls: true
    * }
    * ```
-   * @privateRemarks This will only be accurate for classes extending `PointEffectSourceMixin(BaseEffectSource)`.
-   * Other subclasses must override this.
+   * @remarks This type is only accurate for classes extending `PointEffectSourceMixin(BaseEffectSource)`.
+   * Other subclasses must override.
    */
   static defaultData: PointEffectSourceMixin.MixedSourceData;
 
-  /** @privateRemarks This is not in Foundry's code, but the mixin class loses access to the type parameter that would otherwise be here */
+  /**
+   * @defaultValue `CONFIG.Canvas.polygonBackends[this.constructor.sourceType].create(origin, config)`
+   * @privateRemarks This is not in Foundry's code, but the mixin class loses access to the type parameter that would
+   * otherwise be here, and per the default above this is always a {@link PointSourcePolygon | `PointSourcePolygon`} subclass, always
+   * {@link ClockwiseSweepPolygon | `ClockwiseSweepPolygon`} in core
+   */
   shape: PointSourcePolygon;
 
   /**
@@ -30,20 +36,20 @@ declare class PointEffectSource {
    */
   get radius(): number;
 
-  _initialize(data: IntentionalPartial<PointEffectSourceMixin.MixedSourceData>): void;
+  protected _initialize(data: IntentionalPartial<PointEffectSourceMixin.MixedSourceData>): void;
 
-  _initializeSoftEdges(): void;
+  protected _initializeSoftEdges(): void;
 
   /**
    * Configure the parameters of the polygon that is generated for this source.
    */
-  protected _getPolygonConfiguration(): PointSourcePolygon.Config;
+  protected _getPolygonConfiguration(): PointEffectSourceMixin.PolygonConfig;
 
-  _createShapes(): void;
+  protected _createShapes(): void;
 
-  _drawMesh(layerId: string): PIXI.Mesh | null;
+  protected _drawMesh(layerId: string): PointSourceMesh | null;
 
-  _updateGeometry(): void;
+  protected _updateGeometry(): void;
 
   /**
    * @deprecated since v11, until v13
@@ -55,9 +61,9 @@ declare class PointEffectSource {
   /**
    * @deprecated since v11, until v13
    * @remarks `"PointEffectSource#los is deprecated in favor of PointEffectSource#shape."`
-   * @privateRemarks Actual definition is get/set
+   * @privateRemarks Actually implemented as getter/setter for deprecation warning purposes, but this causes inheritance problems with  {@link foundry.canvas.sources.PointVisionSource#los | `PointVisionSource`}
    */
-  los: PointSourcePolygon;
+  los: this["shape"];
 }
 
 /**
@@ -69,32 +75,45 @@ declare function PointEffectSourceMixin<BaseClass extends PointEffectSourceMixin
 ): Mixin<typeof PointEffectSource, BaseClass>;
 
 declare namespace PointEffectSourceMixin {
-  type AnyMixedConstructor = ReturnType<typeof PointEffectSourceMixin<BaseClass>>;
+  interface AnyMixedConstructor extends ReturnType<typeof PointEffectSourceMixin<BaseClass>> {}
   interface AnyMixed extends FixedInstanceType<AnyMixedConstructor> {}
 
   type BaseClass = BaseEffectSource.AnyConstructor;
 
   type MixedSourceData = SourceData & BaseEffectSource.SourceData;
 
+  /** @remarks This mixin guarantees certain keys in the return type beyond the base required `type` */
+  interface PolygonConfig
+    extends RequiredProps<PointSourcePolygon.Config, "radius" | "externalRadius" | "angle" | "rotation" | "source"> {}
+
   interface SourceData {
     /**
      * The radius of the source
+     * @defaultValue `0`
      */
     radius: number;
+
     /**
      * A secondary radius used for limited angles
+     * @defaultValue `0`
      */
     externalRadius: number;
+
     /**
      * The angle of rotation for this point source
+     * @defaultValue `0`
      */
     rotation: number;
+
     /**
      * The angle of emission for this point source
+     * @defaultValue `360`
      */
     angle: number;
+
     /**
      * Whether or not the source is constrained by walls
+     * @defaultValue `true`
      */
     walls: boolean;
   }

package/src/foundry/client-esm/canvas/sources/point-light-source.d.mts

@@ -1,6 +1,7 @@
-import type { IntentionalPartial } from "fvtt-types/utils";
+import type { AnyObject, FixedInstanceType, Identity, IntentionalPartial, RequiredProps } from "fvtt-types/utils";
 import type BaseLightSource from "./base-light-source.d.mts";
 import type PointEffectSourceMixin from "./point-effect-source.d.mts";
+import type RenderedEffectSource from "./rendered-effect-source.d.mts";
 
 /**
  * A specialized subclass of the BaseLightSource which renders a source of light as a point-based effect.
@@ -8,30 +9,36 @@ import type PointEffectSourceMixin from "./point-effect-source.d.mts";
 declare class PointLightSource<
   SourceData extends PointLightSource.SourceData = PointLightSource.SourceData,
   SourceShape extends PointSourcePolygon = PointSourcePolygon,
-> extends PointEffectSourceMixin(BaseLightSource)<SourceData, SourceShape> {
+  RenderingLayers extends Record<string, RenderedEffectSource.SourceLayer> = RenderedEffectSource.Layers,
+> extends PointEffectSourceMixin(BaseLightSource)<SourceData, SourceShape, RenderingLayers> {
   /** @defaultValue `"lightSources"` */
   static override effectsCollection: string;
 
+  /** @privateRemarks Not in Foundry code, necessary type override */
+  static override defaultData: PointLightSource.SourceData;
+
   /**
    * @privateRemarks This is not in foundry's code, but since this class (and its parent) implements `_createShapes`,
    * and we are counting what happens in `initialize` as 'the constructor', this gets to be declared never undefined.
    */
   override shape: SourceShape;
 
-  override _initialize(data: IntentionalPartial<SourceData>): void;
+  protected override _initialize(data: IntentionalPartial<SourceData>): void;
 
-  override _createShapes(): void;
+  protected override _createShapes(): void;
 
-  override _configure(changes: IntentionalPartial<SourceData>): void;
+  // TODO: Flatten<IntentionalPartial<SourceData>>
+  protected override _configure(changes: AnyObject): void;
 
-  override _getPolygonConfiguration(): PointSourcePolygon.Config;
+  protected override _getPolygonConfiguration(): PointLightSource.PolygonConfig;
 
   /**
    * Test whether this LightSource provides visibility to see a certain target object.
    * @param config - The visibility test configuration
    * @returns Is the target object visible to this source?
+   * @remarks Despite being an `={}` parameter, this will error if `config.tests` is not at least an empty array of `CanvasVisibility.Test`s
    */
-  testVisibility(config?: CanvasVisibilityTestConfig): boolean;
+  testVisibility(config: CanvasVisibility.TestConfig): boolean;
 
   /**
    * Can this LightSource theoretically detect a certain object based on its properties?
@@ -39,17 +46,39 @@ declare class PointLightSource<
    * @param target - The target object being tested
    * @returns Can the target object theoretically be detected by this vision source?
    */
-  _canDetectObject(target?: PlaceableObject | null): boolean;
+  protected _canDetectObject(target?: PlaceableObject.Any | null): boolean;
+
+  /**
+   * @deprecated since v12, until v14
+   * @remarks `"BaseLightSource#isDarkness is now obsolete. Use DarknessSource instead."`
+   *
+   * Always returns `false`
+   * @privateRemarks This isn't actually overridden here, `BaseLightSource#isDarkness` always returns false, but it's type as `boolean` there to allow `PointDarknessSource#isDarkness` to return true.
+   */
+  get isDarkness(): false;
 }
 
 declare namespace PointLightSource {
-  type AnyConstructor = typeof AnyPointLightSource;
+  interface Any extends AnyPointLightSource {}
+  interface AnyConstructor extends Identity<typeof AnyPointLightSource> {}
+
+  interface SourceData extends PointEffectSourceMixin.SourceData, BaseLightSource.SourceData {
+    animation: RenderedEffectSource.StoredLightAnimationConfig;
+  }
+
+  interface PolygonConfig
+    extends RequiredProps<PointEffectSourceMixin.PolygonConfig, "useThreshold" | "includeDarkness"> {}
 
-  type SourceData = PointEffectSourceMixin.SourceData & BaseLightSource.SourceData;
+  type ConfiguredClass = CONFIG["Canvas"]["lightSourceClass"];
+  type ConfiguredInstance = FixedInstanceType<ConfiguredClass>;
 }
 
-declare abstract class AnyPointLightSource extends PointLightSource {
-  constructor(arg0: never, ...args: never[]);
+declare abstract class AnyPointLightSource extends PointLightSource<
+  PointLightSource.SourceData,
+  PointSourcePolygon,
+  RenderedEffectSource.Layers
+> {
+  constructor(...args: never);
 }
 
 export default PointLightSource;

package/src/foundry/client-esm/canvas/sources/point-movement-source.d.mts

@@ -1,3 +1,4 @@
+import type { Identity } from "fvtt-types/utils";
 import type BaseEffectSource from "./base-effect-source.d.mts";
 import type PointEffectSourceMixin from "./point-effect-source.d.mts";
 
@@ -11,6 +12,9 @@ declare class PointMovementSource<
   /** @defaultValue `"move"` */
   static override sourceType: string;
 
+  /** @privateRemarks Not in Foundry code, necessary type override */
+  static override defaultData: PointMovementSource.SourceData;
+
   /**
    * @privateRemarks This is not in foundry's code, but since this class (and its parent) implements `_createShapes`,
    * and we are counting what happens in `initialize` as 'the constructor', this gets to be declared never undefined.
@@ -19,13 +23,20 @@ declare class PointMovementSource<
 }
 
 declare namespace PointMovementSource {
-  type AnyConstructor = typeof AnyPointMovementSource;
+  interface Any extends AnyPointMovementSource {}
+  interface AnyConstructor extends Identity<typeof AnyPointMovementSource> {}
+
+  interface SourceData extends PointEffectSourceMixin.MixedSourceData {}
 
-  type SourceData = PointEffectSourceMixin.MixedSourceData;
+  // This is the only core Point*Source class that isn't configurable, `Token##getMovementSource`
+  // references this class directly, not a `CONFIG` property
 }
 
-declare abstract class AnyPointMovementSource extends PointMovementSource {
-  constructor(arg0: never, ...args: never[]);
+declare abstract class AnyPointMovementSource extends PointMovementSource<
+  PointMovementSource.SourceData,
+  PointSourcePolygon
+> {
+  constructor(...args: never);
 }
 
 export default PointMovementSource;

package/src/foundry/client-esm/canvas/sources/point-sound-source.d.mts

@@ -1,4 +1,4 @@
-import type { NullishProps } from "fvtt-types/utils";
+import type { FixedInstanceType, Identity, NullishProps, RequiredProps } from "fvtt-types/utils";
 import type BaseEffectSource from "./base-effect-source.d.mts";
 import type PointEffectSourceMixin from "./point-effect-source.d.mts";
 
@@ -12,36 +12,51 @@ declare class PointSoundSource<
   /** @defaultValue `"sound"` */
   static override sourceType: string;
 
+  /** @privateRemarks Not in Foundry code, necessary type override */
+  static override defaultData: PointSoundSource.SourceData;
+
   /**
    * @privateRemarks This is not in foundry's code, but since this class (and its parent) implements `_createShapes`,
    * and we are counting what happens in `initialize` as 'the constructor', this gets to be declared never undefined.
    */
   override shape: SourceShape;
 
-  override get effectsCollection(): Collection<this>;
+  override get effectsCollection(): foundry.utils.Collection<this>;
 
-  override _getPolygonConfiguration(): PointSourcePolygon.Config;
+  override _getPolygonConfiguration(): PointSoundSource.PolygonConfig;
 
   /**
    * Get the effective volume at which an AmbientSound source should be played for a certain listener.
+   * @remarks If `listener` is falsey, returns `0`. If `options.easing` is falsey, returns `1`
    */
-  getVolumeMultiplier(
-    listener: Canvas.Point,
-    options?: NullishProps<{
-      /** If no easing, return `1` */
-      easing: boolean;
-    }>,
-  ): number;
+  getVolumeMultiplier(listener?: Canvas.Point | null, options?: PointSoundSource.GetVolumeMultiplierOptions): number;
 }
 
 declare namespace PointSoundSource {
-  type AnyConstructor = typeof AnyPointSoundSource;
+  interface Any extends AnyPointSoundSource {}
+  interface AnyConstructor extends Identity<typeof AnyPointSoundSource> {}
+
+  /** @internal */
+  type _GetVolumeMultiplierOptions = NullishProps<{
+    /**
+     * @defaultValue `true`
+     * @remarks If `false`, return `1`
+     */
+    easing: boolean;
+  }>;
+
+  interface GetVolumeMultiplierOptions extends _GetVolumeMultiplierOptions {}
+
+  interface SourceData extends PointEffectSourceMixin.MixedSourceData {}
+
+  interface PolygonConfig extends RequiredProps<PointEffectSourceMixin.PolygonConfig, "useThreshold"> {}
 
-  type SourceData = PointEffectSourceMixin.MixedSourceData;
+  type ConfiguredClass = CONFIG["Canvas"]["soundSourceClass"];
+  type ConfiguredInstance = FixedInstanceType<ConfiguredClass>;
 }
 
-declare abstract class AnyPointSoundSource extends PointSoundSource {
-  constructor(arg0: never, ...args: never[]);
+declare abstract class AnyPointSoundSource extends PointSoundSource<PointSoundSource.SourceData, PointSourcePolygon> {
+  constructor(...args: never);
 }
 
 export default PointSoundSource;