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

package/src/foundry/client/pixi/webgl/shaders/filters/transition.d.mts

@@ -1,49 +1,19 @@
-import type { InexactPartial, ValueOf } from "../../../../../../types/utils.d.mts";
-
-declare abstract class AnyTextureTransitionFilter extends TextureTransitionFilter {
-  constructor(arg0: never, ...args: never[]);
-}
+import type { Brand, InexactPartial } from "fvtt-types/utils";
 
 declare global {
-  namespace TextureTransitionFilter {
-    type AnyConstructor = typeof AnyTextureTransitionFilter;
-
-    /**
-     * @privateRemarks types are literals and not `string` to make the `type` getter and setter typings work
-     */
-    interface TYPES {
-      FADE: "fade";
-      SWIRL: "swirl";
-      WATER_DROP: "waterDrop";
-      MORPH: "morph";
-      CROSSHATCH: "crosshatch";
-      WIND: "wind";
-      WAVES: "waves";
-      WHITE_NOISE: "whiteNoise";
-      HOLOGRAM: "hologram";
-      HOLE: "hole";
-      HOLE_SWIRL: "holeSwirl";
-      GLITCH: "glitch";
-      DOTS: "dots";
-    }
-  }
-
   /**
    * A filter specialized for transition effects between a source object and a target texture.
    */
   class TextureTransitionFilter extends AbstractBaseFilter {
-    /**
-     * Transition types for this shader.
-     */
-    static get TYPES(): TextureTransitionFilter.TYPES;
+    static get TYPES(): TextureTransitionFilter.Types;
 
     /**
      * The transition type (see {@link TextureTransitionFilter.TYPES}).
      * @defaultValue TYPES.FADE
      */
-    get type(): ValueOf<TextureTransitionFilter.TYPES>;
+    get type(): TextureTransitionFilter.TYPES;
 
-    set type(type: ValueOf<TextureTransitionFilter.TYPES>);
+    set type(type);
 
     /**
      * Sampler target for this filter.
@@ -61,30 +31,7 @@ declare global {
     static animate(
       subject: PIXI.Sprite | SpriteMesh,
       texture: PIXI.Texture,
-      options?: InexactPartial<{
-        /**
-         * The transition type
-         * @defaultValue `TYPES.FADE`
-         */
-        type: ValueOf<TextureTransitionFilter.TYPES>;
-
-        /**
-         * The name of the {@link CanvasAnimation}.
-         */
-        name: string | symbol;
-
-        /**
-         * The animation duration
-         * @defaultValue 1000
-         * @remarks this function does not provide a default, but CanvasAnimation.animate does
-         */
-        duration: number;
-
-        /**
-         * The easing function of the animation
-         */
-        easing: CanvasAnimation.EasingFunction;
-      }>,
+      options?: TextureTransitionFilter.AnimateOptions,
     ): Promise<boolean>;
 
     /**
@@ -116,4 +63,64 @@ declare global {
       clearMode?: PIXI.CLEAR_MODES,
     ): void;
   }
+
+  namespace TextureTransitionFilter {
+    interface Any extends AnyTextureTransitionFilter {}
+    type AnyConstructor = typeof AnyTextureTransitionFilter;
+
+    type TYPES = Brand<string, "TextureTransitionFilter.TYPES">;
+
+    /**
+     * Transition types for this shader.
+     */
+    interface Types {
+      readonly FADE: "fade" & TextureTransitionFilter.TYPES;
+      readonly SWIRL: "swirl" & TextureTransitionFilter.TYPES;
+      readonly WATER_DROP: "waterDrop" & TextureTransitionFilter.TYPES;
+      readonly MORPH: "morph" & TextureTransitionFilter.TYPES;
+      readonly CROSSHATCH: "crosshatch" & TextureTransitionFilter.TYPES;
+      readonly WIND: "wind" & TextureTransitionFilter.TYPES;
+      readonly WAVES: "waves" & TextureTransitionFilter.TYPES;
+      readonly WHITE_NOISE: "whiteNoise" & TextureTransitionFilter.TYPES;
+      readonly HOLOGRAM: "hologram" & TextureTransitionFilter.TYPES;
+      readonly HOLE: "hole" & TextureTransitionFilter.TYPES;
+      readonly HOLE_SWIRL: "holeSwirl" & TextureTransitionFilter.TYPES;
+      readonly GLITCH: "glitch" & TextureTransitionFilter.TYPES;
+      readonly DOTS: "dots" & TextureTransitionFilter.TYPES;
+    }
+
+    /** @internal */
+    type _AnimateOptions = InexactPartial<{
+      /**
+       * The transition type
+       * @defaultValue `TYPES.FADE`
+       * @remarks Can't be null because it only has a signature-provided default.
+       */
+      type: TextureTransitionFilter.TYPES;
+
+      /**
+       * The name of the {@link CanvasAnimation}.
+       * @remarks All use of `name` in `CanvasAnimation.animate` is predicated on `if (name)`, so null should be equivalent to leaving it off.
+       */
+      name: PropertyKey | null;
+
+      /**
+       * The animation duration
+       * @defaultValue `1000`
+       * @remarks This function does not provide a default, but CanvasAnimation.animate does. Can't be null beause that default is only signature-provided.
+       */
+      duration: number;
+
+      /**
+       * The easing function of the animation
+       */
+      easing: CanvasAnimation.EasingFunction | null;
+    }>;
+
+    interface AnimateOptions extends _AnimateOptions {}
+  }
+}
+
+declare abstract class AnyTextureTransitionFilter extends TextureTransitionFilter {
+  constructor(arg0: never, ...args: never[]);
 }

package/src/foundry/client/pixi/webgl/shaders/filters/visibility.d.mts

@@ -1,18 +1,6 @@
-import type { InexactPartial } from "../../../../../../types/utils.d.mts";
-
-declare abstract class AnyVisibilityFilter extends VisibilityFilter {
-  constructor(arg0: never, ...args: never[]);
-}
+import type { FixedInstanceType, NullishProps } from "fvtt-types/utils";
 
 declare global {
-  namespace VisibilityFilter {
-    type AnyConstructor = typeof AnyVisibilityFilter;
-
-    interface FragmentShaderOptions {
-      persistentVision: boolean;
-    }
-  }
-
   /**
    * Apply visibility coloration according to the baseLine color.
    * Uses very lightweight gaussian vertical and horizontal blur filter passes.
@@ -40,12 +28,12 @@ declare global {
     static override create<ThisType extends AbstractBaseFilter.AnyConstructor>(
       this: ThisType,
       initiaUniforms?: AbstractBaseShader.Uniforms,
-      options?: InexactPartial<VisibilityFilter.FragmentShaderOptions>,
-    ): InstanceType<ThisType>;
+      options?: VisibilityFilter.FragmentShaderOptions,
+    ): FixedInstanceType<ThisType>;
 
     static override vertexShader: string;
 
-    static override fragmentShader(options: InexactPartial<VisibilityFilter.FragmentShaderOptions>): string;
+    static override fragmentShader(options: VisibilityFilter.FragmentShaderOptions): string;
 
     /**
      * Set the blur strength
@@ -67,4 +55,20 @@ declare global {
      */
     calculateMatrix(filterManager: PIXI.FilterSystem): void;
   }
+
+  namespace VisibilityFilter {
+    interface Any extends AnyVisibilityFilter {}
+    type AnyConstructor = typeof AnyVisibilityFilter;
+
+    /** @internal */
+    type _FragmentShaderOptions = NullishProps<{
+      persistentVision: boolean;
+    }>;
+
+    interface FragmentShaderOptions extends _FragmentShaderOptions {}
+  }
+}
+
+declare abstract class AnyVisibilityFilter extends VisibilityFilter {
+  constructor(arg0: never, ...args: never[]);
 }

package/src/foundry/client/pixi/webgl/shaders/filters/vision-mask-filter.d.mts

@@ -1,14 +1,6 @@
-export {};
-
-declare abstract class AnyVisionMaskFilter extends VisionMaskFilter {
-  constructor(arg0: never, ...args: never[]);
-}
+import type { FixedInstanceType } from "fvtt-types/utils";
 
 declare global {
-  namespace VisionMaskFilter {
-    type AnyConstructor = typeof AnyVisionMaskFilter;
-  }
-
   class VisionMaskFilter extends AbstractBaseMaskFilter {
     static override fragmentShader: string;
 
@@ -22,7 +14,9 @@ declare global {
      */
     static override defaultUniforms: AbstractBaseShader.Uniforms;
 
-    static override create<ThisType extends AbstractBaseFilter.AnyConstructor>(this: ThisType): InstanceType<ThisType>;
+    static override create<ThisType extends AbstractBaseFilter.AnyConstructor>(
+      this: ThisType,
+    ): FixedInstanceType<ThisType>;
 
     /**
      * @remarks This is set as a property all the way up in PIXI.Filter, however Foundry has it
@@ -30,4 +24,13 @@ declare global {
      */
     override readonly enabled: boolean;
   }
+
+  namespace VisionMaskFilter {
+    interface Any extends AnyVisionMaskFilter {}
+    type AnyConstructor = typeof AnyVisionMaskFilter;
+  }
+}
+
+declare abstract class AnyVisionMaskFilter extends VisionMaskFilter {
+  constructor(arg0: never, ...args: never[]);
 }

package/src/foundry/client/pixi/webgl/shaders/filters/void.d.mts

@@ -1,18 +1,19 @@
 export {};
 
-declare abstract class AnyVoidFilter extends VoidFilter {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace VoidFilter {
-    type AnyConstructor = typeof AnyVoidFilter;
-  }
-
   /**
    * A minimalist filter (just used for blending)
    */
   class VoidFilter extends AbstractBaseFilter {
     static override fragmentShader: string;
   }
+
+  namespace VoidFilter {
+    interface Any extends AnyVoidFilter {}
+    type AnyConstructor = typeof AnyVoidFilter;
+  }
+}
+
+declare abstract class AnyVoidFilter extends VoidFilter {
+  constructor(arg0: never, ...args: never[]);
 }

package/src/foundry/client/pixi/webgl/shaders/filters/weather-occlusion-masks.d.mts

@@ -1,14 +1,6 @@
 export {};
 
-declare abstract class AnyWeatherOcclusionMaskFilter extends WeatherOcclusionMaskFilter {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace WeatherOcclusionMaskFilter {
-    type AnyConstructor = typeof AnyWeatherOcclusionMaskFilter;
-  }
-
   /**
    * The filter used by the weather layer to mask weather above occluded roofs.
    * @see {@link WeatherEffects}
@@ -53,4 +45,13 @@ declare global {
       currentState: PIXI.FilterState,
     ): void;
   }
+
+  namespace WeatherOcclusionMaskFilter {
+    interface Any extends AnyWeatherOcclusionMaskFilter {}
+    type AnyConstructor = typeof AnyWeatherOcclusionMaskFilter;
+  }
+}
+
+declare abstract class AnyWeatherOcclusionMaskFilter extends WeatherOcclusionMaskFilter {
+  constructor(arg0: never, ...args: never[]);
 }

package/src/foundry/client/pixi/webgl/shaders/fragment-channel-mixin.d.mts

@@ -1,8 +1,4 @@
-import type { AnyObject, Mixin, ShapeWithIndexSignature } from "../../../../../types/utils.d.mts";
-
-declare abstract class AnyAdaptiveFragmentChannel extends AdaptiveFragmentChannel {
-  constructor(arg0: never, ...args: never[]);
-}
+import type { AnyObject, FixedInstanceType, Mixin, ShapeWithIndexSignature } from "fvtt-types/utils";
 
 declare class AdaptiveFragmentChannel {
   /** @privateRemarks All mixin classses should accept anything for its constructor. */
@@ -13,12 +9,13 @@ declare class AdaptiveFragmentChannel {
    * A subclass of AdaptiveFragmentChannelMixin must implement the fragmentShader static field.
    * @defaultValue `null`
    */
-  static adaptiveFragmentShader: ((channel: AdaptiveFragmentChannel.Channel) => string) | null;
+  static adaptiveFragmentShader: ((channel: AdaptiveFragmentChannelMixin.Channel) => string) | null;
 
   /**
    * A factory method for creating the filter using its defined default values
    * @param options - Options which affect filter construction
    */
+  //TODO: See if we can get this to return the mixed shader class, as it calls `super.create()`
   static create<T extends AnyObject>({
     /**
      * A color channel to target for masking.
@@ -31,24 +28,33 @@ declare class AdaptiveFragmentChannel {
     ...uniforms
   }?: ShapeWithIndexSignature<
     T,
-    AdaptiveFragmentChannel.ConcreteCreateOptions,
+    AdaptiveFragmentChannelMixin.ConcreteCreateOptions,
     string,
     AbstractBaseShader.UniformValue
   >): PIXI.Shader | PIXI.Filter;
 }
 
 declare global {
-  namespace AdaptiveFragmentChannel {
-    type AnyConstructor = typeof AnyAdaptiveFragmentChannel;
+  /**
+   * A mixin wich decorates a shader or filter and construct a fragment shader according to a choosen channel.
+   * @param ShaderClass - The parent ShaderClass class being mixed.
+   * @returns A Shader/Filter subclass mixed with AdaptiveFragmentChannelMixin.
+   */
+  function AdaptiveFragmentChannelMixin<BaseClass extends AdaptiveFragmentChannelMixin.BaseClass>(
+    ShaderClass: BaseClass,
+  ): Mixin<typeof AdaptiveFragmentChannel, BaseClass>;
+
+  namespace AdaptiveFragmentChannelMixin {
+    /** @privateRemarks Can't extend `AnyMixedConstructor` if it's using the `BaseClass` union; `PIXI.Shader` is the parent of `Filter`, so it's used instead */
+    type AnyMixedConstructor = ReturnType<typeof AdaptiveFragmentChannelMixin<PIXI.Shader.AnyConstructor>>;
+    interface AnyMixed extends FixedInstanceType<AnyMixedConstructor> {}
+
+    type BaseClass = PIXI.Shader.AnyConstructor | PIXI.Filter.AnyConstructor;
 
     type Channel = "r" | "g" | "b";
 
     interface ConcreteCreateOptions {
-      channel?: AdaptiveFragmentChannel.Channel | undefined;
+      channel?: AdaptiveFragmentChannelMixin.Channel | undefined;
     }
   }
-
-  function AdaptiveFragmentChannelMixin<BaseClass extends PIXI.Shader.AnyConstructor | PIXI.Filter.AnyConstructor>(
-    ShaderClass: BaseClass,
-  ): Mixin<typeof AdaptiveFragmentChannel, BaseClass>;
 }

package/src/foundry/client/pixi/webgl/shaders/grid/grid.d.mts

@@ -1,14 +1,6 @@
-import type { IntentionalPartial } from "../../../../../../types/helperTypes.d.mts";
-
-declare abstract class AnyGridShader extends GridShader {
-  constructor(arg0: never, ...args: never[]);
-}
+import type { NullishProps } from "fvtt-types/utils";
 
 declare global {
-  namespace GridShader {
-    type AnyConstructor = typeof AnyGridShader;
-  }
-
   /**
    * The grid shader used by {@link GridMesh}.
    */
@@ -105,8 +97,17 @@ declare global {
     /**
      * Configure the shader.
      */
-    configure(options?: IntentionalPartial<{ style: AbstractBaseShader.UniformValue }>): void;
+    configure(options?: NullishProps<{ style: AbstractBaseShader.UniformValue }>): void;
 
     protected override _preRender: AbstractBaseShader.PreRenderFunction;
   }
+
+  namespace GridShader {
+    interface Any extends AnyGridShader {}
+    type AnyConstructor = typeof AnyGridShader;
+  }
+}
+
+declare abstract class AnyGridShader extends GridShader {
+  constructor(arg0: never, ...args: never[]);
 }

package/src/foundry/client/pixi/webgl/shaders/lighting/background-lighting.d.mts

@@ -1,14 +1,6 @@
 export {};
 
-declare abstract class AnyAdaptiveBackgroundShader extends AdaptiveBackgroundShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace AdaptiveBackgroundShader {
-    type AnyConstructor = typeof AnyAdaptiveBackgroundShader;
-  }
-
   /**
    * The default coloration shader used by standard rendering and animations
    * A fragment shader which creates a solid light source.
@@ -62,4 +54,13 @@ declare global {
      */
     get isRequired(): boolean;
   }
+
+  namespace AdaptiveBackgroundShader {
+    interface Any extends AnyAdaptiveBackgroundShader {}
+    type AnyConstructor = typeof AnyAdaptiveBackgroundShader;
+  }
+}
+
+declare abstract class AnyAdaptiveBackgroundShader extends AdaptiveBackgroundShader {
+  constructor(arg0: never, ...args: never[]);
 }

package/src/foundry/client/pixi/webgl/shaders/lighting/base-lighting.d.mts

@@ -1,35 +1,6 @@
 export {};
 
-declare abstract class AnyAdaptiveLightingShader extends AdaptiveLightingShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace AdaptiveLightingShader {
-    type AnyConstructor = typeof AnyAdaptiveLightingShader;
-
-    type TechniqueReturn = ReturnType<(typeof AdaptiveLightingShader)["getShaderTechniques"]>;
-
-    type ShaderTypes = "coloration" | "illumination" | "background" | (string & {});
-
-    interface ShaderTechnique {
-      /** The numeric identifier of the technique */
-      id: number;
-
-      /** The localization string that labels the technique */
-      label: string;
-
-      /**  The coloration shader fragment when the technique is used */
-      coloration?: string | undefined;
-
-      /** The illumination shader fragment when the technique is used */
-      illumination?: string | undefined;
-
-      /** The background shader fragment when the technique is used */
-      background?: string | undefined;
-    }
-  }
-
   /**
    * This class defines an interface which all adaptive lighting shaders extend.
    */
@@ -91,17 +62,17 @@ declare global {
     /**
      * The coloration technique coloration shader fragment
      */
-    static get COLORATION_TECHNIQUES(): AdaptiveLightingShader.TechniqueReturn;
+    static get COLORATION_TECHNIQUES(): string;
 
     /**
      * The coloration technique illumination shader fragment
      */
-    static get ILLUMINATION_TECHNIQUES(): AdaptiveLightingShader.TechniqueReturn;
+    static get ILLUMINATION_TECHNIQUES(): string;
 
     /**
      * The coloration technique background shader fragment
      */
-    static get BACKGROUND_TECHNIQUES(): AdaptiveLightingShader.TechniqueReturn;
+    static get BACKGROUND_TECHNIQUES(): string;
 
     /**
      * The adjustments made into fragment shaders
@@ -161,6 +132,7 @@ declare global {
 
     /**
      * A mapping of available coloration techniques
+     * @privateRemarks This type would have at least the `id` keys Branded if not for subclasses overriding the entries
      */
     static SHADER_TECHNIQUES: Record<string, AdaptiveLightingShader.ShaderTechnique>;
 
@@ -175,4 +147,32 @@ declare global {
      */
     getDarknessPenalty(darknessLevel: number, luminosity: number): number;
   }
+
+  namespace AdaptiveLightingShader {
+    interface Any extends AnyAdaptiveLightingShader {}
+    type AnyConstructor = typeof AnyAdaptiveLightingShader;
+
+    type ShaderTypes = "coloration" | "illumination" | "background" | (string & {});
+
+    interface ShaderTechnique {
+      /** The numeric identifier of the technique */
+      id: number;
+
+      /** The localization string that labels the technique */
+      label: string;
+
+      /**  The coloration shader fragment when the technique is used */
+      coloration?: string | undefined;
+
+      /** The illumination shader fragment when the technique is used */
+      illumination?: string | undefined;
+
+      /** The background shader fragment when the technique is used */
+      background?: string | undefined;
+    }
+  }
+}
+
+declare abstract class AnyAdaptiveLightingShader extends AdaptiveLightingShader {
+  constructor(arg0: never, ...args: never[]);
 }

package/src/foundry/client/pixi/webgl/shaders/lighting/coloration-lighting.d.mts

@@ -1,14 +1,6 @@
 export {};
 
-declare abstract class AnyAdaptiveColorationShader extends AdaptiveColorationShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace AdaptiveColorationShader {
-    type AnyConstructor = typeof AnyAdaptiveColorationShader;
-  }
-
   /**
    * The default coloration shader used by standard rendering and animations.
    * A fragment shader which creates a light source.
@@ -70,4 +62,13 @@ declare global {
      */
     get isRequired(): boolean;
   }
+
+  namespace AdaptiveColorationShader {
+    interface Any extends AnyAdaptiveColorationShader {}
+    type AnyConstructor = typeof AnyAdaptiveColorationShader;
+  }
+}
+
+declare abstract class AnyAdaptiveColorationShader extends AdaptiveColorationShader {
+  constructor(arg0: never, ...args: never[]);
 }

package/src/foundry/client/pixi/webgl/shaders/lighting/darkness-lighting.d.mts

@@ -1,14 +1,6 @@
 export {};
 
-declare abstract class AnyAdaptiveDarknessShader extends AdaptiveDarknessShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace AdaptiveDarknessShader {
-    type AnyConstructor = typeof AnyAdaptiveDarknessShader;
-  }
-
   /**
    * The default coloration shader used by standard rendering and animations.
    * A fragment shader which creates a solid light source.
@@ -70,4 +62,13 @@ declare global {
 
     static override fragmentShader: string;
   }
+
+  namespace AdaptiveDarknessShader {
+    interface Any extends AnyAdaptiveDarknessShader {}
+    type AnyConstructor = typeof AnyAdaptiveDarknessShader;
+  }
+}
+
+declare abstract class AnyAdaptiveDarknessShader extends AdaptiveDarknessShader {
+  constructor(arg0: never, ...args: never[]);
 }

package/src/foundry/client/pixi/webgl/shaders/lighting/effects/bewitching-wave.d.mts

@@ -1,22 +1,6 @@
 export {};
 
-declare abstract class AnyBewitchingWaveColorationShader extends BewitchingWaveColorationShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
-declare abstract class AnyBewitchingWaveIlluminationShader extends BewitchingWaveIlluminationShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace BewitchingWaveColorationShader {
-    type AnyConstructor = typeof AnyBewitchingWaveColorationShader;
-  }
-
-  namespace BewitchingWaveIlluminationShader {
-    type AnyConstructor = typeof AnyBewitchingWaveIlluminationShader;
-  }
-
   /**
    * Bewitching Wave animation illumination shader
    */
@@ -24,10 +8,28 @@ declare global {
     static override fragmentShader: string;
   }
 
+  namespace BewitchingWaveColorationShader {
+    interface Any extends AnyBewitchingWaveColorationShader {}
+    type AnyConstructor = typeof AnyBewitchingWaveColorationShader;
+  }
+
   /**
    * Bewitching Wave animation coloration shader
    */
   class BewitchingWaveColorationShader extends AdaptiveColorationShader {
     static override fragmentShader: string;
   }
+
+  namespace BewitchingWaveIlluminationShader {
+    interface Any extends AnyBewitchingWaveIlluminationShader {}
+    type AnyConstructor = typeof AnyBewitchingWaveIlluminationShader;
+  }
+}
+
+declare abstract class AnyBewitchingWaveColorationShader extends BewitchingWaveColorationShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare abstract class AnyBewitchingWaveIlluminationShader extends BewitchingWaveIlluminationShader {
+  constructor(arg0: never, ...args: never[]);
 }

package/src/foundry/client/pixi/webgl/shaders/lighting/effects/black-hole.d.mts

@@ -1,18 +1,19 @@
 export {};
 
-declare abstract class AnyBlackHoleDarknessShader extends BlackHoleDarknessShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace BlackHoleDarknessShader {
-    type AnyConstructor = typeof AnyBlackHoleDarknessShader;
-  }
-
   /**
    * Black Hole animation illumination shader
    */
   class BlackHoleDarknessShader extends AdaptiveDarknessShader {
     static override fragmentShader: string;
   }
+
+  namespace BlackHoleDarknessShader {
+    interface Any extends AnyBlackHoleDarknessShader {}
+    type AnyConstructor = typeof AnyBlackHoleDarknessShader;
+  }
+}
+
+declare abstract class AnyBlackHoleDarknessShader extends BlackHoleDarknessShader {
+  constructor(arg0: never, ...args: never[]);
 }