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

package/src/foundry/client/game.d.mts

@@ -1,13 +1,7 @@
 import type { Socket } from "socket.io-client";
-import type {
-  ConfiguredDocumentClassForName,
-  ConfiguredModule,
-  GetKey,
-  ModuleRequiredOrOptional,
-} from "../../types/helperTypes.d.mts";
-import type { EmptyObject, ValueOf } from "../../types/utils.d.mts";
+import type { ConfiguredModule, GetKey, EmptyObject, ValueOf, FixedInstanceType } from "fvtt-types/utils";
 import type BasePackage from "../common/packages/base-package.d.mts";
-import type { Document } from "../common/abstract/module.d.mts";
+import type { Document } from "../common/abstract/_module.d.mts";
 
 interface EarlierEvents {
   none: never;
@@ -27,11 +21,14 @@ type GameInitialized<Data, MustRun extends InitializationEvent, RunEvents extend
 type HooksRan<T extends InitializationEvent> = EarlierEvents[T] | T;
 
 // May be called with just one hook.
-type MaybeInitialized<
+type MaybeInitialized<Data, MustRun extends InitializationEvent> = GameInitialized<
   Data,
-  MustRun extends InitializationEvent,
-  RunEvents extends InitializationEvent,
-> = GameInitialized<Data, MustRun, HooksRan<RunEvents>, Data | undefined>;
+  MustRun,
+  HooksRan<ValidHooksRan>,
+  Data | undefined
+>;
+
+type ValidHooksRan = Extract<keyof AssumeHookRan, InitializationEvent>;
 
 /**
  * @privateRemarks In v12 many of these properties were mistakenly stripped of their readonly quality;
@@ -473,8 +470,10 @@ declare class InternalGame<RunEvents extends InitializationEvent> {
 
   /**
    * The currently connected User entity, or null if Users is not yet initialized
+   *
+   * @remarks Initialized just before the `"setup"` hook event.
    */
-  get user(): Document.Stored<User.ConfiguredInstance> | null;
+  get user(): GameInitialized<Document.Stored<User.ConfiguredInstance>, "setup", RunEvents, null>;
 
   /**
    * A convenience accessor for the currently viewed Combat encounter
@@ -654,20 +653,23 @@ declare global {
        * @see {@link RequiredModules} to remove `undefined` from the return type for a given module
        * @param id - The module ID to look up
        */
-      get<T extends string>(id: T): (Module & ConfiguredModule<T>) | Exclude<ModuleRequiredOrOptional<T>, undefined>;
+      get<T extends string>(id: T): Module & ConfiguredModule<T>;
     }
 
     namespace Model {
       /**
        * Get the configured core and system type names for a specific document type.
        *
-       * Because of module subtypes, extra types of the form `${moduleName}.${subtype}` are always a possibility.
+       * Because of module subtypes, extra types of the form `${moduleName}.${subtype}` are
+       * possible when `hasTypeData` is true.
        *
        * @typeParam DocumentName - the type of the Document this data is for
        */
       type TypeNames<DocumentName extends Document.Type> =
         | (string & keyof Model[DocumentName])
-        | (`${string}.${string}` & {});
+        | (Document.Internal.SimpleMetadata<DocumentName> extends { readonly hasTypeData: true }
+            ? `${string}.${string}` & {}
+            : never);
     }
 
     type Model = {
@@ -751,10 +753,10 @@ declare global {
       userId: string;
       world: World["_source"];
     } & {
-      [DocumentType in
+      [DocumentType in  // eslint-disable-next-line @typescript-eslint/no-deprecated
         | foundry.CONST.DOCUMENT_TYPES
-        | "Setting" as ConfiguredDocumentClassForName<DocumentType>["metadata"]["collection"]]?: InstanceType<
-        ConfiguredDocumentClassForName<DocumentType>
+        | "Setting" as Document.ConfiguredClassForName<DocumentType>["metadata"]["collection"]]?: FixedInstanceType<
+        Document.ConfiguredClassForName<DocumentType>
       >["_source"][];
     };
 
@@ -769,16 +771,16 @@ declare global {
    * @defaultValue `undefined`
    * Initialized just before the `"init"` hook event.
    */
-  let canvas: MaybeInitialized<Canvas, "init", keyof AssumeHookRan>;
+  let canvas: MaybeInitialized<Canvas, "init">;
 
   /**
    * @defaultValue `undefined`
    * Initialized just before the `"ready"` hook event.
    */
-  let keyboard: MaybeInitialized<KeyboardManager, "ready", keyof AssumeHookRan>;
+  let keyboard: MaybeInitialized<KeyboardManager, "ready">;
 }
 
-type ConfiguredCollectionClassForName<Name extends foundry.CONST.DOCUMENT_TYPES> = InstanceType<
+type ConfiguredCollectionClassForName<Name extends foundry.CONST.WORLD_DOCUMENT_TYPES> = FixedInstanceType<
   CONFIG[Name]["collection"]
 >;
 

package/src/foundry/client/head.d.mts

@@ -1,3 +1,4 @@
+import type { FixedInstanceType } from "fvtt-types/utils";
 import type { EarlierEvents, InitializationEvent } from "./game.d.mts";
 
 type ValidRanHooks = Extract<keyof AssumeHookRan, InitializationEvent>;
@@ -16,9 +17,9 @@ interface Games {
 }
 
 // Needs to include the current hook as well as all hooks that can run after it.
-type GameHooks = Exclude<InitializationEvent, EarlierEvents[keyof AssumeHookRan]>;
+type GameHooks = Exclude<InitializationEvent, EarlierEvents[ValidRanHooks]>;
 
-type MaybeUI = Extract<keyof AssumeHookRan, "ready"> extends never ? Partial<UiApplications> : UiApplications;
+type MaybeUI = Extract<ValidRanHooks, "ready"> extends never ? Partial<UiApplications> : UiApplications;
 
 declare global {
   /**
@@ -48,7 +49,11 @@ declare global {
    * Critical server-side startup messages which need to be displayed to the client.
    */
   let MESSAGES:
-    | { type: Notifications.Notification["type"]; message: string; options: Notifications.NotifyOptions }[]
+    | {
+        type: foundry.applications.ui.Notifications.Type;
+        message: string;
+        options: foundry.applications.ui.Notifications.NotifyOptions;
+      }[]
     | null;
 
   /**
@@ -60,14 +65,14 @@ declare global {
   let ui: {
     /**
      * @remarks
-     * Initialized whenever a {@link ContextMenu} is opened, deleted when it's closed again.
+     * Initialized whenever a {@link foundry.applications.ux.ContextMenu | `ContextMenu`} is opened, deleted when it's closed again.
      */
-    context?: ContextMenu;
+    context?: foundry.applications.ux.ContextMenu;
 
     /**
      * @defaultValue `{}`
      */
-    windows: Record<number, Application>;
+    windows: Record<number, Application.Any>;
   } & MaybeUI;
 
   /**
@@ -82,5 +87,5 @@ declare global {
 }
 
 type UiApplications = {
-  [Key in keyof CONFIG["ui"]]: InstanceType<CONFIG["ui"][Key]>;
+  [Key in keyof CONFIG["ui"]]: FixedInstanceType<CONFIG["ui"][Key]>;
 };

package/src/foundry/client/hooks.d.mts

@@ -1,11 +1,8 @@
 import type { EditorState, Plugin } from "prosemirror-state";
-import type { DeepPartial, EmptyObject, ValueOf } from "../../types/utils.d.mts";
+import type { DeepPartial, EmptyObject, FixedInstanceType, ValueOf } from "fvtt-types/utils";
 import type Document from "../common/abstract/document.d.mts";
 import type { EffectChangeData } from "../common/documents/_types.d.mts";
 import type { ProseMirrorDropDown } from "../common/prosemirror/menu.d.mts";
-import type { DropData } from "./data/abstract/client-document.d.mts";
-
-// eslint-disable-next-line import/no-named-as-default
 import type ProseMirrorMenu from "../common/prosemirror/menu.d.mts";
 import type PointVisionSource from "../client-esm/canvas/sources/point-vision-source.d.mts";
 import type RenderedEffectSource from "../client-esm/canvas/sources/rendered-effect-source.d.mts";
@@ -209,7 +206,7 @@ declare global {
        * @remarks An explicit return value of `false` prevents the Document being created.
        * @see {@link Hotbar#_onDrop}
        */
-      hotbarDrop: (hotbar: Hotbar, data: DropData<Macro.ConfiguredInstance>, slot: number) => boolean | void;
+      hotbarDrop: (hotbar: Hotbar, data: Document.DropData<Macro.ConfiguredInstance>, slot: number) => boolean | void;
 
       /**
        * A hook event that fires when the SceneNavigation menu is expanded or collapsed.
@@ -248,7 +245,7 @@ declare global {
        * @remarks This is called by {@link Hooks.call}.
        * @see {@link ActiveEffect#_applyCustom}
        */
-      applyActiveEffect: (actor: Actor.ConfiguredInstance, change: EffectChangeData) => boolean | void;
+      applyActiveEffect: (actor: Actor.ConfiguredInstance, change: ActiveEffect.EffectChangeData) => boolean | void;
 
       /** Compendium */
 
@@ -351,7 +348,7 @@ declare global {
        * @param options - Options for rendering the associated {@link JournalSheet}
        * @remarks This is called by {@link Hooks.call}.
        */
-      activateNote: (note: Note.ConfiguredInstance, options: JournalSheet.RenderOptions) => boolean | false;
+      activateNote: (note: Note.ConfiguredInstance, options: JournalSheet.RenderOptions) => true | false;
 
       /** Cards */
 
@@ -708,8 +705,8 @@ declare global {
         messageData: {
           message: Document.ToObjectFalseType<ChatMessage.ConfiguredInstance>;
           user: Game["user"];
-          author: ChatMessage.ConfiguredInstance["user"];
-          alias: ChatMessage.ConfiguredInstance["alias"];
+          author: User.ConfiguredInstance | null;
+          alias: string;
           cssClass: string;
           isWhisper: boolean;
           canDelete: boolean;
@@ -781,21 +778,27 @@ declare global {
 
       /**
        * A hook event that fires when the context menu for a SceneNavigation entry is constructed.
-       * @param html         - The HTML element to which the context options are attached
+       * @param app          - The Application instance that the context menu is constructed in
        * @param entryOptions - The context menu entries
        * @remarks This is called by {@link Hooks.call}.
        * @see {@link SceneNavigation#activateListeners}
        */
-      getSceneNavigationContext: (html: JQuery, entryOptions: ContextMenuEntry[]) => boolean | void;
+      getSceneNavigationContext: (
+        app: foundry.applications.ui.SceneNavigation,
+        contextOptions: foundry.applications.ux.ContextMenu.Entry<HTMLElement>[],
+      ) => boolean | void;
 
       /**
        * A hook event that fires when the context menu for a PlayersList entry is constructed.
-       * @param html         - The HTML element to which the context options are attached
-       * @param entryOptions - The context menu entries
+       * @param app            - The Application instance that the context menu is constructed in
+       * @param contextOptions - The context menu entries
        * @remarks This is called by {@link Hooks.call}.
        * @see {@link PlayerList#activateListeners}
        */
-      getUserContextOptions: (html: JQuery, entryOptions: ContextMenuEntry[]) => boolean | void;
+      getUserContextOptions: (
+        app: foundry.applications.ui.Players,
+        contextOptions: foundry.applications.ux.ContextMenu.Entry<HTMLElement>[],
+      ) => boolean | void;
     }
 
     /** Application */
@@ -813,11 +816,11 @@ declare global {
      * @remarks This is called by {@link Hooks.callAll}.
      * @see {@link Application#_render}
      */
-    type RenderApplication<A extends Application = Application> = (
+    type RenderApplication<A extends Application.Any = Application.Any> = (
       app: A,
       html: JQuery,
       data: ReturnType<A["getData"]> extends Promise<infer T> ? T : ReturnType<A["getData"]>,
-    ) => boolean | void;
+    ) => void;
 
     /**
      * A hook event that fires whenever this Application is first rendered to add buttons to its header.
@@ -829,7 +832,7 @@ declare global {
      * @remarks This is called by {@link Hooks.call}.
      * @see {@link Application#_getHeaderButtons}
      */
-    type GetApplicationHeaderButtons<A extends Application = Application> = (
+    type GetApplicationHeaderButtons<A extends Application.Any = Application.Any> = (
       app: A,
       buttons: Application.HeaderButton[],
     ) => boolean | void;
@@ -840,10 +843,22 @@ declare global {
      * @param html  - The application HTML when it is closed
      * @typeParam A - the type of the Application
      * @remarks The name for this hook is dynamically created by joining "close" with the type name of the Application.
-     * @remarks This is called by {@link Hooks.call}.
+     * @remarks This is called by {@link Hooks.callAll}.
      * @see {@link Application#close}
      */
-    type CloseApplication<A extends Application = Application> = (app: A, html: JQuery) => boolean | void;
+    type CloseApplication<A extends Application.Any = Application.Any> = (app: A, html: JQuery) => void;
+
+    /** ApplicationV2 */
+
+    // Not explicitly typed in Foundry v12 but still fires
+    type RenderApplicationV2<
+      A extends foundry.applications.api.ApplicationV2.Any = foundry.applications.api.ApplicationV2.Any,
+    > = (app: A, element: HTMLElement) => void;
+
+    // Not explicitly typed in Foundry v12 but still fires
+    type CloseApplicationV2<
+      A extends foundry.applications.api.ApplicationV2.Any = foundry.applications.api.ApplicationV2.Any,
+    > = (app: A) => void;
 
     /** EffectsCanvasGroup */
 
@@ -852,18 +867,14 @@ declare global {
      * The dispatched event name replaces "Group" with the named CanvasGroup subclass, i.e. "drawPrimaryCanvasGroup".
      * @param group - The group being drawn
      */
-    type DrawGroup<
-      G extends ReturnType<typeof CanvasGroupMixin> = ReturnType<typeof CanvasGroupMixin<CanvasGroupMixin.BaseClass>>,
-    > = (group: G) => void;
+    type DrawGroup<G extends CanvasGroupMixin.AnyMixed = CanvasGroupMixin.AnyMixed> = (group: G) => void;
 
     /**
      * A hook event that fires when a {@link CanvasGroup} is deconstructed.
      * The dispatched event name replaces "Group" with the named CanvasGroup subclass, i.e. "tearDownPrimaryCanvasGroup".
      * @param group - The group being deconstructed
      */
-    type TearDownGroup<
-      G extends ReturnType<typeof CanvasGroupMixin> = ReturnType<typeof CanvasGroupMixin<CanvasGroupMixin.BaseClass>>,
-    > = (group: G) => void;
+    type TearDownGroup<G extends CanvasGroupMixin.AnyMixed = CanvasGroupMixin.AnyMixed> = (group: G) => void;
 
     /** CanvasLayer */
 
@@ -983,7 +994,7 @@ declare global {
     type PreCreateDocument<D extends Document.AnyConstructor = Document.AnyConstructor> = (
       document: Document.ToConfiguredInstance<D>,
       data: ConstructorParameters<D>[0],
-      options: Document.PreCreateOptions<InstanceType<D>["documentName"]>,
+      options: Document.PreCreateOptions<FixedInstanceType<D>["documentName"]>,
       userId: string,
     ) => boolean | void;
 
@@ -1009,7 +1020,7 @@ declare global {
     type PreUpdateDocument<D extends Document.AnyConstructor = Document.AnyConstructor> = (
       document: Document.ToConfiguredInstance<D>,
       changed: DeepPartial<ConstructorParameters<D>[0]>,
-      options: Document.PreUpdateOptions<InstanceType<D>["documentName"]>,
+      options: Document.PreUpdateOptions<FixedInstanceType<D>["documentName"]>,
       userId: string,
     ) => boolean | void;
 
@@ -1033,7 +1044,7 @@ declare global {
      */
     type PreDeleteDocument<D extends Document.AnyConstructor = Document.AnyConstructor> = (
       document: Document.ToConfiguredInstance<D>,
-      options: Document.PreDeleteOptions<InstanceType<D>["documentName"]>,
+      options: Document.PreDeleteOptions<FixedInstanceType<D>["documentName"]>,
       userId: string,
     ) => boolean | void;
 
@@ -1053,7 +1064,7 @@ declare global {
      */
     type CreateDocument<D extends Document.AnyConstructor = Document.AnyConstructor> = (
       document: Document.ToConfiguredInstance<D>,
-      options: Document.OnCreateOptions<InstanceType<D>["documentName"]>,
+      options: Document.OnCreateOptions<FixedInstanceType<D>["documentName"]>,
       userId: string,
     ) => void;
 
@@ -1075,7 +1086,7 @@ declare global {
     type UpdateDocument<D extends Document.AnyConstructor = Document.AnyConstructor> = (
       document: Document.ToConfiguredInstance<D>,
       change: DeepPartial<ConstructorParameters<D>[0]>,
-      options: Document.OnUpdateOptions<InstanceType<D>["documentName"]>,
+      options: Document.OnUpdateOptions<FixedInstanceType<D>["documentName"]>,
       userId: string,
     ) => void;
 
@@ -1095,7 +1106,7 @@ declare global {
      */
     type DeleteDocument<D extends Document.AnyConstructor = Document.AnyConstructor> = (
       document: Document.ToConfiguredInstance<D>,
-      options: Document.OnDeleteOptions<InstanceType<D>["documentName"]>,
+      options: Document.OnDeleteOptions<FixedInstanceType<D>["documentName"]>,
       userId: string,
     ) => void;
 
@@ -1134,36 +1145,45 @@ declare global {
      * A hook event that fires when the context menu for entries in an Application is constructed. Substitute the
      * Application name in the hook event to target a specific Application, for example
      * "getActorDirectoryEntryContext".
-     * @param html         - The HTML element to which the context options are attached
+     * @param app          - The Application instance that the context menu is constructed in
      * @param entryOptions - The context menu entries
      * @remarks This is called by {@link Hooks.call}.
      * @see {@link ContextMenu.create}
      */
-    type GetEntryContext = (html: JQuery, entryOptions: ContextMenuEntry[]) => boolean | void;
+    type GetEntryContext = (
+      app: Application.Any | foundry.applications.api.ApplicationV2.Any,
+      entryOptions: foundry.applications.ux.ContextMenu.Entry<HTMLElement | JQuery>[],
+    ) => boolean | void;
 
     /**
      * A hook event that fires when the context menu for a Sound in the PlaylistDirectory is constructed.
-     * @param html         - The HTML element to which the context options are attached
+     * @param app          - The Application instance that the context menu is constructed in
      * @param entryOptions - The context menu entries
      * @remarks The name for this hook is dynamically created by joining "get" with the type name of the PlaylistDirectory
      * and "SoundContext".
      * @remarks This is called by {@link Hooks.call}.
      * @see {@link PlaylistDirectory#_contextMenu}
      */
-    type GetPlaylistDirectorySoundContext = (html: JQuery, entryOptions: ContextMenuEntry[]) => boolean | void;
+    type GetSoundContextPlaylistDirectory = (
+      app: foundry.applications.sidebar.tabs.PlaylistDirectory,
+      entryOptions: foundry.applications.ux.ContextMenu.Entry<HTMLElement>[],
+    ) => boolean | void;
 
     /**
      * A hook event that fires when the context menu for folders in a SidebarTab
      * is constructed. Substitute the SidebarTab name in the hook event to target
      * a specific SidebarTab, for example "getActorDirectoryFolderContext".
-     * @param html         - The HTML element to which the context options are attached
+     * @param app          - The Application instance that the context menu is constructed in
      * @param entryOptions - The context menu entries
      * @remarks The name for this hook is dynamically created by joining "get" with the type name of the SidebarDirectory
      * and "FolderContext".
      * @remarks This is called by {@link Hooks.call}.
      * @see {@link SidebarDirectory#_contextMenu}
      */
-    type GetSidebarDirectoryFolderContext = (html: JQuery, entryOptions: ContextMenuEntry[]) => boolean | void;
+    type GetSidebarDirectoryFolderContext = (
+      app: foundry.applications.sidebar.DocumentDirectory,
+      entryOptions: foundry.applications.ux.ContextMenu.Entry<HTMLElement>[],
+    ) => boolean | void;
 
     type DynamicCallbacks =
       | RenderApplication
@@ -1188,9 +1208,8 @@ declare global {
       | ActivateLayer
       | DeactivateLayer
       | GetEntryContext
-      | GetPlaylistDirectorySoundContext
-      | GetSidebarDirectoryFolderContext
-      | HoverObject;
+      | GetSoundContextPlaylistDirectory
+      | GetSidebarDirectoryFolderContext;
 
     interface ErrorCallbackParameters {
       "Canvas#draw": [location: "Canvas#draw", err: Error, data: { layer: CanvasLayer }];

package/src/foundry/client/pixi/board.d.mts

@@ -1,4 +1,4 @@
-import type { InexactPartial, NullishProps } from "../../../types/utils.d.mts";
+import type { InexactPartial, NullishProps, FixedInstanceType } from "fvtt-types/utils";
 import type Document from "../../common/abstract/document.d.mts";
 import type { CANVAS_PERFORMANCE_MODES } from "../../common/constants.d.mts";
 
@@ -6,7 +6,7 @@ type InternalCanvas = new (
   arg0: never,
   ...args: never[]
 ) => {
-  readonly [K in keyof CONFIG.Canvas.Groups]?: InstanceType<CONFIG.Canvas.Groups[K]["groupClass"]> | undefined;
+  readonly [K in keyof CONFIG.Canvas.Groups]?: FixedInstanceType<CONFIG.Canvas.Groups[K]["groupClass"]> | undefined;
 };
 
 declare const _InternalCanvas: InternalCanvas;
@@ -167,7 +167,7 @@ declare global {
     /**
      * The singleton FogManager instance.
      */
-    fog: FogManager;
+    fog: FixedInstanceType<typeof CONFIG.Canvas.fogManager>;
 
     /**
      * A perception manager interface for batching lighting, sight, and sound updates
@@ -444,6 +444,8 @@ declare global {
 
     readonly notes?: NotesLayer;
 
+    readonly regions?: RegionLayer;
+
     readonly controls?: ControlsLayer;
 
     /**
@@ -650,8 +652,8 @@ declare global {
      * Track objects which have pending render flags.
      */
     readonly pendingRenderFlags: {
-      OBJECTS: Set<InstanceType<ReturnType<typeof RenderFlagsMixin>>>;
-      PERCEPTION: Set<InstanceType<ReturnType<typeof RenderFlagsMixin>>>;
+      OBJECTS: Set<FixedInstanceType<ReturnType<typeof RenderFlagsMixin>>>;
+      PERCEPTION: Set<FixedInstanceType<ReturnType<typeof RenderFlagsMixin>>>;
     };
 
     /**
@@ -776,8 +778,12 @@ declare global {
     /**
      * A single point, expressed as an array \[x,y\]
      * @remarks Copied from `resources/app/common/types.mjs`
+     *
+     * Renamed from `PointArray` to avoid confusion (for `[{x,y},{x,y}]` for example)
      */
-    type PointArray = [x: number, y: number];
+    type PointTuple = [x: number, y: number];
+
+    type PairOfPointsTuple = [x0: number, y0: number, x1: number, y1: number];
 
     /**
      * A standard rectangle interface.

package/src/foundry/client/pixi/core/containers/base-canvas-group.d.mts

@@ -1,22 +1,39 @@
-import type { AnyObject, Mixin } from "../../../../../types/utils.d.mts";
+import type { FixedInstanceType, HandleEmptyObject, PrettifyType, RemoveIndexSignatures } from "fvtt-types/utils";
 
-declare class CanvasGroup {
-  /** @privateRemarks All mixin classses should accept anything for its constructor. */
-  constructor(...args: any[]);
+declare const DynamicClass: new <_Computed extends object>(arg0: never, ...args: never[]) => _Computed;
 
-  /** @defaultValue `true` */
-  sortableChildren: boolean;
+// @ts-expect-error - This is a workaround to allow for dynamic top level properties in a class.
+declare class LayersClass<
+  Group extends CanvasGroupMixin.LayerGroup | NoLayerGroup,
+  Instance extends object = RemoveIndexSignatures<CanvasGroupMixin.LayersFor<Group>>,
+> extends DynamicClass<Instance> {}
 
+// Note(LukeAbby): This interface has been separated out to simplify the constructor edge cases.
+// By avoiding having the instance side it makes the class more malleable and allows generics.
+interface CanvasGroupStatic<Group extends CanvasGroupMixin.LayerGroup | NoLayerGroup> {
   /**
    * The name of this canvas group
    * @remarks Foundry marked as abstract
    */
-  static groupName: string;
+  groupName: Group extends NoLayerGroup ? undefined : Group;
 
   /**
    * If this canvas group should teardown non-layers children.
+   * @defaultValue `true`
    */
-  static tearDownChildren: boolean;
+  tearDownChildren: boolean;
+}
+
+declare class CanvasGroup<
+  Group extends CanvasGroupMixin.LayerGroup | NoLayerGroup,
+  DrawOptions extends CanvasGroupMixin.DrawOptions = CanvasGroupMixin.DrawOptions,
+  TearDownOptions extends CanvasGroupMixin.TearDownOptions = CanvasGroupMixin.TearDownOptions,
+> extends LayersClass<Group> {
+  /** @privateRemarks All mixin classses should accept anything for its constructor. */
+  constructor(...args: any[]);
+
+  /** @defaultValue `true` */
+  sortableChildren: boolean;
 
   /**
    * The canonical name of the canvas group is the name of the constructor that is the immediate child of the defined base class.
@@ -31,53 +48,107 @@ declare class CanvasGroup {
 
   /**
    * A mapping of CanvasLayer classes which belong to this group.
-   * @remarks Default value defined by this._createLayers, which pulls from CONFIG.Canvas.layers
+   * @remarks Default value defined by this._createLayers, which is called in the constructor, and   pulls from CONFIG.Canvas.layers
    */
-  layers: Record<string, CanvasLayer>;
+  layers: CanvasGroupMixin.LayersFor<Group>;
 
   /**
    * Create CanvasLayer instances which belong to the canvas group.
    */
-  _createLayers(): Record<string, CanvasLayer>;
+  protected _createLayers(): CanvasGroupMixin.LayersFor<Group>;
 
   /** Draw the canvas group and all its component layers. */
-  draw(options: CanvasGroupMixin.DrawOptions): Promise<void>;
+  draw(options?: HandleEmptyObject<DrawOptions>): Promise<this>;
 
   /**
    * Draw the canvas group and all its component layers.
    */
-  protected _draw(options: CanvasGroupMixin.DrawOptions): Promise<void>;
+  protected _draw(options?: HandleEmptyObject<DrawOptions>): Promise<void>;
 
   /**
    * Remove and destroy all layers from the base canvas.
    */
-  tearDown(options: CanvasGroupMixin.TearDownOptions): Promise<void>;
+  tearDown(options: HandleEmptyObject<TearDownOptions>): Promise<this>;
 
   /**
    * Remove and destroy all layers from the base canvas.
    */
-  protected _tearDown(options: CanvasGroupMixin.TearDownOptions): Promise<void>;
+  protected _tearDown(options: HandleEmptyObject<TearDownOptions>): Promise<void>;
 }
 
+declare const _NoLayerGroup: unique symbol;
+type NoLayerGroup = typeof _NoLayerGroup;
+
+type ApplyGroup<
+  BaseClass extends CanvasGroupMixin.BaseClass,
+  Group extends CanvasGroupMixin.LayerGroup | NoLayerGroup,
+> = CanvasGroupStatic<Group> &
+  (new <DrawOptions extends CanvasGroupMixin.DrawOptions, TearDownOptions extends CanvasGroupMixin.TearDownOptions>(
+    ...args: ConstructorParameters<BaseClass>
+  ) => CanvasGroup<Group, DrawOptions, TearDownOptions> & FixedInstanceType<BaseClass>);
+
 declare global {
   /**
    * A mixin which decorates any container with base canvas common properties.
    * @param ContainerClass - The parent Container class being mixed.
    * @returns A ContainerClass subclass mixed with BaseCanvasMixin features.
    */
-  function CanvasGroupMixin<BaseClass extends CanvasGroupMixin.BaseClass>(
-    ContainerClass: BaseClass,
-  ): Mixin<typeof CanvasGroup, BaseClass>;
+  function CanvasGroupMixin<
+    BaseClass extends CanvasGroupMixin.BaseClass,
+    // In `_createLayers` the code assigns top level properties to the class.
+    // This is why Group exists.`
+    Group extends CanvasGroupMixin.LayerGroup | NoLayerGroup = NoLayerGroup,
+  >(ContainerClass: BaseClass): CanvasGroupMixin.Mixed<BaseClass, Group>;
 
-  namespace CanvasGroupMixin {
-    type BaseClass = typeof AnyPIXIContainer;
-
-    type DrawOptions = AnyObject;
+  /**
+   * @deprecated since v12, until 14
+   * @remarks "BaseCanvasMixin is deprecated in favor of CanvasGroupMixin"
+   */
+  const BaseCanvasMixin: typeof CanvasGroupMixin;
 
-    type TearDownOptions = AnyObject;
+  namespace CanvasGroupMixin {
+    type AnyMixedConstructor = ReturnType<
+      typeof CanvasGroupMixin<CanvasGroupMixin.BaseClass, CanvasGroupMixin.LayerGroup | NoLayerGroup>
+    >;
+    interface AnyMixed extends FixedInstanceType<AnyMixedConstructor> {}
+
+    type BaseClass = PIXI.Container.AnyConstructor;
+
+    type Mixed<
+      BaseClass extends CanvasGroupMixin.BaseClass,
+      Group extends CanvasGroupMixin.LayerGroup | NoLayerGroup,
+    > = BaseClass & ApplyGroup<BaseClass, Group>;
+
+    // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+    interface DrawOptions {}
+
+    // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+    interface TearDownOptions {}
+
+    interface Layers {
+      readonly [key: string]: CanvasLayer;
+    }
+
+    type LayerGroup = keyof CONFIG["Canvas"]["groups"];
+
+    type LayersFor<T extends LayerGroup | NoLayerGroup> = PrettifyType<
+      _FilterOutNever<{
+        readonly [K in keyof typeof Canvas.layers]: (typeof Canvas.layers)[K] extends {
+          readonly layerClass?: abstract new (...args: infer _1) => infer LayerInstance extends CanvasLayer;
+          readonly group?: T;
+        }
+          ? LayerInstance
+          : never;
+      }>
+    >;
+
+    /** @internal */
+    type _FilterOutNever<T> = {
+      [K in keyof T as [T[K]] extends [never] ? never : K]: T[K];
+    };
   }
 }
 
-declare abstract class AnyPIXIContainer extends PIXI.Container<any> {
+declare abstract class AnyCanvasGroup extends CanvasGroup<NoLayerGroup> {
   constructor(arg0: never, ...args: never[]);
 }