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

package/src/foundry/client/pixi/webgl/shaders/filters/effects-masking.d.mts

@@ -1,32 +1,6 @@
-import type { AnyObject,  ShapeWithIndexSignature } from "../../../../../../types/utils.d.mts";
-
-declare abstract class AnyVisualEffectsMaskingFilter extends VisualEffectsMaskingFilter {
-  constructor(arg0: never, ...args: never[]);
-}
+import type { AnyObject, Brand, FixedInstanceType, ShapeWithIndexSignature } from "fvtt-types/utils";
 
 declare global {
-  namespace VisualEffectsMaskingFilter {
-    type AnyConstructor = typeof AnyVisualEffectsMaskingFilter;
-
-    type PostProcessModes = Array<keyof VisualEffectsMaskingFilter.POST_PROCESS_TECHNIQUES>;
-
-    interface ConcreteCreateOptions {
-      postProcessModes?: PostProcessModes | undefined;
-    }
-
-    interface FILTER_MODES {
-      readonly BACKGROUND: 0;
-      readonly ILLUMINATION: 1;
-      readonly COLORATION: 2;
-    }
-
-    interface POST_PROCESS_TECHNIQUES {
-      EXPOSURE: { id: string; glsl: string };
-      CONTRAST: { id: string; glsl: string };
-      SATURATION: { id: string; glsl: string };
-    }
-  }
-
   /**
    * This filter handles masking and post-processing for visual effects.
    */
@@ -42,12 +16,17 @@ declare global {
         string,
         AbstractBaseShader.UniformValue
       >,
-    ): InstanceType<ThisType>;
+    ): FixedInstanceType<ThisType>;
 
     /**
      * Masking modes.
+     * @remarks Object is frozen
      */
-    static readonly FILTER_MODES: VisualEffectsMaskingFilter.FILTER_MODES
+    static FILTER_MODES: {
+      readonly BACKGROUND: 0 & VisualEffectsMaskingFilter.FILTER_MODES;
+      readonly ILLUMINATION: 1 & VisualEffectsMaskingFilter.FILTER_MODES;
+      readonly COLORATION: 2 & VisualEffectsMaskingFilter.FILTER_MODES;
+    };
 
     /**
      * @defaultValue
@@ -90,14 +69,17 @@ declare global {
       input: PIXI.RenderTexture,
       output: PIXI.RenderTexture,
       clear: PIXI.CLEAR_MODES,
-      currentState: PIXI.FilterState,
+      currentState?: PIXI.FilterState,
     ): void;
 
     /**
      * Filter post-process techniques.
      */
-    static POST_PROCESS_TECHNIQUES: VisualEffectsMaskingFilter.POST_PROCESS_TECHNIQUES;
-
+    static POST_PROCESS_TECHNIQUES: {
+      EXPOSURE: { id: "EXPOSURE" & VisualEffectsMaskingFilter.POST_PROCESS_TECHNIQUES_ID; glsl: string };
+      CONTRAST: { id: "CONTRAST" & VisualEffectsMaskingFilter.POST_PROCESS_TECHNIQUES_ID; glsl: string };
+      SATURATION: { id: "SATURATION" & VisualEffectsMaskingFilter.POST_PROCESS_TECHNIQUES_ID; glsl: string };
+    };
     /**
      * Memory allocations and headers for the VisualEffectsMaskingFilter
      */
@@ -118,4 +100,23 @@ declare global {
      */
     static override fragmentShader(postProcessModes?: VisualEffectsMaskingFilter.PostProcessModes): string;
   }
+
+  namespace VisualEffectsMaskingFilter {
+    interface Any extends AnyVisualEffectsMaskingFilter {}
+    type AnyConstructor = typeof AnyVisualEffectsMaskingFilter;
+
+    type PostProcessModes = Array<keyof typeof VisualEffectsMaskingFilter.POST_PROCESS_TECHNIQUES>;
+
+    interface ConcreteCreateOptions {
+      postProcessModes?: PostProcessModes | undefined;
+    }
+
+    type FILTER_MODES = Brand<number, "VisualEffectsMaskingFilter.FILTER_MODES">;
+
+    type POST_PROCESS_TECHNIQUES_ID = Brand<string, "VisualEffectsMaskingFilter.POST_PROCESS_TECHNIQUES.ID">;
+  }
+}
+
+declare abstract class AnyVisualEffectsMaskingFilter extends VisualEffectsMaskingFilter {
+  constructor(arg0: never, ...args: never[]);
 }

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

@@ -1,14 +1,6 @@
 export {};
 
-declare abstract class AnyPrimaryCanvasGroupAmbienceFilter extends PrimaryCanvasGroupAmbienceFilter {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace PrimaryCanvasGroupAmbienceFilter {
-    type AnyConstructor = typeof AnyPrimaryCanvasGroupAmbienceFilter;
-  }
-
   /**
    * A filter used to apply color adjustments and other modifications to the environment.
    */
@@ -37,4 +29,13 @@ declare global {
      */
     static override defaultUniforms: AbstractBaseShader.Uniforms;
   }
+
+  namespace PrimaryCanvasGroupAmbienceFilter {
+    interface Any extends AnyPrimaryCanvasGroupAmbienceFilter {}
+    type AnyConstructor = typeof AnyPrimaryCanvasGroupAmbienceFilter;
+  }
+}
+
+declare abstract class AnyPrimaryCanvasGroupAmbienceFilter extends PrimaryCanvasGroupAmbienceFilter {
+  constructor(arg0: never, ...args: never[]);
 }

package/src/foundry/client/pixi/webgl/shaders/filters/glow-overlay.d.mts

@@ -1,14 +1,6 @@
-export {};
-
-declare abstract class AnyGlowOverlayFilter extends GlowOverlayFilter {
-  constructor(arg0: never, ...args: never[]);
-}
+import type { FixedInstanceType } from "fvtt-types/utils";
 
 declare global {
-  namespace GlowOverlayFilter {
-    type AnyConstructor = typeof AnyGlowOverlayFilter;
-  }
-
   /**
    * A filter which implements an inner or outer glow around the source texture.
    * Inspired from https://github.com/pixijs/filters/tree/main/filters/glow
@@ -63,7 +55,7 @@ declare global {
     static override create<ThisType extends AbstractBaseFilter.AnyConstructor>(
       this: ThisType,
       initialUniforms?: AbstractBaseShader.Uniforms,
-    ): InstanceType<ThisType>;
+    ): FixedInstanceType<ThisType>;
 
     override apply(
       filterManager: PIXI.FilterSystem,
@@ -72,4 +64,13 @@ declare global {
       clear: PIXI.CLEAR_MODES,
     ): void;
   }
+
+  namespace GlowOverlayFilter {
+    interface Any extends AnyGlowOverlayFilter {}
+    type AnyConstructor = typeof AnyGlowOverlayFilter;
+  }
+}
+
+declare abstract class AnyGlowOverlayFilter extends GlowOverlayFilter {
+  constructor(arg0: never, ...args: never[]);
 }

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

@@ -1,14 +1,6 @@
 export {};
 
-declare abstract class AnyInvisibilityFilter extends InvisibilityFilter {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace InvisibilityFilter {
-    type AnyConstructor = typeof AnyInvisibilityFilter;
-  }
-
   /**
    * Invisibility effect filter for placeables.
    */
@@ -26,4 +18,13 @@ declare global {
      */
     static override defaultUniforms: AbstractBaseShader.Uniforms;
   }
+
+  namespace InvisibilityFilter {
+    interface Any extends AnyInvisibilityFilter {}
+    type AnyConstructor = typeof AnyInvisibilityFilter;
+  }
+}
+
+declare abstract class AnyInvisibilityFilter extends InvisibilityFilter {
+  constructor(arg0: never, ...args: never[]);
 }

package/src/foundry/client/pixi/webgl/shaders/filters/outline-overlay.d.mts

@@ -1,14 +1,6 @@
-export {};
-
-declare abstract class AnyOutlineOverlayFilter extends OutlineOverlayFilter {
-  constructor(arg0: never, ...args: never[]);
-}
+import type { FixedInstanceType } from "fvtt-types/utils";
 
 declare global {
-  namespace OutlineOverlayFilter {
-    type AnyConstructor = typeof AnyOutlineOverlayFilter;
-  }
-
   /**
    * A filter which implements an outline.
    * Inspired from https://github.com/pixijs/filters/tree/main/filters/outline
@@ -62,7 +54,7 @@ declare global {
     static override create<ThisType extends AbstractBaseFilter.AnyConstructor>(
       this: ThisType,
       initialUniforms?: AbstractBaseShader.Uniforms,
-    ): InstanceType<ThisType>;
+    ): FixedInstanceType<ThisType>;
 
     override apply(
       filterManager: PIXI.FilterSystem,
@@ -83,4 +75,13 @@ declare global {
      */
     set animate(v);
   }
+
+  namespace OutlineOverlayFilter {
+    interface Any extends AnyOutlineOverlayFilter {}
+    type AnyConstructor = typeof AnyOutlineOverlayFilter;
+  }
+}
+
+declare abstract class AnyOutlineOverlayFilter extends OutlineOverlayFilter {
+  constructor(arg0: never, ...args: never[]);
 }

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[]);
 }