@league-of-foundry-developers/foundry-vtt-types 13.340.0 → 13.345.1-beta.20250704.94554

package/src/foundry/client/canvas/rendering/filters/smaa/edges.d.mts

@@ -0,0 +1,22 @@
+import type { Identity } from "#utils";
+import type SMAAFilter from "./smaa.d.mts";
+
+/**
+ * The edge detection filter for {@linkcode foundry.canvas.rendering.filters.SMAAFilter}.
+ */
+declare class SMAAEdgeDetectionFilter extends PIXI.Filter {
+  constructor(config: SMAAEdgeDetectionFilter.Config);
+}
+
+declare namespace SMAAEdgeDetectionFilter {
+  interface Any extends AnySMAAEdgeDetectionFilter {}
+  interface AnyConstructor extends Identity<typeof AnySMAAEdgeDetectionFilter> {}
+
+  interface Config extends Pick<SMAAFilter.Config, "threshold" | "localContrastAdaptionFactor"> {}
+}
+
+export default SMAAEdgeDetectionFilter;
+
+declare abstract class AnySMAAEdgeDetectionFilter extends SMAAEdgeDetectionFilter {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/rendering/filters/smaa/smaa.d.mts

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

package/src/foundry/client/canvas/rendering/filters/smaa/weights.d.mts

@@ -0,0 +1,22 @@
+import type { Identity } from "#utils";
+import type SMAAFilter from "./smaa.d.mts";
+
+/**
+ * The blending weight calculation filter for {@linkcode foundry.canvas.rendering.filters.SMAAFilter}.
+ */
+declare class SMAABWeightCalculationFilter extends PIXI.Filter {
+  constructor(config: SMAABWeightCalculationFilter.Config);
+}
+
+declare namespace SMAABWeightCalculationFilter {
+  interface Any extends AnySMAABWeightCalculationFilter {}
+  interface AnyConstructor extends Identity<typeof AnySMAABWeightCalculationFilter> {}
+
+  interface Config extends Omit<SMAAFilter.Config, "localContrastAdaptionFactor"> {}
+}
+
+export default SMAABWeightCalculationFilter;
+
+declare abstract class AnySMAABWeightCalculationFilter extends SMAABWeightCalculationFilter {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/rendering/filters/transition.d.mts

@@ -0,0 +1,130 @@
+import type { Brand, Identity, InexactPartial } from "#utils";
+import type { AbstractBaseFilter } from "./_module.d.mts";
+import type { AbstractBaseShader } from "../shaders/_module.mjs";
+import type { SpriteMesh } from "#client/canvas/containers/_module.mjs";
+import type { CanvasAnimation } from "#client/canvas/animation/_module.d.mts";
+
+/**
+ * A filter specialized for transition effects between a source object and a target texture.
+ */
+declare class TextureTransitionFilter extends AbstractBaseFilter {
+  static get TYPES(): TextureTransitionFilter.Types;
+
+  /**
+   * The transition type (see {@linkcode TextureTransitionFilter.TYPES}).
+   * @defaultValue `TextureTransitionFilter.TYPES.FADE`
+   */
+  get type(): TextureTransitionFilter.TYPES;
+
+  set type(type);
+
+  /**
+   * Sampler target for this filter.
+   */
+  set targetTexture(targetTexture: PIXI.Texture);
+
+  /**
+   * Animate a transition from a subject SpriteMesh/PIXI.Sprite to a given texture.
+   * @param subject - The source mesh/sprite to apply a transition.
+   * @param texture - The target texture.
+   * @param options - Animation options.
+   * @returns   A Promise which resolves to true once the animation has concluded or false
+   * if the animation was prematurely terminated
+   */
+  static animate(
+    subject: PIXI.Sprite | SpriteMesh,
+    texture: PIXI.Texture,
+    options?: TextureTransitionFilter.AnimateOptions,
+  ): Promise<boolean>;
+
+  /**
+   * @defaultValue
+   * ```js
+   * {
+   *   tintAlpha: [1, 1, 1, 1],
+   *   targetTexture: null,
+   *   progress: 0,
+   *   rotation: 0,
+   *   anchor: {x: 0.5, y: 0.5},
+   *   type: 1,
+   *   filterMatrix: new PIXI.Matrix(),
+   *   filterMatrixInverse: new PIXI.Matrix(),
+   *   targetUVMatrix: new PIXI.Matrix()
+   * }
+   * ```
+   */
+  static override defaultUniforms: AbstractBaseShader.Uniforms;
+
+  static override vertexShader: string;
+
+  static override fragmentShader: string;
+
+  override apply(
+    filterManager: PIXI.FilterSystem,
+    input: PIXI.RenderTexture,
+    output: PIXI.RenderTexture,
+    clearMode?: PIXI.CLEAR_MODES,
+  ): void;
+
+  #TextureTransitionFilter: true;
+}
+
+declare namespace TextureTransitionFilter {
+  interface Any extends AnyTextureTransitionFilter {}
+  interface AnyConstructor extends Identity<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 `this.TYPES.FADE`
+     */
+    type: TextureTransitionFilter.TYPES;
+
+    /**
+     * The name of the {@linkcode foundry.canvas.animation.CanvasAnimation}.
+     */
+    name: PropertyKey;
+
+    /**
+     * The animation duration
+     * @defaultValue `1000`
+     * @remarks Default provided by {@linkcode foundry.canvas.animation.CanvasAnimation.animate}
+     */
+    duration: number;
+
+    /**
+     * The easing function of the animation
+     */
+    easing: CanvasAnimation.EasingFunction;
+  }>;
+
+  interface AnimateOptions extends _AnimateOptions {}
+}
+
+export default TextureTransitionFilter;
+
+declare abstract class AnyTextureTransitionFilter extends TextureTransitionFilter {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/rendering/filters/visibility.d.mts

@@ -0,0 +1,82 @@
+import type { FixedInstanceType, Identity, InexactPartial } from "#utils";
+import type { AbstractBaseFilter, AbstractBaseMaskFilter } from "./_module.d.mts";
+import type { AbstractBaseShader } from "../shaders/_module.mjs";
+
+/**
+ * Apply visibility coloration according to the baseLine color.
+ * Uses very lightweight gaussian vertical and horizontal blur filter passes.
+ */
+declare class VisibilityFilter extends AbstractBaseMaskFilter {
+  constructor(...args: ConstructorParameters<typeof AbstractBaseMaskFilter>);
+
+  /**
+   * @defaultValue
+   * ```js
+   * {
+   *    exploredColor: [1, 1, 1],
+   *    unexploredColor: [0, 0, 0],
+   *    screenDimensions: [1, 1],
+   *    visionTexture: null,
+   *    primaryTexture: null,
+   *    overlayTexture: null,
+   *    overlayMatrix: new PIXI.Matrix(),
+   *    hasOverlayTexture: false
+   * }
+   * ```
+   */
+  static override defaultUniforms: AbstractBaseShader.Uniforms;
+
+  static override create<ThisType extends AbstractBaseFilter.AnyConstructor>(
+    this: ThisType,
+    initialUniforms?: AbstractBaseShader.Uniforms,
+    options?: VisibilityFilter.FragmentShaderOptions,
+  ): FixedInstanceType<ThisType>;
+
+  static override vertexShader: string;
+
+  static override fragmentShader(options: VisibilityFilter.FragmentShaderOptions): string;
+
+  /**
+   * Set the blur strength
+   * @param value - blur strength
+   */
+  set blur(value: number);
+
+  get blur(): number;
+
+  override apply(
+    filterManager: PIXI.FilterSystem,
+    input: PIXI.RenderTexture,
+    output: PIXI.RenderTexture,
+    clear?: PIXI.CLEAR_MODES,
+  ): void;
+
+  /**
+   * Calculate the fog overlay sprite matrix.
+   */
+  calculateMatrix(filterManager: PIXI.FilterSystem): void;
+
+  #VisibilityFilter: true;
+}
+
+declare namespace VisibilityFilter {
+  interface Any extends AnyVisibilityFilter {}
+  interface AnyConstructor extends Identity<typeof AnyVisibilityFilter> {}
+
+  // TODO: This can't be an interface yet because of 'An interface can only extend an object type or intersection of object types with statically known members' errors
+  type ImplementationClass = CONFIG["Canvas"]["visibilityFilter"];
+  interface Implementation extends FixedInstanceType<ImplementationClass> {}
+
+  /** @internal */
+  type _FragmentShaderOptions = InexactPartial<{
+    persistentVision: boolean;
+  }>;
+
+  interface FragmentShaderOptions extends _FragmentShaderOptions {}
+}
+
+export default VisibilityFilter;
+
+declare abstract class AnyVisibilityFilter extends VisibilityFilter {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/rendering/filters/vision-mask-filter.d.mts

@@ -0,0 +1,38 @@
+import type { FixedInstanceType, Identity } from "#utils";
+import type { AbstractBaseFilter, AbstractBaseMaskFilter } from "./_module.d.mts";
+import type { AbstractBaseShader } from "../shaders/_module.mjs";
+
+declare class VisionMaskFilter extends AbstractBaseMaskFilter {
+  static override fragmentShader: string;
+
+  /**
+   * @defaultValue
+   * ```js
+   * {
+   *   uMaskSampler: null
+   * }
+   * ```
+   */
+  static override defaultUniforms: AbstractBaseShader.Uniforms;
+
+  static override create<ThisType extends AbstractBaseFilter.AnyConstructor>(
+    this: ThisType,
+  ): FixedInstanceType<ThisType>;
+
+  /**
+   * @remarks This is set as a property all the way up in PIXI.Filter, however Foundry has it
+   * as a getter, with a no-op setter. It's still like this in 13.345.
+   */
+  override readonly enabled: boolean;
+}
+
+declare namespace VisionMaskFilter {
+  interface Any extends AnyVisionMaskFilter {}
+  interface AnyConstructor extends Identity<typeof AnyVisionMaskFilter> {}
+}
+
+export default VisionMaskFilter;
+
+declare abstract class AnyVisionMaskFilter extends VisionMaskFilter {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/rendering/filters/void.d.mts

@@ -0,0 +1,20 @@
+import type { Identity } from "#utils";
+import type { AbstractBaseFilter } from "./_module.d.mts";
+
+/**
+ * A minimalist filter (just used for blending)
+ */
+declare class VoidFilter extends AbstractBaseFilter {
+  static override fragmentShader: string;
+}
+
+declare namespace VoidFilter {
+  interface Any extends AnyVoidFilter {}
+  interface AnyConstructor extends Identity<typeof AnyVoidFilter> {}
+}
+
+export default VoidFilter;
+
+declare abstract class AnyVoidFilter extends VoidFilter {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/rendering/filters/weather-occlusion-mask.d.mts

@@ -0,0 +1,59 @@
+import type { Identity } from "#utils";
+import type { AbstractBaseMaskFilter } from "./_module.d.mts";
+import type { AbstractBaseShader } from "../shaders/_module.mjs";
+
+/**
+ * The filter used by the weather layer to mask weather above occluded roofs.
+ * @see {@linkcode foundry.canvas.layers.WeatherEffects}
+ */
+declare class WeatherOcclusionMaskFilter extends AbstractBaseMaskFilter {
+  /**
+   * Elevation of this weather occlusion mask filter.
+   * @defaultValue `Infinity`
+   */
+  elevation: number;
+
+  static override vertexShader: string;
+
+  static override fragmentShader: string;
+
+  /**
+   * @defaultValue
+   * ```js
+   * {
+   *   depthElevation: 0,
+   *   useOcclusion: true,
+   *   occlusionTexture: null,
+   *   reverseOcclusion: false,
+   *   occlusionWeights: [0, 0, 1, 0],
+   *   seTerrain: false,
+   *   terrainTexture: null,
+   *   reverseTerrain: false,
+   *   terrainWeights: [1, 0, 0, 0],
+   *   sceneDimensions: [0, 0],
+   *   sceneAnchor: [0, 0]
+   *   terrainUvMatrix: new PIXI.Matrix()
+   * }
+   * ```
+   */
+  static override defaultUniforms: AbstractBaseShader.Uniforms;
+
+  override apply(
+    filterManager: PIXI.FilterSystem,
+    input: PIXI.RenderTexture,
+    output: PIXI.RenderTexture,
+    clear?: PIXI.CLEAR_MODES,
+    currentState?: PIXI.FilterState,
+  ): void;
+}
+
+declare namespace WeatherOcclusionMaskFilter {
+  interface Any extends AnyWeatherOcclusionMaskFilter {}
+  interface AnyConstructor extends Identity<typeof AnyWeatherOcclusionMaskFilter> {}
+}
+
+export default WeatherOcclusionMaskFilter;
+
+declare abstract class AnyWeatherOcclusionMaskFilter extends WeatherOcclusionMaskFilter {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/rendering/mixins/_module.d.mts

@@ -0,0 +1,7 @@
+// In Foundry itself this file contains re-exports of these other modules.
+// Therefore it has a runtime effect and uses `.mjs` instead of `.d.mts`.
+// While `.mts` could work, to avoid `import-x/no-unresolved` from erroring `.mjs` is used.
+/* eslint-disable import-x/extensions */
+
+export { default as BaseShaderMixin } from "./base-shader-mixin.mjs";
+export { default as AdaptiveFragmentChannelMixin } from "./fragment-channel-mixin.mjs";

package/src/foundry/client/canvas/rendering/mixins/base-shader-mixin.d.mts

@@ -0,0 +1,134 @@
+import type { FixedInstanceType, Mixin } from "#utils";
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+declare class BaseShader {
+  /** @privateRemarks All mixin classes should accept anything for its constructor. */
+  constructor(...args: any[]);
+
+  /**
+   * Useful constant values computed at compile time
+   */
+  static CONSTANTS: string;
+
+  /**
+   * Fast approximate perceived brightness computation
+   * Using Digital ITU BT.709 : Exact luminance factors
+   */
+  static PERCEIVED_BRIGHTNESS: string;
+
+  /**
+   * Simplex 3D noise functions
+   */
+  static SIMPLEX_3D: string;
+
+  /**
+   * Conversion functions for sRGB and Linear RGB.
+   */
+  static COLOR_SPACES: string;
+
+  /**
+   * Fractional Brownian Motion for a given number of octaves
+   * @param octaves - (default: `4`)
+   * @param amp     - (default: `1.0`)
+   */
+  static FBM(octaves?: number, amp?: number): string;
+
+  /**
+   * High Quality Fractional Brownian Motion.
+   * @param octaves       - Number of octaves (iteration). (default: `3`)
+   * @param fbmFuncName   - Name of the fbm function. (default `"fbm"`)
+   * @param noiseFuncName - Name of the noise function to use inside fbm (must return a `float`). (default: `"noise"`)
+   * @param vecType       - The vec type the function accepts as a parameter. (default: `"vec2"`)
+   * @returns The formed fbm function
+   */
+  static FBMHQ(octaves?: number, fbmFuncName?: string, noiseFuncName?: string, vecType?: string): string;
+
+  /**
+   * Angular constraint working with coordinates on the range [-1, 1]
+   * =\> coord: Coordinates
+   * =\> angle: Angle in radians
+   * =\> smoothness: Smoothness of the pie
+   * =\> l: Length of the pie.
+   */
+  static PIE: string;
+
+  /**
+   * A conventional pseudo-random number generator with the "golden" numbers, based on uv position
+   */
+  static PRNG_LEGACY: string;
+
+  /**
+   * A pseudo-random number generator based on uv position which does not use cos/sin
+   * This PRNG replaces the old PRNG_LEGACY to workaround some driver bugs
+   */
+  static PRNG: string;
+
+  /**
+   * A Vec2 pseudo-random generator, based on uv position
+   */
+  static PRNG2D: string;
+
+  /**
+   * A Vec3 pseudo-random generator, based on uv position
+   */
+  static PRNG3D: string;
+
+  /**
+   * A conventional noise generator
+   */
+  static NOISE: string;
+
+  /**
+   * Convert a Hue-Saturation-Brightness color to RGB - useful to convert polar coordinates to RGB
+   */
+  static HSB2RGB: string;
+
+  /**
+   * Declare a wave function in a shader -\> wcos (default), wsin or wtan.
+   * Wave on the [v1,v2] range with amplitude -\> a and speed -\> speed.
+   * @param func - the math function to use (default: `"cos"`)
+   */
+  static WAVE(func?: BaseShaderMixin.WaveTrigFunction): string;
+
+  /**
+   * Rotation function.
+   */
+  static ROTATION: string;
+
+  /**
+   * Voronoi noise function. Needs PRNG2D and CONSTANTS.
+   * @see {@linkcode PRNG2D}
+   * @see {@linkcode CONSTANTS}
+   */
+  static VORONOI: string;
+
+  /**
+   * Enables GLSL 1.0 backwards compatibility in GLSL 3.00 ES vertex shaders.
+   */
+  static GLSL1_COMPATIBILITY_VERTEX: string;
+
+  /**
+   * Enables GLSL 1.0 backwards compatibility in GLSL 3.00 ES fragment shaders.
+   */
+  static GLSL1_COMPATIBILITY_FRAGMENT: string;
+}
+
+/**
+ * A mixin which decorates a PIXI.Filter or PIXI.Shader with common properties.
+ * @param ShaderClass - The parent ShaderClass class being mixed.
+ */
+declare function BaseShaderMixin<BaseClass extends BaseShaderMixin.BaseClass>(
+  ShaderClass: BaseClass,
+): Mixin<typeof BaseShader, BaseClass>;
+
+declare namespace BaseShaderMixin {
+  /** @privateRemarks `AnyMixed` can't extend `AnyMixedConstructor` if it's using the `BaseClass` union; `PIXI.Shader` is the parent of `Filter`, so it's used instead */
+  interface AnyMixedConstructor extends ReturnType<typeof BaseShaderMixin<PIXI.Shader.AnyConstructor>> {}
+  interface AnyMixed extends FixedInstanceType<AnyMixedConstructor> {}
+
+  type BaseClass = PIXI.Shader.AnyConstructor | PIXI.Filter.AnyConstructor;
+
+  type WaveTrigFunction = "cos" | "sin" | "tan";
+}
+
+export default BaseShaderMixin;