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

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

@@ -1,125 +0,0 @@
-import type { AnyObject, Brand, FixedInstanceType, Identity, ShapeWithIndexSignature } from "fvtt-types/utils";
-
-declare global {
-  /**
-   * This filter handles masking and post-processing for visual effects.
-   */
-  class VisualEffectsMaskingFilter extends AbstractBaseMaskFilter {
-    static override create<ThisType extends AbstractBaseFilter.AnyConstructor, T extends AnyObject>(
-      this: ThisType,
-      {
-        postProcessModes,
-        ...initialUniforms
-      }?: ShapeWithIndexSignature<
-        T,
-        VisualEffectsMaskingFilter.ConcreteCreateOptions,
-        string,
-        AbstractBaseShader.UniformValue
-      >,
-    ): FixedInstanceType<ThisType>;
-
-    /**
-     * Masking modes.
-     * @remarks Object is frozen
-     */
-    static FILTER_MODES: {
-      readonly BACKGROUND: 0 & VisualEffectsMaskingFilter.FILTER_MODES;
-      readonly ILLUMINATION: 1 & VisualEffectsMaskingFilter.FILTER_MODES;
-      readonly COLORATION: 2 & VisualEffectsMaskingFilter.FILTER_MODES;
-    };
-
-    /**
-     * @defaultValue
-     * ```js
-     * {
-     *    tint: [1, 1, 1],
-     *    screenDimensions: [1, 1],
-     *    enableVisionMasking: true,
-     *    visionTexture: null,
-     *    darknessLevelTexture: null,
-     *    exposure: 0,
-     *    contrast: 0,
-     *    saturation: 0,
-     *    mode: 0,
-     *    ambientDarkness: [0, 0, 0],
-     *    ambientDaylight: [1, 1, 1],
-     *    replacementColor: [0, 0, 0]
-     * }
-     * ```
-     */
-    static override defaultUniforms: AbstractBaseShader.Uniforms;
-
-    /**
-     * Update the filter shader with new post-process modes.
-     * @param postProcessModes - New modes to apply.
-     * @param uniforms         - Uniforms value to update.
-     */
-    updatePostprocessModes(
-      postProcessModes?: VisualEffectsMaskingFilter.PostProcessModes,
-      uniforms?: AbstractBaseShader.Uniforms,
-    ): void;
-
-    /**
-     * Remove all post-processing modes and reset some key uniforms.
-     */
-    reset(): void;
-
-    override apply(
-      filterManager: PIXI.FilterSystem,
-      input: PIXI.RenderTexture,
-      output: PIXI.RenderTexture,
-      clear: PIXI.CLEAR_MODES,
-      currentState?: PIXI.FilterState,
-    ): void;
-
-    /**
-     * Filter 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
-     */
-    static fragmentHeader: string;
-
-    static fragmentCore: string;
-
-    /**
-     * Construct filter post-processing code according to provided value.
-     * @param postProcessModes - Post-process modes to construct techniques.
-     * @returns The constructed shader code for post-process techniques.
-     */
-    static fragmentPostProcess(postProcessModes?: VisualEffectsMaskingFilter.PostProcessModes): string;
-
-    /**
-     * Specify the fragment shader to use according to mode
-     * @param postProcessModes - (default: [])
-     */
-    static override fragmentShader(postProcessModes?: VisualEffectsMaskingFilter.PostProcessModes): string;
-  }
-
-  namespace VisualEffectsMaskingFilter {
-    interface Any extends AnyVisualEffectsMaskingFilter {}
-    interface AnyConstructor extends Identity<typeof AnyVisualEffectsMaskingFilter> {}
-
-    type ConfiguredClass = CONFIG["Canvas"]["visualEffectsMaskingFilter"];
-    type ConfiguredInstance = FixedInstanceType<ConfiguredClass>;
-
-    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(...args: never);
-}

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

@@ -1,41 +0,0 @@
-import type { Identity } from "fvtt-types/utils";
-
-declare global {
-  /**
-   * A filter used to apply color adjustments and other modifications to the environment.
-   */
-  class PrimaryCanvasGroupAmbienceFilter extends AbstractBaseMaskFilter {
-    static override fragmentShader: string;
-
-    /**
-     * @defaultValue
-     * ```js
-     * {
-     *    uSampler: null,
-     *    darknessLevelTexture: null,
-     *    cycle: true,
-     *    baseTint: [1, 1, 1], // Important: The base tint uniform must be in linear RGB!
-     *    baseIntensity: 0,
-     *    baseLuminosity: 0,
-     *    baseSaturation: 0,
-     *    baseShadows: 0,
-     *    darkTint: [1, 1, 1], // Important: The dark tint uniform must be in linear RGB!
-     *    darkIntensity: 0,
-     *    darkLuminosity: 0,
-     *    darkSaturation: 0,
-     *    darkShadows: 0
-     * }
-     * ```
-     */
-    static override defaultUniforms: AbstractBaseShader.Uniforms;
-  }
-
-  namespace PrimaryCanvasGroupAmbienceFilter {
-    interface Any extends AnyPrimaryCanvasGroupAmbienceFilter {}
-    interface AnyConstructor extends Identity<typeof AnyPrimaryCanvasGroupAmbienceFilter> {}
-  }
-}
-
-declare abstract class AnyPrimaryCanvasGroupAmbienceFilter extends PrimaryCanvasGroupAmbienceFilter {
-  constructor(...args: never);
-}

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

@@ -1,76 +0,0 @@
-import type { FixedInstanceType, Identity } from "fvtt-types/utils";
-
-declare global {
-  /**
-   * A filter which implements an inner or outer glow around the source texture.
-   * Inspired from https://github.com/pixijs/filters/tree/main/filters/glow
-   * @remarks MIT License
-   */
-  class GlowOverlayFilter extends AbstractBaseFilter {
-    /**
-     * @defaultValue `6`
-     */
-    override padding: number;
-
-    /**
-     * The inner strength of the glow.
-     * @defaultValue `3`
-     */
-    innerStrength: number;
-
-    /**
-     * The outer strength of the glow.
-     * @defaultValue `3`
-     */
-    outerStrength: number;
-
-    /**
-     * Should this filter auto-animate?
-     * @defaultValue `true`
-     */
-    animated: boolean;
-
-    /**
-     * @defaultValue
-     * ```js
-     * {
-     *   distance: 10,
-     *   glowColor: [1, 1, 1, 1],
-     *   quality: 0.1,
-     *   time: 0,
-     *   knockout: true,
-     *   alpha: 1
-     * }
-     * ```
-     */
-    static override defaultUniforms: AbstractBaseShader.Uniforms;
-
-    /**
-     * Dynamically create the fragment shader used for filters of this type.
-     */
-    static createFragmentShader(quality: number, distance: number): string;
-
-    static override vertexShader: string;
-
-    static override create<ThisType extends AbstractBaseFilter.AnyConstructor>(
-      this: ThisType,
-      initialUniforms?: AbstractBaseShader.Uniforms | null,
-    ): FixedInstanceType<ThisType>;
-
-    override apply(
-      filterManager: PIXI.FilterSystem,
-      input: PIXI.RenderTexture,
-      output: PIXI.RenderTexture,
-      clear: PIXI.CLEAR_MODES,
-    ): void;
-  }
-
-  namespace GlowOverlayFilter {
-    interface Any extends AnyGlowOverlayFilter {}
-    interface AnyConstructor extends Identity<typeof AnyGlowOverlayFilter> {}
-  }
-}
-
-declare abstract class AnyGlowOverlayFilter extends GlowOverlayFilter {
-  constructor(...args: never);
-}

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

@@ -1,13 +0,0 @@
-import "./base-filter.d.mts";
-import "./base-mask-filter.d.mts";
-import "./blur.d.mts";
-import "./effects-masking.d.mts";
-import "./environment.d.mts";
-import "./glow-overlay.d.mts";
-import "./invisibility.d.mts";
-import "./outline-overlay.d.mts";
-import "./transition.d.mts";
-import "./visibility.d.mts";
-import "./vision-mask-filter.d.mts";
-import "./void.d.mts";
-import "./weather-occlusion-masks.d.mts";

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

@@ -1,30 +0,0 @@
-import type { Identity } from "fvtt-types/utils";
-
-declare global {
-  /**
-   * Invisibility effect filter for placeables.
-   */
-  class InvisibilityFilter extends AbstractBaseFilter {
-    static override fragmentShader: string;
-
-    /**
-     * @defaultValue
-     * ```js
-     * {
-     *   uSampler: null,
-     *   color: [0.5, 1, 1]
-     * }
-     * ```
-     */
-    static override defaultUniforms: AbstractBaseShader.Uniforms;
-  }
-
-  namespace InvisibilityFilter {
-    interface Any extends AnyInvisibilityFilter {}
-    interface AnyConstructor extends Identity<typeof AnyInvisibilityFilter> {}
-  }
-}
-
-declare abstract class AnyInvisibilityFilter extends InvisibilityFilter {
-  constructor(...args: never);
-}

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

@@ -1,87 +0,0 @@
-import type { FixedInstanceType, Identity } from "fvtt-types/utils";
-
-declare global {
-  /**
-   * A filter which implements an outline.
-   * Inspired from https://github.com/pixijs/filters/tree/main/filters/outline
-   * @remarks MIT License
-   */
-  class OutlineOverlayFilter extends AbstractBaseFilter {
-    /**
-     * @defaultValue `3`
-     */
-    override padding: number;
-
-    /**
-     * @defaultValue `false`
-     */
-    override autoFit: boolean;
-
-    /**
-     * If the filter is animated or not.
-     * @defaultValue `true`
-     */
-    animated: boolean;
-
-    /**
-     * @defaultValue
-     * ```js
-     * {
-     *    outlineColor: [1, 1, 1, 1],
-     *    thickness: [1, 1],
-     *    alphaThreshold: 0.60,
-     *    knockout: true,
-     *    wave: false
-     * }
-     * ```
-     */
-    static override defaultUniforms: AbstractBaseShader.Uniforms;
-
-    static override vertexShader: string;
-
-    /**
-     * Dynamically create the fragment shader used for filters of this type.
-     */
-    static createFragmentShader(): string;
-
-    /**
-     * The thickness of the outline.
-     */
-    get thickness(): number;
-
-    set thickness(value);
-
-    static override create<ThisType extends AbstractBaseFilter.AnyConstructor>(
-      this: ThisType,
-      initialUniforms?: AbstractBaseShader.Uniforms | null,
-    ): FixedInstanceType<ThisType>;
-
-    override apply(
-      filterManager: PIXI.FilterSystem,
-      input: PIXI.RenderTexture,
-      output: PIXI.RenderTexture,
-      clear: PIXI.CLEAR_MODES,
-    ): void;
-
-    /**
-     * @deprecated since v12, until v14
-     * @remarks OutlineOverlayFilter#animate is deprecated in favor of OutlineOverlayFilter#animated.
-     */
-    get animate(): boolean;
-
-    /**
-     * @deprecated since v12, until v14
-     * @remarks OutlineOverlayFilter#animate is deprecated in favor of OutlineOverlayFilter#animated.
-     */
-    set animate(v);
-  }
-
-  namespace OutlineOverlayFilter {
-    interface Any extends AnyOutlineOverlayFilter {}
-    interface AnyConstructor extends Identity<typeof AnyOutlineOverlayFilter> {}
-  }
-}
-
-declare abstract class AnyOutlineOverlayFilter extends OutlineOverlayFilter {
-  constructor(...args: never);
-}

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

@@ -1,126 +0,0 @@
-import type { Brand, Identity, InexactPartial } from "fvtt-types/utils";
-
-declare global {
-  /**
-   * A filter specialized for transition effects between a source object and a target texture.
-   */
-  class TextureTransitionFilter extends AbstractBaseFilter {
-    static get TYPES(): TextureTransitionFilter.Types;
-
-    /**
-     * The transition type (see {@link TextureTransitionFilter.TYPES | `TextureTransitionFilter.TYPES`}).
-     * @defaultValue `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;
-  }
-
-  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 `TYPES.FADE`
-       * @remarks Can't be null because it only has a signature-provided default.
-       */
-      type: TextureTransitionFilter.TYPES;
-
-      /**
-       * The name of the {@link CanvasAnimation | `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(...args: never);
-}

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

@@ -1,77 +0,0 @@
-import type { FixedInstanceType, Identity, NullishProps } from "fvtt-types/utils";
-
-declare global {
-  /**
-   * Apply visibility coloration according to the baseLine color.
-   * Uses very lightweight gaussian vertical and horizontal blur filter passes.
-   */
-  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,
-      initiaUniforms?: AbstractBaseShader.Uniforms | null,
-      options?: VisibilityFilter.FragmentShaderOptions, // not:null (passed to `this.fragmentShader()` where its properties are accesed unsafely),
-    ): 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;
-  }
-
-  namespace VisibilityFilter {
-    interface Any extends AnyVisibilityFilter {}
-    interface AnyConstructor extends Identity<typeof AnyVisibilityFilter> {}
-
-    type ConfiguredClass = CONFIG["Canvas"]["visibilityFilter"];
-    type ConfiguredInstance = FixedInstanceType<ConfiguredClass>;
-
-    /** @internal */
-    type _FragmentShaderOptions = NullishProps<{
-      persistentVision: boolean;
-    }>;
-
-    interface FragmentShaderOptions extends _FragmentShaderOptions {}
-  }
-}
-
-declare abstract class AnyVisibilityFilter extends VisibilityFilter {
-  constructor(...args: never);
-}

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

@@ -1,36 +0,0 @@
-import type { FixedInstanceType, Identity } from "fvtt-types/utils";
-
-declare global {
-  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.332.
-     */
-    override readonly enabled: boolean;
-  }
-
-  namespace VisionMaskFilter {
-    interface Any extends AnyVisionMaskFilter {}
-    interface AnyConstructor extends Identity<typeof AnyVisionMaskFilter> {}
-  }
-}
-
-declare abstract class AnyVisionMaskFilter extends VisionMaskFilter {
-  constructor(...args: never);
-}

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

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

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

@@ -1,57 +0,0 @@
-import type { Identity } from "fvtt-types/utils";
-
-declare global {
-  /**
-   * The filter used by the weather layer to mask weather above occluded roofs.
-   * @see {@link WeatherEffects | `WeatherEffects`}
-   */
-  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,
-     *   everseOcclusion: 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;
-  }
-
-  namespace WeatherOcclusionMaskFilter {
-    interface Any extends AnyWeatherOcclusionMaskFilter {}
-    interface AnyConstructor extends Identity<typeof AnyWeatherOcclusionMaskFilter> {}
-  }
-}
-
-declare abstract class AnyWeatherOcclusionMaskFilter extends WeatherOcclusionMaskFilter {
-  constructor(...args: never);
-}