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

package/src/foundry/client/canvas/primary/primary-occludable-object.d.mts

@@ -0,0 +1,205 @@
+import type { FixedInstanceType, Mixin, NullishProps } from "#utils";
+import type { PrimaryCanvasObjectMixin } from "./_module.d.mts";
+import type { Token } from "#client/canvas/placeables/_module.d.mts";
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+declare class PrimaryOccludableObject {
+  /** @privateRemarks All mixin classes should accept anything for its constructor. */
+  constructor(...args: any[]);
+
+  /**
+   * Is this occludable object hidden for Gamemaster visibility only?
+   * @defaultValue `false`
+   */
+  hidden: boolean;
+
+  /**
+   * A flag which tracks whether the primary canvas object is currently in an occluded state.
+   * @defaultValue `false`
+   */
+  occluded: boolean;
+
+  /**
+   * The occlusion mode of this occludable object.
+   * @defaultValue `CONST.OCCLUSION_MODES.NONE`
+   */
+  occlusionMode: CONST.OCCLUSION_MODES;
+
+  /**
+   * The unoccluded alpha of this object.
+   * @defaultValue `1`
+   */
+  unoccludedAlpha: number;
+
+  /**
+   * The occlusion alpha of this object.
+   * @defaultValue `0`
+   */
+  occludedAlpha: number;
+
+  /**
+   * Fade this object on hover?
+   * @defaultValue `true`
+   */
+  get hoverFade(): boolean;
+
+  set hoverFade(value);
+
+  /**
+   * The amount of rendered FADE, RADIAL, and VISION occlusion.
+   * @defaultValue
+   * ```js
+   * {
+   *   fade: 0.0,
+   *   radial: 0.0,
+   *   vision: 0.0
+   * }
+   * ```
+   * @privateRemarks Foundry marked `@internal`
+   */
+  _occlusionState: PrimaryOccludableObjectMixin.OcclusionState;
+
+  /**
+   * The state of hover-fading.
+   * @defaultValue
+   * ```js
+   * {
+   *   hovered: false,
+   *   hoveredTime: 0,
+   *   faded: false,
+   *   fading: false,
+   *   fadingTime: 0,
+   *   occlusion: 0.0
+   * }
+   * ```
+   * @privateRemarks Foundry marked `@internal`
+   */
+  _hoverFadeState: PrimaryOccludableObjectMixin.HoverFadeState;
+
+  /**
+   * Get the blocking option bitmask value.
+   * @privateRemarks Foundry marked `@internal`
+   */
+  get _restrictionState(): number;
+
+  /**
+   * Is this object blocking light?
+   */
+  get restrictsLight(): boolean;
+
+  set restrictsLight(enabled);
+
+  /**
+   * Is this object blocking weather?
+   */
+  get restrictsWeather(): boolean;
+
+  set restrictsWeather(enabled);
+
+  /**
+   * Is this occludable object... occludable?
+   */
+  get isOccludable(): boolean;
+
+  /**
+   * Debounce assignment of the PCO occluded state to avoid cases like animated token movement which can rapidly
+   * change PCO appearance.
+   * Uses a 50ms debounce threshold.
+   * Objects which are in the hovered state remain occluded until their hovered state ends.
+   * @remarks Actually the return value of an arrow function passed to `foundry.utils.debounce` with a timeout of 50ms
+   */
+  debounceSetOcclusion: (occluded: boolean) => boolean;
+
+  updateCanvasTransform(): void;
+
+  _shouldRenderDepth(): boolean;
+
+  /**
+   * Test whether a specific Token occludes this PCO.
+   * Occlusion is tested against 9 points, the center, the four corners-, and the four cardinal directions
+   * @param token   - The Token to test
+   * @param options - Additional options that affect testing
+   * @returns Is the Token occluded by the PCO?
+   */
+  testOcclusion(token: Token.Implementation, options?: PrimaryOccludableObjectMixin.TestOcclusionOptions): boolean;
+
+  /**
+   * @deprecated since v12, will be removed in v14
+   * @remarks "`#roof` is deprecated in favor of more granular options: `#restrictsLight` and `#restrictsWeather`"
+   */
+  get roof(): boolean;
+
+  /**
+   * @deprecated since v12, until v14
+   * @remarks "#roof is deprecated in favor of more granular options: #restrictsLight and #restrictsWeather"
+   */
+  set roof(enabled);
+
+  /**
+   * @deprecated since v12, will be removed in v14
+   * @remarks "#containsPixel is deprecated. Use #containsCanvasPoint instead."
+   */
+  containsPixel(x: number, y: number, alphaThreshold?: number): boolean;
+
+  /**
+   * @deprecated since v11, will be removed in v13
+   * @remarks "PrimaryCanvasObject#renderOcclusion is deprecated in favor of PrimaryCanvasObject#renderDepth"
+   */
+  renderOcclusion(renderer: PIXI.Renderer): void;
+}
+
+declare function PrimaryOccludableObjectMixin<BaseClass extends PrimaryOccludableObjectMixin.BaseClass>(
+  DisplayObject: BaseClass,
+): Mixin<typeof PrimaryOccludableObject, ReturnType<typeof PrimaryCanvasObjectMixin<BaseClass>>>;
+
+declare namespace PrimaryOccludableObjectMixin {
+  interface AnyMixedConstructor extends ReturnType<typeof PrimaryOccludableObjectMixin<BaseClass>> {}
+  interface AnyMixed extends FixedInstanceType<AnyMixedConstructor> {}
+
+  type BaseClass = PIXI.Container.AnyConstructor;
+
+  /** @internal */
+  type _TestOcclusionOptions = NullishProps<{
+    /**
+     * Test corners of the hit-box in addition to the token center?
+     * @defaultValue `0`
+     */
+    corners: boolean;
+  }>;
+
+  /** Additional options that affect testing */
+  interface TestOcclusionOptions extends _TestOcclusionOptions {}
+
+  interface OcclusionState {
+    /** The amount of FADE occlusion */
+    fade: number;
+
+    /** The amount of RADIAL occlusion */
+    radial: number;
+
+    /** The amount of VISION occlusion */
+    vision: number;
+  }
+
+  interface HoverFadeState {
+    /** The hovered state */
+    hovered: boolean;
+
+    /** The last time when a mouse event was hovering this object */
+    hoveredTime: number;
+
+    /** The faded state */
+    faded: boolean;
+
+    /** The fading state */
+    fading: boolean;
+
+    /** The time the fade animation started */
+    fadingTime: number;
+
+    /** The amount of occlusion */
+    occlusion: number;
+  }
+}
+
+export default PrimaryOccludableObjectMixin;

package/src/foundry/client/canvas/primary/primary-particle-effect.d.mts

@@ -0,0 +1,17 @@
+import type { Identity } from "#utils";
+import type { CanvasTransformMixin } from "./primary-canvas-object.d.mts";
+
+declare class PrimaryParticleEffect extends CanvasTransformMixin(PIXI.Container) {
+  #PrimaryParticleEffect: true;
+}
+
+declare namespace PrimaryParticleEffect {
+  interface Any extends AnyPrimaryParticleEffect {}
+  interface AnyConstructor extends Identity<typeof AnyPrimaryParticleEffect> {}
+}
+
+export default PrimaryParticleEffect;
+
+declare abstract class AnyPrimaryParticleEffect extends PrimaryParticleEffect {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/primary/primary-sprite-mesh.d.mts

@@ -0,0 +1,203 @@
+import type { Identity, InexactPartial, NullishProps } from "#utils";
+import type { PrimaryBaseSamplerShader } from "#client/canvas/rendering/shaders/_module.d.mts";
+import type { TextureLoader } from "#client/canvas/_module.d.mts";
+import type { SpriteMesh } from "#client/canvas/containers/_module.mjs";
+import type { PrimaryOccludableObjectMixin } from "./_module.d.mts";
+import type { CanvasGroupMixin } from "#client/canvas/groups/_module.d.mts";
+import type { PlaceableObject } from "#client/canvas/placeables/_module.d.mts";
+
+/**
+ * A basic PCO sprite mesh which is handling occlusion and depth.
+ */
+declare class PrimarySpriteMesh extends PrimaryOccludableObjectMixin(SpriteMesh) {
+  constructor(
+    /**
+     * The constructor options.
+     * @defaultValue `{}`
+     * @remarks Default is applied if `options` is `instanceof PIXI.Texture`, or neither that nor `instanceof Object`
+     */
+    options?: PrimarySpriteMesh.ConstructorOptions | PIXI.Texture | null,
+
+    /**
+     * The shader class used to render this sprite.
+     * @defaultValue `PrimaryBaseSamplerShader`
+     * @remarks If `options` is an object, `options.shaderClass` takes precedence. If omitted,
+     * or if `options` is a `PIXI.Texture`, default is provided by `??` in function body.
+     */
+    shaderClass?: PrimaryBaseSamplerShader.AnyConstructor | null,
+  );
+
+  /**
+   * The texture alpha data.
+   */
+  protected _textureAlphaData: TextureLoader.TextureAlphaData | null;
+
+  /**
+   * The texture alpha threshold used for point containment tests.
+   * If set to a value larger than 0, the texture alpha data is
+   * extracted from the texture at 25% resolution.
+   * @defaultValue `0`
+   */
+  textureAlphaThreshold: number;
+
+  override _onTextureUpdate(): void;
+
+  override setShaderClass(shaderClass: PrimaryBaseSamplerShader.AnyConstructor): void;
+
+  /**
+   * An all-in-one helper method: Resizing the PCO according to desired dimensions and options.
+   * This helper computes the width and height based on the following factors:
+   *
+   * - The ratio of texture width and base width.
+   * - The ratio of texture height and base height.
+   *
+   * Additionally, It takes into account the desired fit options:
+   *
+   * - (default) "fill" computes the exact width and height ratio.
+   * - "cover" takes the maximum ratio of width and height and applies it to both.
+   * - "contain" takes the minimum ratio of width and height and applies it to both.
+   * - "width" applies the width ratio to both width and height.
+   * - "height" applies the height ratio to both width and height.
+   *
+   * You can also apply optional scaleX and scaleY options to both width and height. The scale is applied after fitting.
+   *
+   * **Important**: By using this helper, you don't need to set the height, width, and scale properties of the DisplayObject.
+   *
+   * **Note**: This is a helper method. Alternatively, you could assign properties as you would with a PIXI DisplayObject.
+   * @param baseWidth  - The base width used for computations.
+   * @param baseHeight - The base height used for computations.
+   * @param options    - The options.
+   * @throws If either `baseWidth` or `baseHeight` are less than 0, or if `options.fit` is not a FitType
+   */
+  resize(baseWidth: number, baseHeight: number, options?: PrimarySpriteMesh.ResizeOptions): void;
+
+  protected override _updateBatchData(): void;
+
+  protected override _calculateCanvasBounds(): void;
+
+  /**
+   * Is the given point in canvas space contained in this object?
+   * @param point                 - The point in canvas space
+   * @param textureAlphaThreshold - The minimum texture alpha required for containment
+   */
+  containsCanvasPoint(
+    point: PIXI.IPointData,
+
+    /** @defaultValue `this.textureAlphaThreshold` */
+    textureAlphaThreshold?: number,
+  ): boolean;
+
+  /**
+   * Is the given point in world space contained in this object?
+   * @param point                 - The point in world space
+   * @param textureAlphaThreshold - The minimum texture alpha required for containment
+   */
+  containsPoint(
+    point: PIXI.IPointData,
+
+    /** @defaultValue `this.textureAlphaThreshold` */
+    textureAlphaThreshold?: number,
+  ): boolean;
+
+  override renderDepthData(renderer: PIXI.Renderer): void;
+
+  /**
+   * Render the sprite with ERASE blending.
+   * Note: The sprite must not have visible/renderable children.
+   * @param renderer - The renderer
+   */
+  protected _renderVoid(renderer: PIXI.Renderer): void;
+
+  /**
+   * @deprecated since v12, will be removed in v14
+   * @remarks "#getPixelAlpha is deprecated without replacement."
+   */
+  getPixelAlpha(x: number, y: number): number;
+
+  /**
+   * @deprecated since v12, until v14
+   * @remarks "#_getAlphaBounds is deprecated without replacement."
+   */
+  _getAlphaBounds(): PIXI.Rectangle;
+
+  /**
+   * @deprecated since v12, until v14
+   * @remarks "#_getTextureCoordinate is deprecated without replacement."
+   */
+  _getTextureCoordinate(testX: number, testY: number): PIXI.IPointData;
+}
+
+declare namespace PrimarySpriteMesh {
+  interface Any extends AnyPrimarySpriteMesh {}
+  interface AnyConstructor extends Identity<typeof AnyPrimarySpriteMesh> {}
+
+  type FitType = "fill" | "cover" | "contain" | "width" | "height";
+
+  /** @internal */
+  type _ConstructorOptions = NullishProps<{
+    /**
+     * Texture passed to the SpriteMesh.
+     * @defaultValue `null`
+     * @remarks Default ultimately provided by the `SpriteMesh` constructor
+     */
+    texture: PIXI.Texture;
+
+    /**
+     * The shader class used to render this sprite.
+     * @defaultValue `PrimaryBaseSamplerShader`
+     * @remarks Default provided by `??=` in function body
+     */
+    shaderClass: PrimaryBaseSamplerShader.AnyConstructor;
+
+    /**
+     * The name of this sprite.
+     * @defaultValue `null`
+     * @remarks Default provided by `?? null` in function body
+     */
+    name: string;
+
+    /**
+     * Any object that owns this PCO.
+     * @defaultValue `null`
+     * @remarks Default via `?? null` in function body
+     * @privateRemarks Foundry types as `*`, but the only things passed in practice are `Tile`s, `Token`s, and the `PrimaryCanvasGroup`
+     */
+    // TODO: (esheyw) Revisit the "any canvas group" type when groups are done
+    object: PlaceableObject.Any | CanvasGroupMixin.AnyMixed;
+  }>;
+
+  /** The constructor options */
+  interface ConstructorOptions extends _ConstructorOptions {}
+
+  /** @internal */
+  type _ResizeOptions = InexactPartial<{
+    /**
+     * The fit type.
+     * @defaultValue `"fill"`
+     * @remarks Can't be `null` because it only has a parameter default, and is then fed into a switch statement where the default is throw
+     */
+    fit: FitType;
+
+    /**
+     * The scale on X axis.
+     * @defaultValue `1`
+     * @remarks Can't be `null` because it only has a parameter default and a width scale of 0 is, if not nonsensical, not to be done by accident.
+     */
+    scaleX: number;
+
+    /**
+     * The scale on Y axis.
+     * @defaultValue `1`
+     * @remarks Can't be `null` because it only has a parameter default and a height scale of 0 is, if not nonsensical, not to be done by accident.
+     */
+    scaleY: number;
+  }>;
+
+  interface ResizeOptions extends _ResizeOptions {}
+}
+
+export default PrimarySpriteMesh;
+
+declare abstract class AnyPrimarySpriteMesh extends PrimarySpriteMesh {
+  constructor(...args: never);
+}

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

@@ -0,0 +1,10 @@
+// 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 * as filters from "./filters/_module.mjs";
+export * as batching from "./batching/_module.mjs";
+export * as mixins from "./mixins/_module.mjs";
+export * as shaders from "./shaders/_module.mjs";
+export { BLEND_MODES } from "./blend-modes.mjs";

package/src/foundry/client/canvas/rendering/batching/_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 BatchShaderGenerator } from "./batch-shader-generator.mjs";
+export { default as BatchRenderer } from "./batch-renderer.mjs";

package/src/foundry/client/canvas/rendering/batching/batch-renderer.d.mts

@@ -0,0 +1,136 @@
+import type { ToMethod, InexactPartial, IntentionalPartial, Identity } from "#utils";
+import type { IBatchableElement, ViewableBuffer } from "pixi.js";
+import type BatchShaderGenerator from "./batch-shader-generator.mjs";
+import type { AbstractBaseShader } from "../shaders/_module.mjs";
+
+/**
+ * A batch renderer with a customizable data transfer function to packed geometries.
+ */
+declare class BatchRenderer extends PIXI.BatchRenderer {
+  /**
+   * The batch shader generator class.
+   * @defaultValue `BatchShaderGenerator`
+   */
+  static shaderGeneratorClass: typeof BatchShaderGenerator;
+
+  /**
+   * The default uniform values for the batch shader.
+   * @defaultValue `{}`
+   */
+  static defaultUniforms: AbstractBaseShader.Uniforms | BatchRenderer.BatchDefaultUniformsFunction;
+
+  /**
+   * The PackInterleavedGeometry function provided by the sampler.
+   */
+  protected _packInterleavedGeometry: BatchRenderer.PackInterleavedGeometryFunction | undefined;
+
+  /**
+   * The preRender function provided by the sampler and that is called just before a flush.
+   */
+  protected _preRenderBatch: BatchRenderer.PreRenderBatchFunction | undefined;
+
+  get uniforms(): AbstractBaseShader.Uniforms | undefined;
+
+  /**
+   * The number of reserved texture units that the shader generator should not use (maximum 4).
+   */
+  protected set reservedTextureUnits(val: BatchRenderer.ReservedTextureUnits);
+
+  /**
+   * Number of reserved texture units reserved by the batch shader that cannot be used by the batch renderer.
+   */
+  get reservedTextureUnits(): BatchRenderer.ReservedTextureUnits;
+
+  override setShaderGenerator(options?: BatchRenderer.ShaderGeneratorOptions): void;
+
+  /**
+   * This override allows to allocate a given number of texture units reserved for a custom batched shader.
+   * These reserved texture units won't be used to batch textures for PIXI.Sprite or SpriteMesh.
+   * @override
+   */
+  override contextChange(): void;
+
+  override onPrerender(): void;
+
+  override start(): void;
+
+  /**
+   * @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.
+   * @param name - The name of the pixi plugin to check.
+   * @returns True if the plugin exists, false otherwise.
+   */
+  static hasPlugin(name: string): boolean;
+}
+
+declare namespace BatchRenderer {
+  interface Any extends AnyBatchRenderer {}
+  interface AnyConstructor extends Identity<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 values 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>;
+
+  /** @remarks The `BatchRenderer#reservedTextureUnits` setter throws if passed a value outside of 0-4, and by usage wants an integer */
+  type ReservedTextureUnits = 0 | 1 | 2 | 3 | 4;
+
+  /** @internal */
+  type _ShaderGeneratorOptions = InexactPartial<{
+    /**
+     * The vertex shader source
+     * @remarks Can't be null as only a signature default is provided
+     */
+    vertex: typeof BatchRenderer.defaultVertexSrc;
+
+    /**
+     * The fragment shader source template
+     * @remarks Can't be null as only a signature default is provided
+     */
+    fragment: typeof BatchRenderer.defaultFragmentTemplate;
+
+    /**
+     * Additional Uniforms
+     * @remarks Can't be null as only a signature default is provided
+     */
+    uniforms: typeof BatchRenderer.defaultUniforms;
+  }>;
+
+  /**
+   * Options for {@link BatchRenderer#setShaderGenerator} (and ultimately the
+   * constructor of whatever's set as {@link BatchRenderer.shaderGeneratorClass})
+   */
+  interface ShaderGeneratorOptions extends _ShaderGeneratorOptions {}
+}
+
+export default BatchRenderer;
+
+declare abstract class AnyBatchRenderer extends BatchRenderer {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/rendering/batching/batch-shader-generator.d.mts

@@ -0,0 +1,30 @@
+import type { Identity } from "#utils";
+import type BatchRenderer from "./batch-renderer.mjs";
+import type { AbstractBaseShader } from "../shaders/_module.mjs";
+
+/**
+ * A batch shader generator that could handle extra uniforms during initialization.
+ * @param vertexSrc    - The vertex shader source
+ * @param fragTemplate - The fragment shader source template
+ * @param uniforms     - Additional uniforms (default: `{}`)
+ */
+declare class BatchShaderGenerator extends PIXI.BatchShaderGenerator {
+  constructor(
+    vertexSrc: string,
+    fragTemplate: string,
+    uniforms?: AbstractBaseShader.Uniforms | BatchRenderer.BatchDefaultUniformsFunction,
+  );
+
+  override generateShader(maxTextures: number): PIXI.Shader;
+}
+
+declare namespace BatchShaderGenerator {
+  interface Any extends AnyBatchShaderGenerator {}
+  interface AnyConstructor extends Identity<typeof AnyBatchShaderGenerator> {}
+}
+
+export default BatchShaderGenerator;
+
+declare abstract class AnyBatchShaderGenerator extends BatchShaderGenerator {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/rendering/blend-modes.d.mts

@@ -0,0 +1,49 @@
+export const BLEND_MODES: {
+  /**
+   * A custom blend mode equation which chooses the maximum color from each channel within the stack.
+   * @defaultValue
+   * ```typescript
+   * [
+   *   WebGL2RenderingContext.ONE,
+   *   WebGL2RenderingContext.ONE,
+   *   WebGL2RenderingContext.ONE,
+   *   WebGL2RenderingContext.ONE,
+   *   WebGL2RenderingContext.MAX,
+   *   WebGL2RenderingContext.MAX,
+   * ]
+   * ```
+   */
+  MAX_COLOR: [GLenum, GLenum, GLenum, GLenum, GLenum, GLenum];
+
+  /**
+   * A custom blend mode equation which chooses the minimum color from each channel within the stack.
+   * @defaultValue
+   * ```typescript
+   * [
+   *   WebGL2RenderingContext.ONE,
+   *   WebGL2RenderingContext.ONE,
+   *   WebGL2RenderingContext.ONE,
+   *   WebGL2RenderingContext.ONE,
+   *   WebGL2RenderingContext.MIN,
+   *   WebGL2RenderingContext.MAX,
+   * ]
+   * ```
+   */
+  MIN_COLOR: [GLenum, GLenum, GLenum, GLenum, GLenum, GLenum];
+
+  /**
+   * A custom blend mode equation which chooses the minimum color for color channels and min alpha from alpha channel.
+   * @defaultValue
+   * ```typescript
+   * [
+   *   WebGL2RenderingContext.ONE,
+   *   WebGL2RenderingContext.ONE,
+   *   WebGL2RenderingContext.ONE,
+   *   WebGL2RenderingContext.ONE,
+   *   WebGL2RenderingContext.MIN,
+   *   WebGL2RenderingContext.MIN,
+   * ]
+   * ```
+   */
+  MIN_ALL: [GLenum, GLenum, GLenum, GLenum, GLenum, GLenum];
+};

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

@@ -0,0 +1,23 @@
+// 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 * as types from "./_types.mjs";
+
+export { default as SMAAFilter } from "./smaa/smaa.mjs";
+export { default as SMAANeighborhoodBlendingFilter } from "./smaa/blend.mjs";
+export { default as SMAAEdgeDetectionFilter } from "./smaa/edges.mjs";
+export { default as SMAABlendingWeightCalculationFilter } from "./smaa/weights.mjs";
+export { default as AbstractBaseFilter } from "./base-filter.mjs";
+export { default as AbstractBaseMaskFilter } from "./base-mask-filter.mjs";
+export { default as VisualEffectsMaskingFilter } from "./effects-masking.mjs";
+export { default as PrimaryCanvasGroupAmbienceFilter } from "./environment.mjs";
+export { default as GlowOverlayFilter } from "./glow-overlay.mjs";
+export { default as InvisibilityFilter } from "./invisibility.mjs";
+export { default as OutlineOverlayFilter } from "./outline-overlay.mjs";
+export { default as TextureTransitionFilter } from "./transition.mjs";
+export { default as VisibilityFilter } from "./visibility.mjs";
+export { default as VisionMaskFilter } from "./vision-mask-filter.mjs";
+export { default as VoidFilter } from "./void.mjs";
+export { default as WeatherOcclusionMaskFilter } from "./weather-occlusion-mask.mjs";

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

@@ -0,0 +1,4 @@
+/* eslint-disable import-x/export */
+/* eslint-disable import-x/extensions */
+
+export * from "./smaa/_types.mjs";