@league-of-foundry-developers/foundry-vtt-types 13.340.0 → 13.340.1

package/src/foundry/client/pixi/core/interaction/canvas-animation.d.mts

@@ -1,4 +1,4 @@
-import type { PropertiesOfType, Brand, NullishProps, AnyObject } from "fvtt-types/utils";
+import type { PropertiesOfType, Brand, NullishProps, AnyObject, Identity } from "fvtt-types/utils";
 
 declare global {
   /**
@@ -19,7 +19,7 @@ declare global {
      * @privateRemarks Foundry does not account for the possibility of Symbol animation names and types the keys as simply `string`,
      * despite typing `CanvasAnimationOptions.name` as `string | symbol`
      */
-    static animations: Record<PropertyKey, CanvasAnimationData>;
+    static animations: Record<PropertyKey, CanvasAnimation.AnimationData>;
 
     /**
      * Apply an animation from the current value of some attribute to a new value
@@ -50,7 +50,7 @@ declare global {
      */
     static animate(
       attributes: CanvasAnimation.Attribute[],
-      options?: CanvasAnimationOptions,
+      options?: CanvasAnimation.AnimateOptions,
     ): CanvasAnimation.AnimateReturn;
 
     /**
@@ -58,7 +58,7 @@ declare global {
      * @param name - The animation name to retrieve
      * @returns The animation data, or undefined
      */
-    static getAnimation(name: PropertyKey): CanvasAnimationData | undefined;
+    static getAnimation(name: PropertyKey): CanvasAnimation.AnimationData | undefined;
 
     /**
      * If an animation using a certain name already exists, terminate it
@@ -90,7 +90,7 @@ declare global {
 
   namespace CanvasAnimation {
     interface Any extends AnyCanvasAnimation {}
-    type AnyConstructor = typeof AnyCanvasAnimation;
+    interface AnyConstructor extends Identity<typeof AnyCanvasAnimation> {}
 
     /** @remarks Helper type as many things `return CanvasAnimation.animate(...)` */
     type AnimateReturn = Promise<boolean | void>;
@@ -117,10 +117,10 @@ declare global {
       readonly COMPLETED: 2 & CanvasAnimation.STATES;
     }
 
-    type OnTickFunction = (dt: number, animation: CanvasAnimationData) => void;
+    type OnTickFunction = (dt: number, animation: CanvasAnimation.AnimationData) => void;
 
     /** @internal */
-    type _AnimationOptions = NullishProps<{
+    type _AnimateOptions = NullishProps<{
       /**
        * A DisplayObject which defines context to the PIXI.Ticker function
        * @defaultValue `canvas.stage`
@@ -174,63 +174,69 @@ declare global {
       /** The destination value of the attribute */
       to: number | Color;
     }
-  }
 
-  interface CanvasAnimationOptions extends CanvasAnimation._AnimationOptions {
-    /**
-     * A duration in milliseconds over which the animation should occur
-     * @defaultValue `1000`
-     * @remarks Can't be `null` because it only has a parameter default, and used as a divisor in `CanvasAnimation.#animateFrame`
-     */
-    duration?: number | undefined;
-  }
+    interface AnimateOptions extends CanvasAnimation._AnimateOptions {
+      /**
+       * A duration in milliseconds over which the animation should occur
+       * @defaultValue `1000`
+       * @remarks Can't be `null` because it only has a parameter default, and is used as a divisor in `CanvasAnimation.#animateFrame`
+       */
+      duration?: number | undefined;
+    }
 
-  interface CanvasAnimationAttribute extends CanvasAnimation.Attribute {
-    /**
-     * The computed delta between to and from
-     * @remarks This key is always overwritten inside `.animate`, its passed value is irrelevant
-     */
-    delta: number;
+    interface CanvasAnimationAttribute extends CanvasAnimation.Attribute {
+      /**
+       * The computed delta between to and from
+       * @remarks This key is always overwritten inside `.animate`, its passed value is irrelevant
+       */
+      delta: number;
 
-    /**
-     * The amount of the total delta which has been animated
-     * @remarks This key is always overwritten inside `.animate`, its passed value is irrelevant
-     */
-    done: number;
+      /**
+       * The amount of the total delta which has been animated
+       * @remarks This key is always overwritten inside `.animate`, its passed value is irrelevant
+       */
+      done: number;
 
-    /**
-     * Is this a color animation that applies to RGB channels
-     * @remarks When true, `CanvasAnimation.#animateFrame` assumes `to` *and* `from` are
-     * both `Color`s. It's automatically set `true` if `to` is passed as a `Color`, so it
-     * should be unnecessary to set manually.
-     */
-    color?: boolean;
-  }
+      /**
+       * Is this a color animation that applies to RGB channels
+       * @remarks When true, `CanvasAnimation.#animateFrame` assumes `to` *and* `from` are
+       * both `Color`s. It's automatically set `true` if `to` is passed as a `Color`, so it
+       * should be unnecessary to set manually.
+       */
+      color?: boolean;
+    }
 
-  interface CanvasAnimationData extends CanvasAnimationOptions {
-    /** The animation function being executed each frame */
-    fn: (dt: number) => void;
+    interface AnimationData extends CanvasAnimation.AnimateOptions {
+      /** The animation function being executed each frame */
+      fn: (dt: number) => void;
 
-    /** The current time of the animation, in milliseconds */
-    time: number;
+      /** The current time of the animation, in milliseconds */
+      time: number;
 
-    /** The attributes being animated */
-    attributes: CanvasAnimationAttribute[];
+      /** The attributes being animated */
+      attributes: CanvasAnimationAttribute[];
 
-    /** The current state of the animation */
-    state: CanvasAnimation.STATES;
+      /** The current state of the animation */
+      state: CanvasAnimation.STATES;
 
-    /** A Promise which resolves once the animation is complete */
-    promise: Promise<boolean>;
+      /** A Promise which resolves once the animation is complete */
+      promise: Promise<boolean>;
 
-    /** The resolution function, allowing animation to be ended early */
-    resolve: (value: boolean) => void;
+      /** The resolution function, allowing animation to be ended early */
+      resolve: (value: boolean) => void;
 
-    /** The rejection function, allowing animation to be ended early */
-    reject: (err: Error) => void;
+      /** The rejection function, allowing animation to be ended early */
+      reject: (err: Error) => void;
+    }
   }
+
+  /** @deprecated {@link CanvasAnimation.AnimateOptions | `CanvasAnimation.AnimateOptions`} */
+  type CanvasAnimationOptions = CanvasAnimation.AnimateOptions;
+
+  /** @deprecated {@link CanvasAnimation.AnimationData | `CanvasAnimation.AnimationData`} */
+  type CanvasAnimationData = CanvasAnimation.AnimationData;
 }
 
 declare abstract class AnyCanvasAnimation extends CanvasAnimation {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

package/src/foundry/client/pixi/core/interaction/control-icon.d.mts

@@ -1,4 +1,4 @@
-import type { InexactPartial } from "fvtt-types/utils";
+import type { Identity, InexactPartial } from "fvtt-types/utils";
 
 declare global {
   /**
@@ -68,7 +68,7 @@ declare global {
 
   namespace ControlIcon {
     interface Any extends AnyControlIcon {}
-    type AnyConstructor = typeof AnyControlIcon;
+    interface AnyConstructor extends Identity<typeof AnyControlIcon> {}
 
     /** @internal */
     type _Options = InexactPartial<{
@@ -124,5 +124,5 @@ declare global {
 }
 
 declare abstract class AnyControlIcon extends ControlIcon {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

package/src/foundry/client/pixi/core/interaction/mouse-handler.d.mts

@@ -1,4 +1,4 @@
-import type { Brand, NullishProps } from "fvtt-types/utils";
+import type { AnyArray, Brand, Identity, NullishProps } from "fvtt-types/utils";
 
 declare global {
   /**
@@ -195,7 +195,7 @@ declare global {
      *          Events which do not specify a callback are assumed to have been handled as no-op.
      * @remarks
      */
-    callback(action: MouseInteractionManager.Action, event: Event | PIXI.FederatedEvent, ...args: any[]): boolean;
+    callback(action: MouseInteractionManager.Action, event: Event | PIXI.FederatedEvent, ...args: AnyArray): boolean;
 
     /**
      * A reference to the possible interaction states which can be observed
@@ -227,9 +227,9 @@ declare global {
 
   namespace MouseInteractionManager {
     interface Any extends AnyMouseInteractionManager {}
-    type AnyConstructor = typeof AnyMouseInteractionManager;
+    interface AnyConstructor extends Identity<typeof AnyMouseInteractionManager> {}
 
-    /** @privateRemarks The private class property is `#HANDLER_OUTCOME` singular, but the getter is `handlerOutcomes`, so the brand uses the plural*/
+    /** @privateRemarks The private class property is `#HANDLER_OUTCOME` singular, but the getter is `handlerOutcomes`, so the brand uses the plural */
     type HANDLER_OUTCOMES = Brand<number, "MouseInteractionManager.HANDLER_OUTCOMES">;
 
     interface HandlerOutcomes {
@@ -274,7 +274,7 @@ declare global {
       | "hoverIn"
       | "hoverOut";
 
-    type PermissionFunction = (user: User.ConfiguredInstance, event: Event | PIXI.FederatedEvent) => boolean;
+    type PermissionFunction = (user: User.Implementation, event: Event | PIXI.FederatedEvent) => boolean;
 
     type Permissions = Partial<Record<PermissionAction, PermissionFunction | boolean>>;
 
@@ -300,7 +300,7 @@ declare global {
      *   - For Regions specifically, `hoverOut` takes an `options: { updateLegend: boolean }` object, and that key is also added to Region `hoverIn` options
      * - `longPress` receives `origin: PIXI.Point`
      */
-    type CallbackFunction = (event: Event | PIXI.FederatedEvent, ...args: any[]) => boolean | null | void;
+    type CallbackFunction = (event: Event | PIXI.FederatedEvent, ...args: AnyArray) => boolean | null | void;
 
     type Callbacks = Partial<Record<Action, CallbackFunction>>;
 
@@ -354,5 +354,5 @@ declare global {
 }
 
 declare abstract class AnyMouseInteractionManager extends MouseInteractionManager {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

package/src/foundry/client/pixi/core/interaction/ping.d.mts

@@ -1,4 +1,4 @@
-import type { InexactPartial } from "fvtt-types/utils";
+import type { Identity, IntentionalPartial, RemoveIndexSignatures } from "fvtt-types/utils";
 
 declare global {
   /**
@@ -9,9 +9,9 @@ declare global {
      * @param origin  - The canvas coordinates of the origin of the ping.
      * @param options - Additional options to configure the ping animation.
      */
-    constructor(origin: Canvas.Point, options?: PingOptions);
+    constructor(origin: Canvas.Point, options?: Ping.ConstructorOptions);
 
-    options: PingOptions;
+    options: Ping.ConstructorOptions;
 
     _color: Color;
 
@@ -31,20 +31,23 @@ declare global {
      * @param dt        - The number of ms that elapsed since the previous frame.
      * @param animation - The animation state.
      */
-    protected _animateFrame(dt: number, animation: CanvasAnimationData): void;
+    protected _animateFrame(dt: number, animation: CanvasAnimation.AnimationData): void;
   }
 
   namespace Ping {
     interface Any extends AnyPing {}
-    type AnyConstructor = typeof AnyPing;
+    interface AnyConstructor extends Identity<typeof AnyPing> {}
+
+    type ConfiguredStyles = keyof RemoveIndexSignatures<typeof CONFIG.Canvas.pings.styles>;
 
     /** @internal */
-    type _Options = InexactPartial<{
+    type _ConstructorOptions = IntentionalPartial<{
       /**
        * The duration of the animation in milliseconds.
        * @defaultValue `900`
        * @remarks Can't be `null` because `options` is `mergeObject`ed with an object with this key,
-       * and the result is passed on to `CanvasAnimation.animate` in its options
+       * and the result is passed on to `CanvasAnimation.animate` in its options, which only has a
+       * parameter default for this property
        */
       duration: number | undefined;
 
@@ -67,15 +70,20 @@ declare global {
       color: Color.Source;
 
       /**
-       * The name for the ping animation to pass to {@link CanvasAnimation.animate}.
+       * The name for the ping animation to pass to {@link CanvasAnimation.animate | `CanvasAnimation.animate`}.
        */
-      name?: PropertyKey | undefined | null;
+      name: PropertyKey | undefined | null;
     }>;
+
+    interface ConstructorOptions extends Ping._ConstructorOptions {}
   }
 
-  interface PingOptions extends Ping._Options {}
+  /**
+   * @deprecated {@link Ping.ConstructorOptions | `Ping.ConstructorOptions`}
+   */
+  type PingOptions = Ping.ConstructorOptions;
 }
 
 declare abstract class AnyPing extends Ping {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

package/src/foundry/client/pixi/core/interaction/pings/chevron.d.mts

@@ -10,7 +10,12 @@ declare global {
      * @param options - Additional options to configure the ping animation.
      *                  (default: `{duration: 900, size: 128, color: "#ff6400"}`)
      */
-    constructor(origin: Canvas.Point, options?: PingOptions);
+    constructor(
+      origin: Canvas.Point,
+
+      /** @privateRemarks Can't be `null` as it's directly assigned to  `Ping#options` which has properties accessed null-unsafely */
+      options?: Ping.ConstructorOptions,
+    );
 
     /** @defaultValue `(this.options.size / 2) * .75` */
     _r: number;
@@ -57,7 +62,7 @@ declare global {
 
     override animate(): Promise<boolean>;
 
-    override _animateFrame(dt: number, animation: CanvasAnimationData): void;
+    override _animateFrame(dt: number, animation: CanvasAnimation.AnimationData): void;
 
     /**
      * Draw the outer and inner rings.

package/src/foundry/client/pixi/core/interaction/pings/pulse.d.mts

@@ -1,4 +1,4 @@
-import type { InexactPartial, NullishProps } from "fvtt-types/utils";
+import type { Identity, InexactPartial, NullishProps } from "fvtt-types/utils";
 
 declare global {
   /**
@@ -9,9 +9,14 @@ declare global {
      * @param origin - The canvas coordinates of the origin of the ping.
      * @param options - Additional options to configure the ping animation.
      */
-    constructor(origin: Canvas.Point, options?: PulsePingOptions);
+    constructor(
+      origin: Canvas.Point,
 
-    override options: PulsePingOptions;
+      /** @privateRemarks Can't be `null` as it's directly assigned to  `Ping#options` which has properties accessed null-unsafely */
+      options?: PulsePing.ConstructorOptions,
+    );
+
+    override options: PulsePing.ConstructorOptions;
 
     _color2: Color;
 
@@ -43,7 +48,7 @@ declare global {
 
     override animate(): Promise<boolean>;
 
-    override _animateFrame(dt: number, animation: CanvasAnimationData): void;
+    override _animateFrame(dt: number, animation: CanvasAnimation.AnimationData): void;
 
     /**
      * Transition linearly from one color to another.
@@ -68,27 +73,27 @@ declare global {
 
   namespace PulsePing {
     interface Any extends AnyPulsePing {}
-    type AnyConstructor = typeof AnyPulsePing;
+    interface AnyConstructor extends Identity<typeof AnyPulsePing> {}
 
     /** @internal */
-    type _Options = InexactPartial<{
+    type _ConstructorOptions = InexactPartial<{
       /**
        * The number of rings used in the animation.
        * @defaultValue `3`
        * @remarks Can't be `null` as it only has a parameter default and a coerced `0` ring count is nonsensical
        */
-      rings?: number;
+      rings: number;
 
       /**
        * The alternate color that the rings begin at. Use white for a 'flashing' effect.
        * @defaultValue `#ffffff`
        * @remarks Can't be `null` as it only has a parameter default and `Color(NaN)`s are to be avoided
        */
-      color2?: Color.Source;
+      color2: Color.Source;
     }>;
-  }
 
-  interface PulsePingOptions extends PingOptions, PulsePing._Options {}
+    interface ConstructorOptions extends _ConstructorOptions, Ping.ConstructorOptions {}
+  }
 
   /**
    * A type of ping that produces an arrow pointing in a given direction.
@@ -98,20 +103,20 @@ declare global {
      * @param origin - The canvas coordinates of the origin of the ping. This becomes the arrow's tip.
      * @param options - Additional options to configure the ping animation.
      */
-    constructor(origin: PIXI.Point, options?: ArrowPing.Options);
+    constructor(origin: PIXI.Point, options?: ArrowPing.ConstructorOptions);
 
-    // @privateRemarks `options` does not get overridden here as the `rotation` key does not
-    // get passed up to super, so the property is still just `PulsePingOptions`
+    // @privateRemarks The `options` property does not get overridden here as the `rotation` key does not
+    // get passed up to super, so it's still just `PulsePing.Constructor.Options`
 
     protected override _drawShape(g: PIXI.Graphics, color: number | Color, alpha: number, size: number): void;
   }
 
   namespace ArrowPing {
     interface Any extends AnyArrowPing {}
-    type AnyConstructor = typeof AnyArrowPing;
+    interface AnyConstructor extends Identity<typeof AnyArrowPing> {}
 
     /** @internal */
-    type _Options = NullishProps<{
+    type _ConstructorOptions = NullishProps<{
       /**
        * The angle of the arrow in radians.
        * @defaultValue `0`
@@ -120,7 +125,7 @@ declare global {
       rotation: number;
     }>;
 
-    interface Options extends PulsePingOptions, _Options {}
+    interface ConstructorOptions extends _ConstructorOptions, PulsePing.ConstructorOptions {}
   }
 
   /**
@@ -131,36 +136,37 @@ declare global {
      * @param origin  - The canvas coordinates of the origin of the ping.
      * @param options - Additional options to configure the ping animation.
      */
-    constructor(origin: PIXI.Point, options: AlertPing.Options);
+    constructor(origin: PIXI.Point, options: AlertPing.ConstructorOptions);
 
     protected override _drawShape(g: PIXI.Graphics, color: number | Color, alpha: number, size: number): void;
   }
 
   namespace AlertPing {
     interface Any extends AnyAlertPing {}
-    type AnyConstructor = typeof AnyAlertPing;
+    interface AnyConstructor extends Identity<typeof AnyAlertPing> {}
 
     /** @privateRemarks Only exists to change the default value of `color` */
-    interface Options extends PulsePingOptions {
+    interface ConstructorOptions extends PulsePing.ConstructorOptions {
       /**
        * @defaultValue `"#ff0000"`
        * @remarks Can't be `null` or `undefined` because `options` is `mergeObject`ed with an object with this key,
        * and passing either to `Color.from` produces a `Color(NaN)`, which may cause breakage in subclasses or when
        * passed to PIXI methods
+       * @privateRemarks Typing this as `Ping.ConstructorOptions["color"]` breaks, because it thinks `| undefined` has snuck in for unknown reasons
        */
-      color?: PulsePingOptions["color"];
+      color?: Color.Source;
     }
   }
 }
 
 declare abstract class AnyPulsePing extends PulsePing {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }
 
 declare abstract class AnyArrowPing extends ArrowPing {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }
 
 declare abstract class AnyAlertPing extends AlertPing {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

package/src/foundry/client/pixi/core/interaction/render-flags.d.mts

@@ -1,5 +1,14 @@
-import type { AnyConstructor, FixedInstanceType, InexactPartial, Mixin } from "fvtt-types/utils";
-import type { LogCompatibilityWarningOptions } from "../../../../common/utils/logging.d.mts";
+import type {
+  AnyConstructor,
+  Coalesce,
+  ConcreteKeys,
+  FixedInstanceType,
+  InexactPartial,
+  MakeConform,
+  Mixin,
+  PhantomConstructor,
+} from "fvtt-types/utils";
+import type { LogCompatibilityWarningOptions } from "#common/utils/logging.d.mts";
 
 declare class RenderFlagObject {
   /** @privateRemarks All mixin classses should accept anything for its constructor. */
@@ -9,12 +18,12 @@ declare class RenderFlagObject {
    * Configure the render flags used for this class.
    * @defaultValue `{}`
    */
-  static RENDER_FLAGS: Record<string, RenderFlag.Any>;
+  static RENDER_FLAGS: RenderFlagsMixin.RENDER_FLAGS;
 
   /**
    * The ticker priority when RenderFlags of this class are handled.
    * Valid values are OBJECTS or PERCEPTION.
-   * @defaultValue "OBJECTS"
+   * @defaultValue `"OBJECTS"`
    */
   static RENDER_FLAG_PRIORITY: "OBJECTS" | "PERCEPTION";
 
@@ -22,7 +31,8 @@ declare class RenderFlagObject {
    * Status flags which are applied at render-time to update the PlaceableObject.
    * If an object defines RenderFlags, it should at least include flags for "redraw" and "refresh".
    */
-  renderFlags: RenderFlags;
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+  renderFlags: RenderFlags<{}>;
 
   /**
    * Apply any current render flags, clearing the renderFlags set.
@@ -35,12 +45,16 @@ declare class RenderFlagObject {
  * @privateRemarks Values are marked as optional here based on use, foundry docs incomplete
  * @internal
  */
-type _RenderFlags<Flags> = InexactPartial<{
-  /** Activating this flag also sets these flags to true */
-  propagate: Array<keyof Flags>;
+type _RenderFlag<Keys extends string> = InexactPartial<{
+  /**
+   * Activating this flag also sets these flags to true
+   */
+  propagate: Keys[];
 
-  /** Activating this flag resets these flags to false */
-  reset: Array<keyof Flags>;
+  /**
+   * Activating this flag resets these flags to false
+   */
+  reset: Keys[];
 
   /**
    * Is this flag deprecated? The deprecation options are passed to
@@ -60,40 +74,46 @@ type _RenderFlags<Flags> = InexactPartial<{
 }>;
 
 declare global {
-  // @ts-expect-error - RenderFlag is built around willfully violating subclassing rules.
-  // The primary issue at hand is that each value can refer to the keys, thus making it technically
-  // unsound to apply a subclass to its superclass.
-  interface RenderFlag<out Flags> extends _RenderFlags<Flags> {}
+  // Note(LukeAbby): The usage of `ConcreteKeys` is a hazard; if tsc were to become smarter it might
+  // notice that `ConcreteKeys<Flags>` is actually contravariant and reject this type. However
+  // `RenderFlags` is built upon the assumption this is only used in safe ways.
+  interface RenderFlag<out Flags extends object, Key extends keyof Flags>
+    extends _RenderFlag<Exclude<Extract<ConcreteKeys<Flags>, string>, Key>> {}
 
   namespace RenderFlag {
-    type Any = RenderFlag<any>;
+    interface Any extends _RenderFlag<string> {}
+  }
+
+  namespace RenderFlags {
+    type ValidateFlags<Flags extends object> = {
+      [K in keyof Flags]: MakeConform<Flags[K], _RenderFlag<Extract<Exclude<keyof Flags, K>, string>>>;
+    };
+
+    interface Config {
+      /** The object which owns this RenderFlags instance */
+      object?: RenderFlagObject;
+
+      /**
+       * The update priority when these render flags are applied.
+       * Valid options are OBJECTS or PERCEPTION.
+       * @defaultValue `PIXI.UPDATE_PRIORITY.OBJECTS`
+       */
+      priority?: typeof PIXI.UPDATE_PRIORITY.OBJECTS | typeof PIXI.UPDATE_PRIORITY.PERCEPTION;
+    }
   }
 
   /**
    * A data structure for tracking a set of boolean status flags.
    * This is a restricted set which can only accept flag values which are pre-defined.
    */
-  class RenderFlags extends Set<string> {
+  class RenderFlags<Flags extends RenderFlags.ValidateFlags<Flags>> extends Set<string> {
     /**
      * @param flags  - An object which defines the flags which are supported for tracking
      * @param config - Optional configuration
      */
-    constructor(
-      flags: Record<string, RenderFlag<Record<string, boolean>>>,
-      config?: {
-        /** The object which owns this RenderFlags instance */
-        object?: RenderFlagObject;
-
-        /**
-         * The update priority when these render flags are applied.
-         * Valid options are OBJECTS or PERCEPTION.
-         * @defaultValue `PIXI.UPDATE_PRIORITY.OBJECTS`
-         */
-        priority?: PIXI.UPDATE_PRIORITY;
-      },
-    );
-
-    readonly flags: Record<string, RenderFlag<Record<string, boolean>>>;
+    constructor(flags: Flags, config?: RenderFlags.Config);
+
+    readonly flags: Flags;
 
     readonly object: RenderFlagObject;
 
@@ -112,24 +132,49 @@ declare global {
 
     /**
      * Activate certain flags, also toggling propagation and reset behaviors
+     * @remarks Flags are only set if `true`, nullish values are discarded
      */
-    set(changes: Record<string, boolean>): void;
+    set(changes: Record<string, boolean | undefined | null>): void;
   }
 
   /**
    * Add RenderFlags functionality to some other object.
    * This mixin standardizes the interface for such functionality.
-   * @param Base - The base class being mixed. Normally a PIXI.DisplayObject
+   * @param Base - The base class being mixed: defaults to an anonymous empty class.
    * @returns The mixed class definition
+   *
+   * @remarks `Base` is normally a PIXI.DisplayObject
    */
-  function RenderFlagsMixin<BaseClass extends RenderFlagsMixin.BaseClass>(
-    Base: BaseClass,
-  ): Mixin<typeof RenderFlagObject, BaseClass>;
+  // Note(LukeAbby): In theory a similar thing to what happens in `CanvasGroupMixin` could be done.
+  // That is passing up a generic to instantiate the generic side. However `RenderFlagsMixin` is
+  // only inherited directly by `PerceptionManager` and `PlaceableObject`.
+  // Therefore it's mostly the subclasses of `PlaceableObject` that face this problem and that can't
+  // be solved here unfortunately.
+  function RenderFlagsMixin<BaseClass extends RenderFlagsMixin.BaseClass | undefined = undefined>(
+    Base?: BaseClass,
+  ): RenderFlagsMixin.Mix<BaseClass>;
 
   namespace RenderFlagsMixin {
-    type AnyMixedConstructor = ReturnType<typeof RenderFlagsMixin<BaseClass>>;
+    interface AnyMixedConstructor extends ReturnType<typeof RenderFlagsMixin<BaseClass>> {}
     interface AnyMixed extends FixedInstanceType<AnyMixedConstructor> {}
 
+    type Mix<BaseClass extends RenderFlagsMixin.BaseClass | undefined> = Mixin<
+      typeof RenderFlagObject,
+      Coalesce<BaseClass, PhantomConstructor>
+    >;
+
     type BaseClass = AnyConstructor;
+
+    type RENDER_FLAGS = Record<string, RenderFlag.Any>;
+
+    /**
+     * @internal This type exists only to make sure `ToBooleanFlags` isn't a homomorphic mapped type
+     * to avoid keeping documentation.
+     */
+    type _KeyOf<T> = keyof T;
+
+    type ToBooleanFlags<RenderFlags extends object> = {
+      [K in _KeyOf<RenderFlags>]?: boolean | null | undefined;
+    };
   }
 }