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

package/src/foundry/client-esm/canvas/smaa/smaa.d.mts

@@ -1,55 +1,154 @@
-import type { CLEAR_MODES, FilterState, FilterSystem, RenderTexture } from "pixi.js";
-
-import type { InexactPartial } from "fvtt-types/utils";
+import type { Brand, InexactPartial } from "fvtt-types/utils";
 
 declare class SMAAFilter extends PIXI.Filter {
   /**
-   * @param config    - The config (defaults: SMAAFilter.PRESETS.DEFAULT)
+   * @param config - The config
+   * @remarks The one place Foundry makes one of these it passes no config
+   * @privateRemarks Foundry references `SMAAFilter.PRESETS.DEFAULT` as the default values for `config`,
+   * but that key does not exist in 12.331 or 11.315, and appears to just be a docs error.
    */
-  constructor(config?: InexactPartial<SMAAFilter.SMAAFilterConfig>);
+  // config: not null (destructured)
+  constructor(config?: SMAAFilter.ConstructorOptions);
 
   // a placeholder private method to help subclassing
   #smaaFilter: true;
 
   /**
    * The presets.
+   * @remarks Unused in 12.331
    */
-  static get PRESETS(): Record<string, SMAAFilter.SMAAFilterConfig>;
+  static get PRESETS(): SMAAFilter.Presets;
 
   override apply(
-    filterManager: FilterSystem,
-    input: RenderTexture,
-    output: RenderTexture,
-    clearMode: CLEAR_MODES | undefined,
-    currentState: FilterState,
+    filterManager: PIXI.FilterSystem,
+    input: PIXI.RenderTexture,
+    output: PIXI.RenderTexture,
+    clearMode: PIXI.CLEAR_MODES | undefined,
+    currentState: PIXI.FilterState,
   ): void;
 }
 
 declare namespace SMAAFilter {
-  interface SMAAFilterConfig {
-    /** Specifies the threshold or sensitivity to edges. Lowering this value you will be able to detect more edges at the expense of performance. Range: [0, 0.5]. 0.1 is a reasonable value, and allows to catch most visible edges. 0.05 is a rather overkill value, that allows to catch 'em all. */
+  interface Any extends AnySMAAFilter {}
+  type AnyConstructor = typeof AnySMAAFilter;
+
+  type PRESETS = Brand<Config, "SMAAFilter.PRESETS">;
+
+  interface Presets {
+    LOW: {
+      threshold: 0.15;
+      localContrastAdaptionFactor: 2.0;
+      maxSearchSteps: 4;
+      maxSearchStepsDiag: 0;
+      cornerRounding: 0;
+      disableDiagDetection: true;
+      disableCornerDetection: true;
+    } & PRESETS;
+    MEDIUM: {
+      threshold: 0.1;
+      localContrastAdaptionFactor: 2.0;
+      maxSearchSteps: 8;
+      maxSearchStepsDiag: 0;
+      cornerRounding: 0;
+      disableDiagDetection: true;
+      disableCornerDetection: true;
+    } & PRESETS;
+    HIGH: {
+      threshold: 0.1;
+      localContrastAdaptionFactor: 2.0;
+      maxSearchSteps: 16;
+      maxSearchStepsDiag: 8;
+      cornerRounding: 25;
+      disableDiagDetection: false;
+      disableCornerDetection: false;
+    } & PRESETS;
+    ULTRA: {
+      threshold: 0.05;
+      localContrastAdaptionFactor: 2.0;
+      maxSearchSteps: 32;
+      maxSearchStepsDiag: 16;
+      cornerRounding: 25;
+      disableDiagDetection: false;
+      disableCornerDetection: false;
+    } & PRESETS;
+  }
+
+  interface Config {
+    /**
+     * Specifies the threshold or sensitivity to edges. Lowering this value you will be able to detect more
+     * edges at the expense of performance.
+     *
+     * Range: [0, 0.5].
+     *
+     * 0.1 is a reasonable value, and allows to catch
+     * most visible edges. 0.05 is a rather overkill value, that allows to catch 'em all.
+     * @defaultValue `0.1`
+     * @remarks Can't be `null` as it only has a parameter default
+     */
     threshold: number;
 
-    /** If there is an neighbor edge that has SMAA_LOCAL_CONTRAST_FACTOR times bigger contrast than current edge, current edge will be discarded.
-     *  This allows to eliminate spurious crossing edges, and is based on the fact that, if there is too much contrast in a direction, that will hide perceptually contrast in the other neighbors.
+    /**
+     * If there is an neighbor edge that has SMAA_LOCAL_CONTRAST_FACTOR times bigger contrast than current
+     * edge, current edge will be discarded. This allows to eliminate spurious crossing edges, and is based
+     * on the fact that, if there is too much contrast in a direction, that will hide perceptually contrast
+     * in the other neighbors.
+     * @defaultValue `2.0`
+     * @remarks Can't be `null` as it only has a parameter default
      */
     localContrastAdaptionFactor: number;
 
-    /** Specifies the maximum steps performed in the horizontal/vertical pattern searches, at each side of the pixel. In number of pixels, it's actually the double. So the maximum line length perfectly handled by, for example 16, is 64 (by perfectly, we meant that longer lines won't look as good, but still antialiased. Range: [0, 112]. */
+    /**
+     * Specifies the maximum steps performed in the horizontal/vertical pattern searches, at each side of the
+     * pixel. In number of pixels, it's actually the double. So the maximum line length perfectly handled by,
+     * for example 16, is 64 (by perfectly, we meant that longer lines won't look as good, but still antialiased).
+     *
+     * Range: [0, 112].
+     * @defaultValue `16`
+     * @remarks Can't be `null` as it only has a parameter default
+     */
     maxSearchSteps: number;
 
-    /** Specifies the maximum steps performed in the diagonal pattern searches, at each side of the pixel. In this case we jump one pixel at time, instead of two. Range: [0, 20]. */
+    /**
+     * Specifies the maximum steps performed in the diagonal pattern searches, at each side of the pixel. In this
+     * case we jump one pixel at time, instead of two.
+     *
+     * Range: [0, 20].
+     * @defaultValue `8`
+     * @remarks Can't be `null` as it only has a parameter default
+     */
     maxSearchStepsDiag: number;
 
-    /** Specifies how much sharp corners will be rounded. Range: [0, 100]. */
+    /**
+     * Specifies how much sharp corners will be rounded.
+     *
+     * Range: [0, 100].
+     * @defaultValue `25`
+     * @remarks Can't be `null` as it only has a parameter default
+     */
     cornerRounding: number;
 
-    /** Is diagonal detection disabled? */
+    /**
+     * Is diagonal detection disabled?
+     * @defaultValue `false`
+     * @remarks Can't be `null` as it only has a parameter default
+     */
     disableDiagDetection: boolean;
 
-    /** Is corner detection disabled? */
+    /**
+     * Is corner detection disabled?
+     * @defaultValue `false`
+     * @remarks Can't be `null` as it only has a parameter default
+     */
     disableCornerDetection: boolean;
   }
+
+  type _ConstructorOptions = InexactPartial<Config>;
+
+  interface ConstructorOptions extends _ConstructorOptions {}
+}
+
+declare abstract class AnySMAAFilter extends SMAAFilter {
+  constructor(...args: never);
 }
 
 export default SMAAFilter;

package/src/foundry/client-esm/canvas/smaa/weights.d.mts

@@ -1,6 +1,29 @@
+import type { Identity, IntentionalPartial, RequiredProps } from "fvtt-types/utils";
+
 /**
- * The neighborhood blending filter for {@link foundry.canvas.SMAAFilter}.
+ * The blending weight calculation filter for {@link foundry.canvas.SMAAFilter | `foundry.canvas.SMAAFilter`}.
  */
-export default class SMAANeighborhoodBlendingFilter extends PIXI.Filter {
-  constructor();
+declare class SMAABWeightCalculationFilter extends PIXI.Filter {
+  constructor(config: SMAABWeightCalculationFilter.Config);
 }
+
+declare namespace SMAABWeightCalculationFilter {
+  interface Any extends AnySMAABWeightCalculationFilter {}
+  interface AnyConstructor extends Identity<typeof AnySMAABWeightCalculationFilter> {}
+
+  type Config = RequiredProps<
+    IntentionalPartial<foundry.canvas.SMAAFilter.Config>,
+    | "maxSearchSteps"
+    | "threshold"
+    | "maxSearchStepsDiag"
+    | "cornerRounding"
+    | "disableCornerDetection"
+    | "disableDiagDetection"
+  >;
+}
+
+declare abstract class AnySMAABWeightCalculationFilter extends SMAABWeightCalculationFilter {
+  constructor(...args: never);
+}
+
+export default SMAABWeightCalculationFilter;

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

@@ -1,4 +1,4 @@
-import type { NullishProps, IntentionalPartial } from "fvtt-types/utils";
+import type { NullishProps, IntentionalPartial, AnyObject, Identity } from "fvtt-types/utils";
 
 /**
  * TODO - Re-document after ESM refactor.
@@ -23,28 +23,31 @@ declare abstract class BaseEffectSource<
    * @param options - Options which modify the base effect source instance
    * @remarks Passing a PlaceableObject is deprecated, and will be removed in v13
    */
-  constructor(options?: BaseEffectSource.SourceOptions | PlaceableObject);
+  // not null (property access)
+  constructor(options?: BaseEffectSource.ConstructorOptions | PlaceableObject);
 
   /**
    * The type of source represented by this data structure.
    * Each subclass must implement this attribute.
+   * @remarks Effectively abstract, must be defined by subclasses; `undefined` in `BaseEffectSource`
    */
-  static sourceType: string;
+  static sourceType: string | undefined;
 
   /**
    * The target collection into the effects canvas group.
+   * @remarks Foundry marked `@abstract`; Is `undefined` in `BaseEffectSource`
    */
-  static effectsCollection: string;
+  static effectsCollection: string | undefined;
 
   /**
    * Effect source default data.
    * @defaultValue
    * ```js
    * {
-   * x: 0,
-   * y: 0,
-   * elevation: 0,
-   * disabled: false
+   *   x: 0,
+   *   y: 0,
+   *   elevation: 0,
+   *   disabled: false
    * }
    * ```
    */
@@ -52,7 +55,7 @@ declare abstract class BaseEffectSource<
 
   /**
    * Some other object which is responsible for this source.
-   * @privateRemarks In Foundry practice this appears to only ever be `null`, `Token.ConfiguredInstance`, or `EffectsCanvasGroup` in v12
+   * @privateRemarks In Foundry practice this appears to only ever be `null`, `Token.Implementation`, or `EffectsCanvasGroup` in v12
    */
   object: PlaceableObject.Any | CanvasGroupMixin.AnyMixed | null;
 
@@ -69,14 +72,15 @@ declare abstract class BaseEffectSource<
 
   /**
    * The geometric shape of the effect source which is generated later.
-   * @remarks This only isn't `undefined` in subclasses implementing `_createShapes()`, usually via {@link PointEffectSourceMixin}
+   * @remarks This only isn't `undefined` in subclasses implementing `_createShapes()`, usually via {@link foundry.canvas.sources.PointEffectSourceMixin | `PointEffectSourceMixin`}
    */
   shape: SourceShape | undefined;
 
   /**
    * A collection of boolean flags which control rendering and refresh behavior for the source.
+   * @defaultValue `{}`
    */
-  protected _flags: Record<string, boolean | number>;
+  protected _flags: BaseEffectSource.Flags;
 
   /**
    * The x-coordinate of the point source origin.
@@ -123,6 +127,7 @@ declare abstract class BaseEffectSource<
   /**
    * Records of suppression strings with a boolean value.
    * If any of this record is true, the source is suppressed.
+   * @defaultValue `{}`
    */
   suppression: Record<string, boolean>;
 
@@ -132,39 +137,34 @@ declare abstract class BaseEffectSource<
    * @param options - Additional options which modify source initialization
    * @returns The initialized source
    */
-  initialize(
-    data?: NullishProps<SourceData>,
-    /** @privateRemarks Foundry describes an `options.behaviors` key, but it is neither checked for nor used at runtime */
-    options?: NullishProps<{
-      /**
-       * Should source data be reset to default values before applying changes?
-       * @defaultValue `false`
-       */
-      reset: boolean;
-    }>,
-  ): this;
+  // options: not null (destructured)
+  initialize(data?: NullishProps<SourceData> | null, options?: BaseEffectSource.InitializeOptions): this;
 
   /**
    * Subclass specific data initialization steps.
    * @param data - Provided data for configuration
+   * @remarks Not actually `abstract`, but a is a no-op in `BaseEffectSource`
    */
-  _initialize(
-    /** @remarks IntentionalPartial because `this.initialize` has filtered invalid keys and replaced any nullish values before calling this */
+  protected _initialize(
+    /** @privateRemarks `IntentionalPartial` because `#initialize` has filtered invalid keys and replaced any nullish values before calling this */
     data: IntentionalPartial<SourceData>,
   ): void;
 
-  /**
-   * Create the polygon shape (or shapes) for this source using configured data.
-   */
-  protected _createShapes(): void;
+  /** Create the polygon shape (or shapes) for this source using configured data. */
+  protected abstract _createShapes(): void;
 
   /**
    * Subclass specific configuration steps. Occurs after data initialization and shape computation.
    * Only called if the source is attached and not disabled.
    * @param changes - Changes to the source data which were applied
-   * @remarks This is actually passed *flattened* partial data
+   * @remarks Not actually abstract, but is a no-op in `BaseEffectSource`
+   * @privateRemarks This is actually passed *flattened* partial data, and while we were very close to having
+   * that be a non-issue, `RenderedEffectSource`'s data's `animation` and `GlobalLightSource`'s `darkness`
+   * properties are objects, so this can't just be `IntentionalPartial<SourceData>` until we have a `Flatten<>`
+   * type.
    */
-  protected _configure(changes: IntentionalPartial<SourceData>): void;
+  // TODO: Flatten<IntentionalPartial<SourceData>>
+  protected _configure(changes: AnyObject): void;
 
   /**
    * Refresh the state and uniforms of the source.
@@ -207,7 +207,7 @@ declare abstract class BaseEffectSource<
    * @deprecated since v12, will be removed in v14
    * @remarks `"BaseEffectSource#_createShape is deprecated in favor of BaseEffectSource#_createShapes."`
    */
-  _createShape(): void;
+  protected _createShape(): void;
 
   /**
    * @deprecated since v12, will be removed in v14
@@ -217,22 +217,26 @@ declare abstract class BaseEffectSource<
 }
 
 declare namespace BaseEffectSource {
-  type AnyConstructor = typeof AnyBaseEffectSource;
+  interface Any extends AnyBaseEffectSource {}
+  interface AnyConstructor extends Identity<typeof AnyBaseEffectSource> {}
 
   /** @internal */
-  type _SourceOptions = NullishProps<{
+  type _ConstructorOptions = NullishProps<{
     /**
      * An optional PlaceableObject which is responsible for this source
+     * @remarks Only the global light source is passed the ECG
      */
-    object: PlaceableObject;
+    object: PlaceableObject.Any | EffectsCanvasGroup.Any;
   }>;
 
-  interface SourceOptions extends _SourceOptions {
+  interface ConstructorOptions extends _ConstructorOptions {
     /**
      * A unique ID for this source. This will be set automatically if an
      * object is provided, otherwise is required.
-     * @remarks The above is misleading; sourceId will *not* be inferred if you pass in `{object: PlaceableObject}`,
-     * only if you pass a `PlaceableObject` *instead* of an options object to the constructor.
+     * @remarks The above is misleading; sourceId will only be inferred if you pass a `PlaceableObject`
+     * _instead_ of an options object to the constructor (which is a deprecated path removed in v13),
+     * _not_ if you pass in `{ object: PlaceableObject }`, where you're expected to also pass `sourceId`
+     * yourself.
      */
     sourceId?: string;
   }
@@ -240,25 +244,51 @@ declare namespace BaseEffectSource {
   interface SourceData {
     /**
      * The x-coordinate of the source location
+     * @defaultValue `0`
      */
     x: number;
+
     /**
      * The y-coordinate of the source location
+     * @defaultValue `0`
      */
     y: number;
+
     /**
      * The elevation of the point source
+     * @defaultValue `0`
      */
     elevation: number;
+
     /**
      * Whether or not the source is disabled
+     * @defaultValue `false`
      */
     disabled: boolean;
   }
+
+  /** @internal */
+  type _InitializeOptions = NullishProps<{
+    /**
+     * Should source data be reset to default values before applying changes?
+     * @defaultValue `false`
+     */
+    reset: boolean;
+  }>;
+
+  /** @privateRemarks Foundry describes an `options.behaviors` key, but it is neither checked for nor used at runtime */
+  interface InitializeOptions extends _InitializeOptions {}
+
+  /** @privateRemarks The `| number` is from Foundry's typing, but core only uses boolean flags in v12.331 */
+  interface Flags extends Record<string, boolean | number | undefined> {
+    renderSoftEdges?: boolean;
+    initializedMeshes?: boolean;
+    hasColor?: boolean;
+  }
 }
 
-declare abstract class AnyBaseEffectSource extends BaseEffectSource<any, any> {
-  constructor(arg0: never, ...args: never[]);
+declare abstract class AnyBaseEffectSource extends BaseEffectSource<BaseEffectSource.SourceData, PIXI.Polygon> {
+  constructor(...args: never);
 }
 
 export default BaseEffectSource;

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

@@ -1,4 +1,4 @@
-import type { InexactPartial, IntentionalPartial } from "fvtt-types/utils";
+import type { Identity, IntentionalPartial, NullishProps } from "fvtt-types/utils";
 import type RenderedEffectSource from "./rendered-effect-source.d.mts";
 
 /**
@@ -32,8 +32,10 @@ declare abstract class BaseLightSource<
 
   /**
    * The corresponding animation config.
-   * @remarks More broad than it should be to accomodate {@link foundry.canvas.sources.PointDarknessSource}
-   * TODO: Reevaluate after CONFIG has been gone over
+   * @privateRemarks Only uses {@link CONFIG.Canvas.lightAnimations | `CONFIG.Canvas.lightAnimations`} in
+   * {@link foundry.canvas.sources.BaseLightSource | `foundry.canvas.sources.BaseLightSource`}, but
+   * {@link foundry.canvas.sources.PointDarknessSource | `foundry.canvas.sources.PointDarknessSource`}
+   * overrides to use `.darknessAnimations`, so the union type is necessary
    */
   protected static get ANIMATIONS(): typeof CONFIG.Canvas.lightAnimations | typeof CONFIG.Canvas.darknessAnimations;
 
@@ -41,18 +43,18 @@ declare abstract class BaseLightSource<
    * @defaultValue
    * ```js
    * {
-   * ...super.defaultData,
-   * priority: 0,
-   * alpha: 0.5,
-   * bright: 0,
-   * coloration: 1,
-   * contrast: 0,
-   * dim: 0,
-   * attenuation: 0.5,
-   * luminosity: 0.5,
-   * saturation: 0,
-   * shadows: 0,
-   * vision: false
+   *   ...super.defaultData,
+   *   priority: 0,
+   *   alpha: 0.5,
+   *   bright: 0,
+   *   coloration: 1,
+   *   contrast: 0,
+   *   dim: 0,
+   *   attenuation: 0.5,
+   *   luminosity: 0.5,
+   *   saturation: 0,
+   *   shadows: 0,
+   *   vision: false
    * }
    * ```
    */
@@ -63,27 +65,28 @@ declare abstract class BaseLightSource<
    */
   ratio: number;
 
-  override _initialize(data: IntentionalPartial<SourceData>): void;
+  protected override _initialize(data: IntentionalPartial<SourceData>): void;
 
-  override _updateColorationUniforms(): void;
+  protected override _updateColorationUniforms(): void;
 
-  override _updateIlluminationUniforms(): void;
+  protected override _updateIlluminationUniforms(): void;
 
-  override _updateBackgroundUniforms(): void;
+  protected override _updateBackgroundUniforms(): void;
 
-  override _updateCommonUniforms(shader: AbstractBaseShader): void;
+  protected override _updateCommonUniforms(shader: AbstractBaseShader): void;
 
-  /** @remarks This property is undocumented, and only defined during `_updateCommonUniforms` */
-  cachededAttentuation?: number;
+  /** @remarks Doesn't exist prior to initialization. Ultimately set in `_updateCommonUniforms` */
+  cachedAttenuation?: number;
 
-  /** @remarks This property is undocumented, and only defined during `_updateCommonUniforms` */
-  computedAttentuation?: number;
+  /** @remarks Doesn't exist prior to initialization. Ultimately set in `_updateCommonUniforms` */
+  computedAttenuation?: number;
 
   /**
    * An animation with flickering ratio and light intensity.
    * @param dt      - Delta time
    * @param options - Additional options which modify the torch animation
    */
+  // not null (destructured)
   animateTorch(dt: number, options?: RenderedEffectSource.AnimationFunctionOptions): void;
 
   /**
@@ -91,21 +94,13 @@ declare abstract class BaseLightSource<
    * @param dt      - Delta time
    * @param options - Additional options which modify the flame animation
    */
-  animateFlickering(
-    dt: number,
-    options?: RenderedEffectSource.AnimationFunctionOptions &
-      InexactPartial<{
-        /**
-         * Noise amplification (\>1) or dampening (\<1)
-         * @defaultValue `1`
-         */
-        amplification: number;
-      }>,
-  ): void;
+  // not null (destructured)
+  animateFlickering(dt: number, options?: BaseLightSource.AnimateFlickeringOptions): void;
 
   /**
-   * @remarks This property will be generated on any class that is `animateFlickering`'s `this` when it is called.
-   * Foundry does not document it.
+   * @remarks This property will be generated on any class that is `#animateFlickering`'s `this` when it is called.
+   * In Foundry practice this will always be a `BaseLightSource` subclass, so it's defined here. Foundry does not
+   * document it.
    */
   _noise?: SmoothNoise;
 
@@ -114,17 +109,21 @@ declare abstract class BaseLightSource<
    * @param dt      - Delta time
    * @param options - Additional options which modify the pulse animation
    */
+  // not null (destructured)
   animatePulse(dt: number, options?: RenderedEffectSource.AnimationFunctionOptions): void;
 
   /**
    * @deprecated since v12, until v14
    * @remarks "BaseLightSource#isDarkness is now obsolete. Use DarknessSource instead."
+   *
+   * Always returns `false`
    */
   get isDarkness(): boolean;
 }
 
 declare namespace BaseLightSource {
-  type AnyConstructor = typeof AnyBaseLightSource;
+  interface Any extends AnyBaseLightSource {}
+  interface AnyConstructor extends Identity<typeof AnyBaseLightSource> {}
 
   type LightAnimationFunction = (
     this: BaseLightSource,
@@ -135,63 +134,90 @@ declare namespace BaseLightSource {
   interface SourceData extends RenderedEffectSource.SourceData {
     /**
      * An opacity for the emitted light, if any
+     * @defaultValue `0.5`
      */
     alpha: number;
 
     /**
      * The allowed radius of bright vision or illumination
+     * @defaultValue `0`
      */
     bright: number;
 
     /**
      * The coloration technique applied in the shader
+     * @defaultValue `1`
      */
     coloration: number;
 
     /**
      * The amount of contrast this light applies to the background texture
+     * @defaultValue `0`
      */
     contrast: number;
 
     /**
      * The allowed radius of dim vision or illumination
+     * @defaultValue `0`
      */
     dim: number;
 
     /**
      * Strength of the attenuation between bright, dim, and dark
+     * @defaultValue `0.5`
      */
     attenuation: number;
 
     /**
      * The luminosity applied in the shader
+     * @defaultValue `0.5`
      */
     luminosity: number;
 
     /**
      * The amount of color saturation this light applies to the background texture
+     * @defaultValue `0`
      */
     saturation: number;
 
     /**
      * The depth of shadows this light applies to the background texture
+     * @defaultValue `0`
      */
     shadows: number;
 
     /**
      * Whether or not this source provides a source of vision
+     * @defaultValue `false`
      */
     vision: boolean;
 
     /**
      * Strength of this source to beat or not negative/positive sources
+     * @defaultValue `0`
      */
     priority: number;
   }
+
+  /** @internal */
+  type _AnimateFlickeringOptions = NullishProps<{
+    /**
+     * Noise amplification (\>1) or dampening (\<1)
+     * @defaultValue `1`
+     * @remarks Parameter default only, `null` is only cast to `0`
+     */
+    amplification: number;
+  }>;
+
+  interface AnimateFlickeringOptions extends RenderedEffectSource.AnimationFunctionOptions, _AnimateFlickeringOptions {}
 }
 
-declare abstract class AnyBaseLightSource extends BaseLightSource {
-  constructor(arg0: never, ...args: never[]);
+declare abstract class AnyBaseLightSource extends BaseLightSource<
+  BaseLightSource.SourceData,
+  PIXI.Polygon,
+  RenderedEffectSource.Layers
+> {
+  constructor(...args: never);
 }
 
 export default BaseLightSource;