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

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

@@ -0,0 +1,47 @@
+import type { FixedInstanceType, Identity } from "#utils";
+import type { AbstractBaseShader } from "../shaders/_module.mjs";
+import type { BaseShaderMixin } from "../mixins/_module.mjs";
+
+/**
+ * An abstract filter which provides a framework for reusable definition
+ */
+declare class AbstractBaseFilter extends BaseShaderMixin(PIXI.Filter) {
+  /**
+   * The default uniforms used by the filter
+   * @defaultValue `{}`
+   */
+  static defaultUniforms: AbstractBaseShader.Uniforms;
+
+  /**
+   * The fragment shader which renders this filter.
+   * @defaultValue `undefined`
+   */
+  static fragmentShader: AbstractBaseShader.FragmentShaderFunction | string | undefined;
+
+  /**
+   * The vertex shader which renders this filter.
+   * @defaultValue `undefined`
+   */
+  static vertexShader: string | undefined;
+
+  /**
+   * A factory method for creating the filter using its defined default values.
+   * @param initialUniforms - Initial uniform values which override filter defaults (default: `{}`)
+   * @returns The constructed AbstractFilter[sic] instance.
+   */
+  static create<ThisType extends AbstractBaseFilter.AnyConstructor>(
+    this: ThisType,
+    initialUniforms?: AbstractBaseShader.Uniforms,
+  ): FixedInstanceType<ThisType>;
+}
+
+declare namespace AbstractBaseFilter {
+  interface Any extends AnyAbstractBaseFilter {}
+  interface AnyConstructor extends Identity<typeof AnyAbstractBaseFilter> {}
+}
+
+export default AbstractBaseFilter;
+
+declare abstract class AnyAbstractBaseFilter extends AbstractBaseFilter {
+  constructor(...args: never);
+}

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

@@ -0,0 +1,32 @@
+import type { Identity } from "#utils";
+import type { AbstractBaseFilter } from "./_module.d.mts";
+
+/**
+ * This class defines an interface for masked custom filters
+ */
+declare class AbstractBaseMaskFilter extends AbstractBaseFilter {
+  /**
+   * The default vertex shader used by all instances of AbstractBaseMaskFilter
+   */
+  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,
+  ): void;
+}
+
+declare namespace AbstractBaseMaskFilter {
+  interface Any extends AnyAbstractBaseMaskFilter {}
+  interface AnyConstructor extends Identity<typeof AnyAbstractBaseMaskFilter> {}
+}
+
+export default AbstractBaseMaskFilter;
+
+declare abstract class AnyAbstractBaseMaskFilter extends AbstractBaseMaskFilter {
+  constructor(...args: never);
+}

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

@@ -0,0 +1,194 @@
+import type { Identity } from "#utils";
+
+/**
+ * Apply a vertical or horizontal gaussian blur going inward by using alpha as the penetrating channel.
+ */
+declare class AlphaBlurFilterPass extends PIXI.Filter {
+  /**
+   * @param horizontal - If the pass is horizontal (true) or vertical (false).
+   * @param strength   - Strength of the blur (distance of sampling). (default: `8`)
+   * @param quality    - Number of passes to generate the blur. More passes = Higher quality = Lower Perf. (default: `4`)
+   * @param resolution - Resolution of the filter. (default: `PIXI.Filter.defaultResolution`)
+   * @param kernelSize - Number of kernels to use. More kernels = Higher quality = Lower Perf. (default: `5`)
+   */
+  constructor(horizontal: boolean, strength?: number, quality?: number, resolution?: number, kernelSize?: number);
+
+  /**
+   * If the pass is horizontal (true) or vertical (false).
+   */
+  horizontal: boolean;
+
+  /**
+   * Strength of the blur (distance of sampling).
+   */
+  strength: number;
+
+  /**
+   * The number of passes to generate the blur.
+   */
+  passes: number;
+
+  /**
+   * The quality of the filter is defined by its number of passes.
+   */
+  get quality(): number;
+
+  set quality(value);
+
+  /**
+   * The strength of the blur filter in pixels.
+   */
+  get blur(): number;
+
+  set blur(value);
+
+  /**
+   * The kernels containing the gaussian constants.
+   * @defaultValue
+   * ```js
+   * {
+   *   5:  [0.153388, 0.221461, 0.250301],
+   *   7:  [0.071303, 0.131514, 0.189879, 0.214607],
+   *   9:  [0.028532, 0.067234, 0.124009, 0.179044, 0.20236],
+   *   11: [0.0093,   0.028002, 0.065984, 0.121703, 0.175713, 0.198596],
+   *   13: [0.002406, 0.009255, 0.027867, 0.065666, 0.121117, 0.174868, 0.197641],
+   *   15: [0.000489, 0.002403, 0.009246, 0.02784,  0.065602, 0.120999, 0.174697, 0.197448]
+   * }
+   * ```
+   */
+  static GAUSSIAN_VALUES: Record<number, number[]>;
+
+  /**
+   * The fragment template generator
+   * @param kernelSize - The number of kernels to use.
+   * @returns The generated fragment shader.
+   */
+  static fragTemplate(kernelSize: number): string;
+
+  /**
+   * The vertex template generator
+   * @param kernelSize - The number of kernels to use.
+   * @param horizontal - If the vertex should handle horizontal or vertical pass.
+   * @returns The generated vertex shader.
+   */
+  static vertTemplate(kernelSize: number, horizontal: boolean): string;
+
+  /**
+   * Generating the dynamic part of the blur in the fragment
+   * @param kernelSize - The number of kernels to use.
+   * @returns The dynamic blur part.
+   */
+  static generateBlurFragSource(kernelSize: number): string;
+
+  /**
+   * Generating the dynamic part of the blur in the vertex
+   * @param kernelSize - number of kernels to use.
+   * @param horizontal - If the vertex should handle horizontal or vertical pass.
+   * @returns The dynamic blur part.
+   */
+  static generateBlurVertSource(kernelSize: number, horizontal: boolean): string;
+
+  override apply(
+    filterManager: PIXI.FilterSystem,
+    input: PIXI.RenderTexture,
+    output: PIXI.RenderTexture,
+    clearMode?: PIXI.CLEAR_MODES,
+  ): void;
+}
+
+declare namespace AlphaBlurFilterPass {
+  interface Any extends AnyAlphaBlurFilterPass {}
+  interface AnyConstructor extends Identity<typeof AnyAlphaBlurFilterPass> {}
+}
+
+/**
+ * Apply a gaussian blur going inward by using alpha as the penetrating channel.
+ */
+declare class AlphaBlurFilter extends PIXI.Filter {
+  /**
+   * @param strength   - Strength of the blur (distance of sampling). (default: `8`)
+   * @param quality    - Number of passes to generate the blur. More passes = Higher quality = Lower Perf. (default: `4`)
+   * @param resolution - Resolution of the filter. (default: `PIXI.Filter.defaultResolution`)
+   * @param kernelSize - Number of kernels to use. More kernels = Higher quality = Lower Perf. (default: `5`)
+   */
+  constructor(strength?: number, quality?: number, resolution?: number, kernelSize?: number);
+
+  /** @privateRemarks Not in class body, set in constructor */
+  blurXFilter: AlphaBlurFilterPass;
+
+  /** @privateRemarks Not in class body, set in constructor */
+  blurYFilter: AlphaBlurFilterPass;
+
+  /** @privateRemarks Not in class body, set in constructor */
+  _repeatEdgePixels: boolean;
+
+  override apply(
+    filterManager: PIXI.FilterSystem,
+    input: PIXI.RenderTexture,
+    output: PIXI.RenderTexture,
+    clearMode?: PIXI.CLEAR_MODES,
+  ): void;
+
+  /**
+   * Update the filter padding according to the blur strength value (0 if _repeatEdgePixels is active)
+   */
+  updatePadding(): void;
+
+  /**
+   * The amount of blur is forwarded to the X and Y filters.
+   */
+  get blur(): number;
+
+  set blur(value);
+
+  /**
+   * The quality of blur defines the number of passes used by subsidiary filters.
+   */
+  get quality(): number;
+
+  set quality(value);
+
+  /**
+   * Whether to repeat edge pixels, adding padding to the filter area.
+   */
+  get repeatEdgePixels(): boolean;
+
+  set repeatEdgePixels(value);
+
+  /**
+   * Provided for completeness with PIXI.BlurFilter
+   */
+  get blurX(): number;
+
+  set blurX(value);
+
+  /**
+   * Provided for completeness with PIXI.BlurFilter
+   */
+  get blurY(): number;
+
+  set blurY(value);
+
+  /**
+   * Provided for completeness with PIXI.BlurFilter
+   */
+  get blendMode(): PIXI.BLEND_MODES;
+
+  set blendMode(value);
+}
+
+declare namespace AlphaBlurFilter {
+  interface Any extends AnyAlphaBlurFilter {}
+  interface AnyConstructor extends Identity<typeof AnyAlphaBlurFilter> {}
+}
+
+// note: not re-exported by `./_module.mjs`, only imported by core in `../../board.mjs`
+export { AlphaBlurFilter as default, AlphaBlurFilterPass };
+
+declare abstract class AnyAlphaBlurFilterPass extends AlphaBlurFilterPass {
+  constructor(...args: never);
+}
+
+declare abstract class AnyAlphaBlurFilter extends AlphaBlurFilter {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/rendering/filters/effects-masking.d.mts

@@ -0,0 +1,144 @@
+import type { AnyObject, Brand, FixedInstanceType, Identity, InexactPartial, ShapeWithIndexSignature } from "#utils";
+import type { AbstractBaseFilter, AbstractBaseMaskFilter } from "./_module.d.mts";
+import type { AbstractBaseShader } from "../shaders/_module.mjs";
+
+/**
+ * This filter handles masking and post-processing for visual effects.
+ */
+declare class VisualEffectsMaskingFilter extends AbstractBaseMaskFilter {
+  /**
+   * @remarks `postProcessModes` is pulled out of `options` and passed to {@link VisualEffectsMaskingFilter.fragmentShader | `this.fragmentShader`},
+   * the rest of the object is treated as `initialUniforms` as per {@linkcode AbstractBaseFilter.create}
+   */
+  static override create<ThisType extends AbstractBaseFilter.AnyConstructor, T extends AnyObject>(
+    this: ThisType,
+    { postProcessModes, ...initialUniforms }?: VisualEffectsMaskingFilter.CreateOptions<T>,
+  ): FixedInstanceType<ThisType>;
+
+  /**
+   * Masking modes.
+   * @remarks Object is frozen
+   */
+  static FILTER_MODES: VisualEffectsMaskingFilter.FilterModes;
+
+  /**
+   * @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: VisualEffectsMaskingFilter.PostProcessTechniques;
+
+  /**
+   * 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;
+
+  #VisualEffectsMaskingFilter: true;
+}
+
+declare namespace VisualEffectsMaskingFilter {
+  interface Any extends AnyVisualEffectsMaskingFilter {}
+  interface AnyConstructor extends Identity<typeof AnyVisualEffectsMaskingFilter> {}
+
+  // 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"]["visualEffectsMaskingFilter"];
+  interface Implementation extends FixedInstanceType<ImplementationClass> {}
+
+  type PostProcessModes = Array<keyof typeof VisualEffectsMaskingFilter.POST_PROCESS_TECHNIQUES>;
+
+  /** @internal */
+  type _ConcreteCreateOptions = InexactPartial<{
+    /**
+     * @defaultValue `[]`
+     * @privateRemarks Default not in construction signature, but provided by {@linkcode VisualEffectsMaskingFilter.fragmentShader}
+     */
+    postProcessModes: PostProcessModes;
+  }>;
+
+  interface ConcreteCreateOptions extends _ConcreteCreateOptions {}
+  type CreateOptions<T extends AnyObject> = ShapeWithIndexSignature<
+    T,
+    VisualEffectsMaskingFilter.ConcreteCreateOptions,
+    string,
+    AbstractBaseShader.UniformValue
+  >;
+
+  type FILTER_MODES = Brand<number, "VisualEffectsMaskingFilter.FILTER_MODES">;
+
+  interface FilterModes {
+    readonly BACKGROUND: 0 & FILTER_MODES;
+    readonly ILLUMINATION: 1 & FILTER_MODES;
+    readonly COLORATION: 2 & FILTER_MODES;
+  }
+
+  type POST_PROCESS_TECHNIQUES_ID = Brand<string, "VisualEffectsMaskingFilter.POST_PROCESS_TECHNIQUES.ID">;
+
+  interface PostProcessTechniques {
+    EXPOSURE: { id: "EXPOSURE" & POST_PROCESS_TECHNIQUES_ID; glsl: string };
+    CONTRAST: { id: "CONTRAST" & POST_PROCESS_TECHNIQUES_ID; glsl: string };
+    SATURATION: { id: "SATURATION" & POST_PROCESS_TECHNIQUES_ID; glsl: string };
+  }
+}
+
+export default VisualEffectsMaskingFilter;
+
+declare abstract class AnyVisualEffectsMaskingFilter extends VisualEffectsMaskingFilter {
+  constructor(...args: never);
+}

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

@@ -0,0 +1,43 @@
+import type { Identity } from "#utils";
+import type { AbstractBaseMaskFilter } from "./_module.mjs";
+import type { AbstractBaseShader } from "../shaders/_module.mjs";
+
+/**
+ * A filter used to apply color adjustments and other modifications to the environment.
+ */
+declare 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;
+}
+
+declare namespace PrimaryCanvasGroupAmbienceFilter {
+  interface Any extends AnyPrimaryCanvasGroupAmbienceFilter {}
+  interface AnyConstructor extends Identity<typeof AnyPrimaryCanvasGroupAmbienceFilter> {}
+}
+
+export default PrimaryCanvasGroupAmbienceFilter;
+
+declare abstract class AnyPrimaryCanvasGroupAmbienceFilter extends PrimaryCanvasGroupAmbienceFilter {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/rendering/filters/glow-overlay.d.mts

@@ -0,0 +1,78 @@
+import type { FixedInstanceType, Identity } from "#utils";
+import type { AbstractBaseFilter } from "./_module.d.mts";
+import type { AbstractBaseShader } from "../shaders/_module.mjs";
+
+/**
+ * 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
+ */
+declare 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,
+  ): FixedInstanceType<ThisType>;
+
+  override apply(
+    filterManager: PIXI.FilterSystem,
+    input: PIXI.RenderTexture,
+    output: PIXI.RenderTexture,
+    clear?: PIXI.CLEAR_MODES,
+  ): void;
+}
+
+declare namespace GlowOverlayFilter {
+  interface Any extends AnyGlowOverlayFilter {}
+  interface AnyConstructor extends Identity<typeof AnyGlowOverlayFilter> {}
+}
+
+export default GlowOverlayFilter;
+
+declare abstract class AnyGlowOverlayFilter extends GlowOverlayFilter {
+  constructor(...args: never);
+}

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

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

package/src/foundry/client/canvas/rendering/filters/outline-overlay.d.mts

@@ -0,0 +1,87 @@
+import type { FixedInstanceType, Identity } from "#utils";
+import type { AbstractBaseFilter } from "./_module.d.mts";
+import type { AbstractBaseShader } from "../shaders/_module.mjs";
+
+/**
+ * A filter which implements an outline.
+ * Inspired from https://github.com/pixijs/filters/tree/main/filters/outline
+ * @remarks MIT License
+ */
+declare 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.
+   * @defaultValue `3`
+   */
+  get thickness(): number;
+
+  set thickness(value);
+
+  static override create<ThisType extends AbstractBaseFilter.AnyConstructor>(
+    this: ThisType,
+    initialUniforms?: AbstractBaseShader.Uniforms,
+  ): FixedInstanceType<ThisType>;
+
+  override apply(
+    filterManager: PIXI.FilterSystem,
+    input: PIXI.RenderTexture,
+    output: PIXI.RenderTexture,
+    clear?: PIXI.CLEAR_MODES,
+  ): void;
+
+  /**
+   * @deprecated "`OutlineOverlayFilter#animate` is deprecated in favor of {@link OutlineOverlayFilter.animated | `OutlineOverlayFilter#animated`}." (since v12, until v14)
+   */
+  get animate(): boolean;
+
+  set animate(v);
+
+  #OutlineOverlayFilter: true;
+}
+
+declare namespace OutlineOverlayFilter {
+  interface Any extends AnyOutlineOverlayFilter {}
+  interface AnyConstructor extends Identity<typeof AnyOutlineOverlayFilter> {}
+}
+
+export default OutlineOverlayFilter;
+
+declare abstract class AnyOutlineOverlayFilter extends OutlineOverlayFilter {
+  constructor(...args: never);
+}

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

@@ -0,0 +1,13 @@
+import type { SMAAFilter } from "../_module.mjs";
+/* eslint-disable @typescript-eslint/no-unused-vars */
+
+// After seeing that none of these types add anything or are even exported a
+// very reasonable question may be: Why on earth does this file exist?
+//
+// Well this is the file in which Foundry defines these types. We don't house
+// them here because it has poor discoverability. It's also just nice to
+// have as reference to keep us synced with the latest version of Foundry.
+
+export {};
+
+type SMAAFilterConfig = SMAAFilter.Config;

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

@@ -0,0 +1,19 @@
+import type { Identity } from "#utils";
+
+/**
+ * The neighborhood blending filter for {@linkcode foundry.canvas.rendering.filters.SMAAFilter}.
+ */
+declare class SMAANeighborhoodBlendingFilter extends PIXI.Filter {
+  constructor();
+}
+
+declare namespace SMAANeighborhoodBlendingFilter {
+  interface Any extends AnySMAANeighborhoodBlendingFilter {}
+  interface AnyConstructor extends Identity<typeof AnySMAANeighborhoodBlendingFilter> {}
+}
+
+export default SMAANeighborhoodBlendingFilter;
+
+declare abstract class AnySMAANeighborhoodBlendingFilter extends SMAANeighborhoodBlendingFilter {
+  constructor(...args: never);
+}