Repository: League-of-Foundry-Developers/foundry-vtt-types
Pull request #3022 (2025-01-15 06:36:33)

`pixi/webgl/**` touchup
Reorganize all of `pixi/webgl/**` to preferred order of classes and namespaces
Change over to new `interface Any` from `type Any`
Add tests for all shaders, extensions, and helpers
Fix enum issues from Brand conversions
General other touchup


Patch:
diff --git a/src/foundry/client/pixi/webgl/extensions/batch-renderer.d.mts b/src/foundry/client/pixi/webgl/extensions/batch-renderer.d.mts
index c14ab38f8..e611dbd12 100644
--- a/src/foundry/client/pixi/webgl/extensions/batch-renderer.d.mts
+++ b/src/foundry/client/pixi/webgl/extensions/batch-renderer.d.mts
@@ -1,36 +1,7 @@
-import type { ToMethod, InexactPartial } from "fvtt-types/utils";
-
-declare abstract class AnyBatchRenderer extends BatchRenderer {
-  constructor(arg0: never, ...args: never[]);
-}
+import type { ToMethod, InexactPartial, IntentionalPartial } from "fvtt-types/utils";
+import type { IBatchableElement, ViewableBuffer } from "pixi.js";
 
 declare global {
-  namespace BatchRenderer {
-    type AnyConstructor = typeof AnyBatchRenderer;
-
-    type PackInterleavedGeometryFunction = ToMethod<
-      (
-        element: PIXI.IBatchableElement,
-        attributeBuffer: PIXI.ViewableBuffer,
-        indexBuffer: Uint16Array,
-        aIndex: number,
-        iIndex: number,
-      ) => void
-    >;
-
-    type PreRenderBatchFunction = ToMethod<(batchRenderer: typeof BatchRenderer) => void>;
-
-    type BatchDefaultUniformsFunction = ToMethod<(maxTextures: number) => AbstractBaseShader.Uniforms>;
-
-    type ReservedTextureUnits = 0 | 1 | 2 | 3 | 4;
-
-    interface ShaderGeneratorOptions {
-      vertex: typeof BatchRenderer.defaultVertexSrc;
-      fragment: typeof BatchRenderer.defaultFragmentTemplate;
-      uniforms: typeof BatchRenderer.defaultUniforms;
-    }
-  }
-
   /**
    * A batch renderer with a customizable data transfer function to packed geometries.
    */
@@ -82,7 +53,18 @@ declare global {
 
     override start(): void;
 
-    override packInterleavedGeometry: BatchRenderer.PackInterleavedGeometryFunction;
+    /**
+     * @privateRemarks This signature must match `PIXI.BatchRenderer#packInterleavedGeometry`, as opposed to being
+     * a `PackInterleavedGeometryFunction`, as these params will be piped there if the subclass in question
+     * doesn't implement `_packInterleavedGeometry`
+     */
+    override packInterleavedGeometry(
+      element: IBatchableElement,
+      attributeBuffer: ViewableBuffer,
+      indexBuffer: Uint16Array,
+      aIndex: number,
+      iIndex: number,
+    ): void;
 
     /**
      * Verify if a PIXI plugin exists. Check by name.
@@ -91,4 +73,40 @@ declare global {
      */
     static hasPlugin(name: string): boolean;
   }
+
+  namespace BatchRenderer {
+    interface Any extends AnyBatchRenderer {}
+    type AnyConstructor = typeof AnyBatchRenderer;
+
+    type PackInterleavedGeometryFunction = ToMethod<
+      (
+        /**
+         * @privateRemarks The `element` param is `Partial`'d here because at least one `_packInterleavedGeometry` implementation (`DepthSampleShader`'s)
+         * omits properties from the parent PIXI interface. Neither `PIXI.BatchRenderer` nor any Foundry implementations provide any default vaules for
+         * properties of this interface, so no `InexactPartial` or `NullishProps`.
+         */
+        element: IntentionalPartial<PIXI.IBatchableElement>,
+        attributeBuffer: PIXI.ViewableBuffer,
+        indexBuffer: Uint16Array,
+        aIndex: number,
+        iIndex: number,
+      ) => void
+    >;
+
+    type PreRenderBatchFunction = ToMethod<(batchRenderer: typeof BatchRenderer) => void>;
+
+    type BatchDefaultUniformsFunction = ToMethod<(maxTextures: number) => AbstractBaseShader.Uniforms>;
+
+    type ReservedTextureUnits = 0 | 1 | 2 | 3 | 4;
+
+    interface ShaderGeneratorOptions {
+      vertex: typeof BatchRenderer.defaultVertexSrc;
+      fragment: typeof BatchRenderer.defaultFragmentTemplate;
+      uniforms: typeof BatchRenderer.defaultUniforms;
+    }
+  }
+}
+
+declare abstract class AnyBatchRenderer extends BatchRenderer {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/extensions/batch-shader-generator.d.mts b/src/foundry/client/pixi/webgl/extensions/batch-shader-generator.d.mts
index 0ce6ba4a2..b21f319a9 100644
--- a/src/foundry/client/pixi/webgl/extensions/batch-shader-generator.d.mts
+++ b/src/foundry/client/pixi/webgl/extensions/batch-shader-generator.d.mts
@@ -1,14 +1,6 @@
 export {};
 
-declare abstract class AnyBatchShaderGenerator extends BatchShaderGenerator {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace BatchShaderGenerator {
-    type AnyConstructor = typeof AnyBatchShaderGenerator;
-  }
-
   /**
    * A batch shader generator that could handle extra uniforms during initialization.
    * @param vertexSrc    - The vertex shader source
@@ -27,4 +19,13 @@ declare global {
 
     override generateShader(maxTextures: number): PIXI.Shader;
   }
+
+  namespace BatchShaderGenerator {
+    interface Any extends AnyBatchShaderGenerator {}
+    type AnyConstructor = typeof AnyBatchShaderGenerator;
+  }
+}
+
+declare abstract class AnyBatchShaderGenerator extends BatchShaderGenerator {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/helpers/framebugger-snapshot.d.mts b/src/foundry/client/pixi/webgl/helpers/framebuffer-snapshot.d.mts
similarity index 94%
rename from src/foundry/client/pixi/webgl/helpers/framebugger-snapshot.d.mts
rename to src/foundry/client/pixi/webgl/helpers/framebuffer-snapshot.d.mts
index 9b7a265be..133b530b5 100644
--- a/src/foundry/client/pixi/webgl/helpers/framebugger-snapshot.d.mts
+++ b/src/foundry/client/pixi/webgl/helpers/framebuffer-snapshot.d.mts
@@ -1,14 +1,6 @@
 export {};
 
-declare abstract class AnyFramebufferSnapshot extends FramebufferSnapshot {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace FramebufferSnapshot {
-    type AnyConstructor = typeof AnyFramebufferSnapshot;
-  }
-
   /**
    * Provide the necessary methods to get a snapshot of the framebuffer into a render texture.
    * Class meant to be used as a singleton.
@@ -27,4 +19,13 @@ declare global {
      */
     getFramebufferTexture(renderer: PIXI.Renderer): PIXI.RenderTexture;
   }
+
+  namespace FramebufferSnapshot {
+    interface Any extends AnyFramebufferSnapshot {}
+    type AnyConstructor = typeof AnyFramebufferSnapshot;
+  }
+}
+
+declare abstract class AnyFramebufferSnapshot extends FramebufferSnapshot {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/helpers/index.d.mts b/src/foundry/client/pixi/webgl/helpers/index.d.mts
index 81733aa41..5b5ba02be 100644
--- a/src/foundry/client/pixi/webgl/helpers/index.d.mts
+++ b/src/foundry/client/pixi/webgl/helpers/index.d.mts
@@ -1,3 +1,3 @@
-import "./framebugger-snapshot.d.mts";
+import "./framebuffer-snapshot.d.mts";
 import "./smooth-noise.d.mts";
 import "./texture-extractor.d.mts";
diff --git a/src/foundry/client/pixi/webgl/helpers/smooth-noise.d.mts b/src/foundry/client/pixi/webgl/helpers/smooth-noise.d.mts
index a6fdfb104..01bec5d24 100644
--- a/src/foundry/client/pixi/webgl/helpers/smooth-noise.d.mts
+++ b/src/foundry/client/pixi/webgl/helpers/smooth-noise.d.mts
@@ -1,28 +1,6 @@
 import type { InexactPartial } from "fvtt-types/utils";
 
 declare global {
-  namespace SmoothNoise {
-    interface ConstructorOptions {
-      /**
-       * The generated noise will be on the range [0, amplitude].
-       * @defaultValue `1`
-       */
-      amplitude: number;
-
-      /**
-       * An adjustment factor for the input x values which place them on an appropriate range.
-       * @defaultValue `1`
-       */
-      scale: number;
-
-      /**
-       * The number of pre-generated random numbers to generate.
-       * @defaultValue `256`
-       */
-      maxReferences: number;
-    }
-  }
-
   /**
    * A smooth noise generator for one-dimensional values.
    */
@@ -62,4 +40,33 @@ declare global {
      */
     generate(x: number): number;
   }
+
+  namespace SmoothNoise {
+    interface Any extends AnySmoothNoise {}
+    type AnyConstructor = typeof AnySmoothNoise;
+
+    interface ConstructorOptions {
+      /**
+       * The generated noise will be on the range [0, amplitude].
+       * @defaultValue `1`
+       */
+      amplitude: number;
+
+      /**
+       * An adjustment factor for the input x values which place them on an appropriate range.
+       * @defaultValue `1`
+       */
+      scale: number;
+
+      /**
+       * The number of pre-generated random numbers to generate.
+       * @defaultValue `256`
+       */
+      maxReferences: number;
+    }
+  }
+}
+
+declare abstract class AnySmoothNoise extends SmoothNoise {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/helpers/texture-extractor.d.mts b/src/foundry/client/pixi/webgl/helpers/texture-extractor.d.mts
index 207f991c5..bf7d1642a 100644
--- a/src/foundry/client/pixi/webgl/helpers/texture-extractor.d.mts
+++ b/src/foundry/client/pixi/webgl/helpers/texture-extractor.d.mts
@@ -1,65 +1,16 @@
-import type { InexactPartial } from "fvtt-types/utils";
-
-declare abstract class AnyTextureExtractor extends TextureExtractor {
-  constructor(arg0: never, ...args: never[]);
-}
+import type { Brand, InexactPartial } from "fvtt-types/utils";
 
 declare global {
-  namespace TextureExtractor {
-    type AnyConstructor = typeof AnyTextureExtractor;
-
-    interface ConstructorOptions {
-      /** @defaultValue `"TextureExtractor"` */
-      callerName: string;
-
-      controlHash: boolean;
-
-      /** @defaultValue `PIXI.FORMATS.RED` */
-      format: PIXI.FORMATS;
-    }
-
-    interface TextureExtractionOptions {
-      /**
-       * The texture the pixels are extracted from.
-       * Otherwise, extract from the renderer.
-       */
-      texture: PIXI.Texture | PIXI.RenderTexture | null;
-
-      /** The rectangle which the pixels are extracted from. */
-      frame: PIXI.Rectangle;
-
-      /** The compression mode to apply, or NONE */
-      compression: TextureExtractor.COMPRESSION_MODES;
-
-      /** The optional image mime type. */
-      type: string;
-
-      /** The optional image quality. */
-      quality: string;
-
-      /** The optional debug flag to use. */
-      debug: boolean;
-    }
-
-    interface COMPRESSION_MODES {
-      readonly NONE: 0;
-      readonly BASE64: 1;
-    }
-  }
-
   /**
    * A class or interface that provide support for WebGL async read pixel/texture data extraction.
    */
   class TextureExtractor {
-    constructor(
-      renderer: PIXI.Renderer,
-      { callerName, controlHash, format }?: InexactPartial<TextureExtractor.ConstructorOptions>,
-    );
+    constructor(renderer: PIXI.Renderer, options?: TextureExtractor.ConstructorOptions);
 
     /**
      * List of compression that could be applied with extraction
      */
-    static COMPRESSION_MODES: TextureExtractor.COMPRESSION_MODES;
+    static COMPRESSION_MODES: TextureExtractor.CompressionModes;
 
     /**
      * Debug flag.
@@ -75,7 +26,7 @@ declare global {
      * Extract a rectangular block of pixels from the texture (without un-pre-multiplying).
      * @param options - Options which configure extraction behavior
      */
-    extract(options: InexactPartial<TextureExtractor.TextureExtractionOptions>): ReturnType<Semaphore["add"]>;
+    extract(options?: TextureExtractor.TextureExtractionOptions): Promise<string | Uint8ClampedArray>;
 
     /**
      * Free all the bound objects.
@@ -87,4 +38,82 @@ declare global {
      */
     contextChange(): void;
   }
+
+  namespace TextureExtractor {
+    type Any = AnyTextureExtractor;
+    type AnyConstructor = typeof AnyTextureExtractor;
+
+    /** @internal */
+    type _ConstructorOptions = InexactPartial<{
+      /**
+       * The caller name associated with this instance of texture extractor (optional, used for debug)
+       * @defaultValue `"TextureExtractor"`
+       * @remarks Default provided by ?? in function body
+       */
+      callerName: string | null;
+
+      /**
+       * Does the TextureCompressor neeed to control the hash?
+       * @remarks Passed to `new TextureCompressor()`, where it is provided a default of `false` if null
+       */
+      controlHash: boolean | null;
+
+      /**
+       * The PIXI Format this TextureExtractor uses
+       * @defaultValue `PIXI.FORMATS.RED`
+       * @remarks Construction throws if this isn't `.RED` or `.RGBA`, so can't be null
+       */
+      format: PIXI.FORMATS;
+    }>;
+
+    /** Options for the constructor of {@link TextureExtractor} */
+    interface ConstructorOptions extends _ConstructorOptions {}
+
+    /** @internal */
+    type _ExtractOptions = InexactPartial<{
+      /**
+       * The texture the pixels are extracted from.
+       * Otherwise, extract from the renderer.
+       * @remarks Can't be null despite Foundry's typedef claiming it can, as eventually `texture?.baseTexture.resolution` is accessed
+       */
+      texture: PIXI.Texture | PIXI.RenderTexture;
+
+      /** The rectangle which the pixels are extracted from. */
+      frame: PIXI.Rectangle;
+
+      /** The compression mode to apply, or NONE */
+      compression: TextureExtractor.COMPRESSION_MODES;
+
+      /**
+       * The optional image mime type.
+       * @privateRemarks Allowed to be null because it has an `??` default in `TextureExtractor##compressBufferWorker`
+       * via `##compressBuffer`, the only place it is actually used, despite being passed to other functions as well
+       */
+      type: string | null;
+
+      /**
+       * The optional image quality.
+       *  @privateRemarks Foundry types as `string` but is clearly meant to be `number` by usage. Allowing null due to
+       * it having a `??` default in the path any browser someone is realistically using for Foundry will take.
+       */
+      quality: number | null;
+
+      /** The optional debug flag to use. */
+      debug: boolean | null;
+    }>;
+
+    /** Options for {@link TextureExtractor#extract} */
+    interface TextureExtractionOptions extends _ExtractOptions {}
+
+    type COMPRESSION_MODES = Brand<number, "TextureExtractor.COMPRESSION_MODES">;
+
+    interface CompressionModes {
+      NONE: 0 & COMPRESSION_MODES;
+      BASE64: 1 & COMPRESSION_MODES;
+    }
+  }
+}
+
+declare abstract class AnyTextureExtractor extends TextureExtractor {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/base-shader-mixin.d.mts b/src/foundry/client/pixi/webgl/shaders/base-shader-mixin.d.mts
index 5c74fa00c..101dc3616 100644
--- a/src/foundry/client/pixi/webgl/shaders/base-shader-mixin.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/base-shader-mixin.d.mts
@@ -1,9 +1,5 @@
 import type { Mixin } from "fvtt-types/utils";
 
-declare abstract class AnyBaseShader extends BaseShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare class BaseShader {
   /** @privateRemarks All mixin classses should accept anything for its constructor. */
   constructor(...args: any[]);
@@ -109,11 +105,16 @@ declare class BaseShader {
 }
 
 declare global {
+  function BaseShaderMixin<BaseClass extends PIXI.Shader.AnyConstructor | PIXI.Filter.AnyConstructor>(
+    ShaderClass: BaseClass,
+  ): Mixin<typeof BaseShader, BaseClass>;
+
   namespace BaseShader {
+    type AnyMixed = ReturnType<typeof BaseShaderMixin<PIXI.Shader.AnyConstructor | PIXI.Filter.AnyConstructor>>;
     type AnyConstructor = typeof AnyBaseShader;
   }
+}
 
-  function BaseShaderMixin<BaseClass extends PIXI.Shader.AnyConstructor | PIXI.Filter.AnyConstructor>(
-    ShaderClass: BaseClass,
-  ): Mixin<typeof BaseShader, BaseClass>;
+declare abstract class AnyBaseShader extends BaseShader {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/base-shader.d.mts b/src/foundry/client/pixi/webgl/shaders/base-shader.d.mts
index 11abbccf9..2f1f7efcd 100644
--- a/src/foundry/client/pixi/webgl/shaders/base-shader.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/base-shader.d.mts
@@ -1,35 +1,19 @@
 import type { FixedInstanceType, ToMethod } from "fvtt-types/utils";
 
-declare abstract class AnyAbstractBaseShader extends AbstractBaseShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace AbstractBaseShader {
-    type AnyConstructor = typeof AnyAbstractBaseShader;
-
-    type Coordinates =
-      | { x: number; y: number }
-      | { x: number; y: number; z: number }
-      | { x: number; y: number; z: number; w: number };
-
-    type UniformValue = boolean | number | Int32List | Float32List | Coordinates | Coordinates[] | PIXI.Texture;
-
-    // eslint-disable-next-line @typescript-eslint/consistent-type-definitions
-    type Uniforms = {
-      readonly [K: string]: AbstractBaseShader.UniformValue;
-    };
-
-    type FragmentShaderFunction = ToMethod<(arg0: never) => string>;
-
-    type PreRenderFunction = ToMethod<(mesh: PIXI.DisplayObject, renderer: PIXI.Renderer) => void>;
-  }
-
   /**
    * This class defines an interface which all shaders utilize
    */
   abstract class AbstractBaseShader extends BaseShaderMixin(PIXI.Shader) {
-    constructor(program: PIXI.Program, uniforms: AbstractBaseShader.Uniforms);
+    /**
+     * @param program  - The program to use with this shader.
+     * @param uniforms - The current uniforms of the Shader
+     */
+    constructor(
+      program: PIXI.Program,
+      /** @defaultValue `{}` */
+      uniforms?: AbstractBaseShader.Uniforms,
+    );
 
     /**
      * The raw vertex shader used by this class.
@@ -63,7 +47,7 @@ declare global {
      */
     static create<ThisType extends AbstractBaseShader.AnyConstructor>(
       this: ThisType,
-      initialUniforms: AbstractBaseShader.Uniforms,
+      initialUniforms?: AbstractBaseShader.Uniforms,
     ): FixedInstanceType<ThisType>;
 
     /**
@@ -81,6 +65,7 @@ declare global {
      * Perform operations which are required before binding the Shader to the Renderer.
      * @param mesh - The mesh display object linked to this shader.
      * @param renderer - The renderer
+     * @privateRemarks Foundry marks this as protected despite it getting called from `QuadMesh#_render`
      */
     protected _preRender: AbstractBaseShader.PreRenderFunction;
 
@@ -91,4 +76,36 @@ declare global {
      */
     protected get _defaults(): AbstractBaseShader.Uniforms;
   }
+
+  namespace AbstractBaseShader {
+    type AnyConstructor = typeof AnyAbstractBaseShader;
+
+    type Coordinates = { x: number; y: number; z?: number } | { x: number; y: number; z: number; w?: number };
+
+    type UniformValue =
+      | boolean
+      | number
+      | null
+      | Int32List
+      | Float32List
+      | Coordinates
+      | Coordinates[]
+      | Color.RGBColorVector
+      | Color.RGVAColorVector
+      | PIXI.Texture
+      | PIXI.Matrix;
+
+    // eslint-disable-next-line @typescript-eslint/consistent-type-definitions
+    type Uniforms = {
+      readonly [K: string]: AbstractBaseShader.UniformValue;
+    };
+
+    type FragmentShaderFunction = ToMethod<(arg0: never) => string>;
+
+    type PreRenderFunction = ToMethod<(mesh: PIXI.DisplayObject, renderer: PIXI.Renderer) => void>;
+  }
+}
+
+declare abstract class AnyAbstractBaseShader extends AbstractBaseShader {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/filters/base-filter.d.mts b/src/foundry/client/pixi/webgl/shaders/filters/base-filter.d.mts
index d2971cc0f..6b00dc41f 100644
--- a/src/foundry/client/pixi/webgl/shaders/filters/base-filter.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/filters/base-filter.d.mts
@@ -1,14 +1,6 @@
 import type { FixedInstanceType } from "fvtt-types/utils";
 
-declare abstract class AnyAbstractBaseFilter extends AbstractBaseFilter {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace AbstractBaseFilter {
-    type AnyConstructor = typeof AnyAbstractBaseFilter;
-  }
-
   /**
    * An abstract filter which provides a framework for reusable definition
    */
@@ -44,4 +36,13 @@ declare global {
       initialUniforms?: AbstractBaseShader.Uniforms,
     ): FixedInstanceType<ThisType>;
   }
+
+  namespace AbstractBaseFilter {
+    interface Any extends AnyAbstractBaseFilter {}
+    type AnyConstructor = typeof AnyAbstractBaseFilter;
+  }
+}
+
+declare abstract class AnyAbstractBaseFilter extends AbstractBaseFilter {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/filters/base-mask-filter.d.mts b/src/foundry/client/pixi/webgl/shaders/filters/base-mask-filter.d.mts
index 2be4fc2eb..2a51d9649 100644
--- a/src/foundry/client/pixi/webgl/shaders/filters/base-mask-filter.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/filters/base-mask-filter.d.mts
@@ -1,14 +1,6 @@
 export {};
 
-declare abstract class AnyAbstractBaseMaskFilter extends AbstractBaseMaskFilter {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace AbstractBaseMaskFilter {
-    type AnyConstructor = typeof AnyAbstractBaseMaskFilter;
-  }
-
   /**
    * This class defines an interface for masked custom filters
    */
@@ -18,12 +10,22 @@ declare global {
      */
     static vertexShader: string;
 
+    /** @remarks Foundry does not use the `currentState` param */
     override apply(
       filterManager: PIXI.FilterSystem,
       input: PIXI.RenderTexture,
       output: PIXI.RenderTexture,
       clear: PIXI.CLEAR_MODES,
-      currentState: PIXI.FilterState,
+      currentState?: PIXI.FilterState,
     ): void;
   }
+
+  namespace AbstractBaseMaskFilter {
+    interface Any extends AnyAbstractBaseMaskFilter {}
+    type AnyConstructor = typeof AnyAbstractBaseMaskFilter;
+  }
+}
+
+declare abstract class AnyAbstractBaseMaskFilter extends AbstractBaseMaskFilter {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/filters/blur.d.mts b/src/foundry/client/pixi/webgl/shaders/filters/blur.d.mts
index 30ae695b0..be163c19b 100644
--- a/src/foundry/client/pixi/webgl/shaders/filters/blur.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/filters/blur.d.mts
@@ -1,22 +1,6 @@
 export {};
 
-declare abstract class AnyAlphaBlurFilterPass extends AlphaBlurFilterPass {
-  constructor(arg0: never, ...args: never[]);
-}
-
-declare abstract class AnyAlphaBlurFilter extends AlphaBlurFilter {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace AlphaBlurFilterPass {
-    type AnyConstructor = typeof AnyAlphaBlurFilterPass;
-  }
-
-  namespace AlphaBlurFilter {
-    type AnyConstructor = typeof AnyAlphaBlurFilter;
-  }
-
   /**
    * Apply a vertical or horizontal gaussian blur going inward by using alpha as the penetrating channel.
    */
@@ -106,6 +90,11 @@ declare global {
     ): void;
   }
 
+  namespace AlphaBlurFilterPass {
+    interface Any extends AnyAlphaBlurFilterPass {}
+    type AnyConstructor = typeof AnyAlphaBlurFilterPass;
+  }
+
   /**
    * Apply a gaussian blur going inward by using alpha as the penetrating channel.
    */
@@ -122,9 +111,9 @@ declare global {
      */
     constructor(strength?: number, quality?: number, resolution?: number, kernelSize?: number);
 
-    blurXFilter: typeof AlphaBlurFilterPass;
+    blurXFilter: AlphaBlurFilterPass;
 
-    blurYFilter: typeof AlphaBlurFilterPass;
+    blurYFilter: AlphaBlurFilterPass;
 
     _repeatEdgePixels: boolean;
 
@@ -178,8 +167,21 @@ declare global {
     /**
      * Provided for completeness with PIXI.BlurFilter
      */
-    get blendMode(): number;
+    get blendMode(): PIXI.BLEND_MODES;
 
     set blendMode(value);
   }
+
+  namespace AlphaBlurFilter {
+    interface Any extends AnyAlphaBlurFilter {}
+    type AnyConstructor = typeof AnyAlphaBlurFilter;
+  }
+}
+
+declare abstract class AnyAlphaBlurFilterPass extends AlphaBlurFilterPass {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare abstract class AnyAlphaBlurFilter extends AlphaBlurFilter {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/filters/effects-masking.d.mts b/src/foundry/client/pixi/webgl/shaders/filters/effects-masking.d.mts
index 6187f3d3f..2e3960879 100644
--- a/src/foundry/client/pixi/webgl/shaders/filters/effects-masking.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/filters/effects-masking.d.mts
@@ -1,32 +1,6 @@
-import type { AnyObject, FixedInstanceType, ShapeWithIndexSignature } from "fvtt-types/utils";
-
-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.
    */
@@ -46,8 +20,13 @@ declare global {
 
     /**
      * 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[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/filters/environment.d.mts b/src/foundry/client/pixi/webgl/shaders/filters/environment.d.mts
index fc2e1f57d..1c57c8a12 100644
--- a/src/foundry/client/pixi/webgl/shaders/filters/environment.d.mts
+++ b/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[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/filters/glow-overlay.d.mts b/src/foundry/client/pixi/webgl/shaders/filters/glow-overlay.d.mts
index 5d826dcbe..033a47eb5 100644
--- a/src/foundry/client/pixi/webgl/shaders/filters/glow-overlay.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/filters/glow-overlay.d.mts
@@ -1,14 +1,6 @@
 import type { FixedInstanceType } from "fvtt-types/utils";
 
-declare abstract class AnyGlowOverlayFilter extends GlowOverlayFilter {
-  constructor(arg0: never, ...args: never[]);
-}
-
 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
@@ -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[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/filters/invisibility.d.mts b/src/foundry/client/pixi/webgl/shaders/filters/invisibility.d.mts
index e254d71c7..426fcc85b 100644
--- a/src/foundry/client/pixi/webgl/shaders/filters/invisibility.d.mts
+++ b/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[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/filters/outline-overlay.d.mts b/src/foundry/client/pixi/webgl/shaders/filters/outline-overlay.d.mts
index 819de1a9f..6a9f37625 100644
--- a/src/foundry/client/pixi/webgl/shaders/filters/outline-overlay.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/filters/outline-overlay.d.mts
@@ -1,14 +1,6 @@
 import type { FixedInstanceType } from "fvtt-types/utils";
 
-declare abstract class AnyOutlineOverlayFilter extends OutlineOverlayFilter {
-  constructor(arg0: never, ...args: never[]);
-}
-
 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
@@ -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[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/filters/transition.d.mts b/src/foundry/client/pixi/webgl/shaders/filters/transition.d.mts
index b7ac66208..9461c3f3e 100644
--- a/src/foundry/client/pixi/webgl/shaders/filters/transition.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/filters/transition.d.mts
@@ -1,49 +1,19 @@
-import type { InexactPartial, ValueOf } from "fvtt-types/utils";
-
-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[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/filters/visibility.d.mts b/src/foundry/client/pixi/webgl/shaders/filters/visibility.d.mts
index b676600e0..65d0c70b4 100644
--- a/src/foundry/client/pixi/webgl/shaders/filters/visibility.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/filters/visibility.d.mts
@@ -1,18 +1,6 @@
-import type { InexactPartial, FixedInstanceType } from "fvtt-types/utils";
-
-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>,
+      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[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/filters/vision-mask-filter.d.mts b/src/foundry/client/pixi/webgl/shaders/filters/vision-mask-filter.d.mts
index bcacd64ec..f69795242 100644
--- a/src/foundry/client/pixi/webgl/shaders/filters/vision-mask-filter.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/filters/vision-mask-filter.d.mts
@@ -1,14 +1,6 @@
 import type { FixedInstanceType } from "fvtt-types/utils";
 
-declare abstract class AnyVisionMaskFilter extends VisionMaskFilter {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace VisionMaskFilter {
-    type AnyConstructor = typeof AnyVisionMaskFilter;
-  }
-
   class VisionMaskFilter extends AbstractBaseMaskFilter {
     static override fragmentShader: string;
 
@@ -32,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[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/filters/void.d.mts b/src/foundry/client/pixi/webgl/shaders/filters/void.d.mts
index e6ac9002b..e68742e7c 100644
--- a/src/foundry/client/pixi/webgl/shaders/filters/void.d.mts
+++ b/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[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/filters/weather-occlusion-masks.d.mts b/src/foundry/client/pixi/webgl/shaders/filters/weather-occlusion-masks.d.mts
index 70697ec61..e5ab53ca8 100644
--- a/src/foundry/client/pixi/webgl/shaders/filters/weather-occlusion-masks.d.mts
+++ b/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[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/fragment-channel-mixin.d.mts b/src/foundry/client/pixi/webgl/shaders/fragment-channel-mixin.d.mts
index 771da373b..76c695f99 100644
--- a/src/foundry/client/pixi/webgl/shaders/fragment-channel-mixin.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/fragment-channel-mixin.d.mts
@@ -1,9 +1,5 @@
 import type { AnyObject, Mixin, ShapeWithIndexSignature } from "fvtt-types/utils";
 
-declare abstract class AnyAdaptiveFragmentChannel extends AdaptiveFragmentChannel {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare class AdaptiveFragmentChannel {
   /** @privateRemarks All mixin classses should accept anything for its constructor. */
   constructor(...args: any[]);
@@ -19,6 +15,7 @@ declare class AdaptiveFragmentChannel {
    * 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.
@@ -38,7 +35,18 @@ declare class AdaptiveFragmentChannel {
 }
 
 declare global {
+  /**
+   * 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 PIXI.Shader.AnyConstructor | PIXI.Filter.AnyConstructor>(
+    ShaderClass: BaseClass,
+  ): Mixin<typeof AdaptiveFragmentChannel, BaseClass>;
+
   namespace AdaptiveFragmentChannel {
+    // Filter extends Shader, so Shader is the broadest option
+    type AnyMixed = ReturnType<typeof AdaptiveFragmentChannelMixin<PIXI.Shader.AnyConstructor>>;
     type AnyConstructor = typeof AnyAdaptiveFragmentChannel;
 
     type Channel = "r" | "g" | "b";
@@ -47,8 +55,8 @@ declare global {
       channel?: AdaptiveFragmentChannel.Channel | undefined;
     }
   }
+}
 
-  function AdaptiveFragmentChannelMixin<BaseClass extends PIXI.Shader.AnyConstructor | PIXI.Filter.AnyConstructor>(
-    ShaderClass: BaseClass,
-  ): Mixin<typeof AdaptiveFragmentChannel, BaseClass>;
+declare abstract class AnyAdaptiveFragmentChannel extends AdaptiveFragmentChannel {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/grid/grid.d.mts b/src/foundry/client/pixi/webgl/shaders/grid/grid.d.mts
index 2a31c6625..15a820c80 100644
--- a/src/foundry/client/pixi/webgl/shaders/grid/grid.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/grid/grid.d.mts
@@ -1,14 +1,6 @@
-import type { IntentionalPartial } from "fvtt-types/utils";
-
-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[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/lighting/background-lighting.d.mts b/src/foundry/client/pixi/webgl/shaders/lighting/background-lighting.d.mts
index 921b7108a..a0eb41142 100644
--- a/src/foundry/client/pixi/webgl/shaders/lighting/background-lighting.d.mts
+++ b/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[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/lighting/base-lighting.d.mts b/src/foundry/client/pixi/webgl/shaders/lighting/base-lighting.d.mts
index c1f61a572..7581c5f58 100644
--- a/src/foundry/client/pixi/webgl/shaders/lighting/base-lighting.d.mts
+++ b/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[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/lighting/coloration-lighting.d.mts b/src/foundry/client/pixi/webgl/shaders/lighting/coloration-lighting.d.mts
index 4fb0d11bd..86902b59c 100644
--- a/src/foundry/client/pixi/webgl/shaders/lighting/coloration-lighting.d.mts
+++ b/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[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/lighting/darkness-lighting.d.mts b/src/foundry/client/pixi/webgl/shaders/lighting/darkness-lighting.d.mts
index 647090e9d..da81be683 100644
--- a/src/foundry/client/pixi/webgl/shaders/lighting/darkness-lighting.d.mts
+++ b/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[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/lighting/effects/bewitching-wave.d.mts b/src/foundry/client/pixi/webgl/shaders/lighting/effects/bewitching-wave.d.mts
index 7219eaaa5..ad028f22e 100644
--- a/src/foundry/client/pixi/webgl/shaders/lighting/effects/bewitching-wave.d.mts
+++ b/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[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/lighting/effects/black-hole.d.mts b/src/foundry/client/pixi/webgl/shaders/lighting/effects/black-hole.d.mts
index 4999e78d0..a0b167bc2 100644
--- a/src/foundry/client/pixi/webgl/shaders/lighting/effects/black-hole.d.mts
+++ b/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[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/lighting/effects/chroma.d.mts b/src/foundry/client/pixi/webgl/shaders/lighting/effects/chroma.d.mts
index ba487cfff..1885254af 100644
--- a/src/foundry/client/pixi/webgl/shaders/lighting/effects/chroma.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/lighting/effects/chroma.d.mts
@@ -1,14 +1,6 @@
 export {};
 
-declare abstract class AnyChromaColorationShader extends ChromaColorationShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace ChromaColorationShader {
-    type AnyConstructor = typeof AnyChromaColorationShader;
-  }
-
   /**
    * Chroma animation coloration shader
    */
@@ -20,4 +12,13 @@ declare global {
 
     static override fragmentShader: string;
   }
+
+  namespace ChromaColorationShader {
+    interface Any extends AnyChromaColorationShader {}
+    type AnyConstructor = typeof AnyChromaColorationShader;
+  }
+}
+
+declare abstract class AnyChromaColorationShader extends ChromaColorationShader {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/lighting/effects/emanation.d.mts b/src/foundry/client/pixi/webgl/shaders/lighting/effects/emanation.d.mts
index 8b26a5538..2d3752cb0 100644
--- a/src/foundry/client/pixi/webgl/shaders/lighting/effects/emanation.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/lighting/effects/emanation.d.mts
@@ -1,14 +1,6 @@
 export {};
 
-declare abstract class AnyEmanationColorationShader extends EmanationColorationShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace EmanationColorationShader {
-    type AnyConstructor = typeof AnyEmanationColorationShader;
-  }
-
   /**
    * Emanation animation coloration shader
    */
@@ -20,4 +12,13 @@ declare global {
 
     static override fragmentShader: string;
   }
+
+  namespace EmanationColorationShader {
+    interface Any extends AnyEmanationColorationShader {}
+    type AnyConstructor = typeof AnyEmanationColorationShader;
+  }
+}
+
+declare abstract class AnyEmanationColorationShader extends EmanationColorationShader {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/lighting/effects/energy-field.d.mts b/src/foundry/client/pixi/webgl/shaders/lighting/effects/energy-field.d.mts
index ad67a0998..cb1fb4253 100644
--- a/src/foundry/client/pixi/webgl/shaders/lighting/effects/energy-field.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/lighting/effects/energy-field.d.mts
@@ -1,14 +1,6 @@
 export {};
 
-declare abstract class AnyEnergyFieldColorationShader extends EnergyFieldColorationShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace EnergyFieldColorationShader {
-    type AnyConstructor = typeof AnyEnergyFieldColorationShader;
-  }
-
   /**
    * Energy field animation coloration shader
    */
@@ -20,4 +12,13 @@ declare global {
 
     static override fragmentShader: string;
   }
+
+  namespace EnergyFieldColorationShader {
+    interface Any extends AnyEnergyFieldColorationShader {}
+    type AnyConstructor = typeof AnyEnergyFieldColorationShader;
+  }
+}
+
+declare abstract class AnyEnergyFieldColorationShader extends EnergyFieldColorationShader {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/lighting/effects/fairy-light.d.mts b/src/foundry/client/pixi/webgl/shaders/lighting/effects/fairy-light.d.mts
index aa7a433a6..a543dbc20 100644
--- a/src/foundry/client/pixi/webgl/shaders/lighting/effects/fairy-light.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/lighting/effects/fairy-light.d.mts
@@ -1,22 +1,6 @@
 export {};
 
-declare abstract class AnyFairyLightColorationShader extends FairyLightColorationShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
-declare abstract class AnyFairyLightIlluminationShader extends FairyLightIlluminationShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace FairyLightColorationShader {
-    type AnyConstructor = typeof AnyFairyLightColorationShader;
-  }
-
-  namespace FairyLightIlluminationShader {
-    type AnyConstructor = typeof AnyFairyLightIlluminationShader;
-  }
-
   /**
    * Fairy light animation coloration shader
    */
@@ -29,10 +13,28 @@ declare global {
     static override fragmentShader: string;
   }
 
+  namespace FairyLightColorationShader {
+    interface Any extends AnyFairyLightColorationShader {}
+    type AnyConstructor = typeof AnyFairyLightColorationShader;
+  }
+
   /**
    * Fairy light animation illumination shader
    */
   class FairyLightIlluminationShader extends AdaptiveIlluminationShader {
     static override fragmentShader: string;
   }
+
+  namespace FairyLightIlluminationShader {
+    interface Any extends AnyFairyLightColorationShader {}
+    type AnyConstructor = typeof AnyFairyLightIlluminationShader;
+  }
+}
+
+declare abstract class AnyFairyLightColorationShader extends FairyLightColorationShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare abstract class AnyFairyLightIlluminationShader extends FairyLightIlluminationShader {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/lighting/effects/flame.d.mts b/src/foundry/client/pixi/webgl/shaders/lighting/effects/flame.d.mts
index e8b703b5e..e2a097b4c 100644
--- a/src/foundry/client/pixi/webgl/shaders/lighting/effects/flame.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/lighting/effects/flame.d.mts
@@ -1,22 +1,6 @@
 export {};
 
-declare abstract class AnyFlameIlluminationShader extends FlameIlluminationShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
-declare abstract class AnyFlameColorationShader extends FlameColorationShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace FlameIlluminationShader {
-    type AnyConstructor = typeof AnyFlameIlluminationShader;
-  }
-
-  namespace FlameColorationShader {
-    type AnyConstructor = typeof AnyFlameColorationShader;
-  }
-
   /**
    * Alternative torch illumination shader
    */
@@ -35,6 +19,11 @@ declare global {
     static override defaultUniforms: AbstractBaseShader.Uniforms;
   }
 
+  namespace FlameIlluminationShader {
+    interface Any extends AnyFlameIlluminationShader {}
+    type AnyConstructor = typeof AnyFlameIlluminationShader;
+  }
+
   /**
    * Alternative torch coloration shader
    */
@@ -52,4 +41,17 @@ declare global {
      */
     static override defaultUniforms: AbstractBaseShader.Uniforms;
   }
+
+  namespace FlameColorationShader {
+    interface Any extends AnyFlameColorationShader {}
+    type AnyConstructor = typeof AnyFlameColorationShader;
+  }
+}
+
+declare abstract class AnyFlameIlluminationShader extends FlameIlluminationShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare abstract class AnyFlameColorationShader extends FlameColorationShader {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/lighting/effects/fog.d.mts b/src/foundry/client/pixi/webgl/shaders/lighting/effects/fog.d.mts
index 1d6822e78..451f0fa16 100644
--- a/src/foundry/client/pixi/webgl/shaders/lighting/effects/fog.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/lighting/effects/fog.d.mts
@@ -1,14 +1,6 @@
 export {};
 
-declare abstract class AnyFogColorationShader extends FogColorationShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace FogColorationShader {
-    type AnyConstructor = typeof AnyFogColorationShader;
-  }
-
   /**
    * Fog animation coloration shader
    */
@@ -20,4 +12,13 @@ declare global {
 
     static override fragmentShader: string;
   }
+
+  namespace FogColorationShader {
+    interface Any extends AnyFogColorationShader {}
+    type AnyConstructor = typeof AnyFogColorationShader;
+  }
+}
+
+declare abstract class AnyFogColorationShader extends FogColorationShader {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/lighting/effects/force-grid.d.mts b/src/foundry/client/pixi/webgl/shaders/lighting/effects/force-grid.d.mts
index 3ec148914..a6190194a 100644
--- a/src/foundry/client/pixi/webgl/shaders/lighting/effects/force-grid.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/lighting/effects/force-grid.d.mts
@@ -1,13 +1,6 @@
 export {};
 
-declare abstract class AnyForceGridColorationShader extends ForceGridColorationShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace ForceGridColorationShader {
-    type AnyConstructor = typeof AnyForceGridColorationShader;
-  }
   /**
    * A futuristic Force Grid animation.
    */
@@ -19,4 +12,13 @@ declare global {
 
     static override fragmentShader: string;
   }
+
+  namespace ForceGridColorationShader {
+    interface Any extends AnyForceGridColorationShader {}
+    type AnyConstructor = typeof AnyForceGridColorationShader;
+  }
+}
+
+declare abstract class AnyForceGridColorationShader extends ForceGridColorationShader {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/lighting/effects/ghost-light.d.mts b/src/foundry/client/pixi/webgl/shaders/lighting/effects/ghost-light.d.mts
index 464039c7b..c9e0ceb92 100644
--- a/src/foundry/client/pixi/webgl/shaders/lighting/effects/ghost-light.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/lighting/effects/ghost-light.d.mts
@@ -1,22 +1,6 @@
 export {};
 
-declare abstract class AnyGhostLightIlluminationShader extends GhostLightIlluminationShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
-declare abstract class AnyGhostLightColorationShader extends GhostLightColorationShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace GhostLightIlluminationShader {
-    type AnyConstructor = typeof AnyGhostLightIlluminationShader;
-  }
-
-  namespace GhostLightColorationShader {
-    type AnyConstructor = typeof AnyGhostLightColorationShader;
-  }
-
   /**
    * Ghost light animation illumination shader
    */
@@ -24,10 +8,28 @@ declare global {
     static override fragmentShader: string;
   }
 
+  namespace GhostLightIlluminationShader {
+    interface Any extends AnyGhostLightIlluminationShader {}
+    type AnyConstructor = typeof AnyGhostLightIlluminationShader;
+  }
+
   /**
    * Ghost light animation coloration shader
    */
   class GhostLightColorationShader extends AdaptiveColorationShader {
     static override fragmentShader: string;
   }
+
+  namespace GhostLightColorationShader {
+    interface Any extends AnyGhostLightColorationShader {}
+    type AnyConstructor = typeof AnyGhostLightColorationShader;
+  }
+}
+
+declare abstract class AnyGhostLightIlluminationShader extends GhostLightIlluminationShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare abstract class AnyGhostLightColorationShader extends GhostLightColorationShader {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/lighting/effects/hexa-dome.d.mts b/src/foundry/client/pixi/webgl/shaders/lighting/effects/hexa-dome.d.mts
index 092443c08..a872d8a87 100644
--- a/src/foundry/client/pixi/webgl/shaders/lighting/effects/hexa-dome.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/lighting/effects/hexa-dome.d.mts
@@ -1,14 +1,6 @@
 export {};
 
-declare abstract class AnyHexaDomeColorationShader extends HexaDomeColorationShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace HexaDomeColorationShader {
-    type AnyConstructor = typeof AnyHexaDomeColorationShader;
-  }
-
   /**
    * Hexagonal dome animation coloration shader
    */
@@ -20,4 +12,13 @@ declare global {
 
     static override fragmentShader: string;
   }
+
+  namespace HexaDomeColorationShader {
+    interface Any extends AnyHexaDomeColorationShader {}
+    type AnyConstructor = typeof AnyHexaDomeColorationShader;
+  }
+}
+
+declare abstract class AnyHexaDomeColorationShader extends HexaDomeColorationShader {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/lighting/effects/light-dome.d.mts b/src/foundry/client/pixi/webgl/shaders/lighting/effects/light-dome.d.mts
index 8860853f9..33c909caa 100644
--- a/src/foundry/client/pixi/webgl/shaders/lighting/effects/light-dome.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/lighting/effects/light-dome.d.mts
@@ -1,14 +1,6 @@
 export {};
 
-declare abstract class AnyLightDomeColorationShader extends LightDomeColorationShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace LightDomeColorationShader {
-    type AnyConstructor = typeof AnyLightDomeColorationShader;
-  }
-
   /**
    * Light dome animation coloration shader
    */
@@ -20,4 +12,13 @@ declare global {
 
     static override fragmentShader: string;
   }
+
+  namespace LightDomeColorationShader {
+    interface Any extends AnyLightDomeColorationShader {}
+    type AnyConstructor = typeof AnyLightDomeColorationShader;
+  }
+}
+
+declare abstract class AnyLightDomeColorationShader extends LightDomeColorationShader {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/lighting/effects/magical-gloom.d.mts b/src/foundry/client/pixi/webgl/shaders/lighting/effects/magical-gloom.d.mts
index e82f85e13..fb137a1b3 100644
--- a/src/foundry/client/pixi/webgl/shaders/lighting/effects/magical-gloom.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/lighting/effects/magical-gloom.d.mts
@@ -1,18 +1,19 @@
 export {};
 
-declare abstract class AnyMagicalGloomDarknessShader extends MagicalGloomDarknessShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace MagicalGloomDarknessShader {
-    type AnyConstructor = typeof AnyMagicalGloomDarknessShader;
-  }
-
   /**
    * Creates a gloomy ring of pure darkness.
    */
   class MagicalGloomDarknessShader extends AdaptiveDarknessShader {
     static override fragmentShader: string;
   }
+
+  namespace MagicalGloomDarknessShader {
+    interface Any extends AnyMagicalGloomDarknessShader {}
+    type AnyConstructor = typeof AnyMagicalGloomDarknessShader;
+  }
+}
+
+declare abstract class AnyMagicalGloomDarknessShader extends MagicalGloomDarknessShader {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/lighting/effects/pulse.d.mts b/src/foundry/client/pixi/webgl/shaders/lighting/effects/pulse.d.mts
index 0522ee668..9b4003528 100644
--- a/src/foundry/client/pixi/webgl/shaders/lighting/effects/pulse.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/lighting/effects/pulse.d.mts
@@ -1,22 +1,6 @@
 export {};
 
-declare abstract class AnyPulseColorationShader extends PulseColorationShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
-declare abstract class AnyPulseIlluminationShader extends PulseIlluminationShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace PulseColorationShader {
-    type AnyConstructor = typeof AnyPulseColorationShader;
-  }
-
-  namespace PulseIlluminationShader {
-    type AnyConstructor = typeof AnyPulseIlluminationShader;
-  }
-
   /**
    * Pulse animation illumination shader
    */
@@ -24,6 +8,11 @@ declare global {
     static override fragmentShader: string;
   }
 
+  namespace PulseIlluminationShader {
+    interface Any extends AnyPulseIlluminationShader {}
+    type AnyConstructor = typeof AnyPulseIlluminationShader;
+  }
+
   /**
    * Pulse animation coloration shader
    */
@@ -41,4 +30,17 @@ declare global {
      */
     static override defaultUniforms: AbstractBaseShader.Uniforms;
   }
+
+  namespace PulseColorationShader {
+    interface Any extends AnyPulseColorationShader {}
+    type AnyConstructor = typeof AnyPulseColorationShader;
+  }
+}
+
+declare abstract class AnyPulseColorationShader extends PulseColorationShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare abstract class AnyPulseIlluminationShader extends PulseIlluminationShader {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/lighting/effects/radial-rainbow.d.mts b/src/foundry/client/pixi/webgl/shaders/lighting/effects/radial-rainbow.d.mts
index fe8bc538d..70719aea4 100644
--- a/src/foundry/client/pixi/webgl/shaders/lighting/effects/radial-rainbow.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/lighting/effects/radial-rainbow.d.mts
@@ -1,14 +1,6 @@
 export {};
 
-declare abstract class AnyRadialRainbowColorationShader extends RadialRainbowColorationShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace RadialRainbowColorationShader {
-    type AnyConstructor = typeof AnyRadialRainbowColorationShader;
-  }
-
   /**
    * Radial rainbow animation coloration shader
    */
@@ -20,4 +12,13 @@ declare global {
 
     static override fragmentShader: string;
   }
+
+  namespace RadialRainbowColorationShader {
+    interface Any extends AnyRadialRainbowColorationShader {}
+    type AnyConstructor = typeof AnyRadialRainbowColorationShader;
+  }
+}
+
+declare abstract class AnyRadialRainbowColorationShader extends RadialRainbowColorationShader {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/lighting/effects/revolving-light.d.mts b/src/foundry/client/pixi/webgl/shaders/lighting/effects/revolving-light.d.mts
index 1a1e394cc..6d21ccb7b 100644
--- a/src/foundry/client/pixi/webgl/shaders/lighting/effects/revolving-light.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/lighting/effects/revolving-light.d.mts
@@ -1,14 +1,6 @@
 export {};
 
-declare abstract class AnyRevolvingColorationShader extends RevolvingColorationShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace RevolvingColorationShader {
-    type AnyConstructor = typeof AnyRevolvingColorationShader;
-  }
-
   /**
    * Revolving animation coloration shader
    */
@@ -33,4 +25,13 @@ declare global {
      */
     static defaultUniforms: AbstractBaseShader.Uniforms;
   }
+
+  namespace RevolvingColorationShader {
+    interface Any extends AnyRevolvingColorationShader {}
+    type AnyConstructor = typeof AnyRevolvingColorationShader;
+  }
+}
+
+declare abstract class AnyRevolvingColorationShader extends RevolvingColorationShader {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/lighting/effects/roiling-mass.d.mts b/src/foundry/client/pixi/webgl/shaders/lighting/effects/roiling-mass.d.mts
index 33fe005f6..f9656aa1d 100644
--- a/src/foundry/client/pixi/webgl/shaders/lighting/effects/roiling-mass.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/lighting/effects/roiling-mass.d.mts
@@ -1,18 +1,19 @@
 export {};
 
-declare abstract class AnyRoilingDarknessShader extends RoilingDarknessShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace RoilingDarknessShader {
-    type AnyConstructor = typeof AnyRoilingDarknessShader;
-  }
-
   /**
    * Roiling mass illumination shader - intended primarily for darkness
    */
   class RoilingDarknessShader extends AdaptiveIlluminationShader {
     static override fragmentShader: string;
   }
+
+  namespace RoilingDarknessShader {
+    interface Any extends AnyRoilingDarknessShader {}
+    type AnyConstructor = typeof AnyRoilingDarknessShader;
+  }
+}
+
+declare abstract class AnyRoilingDarknessShader extends RoilingDarknessShader {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/lighting/effects/siren-light.d.mts b/src/foundry/client/pixi/webgl/shaders/lighting/effects/siren-light.d.mts
index c8afc6edb..f0f2cd235 100644
--- a/src/foundry/client/pixi/webgl/shaders/lighting/effects/siren-light.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/lighting/effects/siren-light.d.mts
@@ -1,22 +1,6 @@
 export {};
 
-declare abstract class AnySirenColorationShader extends SirenColorationShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
-declare abstract class AnySirenIlluminationShader extends SirenIlluminationShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace SirenColorationShader {
-    type AnyConstructor = typeof AnySirenColorationShader;
-  }
-
-  namespace SirenIlluminationShader {
-    type AnyConstructor = typeof AnySirenIlluminationShader;
-  }
-
   /**
    * Siren light animation coloration shader
    */
@@ -39,6 +23,11 @@ declare global {
     static defaultUniforms: AbstractBaseShader.Uniforms;
   }
 
+  namespace SirenColorationShader {
+    interface Any extends AnySirenColorationShader {}
+    type AnyConstructor = typeof AnySirenColorationShader;
+  }
+
   /**
    * Siren light animation illumination shader
    */
@@ -58,4 +47,17 @@ declare global {
      */
     static defaultUniforms: AbstractBaseShader.Uniforms;
   }
+
+  namespace SirenIlluminationShader {
+    interface Any extends AnySirenIlluminationShader {}
+    type AnyConstructor = typeof AnySirenIlluminationShader;
+  }
+}
+
+declare abstract class AnySirenColorationShader extends SirenColorationShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare abstract class AnySirenIlluminationShader extends SirenIlluminationShader {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/lighting/effects/smoke-patch.d.mts b/src/foundry/client/pixi/webgl/shaders/lighting/effects/smoke-patch.d.mts
index a74dd84ec..f28acedaa 100644
--- a/src/foundry/client/pixi/webgl/shaders/lighting/effects/smoke-patch.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/lighting/effects/smoke-patch.d.mts
@@ -1,32 +1,34 @@
 export {};
-
-declare abstract class AnySmokePatchColorationShader extends SmokePatchColorationShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
-declare abstract class AnySmokePatchIlluminationShader extends SmokePatchIlluminationShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace SmokePatchColorationShader {
-    type AnyConstructor = typeof AnySmokePatchColorationShader;
-  }
-
-  namespace SmokePatchIlluminationShader {
-    type AnyConstructor = typeof AnySmokePatchIlluminationShader;
-  }
-
   /**
    * A patch of smoke
    */
   class SmokePatchColorationShader extends AdaptiveColorationShader {
     static override fragmentShader: string;
   }
+
+  namespace SmokePatchColorationShader {
+    interface Any extends AnySmokePatchColorationShader {}
+    type AnyConstructor = typeof AnySmokePatchColorationShader;
+  }
+
   /**
    * A patch of smoke
    */
   class SmokePatchIlluminationShader extends AdaptiveIlluminationShader {
     static override fragmentShader: string;
   }
+
+  namespace SmokePatchIlluminationShader {
+    interface Any extends AnySmokePatchIlluminationShader {}
+    type AnyConstructor = typeof AnySmokePatchIlluminationShader;
+  }
+}
+
+declare abstract class AnySmokePatchColorationShader extends SmokePatchColorationShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare abstract class AnySmokePatchIlluminationShader extends SmokePatchIlluminationShader {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/lighting/effects/star-light.d.mts b/src/foundry/client/pixi/webgl/shaders/lighting/effects/star-light.d.mts
index a46552833..aad1eed31 100644
--- a/src/foundry/client/pixi/webgl/shaders/lighting/effects/star-light.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/lighting/effects/star-light.d.mts
@@ -1,14 +1,6 @@
 export {};
 
-declare abstract class AnyStarLightColorationShader extends StarLightColorationShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace StarLightColorationShader {
-    type AnyConstructor = typeof AnyStarLightColorationShader;
-  }
-
   /**
    * A disco like star light.
    */
@@ -20,4 +12,13 @@ declare global {
 
     static override fragmentShader: string;
   }
+
+  namespace StarLightColorationShader {
+    interface Any extends AnyStarLightColorationShader {}
+    type AnyConstructor = typeof AnyStarLightColorationShader;
+  }
+}
+
+declare abstract class AnyStarLightColorationShader extends StarLightColorationShader {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/lighting/effects/sunburst.d.mts b/src/foundry/client/pixi/webgl/shaders/lighting/effects/sunburst.d.mts
index 748d40da7..7f15857c3 100644
--- a/src/foundry/client/pixi/webgl/shaders/lighting/effects/sunburst.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/lighting/effects/sunburst.d.mts
@@ -1,22 +1,6 @@
 export {};
 
-declare abstract class AnySunburstColorationShader extends SunburstColorationShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
-declare abstract class AnySunburstIlluminationShader extends SunburstIlluminationShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace SunburstColorationShader {
-    type AnyConstructor = typeof AnySunburstColorationShader;
-  }
-
-  namespace SunburstIlluminationShader {
-    type AnyConstructor = typeof AnySunburstIlluminationShader;
-  }
-
   /**
    * Sunburst animation illumination shader
    */
@@ -24,10 +8,28 @@ declare global {
     static override fragmentShader: string;
   }
 
+  namespace SunburstIlluminationShader {
+    interface Any extends AnySunburstIlluminationShader {}
+    type AnyConstructor = typeof AnySunburstIlluminationShader;
+  }
+
   /**
    * Sunburst animation coloration shader
    */
   class SunburstColorationShader extends AdaptiveColorationShader {
     static override fragmentShader: string;
   }
+
+  namespace SunburstColorationShader {
+    interface Any extends AnySunburstColorationShader {}
+    type AnyConstructor = typeof AnySunburstColorationShader;
+  }
+}
+
+declare abstract class AnySunburstColorationShader extends SunburstColorationShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare abstract class AnySunburstIlluminationShader extends SunburstIlluminationShader {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/lighting/effects/swirling-rainbow.d.mts b/src/foundry/client/pixi/webgl/shaders/lighting/effects/swirling-rainbow.d.mts
index 5285572d1..c508d3e3d 100644
--- a/src/foundry/client/pixi/webgl/shaders/lighting/effects/swirling-rainbow.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/lighting/effects/swirling-rainbow.d.mts
@@ -1,14 +1,5 @@
 export {};
-
-declare abstract class AnySwirlingRainbowColorationShader extends SwirlingRainbowColorationShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace SwirlingRainbowColorationShader {
-    type AnyConstructor = typeof AnySwirlingRainbowColorationShader;
-  }
-
   /**
    * Swirling rainbow animation coloration shader
    */
@@ -20,4 +11,13 @@ declare global {
 
     static override fragmentShader: string;
   }
+
+  namespace SwirlingRainbowColorationShader {
+    interface Any extends AnySwirlingRainbowColorationShader {}
+    type AnyConstructor = typeof AnySwirlingRainbowColorationShader;
+  }
+}
+
+declare abstract class AnySwirlingRainbowColorationShader extends SwirlingRainbowColorationShader {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/lighting/effects/torch.d.mts b/src/foundry/client/pixi/webgl/shaders/lighting/effects/torch.d.mts
index 174262798..4600578bb 100644
--- a/src/foundry/client/pixi/webgl/shaders/lighting/effects/torch.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/lighting/effects/torch.d.mts
@@ -1,22 +1,6 @@
 export {};
 
-declare abstract class AnyTorchColorationShader extends TorchColorationShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
-declare abstract class AnyTorchIlluminationShader extends TorchIlluminationShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace TorchColorationShader {
-    type AnyConstructor = typeof AnyTorchColorationShader;
-  }
-
-  namespace TorchIlluminationShader {
-    type AnyConstructor = typeof AnyTorchIlluminationShader;
-  }
-
   /**
    * Allow coloring of illumination
    */
@@ -24,6 +8,11 @@ declare global {
     static override fragmentShader: string;
   }
 
+  namespace TorchIlluminationShader {
+    interface Any extends AnyTorchIlluminationShader {}
+    type AnyConstructor = typeof AnyTorchIlluminationShader;
+  }
+
   /**
    * Torch animation coloration shader
    */
@@ -42,4 +31,17 @@ declare global {
      */
     static override defaultUniforms: AbstractBaseShader.Uniforms;
   }
+
+  namespace TorchColorationShader {
+    interface Any extends AnyTorchColorationShader {}
+    type AnyConstructor = typeof AnyTorchColorationShader;
+  }
+}
+
+declare abstract class AnyTorchColorationShader extends TorchColorationShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare abstract class AnyTorchIlluminationShader extends TorchIlluminationShader {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/lighting/effects/vortex.d.mts b/src/foundry/client/pixi/webgl/shaders/lighting/effects/vortex.d.mts
index 338d079a7..480c7ff80 100644
--- a/src/foundry/client/pixi/webgl/shaders/lighting/effects/vortex.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/lighting/effects/vortex.d.mts
@@ -1,22 +1,6 @@
 export {};
 
-declare abstract class AnyVortexColorationShader extends VortexColorationShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
-declare abstract class AnyVortexIlluminationShader extends VortexIlluminationShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace VortexColorationShader {
-    type AnyConstructor = typeof AnyVortexColorationShader;
-  }
-
-  namespace VortexIlluminationShader {
-    type AnyConstructor = typeof AnyVortexIlluminationShader;
-  }
-
   /**
    * Vortex animation coloration shader
    */
@@ -29,10 +13,28 @@ declare global {
     static override fragmentShader: string;
   }
 
+  namespace VortexColorationShader {
+    interface Any extends AnyVortexColorationShader {}
+    type AnyConstructor = typeof AnyVortexColorationShader;
+  }
+
   /**
    * Vortex animation coloration shader
    */
   class VortexIlluminationShader extends AdaptiveIlluminationShader {
     static override fragmentShader: string;
   }
+
+  namespace VortexIlluminationShader {
+    interface Any extends AnyVortexIlluminationShader {}
+    type AnyConstructor = typeof AnyVortexIlluminationShader;
+  }
+}
+
+declare abstract class AnyVortexColorationShader extends VortexColorationShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare abstract class AnyVortexIlluminationShader extends VortexIlluminationShader {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/lighting/effects/wave.d.mts b/src/foundry/client/pixi/webgl/shaders/lighting/effects/wave.d.mts
index a888985f2..6a1f706ca 100644
--- a/src/foundry/client/pixi/webgl/shaders/lighting/effects/wave.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/lighting/effects/wave.d.mts
@@ -1,22 +1,6 @@
 export {};
 
-declare abstract class AnyWaveColorationShader extends WaveColorationShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
-declare abstract class AnyWaveIlluminationShader extends WaveIlluminationShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace WaveColorationShader {
-    type AnyConstructor = typeof AnyWaveColorationShader;
-  }
-
-  namespace WaveIlluminationShader {
-    type AnyConstructor = typeof AnyWaveIlluminationShader;
-  }
-
   /**
    * Wave animation illumination shader
    */
@@ -24,10 +8,28 @@ declare global {
     static override fragmentShader: string;
   }
 
+  namespace WaveIlluminationShader {
+    interface Any extends AnyWaveIlluminationShader {}
+    type AnyConstructor = typeof AnyWaveIlluminationShader;
+  }
+
   /**
    * Wave animation coloration shader
    */
   class WaveColorationShader extends AdaptiveColorationShader {
     static override fragmentShader: string;
   }
+
+  namespace WaveColorationShader {
+    interface Any extends AnyWaveColorationShader {}
+    type AnyConstructor = typeof AnyWaveColorationShader;
+  }
+}
+
+declare abstract class AnyWaveColorationShader extends WaveColorationShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare abstract class AnyWaveIlluminationShader extends WaveIlluminationShader {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/lighting/illumination-lighting.d.mts b/src/foundry/client/pixi/webgl/shaders/lighting/illumination-lighting.d.mts
index 74daf2d08..63c542713 100644
--- a/src/foundry/client/pixi/webgl/shaders/lighting/illumination-lighting.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/lighting/illumination-lighting.d.mts
@@ -1,14 +1,6 @@
 export {};
 
-declare abstract class AnyAdaptiveIlluminationShader extends AdaptiveIlluminationShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace AdaptiveIlluminationShader {
-    type AnyConstructor = typeof AnyAdaptiveIlluminationShader;
-  }
-
   /**
    * The default coloration shader used by standard rendering and animations
    * A fragment shader which creates a solid light source.
@@ -76,4 +68,13 @@ declare global {
      */
     get isRequired(): boolean;
   }
+
+  namespace AdaptiveIlluminationShader {
+    interface Any extends AnyAdaptiveIlluminationShader {}
+    type AnyConstructor = typeof AnyAdaptiveIlluminationShader;
+  }
+}
+
+declare abstract class AnyAdaptiveIlluminationShader extends AdaptiveIlluminationShader {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/region/adjust-darkness-level.d.mts b/src/foundry/client/pixi/webgl/shaders/region/adjust-darkness-level.d.mts
index 15dbcd98d..7ab56d785 100644
--- a/src/foundry/client/pixi/webgl/shaders/region/adjust-darkness-level.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/region/adjust-darkness-level.d.mts
@@ -1,35 +1,10 @@
 export {};
 
-declare abstract class AnyAbstractDarknessLevelRegionShader extends AbstractDarknessLevelRegionShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
-declare abstract class AnyAdjustDarknessLevelRegionShader extends AdjustDarknessLevelRegionShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
-declare abstract class AnyIlluminationDarknessLevelRegionShader extends IlluminationDarknessLevelRegionShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace AbstractDarknessLevelRegionShader {
-    type AnyConstructor = typeof AnyAbstractDarknessLevelRegionShader;
-  }
-
-  namespace AdjustDarknessLevelRegionShader {
-    type AnyConstructor = typeof AnyAdjustDarknessLevelRegionShader;
-  }
-
-  namespace IlluminationDarknessLevelRegionShader {
-    type AnyConstructor = typeof AnyIlluminationDarknessLevelRegionShader;
-  }
-
   /**
    * Abstract shader used for Adjust Darkness Level region behavior.
-   * @remarks Foundry labeled as abstract
    */
-  class AbstractDarknessLevelRegionShader extends RegionShader {
+  abstract class AbstractDarknessLevelRegionShader extends RegionShader {
     /**
      * @defaultValue
      * ```js
@@ -47,7 +22,7 @@ declare global {
      * The darkness level adjustment mode.
      * @defaultValue `foundry.data.regionBehaviors.AdjustDarknessLevelRegionBehaviorType.MODES.OVERRIDE`
      */
-    mode: foundry.data.regionBehaviors.AdjustDarknessLevelRegionBehaviorType.Modes;
+    mode: foundry.data.regionBehaviors.AdjustDarknessLevelRegionBehaviorType.MODES;
 
     /**
      * The darkness level modifier.
@@ -63,6 +38,11 @@ declare global {
     protected override _preRender: AbstractBaseShader.PreRenderFunction;
   }
 
+  namespace AbstractDarknessLevelRegionShader {
+    interface Any extends AnyAbstractDarknessLevelRegionShader {}
+    type AnyConstructor = typeof AnyAbstractDarknessLevelRegionShader;
+  }
+
   /**
    * Render the RegionMesh with darkness level adjustments.
    */
@@ -104,6 +84,11 @@ declare global {
     protected override _preRender: AbstractBaseShader.PreRenderFunction;
   }
 
+  namespace AdjustDarknessLevelRegionShader {
+    interface Any extends AnyAdjustDarknessLevelRegionShader {}
+    type AnyConstructor = typeof AnyAdjustDarknessLevelRegionShader;
+  }
+
   /**
    * Render the RegionMesh with darkness level adjustments.
    */
@@ -130,4 +115,21 @@ declare global {
      */
     static override fragmentShader: string;
   }
+
+  namespace IlluminationDarknessLevelRegionShader {
+    interface Any extends AnyIlluminationDarknessLevelRegionShader {}
+    type AnyConstructor = typeof AnyIlluminationDarknessLevelRegionShader;
+  }
+}
+
+declare abstract class AnyAbstractDarknessLevelRegionShader extends AbstractDarknessLevelRegionShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare abstract class AnyAdjustDarknessLevelRegionShader extends AdjustDarknessLevelRegionShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare abstract class AnyIlluminationDarknessLevelRegionShader extends IlluminationDarknessLevelRegionShader {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/region/base.d.mts b/src/foundry/client/pixi/webgl/shaders/region/base.d.mts
index 2c5166825..514148a01 100644
--- a/src/foundry/client/pixi/webgl/shaders/region/base.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/region/base.d.mts
@@ -1,14 +1,6 @@
 export {};
 
-declare abstract class AnyRegionShader extends RegionShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace RegionShader {
-    type AnyConstructor = typeof AnyRegionShader;
-  }
-
   /**
    * The shader used by {@link RegionMesh}.
    */
@@ -75,4 +67,13 @@ declare global {
 
     protected override _preRender: AbstractBaseShader.PreRenderFunction;
   }
+
+  namespace RegionShader {
+    interface Any extends AnyRegionShader {}
+    type AnyConstructor = typeof AnyRegionShader;
+  }
+}
+
+declare abstract class AnyRegionShader extends RegionShader {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/region/highlight.d.mts b/src/foundry/client/pixi/webgl/shaders/region/highlight.d.mts
index 7bd436331..9de5ac9d8 100644
--- a/src/foundry/client/pixi/webgl/shaders/region/highlight.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/region/highlight.d.mts
@@ -1,14 +1,6 @@
 export {};
 
-declare abstract class AnyHighlightRegionShader extends HighlightRegionShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace HighlightRegionShader {
-    type AnyConstructor = typeof AnyHighlightRegionShader;
-  }
-
   /**
    * Shader for the Region highlight.
    */
@@ -91,4 +83,13 @@ declare global {
 
     protected override _preRender: AbstractBaseShader.PreRenderFunction;
   }
+
+  namespace HighlightRegionShader {
+    interface Any extends AnyHighlightRegionShader {}
+    type AnyConstructor = typeof AnyHighlightRegionShader;
+  }
+}
+
+declare abstract class AnyHighlightRegionShader extends HighlightRegionShader {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/samplers/base-sampler.d.mts b/src/foundry/client/pixi/webgl/shaders/samplers/base-sampler.d.mts
index 09a0e7b98..397fcf27b 100644
--- a/src/foundry/client/pixi/webgl/shaders/samplers/base-sampler.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/samplers/base-sampler.d.mts
@@ -1,9 +1,5 @@
 import type { InexactPartial, Mixin } from "fvtt-types/utils";
 
-declare abstract class AnyBaseSamplerShader extends BaseSamplerShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare class BatchPlugin<BaseSamplerShaderClass extends BaseSamplerShader.AnyConstructor> {
   /** @privateRemarks All mixin classses should accept anything for its constructor. */
   constructor(...args: any[]);
@@ -26,24 +22,6 @@ declare class BatchGeometry extends PIXI.Geometry {
 }
 
 declare global {
-  namespace BaseSamplerShader {
-    type AnyConstructor = typeof AnyBaseSamplerShader;
-
-    type PluginName = (typeof BaseSamplerShader)["classPluginName"];
-
-    interface BatchGeometryData {
-      id: string;
-      size: number;
-      normalized: boolean;
-      type: PIXI.TYPES;
-    }
-
-    type ToGeometryClass<G extends PIXI.BatchGeometry.AnyConstructor | BaseSamplerShader.BatchGeometryData[]> =
-      G extends readonly unknown[] ? typeof BatchGeometry : G;
-
-    type BatchGeometry = typeof PIXI.BatchGeometry | BaseSamplerShader.BatchGeometryData[];
-  }
-
   /**
    * A simple shader to emulate a PIXI.Sprite with a PIXI.Mesh (but faster!)
    */
@@ -64,7 +42,7 @@ declare global {
      * The plugin name associated for this instance, if any.
      * Returns "batch" if the shader is disabled.
      */
-    get pluginName(): BaseSamplerShader.PluginName;
+    get pluginName(): (typeof BaseSamplerShader)["classPluginName"];
 
     /**
      * Activate or deactivate this sampler. If set to false, the batch rendering is redirected to "batch".
@@ -203,4 +181,25 @@ declare global {
 
     protected override _preRender: AbstractBaseShader.PreRenderFunction;
   }
+
+  namespace BaseSamplerShader {
+    interface Any extends AnyBaseSamplerShader {}
+    type AnyConstructor = typeof AnyBaseSamplerShader;
+
+    interface BatchGeometryData {
+      id: string;
+      size: number;
+      normalized: boolean;
+      type: PIXI.TYPES;
+    }
+
+    type ToGeometryClass<G extends PIXI.BatchGeometry.AnyConstructor | BaseSamplerShader.BatchGeometryData[]> =
+      G extends readonly unknown[] ? typeof BatchGeometry : G;
+
+    type BatchGeometry = typeof PIXI.BatchGeometry | BaseSamplerShader.BatchGeometryData[];
+  }
+}
+
+declare abstract class AnyBaseSamplerShader extends BaseSamplerShader {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/samplers/baseline-illumination.d.mts b/src/foundry/client/pixi/webgl/shaders/samplers/baseline-illumination.d.mts
index 84f386da4..38d9c9970 100644
--- a/src/foundry/client/pixi/webgl/shaders/samplers/baseline-illumination.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/samplers/baseline-illumination.d.mts
@@ -1,14 +1,6 @@
 export {};
 
-declare abstract class AnyBaselineIlluminationSamplerShader extends BaselineIlluminationSamplerShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace BaselineIlluminationSamplerShader {
-    type AnyConstructor = typeof AnyBaselineIlluminationSamplerShader;
-  }
-
   /**
    * Compute baseline illumination according to darkness level encoded texture.
    */
@@ -35,4 +27,13 @@ declare global {
 
     protected override _preRender: AbstractBaseShader.PreRenderFunction;
   }
+
+  namespace BaselineIlluminationSamplerShader {
+    interface Any extends AnyBaselineIlluminationSamplerShader {}
+    type AnyConstructor = typeof AnyBaselineIlluminationSamplerShader;
+  }
+}
+
+declare abstract class AnyBaselineIlluminationSamplerShader extends BaselineIlluminationSamplerShader {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/samplers/color-adjustment.d.mts b/src/foundry/client/pixi/webgl/shaders/samplers/color-adjustment.d.mts
index 3e5b8cab2..b77cacfc5 100644
--- a/src/foundry/client/pixi/webgl/shaders/samplers/color-adjustment.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/samplers/color-adjustment.d.mts
@@ -1,22 +1,6 @@
 export {};
 
-declare abstract class AnyColorAdjustmentsSamplerShader extends ColorAdjustmentsSamplerShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
-declare abstract class AnyAmplificationSamplerShader extends AmplificationSamplerShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace ColorAdjustmentsSamplerShader {
-    type AnyConstructor = typeof AnyColorAdjustmentsSamplerShader;
-  }
-
-  namespace AmplificationSamplerShader {
-    type AnyConstructor = typeof AnyAmplificationSamplerShader;
-  }
-
   /**
    * A color adjustment shader.
    */
@@ -26,6 +10,8 @@ declare global {
      */
     static override classPluginName: string | null;
 
+    static override vertexShader: string;
+
     static override fragmentShader: string;
 
     /**
@@ -33,7 +19,8 @@ declare global {
      * ```js
      * {
      *   tintAlpha: [1, 1, 1, 1],
-     *   tint: [1, 1, 1],  contrast: 0,
+     *   tint: [1, 1, 1],
+     *   contrast: 0,
      *   saturation: 0,
      *   exposure: 0,
      *   sampler: null,
@@ -45,21 +32,30 @@ declare global {
      */
     static override defaultUniforms: AbstractBaseShader.Uniforms;
 
-    get linkedToDarknessLevel(): AbstractBaseShader.UniformValue;
+    /** @privateRemarks Inferred from defaultUniforms */
+    get linkedToDarknessLevel(): boolean;
+
+    set linkedToDarknessLevel(link);
 
-    set linkedToDarknessLevel(link: AbstractBaseShader.UniformValue);
+    /** @privateRemarks Inferred from defaultUniforms */
+    get contrast(): number;
 
-    get contrast(): AbstractBaseShader.UniformValue;
+    set contrast(contrast);
 
-    set contrast(contrast: AbstractBaseShader.UniformValue);
+    /** @privateRemarks Inferred from defaultUniforms */
+    get exposure(): number;
 
-    get exposure(): AbstractBaseShader.UniformValue;
+    set exposure(exposure);
 
-    set exposure(exposure: AbstractBaseShader.UniformValue);
+    /** @privateRemarks Inferred from defaultUniforms */
+    get saturation(): number;
 
-    get saturation(): AbstractBaseShader.UniformValue;
+    set saturation(saturation);
+  }
 
-    set saturation(saturation: AbstractBaseShader.UniformValue);
+  namespace ColorAdjustmentsSamplerShader {
+    interface Any extends AnyColorAdjustmentsSamplerShader {}
+    type AnyConstructor = typeof AnyColorAdjustmentsSamplerShader;
   }
 
   /**
@@ -95,15 +91,28 @@ declare global {
      */
     get brightness(): number;
 
-    set brightness(brightness: AbstractBaseShader.UniformValue);
+    set brightness(brightness);
 
     /**
      * Tint color applied to Light Amplification.
      * Light Amplification tint
      * @defaultValue `[0.48, 1.0, 0.48]`
      */
-    get colorTint(): number[];
+    get colorTint(): Color.RGBColorVector;
 
-    set colorTint(color: AbstractBaseShader.UniformValue);
+    set colorTint(color);
+  }
+
+  namespace AmplificationSamplerShader {
+    interface Any extends AnyAmplificationSamplerShader {}
+    type AnyConstructor = typeof AnyAmplificationSamplerShader;
   }
 }
+
+declare abstract class AnyColorAdjustmentsSamplerShader extends ColorAdjustmentsSamplerShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare abstract class AnyAmplificationSamplerShader extends AmplificationSamplerShader {
+  constructor(arg0: never, ...args: never[]);
+}
diff --git a/src/foundry/client/pixi/webgl/shaders/samplers/depth.d.mts b/src/foundry/client/pixi/webgl/shaders/samplers/depth.d.mts
index d4ea06cf3..055c3a9d1 100644
--- a/src/foundry/client/pixi/webgl/shaders/samplers/depth.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/samplers/depth.d.mts
@@ -1,22 +1,6 @@
 export {};
 
-declare abstract class AnyDepthSamplerShader extends DepthSamplerShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace DepthSamplerShader {
-    type AnyConstructor = typeof AnyDepthSamplerShader;
-
-    interface DepthBatchData extends PIXI.IBatchableElement {
-      elevation: number;
-      textureAlphaThreshold: number;
-      fadeOcclusion: number;
-      radialOcclusion: number;
-      visionOcclusion: number;
-    }
-  }
-
   /**
    * The depth sampler shader.
    */
@@ -100,4 +84,24 @@ declare global {
 
     protected override _preRender: AbstractBaseShader.PreRenderFunction;
   }
+
+  namespace DepthSamplerShader {
+    interface Any extends AnyDepthSamplerShader {}
+    type AnyConstructor = typeof AnyDepthSamplerShader;
+
+    /** @internal */
+    type PartialPIXIBatchable = Pick<PIXI.IBatchableElement, "_texture" | "vertexData" | "indices" | "uvs">;
+
+    interface DepthBatchData extends PartialPIXIBatchable {
+      elevation: number;
+      textureAlphaThreshold: number;
+      fadeOcclusion: number;
+      radialOcclusion: number;
+      visionOcclusion: number;
+    }
+  }
+}
+
+declare abstract class AnyDepthSamplerShader extends DepthSamplerShader {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/samplers/fog-of-war.d.mts b/src/foundry/client/pixi/webgl/shaders/samplers/fog-of-war.d.mts
index 26b5ad5db..987c480b4 100644
--- a/src/foundry/client/pixi/webgl/shaders/samplers/fog-of-war.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/samplers/fog-of-war.d.mts
@@ -1,14 +1,6 @@
 export {};
 
-declare abstract class AnyFogSamplerShader extends FogSamplerShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace FogSamplerShader {
-    type AnyConstructor = typeof AnyFogSamplerShader;
-  }
-
   /**
    * A simple shader which purpose is to make the original texture red channel the alpha channel,
    * and still keeping channel informations. Used in cunjunction with the AlphaBlurFilterPass and Fog of War.
@@ -21,4 +13,13 @@ declare global {
 
     static override fragmentShader: string;
   }
+
+  namespace FogSamplerShader {
+    interface Any extends AnyFogSamplerShader {}
+    type AnyConstructor = typeof AnyFogSamplerShader;
+  }
+}
+
+declare abstract class AnyFogSamplerShader extends FogSamplerShader {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/samplers/occlusion.d.mts b/src/foundry/client/pixi/webgl/shaders/samplers/occlusion.d.mts
index 115e12b1e..6043d82c2 100644
--- a/src/foundry/client/pixi/webgl/shaders/samplers/occlusion.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/samplers/occlusion.d.mts
@@ -1,23 +1,6 @@
 export {};
 
-declare abstract class AnyOccludableSamplerShader extends OccludableSamplerShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace OccludableSamplerShader {
-    type AnyConstructor = typeof AnyOccludableSamplerShader;
-
-    interface OccludableBatchData extends PIXI.IBatchableElement {
-      elevation: number;
-      unoccludedAlpha: number;
-      occludedAlpha: number;
-      fadeOcclusion: number;
-      radialOcclusion: number;
-      visionOcclusion: number;
-    }
-  }
-
   /**
    * An occlusion shader to reveal certain area with elevation comparisons.
    * This shader is also working as a batched plugin.
@@ -101,4 +84,23 @@ declare global {
 
     protected override _preRender: AbstractBaseShader.PreRenderFunction;
   }
+
+  namespace OccludableSamplerShader {
+    interface Any extends AnyOccludableSamplerShader {}
+    type AnyConstructor = typeof AnyOccludableSamplerShader;
+
+    /** @privateRemarks Unlike `DepthSamplerShader`, this class uses every `IBatchableElement` key */
+    interface OccludableBatchData extends PIXI.IBatchableElement {
+      elevation: number;
+      unoccludedAlpha: number;
+      occludedAlpha: number;
+      fadeOcclusion: number;
+      radialOcclusion: number;
+      visionOcclusion: number;
+    }
+  }
+}
+
+declare abstract class AnyOccludableSamplerShader extends OccludableSamplerShader {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/samplers/primary.d.mts b/src/foundry/client/pixi/webgl/shaders/samplers/primary.d.mts
index dc3121100..e2f6f673e 100644
--- a/src/foundry/client/pixi/webgl/shaders/samplers/primary.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/samplers/primary.d.mts
@@ -23,4 +23,13 @@ declare global {
      */
     protected _configureDepthShader(depthShader: DepthSamplerShader): void;
   }
+
+  namespace PrimaryBaseSamplerShader {
+    interface Any extends AnyPrimaryBaseSamplerShader {}
+    type AnyConstructor = typeof AnyPrimaryBaseSamplerShader;
+  }
+}
+
+declare abstract class AnyPrimaryBaseSamplerShader extends PrimaryBaseSamplerShader {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/samplers/token-ring.d.mts b/src/foundry/client/pixi/webgl/shaders/samplers/token-ring.d.mts
index 8d402cc17..f9f57603d 100644
--- a/src/foundry/client/pixi/webgl/shaders/samplers/token-ring.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/samplers/token-ring.d.mts
@@ -1,3 +1,6 @@
+import type { NullishProps } from "../../../../../../utils/index.d.mts";
+import type TokenRing from "../../../../../client-esm/canvas/tokens/ring.d.mts";
+
 export {};
 
 declare global {
@@ -33,7 +36,8 @@ declare global {
     protected static override _preRenderBatch: BatchRenderer.PreRenderBatchFunction;
 
     protected static override _packInterleavedGeometry(
-      element: PIXI.IBatchableElement,
+      /** @privateRemarks Calls super, which is the grandparent class in this case, with no new keys */
+      element: TokenRingSamplerShader.BatchData,
       attributeBuffer: PIXI.ViewableBuffer,
       indexBuffer: Uint16Array,
       aIndex: number,
@@ -44,4 +48,28 @@ declare global {
 
     protected static override _batchFragmentShader: string;
   }
+
+  namespace TokenRingSamplerShader {
+    interface Any extends AnyTokenRingSamplerShader {}
+    type AnyConstructor = typeof AnyTokenRingSamplerShader;
+
+    /** @internal */
+    type RingContainerObject = NullishProps<{
+      object: NullishProps<{
+        ring: TokenRing;
+      }>;
+    }>;
+
+    interface BatchData extends OccludableSamplerShader.OccludableBatchData {
+      /**
+       * @remarks This key is required to be an object as `TokenRingSamplerShader._packInterleavedGeometry` does `element.object.object || {}`.
+       * All `TokenRing` keys are then accessed via optional chaining with `??` defaults.
+       */
+      object: RingContainerObject;
+    }
+  }
+}
+
+declare abstract class AnyTokenRingSamplerShader extends TokenRingSamplerShader {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/vision/background-vision.d.mts b/src/foundry/client/pixi/webgl/shaders/vision/background-vision.d.mts
index 88d3ac0c1..af5cd7984 100644
--- a/src/foundry/client/pixi/webgl/shaders/vision/background-vision.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/vision/background-vision.d.mts
@@ -1,14 +1,6 @@
 export {};
 
-declare abstract class AnyBackgroundVisionShader extends BackgroundVisionShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace BackgroundVisionShader {
-    type AnyConstructor = typeof AnyBackgroundVisionShader;
-  }
-
   /**
    * The default background shader used for vision sources
    */
@@ -39,4 +31,13 @@ declare global {
      */
     get isRequired(): boolean;
   }
+
+  namespace BackgroundVisionShader {
+    interface Any extends AnyBackgroundVisionShader {}
+    type AnyConstructor = typeof AnyBackgroundVisionShader;
+  }
+}
+
+declare abstract class AnyBackgroundVisionShader extends BackgroundVisionShader {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/vision/base-vision.d.mts b/src/foundry/client/pixi/webgl/shaders/vision/base-vision.d.mts
index d856ea70a..4982ede0a 100644
--- a/src/foundry/client/pixi/webgl/shaders/vision/base-vision.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/vision/base-vision.d.mts
@@ -1,14 +1,6 @@
 export {};
 
-declare abstract class AnyAdaptiveVisionShader extends AdaptiveVisionShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace AdaptiveVisionShader {
-    type AnyConstructor = typeof AnyAdaptiveVisionShader;
-  }
-
   /**
    * This class defines an interface which all adaptive vision shaders extend.
    */
@@ -25,7 +17,17 @@ declare global {
 
     /**
      * A mapping of available shader techniques
+     * @remarks Removes all parent techniques other than `LEGACY`
      */
     static override SHADER_TECHNIQUES: Record<string, AdaptiveLightingShader.ShaderTechnique>;
   }
+
+  namespace AdaptiveVisionShader {
+    interface Any extends AnyAdaptiveVisionShader {}
+    type AnyConstructor = typeof AnyAdaptiveVisionShader;
+  }
+}
+
+declare abstract class AnyAdaptiveVisionShader extends AdaptiveVisionShader {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/vision/coloration-vision.d.mts b/src/foundry/client/pixi/webgl/shaders/vision/coloration-vision.d.mts
index e1b080091..0dd95668f 100644
--- a/src/foundry/client/pixi/webgl/shaders/vision/coloration-vision.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/vision/coloration-vision.d.mts
@@ -1,14 +1,6 @@
 export {};
 
-declare abstract class AnyColorationVisionShader extends ColorationVisionShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace ColorationVisionShader {
-    type AnyConstructor = typeof AnyColorationVisionShader;
-  }
-
   /**
    * The default coloration shader used for vision sources.
    */
@@ -38,4 +30,13 @@ declare global {
      */
     get isRequired(): boolean;
   }
+
+  namespace ColorationVisionShader {
+    interface Any extends AnyColorationVisionShader {}
+    type AnyConstructor = typeof AnyColorationVisionShader;
+  }
+}
+
+declare abstract class AnyColorationVisionShader extends ColorationVisionShader {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/vision/effects/amplification.d.mts b/src/foundry/client/pixi/webgl/shaders/vision/effects/amplification.d.mts
index 2abd61158..82721be40 100644
--- a/src/foundry/client/pixi/webgl/shaders/vision/effects/amplification.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/vision/effects/amplification.d.mts
@@ -1,14 +1,6 @@
 export {};
 
-declare abstract class AnyAmplificationBackgroundVisionShader extends AmplificationBackgroundVisionShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace AmplificationBackgroundVisionShader {
-    type AnyConstructor = typeof AnyAmplificationBackgroundVisionShader;
-  }
-
   /**
    * Shader specialized in light amplification
    */
@@ -29,4 +21,13 @@ declare global {
 
     override get isRequired(): boolean;
   }
+
+  namespace AmplificationBackgroundVisionShader {
+    interface Any extends AnyAmplificationBackgroundVisionShader {}
+    type AnyConstructor = typeof AnyAmplificationBackgroundVisionShader;
+  }
+}
+
+declare abstract class AnyAmplificationBackgroundVisionShader extends AmplificationBackgroundVisionShader {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/vision/effects/wave.d.mts b/src/foundry/client/pixi/webgl/shaders/vision/effects/wave.d.mts
index 3c9f49301..00e353546 100644
--- a/src/foundry/client/pixi/webgl/shaders/vision/effects/wave.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/vision/effects/wave.d.mts
@@ -1,22 +1,6 @@
 export {};
 
-declare abstract class AnyWaveBackgroundVisionShader extends WaveBackgroundVisionShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
-declare abstract class AnyWaveColorationVisionShader extends WaveColorationVisionShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace WaveBackgroundVisionShader {
-    type AnyConstructor = typeof AnyWaveBackgroundVisionShader;
-  }
-
-  namespace WaveColorationVisionShader {
-    type AnyConstructor = typeof AnyWaveColorationVisionShader;
-  }
-
   /**
    * Shader specialized in wave like senses (tremorsenses)
    */
@@ -37,6 +21,11 @@ declare global {
     override get isRequired(): boolean;
   }
 
+  namespace WaveBackgroundVisionShader {
+    interface Any extends AnyWaveBackgroundVisionShader {}
+    type AnyConstructor = typeof AnyWaveBackgroundVisionShader;
+  }
+
   /**
    * The wave vision shader, used to create waves emanations (ex: tremorsense)
    */
@@ -56,4 +45,17 @@ declare global {
 
     override get isRequired(): boolean;
   }
+
+  namespace WaveColorationVisionShader {
+    interface Any extends AnyWaveColorationVisionShader {}
+    type AnyConstructor = typeof AnyWaveColorationVisionShader;
+  }
+}
+
+declare abstract class AnyWaveBackgroundVisionShader extends WaveBackgroundVisionShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare abstract class AnyWaveColorationVisionShader extends WaveColorationVisionShader {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/vision/illumination-vision.d.mts b/src/foundry/client/pixi/webgl/shaders/vision/illumination-vision.d.mts
index 4c014bf91..79c6a270b 100644
--- a/src/foundry/client/pixi/webgl/shaders/vision/illumination-vision.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/vision/illumination-vision.d.mts
@@ -1,14 +1,6 @@
 export {};
 
-declare abstract class AnyIlluminationVisionShader extends IlluminationVisionShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace IlluminationVisionShader {
-    type AnyConstructor = typeof AnyIlluminationVisionShader;
-  }
-
   /**
    * The default illumination shader used for vision sources
    */
@@ -33,4 +25,13 @@ declare global {
 
     static override defaultUniforms: AbstractBaseShader.Uniforms;
   }
+
+  namespace IlluminationVisionShader {
+    interface Any extends AnyIlluminationVisionShader {}
+    type AnyConstructor = typeof AnyIlluminationVisionShader;
+  }
+}
+
+declare abstract class AnyIlluminationVisionShader extends IlluminationVisionShader {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/weather/base-weather.d.mts b/src/foundry/client/pixi/webgl/shaders/weather/base-weather.d.mts
index 42f70449e..a38e6e744 100644
--- a/src/foundry/client/pixi/webgl/shaders/weather/base-weather.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/weather/base-weather.d.mts
@@ -5,10 +5,6 @@ import type {
   FixedInstanceType,
 } from "../../../../../../utils/index.d.mts";
 
-declare abstract class AnyAbstractWeatherShader extends AbstractWeatherShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 type AbstractBaseShaderClass = typeof AbstractBaseShader;
 
 interface InternalAbstractWeatherShader_Interface extends AbstractBaseShaderClass {
@@ -26,31 +22,6 @@ class InternalAbstractWeatherShader<
 > extends InternalAbstractWeatherShader_Const<_ComputedUniforms> {}
 
 declare global {
-  namespace AbstractWeatherShader {
-    type AnyConstructor = typeof AnyAbstractWeatherShader;
-
-    interface CommonUniforms {
-      terrainUvMatrix: PIXI.Matrix;
-      useOcclusion: boolean;
-      occlusionTexture: PIXI.Matrix | null;
-      reverseOcclusion: boolean;
-      occlusionWeights: number[];
-      useTerrain: boolean;
-      terrainTexture: PIXI.Texture | null;
-      reverseTerrain: boolean;
-      terrainWeights: number[];
-      alpha: number;
-      tint: number[];
-      screenDimensions: [number, number];
-      effectDimensions: [number, number];
-      depthElevation: number;
-      time: number;
-    }
-
-    // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-    interface DefaultUniforms {}
-  }
-
   /**
    * The base shader class for weather shaders.
    */
@@ -107,4 +78,34 @@ declare global {
 
     protected override _preRender: AbstractBaseShader.PreRenderFunction;
   }
+
+  namespace AbstractWeatherShader {
+    interface Any extends AnyAbstractWeatherShader {}
+    type AnyConstructor = typeof AnyAbstractWeatherShader;
+
+    interface CommonUniforms extends AbstractBaseShader.Uniforms {
+      terrainUvMatrix: PIXI.Matrix;
+      useOcclusion: boolean;
+      occlusionTexture: PIXI.Matrix | null;
+      reverseOcclusion: boolean;
+      occlusionWeights: number[];
+      useTerrain: boolean;
+      terrainTexture: PIXI.Texture | null;
+      reverseTerrain: boolean;
+      terrainWeights: number[];
+      alpha: number;
+      tint: Color.RGBColorVector;
+      screenDimensions: [number, number];
+      effectDimensions: [number, number];
+      depthElevation: number;
+      time: number;
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+    interface DefaultUniforms {}
+  }
+}
+
+declare abstract class AnyAbstractWeatherShader extends AbstractWeatherShader {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/weather/effect.d.mts b/src/foundry/client/pixi/webgl/shaders/weather/effect.d.mts
index 7c9f0db1b..bece86fe0 100644
--- a/src/foundry/client/pixi/webgl/shaders/weather/effect.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/weather/effect.d.mts
@@ -1,9 +1,5 @@
 import type { InexactPartial, FixedInstanceType } from "fvtt-types/utils";
 
-declare abstract class AnyWeatherShaderEffect extends WeatherShaderEffect<any> {
-  constructor(arg0: never, ...args: never[]);
-}
-
 type QuadMeshClass = typeof QuadMesh;
 
 interface InternalWeatherShaderEffect_Interface extends QuadMeshClass {
@@ -16,17 +12,11 @@ declare const InternalWeatherShaderEffect_Const: InternalWeatherShaderEffect_Int
 
 // @ts-expect-error - This pattern inherently requires a ts-expect-error as the base class is dynamic.
 class InternalWeatherShaderEffect<
-  ShaderClass extends AbstractBaseShader.AnyConstructor,
+  ShaderClass extends AbstractWeatherShader.AnyConstructor,
   _ShaderClassInstance extends object = FixedInstanceType<ShaderClass>,
 > extends InternalWeatherShaderEffect_Const<_ShaderClassInstance> {}
 
 declare global {
-  namespace WeatherShaderEffect {
-    type AnyConstructor = typeof AnyWeatherShaderEffect;
-
-    type WeatherShaderEffectConfig = InexactPartial<AbstractBaseShader.Uniforms & WeatherShaderEffect["shader"]>;
-  }
-
   /**
    * An interface for defining shader-based weather effects
    */
@@ -36,7 +26,7 @@ declare global {
     /**
      * @param config - The config object to create the shader effect
      */
-    constructor(config: WeatherShaderEffect.WeatherShaderEffectConfig, shaderClass: ShaderClass);
+    constructor(config: WeatherShaderEffect.WeatherShaderEffectConfig | undefined, shaderClass: ShaderClass);
 
     /**
      * Set shader parameters.
@@ -59,4 +49,15 @@ declare global {
      */
     protected _initialize(config: WeatherShaderEffect.WeatherShaderEffectConfig): void;
   }
+
+  namespace WeatherShaderEffect {
+    interface Any extends AnyWeatherShaderEffect {}
+    type AnyConstructor = typeof AnyWeatherShaderEffect;
+
+    type WeatherShaderEffectConfig = InexactPartial<AbstractBaseShader.Uniforms & WeatherShaderEffect["shader"]>;
+  }
+}
+
+declare abstract class AnyWeatherShaderEffect extends WeatherShaderEffect<AbstractWeatherShader.AnyConstructor> {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/weather/fog.d.mts b/src/foundry/client/pixi/webgl/shaders/weather/fog.d.mts
index aa1c0f16e..590fa6766 100644
--- a/src/foundry/client/pixi/webgl/shaders/weather/fog.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/weather/fog.d.mts
@@ -1,20 +1,6 @@
 import type { InterfaceToObject } from "fvtt-types/utils";
 
-declare abstract class AnyFogShader extends FogShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace FogShader {
-    type AnyConstructor = typeof AnyFogShader;
-
-    interface DefaultUniforms extends AbstractBaseShader.Uniforms {
-      intensity: number;
-      rotation: number;
-      slope: number;
-    }
-  }
-
   /**
    * Fog shader effect.
    */
@@ -47,4 +33,19 @@ declare global {
 
     static override fragmentShader(mode: number): string;
   }
+
+  namespace FogShader {
+    interface Any extends AnyFogShader {}
+    type AnyConstructor = typeof AnyFogShader;
+
+    interface DefaultUniforms extends AbstractBaseShader.Uniforms, AbstractWeatherShader.DefaultUniforms {
+      intensity: number;
+      rotation: number;
+      slope: number;
+    }
+  }
+}
+
+declare abstract class AnyFogShader extends FogShader {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/weather/rain.d.mts b/src/foundry/client/pixi/webgl/shaders/weather/rain.d.mts
index 7407a75dd..6ba3a315e 100644
--- a/src/foundry/client/pixi/webgl/shaders/weather/rain.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/weather/rain.d.mts
@@ -1,22 +1,6 @@
 import type { InterfaceToObject } from "fvtt-types/utils";
 
-declare abstract class AnyRainShader extends RainShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace RainShader {
-    type AnyConstructor = typeof AnyRainShader;
-
-    interface DefaultUniforms extends AbstractBaseShader.Uniforms {
-      opacity: number;
-      intensity: number;
-      strength: number;
-      rotation: number;
-      resolution: [number, number];
-    }
-  }
-
   /**
    * Rain shader effect.
    */
@@ -39,4 +23,21 @@ declare global {
 
     static override fragmentShader: string;
   }
+
+  namespace RainShader {
+    interface Any extends AnyRainShader {}
+    type AnyConstructor = typeof AnyRainShader;
+
+    interface DefaultUniforms extends AbstractBaseShader.Uniforms {
+      opacity: number;
+      intensity: number;
+      strength: number;
+      rotation: number;
+      resolution: [number, number];
+    }
+  }
+}
+
+declare abstract class AnyRainShader extends RainShader {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/pixi/webgl/shaders/weather/snow.d.mts b/src/foundry/client/pixi/webgl/shaders/weather/snow.d.mts
index eb3de267e..34cf4e6ab 100644
--- a/src/foundry/client/pixi/webgl/shaders/weather/snow.d.mts
+++ b/src/foundry/client/pixi/webgl/shaders/weather/snow.d.mts
@@ -1,18 +1,6 @@
 import type { InterfaceToObject } from "fvtt-types/utils";
 
-declare abstract class AnySnowShader extends SnowShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace SnowShader {
-    type AnyConstructor = typeof AnySnowShader;
-
-    interface DefaultUniforms extends AbstractBaseShader.Uniforms {
-      direction: number;
-    }
-  }
-
   /**
    * Snow shader effect.
    */
@@ -31,4 +19,17 @@ declare global {
 
     static override fragmentShader: string;
   }
+
+  namespace SnowShader {
+    interface Any extends AnySnowShader {}
+    type AnyConstructor = typeof AnySnowShader;
+
+    interface DefaultUniforms extends AbstractBaseShader.Uniforms {
+      direction: number;
+    }
+  }
+}
+
+declare abstract class AnySnowShader extends SnowShader {
+  constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/common/utils/color.d.mts b/src/foundry/common/utils/color.d.mts
index 85c2e12e4..c7e91857f 100644
--- a/src/foundry/common/utils/color.d.mts
+++ b/src/foundry/common/utils/color.d.mts
@@ -292,6 +292,7 @@ declare class Color extends Number {
 
 declare namespace Color {
   type RGBColorVector = [r: number, g: number, b: number];
+  type RGVAColorVector = [r: number, g: number, b: number, a: number];
   type HSVColorVector = [h: number, s: number, v: number];
   type HSLColorVector = [h: number, s: number, l: number];
 


Test patch:
diff --git a/tests/foundry/client/pixi/webgl/extensions/batch-renderer.test-d.ts b/tests/foundry/client/pixi/webgl/extensions/batch-renderer.test-d.ts
new file mode 100644
index 000000000..dc7af0bbe
--- /dev/null
+++ b/tests/foundry/client/pixi/webgl/extensions/batch-renderer.test-d.ts
@@ -0,0 +1,10 @@
+import { expectTypeOf } from "vitest";
+
+expectTypeOf(BatchRenderer.shaderGeneratorClass).toEqualTypeOf<typeof BatchShaderGenerator>();
+expectTypeOf(BatchRenderer.hasPlugin("bob")).toEqualTypeOf<boolean>;
+
+declare const someRenderer: PIXI.Renderer;
+const myBR = new BatchRenderer(someRenderer);
+
+expectTypeOf(myBR.reservedTextureUnits).toEqualTypeOf<BatchRenderer.ReservedTextureUnits>();
+expectTypeOf(myBR.start()).toEqualTypeOf<void>();
diff --git a/tests/foundry/client/pixi/webgl/extensions/batch-shader-generator.test-d.ts b/tests/foundry/client/pixi/webgl/extensions/batch-shader-generator.test-d.ts
new file mode 100644
index 000000000..290f09aa0
--- /dev/null
+++ b/tests/foundry/client/pixi/webgl/extensions/batch-shader-generator.test-d.ts
@@ -0,0 +1,9 @@
+import { expectTypeOf } from "vitest";
+
+const myBSG = new BatchShaderGenerator("some glsl", "some other glsl", {
+  foo: true,
+  bar: 5,
+  baz: [1, 2, 2],
+});
+
+expectTypeOf(myBSG.generateShader(4)).toEqualTypeOf<PIXI.Shader>();
diff --git a/tests/foundry/client/pixi/webgl/helpers/framebuffer-snapshot.test-d.ts b/tests/foundry/client/pixi/webgl/helpers/framebuffer-snapshot.test-d.ts
new file mode 100644
index 000000000..95a141263
--- /dev/null
+++ b/tests/foundry/client/pixi/webgl/helpers/framebuffer-snapshot.test-d.ts
@@ -0,0 +1,7 @@
+import { expectTypeOf } from "vitest";
+
+const myFS = new FramebufferSnapshot();
+declare const someRenderer: PIXI.Renderer;
+
+expectTypeOf(myFS.framebufferTexture).toEqualTypeOf<PIXI.RenderTexture>();
+expectTypeOf(myFS.getFramebufferTexture(someRenderer)).toEqualTypeOf<PIXI.RenderTexture>();
diff --git a/tests/foundry/client/pixi/webgl/helpers/smooth-noise.test-d.ts b/tests/foundry/client/pixi/webgl/helpers/smooth-noise.test-d.ts
new file mode 100644
index 000000000..c25d7ef86
--- /dev/null
+++ b/tests/foundry/client/pixi/webgl/helpers/smooth-noise.test-d.ts
@@ -0,0 +1,12 @@
+import { expectTypeOf } from "vitest";
+
+const mySN = new SmoothNoise({
+  amplitude: 0.2,
+  scale: 1,
+  maxReferences: 16,
+});
+
+expectTypeOf(mySN.amplitude).toEqualTypeOf<number>();
+expectTypeOf(mySN.scale).toEqualTypeOf<number>();
+expectTypeOf(mySN["_references"]).toEqualTypeOf<number[]>();
+expectTypeOf(mySN.generate(4)).toEqualTypeOf<number>();
diff --git a/tests/foundry/client/pixi/webgl/helpers/texture-extractor.test-d.ts b/tests/foundry/client/pixi/webgl/helpers/texture-extractor.test-d.ts
new file mode 100644
index 000000000..ad0e73d6a
--- /dev/null
+++ b/tests/foundry/client/pixi/webgl/helpers/texture-extractor.test-d.ts
@@ -0,0 +1,24 @@
+import { expectTypeOf } from "vitest";
+
+expectTypeOf(TextureExtractor.COMPRESSION_MODES.BASE64).toMatchTypeOf<TextureExtractor.COMPRESSION_MODES>();
+
+declare const someRenderer: PIXI.Renderer;
+const myTE = new TextureExtractor(someRenderer, {
+  callerName: "bob",
+  controlHash: false,
+  format: PIXI.FORMATS.RGBA,
+});
+
+declare const someRect: PIXI.Rectangle;
+declare const someTex: PIXI.Texture;
+expectTypeOf(myTE.pixelBuffer).toEqualTypeOf<Uint8ClampedArray>();
+expectTypeOf(
+  myTE.extract({
+    compression: TextureExtractor.COMPRESSION_MODES.BASE64,
+    frame: someRect,
+    quality: 0.85,
+    type: "image/webp",
+    texture: someTex,
+    debug: false,
+  }),
+).toEqualTypeOf<Promise<string | Uint8ClampedArray>>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/base-shader-mixin.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/base-shader-mixin.test-d.ts
new file mode 100644
index 000000000..8e01e2482
--- /dev/null
+++ b/tests/foundry/client/pixi/webgl/shaders/base-shader-mixin.test-d.ts
@@ -0,0 +1,1 @@
+// Intentionally blank, tested in base-shader.test-d.ts
diff --git a/tests/foundry/client/pixi/webgl/shaders/base.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/base.test-d.ts
index fcd9100da..66b808a60 100644
--- a/tests/foundry/client/pixi/webgl/shaders/base.test-d.ts
+++ b/tests/foundry/client/pixi/webgl/shaders/base.test-d.ts
@@ -1,18 +1,16 @@
 import { expectTypeOf } from "vitest";
 
-class TestShader extends AbstractBaseShader {
-  constructor(program: PIXI.Program, uniforms: AbstractBaseShader.Uniforms) {
-    super(program, uniforms);
-    this.defaults = this._defaults;
-  }
-
-  defaults: AbstractBaseShader["_defaults"];
-}
+class TestShader extends AbstractBaseShader {}
 
 expectTypeOf(TestShader.defaultUniforms.foo).toEqualTypeOf<AbstractBaseShader.UniformValue>();
 expectTypeOf(TestShader.defaultUniforms.bar).toEqualTypeOf<AbstractBaseShader.UniformValue>();
 
-const testShader2 = TestShader.create({
+//BaseShaderMixin tests
+expectTypeOf(TestShader.WAVE()).toEqualTypeOf<string>();
+expectTypeOf(TestShader.FBM(2, 1.6)).toEqualTypeOf<string>();
+expectTypeOf(TestShader.VORONOI).toEqualTypeOf<string>();
+
+const testShaderInstance = TestShader.create({
   alpha: 1.0,
   ratio: 0.5,
   colorDim: [0.5, 0.5, 0.5],
@@ -20,7 +18,7 @@ const testShader2 = TestShader.create({
   time: 0,
   intensity: 5,
 });
-testShader2.uniforms.darkness = false;
+testShaderInstance.uniforms.darkness = false;
 
-// @ts-expect-error - create requires a constructor for TestShader
+// @ts-expect-error - string is not a valid UniformValue
 TestShader.create({ foo: "bar" });
diff --git a/tests/foundry/client/pixi/webgl/shaders/effects/lighting.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/effects/lighting.test-d.ts
deleted file mode 100644
index c6da26deb..000000000
--- a/tests/foundry/client/pixi/webgl/shaders/effects/lighting.test-d.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { expectTypeOf } from "vitest";
-
-expectTypeOf(AdaptiveLightingShader.create()).toEqualTypeOf<AdaptiveLightingShader>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/effects/vision.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/effects/vision.test-d.ts
deleted file mode 100644
index d448e3933..000000000
--- a/tests/foundry/client/pixi/webgl/shaders/effects/vision.test-d.ts
+++ /dev/null
@@ -1,12 +0,0 @@
-import { expectTypeOf } from "vitest";
-
-class myVisionShader extends AmplificationBackgroundVisionShader {
-  static COLOR_TINT = [0.25, 0.41, 0.88];
-
-  static override defaultUniforms = {
-    ...super.defaultUniforms,
-    colorTint: this.COLOR_TINT,
-  };
-}
-
-expectTypeOf(myVisionShader.create()).toEqualTypeOf<myVisionShader>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/effects/weather/base.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/effects/weather/base.test-d.ts
deleted file mode 100644
index 874c8445b..000000000
--- a/tests/foundry/client/pixi/webgl/shaders/effects/weather/base.test-d.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { expectTypeOf } from "vitest";
-
-expectTypeOf(AbstractWeatherShader.create()).toEqualTypeOf<AbstractWeatherShader>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/effects/weather/effect.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/effects/weather/effect.test-d.ts
deleted file mode 100644
index c70f94d3e..000000000
--- a/tests/foundry/client/pixi/webgl/shaders/effects/weather/effect.test-d.ts
+++ /dev/null
@@ -1,5 +0,0 @@
-import { expectTypeOf } from "vitest";
-
-const myWeatherEffect = new WeatherShaderEffect({ enabled: true, blendMode: PIXI.BLEND_MODES.SCREEN }, FogShader);
-
-expectTypeOf(myWeatherEffect.configure({})).toEqualTypeOf<void>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/effects/weather/fog.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/effects/weather/fog.test-d.ts
deleted file mode 100644
index 7661984ea..000000000
--- a/tests/foundry/client/pixi/webgl/shaders/effects/weather/fog.test-d.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { expectTypeOf } from "vitest";
-
-expectTypeOf(FogShader.create()).toEqualTypeOf<FogShader>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/effects/weather/rain.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/effects/weather/rain.test-d.ts
deleted file mode 100644
index f0c238ac0..000000000
--- a/tests/foundry/client/pixi/webgl/shaders/effects/weather/rain.test-d.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { expectTypeOf } from "vitest";
-
-expectTypeOf(RainShader.create()).toEqualTypeOf<RainShader>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/effects/weather/snow.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/effects/weather/snow.test-d.ts
deleted file mode 100644
index eb51940c0..000000000
--- a/tests/foundry/client/pixi/webgl/shaders/effects/weather/snow.test-d.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { expectTypeOf } from "vitest";
-
-expectTypeOf(SnowShader.create()).toEqualTypeOf<SnowShader>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/filters/base-filter.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/filters/base-filter.test-d.ts
new file mode 100644
index 000000000..1d72ce837
--- /dev/null
+++ b/tests/foundry/client/pixi/webgl/shaders/filters/base-filter.test-d.ts
@@ -0,0 +1,10 @@
+import { expectTypeOf } from "vitest";
+
+class TestFilter extends AbstractBaseFilter {}
+let testFilterInstance;
+
+expectTypeOf(TestFilter.vertexShader).toEqualTypeOf<string | undefined>();
+expectTypeOf(TestFilter.defaultUniforms).toEqualTypeOf<AbstractBaseShader.Uniforms>();
+expectTypeOf((testFilterInstance = TestFilter.create())).toEqualTypeOf<TestFilter>();
+
+expectTypeOf(testFilterInstance.padding).toMatchTypeOf<number>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/filters/base-mask-filter.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/filters/base-mask-filter.test-d.ts
new file mode 100644
index 000000000..44304769a
--- /dev/null
+++ b/tests/foundry/client/pixi/webgl/shaders/filters/base-mask-filter.test-d.ts
@@ -0,0 +1,12 @@
+import { expectTypeOf } from "vitest";
+
+expectTypeOf(AbstractBaseMaskFilter.vertexShader).toEqualTypeOf<string>();
+
+let myABMF;
+expectTypeOf((myABMF = AbstractBaseMaskFilter.create())).toEqualTypeOf<AbstractBaseMaskFilter>();
+
+declare const someFilterSystem: PIXI.FilterSystem;
+declare const someRT1: PIXI.RenderTexture;
+declare const someRT2: PIXI.RenderTexture;
+
+expectTypeOf(myABMF.apply(someFilterSystem, someRT1, someRT2, PIXI.CLEAR_MODES.BLIT)).toEqualTypeOf<void>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/filters/blur.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/filters/blur.test-d.ts
index c02e94af1..24fd74580 100644
--- a/tests/foundry/client/pixi/webgl/shaders/filters/blur.test-d.ts
+++ b/tests/foundry/client/pixi/webgl/shaders/filters/blur.test-d.ts
@@ -1,5 +1,15 @@
 import { expectTypeOf } from "vitest";
 
-const myFilter = new AlphaBlurFilterPass(true);
+//AlphaBlurFilterPass tests
+expectTypeOf(AlphaBlurFilterPass.vertTemplate(2, false)).toEqualTypeOf<string>();
 
-expectTypeOf(myFilter.blur).toEqualTypeOf<number>();
+const myABFilterPass = new AlphaBlurFilterPass(true, 4, 2, 500, 3);
+
+expectTypeOf(myABFilterPass.blur).toEqualTypeOf<number>();
+
+//AlphaBlurFilter tests
+const myABFilter = new AlphaBlurFilter(4, 2, 500, 2);
+declare const someRT: PIXI.RenderTexture;
+declare const someFilterSystem: PIXI.FilterSystem;
+expectTypeOf(myABFilter.apply(someFilterSystem, someRT, someRT, PIXI.CLEAR_MODES.AUTO)).toEqualTypeOf<void>();
+expectTypeOf(myABFilter.blendMode).toEqualTypeOf<PIXI.BLEND_MODES>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/filters/effects-masking.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/filters/effects-masking.test-d.ts
new file mode 100644
index 000000000..94317da7a
--- /dev/null
+++ b/tests/foundry/client/pixi/webgl/shaders/filters/effects-masking.test-d.ts
@@ -0,0 +1,13 @@
+import { expectTypeOf } from "vitest";
+
+const VEMF = VisualEffectsMaskingFilter;
+
+expectTypeOf(VEMF.FILTER_MODES).toMatchTypeOf<Record<string, number & VisualEffectsMaskingFilter.FILTER_MODES>>();
+expectTypeOf(VEMF.POST_PROCESS_TECHNIQUES).toMatchTypeOf<
+  Record<string, { id: string & VisualEffectsMaskingFilter.POST_PROCESS_TECHNIQUES_ID; glsl: string }>
+>();
+expectTypeOf(VEMF.fragmentPostProcess(["CONTRAST"])).toEqualTypeOf<string>();
+
+const myVEMF = VEMF.create({ postProcessModes: ["EXPOSURE"] });
+
+expectTypeOf(myVEMF.updatePostprocessModes(["EXPOSURE"], { foo: 16, bar: [1, 2, 3] })).toEqualTypeOf<void>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/filters/environment.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/filters/environment.test-d.ts
new file mode 100644
index 000000000..3321825db
--- /dev/null
+++ b/tests/foundry/client/pixi/webgl/shaders/filters/environment.test-d.ts
@@ -0,0 +1,5 @@
+import { expectTypeOf } from "vitest";
+
+expectTypeOf(PrimaryCanvasGroupAmbienceFilter.fragmentShader).toEqualTypeOf<string>();
+
+expectTypeOf(PrimaryCanvasGroupAmbienceFilter.create()).toEqualTypeOf<PrimaryCanvasGroupAmbienceFilter>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/filters/glow-overlay.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/filters/glow-overlay.test-d.ts
new file mode 100644
index 000000000..cf4e98247
--- /dev/null
+++ b/tests/foundry/client/pixi/webgl/shaders/filters/glow-overlay.test-d.ts
@@ -0,0 +1,8 @@
+import { expectTypeOf } from "vitest";
+
+let myGOF;
+expectTypeOf(GlowOverlayFilter.createFragmentShader(2, 20)).toEqualTypeOf<string>();
+expectTypeOf((myGOF = GlowOverlayFilter.create())).toEqualTypeOf<GlowOverlayFilter>();
+
+expectTypeOf(myGOF.padding).toEqualTypeOf<number>();
+expectTypeOf(myGOF.animated).toEqualTypeOf<boolean>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/filters/invisibility.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/filters/invisibility.test-d.ts
new file mode 100644
index 000000000..d50802466
--- /dev/null
+++ b/tests/foundry/client/pixi/webgl/shaders/filters/invisibility.test-d.ts
@@ -0,0 +1,8 @@
+import { expectTypeOf } from "vitest";
+
+expectTypeOf(InvisibilityFilter.fragmentShader).toEqualTypeOf<string>();
+expectTypeOf(InvisibilityFilter.defaultUniforms).toEqualTypeOf<AbstractBaseShader.Uniforms>();
+
+let myIF;
+expectTypeOf((myIF = InvisibilityFilter.create())).toEqualTypeOf<InvisibilityFilter>();
+expectTypeOf(myIF.padding).toEqualTypeOf<number>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/filters/outline-overlay.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/filters/outline-overlay.test-d.ts
new file mode 100644
index 000000000..bd8a440e9
--- /dev/null
+++ b/tests/foundry/client/pixi/webgl/shaders/filters/outline-overlay.test-d.ts
@@ -0,0 +1,8 @@
+import { expectTypeOf } from "vitest";
+
+expectTypeOf(OutlineOverlayFilter.vertexShader).toEqualTypeOf<string>();
+expectTypeOf(OutlineOverlayFilter.createFragmentShader()).toEqualTypeOf<string>();
+
+let myOOF;
+expectTypeOf((myOOF = OutlineOverlayFilter.create())).toEqualTypeOf<OutlineOverlayFilter>();
+expectTypeOf(myOOF.thickness).toEqualTypeOf<number>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/filters/transition.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/filters/transition.test-d.ts
new file mode 100644
index 000000000..644c19491
--- /dev/null
+++ b/tests/foundry/client/pixi/webgl/shaders/filters/transition.test-d.ts
@@ -0,0 +1,19 @@
+import { expectTypeOf } from "vitest";
+
+declare const someSprite: PIXI.Sprite;
+declare const someTex: PIXI.Texture;
+let myTTF;
+
+expectTypeOf(TextureTransitionFilter.TYPES.CROSSHATCH).toMatchTypeOf<TextureTransitionFilter.TYPES>();
+expectTypeOf(
+  TextureTransitionFilter.animate(someSprite, someTex, {
+    duration: 400,
+    name: "bob",
+    easing: "easeInCircle",
+    type: TextureTransitionFilter.TYPES.HOLE,
+  }),
+).toEqualTypeOf<Promise<boolean>>();
+expectTypeOf(TextureTransitionFilter.fragmentShader).toEqualTypeOf<string>();
+
+expectTypeOf((myTTF = TextureTransitionFilter.create())).toEqualTypeOf<TextureTransitionFilter>();
+expectTypeOf(myTTF.type).toEqualTypeOf<TextureTransitionFilter.TYPES>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/filters/visibilty.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/filters/visibilty.test-d.ts
new file mode 100644
index 000000000..bd29bba1e
--- /dev/null
+++ b/tests/foundry/client/pixi/webgl/shaders/filters/visibilty.test-d.ts
@@ -0,0 +1,11 @@
+import { expectTypeOf } from "vitest";
+
+let myVF;
+declare const someFilterSystem: PIXI.FilterSystem;
+
+expectTypeOf(VisibilityFilter.fragmentShader({ persistentVision: true })).toEqualTypeOf<string>();
+expectTypeOf(VisibilityFilter.vertexShader).toEqualTypeOf<string>();
+expectTypeOf((myVF = VisibilityFilter.create())).toEqualTypeOf<VisibilityFilter>();
+
+expectTypeOf(myVF.calculateMatrix(someFilterSystem)).toEqualTypeOf<void>();
+expectTypeOf(myVF.blur).toEqualTypeOf<number>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/filters/vision-mask-filter.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/filters/vision-mask-filter.test-d.ts
new file mode 100644
index 000000000..de30e0dc7
--- /dev/null
+++ b/tests/foundry/client/pixi/webgl/shaders/filters/vision-mask-filter.test-d.ts
@@ -0,0 +1,8 @@
+import { expectTypeOf } from "vitest";
+
+let myVMF;
+
+expectTypeOf(VisionMaskFilter.fragmentShader).toEqualTypeOf<string>();
+expectTypeOf((myVMF = VisionMaskFilter.create())).toEqualTypeOf<VisionMaskFilter>();
+
+expectTypeOf(myVMF.enabled).toEqualTypeOf<boolean>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/filters/void.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/filters/void.test-d.ts
new file mode 100644
index 000000000..564e2c647
--- /dev/null
+++ b/tests/foundry/client/pixi/webgl/shaders/filters/void.test-d.ts
@@ -0,0 +1,8 @@
+import { expectTypeOf } from "vitest";
+
+let myVoidFilter;
+
+expectTypeOf(VoidFilter.fragmentShader).toEqualTypeOf<string>();
+expectTypeOf((myVoidFilter = VoidFilter.create())).toEqualTypeOf<VoidFilter>();
+
+expectTypeOf(myVoidFilter.padding).toEqualTypeOf<number>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/filters/weather-occlusion-masks.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/filters/weather-occlusion-masks.test-d.ts
new file mode 100644
index 000000000..138ec8102
--- /dev/null
+++ b/tests/foundry/client/pixi/webgl/shaders/filters/weather-occlusion-masks.test-d.ts
@@ -0,0 +1,8 @@
+import { expectTypeOf } from "vitest";
+
+let myWOMF;
+
+expectTypeOf(WeatherOcclusionMaskFilter.vertexShader).toEqualTypeOf<string>();
+expectTypeOf((myWOMF = WeatherOcclusionMaskFilter.create())).toEqualTypeOf<WeatherOcclusionMaskFilter>();
+
+expectTypeOf(myWOMF.elevation).toEqualTypeOf<number>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/fragment-channel-mixin.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/fragment-channel-mixin.test-d.ts
new file mode 100644
index 000000000..22b61d8a1
--- /dev/null
+++ b/tests/foundry/client/pixi/webgl/shaders/fragment-channel-mixin.test-d.ts
@@ -0,0 +1,19 @@
+import { expectTypeOf } from "vitest";
+
+class MyFragmentChannelShader extends AdaptiveFragmentChannelMixin(BaseSamplerShader) {}
+
+//TODO: figure out how to make this return the mixed shader or filter class
+expectTypeOf(MyFragmentChannelShader.create({ channel: "r", foo: 0.5, bar: [1, 0] })).toEqualTypeOf<
+  PIXI.Shader | PIXI.Filter
+>();
+if (MyFragmentChannelShader.adaptiveFragmentShader) {
+  expectTypeOf(MyFragmentChannelShader.adaptiveFragmentShader).toEqualTypeOf<
+    (channel: AdaptiveFragmentChannel.Channel) => string
+  >();
+} else {
+  expectTypeOf(MyFragmentChannelShader.adaptiveFragmentShader).toEqualTypeOf<null>();
+}
+
+declare const someProgram: PIXI.Program;
+const myFCSInstance = new MyFragmentChannelShader(someProgram, { baz: 32 });
+expectTypeOf(myFCSInstance.uniforms).toMatchTypeOf<AbstractBaseShader.Uniforms>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/grid/grid.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/grid/grid.test-d.ts
new file mode 100644
index 000000000..a0287a44d
--- /dev/null
+++ b/tests/foundry/client/pixi/webgl/shaders/grid/grid.test-d.ts
@@ -0,0 +1,12 @@
+import { expectTypeOf } from "vitest";
+
+let myGS;
+declare const someMesh: PIXI.Mesh;
+declare const someRenderer: PIXI.Renderer;
+
+expectTypeOf(GridShader.TYPE_UNIFORM).toEqualTypeOf<string>();
+expectTypeOf(GridShader.fragmentShader).toEqualTypeOf<string>();
+expectTypeOf((myGS = GridShader.create())).toEqualTypeOf<GridShader>();
+
+expectTypeOf(myGS.configure({ style: 5 })).toEqualTypeOf<void>();
+expectTypeOf(myGS["_preRender"](someMesh, someRenderer)).toEqualTypeOf<void>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/lighting/background-lighting.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/lighting/background-lighting.test-d.ts
new file mode 100644
index 000000000..f957f676d
--- /dev/null
+++ b/tests/foundry/client/pixi/webgl/shaders/lighting/background-lighting.test-d.ts
@@ -0,0 +1,8 @@
+import { expectTypeOf } from "vitest";
+
+let myABS;
+
+expectTypeOf(AdaptiveBackgroundShader.SHADER_HEADER).toEqualTypeOf<string>();
+expectTypeOf((myABS = AdaptiveBackgroundShader.create())).toEqualTypeOf<AdaptiveBackgroundShader>();
+
+expectTypeOf(myABS.isRequired).toEqualTypeOf<boolean>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/lighting/base-lighting.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/lighting/base-lighting.test-d.ts
new file mode 100644
index 000000000..971c44ddb
--- /dev/null
+++ b/tests/foundry/client/pixi/webgl/shaders/lighting/base-lighting.test-d.ts
@@ -0,0 +1,14 @@
+import { expectTypeOf } from "vitest";
+
+let myALS;
+
+expectTypeOf(AdaptiveLightingShader.forceDefaultColor).toEqualTypeOf<boolean>();
+expectTypeOf(AdaptiveLightingShader.SHADER_TECHNIQUES).toMatchTypeOf<
+  Record<string, AdaptiveLightingShader.ShaderTechnique>
+>();
+expectTypeOf(AdaptiveLightingShader.getShaderTechniques("background")).toEqualTypeOf<string>();
+expectTypeOf((myALS = AdaptiveLightingShader.create())).toEqualTypeOf<AdaptiveLightingShader>();
+
+expectTypeOf(myALS.update()).toEqualTypeOf<void>();
+//deprecated since 12 until 14 but I wanted a second instance test
+expectTypeOf(myALS.getDarknessPenalty(0.8, -0.2)).toEqualTypeOf<number>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/lighting/coloration-lighting.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/lighting/coloration-lighting.test-d.ts
new file mode 100644
index 000000000..ca3fccdaa
--- /dev/null
+++ b/tests/foundry/client/pixi/webgl/shaders/lighting/coloration-lighting.test-d.ts
@@ -0,0 +1,10 @@
+import { expectTypeOf } from "vitest";
+
+let myACS;
+
+expectTypeOf(AdaptiveColorationShader.SHADER_HEADER).toEqualTypeOf<string>();
+expectTypeOf(AdaptiveColorationShader.defaultUniforms).toEqualTypeOf<AbstractBaseShader.Uniforms>();
+expectTypeOf((myACS = AdaptiveColorationShader.create())).toEqualTypeOf<AdaptiveColorationShader>();
+
+expectTypeOf(myACS.isRequired).toEqualTypeOf<boolean>();
+expectTypeOf(myACS.initialUniforms).toEqualTypeOf<AbstractBaseShader.Uniforms>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/lighting/darkness-lighting.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/lighting/darkness-lighting.test-d.ts
new file mode 100644
index 000000000..75cc5ca40
--- /dev/null
+++ b/tests/foundry/client/pixi/webgl/shaders/lighting/darkness-lighting.test-d.ts
@@ -0,0 +1,10 @@
+import { expectTypeOf } from "vitest";
+
+let myADS;
+
+expectTypeOf(AdaptiveDarknessShader.FRAGMENT_BEGIN).toEqualTypeOf<string>();
+expectTypeOf(AdaptiveDarknessShader.fragmentShader).toEqualTypeOf<string>();
+expectTypeOf((myADS = AdaptiveDarknessShader.create())).toEqualTypeOf<AdaptiveDarknessShader>();
+
+expectTypeOf(myADS.update()).toEqualTypeOf<void>();
+expectTypeOf(myADS.isRequired).toEqualTypeOf<boolean>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/lighting/illumination-lighting.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/lighting/illumination-lighting.test-d.ts
new file mode 100644
index 000000000..7a33fb2ef
--- /dev/null
+++ b/tests/foundry/client/pixi/webgl/shaders/lighting/illumination-lighting.test-d.ts
@@ -0,0 +1,10 @@
+import { expectTypeOf } from "vitest";
+
+let myAIS;
+
+expectTypeOf(AdaptiveIlluminationShader.SHADER_HEADER).toEqualTypeOf<string>();
+expectTypeOf(AdaptiveIlluminationShader.fragmentShader).toEqualTypeOf<string>();
+expectTypeOf((myAIS = AdaptiveIlluminationShader.create())).toEqualTypeOf<AdaptiveIlluminationShader>();
+
+expectTypeOf(myAIS.isRequired).toEqualTypeOf<boolean>();
+expectTypeOf(myAIS.initialUniforms).toEqualTypeOf<AbstractBaseShader.Uniforms>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/region/adjust-darkness-level.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/region/adjust-darkness-level.test-d.ts
new file mode 100644
index 000000000..265b6041a
--- /dev/null
+++ b/tests/foundry/client/pixi/webgl/shaders/region/adjust-darkness-level.test-d.ts
@@ -0,0 +1,17 @@
+import { expectTypeOf } from "vitest";
+
+let myADLRS;
+
+expectTypeOf(AdjustDarknessLevelRegionShader.fragmentShader).toEqualTypeOf<string>();
+expectTypeOf((myADLRS = AdjustDarknessLevelRegionShader.create())).toEqualTypeOf<AdjustDarknessLevelRegionShader>();
+
+expectTypeOf(myADLRS.mode).toEqualTypeOf<foundry.data.regionBehaviors.AdjustDarknessLevelRegionBehaviorType.MODES>();
+
+let myIDLRS;
+
+expectTypeOf(IlluminationDarknessLevelRegionShader.fragmentShader).toEqualTypeOf<string>();
+expectTypeOf(
+  (myIDLRS = IlluminationDarknessLevelRegionShader.create()),
+).toEqualTypeOf<IlluminationDarknessLevelRegionShader>();
+
+expectTypeOf(myIDLRS.modifier).toEqualTypeOf<number>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/region/base.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/region/base.test-d.ts
new file mode 100644
index 000000000..526195f85
--- /dev/null
+++ b/tests/foundry/client/pixi/webgl/shaders/region/base.test-d.ts
@@ -0,0 +1,10 @@
+import { expectTypeOf } from "vitest";
+
+let myRS;
+declare const someMesh: PIXI.Mesh;
+declare const someRenderer: PIXI.Renderer;
+
+expectTypeOf(RegionShader.fragmentShader).toEqualTypeOf<string>();
+expectTypeOf((myRS = RegionShader.create())).toEqualTypeOf<RegionShader>();
+
+expectTypeOf(myRS["_preRender"](someMesh, someRenderer)).toEqualTypeOf<void>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/region/highlight.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/region/highlight.test-d.ts
new file mode 100644
index 000000000..cdf4ef13c
--- /dev/null
+++ b/tests/foundry/client/pixi/webgl/shaders/region/highlight.test-d.ts
@@ -0,0 +1,10 @@
+import { expectTypeOf } from "vitest";
+
+let myHRS;
+declare const someMesh: PIXI.Mesh;
+declare const someRenderer: PIXI.Renderer;
+
+expectTypeOf(HighlightRegionShader.fragmentShader).toEqualTypeOf<string>();
+expectTypeOf((myHRS = HighlightRegionShader.create())).toEqualTypeOf<HighlightRegionShader>();
+
+expectTypeOf(myHRS["_preRender"](someMesh, someRenderer)).toEqualTypeOf<void>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/samplers/base-sampler.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/samplers/base-sampler.test-d.ts
new file mode 100644
index 000000000..8b1b53e1c
--- /dev/null
+++ b/tests/foundry/client/pixi/webgl/shaders/samplers/base-sampler.test-d.ts
@@ -0,0 +1,13 @@
+import { expectTypeOf } from "vitest";
+
+let myBSS;
+
+expectTypeOf(BaseSamplerShader.pausable).toEqualTypeOf<boolean>();
+expectTypeOf(BaseSamplerShader.classPluginName).toEqualTypeOf<string | null>();
+expectTypeOf(BaseSamplerShader.fragmentShader).toEqualTypeOf<string>();
+expectTypeOf(BaseSamplerShader.registerPlugin({ force: true })).toEqualTypeOf<void>();
+// I'd like to test `.createPlugin` but the BatchPlugin magic isn't exported
+expectTypeOf((myBSS = BaseSamplerShader.create())).toEqualTypeOf<BaseSamplerShader>();
+
+expectTypeOf(myBSS.paused).toEqualTypeOf<boolean>;
+expectTypeOf(myBSS.pluginName).toEqualTypeOf<string | null>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/samplers/baseline-illumination.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/samplers/baseline-illumination.test-d.ts
new file mode 100644
index 000000000..cba9f65be
--- /dev/null
+++ b/tests/foundry/client/pixi/webgl/shaders/samplers/baseline-illumination.test-d.ts
@@ -0,0 +1,13 @@
+import { expectTypeOf } from "vitest";
+
+const BISS = BaselineIlluminationSamplerShader;
+let myBISS;
+
+expectTypeOf(BISS.pausable).toEqualTypeOf<boolean>();
+expectTypeOf(BISS.classPluginName).toEqualTypeOf<string | null>();
+expectTypeOf(BISS.fragmentShader).toEqualTypeOf<string>();
+expectTypeOf(BISS.registerPlugin({ force: true })).toEqualTypeOf<void>();
+expectTypeOf((myBISS = BISS.create())).toEqualTypeOf<BaselineIlluminationSamplerShader>();
+
+expectTypeOf(myBISS.paused).toEqualTypeOf<boolean>;
+expectTypeOf(myBISS.pluginName).toEqualTypeOf<string | null>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/samplers/color-adjustments.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/samplers/color-adjustments.test-d.ts
index a2509c8cf..fe336a4f3 100644
--- a/tests/foundry/client/pixi/webgl/shaders/samplers/color-adjustments.test-d.ts
+++ b/tests/foundry/client/pixi/webgl/shaders/samplers/color-adjustments.test-d.ts
@@ -1,3 +1,27 @@
 import { expectTypeOf } from "vitest";
 
-expectTypeOf(ColorAdjustmentsSamplerShader.create()).toEqualTypeOf<ColorAdjustmentsSamplerShader>();
+const CASS = ColorAdjustmentsSamplerShader;
+let myCASS;
+
+expectTypeOf(CASS.defaultUniforms).toEqualTypeOf<AbstractBaseShader.Uniforms>();
+expectTypeOf(CASS.classPluginName).toEqualTypeOf<string | null>();
+expectTypeOf(CASS.fragmentShader).toEqualTypeOf<string>();
+expectTypeOf(CASS.registerPlugin({ force: true })).toEqualTypeOf<void>();
+expectTypeOf((myCASS = CASS.create())).toEqualTypeOf<ColorAdjustmentsSamplerShader>();
+
+expectTypeOf(myCASS.paused).toEqualTypeOf<boolean>();
+expectTypeOf(myCASS.pluginName).toEqualTypeOf<string | null>();
+expectTypeOf(myCASS.linkedToDarknessLevel).toEqualTypeOf<boolean>();
+
+const ASS = AmplificationSamplerShader;
+let myASS;
+
+expectTypeOf(CASS.defaultUniforms).toEqualTypeOf<AbstractBaseShader.Uniforms>();
+expectTypeOf(ASS.classPluginName).toEqualTypeOf<string | null>();
+expectTypeOf(ASS.fragmentShader).toEqualTypeOf<string>();
+expectTypeOf(ASS.registerPlugin({ force: true })).toEqualTypeOf<void>();
+expectTypeOf((myASS = ASS.create())).toEqualTypeOf<AmplificationSamplerShader>();
+
+expectTypeOf(myASS.paused).toEqualTypeOf<boolean>;
+expectTypeOf(myASS.pluginName).toEqualTypeOf<string | null>();
+expectTypeOf(myASS.colorTint).toEqualTypeOf<Color.RGBColorVector>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/samplers/depth.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/samplers/depth.test-d.ts
new file mode 100644
index 000000000..33c0997eb
--- /dev/null
+++ b/tests/foundry/client/pixi/webgl/shaders/samplers/depth.test-d.ts
@@ -0,0 +1,37 @@
+import { expectTypeOf } from "vitest";
+
+const DSS = DepthSamplerShader;
+let myDSS;
+
+declare const someVB: PIXI.ViewableBuffer;
+declare const someU16Array: Uint16Array;
+declare const someF32Array: Float32Array;
+declare const someTex: PIXI.Texture;
+
+expectTypeOf(DSS.pausable).toEqualTypeOf<boolean>();
+expectTypeOf(DSS.classPluginName).toEqualTypeOf<string | null>();
+expectTypeOf(DSS.fragmentShader).toEqualTypeOf<string>();
+expectTypeOf(DSS.batchDefaultUniforms).toEqualTypeOf<BatchRenderer.BatchDefaultUniformsFunction>();
+expectTypeOf(
+  DSS["_packInterleavedGeometry"](
+    {
+      _texture: someTex,
+      elevation: 0,
+      fadeOcclusion: 0,
+      indices: someU16Array,
+      radialOcclusion: 0,
+      textureAlphaThreshold: 0,
+      uvs: someF32Array,
+      vertexData: someF32Array,
+      visionOcclusion: 0,
+    },
+    someVB,
+    someU16Array,
+    0,
+    0,
+  ),
+).toEqualTypeOf<void>();
+expectTypeOf((myDSS = DSS.create())).toEqualTypeOf<DepthSamplerShader>();
+
+expectTypeOf(myDSS.paused).toEqualTypeOf<boolean>;
+expectTypeOf(myDSS.pluginName).toEqualTypeOf<string | null>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/samplers/fog-of-war.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/samplers/fog-of-war.test-d.ts
index c29f12ef1..64bb6e014 100644
--- a/tests/foundry/client/pixi/webgl/shaders/samplers/fog-of-war.test-d.ts
+++ b/tests/foundry/client/pixi/webgl/shaders/samplers/fog-of-war.test-d.ts
@@ -1,3 +1,12 @@
 import { expectTypeOf } from "vitest";
 
-expectTypeOf(FogSamplerShader.create()).toEqualTypeOf<FogSamplerShader>();
+const FSS = FogSamplerShader;
+let myFSS;
+
+expectTypeOf(FSS.classPluginName).toEqualTypeOf<string | null>();
+expectTypeOf(FSS.fragmentShader).toEqualTypeOf<string>();
+
+expectTypeOf((myFSS = FSS.create())).toEqualTypeOf<FogSamplerShader>();
+
+expectTypeOf(myFSS.paused).toEqualTypeOf<boolean>;
+expectTypeOf(myFSS.pluginName).toEqualTypeOf<string | null>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/samplers/inverse-occlusion.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/samplers/inverse-occlusion.test-d.ts
deleted file mode 100644
index f7aeb2f5a..000000000
--- a/tests/foundry/client/pixi/webgl/shaders/samplers/inverse-occlusion.test-d.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { expectTypeOf } from "vitest";
-
-expectTypeOf(InverseOcclusionSamplerShader.create()).toEqualTypeOf<InverseOcclusionSamplerShader>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/samplers/invisibility.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/samplers/invisibility.test-d.ts
deleted file mode 100644
index 69deafa54..000000000
--- a/tests/foundry/client/pixi/webgl/shaders/samplers/invisibility.test-d.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { expectTypeOf } from "vitest";
-
-expectTypeOf(TokenInvisibilitySamplerShader.create()).toEqualTypeOf<TokenInvisibilitySamplerShader>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/samplers/monochromatic.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/samplers/monochromatic.test-d.ts
deleted file mode 100644
index 4b0567711..000000000
--- a/tests/foundry/client/pixi/webgl/shaders/samplers/monochromatic.test-d.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { expectTypeOf } from "vitest";
-
-expectTypeOf(MonochromaticSamplerShader.create()).toEqualTypeOf<MonochromaticSamplerShader>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/samplers/occlusion.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/samplers/occlusion.test-d.ts
index 1820e2f3b..0fa2800c8 100644
--- a/tests/foundry/client/pixi/webgl/shaders/samplers/occlusion.test-d.ts
+++ b/tests/foundry/client/pixi/webgl/shaders/samplers/occlusion.test-d.ts
@@ -1,3 +1,41 @@
 import { expectTypeOf } from "vitest";
 
-expectTypeOf(OcclusionSamplerShader.create()).toEqualTypeOf<OcclusionSamplerShader>();
+const OSS = OccludableSamplerShader;
+let myOSS;
+
+declare const someVB: PIXI.ViewableBuffer;
+declare const someU16Array: Uint16Array;
+declare const someF32Array: Float32Array;
+declare const someTex: PIXI.Texture;
+
+expectTypeOf(OSS.reservedTextureUnits).toEqualTypeOf<number>();
+expectTypeOf(OSS.classPluginName).toEqualTypeOf<string>();
+expectTypeOf(OSS.fragmentShader).toEqualTypeOf<string>();
+expectTypeOf(OSS.batchDefaultUniforms).toEqualTypeOf<BatchRenderer.BatchDefaultUniformsFunction>();
+expectTypeOf(
+  OSS["_packInterleavedGeometry"](
+    {
+      _texture: someTex,
+      elevation: 0,
+      fadeOcclusion: 0,
+      indices: someU16Array,
+      radialOcclusion: 0,
+      uvs: someF32Array,
+      vertexData: someF32Array,
+      visionOcclusion: 0,
+      _tintRGB: 0,
+      blendMode: PIXI.BLEND_MODES.NORMAL,
+      worldAlpha: 1,
+      occludedAlpha: 0.5,
+      unoccludedAlpha: 1,
+    },
+    someVB,
+    someU16Array,
+    0,
+    0,
+  ),
+).toEqualTypeOf<void>();
+expectTypeOf((myOSS = OSS.create())).toEqualTypeOf<OccludableSamplerShader>();
+
+expectTypeOf(myOSS.paused).toEqualTypeOf<boolean>;
+expectTypeOf(myOSS.pluginName).toEqualTypeOf<string | null>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/samplers/primary.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/samplers/primary.test-d.ts
new file mode 100644
index 000000000..ea8897af7
--- /dev/null
+++ b/tests/foundry/client/pixi/webgl/shaders/samplers/primary.test-d.ts
@@ -0,0 +1,41 @@
+import { expectTypeOf } from "vitest";
+
+const PBSS = PrimaryBaseSamplerShader;
+let myPBSS;
+
+declare const someVB: PIXI.ViewableBuffer;
+declare const someU16Array: Uint16Array;
+declare const someF32Array: Float32Array;
+declare const someTex: PIXI.Texture;
+
+expectTypeOf(PBSS.reservedTextureUnits).toEqualTypeOf<number>();
+expectTypeOf(PBSS.classPluginName).toEqualTypeOf<string>();
+expectTypeOf(PBSS.fragmentShader).toEqualTypeOf<string>();
+expectTypeOf(PBSS.batchDefaultUniforms).toEqualTypeOf<BatchRenderer.BatchDefaultUniformsFunction>();
+expectTypeOf(
+  PBSS["_packInterleavedGeometry"](
+    {
+      _texture: someTex,
+      elevation: 0,
+      fadeOcclusion: 0,
+      indices: someU16Array,
+      radialOcclusion: 0,
+      uvs: someF32Array,
+      vertexData: someF32Array,
+      visionOcclusion: 0,
+      _tintRGB: 0,
+      blendMode: PIXI.BLEND_MODES.NORMAL,
+      worldAlpha: 1,
+      occludedAlpha: 0.5,
+      unoccludedAlpha: 1,
+    },
+    someVB,
+    someU16Array,
+    0,
+    0,
+  ),
+).toEqualTypeOf<void>();
+expectTypeOf((myPBSS = PBSS.create())).toEqualTypeOf<PrimaryBaseSamplerShader>();
+
+expectTypeOf(myPBSS.paused).toEqualTypeOf<boolean>;
+expectTypeOf(myPBSS.pluginName).toEqualTypeOf<string | null>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/samplers/token-rings.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/samplers/token-rings.test-d.ts
new file mode 100644
index 000000000..dabc595e3
--- /dev/null
+++ b/tests/foundry/client/pixi/webgl/shaders/samplers/token-rings.test-d.ts
@@ -0,0 +1,48 @@
+import { expectTypeOf } from "vitest";
+import type TokenRing from "../../../../../../../src/foundry/client-esm/canvas/tokens/ring.d.mts";
+
+const TRSS = TokenRingSamplerShader;
+let myTRSS;
+
+declare const someVB: PIXI.ViewableBuffer;
+declare const someU16Array: Uint16Array;
+declare const someF32Array: Float32Array;
+declare const someTex: PIXI.Texture;
+declare const someRing: TokenRing;
+
+expectTypeOf(TRSS.nullUvs).toEqualTypeOf<Float32Array>();
+expectTypeOf(TRSS.classPluginName).toEqualTypeOf<string>();
+expectTypeOf(TRSS["_batchFragmentShader"]).toEqualTypeOf<string>();
+expectTypeOf(TRSS.batchDefaultUniforms).toEqualTypeOf<BatchRenderer.BatchDefaultUniformsFunction>();
+expectTypeOf(
+  TRSS["_packInterleavedGeometry"](
+    {
+      object: {
+        object: {
+          ring: someRing,
+        },
+      },
+      _texture: someTex,
+      elevation: 0,
+      fadeOcclusion: 0,
+      indices: someU16Array,
+      radialOcclusion: 0,
+      uvs: someF32Array,
+      vertexData: someF32Array,
+      visionOcclusion: 0,
+      _tintRGB: 0,
+      blendMode: PIXI.BLEND_MODES.NORMAL,
+      worldAlpha: 1,
+      occludedAlpha: 0.5,
+      unoccludedAlpha: 1,
+    },
+    someVB,
+    someU16Array,
+    0,
+    0,
+  ),
+).toEqualTypeOf<void>();
+expectTypeOf((myTRSS = TRSS.create())).toEqualTypeOf<TokenRingSamplerShader>();
+
+expectTypeOf(myTRSS.paused).toEqualTypeOf<boolean>;
+expectTypeOf(myTRSS.pluginName).toEqualTypeOf<string | null>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/vision/background-vision.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/vision/background-vision.test-d.ts
new file mode 100644
index 000000000..faff36bb2
--- /dev/null
+++ b/tests/foundry/client/pixi/webgl/shaders/vision/background-vision.test-d.ts
@@ -0,0 +1,11 @@
+import { expectTypeOf } from "vitest";
+
+const BVS = BackgroundVisionShader;
+let myBVS;
+
+expectTypeOf(BVS.fragmentShader).toEqualTypeOf<string>();
+expectTypeOf(BVS.FRAGMENT_END).toEqualTypeOf<string>();
+expectTypeOf((myBVS = BVS.create())).toEqualTypeOf<BackgroundVisionShader>();
+
+expectTypeOf(myBVS.isRequired).toEqualTypeOf<boolean>();
+expectTypeOf(myBVS["_preRender"]).toEqualTypeOf<AbstractBaseShader.PreRenderFunction>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/vision/base-vision.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/vision/base-vision.test-d.ts
new file mode 100644
index 000000000..b61ac2835
--- /dev/null
+++ b/tests/foundry/client/pixi/webgl/shaders/vision/base-vision.test-d.ts
@@ -0,0 +1,10 @@
+import { expectTypeOf } from "vitest";
+
+const AVS = AdaptiveVisionShader;
+let myAVS;
+
+expectTypeOf(AVS.FRAGMENT_FUNCTIONS).toEqualTypeOf<string>();
+expectTypeOf(AVS.SHADER_TECHNIQUES).toEqualTypeOf<Record<string, AdaptiveLightingShader.ShaderTechnique>>();
+expectTypeOf((myAVS = AVS.create())).toEqualTypeOf<AdaptiveVisionShader>();
+
+expectTypeOf(myAVS["_preRender"]).toEqualTypeOf<AbstractBaseShader.PreRenderFunction>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/vision/coloration-vision.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/vision/coloration-vision.test-d.ts
new file mode 100644
index 000000000..5d74b45e3
--- /dev/null
+++ b/tests/foundry/client/pixi/webgl/shaders/vision/coloration-vision.test-d.ts
@@ -0,0 +1,11 @@
+import { expectTypeOf } from "vitest";
+
+const CVS = ColorationVisionShader;
+let myCVS;
+
+expectTypeOf(CVS.fragmentShader).toEqualTypeOf<string>();
+expectTypeOf(CVS.SHADER_HEADER).toEqualTypeOf<string>();
+expectTypeOf((myCVS = CVS.create())).toEqualTypeOf<ColorationVisionShader>();
+
+expectTypeOf(myCVS.isRequired).toEqualTypeOf<boolean>();
+expectTypeOf(myCVS["_preRender"]).toEqualTypeOf<AbstractBaseShader.PreRenderFunction>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/vision/effects/amplification.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/vision/effects/amplification.test-d.ts
new file mode 100644
index 000000000..71a97e1c1
--- /dev/null
+++ b/tests/foundry/client/pixi/webgl/shaders/vision/effects/amplification.test-d.ts
@@ -0,0 +1,11 @@
+import { expectTypeOf } from "vitest";
+
+const ABVS = AmplificationBackgroundVisionShader;
+let myABVS;
+
+expectTypeOf(ABVS.fragmentShader).toEqualTypeOf<string>();
+expectTypeOf(ABVS.SHADER_HEADER).toEqualTypeOf<string>();
+expectTypeOf((myABVS = ABVS.create())).toEqualTypeOf<AmplificationBackgroundVisionShader>();
+
+expectTypeOf(myABVS.isRequired).toEqualTypeOf<boolean>();
+expectTypeOf(myABVS["_preRender"]).toEqualTypeOf<AbstractBaseShader.PreRenderFunction>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/vision/effects/wave.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/vision/effects/wave.test-d.ts
new file mode 100644
index 000000000..1335f848d
--- /dev/null
+++ b/tests/foundry/client/pixi/webgl/shaders/vision/effects/wave.test-d.ts
@@ -0,0 +1,21 @@
+import { expectTypeOf } from "vitest";
+
+const WBVS = WaveBackgroundVisionShader;
+let myWBVS;
+
+expectTypeOf(WBVS.fragmentShader).toEqualTypeOf<string>();
+expectTypeOf(WBVS.defaultUniforms).toEqualTypeOf<AbstractBaseShader.Uniforms>();
+expectTypeOf((myWBVS = WBVS.create())).toEqualTypeOf<WaveBackgroundVisionShader>();
+
+expectTypeOf(myWBVS.isRequired).toEqualTypeOf<boolean>();
+expectTypeOf(myWBVS["_preRender"]).toEqualTypeOf<AbstractBaseShader.PreRenderFunction>();
+
+const WCVS = WaveColorationVisionShader;
+let myWCVS;
+
+expectTypeOf(WCVS.fragmentShader).toEqualTypeOf<string>();
+expectTypeOf(WCVS.defaultUniforms).toEqualTypeOf<AbstractBaseShader.Uniforms>();
+expectTypeOf((myWCVS = WCVS.create())).toEqualTypeOf<WaveColorationVisionShader>();
+
+expectTypeOf(myWCVS.isRequired).toEqualTypeOf<boolean>();
+expectTypeOf(myWCVS["_preRender"]).toEqualTypeOf<AbstractBaseShader.PreRenderFunction>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/vision/illumination-vision.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/vision/illumination-vision.test-d.ts
new file mode 100644
index 000000000..8a9a24256
--- /dev/null
+++ b/tests/foundry/client/pixi/webgl/shaders/vision/illumination-vision.test-d.ts
@@ -0,0 +1,10 @@
+import { expectTypeOf } from "vitest";
+
+const IVS = IlluminationVisionShader;
+let myIVS;
+
+expectTypeOf(IVS.fragmentShader).toEqualTypeOf<string>();
+expectTypeOf(IVS.ADJUSTMENTS).toEqualTypeOf<string>();
+expectTypeOf((myIVS = IVS.create())).toEqualTypeOf<IlluminationVisionShader>();
+
+expectTypeOf(myIVS["_preRender"]).toEqualTypeOf<AbstractBaseShader.PreRenderFunction>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/weather/base-weather.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/weather/base-weather.test-d.ts
new file mode 100644
index 000000000..5ebc023fa
--- /dev/null
+++ b/tests/foundry/client/pixi/webgl/shaders/weather/base-weather.test-d.ts
@@ -0,0 +1,12 @@
+import { expectTypeOf } from "vitest";
+
+const AWS = AbstractWeatherShader;
+let myAWS;
+
+expectTypeOf(AWS.fragmentShader).toEqualTypeOf<string | AbstractBaseShader.FragmentShaderFunction>();
+expectTypeOf(AWS.createProgram()).toEqualTypeOf<PIXI.Program>();
+expectTypeOf(AWS.vertexShader).toEqualTypeOf<string>();
+expectTypeOf((myAWS = AWS.create())).toEqualTypeOf<AbstractWeatherShader>();
+
+expectTypeOf(myAWS.speed).toEqualTypeOf<number>();
+expectTypeOf(myAWS["_preRender"]).toEqualTypeOf<AbstractBaseShader.PreRenderFunction>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/weather/effect.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/weather/effect.test-d.ts
new file mode 100644
index 000000000..f55e3e8a7
--- /dev/null
+++ b/tests/foundry/client/pixi/webgl/shaders/weather/effect.test-d.ts
@@ -0,0 +1,19 @@
+import { expectTypeOf } from "vitest";
+
+const myWSE = new WeatherShaderEffect(
+  {
+    opacity: 1,
+    intensity: 0.8,
+    resolution: [0.5, 0.5],
+  },
+  RainShader,
+);
+
+//not a whole lot to test here not covered by QuadMesh tests
+expectTypeOf(
+  myWSE.configure({
+    foo: { x: 1, y: 1 },
+    bar: false,
+    baz: [1, 1, 1],
+  }),
+).toMatchTypeOf<void>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/weather/fog.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/weather/fog.test-d.ts
new file mode 100644
index 000000000..5505c0fd1
--- /dev/null
+++ b/tests/foundry/client/pixi/webgl/shaders/weather/fog.test-d.ts
@@ -0,0 +1,13 @@
+import { expectTypeOf } from "vitest";
+
+const FS = FogShader;
+let myFS;
+
+expectTypeOf(FS.fragmentShader).toMatchTypeOf<AbstractBaseShader.FragmentShaderFunction>();
+expectTypeOf(FS.fragmentShader(1)).toEqualTypeOf<string>();
+expectTypeOf(FS.createProgram()).toEqualTypeOf<PIXI.Program>();
+expectTypeOf(FS.OCTAVES(4)).toEqualTypeOf<string>();
+expectTypeOf((myFS = FS.create())).toEqualTypeOf<FogShader>();
+
+expectTypeOf(myFS.speed).toEqualTypeOf<number>();
+expectTypeOf(myFS["_preRender"]).toEqualTypeOf<AbstractBaseShader.PreRenderFunction>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/weather/rain.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/weather/rain.test-d.ts
new file mode 100644
index 000000000..4a82766e1
--- /dev/null
+++ b/tests/foundry/client/pixi/webgl/shaders/weather/rain.test-d.ts
@@ -0,0 +1,11 @@
+import { expectTypeOf } from "vitest";
+
+const RS = RainShader;
+let myRS;
+
+expectTypeOf(RS.fragmentShader).toEqualTypeOf<string>();
+expectTypeOf(RS.createProgram()).toEqualTypeOf<PIXI.Program>();
+expectTypeOf((myRS = RS.create())).toEqualTypeOf<RainShader>();
+
+expectTypeOf(myRS.speed).toEqualTypeOf<number>();
+expectTypeOf(myRS["_preRender"]).toEqualTypeOf<AbstractBaseShader.PreRenderFunction>();
diff --git a/tests/foundry/client/pixi/webgl/shaders/weather/snow.test-d.ts b/tests/foundry/client/pixi/webgl/shaders/weather/snow.test-d.ts
new file mode 100644
index 000000000..51ecf1937
--- /dev/null
+++ b/tests/foundry/client/pixi/webgl/shaders/weather/snow.test-d.ts
@@ -0,0 +1,11 @@
+import { expectTypeOf } from "vitest";
+
+const SS = SnowShader;
+let mySS;
+
+expectTypeOf(SS.fragmentShader).toEqualTypeOf<string>();
+expectTypeOf(SS.createProgram()).toEqualTypeOf<PIXI.Program>();
+expectTypeOf((mySS = SS.create())).toEqualTypeOf<SnowShader>();
+
+expectTypeOf(mySS.speed).toEqualTypeOf<number>();
+expectTypeOf(mySS["_preRender"]).toEqualTypeOf<AbstractBaseShader.PreRenderFunction>();