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

package/src/foundry/client/pixi/perception/perception-manager.d.mts

@@ -1,167 +1,167 @@
-export {};
+import type { InterfaceToObject, NullishProps } from "#utils";
 
 declare global {
-  interface PerceptionManagerFlags {
-    /**
-     * Re-initialize the entire lighting configuration. An aggregate behavior
-     * which does no work directly but propagates to set several other flags.
-     */
-    initializeLighting: boolean;
-
-    /** Re-initialize the entire vision configuration. See {@link CanvasVisibility#initializeSources}. */
-    initializeVision: boolean;
-
-    /** Re-initialize the entire vision modes. See {@link CanvasVisibility#initializeVisionMode}. */
-    initializeVisionModes: boolean;
-
-    /** Re-initialize the entire ambient sound configuration. See {@link SoundsLayer#initializeSources}. */
-    initializeSounds: boolean;
-
-    /** Recompute intersections between all registered edges. See {@link CanvasEdges#refresh}. */
-    refreshEdges: boolean;
-
-    /** Refresh the rendered appearance of lighting */
-    refreshLighting: boolean;
-
-    /** Update the configuration of light sources */
-    refreshLightSources: boolean;
-
-    /** Refresh occlusion */
-    refreshOcclusion: boolean;
-
-    /** Refresh the contents of the PrimaryCanvasGroup mesh */
-    refreshPrimary: boolean;
-
-    /** Refresh the audio state of ambient sounds */
-    refreshSounds: boolean;
-
-    /** Refresh the rendered appearance of vision */
-    refreshVision: boolean;
-
-    /** Update the configuration of vision sources */
-    refreshVisionSources: boolean;
-
-    /** Apply a fade duration to sound refresh workflow */
-    soundFadeDuration: boolean;
-  }
+  /**
+   * @deprecated {@link PerceptionManager.RenderFlags | `PerceptionManager.RenderFlags`}
+   */
+  type PerceptionManagerFlags = PerceptionManager.RenderFlags;
 
   /**
    * A helper class which manages the refresh workflow for perception layers on the canvas.
    * This controls the logic which batches multiple requested updates to minimize the amount of work required.
-   * A singleton instance is available as {@link Canvas#perception}.
+   * A singleton instance is available as {@link Canvas.perception | `Canvas#perception`}.
    */
   class PerceptionManager extends RenderFlagsMixin(Object) {
-    static RENDER_FLAGS: {
-      /** @defaultValue `{}` */
-      refreshEdges: RenderFlag<PerceptionManagerFlags>;
-
-      /** @defaultValue `{propagate: ["refreshLighting", "refreshVision"]}` */
-      initializeLighting: RenderFlag<PerceptionManagerFlags>;
-
-      /** @defaultValue `{propagate: ["refreshLighting", "refreshVision", "refreshEdges"]}` */
-      initializeDarknessSources: RenderFlag<PerceptionManagerFlags>;
-
-      /** @defaultValue `{propagate: ["refreshLighting", "refreshVision"]}` */
-      initializeLightSources: RenderFlag<PerceptionManagerFlags>;
-
-      /** @defaultValue `{propagate: ["refreshLightSources"]}` */
-      refreshLighting: RenderFlag<PerceptionManagerFlags>;
-
-      /** @defaultValue `{}` */
-      refreshLightSources: RenderFlag<PerceptionManagerFlags>;
-
-      /** @defaultValue `{propagate: ["refreshVisionSources", "refreshLighting", "refreshPrimary"]}` */
-      initializeVisionModes: RenderFlag<PerceptionManagerFlags>;
-
-      /** @defaultValue `{propagate: ["refreshVision", "refreshTiles", "refreshLighting", "refreshLightSources", "refreshPrimary"]}` */
-      initializeVision: RenderFlag<PerceptionManagerFlags>;
-
-      /** @defaultValue `{propagate: ["refreshVisionSources", "refreshOcclusionMask"]}` */
-      refreshVision: RenderFlag<PerceptionManagerFlags>;
-
-      /** @defaultValue `{}` */
-      refreshVisionSources: RenderFlag<PerceptionManagerFlags>;
-
-      /** @defaultValue `{}` */
-      refreshPrimary: RenderFlag<PerceptionManagerFlags>;
-
-      /** `{propagate: ["refreshOcclusionStates", "refreshOcclusionMask"]}` */
-      refreshOcclusion: RenderFlag<PerceptionManagerFlags>;
-
-      /** @defaultValue `{}` */
-      refreshOcclusionStates: RenderFlag<PerceptionManagerFlags>;
-
-      /** @defaultValue `{}` */
-      refreshOcclusionMask: RenderFlag<PerceptionManagerFlags>;
-
-      /** @defaultValue `{ propagate: ["refreshSounds"] }` */
-      initializeSounds: RenderFlag<PerceptionManagerFlags>;
-
-      /** @defaultValue `{}` */
-      refreshSounds: RenderFlag<PerceptionManagerFlags>;
-
-      /** @defaultValue `{}` */
-      soundFadeDuration: RenderFlag<PerceptionManagerFlags>;
-
-      /** @deprecated since v12, will be removed in v14 */
-      refreshTiles: RenderFlag<PerceptionManagerFlags>;
-
-      /** @deprecated since v12, will be removed in v14 */
-      identifyInteriorWalls: RenderFlag<PerceptionManagerFlags>;
-
-      /** @deprecated since v12, will be removed in v14 */
-      forceUpdateFog: RenderFlag<PerceptionManagerFlags>;
-    };
+    static RENDER_FLAGS: InterfaceToObject<PerceptionManager.RENDER_FLAGS>;
 
     static RENDER_FLAG_PRIORITY: "PERCEPTION";
 
+    // Note: This isn't a "real" override but `renderFlags` is set corresponding to the
+    // `RENDER_FLAGS` and so it has to be adjusted here.
+    renderFlags: RenderFlags<PerceptionManager.RENDER_FLAGS>;
+
     applyRenderFlags(): void;
 
     /**
      * Update perception manager flags which configure which behaviors occur on the next frame render.
      * @param flags - Flag values (true) to assign where the keys belong to PerceptionManager.FLAGS
      */
-    update(flags: Partial<PerceptionManagerFlags>): void;
+    update(flags: PerceptionManager.PassableFlags): void;
 
     /**
      * A helper function to perform an immediate initialization plus incremental refresh.
      */
-    initialize(): ReturnType<this["update"]>;
+    initialize(): void;
 
     /**
      * @deprecated since v12, will be removed in v14
-     * @remarks `"PerceptionManager#refresh is deprecated in favor of assigning granular "refresh flags"`
-     */
-    refresh(): ReturnType<this["update"]>;
-
-    /**
-     * @deprecated since v11, will be removed in v13
-     * @remarks forceUpdateFog flag is now obsolete and has no replacement. The fog is now always updated when the visibility is refreshed
+     * @remarks "PerceptionManager#refresh is deprecated in favor of assigning granular \"refresh flags\""
      */
-    static forceUpdateFog(): void;
+    refresh(): void;
   }
 
   namespace PerceptionManager {
-    /** @deprecated Old flag structure */
-    interface Options {
-      lighting: {
-        initialize: boolean;
-        refresh: boolean;
-      };
-      sight: {
-        initialize: boolean;
-        refresh: boolean;
-        skipUpdateFog: boolean;
-        forceUpdateFog: boolean;
-      };
-      sounds: {
-        initialize: boolean;
-        refresh: boolean;
-        fade: boolean;
-      };
-      foreground: {
-        refresh: boolean;
-      };
+    interface Any extends AnyPerceptionManager {}
+    type AnyConstructor = typeof AnyPerceptionManager;
+
+    type PassableFlags = NullishProps<RenderFlags>;
+
+    type RenderFlags = RenderFlagsMixin.ToBooleanFlags<RENDER_FLAGS>;
+
+    interface RENDER_FLAGS {
+      /**
+       * Recompute intersections between all registered edges. See {@link CanvasEdges#refresh}.
+       * @defaultValue `{}`
+       */
+      refreshEdges: RenderFlag<this, "refreshEdges">;
+
+      /**
+       * Re-initialize the entire lighting configuration. An aggregate behavior
+       * which does no work directly but propagates to set several other flags.
+       * @defaultValue `{ propagate: ["initializeDarknessSources", "initializeLightSources"] }`
+       */
+      initializeLighting: RenderFlag<this, "initializeLighting">;
+
+      /** @defaultValue `{ propagate: ["refreshLighting", "refreshVision", "refreshEdges"] }` */
+      initializeDarknessSources: RenderFlag<this, "initializeDarknessSources">;
+
+      /** @defaultValue `{ propagate: ["refreshLighting", "refreshVision"] }` */
+      initializeLightSources: RenderFlag<this, "initializeLightSources">;
+
+      /**
+       * Refresh the rendered appearance of lighting
+       * @defaultValue `{ propagate: ["refreshLightSources"] }`
+       */
+      refreshLighting: RenderFlag<this, "refreshLighting">;
+
+      /**
+       * Update the configuration of light sources
+       * @defaultValue `{}`
+       */
+      refreshLightSources: RenderFlag<this, "refreshLightSources">;
+
+      /**
+       * Re-initialize the entire vision modes. See {@link CanvasVisibility#initializeVisionMode}.
+       * @defaultValue `{ propagate: ["refreshVisionSources", "refreshLighting", "refreshPrimary"] }`
+       */
+      initializeVisionModes: RenderFlag<this, "initializeVisionModes">;
+
+      /**
+       * Re-initialize the entire vision configuration. See {@link CanvasVisibility#initializeSources}.
+       * @defaultValue `{ propagate: ["initializeVisionModes", "refreshVision"] }`
+       */
+      initializeVision: RenderFlag<this, "initializeVision">;
+
+      /**
+       * Refresh the rendered appearance of vision
+       * @defaultValue `{ propagate: ["refreshVisionSources", "refreshOcclusionMask"] }`
+       */
+      refreshVision: RenderFlag<this, "refreshVision">;
+
+      /**
+       * Update the configuration of vision sources
+       * @defaultValue `{}`
+       */
+      refreshVisionSources: RenderFlag<this, "refreshVisionSources">;
+
+      /**
+       * Refresh the contents of the PrimaryCanvasGroup mesh
+       * @defaultValue `{}`
+       */
+      refreshPrimary: RenderFlag<this, "refreshPrimary">;
+
+      /**
+       * Refresh occlusion
+       * @defaultValue `{propagate: ["refreshOcclusionStates", "refreshOcclusionMask"] }`
+       */
+      refreshOcclusion: RenderFlag<this, "refreshOcclusion">;
+
+      /** @defaultValue `{}` */
+      refreshOcclusionStates: RenderFlag<this, "refreshOcclusionStates">;
+
+      /** @defaultValue `{}` */
+      refreshOcclusionMask: RenderFlag<this, "refreshOcclusionMask">;
+
+      /**
+       * Re-initialize the entire ambient sound configuration. See {@link SoundsLayer#initializeSources}.
+       * @defaultValue `{ propagate: ["refreshSounds"] }`
+       */
+      initializeSounds: RenderFlag<this, "initializeSounds">;
+
+      /**
+       * Refresh the audio state of ambient sounds
+       * @defaultValue `{}`
+       */
+      refreshSounds: RenderFlag<this, "refreshSounds">;
+
+      /**
+       * Apply a fade duration to sound refresh workflow
+       * @defaultValue `{}`
+       */
+      soundFadeDuration: RenderFlag<this, "soundFadeDuration">;
+
+      /**
+       * @defaultValue `{ propagate: ["refreshOcclusion"] }`
+       * @deprecated since v12, will be removed in v14
+       */
+      refreshTiles: RenderFlag<this, "refreshTiles">;
+
+      /**
+       * @defaultValue `{ propagate: ["initializeLighting", "initializeVision"] }`
+       * @deprecated since v12, will be removed in v14
+       */
+      identifyInteriorWalls: RenderFlag<this, "identifyInteriorWalls">;
+
+      /**
+       * @defaultValue `{ propagate: ["refreshVision"] }`
+       * @deprecated since v11, will be removed in v13
+       * @remarks In v12 the flag remains, but the static method it would have triggered was removed prematurely (was listed as until v13 in v11)
+       */
+      forceUpdateFog: RenderFlag<this, "forceUpdateFog">;
     }
   }
 }
+
+declare abstract class AnyPerceptionManager extends PerceptionManager {
+  constructor(...args: never);
+}

package/src/foundry/client/pixi/perception/vision-mode.d.mts

@@ -1,5 +1,9 @@
-import type { AnyObject, InexactPartial, SimpleMerge, ValueOf } from "../../../../types/utils.d.mts";
+import type { Brand, InterfaceToObject, RemoveIndexSignatures, SimpleMerge } from "#utils";
 import type { fields } from "../../../common/data/module.d.mts";
+import type { DataSchema } from "../../../common/data/fields.d.mts";
+import DataField = foundry.data.fields.DataField;
+import type DataModel from "../../../common/abstract/data.d.mts";
+import type PointVisionSource from "../../../client-esm/canvas/sources/point-vision-source.d.mts";
 
 declare global {
   class ShaderField<
@@ -21,25 +25,60 @@ declare global {
 
     // TODO: _cast blatantly breaks inheritance so this is difficult to work with
     /** @remarks The value provided to a ShaderField must be an AbstractBaseShader subclass. */
-    override _cast(value: any): Exclude<InitializedType, undefined | null>; // typeof AbstractBaseShader;
+    override _cast(value: any): NonNullable<InitializedType>; // typeof AbstractBaseShader;
+  }
+
+  namespace ShaderField {
+    type Options = DataField.Options<typeof AbstractBaseShader>;
+
+    type DefaultOptions = SimpleMerge<
+      DataField.DefaultOptions,
+      {
+        nullable: true;
+        initial: undefined;
+      }
+    >;
+
+    /**
+     * A helper type for the given options type merged into the default options of the BooleanField class.
+     * @typeParam Opts - the options that override the default options
+     */
+    type MergedOptions<Opts extends Options> = SimpleMerge<DefaultOptions, Opts>;
+
+    /**
+     * A shorthand for the assignment type of a BooleanField class.
+     * @typeParam Opts - the options that override the default options
+     */
+    type AssignmentType<Opts extends Options> = DataField.DerivedAssignmentType<
+      typeof AbstractBaseShader,
+      MergedOptions<Opts>
+    >;
+
+    /**
+     * A shorthand for the initialized type of a BooleanField class.
+     * @typeParam Opts - the options that override the default options
+     */
+    type InitializedType<Opts extends Options> = DataField.DerivedInitializedType<
+      typeof AbstractBaseShader,
+      MergedOptions<Opts>
+    >;
   }
 
   /**
    * A Vision Mode which can be selected for use by a Token.
    * The selected Vision Mode alters the appearance of various aspects of the canvas while that Token is the POV.
    */
-  class VisionMode extends foundry.abstract.DataModel<VisionMode.Schema> {
-    /**
-     * Construct a Vision Mode using provided configuration parameters and callback functions.
-     * @param data    - Data which fulfills the model defined by the VisionMode schema.
-     * @param options - Additional options passed to the DataModel constructor.
-     */
-    constructor(data: InexactPartial<any>, options?: AnyObject);
+  class VisionMode extends foundry.abstract.DataModel<
+    VisionMode.Schema,
+    DataModel.Any | null,
+    InterfaceToObject<VisionMode.ExtraConstructorOptions>
+  > {
+    // A constructor override has been omitted as there are no typing changes
 
     static defineSchema(): VisionMode.Schema;
 
     /** The lighting illumination levels which are supported. */
-    static LIGHTING_LEVELS: typeof CONST.LIGHTING_LEVELS;
+    static LIGHTING_LEVELS: typeof foundry.CONST.LIGHTING_LEVELS;
 
     /**
      * Flags for how each lighting channel should be rendered for the currently active vision modes:
@@ -47,11 +86,7 @@ declare global {
      * - Enabled: this lighting layer is rendered normally, and the shaders can choose if they should be rendered or not.
      * - Required: the lighting layer is rendered, the shaders does not decide.
      */
-    static LIGHTING_VISIBILITY: {
-      DISABLED: 0;
-      ENABLED: 1;
-      REQUIRED: 2;
-    };
+    static LIGHTING_VISIBILITY: VisionMode.LightingVisibility;
 
     /**
      * A flag for whether this vision source is animated
@@ -69,83 +104,71 @@ declare global {
      * Special activation handling that could be implemented by VisionMode subclasses
      * @param source - Activate this VisionMode for a specific source
      */
-    _activate(source: foundry.canvas.sources.PointVisionSource.Any): void;
+    _activate(source: PointVisionSource.Any): void;
 
     /**
      * Special deactivation handling that could be implemented by VisionMode subclasses
      * @param source - Deactivate this VisionMode for a specific source
      */
-    _deactivate(source: foundry.canvas.sources.PointVisionSource.Any): void;
+    _deactivate(source: PointVisionSource.Any): void;
 
     /**
      * Special handling which is needed when this Vision Mode is activated for a VisionSource.
      * @param source - Activate this VisionMode for a specific source
      */
-    activate(source: foundry.canvas.sources.PointVisionSource.Any): void;
+    activate(source: PointVisionSource.Any): void;
 
     /**
      * Special handling which is needed when this Vision Mode is deactivated for a VisionSource.
      * @param source - Deactivate this VisionMode for a specific source
      */
-    deactivate(source: foundry.canvas.sources.PointVisionSource.Any): void;
+    deactivate(source: PointVisionSource.Any): void;
 
     /**
      * An animation function which runs every frame while this Vision Mode is active.
      * @param dt - The deltaTime passed by the PIXI Ticker
+     * @remarks Calls `RenderedEffectSource#animateTime` with `this` set to this `VisionMode`
      */
     animate(dt: number): void;
   }
 
-  namespace ShaderField {
-    type Options = DataFieldOptions<typeof AbstractBaseShader>;
+  namespace VisionMode {
+    interface Any extends AnyVisionMode {}
+    type AnyConstructor = typeof AnyVisionMode;
 
-    type DefaultOptions = SimpleMerge<
-      foundry.data.fields.DataField.DefaultOptions,
-      {
-        nullable: true;
-        initial: undefined;
-      }
-    >;
+    type ConfiguredModes = keyof RemoveIndexSignatures<CONFIG["Canvas"]["visionModes"]>;
 
-    /**
-     * A helper type for the given options type merged into the default options of the BooleanField class.
-     * @typeParam Opts - the options that override the default options
-     */
-    type MergedOptions<Opts extends Options> = SimpleMerge<DefaultOptions, Opts>;
+    type LIGHTING_VISIBILITY = Brand<number, "VisionMode.LIGHTING_VISIBILITY">;
 
-    /**
-     * A shorthand for the assignment type of a BooleanField class.
-     * @typeParam Opts - the options that override the default options
-     */
-    type AssignmentType<Opts extends Options> = foundry.data.fields.DataField.DerivedAssignmentType<
-      typeof AbstractBaseShader,
-      MergedOptions<Opts>
-    >;
+    interface ExtraConstructorOptions {
+      animated?: boolean | undefined | null;
+    }
 
-    /**
-     * A shorthand for the initialized type of a BooleanField class.
-     * @typeParam Opts - the options that override the default options
-     */
-    type InitializedType<Opts extends Options> = foundry.data.fields.DataField.DerivedInitializedType<
-      typeof AbstractBaseShader,
-      MergedOptions<Opts>
-    >;
-  }
+    interface LightingVisibility {
+      /** Disabled: this lighting layer is not rendered, the shaders does not decide. */
+      DISABLED: 0 & LIGHTING_VISIBILITY;
+      /** Enabled: this lighting layer is rendered normally, and the shaders can choose if they should be rendered or not. */
+      ENABLED: 1 & LIGHTING_VISIBILITY;
+      /** Required: the lighting layer is rendered, the shaders does not decide. */
+      REQUIRED: 2 & LIGHTING_VISIBILITY;
+    }
 
-  namespace VisionMode {
     type ShaderSchema = fields.SchemaField<{
       shader: ShaderField;
       uniforms: fields.ObjectField;
     }>;
 
-    type LightingSchema = fields.SchemaField<{
+    // eslint-disable-next-line @typescript-eslint/consistent-type-definitions
+    type LightingSchema = {
       visibility: fields.NumberField;
       postProcessingModes: fields.ArrayField<fields.StringField>;
       uniforms: fields.ObjectField;
-    }>;
+    };
+
+    type LightingSchemaField = fields.SchemaField<LightingSchema>;
 
-    type LightingLevels = Record<ValueOf<typeof CONST.LIGHTING_LEVELS>, ValueOf<typeof CONST.LIGHTING_LEVELS>>;
-    type LightingMultipliers = Record<ValueOf<typeof VisionMode.LIGHTING_LEVELS>, number>;
+    type LightingLevels = Record<foundry.CONST.LIGHTING_LEVELS, foundry.CONST.LIGHTING_LEVELS>;
+    type LightingMultipliers = Record<foundry.CONST.LIGHTING_LEVELS, number>;
 
     interface Schema extends DataSchema {
       id: fields.StringField<{ blank: false }>;
@@ -156,9 +179,9 @@ declare global {
         uniforms: fields.ObjectField;
       }>;
       lighting: fields.SchemaField<{
-        background: LightingSchema;
-        coloration: LightingSchema;
-        illumination: LightingSchema;
+        background: LightingSchemaField;
+        coloration: LightingSchemaField;
+        illumination: LightingSchemaField;
         levels: fields.ObjectField<
           {
             validate: (o: unknown) => boolean;
@@ -192,22 +215,22 @@ declare global {
             required: false;
             initial: undefined;
             nullable: false;
-            min: number;
-            max: number;
+            min: -1;
+            max: 1;
           }>;
           saturation: fields.NumberField<{
             required: false;
             initial: undefined;
             nullable: false;
-            min: number;
-            max: number;
+            min: -1;
+            max: 1;
           }>;
           contrast: fields.NumberField<{
             required: false;
             initial: undefined;
             nullable: false;
-            min: number;
-            max: number;
+            min: -1;
+            max: 1;
           }>;
         }>;
         preferred: fields.BooleanField<{ initial: false }>;
@@ -215,3 +238,7 @@ declare global {
     }
   }
 }
+
+declare class AnyVisionMode extends VisionMode {
+  constructor(...args: never);
+}

package/src/foundry/client/pixi/perception/weiler-atherton-clipping.d.mts

@@ -1,5 +1,4 @@
-import type { Brand } from "../../../../types/helperTypes.d.mts";
-import type { NullishProps } from "../../../../types/utils.d.mts";
+import type { Brand, Identity, NullishProps } from "#utils";
 
 declare global {
   /**
@@ -16,6 +15,9 @@ declare global {
    * https://en.wikipedia.org/wiki/Weiler%E2%80%93Atherton_clipping_algorithm
    * https://www.geeksforgeeks.org/weiler-atherton-polygon-clipping-algorithm
    * https://h-educate.in/weiler-atherton-polygon-clipping-algorithm/
+   *
+   * @throws If `!Polygon.isPositive`
+   * @remarks In practice the only thing that uses the constructor is the class's static methods
    */
   class WeilerAthertonClipper {
     /**
@@ -38,14 +40,12 @@ declare global {
      * The supported clip types.
      * Values are equivalent to those in ClipperLib.ClipType.
      */
-    static CLIP_TYPES: Readonly<Record<"INTERSECT" | "UNION", WeilerAthertonClipper.CLIP_TYPES>>;
+    static CLIP_TYPES: WeilerAthertonClipper.ClipTypes;
 
     /**
      * The supported intersection types.
      */
-    static INTERSECTION_TYPES: Readonly<
-      Record<"OUT_IN" | "IN_OUT" | "TANGENT", WeilerAthertonClipper.INTERSECTION_TYPES>
-    >;
+    static INTERSECTION_TYPES: WeilerAthertonClipper.IntersectionTypes;
 
     polygon: PIXI.Polygon;
 
@@ -53,14 +53,8 @@ declare global {
 
     /**
      * Configuration settings
-     * @param clipType  - One of CLIP_TYPES (default: `WeilerAthertonClipper.CLIP_TYPES.INTERSECT`)
-     * @param clipOpts  - Object passed to the clippingObject methods toPolygon and pointsBetween
-     *                    (default: `{}`)
      */
-    config: {
-      clipType: WeilerAthertonClipper.CLIP_TYPES;
-      clipOpts: WeilerAthertonClipper.ClipOpts;
-    };
+    config: WeilerAthertonClipper.Config;
 
     /**
      * Union a polygon and clipObject using the Weiler Atherton algorithm.
@@ -127,13 +121,47 @@ declare global {
   }
 
   namespace WeilerAthertonClipper {
-    type AnyConstructor = typeof AnyWeilerAthertonClipper;
+    interface Any extends AnyWeilerAthertonClipper {}
+    interface AnyConstructor extends Identity<typeof AnyWeilerAthertonClipper> {}
 
     type CLIP_TYPES = Brand<number, "WeilerAthertonClipper.CLIP_TYPES">;
 
+    interface ClipTypes {
+      readonly INTERSECT: 0 & CLIP_TYPES;
+      readonly UNION: 1 & CLIP_TYPES;
+    }
+
     type INTERSECTION_TYPES = Brand<number, "WeilerAthertonClipper.INTERSECTION_TYPES">;
 
-    /** @internal Helper type to simplify use of optionality- and nullish-permissiveness-modifying helpers */
+    interface IntersectionTypes {
+      readonly OUT_IN: -1 & INTERSECTION_TYPES;
+      readonly IN_OUT: 1 & INTERSECTION_TYPES;
+      readonly TANGENT: 0 & INTERSECTION_TYPES;
+    }
+
+    /** Configuration settings */
+    interface Config {
+      /**
+       * One of CLIP_TYPES
+       * @defaultValue `WeilerAthertonClipper.CLIP_TYPES.INTERSECT`
+       * @remarks Set to the value of the equivalent constructor parameter. Default provided by `??=` in the constructor body
+       */
+      clipType: WeilerAthertonClipper.CLIP_TYPES;
+
+      /**
+       * Object passed to the clippingObject methods `toPolygon` and `pointsBetween`
+       * @defaultValue `{}`
+       * @remarks Set to the value of the equivalent constructor parameter. Default provided by `??=` in the constructor body
+       */
+      clipOpts: WeilerAthertonClipper.ClipOpts;
+    }
+
+    /**
+     * @internal
+     * @privateRemarks does *not* contain:
+     * - a `scalingFactor` property, despite one being passed in `PIXI.Rectangle#intersectPolygon` in v12
+     * - a `density` property, despite one being passed in `PIXI.Circle#intersectPolygon` in v12
+     */
     type _CombineOptions = NullishProps<{
       /**
        * If the WeilerAtherton constructor could mutate or not the subject polygon points
@@ -158,5 +186,5 @@ declare global {
 }
 
 declare abstract class AnyWeilerAthertonClipper extends WeilerAthertonClipper {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }