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

package/src/foundry/client/pixi/webgl/helpers/texture-extractor.d.mts

@@ -1,65 +1,16 @@
-import type { InexactPartial } from "../../../../../types/utils.d.mts";
-
-declare abstract class AnyTextureExtractor extends TextureExtractor {
-  constructor(arg0: never, ...args: never[]);
-}
+import type { Brand, InexactPartial } from "fvtt-types/utils";
 
 declare global {
-  namespace TextureExtractor {
-    type AnyConstructor = typeof AnyTextureExtractor;
-
-    interface ConstructorOptions {
-      /** @defaultValue `"TextureExtractor"` */
-      callerName: string;
-
-      controlHash: boolean;
-
-      /** @defaultValue `PIXI.FORMATS.RED` */
-      format: PIXI.FORMATS;
-    }
-
-    interface TextureExtractionOptions {
-      /**
-       * The texture the pixels are extracted from.
-       * Otherwise, extract from the renderer.
-       */
-      texture: PIXI.Texture | PIXI.RenderTexture | null;
-
-      /** The rectangle which the pixels are extracted from. */
-      frame: PIXI.Rectangle;
-
-      /** The compression mode to apply, or NONE */
-      compression: TextureExtractor.COMPRESSION_MODES;
-
-      /** The optional image mime type. */
-      type: string;
-
-      /** The optional image quality. */
-      quality: string;
-
-      /** The optional debug flag to use. */
-      debug: boolean;
-    }
-
-    interface COMPRESSION_MODES {
-      readonly NONE: 0;
-      readonly BASE64: 1;
-    }
-  }
-
   /**
    * A class or interface that provide support for WebGL async read pixel/texture data extraction.
    */
   class TextureExtractor {
-    constructor(
-      renderer: PIXI.Renderer,
-      { callerName, controlHash, format }?: InexactPartial<TextureExtractor.ConstructorOptions>,
-    );
+    constructor(renderer: PIXI.Renderer, options?: TextureExtractor.ConstructorOptions);
 
     /**
      * List of compression that could be applied with extraction
      */
-    static COMPRESSION_MODES: TextureExtractor.COMPRESSION_MODES;
+    static COMPRESSION_MODES: TextureExtractor.CompressionModes;
 
     /**
      * Debug flag.
@@ -75,7 +26,7 @@ declare global {
      * Extract a rectangular block of pixels from the texture (without un-pre-multiplying).
      * @param options - Options which configure extraction behavior
      */
-    extract(options: InexactPartial<TextureExtractor.TextureExtractionOptions>): ReturnType<Semaphore["add"]>;
+    extract(options?: TextureExtractor.TextureExtractionOptions): Promise<string | Uint8ClampedArray>;
 
     /**
      * Free all the bound objects.
@@ -87,4 +38,82 @@ declare global {
      */
     contextChange(): void;
   }
+
+  namespace TextureExtractor {
+    type Any = AnyTextureExtractor;
+    type AnyConstructor = typeof AnyTextureExtractor;
+
+    /** @internal */
+    type _ConstructorOptions = InexactPartial<{
+      /**
+       * The caller name associated with this instance of texture extractor (optional, used for debug)
+       * @defaultValue `"TextureExtractor"`
+       * @remarks Default provided by ?? in function body
+       */
+      callerName: string | null;
+
+      /**
+       * Does the TextureCompressor neeed to control the hash?
+       * @remarks Passed to `new TextureCompressor()`, where it is provided a default of `false` if null
+       */
+      controlHash: boolean | null;
+
+      /**
+       * The PIXI Format this TextureExtractor uses
+       * @defaultValue `PIXI.FORMATS.RED`
+       * @remarks Construction throws if this isn't `.RED` or `.RGBA`, so can't be null
+       */
+      format: PIXI.FORMATS;
+    }>;
+
+    /** Options for the constructor of {@link TextureExtractor} */
+    interface ConstructorOptions extends _ConstructorOptions {}
+
+    /** @internal */
+    type _ExtractOptions = InexactPartial<{
+      /**
+       * The texture the pixels are extracted from.
+       * Otherwise, extract from the renderer.
+       * @remarks Can't be null despite Foundry's typedef claiming it can, as eventually `texture?.baseTexture.resolution` is accessed
+       */
+      texture: PIXI.Texture | PIXI.RenderTexture;
+
+      /** The rectangle which the pixels are extracted from. */
+      frame: PIXI.Rectangle;
+
+      /** The compression mode to apply, or NONE */
+      compression: TextureExtractor.COMPRESSION_MODES;
+
+      /**
+       * The optional image mime type.
+       * @privateRemarks Allowed to be null because it has an `??` default in `TextureExtractor##compressBufferWorker`
+       * via `##compressBuffer`, the only place it is actually used, despite being passed to other functions as well
+       */
+      type: string | null;
+
+      /**
+       * The optional image quality.
+       *  @privateRemarks Foundry types as `string` but is clearly meant to be `number` by usage. Allowing null due to
+       * it having a `??` default in the path any browser someone is realistically using for Foundry will take.
+       */
+      quality: number | null;
+
+      /** The optional debug flag to use. */
+      debug: boolean | null;
+    }>;
+
+    /** Options for {@link TextureExtractor#extract} */
+    interface TextureExtractionOptions extends _ExtractOptions {}
+
+    type COMPRESSION_MODES = Brand<number, "TextureExtractor.COMPRESSION_MODES">;
+
+    interface CompressionModes {
+      NONE: 0 & COMPRESSION_MODES;
+      BASE64: 1 & COMPRESSION_MODES;
+    }
+  }
+}
+
+declare abstract class AnyTextureExtractor extends TextureExtractor {
+  constructor(arg0: never, ...args: never[]);
 }

package/src/foundry/client/pixi/webgl/shaders/base-shader-mixin.d.mts

@@ -1,8 +1,4 @@
-import type { Mixin } from "../../../../../types/utils.d.mts";
-
-declare abstract class AnyBaseShader extends BaseShader {
-  constructor(arg0: never, ...args: never[]);
-}
+import type { FixedInstanceType, Mixin } from "fvtt-types/utils";
 
 declare class BaseShader {
   /** @privateRemarks All mixin classses should accept anything for its constructor. */
@@ -109,11 +105,15 @@ declare class BaseShader {
 }
 
 declare global {
-  namespace BaseShader {
-    type AnyConstructor = typeof AnyBaseShader;
-  }
-
-  function BaseShaderMixin<BaseClass extends PIXI.Shader.AnyConstructor | PIXI.Filter.AnyConstructor>(
+  function BaseShaderMixin<BaseClass extends BaseShaderMixin.BaseClass>(
     ShaderClass: BaseClass,
   ): Mixin<typeof BaseShader, BaseClass>;
+
+  namespace BaseShaderMixin {
+    /** @privateRemarks Can't extend `AnyMixedConstructor` if it's using the `BaseClass` union; `PIXI.Shader` is the parent of `Filter`, so it's used instead */
+    type AnyMixedConstructor = ReturnType<typeof BaseShaderMixin<PIXI.Shader.AnyConstructor>>;
+    interface AnyMixed extends FixedInstanceType<AnyMixedConstructor> {}
+
+    type BaseClass = PIXI.Shader.AnyConstructor | PIXI.Filter.AnyConstructor;
+  }
 }

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

@@ -1,35 +1,19 @@
-import type { ToMethod } from "../../../../../types/helperTypes.d.mts";
-
-declare abstract class AnyAbstractBaseShader extends AbstractBaseShader {
-  constructor(arg0: never, ...args: never[]);
-}
+import type { FixedInstanceType, ToMethod } from "fvtt-types/utils";
 
 declare global {
-  namespace AbstractBaseShader {
-    type AnyConstructor = typeof AnyAbstractBaseShader;
-
-    type Coordinates =
-      | { x: number; y: number }
-      | { x: number; y: number; z: number }
-      | { x: number; y: number; z: number; w: number };
-
-    type UniformValue = boolean | number | Int32List | Float32List | Coordinates | Coordinates[] | PIXI.Texture;
-
-    // eslint-disable-next-line @typescript-eslint/consistent-type-definitions
-    type Uniforms = {
-      readonly [K: string]: AbstractBaseShader.UniformValue;
-    };
-
-    type FragmentShaderFunction = ToMethod<(arg0: never) => string>;
-
-    type PreRenderFunction = ToMethod<(mesh: PIXI.DisplayObject, renderer: PIXI.Renderer) => void>;
-  }
-
   /**
    * This class defines an interface which all shaders utilize
    */
   abstract class AbstractBaseShader extends BaseShaderMixin(PIXI.Shader) {
-    constructor(program: PIXI.Program, uniforms: AbstractBaseShader.Uniforms);
+    /**
+     * @param program  - The program to use with this shader.
+     * @param uniforms - The current uniforms of the Shader
+     */
+    constructor(
+      program: PIXI.Program,
+      /** @defaultValue `{}` */
+      uniforms?: AbstractBaseShader.Uniforms,
+    );
 
     /**
      * The raw vertex shader used by this class.
@@ -63,8 +47,8 @@ declare global {
      */
     static create<ThisType extends AbstractBaseShader.AnyConstructor>(
       this: ThisType,
-      initialUniforms: AbstractBaseShader.Uniforms,
-    ): InstanceType<ThisType>;
+      initialUniforms?: AbstractBaseShader.Uniforms,
+    ): FixedInstanceType<ThisType>;
 
     /**
      * Reset the shader uniforms back to their initial values.
@@ -81,6 +65,7 @@ declare global {
      * Perform operations which are required before binding the Shader to the Renderer.
      * @param mesh - The mesh display object linked to this shader.
      * @param renderer - The renderer
+     * @privateRemarks Foundry marks this as protected despite it getting called from `QuadMesh#_render`
      */
     protected _preRender: AbstractBaseShader.PreRenderFunction;
 
@@ -91,4 +76,36 @@ declare global {
      */
     protected get _defaults(): AbstractBaseShader.Uniforms;
   }
+
+  namespace AbstractBaseShader {
+    type AnyConstructor = typeof AnyAbstractBaseShader;
+
+    type Coordinates = { x: number; y: number; z?: number } | { x: number; y: number; z: number; w?: number };
+
+    type UniformValue =
+      | boolean
+      | number
+      | null
+      | Int32List
+      | Float32List
+      | Coordinates
+      | Coordinates[]
+      | Color.RGBColorVector
+      | Color.RGBAColorVector
+      | PIXI.Texture
+      | PIXI.Matrix;
+
+    // eslint-disable-next-line @typescript-eslint/consistent-type-definitions
+    type Uniforms = {
+      readonly [K: string]: AbstractBaseShader.UniformValue;
+    };
+
+    type FragmentShaderFunction = ToMethod<(arg0: never) => string>;
+
+    type PreRenderFunction = ToMethod<(mesh: PIXI.DisplayObject, renderer: PIXI.Renderer) => void>;
+  }
+}
+
+declare abstract class AnyAbstractBaseShader extends AbstractBaseShader {
+  constructor(arg0: never, ...args: never[]);
 }

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

@@ -1,14 +1,6 @@
-export {};
-
-declare abstract class AnyAbstractBaseFilter extends AbstractBaseFilter {
-  constructor(arg0: never, ...args: never[]);
-}
+import type { FixedInstanceType } from "fvtt-types/utils";
 
 declare global {
-  namespace AbstractBaseFilter {
-    type AnyConstructor = typeof AnyAbstractBaseFilter;
-  }
-
   /**
    * An abstract filter which provides a framework for reusable definition
    */
@@ -42,6 +34,15 @@ declare global {
        * @defaultValue `{}`
        */
       initialUniforms?: AbstractBaseShader.Uniforms,
-    ): InstanceType<ThisType>;
+    ): FixedInstanceType<ThisType>;
   }
+
+  namespace AbstractBaseFilter {
+    interface Any extends AnyAbstractBaseFilter {}
+    type AnyConstructor = typeof AnyAbstractBaseFilter;
+  }
+}
+
+declare abstract class AnyAbstractBaseFilter extends AbstractBaseFilter {
+  constructor(arg0: never, ...args: never[]);
 }

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

@@ -1,14 +1,6 @@
 export {};
 
-declare abstract class AnyAbstractBaseMaskFilter extends AbstractBaseMaskFilter {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace AbstractBaseMaskFilter {
-    type AnyConstructor = typeof AnyAbstractBaseMaskFilter;
-  }
-
   /**
    * This class defines an interface for masked custom filters
    */
@@ -18,12 +10,22 @@ declare global {
      */
     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,
+      currentState?: PIXI.FilterState,
     ): void;
   }
+
+  namespace AbstractBaseMaskFilter {
+    interface Any extends AnyAbstractBaseMaskFilter {}
+    type AnyConstructor = typeof AnyAbstractBaseMaskFilter;
+  }
+}
+
+declare abstract class AnyAbstractBaseMaskFilter extends AbstractBaseMaskFilter {
+  constructor(arg0: never, ...args: never[]);
 }

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

@@ -1,22 +1,6 @@
 export {};
 
-declare abstract class AnyAlphaBlurFilterPass extends AlphaBlurFilterPass {
-  constructor(arg0: never, ...args: never[]);
-}
-
-declare abstract class AnyAlphaBlurFilter extends AlphaBlurFilter {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace AlphaBlurFilterPass {
-    type AnyConstructor = typeof AnyAlphaBlurFilterPass;
-  }
-
-  namespace AlphaBlurFilter {
-    type AnyConstructor = typeof AnyAlphaBlurFilter;
-  }
-
   /**
    * Apply a vertical or horizontal gaussian blur going inward by using alpha as the penetrating channel.
    */
@@ -106,6 +90,11 @@ declare global {
     ): void;
   }
 
+  namespace AlphaBlurFilterPass {
+    interface Any extends AnyAlphaBlurFilterPass {}
+    type AnyConstructor = typeof AnyAlphaBlurFilterPass;
+  }
+
   /**
    * Apply a gaussian blur going inward by using alpha as the penetrating channel.
    */
@@ -122,9 +111,9 @@ declare global {
      */
     constructor(strength?: number, quality?: number, resolution?: number, kernelSize?: number);
 
-    blurXFilter: typeof AlphaBlurFilterPass;
+    blurXFilter: AlphaBlurFilterPass;
 
-    blurYFilter: typeof AlphaBlurFilterPass;
+    blurYFilter: AlphaBlurFilterPass;
 
     _repeatEdgePixels: boolean;
 
@@ -178,8 +167,21 @@ declare global {
     /**
      * Provided for completeness with PIXI.BlurFilter
      */
-    get blendMode(): number;
+    get blendMode(): PIXI.BLEND_MODES;
 
     set blendMode(value);
   }
+
+  namespace AlphaBlurFilter {
+    interface Any extends AnyAlphaBlurFilter {}
+    type AnyConstructor = typeof AnyAlphaBlurFilter;
+  }
+}
+
+declare abstract class AnyAlphaBlurFilterPass extends AlphaBlurFilterPass {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare abstract class AnyAlphaBlurFilter extends AlphaBlurFilter {
+  constructor(arg0: never, ...args: never[]);
 }

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

@@ -1,32 +1,6 @@
-import type { AnyObject, ShapeWithIndexSignature } from "../../../../../../types/utils.d.mts";
-
-declare abstract class AnyVisualEffectsMaskingFilter extends VisualEffectsMaskingFilter {
-  constructor(arg0: never, ...args: never[]);
-}
+import type { AnyObject, Brand, FixedInstanceType, ShapeWithIndexSignature } from "fvtt-types/utils";
 
 declare global {
-  namespace VisualEffectsMaskingFilter {
-    type AnyConstructor = typeof AnyVisualEffectsMaskingFilter;
-
-    type PostProcessModes = Array<keyof VisualEffectsMaskingFilter.POST_PROCESS_TECHNIQUES>;
-
-    interface ConcreteCreateOptions {
-      postProcessModes?: PostProcessModes | undefined;
-    }
-
-    interface FILTER_MODES {
-      readonly BACKGROUND: 0;
-      readonly ILLUMINATION: 1;
-      readonly COLORATION: 2;
-    }
-
-    interface POST_PROCESS_TECHNIQUES {
-      EXPOSURE: { id: string; glsl: string };
-      CONTRAST: { id: string; glsl: string };
-      SATURATION: { id: string; glsl: string };
-    }
-  }
-
   /**
    * This filter handles masking and post-processing for visual effects.
    */
@@ -42,12 +16,17 @@ declare global {
         string,
         AbstractBaseShader.UniformValue
       >,
-    ): InstanceType<ThisType>;
+    ): FixedInstanceType<ThisType>;
 
     /**
      * Masking modes.
+     * @remarks Object is frozen
      */
-    static readonly FILTER_MODES: VisualEffectsMaskingFilter.FILTER_MODES;
+    static FILTER_MODES: {
+      readonly BACKGROUND: 0 & VisualEffectsMaskingFilter.FILTER_MODES;
+      readonly ILLUMINATION: 1 & VisualEffectsMaskingFilter.FILTER_MODES;
+      readonly COLORATION: 2 & VisualEffectsMaskingFilter.FILTER_MODES;
+    };
 
     /**
      * @defaultValue
@@ -90,14 +69,17 @@ declare global {
       input: PIXI.RenderTexture,
       output: PIXI.RenderTexture,
       clear: PIXI.CLEAR_MODES,
-      currentState: PIXI.FilterState,
+      currentState?: PIXI.FilterState,
     ): void;
 
     /**
      * Filter post-process techniques.
      */
-    static POST_PROCESS_TECHNIQUES: VisualEffectsMaskingFilter.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
      */
@@ -118,4 +100,23 @@ declare global {
      */
     static override fragmentShader(postProcessModes?: VisualEffectsMaskingFilter.PostProcessModes): string;
   }
+
+  namespace VisualEffectsMaskingFilter {
+    interface Any extends AnyVisualEffectsMaskingFilter {}
+    type AnyConstructor = typeof AnyVisualEffectsMaskingFilter;
+
+    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(arg0: never, ...args: never[]);
 }

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

@@ -1,14 +1,6 @@
 export {};
 
-declare abstract class AnyPrimaryCanvasGroupAmbienceFilter extends PrimaryCanvasGroupAmbienceFilter {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace PrimaryCanvasGroupAmbienceFilter {
-    type AnyConstructor = typeof AnyPrimaryCanvasGroupAmbienceFilter;
-  }
-
   /**
    * A filter used to apply color adjustments and other modifications to the environment.
    */
@@ -37,4 +29,13 @@ declare global {
      */
     static override defaultUniforms: AbstractBaseShader.Uniforms;
   }
+
+  namespace PrimaryCanvasGroupAmbienceFilter {
+    interface Any extends AnyPrimaryCanvasGroupAmbienceFilter {}
+    type AnyConstructor = typeof AnyPrimaryCanvasGroupAmbienceFilter;
+  }
+}
+
+declare abstract class AnyPrimaryCanvasGroupAmbienceFilter extends PrimaryCanvasGroupAmbienceFilter {
+  constructor(arg0: never, ...args: never[]);
 }

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

@@ -1,14 +1,6 @@
-export {};
-
-declare abstract class AnyGlowOverlayFilter extends GlowOverlayFilter {
-  constructor(arg0: never, ...args: never[]);
-}
+import type { FixedInstanceType } from "fvtt-types/utils";
 
 declare global {
-  namespace GlowOverlayFilter {
-    type AnyConstructor = typeof AnyGlowOverlayFilter;
-  }
-
   /**
    * A filter which implements an inner or outer glow around the source texture.
    * Inspired from https://github.com/pixijs/filters/tree/main/filters/glow
@@ -63,7 +55,7 @@ declare global {
     static override create<ThisType extends AbstractBaseFilter.AnyConstructor>(
       this: ThisType,
       initialUniforms?: AbstractBaseShader.Uniforms,
-    ): InstanceType<ThisType>;
+    ): FixedInstanceType<ThisType>;
 
     override apply(
       filterManager: PIXI.FilterSystem,
@@ -72,4 +64,13 @@ declare global {
       clear: PIXI.CLEAR_MODES,
     ): void;
   }
+
+  namespace GlowOverlayFilter {
+    interface Any extends AnyGlowOverlayFilter {}
+    type AnyConstructor = typeof AnyGlowOverlayFilter;
+  }
+}
+
+declare abstract class AnyGlowOverlayFilter extends GlowOverlayFilter {
+  constructor(arg0: never, ...args: never[]);
 }

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

@@ -1,14 +1,6 @@
 export {};
 
-declare abstract class AnyInvisibilityFilter extends InvisibilityFilter {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace InvisibilityFilter {
-    type AnyConstructor = typeof AnyInvisibilityFilter;
-  }
-
   /**
    * Invisibility effect filter for placeables.
    */
@@ -26,4 +18,13 @@ declare global {
      */
     static override defaultUniforms: AbstractBaseShader.Uniforms;
   }
+
+  namespace InvisibilityFilter {
+    interface Any extends AnyInvisibilityFilter {}
+    type AnyConstructor = typeof AnyInvisibilityFilter;
+  }
+}
+
+declare abstract class AnyInvisibilityFilter extends InvisibilityFilter {
+  constructor(arg0: never, ...args: never[]);
 }

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

@@ -1,14 +1,6 @@
-export {};
-
-declare abstract class AnyOutlineOverlayFilter extends OutlineOverlayFilter {
-  constructor(arg0: never, ...args: never[]);
-}
+import type { FixedInstanceType } from "fvtt-types/utils";
 
 declare global {
-  namespace OutlineOverlayFilter {
-    type AnyConstructor = typeof AnyOutlineOverlayFilter;
-  }
-
   /**
    * A filter which implements an outline.
    * Inspired from https://github.com/pixijs/filters/tree/main/filters/outline
@@ -62,7 +54,7 @@ declare global {
     static override create<ThisType extends AbstractBaseFilter.AnyConstructor>(
       this: ThisType,
       initialUniforms?: AbstractBaseShader.Uniforms,
-    ): InstanceType<ThisType>;
+    ): FixedInstanceType<ThisType>;
 
     override apply(
       filterManager: PIXI.FilterSystem,
@@ -83,4 +75,13 @@ declare global {
      */
     set animate(v);
   }
+
+  namespace OutlineOverlayFilter {
+    interface Any extends AnyOutlineOverlayFilter {}
+    type AnyConstructor = typeof AnyOutlineOverlayFilter;
+  }
+}
+
+declare abstract class AnyOutlineOverlayFilter extends OutlineOverlayFilter {
+  constructor(arg0: never, ...args: never[]);
 }