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

package/src/foundry/client/pixi/groups/environment.d.mts

@@ -1,50 +1,50 @@
-import type { InexactPartial } from "../../../../types/utils.d.mts";
-
-// TODO: Remove when this is typed as part of #2674
-type SceneEnvironmentData = unknown;
+import type { FixedInstanceType, HandleEmptyObject, InexactPartial, NullishProps } from "fvtt-types/utils";
+import type { SceneEnvironmentData } from "../../../common/documents/_types.d.mts";
 
 declare global {
   /**
    * A container group which contains the primary canvas group and the effects canvas group.
    */
-  class EnvironmentCanvasGroup extends CanvasGroupMixin(PIXI.Container) {
+  class EnvironmentCanvasGroup<
+    DrawOptions extends EnvironmentCanvasGroup.DrawOptions = EnvironmentCanvasGroup.DrawOptions,
+    TearDownOptions extends EnvironmentCanvasGroup.TearDownOptions = EnvironmentCanvasGroup.TearDownOptions,
+  > extends CanvasGroupMixin<typeof PIXI.Container, "environment">(PIXI.Container)<DrawOptions, TearDownOptions> {
     /**
      * The global light source attached to the environment
+     * @remarks This is `defineProperty`'d as non-writable and non-configurable at construction
      */
-    globalLightSource(): foundry.canvas.sources.GlobalLightSource;
-
-    /**
-     * @defaultValue `"environment"`
-     */
-    static override groupName: string;
+    readonly globalLightSource: FixedInstanceType<typeof CONFIG.Canvas.globalLightSourceClass>;
 
     /**
+     * Should this group tear down its non-layer children?
      * @defaultValue `false`
      */
     static override tearDownChildren: boolean;
 
     /**
      * Colors exposed by the manager.
+     * @remarks Properties here are only `undefined` prior to `#initialize`ation
      */
-    colors: Record<string, Color | undefined>;
+    colors: EnvironmentCanvasGroup.Colors;
 
     /**
      * Weights used by the manager to compute colors.
+     * @remarks Properties here are only `undefined` prior to `#initialize`ation
      */
-    weights: Record<string, number | undefined>;
+    weights: EnvironmentCanvasGroup.Weights;
 
     /**
      * Get the darkness level of this scene.
      */
     get darknessLevel(): number;
 
-    protected override _draw(options: CanvasGroupMixin.DrawOptions): Promise<void>;
+    protected override _draw(options: HandleEmptyObject<DrawOptions>): Promise<void>;
 
     /**
      * Initialize the scene environment options.
      * @remarks `@fires PIXI.FederatedEvent type: "darknessChange" - event: {environmentData: {darknessLevel, priorDarknessLevel}}`
      */
-    initialize(config: InexactPartial<EnvironmentCanvasGroup.InitializeConfig>): void;
+    initialize(config?: EnvironmentCanvasGroup.InitializeOptions): void;
 
     /**
      * @deprecated since v12, will be removed in v14
@@ -54,7 +54,34 @@ declare global {
   }
 
   namespace EnvironmentCanvasGroup {
-    interface InitializeConfig {
+    interface Any extends AnyEnvironmentCanvasGroup {}
+    type AnyConstructor = typeof AnyEnvironmentCanvasGroup;
+
+    interface DrawOptions extends CanvasGroupMixin.DrawOptions {}
+
+    interface TearDownOptions extends CanvasGroupMixin.TearDownOptions {}
+
+    type ColorKeys =
+      | "darkness"
+      | "halfdark"
+      | "background"
+      | "dim"
+      | "bright"
+      | "ambientBrightest"
+      | "ambientDaylight"
+      | "ambientDarkness"
+      | "sceneBackground"
+      | "fogExplored"
+      | "fogUnexplored";
+
+    interface Colors extends Record<EnvironmentCanvasGroup.ColorKeys, Color | undefined> {}
+
+    type WeightKeys = "dark" | "halfdark" | "dim" | "bright";
+
+    interface Weights extends Record<EnvironmentCanvasGroup.WeightKeys, number | undefined> {}
+
+    /** @internal */
+    type _InitializeOptions = NullishProps<{
       /** The background canvas color */
       backgroundColor: Color.Source;
 
@@ -73,8 +100,30 @@ declare global {
       /** The color applied to unexplored areas */
       fogUnexploredColor: Color.Source;
 
-      /** The scene environment data */
-      environment: SceneEnvironmentData;
-    }
+      /**
+       * @deprecated since v12 until v14
+       * @remarks "config.darknessLevel parameter into EnvironmentCanvasGroup#initialize is deprecated.
+       * You should pass the darkness level into config.environment.darknessLevel"
+       * @privateRemarks [sic]
+       */
+      darknessLevel: number;
+    }> &
+      InexactPartial<{
+        /**
+         * The scene environment data
+         * @defaultValue `{}`
+         * @remarks Can't be `null` as it only has a parameter default and has properties accessed
+         */
+        environment: NullishProps<SceneEnvironmentData>;
+      }>;
+
+    interface InitializeOptions extends _InitializeOptions {}
   }
 }
+
+declare abstract class AnyEnvironmentCanvasGroup extends EnvironmentCanvasGroup<
+  EnvironmentCanvasGroup.DrawOptions,
+  EnvironmentCanvasGroup.TearDownOptions
+> {
+  constructor(arg0: never, ...args: never[]);
+}

package/src/foundry/client/pixi/groups/hidden.d.mts

@@ -1,40 +1,56 @@
-import type { EventMode } from "pixi.js";
+import type { HandleEmptyObject } from "fvtt-types/utils";
 
 declare global {
   /**
    * A specialized canvas group for rendering hidden containers before all others (like masks).
    */
-  class HiddenCanvasGroup extends CanvasGroupMixin(PIXI.Container) {
+  class HiddenCanvasGroup<
+    DrawOptions extends HiddenCanvasGroup.DrawOptions = HiddenCanvasGroup.DrawOptions,
+    TearDownOptions extends HiddenCanvasGroup.TearDownOptions = HiddenCanvasGroup.TearDownOptions,
+  > extends CanvasGroupMixin<typeof PIXI.Container, "hidden">(PIXI.Container)<DrawOptions, TearDownOptions> {
     /**
      * @defaultValue `"none"`
      */
-    override eventMode: EventMode;
+    override eventMode: PIXI.EventMode;
 
     /**
      * The container which hold masks.
      */
     masks: PIXI.Container;
 
-    /**
-     * @defaultValue `"hidden"`
-     */
-    static override groupName: string;
-
     /**
      * Add a mask to this group.
      * @param name          - Name of the mask.
      * @param displayObject - Display object to add.
      * @param position      - Position of the mask.
+     * @throws If `displayObject` doesn't implement a `clear` method, or if `name` is an empty string
+     * @remarks `position` is not used if fasley
      */
-    addMask(name: string, displayObject: PIXI.DisplayObject, position?: number): void;
+    addMask(name: string, displayObject: PIXI.DisplayObject, position?: number | null): void;
 
     /**
      * Invalidate the masks: flag them for rerendering.
      */
     invalidateMasks(): void;
 
-    protected override _draw(options: CanvasGroupMixin.DrawOptions): Promise<void>;
+    protected override _draw(options: HandleEmptyObject<DrawOptions>): Promise<void>;
 
-    protected override _tearDown(options: CanvasGroupMixin.TearDownOptions): Promise<void>;
+    protected override _tearDown(options: HandleEmptyObject<TearDownOptions>): Promise<void>;
   }
+
+  namespace HiddenCanvasGroup {
+    interface Any extends AnyHiddenCanvasGroup {}
+    type AnyConstructor = typeof AnyHiddenCanvasGroup;
+
+    interface DrawOptions extends CanvasGroupMixin.DrawOptions {}
+
+    interface TearDownOptions extends CanvasGroupMixin.TearDownOptions {}
+  }
+}
+
+declare abstract class AnyHiddenCanvasGroup extends HiddenCanvasGroup<
+  HiddenCanvasGroup.DrawOptions,
+  HiddenCanvasGroup.TearDownOptions
+> {
+  constructor(arg0: never, ...args: never[]);
 }

package/src/foundry/client/pixi/groups/interface.d.mts

@@ -1,29 +1,28 @@
-import type { InexactPartial } from "../../../../types/utils.d.mts";
+import type { HandleEmptyObject, InexactPartial, NullishProps } from "fvtt-types/utils";
 
 declare global {
   /**
    * A container group which displays interface elements rendered above other canvas groups.
    */
-  class InterfaceCanvasGroup extends CanvasGroupMixin(PIXI.Container) {
-    /**
-     * @defaultValue `"interface"`
-     */
-    static override groupName: string;
-
+  class InterfaceCanvasGroup<
+    DrawOptions extends InterfaceCanvasGroup.DrawOptions = InterfaceCanvasGroup.DrawOptions,
+    TearDownOptions extends InterfaceCanvasGroup.TearDownOptions = InterfaceCanvasGroup.TearDownOptions,
+  > extends CanvasGroupMixin<typeof PIXI.Container, "interface">(PIXI.Container)<DrawOptions, TearDownOptions> {
     /**
      * Add a PrimaryGraphics to the group.
      * @param drawing - The Drawing being added
      * @returns The created Graphics instance
+     * @remarks
      */
-    addDrawing(drawing: Drawing): PIXI.Graphics;
+    addDrawing(drawing: Drawing.ConfiguredInstance): PIXI.Graphics;
 
     /**
      * Remove a PrimaryGraphics from the group.
      * @param drawing - The Drawing being removed
      */
-    removeDrawing(drawing: Drawing): void;
+    removeDrawing(drawing: Drawing.ConfiguredInstance): void;
 
-    protected override _draw(options: CanvasGroupMixin.DrawOptions): Promise<void>;
+    protected override _draw(options: HandleEmptyObject<DrawOptions>): Promise<void>;
 
     /**
      * Display scrolling status text originating from this ObjectHUD container.
@@ -31,44 +30,69 @@ declare global {
      * @param content - The text content to display
      * @param options - Options which customize the text animation
      * @returns - The created PreciseText object which is scrolling
+     * @remarks Only returns `null` if the core `scrollingStatusText` setting is falsey
      */
     createScrollingText(
       origin: Canvas.Point,
       content: string,
-      options?: {
-        /**
-         * The duration of the scrolling effect in milliseconds
-         * @defaultValue `2000`
-         */
-        duration?: number;
+      options?: InterfaceCanvasGroup.CreateScrollingTextOptions,
+    ): Promise<PreciseText | null>;
+  }
 
-        /**
-         * The distance in pixels that the scrolling text should travel
-         * @defaultValue (2 * text.width)
-         */
-        distance?: number;
+  namespace InterfaceCanvasGroup {
+    interface Any extends AnyInterfaceCanvasGroup {}
+    type AnyConstructor = typeof AnyInterfaceCanvasGroup;
 
-        /**
-         * The original anchor point where the text appears
-         */
-        anchor: foundry.CONST.TEXT_ANCHOR_POINTS;
+    /** @internal */
+    type _CreateScrollingTextOptions = NullishProps<{
+      /**
+       * The distance in pixels that the scrolling text should travel
+       * @defaultValue Double the width or height of the text, depending on direction
+       * @remarks Default provided by `??`
+       */
+      distance: number;
 
-        /**
-         * The direction in which the text scrolls
-         */
-        direction: foundry.CONST.TEXT_ANCHOR_POINTS;
+      /**
+       * The original anchor point where the text appears
+       * @defaultValue `CONST.TEXT_ANCHOR_POINTS.CENTER`
+       */
+      anchor: foundry.CONST.TEXT_ANCHOR_POINTS;
 
-        /**
-         * An amount of randomization between [0, 1] applied to the initial position
-         * @defaultValue `0`
-         */
-        jitter: number;
+      /**
+       * The direction in which the text scrolls
+       * @defaultValue `CONST.TEXT_ANCHOR_POINTS.TOP`
+       */
+      direction: foundry.CONST.TEXT_ANCHOR_POINTS;
 
+      /**
+       * An amount of randomization between [0, 1] applied to the initial position
+       * @defaultValue `0`
+       * @remarks Only used if truthy
+       */
+      jitter: number;
+    }> &
+      InexactPartial<{
         /**
-         * Additional parameters of PIXI.TextStyle which are applied to the text
+         * The duration of the scrolling effect in milliseconds
+         * @defaultValue `2000`
+         * @remarks Can't be `null` as it only has a parameter default and a duration of `0` is not appropriate
          */
-        textStyle: InexactPartial<PIXI.ITextStyle>;
-      },
-    ): Promise<PreciseText | null>;
+        duration: number;
+      }> &
+      /**
+       * Additional parameters of PIXI.TextStyle which are applied to the text
+       * @remarks Excess keys are collected as `{...textStyle}` and passed to {@link PreciseText.getTextStyle} which checks for `!== undefined`, so this can't be NullishProps
+       */
+      InexactPartial<PIXI.ITextStyle>;
+
+    interface CreateScrollingTextOptions extends _CreateScrollingTextOptions {}
+
+    interface DrawOptions extends CanvasGroupMixin.DrawOptions {}
+
+    interface TearDownOptions extends CanvasGroupMixin.TearDownOptions {}
   }
 }
+
+declare abstract class AnyInterfaceCanvasGroup extends InterfaceCanvasGroup {
+  constructor(arg0: never, ...args: never[]);
+}

package/src/foundry/client/pixi/groups/overlay.d.mts

@@ -4,15 +4,27 @@ declare global {
   /**
    * A container group which is not bound to the stage world transform.
    */
-  class OverlayCanvasGroup extends CanvasGroupMixin(UnboundContainer) {
-    /**
-     * @defaultValue `"overlay"`
-     */
-    static override groupName: string;
-
+  class OverlayCanvasGroup<
+    DrawOptions extends OverlayCanvasGroup.DrawOptions = OverlayCanvasGroup.DrawOptions,
+    TearDownOptions extends OverlayCanvasGroup.TearDownOptions = OverlayCanvasGroup.TearDownOptions,
+  > extends CanvasGroupMixin<typeof UnboundContainer, "overlay">(UnboundContainer)<DrawOptions, TearDownOptions> {
     /**
+     * Should this group tear down its non-layer children?
      * @defaultValue `false`
      */
     static override tearDownChildren: boolean;
   }
+
+  namespace OverlayCanvasGroup {
+    interface Any extends AnyOverlayCanvasGroup {}
+    type AnyConstructor = typeof AnyOverlayCanvasGroup;
+
+    interface DrawOptions extends CanvasGroupMixin.DrawOptions {}
+
+    interface TearDownOptions extends CanvasGroupMixin.TearDownOptions {}
+  }
+}
+
+declare abstract class AnyOverlayCanvasGroup extends OverlayCanvasGroup {
+  constructor(arg0: never, ...args: never[]);
 }

package/src/foundry/client/pixi/groups/primary.d.mts

@@ -1,4 +1,4 @@
-import type { Renderer } from "pixi.js";
+import type { Brand, HandleEmptyObject } from "fvtt-types/utils";
 
 // Included to match Foundry's documented types
 type PrimaryCanvasObject = ReturnType<typeof PrimaryCanvasObjectMixin>;
@@ -9,7 +9,10 @@ declare global {
    * This group is a {@link CachedContainer} which is rendered to the Scene as a {@link SpriteMesh}.
    * This allows the rendered result of the Primary Canvas Group to be affected by a {@link BaseSamplerShader}.
    */
-  class PrimaryCanvasGroup extends CanvasGroupMixin(CachedContainer) {
+  class PrimaryCanvasGroup<
+    DrawOptions extends PrimaryCanvasGroup.DrawOptions = PrimaryCanvasGroup.DrawOptions,
+    TearDownOptions extends PrimaryCanvasGroup.TearDownOptions = PrimaryCanvasGroup.TearDownOptions,
+  > extends CanvasGroupMixin<typeof CachedContainer, "primary">(CachedContainer)<DrawOptions, TearDownOptions> {
     /**
      * @param sprite - (default: `new SpriteMesh(undefined, BaseSamplerShader)`)
      */
@@ -18,24 +21,19 @@ declare global {
     /**
      * Sort order to break ties on the group/layer level.
      */
-    static readonly SORT_LAYERS: {
-      SCENE: number;
-      TILES: number;
-      DRAWINGS: number;
-      TOKENS: number;
-      WEATHER: number;
-    };
+    static SORT_LAYERS: PrimaryCanvasGroup.Sort_Layers;
 
     /**
-     * @defaultValue `"primary"`
+     * @defaultValue
+     * ```js
+     * {
+     *   scaleMode: PIXI.SCALE_MODES.NEAREST,
+     *   format: PIXI.FORMATS.RGB,
+     *   multisample: PIXI.MSAA_QUALITY.NONE
+     * }
+     * ```
      */
-    static override groupName: string;
-
-    static override textureConfiguration: {
-      scaleMode: PIXI.SCALE_MODES;
-      format: PIXI.FORMATS;
-      multisample: PIXI.MSAA_QUALITY;
-    };
+    static override textureConfiguration: CachedContainer.TextureConfiguration;
 
     /**
      * @defaultValue `"none"`
@@ -45,12 +43,12 @@ declare global {
     /**
      * @defaultValue `[0, 0, 0, 0]`
      */
-    override clearColor: [r: number, g: number, b: number, a: number];
+    override clearColor: Color.RGBAColorVector;
 
     /**
      * The background color in RGB.
      */
-    _backgroundColor?: [red: number, green: number, blue: number];
+    _backgroundColor: Color.RGBColorVector | undefined;
 
     /**
      * Track the set of HTMLVideoElements which are currently playing as part of this group.
@@ -59,6 +57,7 @@ declare global {
 
     /**
      * Occludable objects above this elevation are faded on hover.
+     * @defaultValue `0`
      */
     hoverFadeElevation: number;
 
@@ -71,53 +70,52 @@ declare global {
     /**
      * The primary background image configured for the Scene, rendered as a SpriteMesh.
      */
-    background: SpriteMesh;
+    background: SpriteMesh | undefined;
 
     /**
      * The primary foreground image configured for the Scene, rendered as a SpriteMesh.
      */
-    foreground: SpriteMesh;
+    foreground: SpriteMesh | undefined;
 
     /**
      * A Quadtree which partitions and organizes primary canvas objects.
      */
-    quadtree: CanvasQuadtree;
+    quadtree: CanvasQuadtree<PrimaryCanvasObjectMixin.AnyMixed>;
 
     /**
      * The collection of PrimaryDrawingContainer objects which are rendered in the Scene.
+     * @privateRemarks Foundry types this as `Collection<PrimaryDrawingContainer>`, which doesn't exist. It's `PrimaryGraphics` in practice.
      */
     drawings: Collection<PrimaryGraphics>;
 
     /**
      * The collection of SpriteMesh objects which are rendered in the Scene.
+     * @privateRemarks Foundry types this as `Collection<TokenMesh>`, which doesn't exist. In practice it's `PrimarySpriteMesh`
      */
     tokens: Collection<PrimarySpriteMesh>;
 
     /**
      * The collection of SpriteMesh objects which are rendered in the Scene.
+     * @privateRemarks Foundry types this as `Collection<PrimarySpriteMesh | TileSprite>`, but `TileSprite` doens't exist. In practice it's all `PrimarySpriteMesh`.
      */
     tiles: Collection<PrimarySpriteMesh>;
 
     /**
      * The ambience filter which is applying post-processing effects.
      */
-    _ambienceFilter: PrimaryCanvasGroupAmbienceFilter;
-
-    /**
-     * Render all tokens in their own render texture.
-     * @param renderer - The renderer to use.
-     */
-    _renderTokens(renderer: PIXI.Renderer): void;
+    _ambienceFilter: PrimaryCanvasGroupAmbienceFilter | undefined;
 
     /**
      * Return the base HTML image or video element which provides the background texture.
+     * @privateRemarks Foundry does not indicate the possibility of a null return
      */
-    get backgroundSource(): HTMLImageElement | HTMLVideoElement;
+    get backgroundSource(): HTMLImageElement | HTMLVideoElement | null;
 
     /**
      * Return the base HTML image or video element which provides the foreground texture.
+     * @privateRemarks Foundry does not indicate the possibility of a null return
      */
-    get foregroundSource(): HTMLImageElement | HTMLVideoElement;
+    get foregroundSource(): HTMLImageElement | HTMLVideoElement | null;
 
     /**
      * Refresh the primary mesh.
@@ -129,61 +127,62 @@ declare global {
      */
     update(): void;
 
-    protected override _draw(options: CanvasGroupMixin.DrawOptions): Promise<void>;
+    protected override _draw(options: HandleEmptyObject<DrawOptions>): Promise<void>;
 
-    protected override _render(_renderer: Renderer): void;
+    protected override _render(_renderer: PIXI.Renderer): void;
 
-    protected override _tearDown(options: CanvasGroupMixin.TearDownOptions): Promise<void>;
+    protected override _tearDown(options: HandleEmptyObject<TearDownOptions>): Promise<void>;
 
     /**
      * Draw the SpriteMesh for a specific Token object.
      * @param token - The Token being added
      * @returns The added PrimarySpriteMesh
      */
-    addToken(token: Token): PrimarySpriteMesh;
+    addToken(token: Token.ConfiguredInstance): PrimarySpriteMesh;
 
     /**
      * Remove a TokenMesh from the group.
      * @param token - The Token being removed
      */
-    removeToken(token: Token): void;
+    removeToken(token: Token.ConfiguredInstance): void;
 
     /**
      * Draw the SpriteMesh for a specific Token object.
      * @param tile - The Tile being added
      * @returns The added PrimarySpriteMesh
      */
-    addTile(tile: Tile): PrimarySpriteMesh;
+    addTile(tile: Tile.ConfiguredInstance): PrimarySpriteMesh;
 
     /**
      * Remove a TokenMesh from the group.
      * @param tile - The Tile being removed
      */
-    removeTile(tile: Tile): void;
+    removeTile(tile: Tile.ConfiguredInstance): void;
 
     /**
      * Add a PrimaryGraphics to the group.
      * @param drawing - The Drawing being added
      * @returns The created PrimaryGraphics instance
      */
-    addDrawing(drawing: Drawing): PrimaryGraphics;
+    addDrawing(drawing: Drawing.ConfiguredInstance): PrimaryGraphics;
 
     /**
      * Remove a PrimaryGraphics from the group.
      * @param drawing - The Drawing being removed
      */
-    removeDrawing(drawing: Drawing): void;
+    removeDrawing(drawing: Drawing.ConfiguredInstance): void;
 
     /**
      * Override the default PIXI.Container behavior for how objects in this container are sorted.
-     * @override
+     * @remarks Actually an override of `PIXI.Container#sortChildren`
      */
     sortChildren(): void;
 
     /**
      * Handle mousemove events on the primary group to update the hovered state of its children.
+     * @remarks Foundry marked `@internal`
      */
-    protected _onMouseMove(): void;
+    _onMouseMove(): void;
 
     /**
      * @deprecated since v12, will be removed in v14
@@ -197,4 +196,27 @@ declare global {
      */
     mapElevationAlpha(elevation: number): number;
   }
+
+  namespace PrimaryCanvasGroup {
+    interface Any extends AnyPrimaryCanvasGroup {}
+    type AnyConstructor = typeof AnyPrimaryCanvasGroup;
+
+    interface DrawOptions extends CanvasGroupMixin.DrawOptions {}
+
+    interface TearDownOptions extends CanvasGroupMixin.TearDownOptions {}
+
+    type SORT_LAYERS = Brand<number, "PrimaryCanvasGroup.SORT_LAYERS">;
+
+    interface Sort_Layers {
+      readonly SCENE: 0 & SORT_LAYERS;
+      readonly TILES: 500 & SORT_LAYERS;
+      readonly DRAWINGS: 600 & SORT_LAYERS;
+      readonly TOKENS: 700 & SORT_LAYERS;
+      readonly WEATHER: 1000 & SORT_LAYERS;
+    }
+  }
+}
+
+declare abstract class AnyPrimaryCanvasGroup extends PrimaryCanvasGroup {
+  constructor(arg0: never, ...args: never[]);
 }

package/src/foundry/client/pixi/groups/rendered.d.mts

@@ -4,15 +4,27 @@ declare global {
   /**
    * A container group which contains the environment canvas group and the interface canvas group.
    */
-  class RenderedCanvasGroup extends CanvasGroupMixin(PIXI.Container) {
-    /**
-     * @defaultValue `"rendered"`
-     */
-    static override groupName: string;
-
+  class RenderedCanvasGroup<
+    DrawOptions extends RenderedCanvasGroup.DrawOptions = RenderedCanvasGroup.DrawOptions,
+    TearDownOptions extends RenderedCanvasGroup.TearDownOptions = RenderedCanvasGroup.TearDownOptions,
+  > extends CanvasGroupMixin<typeof PIXI.Container, "rendered">(PIXI.Container)<DrawOptions, TearDownOptions> {
     /**
+     * Should this group tear down its non-layer children?
      * @defaultValue `false`
      */
     static override tearDownChildren: boolean;
   }
+
+  namespace RenderedCanvasGroup {
+    interface Any extends AnyRenderedCanvasGroup {}
+    type AnyConstructor = typeof AnyRenderedCanvasGroup;
+
+    interface DrawOptions extends CanvasGroupMixin.DrawOptions {}
+
+    interface TearDownOptions extends CanvasGroupMixin.TearDownOptions {}
+  }
+}
+
+declare abstract class AnyRenderedCanvasGroup extends RenderedCanvasGroup {
+  constructor(arg0: never, ...args: never[]);
 }