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

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

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

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

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

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

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

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

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

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

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

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

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

package/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
@@ -46,9 +21,8 @@ declare global {
     /**
      * The darkness level adjustment mode.
      * @defaultValue `foundry.data.regionBehaviors.AdjustDarknessLevelRegionBehaviorType.MODES.OVERRIDE`
-     * TODO: make into typeof... when referenced class is available
      */
-    mode: number;
+    mode: foundry.data.regionBehaviors.AdjustDarknessLevelRegionBehaviorType.MODES;
 
     /**
      * The darkness level modifier.
@@ -64,10 +38,36 @@ declare global {
     protected override _preRender: AbstractBaseShader.PreRenderFunction;
   }
 
+  namespace AbstractDarknessLevelRegionShader {
+    interface Any extends AnyAbstractDarknessLevelRegionShader {}
+    type AnyConstructor = typeof AnyAbstractDarknessLevelRegionShader;
+  }
+
   /**
    * Render the RegionMesh with darkness level adjustments.
    */
   class AdjustDarknessLevelRegionShader extends AbstractDarknessLevelRegionShader {
+    /**
+     * @defaultValue
+     * ```
+     *  `
+     *   precision ${PIXI.settings.PRECISION_FRAGMENT} float;
+     *
+     *   uniform sampler2D depthTexture;
+     *   uniform float darknessLevel;
+     *   uniform float top;
+     *   uniform float bottom;
+     *   uniform vec4 tintAlpha;
+     *   varying vec2 vScreenCoord;
+     *
+     *   void main() {
+     *     vec2 depthColor = texture2D(depthTexture, vScreenCoord).rg;
+     *     float depth = step(depthColor.g, top) * step(bottom, (254.5 / 255.0) - depthColor.r);
+     *     gl_FragColor = vec4(darknessLevel, 0.0, 0.0, 1.0) * tintAlpha * depth;
+     *   }
+     *  `
+     * ```
+     */
     static override fragmentShader: string;
 
     /**
@@ -84,10 +84,52 @@ declare global {
     protected override _preRender: AbstractBaseShader.PreRenderFunction;
   }
 
+  namespace AdjustDarknessLevelRegionShader {
+    interface Any extends AnyAdjustDarknessLevelRegionShader {}
+    type AnyConstructor = typeof AnyAdjustDarknessLevelRegionShader;
+  }
+
   /**
    * Render the RegionMesh with darkness level adjustments.
    */
   class IlluminationDarknessLevelRegionShader extends AbstractDarknessLevelRegionShader {
+    /**
+     * @defaultValue
+     * ```
+     *  `
+     *   precision ${PIXI.settings.PRECISION_FRAGMENT} float;
+     *
+     *   uniform sampler2D depthTexture;
+     *   uniform float top;
+     *   uniform float bottom;
+     *   uniform vec4 tintAlpha;
+     *   varying vec2 vScreenCoord;
+     *
+     *   void main() {
+     *     vec2 depthColor = texture2D(depthTexture, vScreenCoord).rg;
+     *     float depth = step(depthColor.g, top) * step(bottom, (254.5 / 255.0) - depthColor.r);
+     *     gl_FragColor = vec4(1.0) * tintAlpha * depth;
+     *   }
+     *  `
+     * ```
+     */
     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[]);
 }

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

@@ -1,20 +1,55 @@
 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}.
    */
   class RegionShader extends AbstractBaseShader {
+    /**
+     * @defaultValue
+     * ```
+     *  `
+     *   precision ${PIXI.settings.PRECISION_VERTEX} float;
+     *
+     *   attribute vec2 aVertexPosition;
+     *
+     *   uniform mat3 translationMatrix;
+     *   uniform mat3 projectionMatrix;
+     *   uniform vec2 canvasDimensions;
+     *   uniform vec4 sceneDimensions;
+     *   uniform vec2 screenDimensions;
+     *
+     *   varying vec2 vCanvasCoord; // normalized canvas coordinates
+     *   varying vec2 vSceneCoord; // normalized scene coordinates
+     *   varying vec2 vScreenCoord; // normalized screen coordinates
+     *
+     *   void main() {
+     *     vec2 pixelCoord = aVertexPosition;
+     *     vCanvasCoord = pixelCoord / canvasDimensions;
+     *     vSceneCoord = (pixelCoord - sceneDimensions.xy) / sceneDimensions.zw;
+     *     vec3 tPos = translationMatrix * vec3(aVertexPosition, 1.0);
+     *     vScreenCoord = tPos.xy / screenDimensions;
+     *     gl_Position = vec4((projectionMatrix * tPos).xy, 0.0, 1.0);
+     *   }
+     *  `
+     * ```
+     */
     static override vertexShader: string;
 
+    /**
+     * @defaultValue
+     * ```
+     *  `
+     *   precision ${PIXI.settings.PRECISION_FRAGMENT} float;
+     *
+     *   uniform vec4 tintAlpha;
+     *
+     *   void main() {
+     *     gl_FragColor = tintAlpha;
+     *   }
+     *  `
+     * ```
+     */
     static override fragmentShader: string;
 
     /**
@@ -32,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[]);
 }