@league-of-foundry-developers/foundry-vtt-types 13.340.0 → 13.345.1-beta.20250704.94554

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

@@ -1,22 +1,987 @@
 import type { EditorState, Plugin } from "prosemirror-state";
-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 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";
-import type { CompendiumArtInfo } from "../client-esm/helpers/_types.d.mts";
+import type { DeepPartial, EmptyObject, ValueOf } from "#utils";
+import type Document from "#common/abstract/document.d.mts";
+import type { ProseMirrorDropDown } from "#common/prosemirror/_module.d.mts";
+import type ProseMirrorMenu from "#common/prosemirror/menu.d.mts";
+import type PointVisionSource from "#client/canvas/sources/point-vision-source.d.mts";
+import type RenderedEffectSource from "#client/canvas/sources/rendered-effect-source.d.mts";
+import type {
+  DatabaseCreateOperation,
+  DatabaseDeleteOperation,
+  DatabaseUpdateOperation,
+} from "#common/abstract/_types.d.mts";
+import type CompendiumArt from "#client/helpers/media/compendium-art.d.mts";
+import type { Hooks as HookConfigs } from "#configuration";
+import type Hooks from "./helpers/hooks.d.mts";
+import type { Canvas } from "#client/canvas/_module.d.mts";
+import type { CanvasGroupMixin, CanvasVisibility, EffectsCanvasGroup } from "#client/canvas/groups/_module.d.mts";
+import type * as layers from "#client/canvas/layers/_module.d.mts";
+
+import type { Note, PlaceableObject, Token } from "#client/canvas/placeables/_module.d.mts";
+import type { TokenRingConfig } from "#client/canvas/placeables/tokens/_module.d.mts";
+
+import AVSettings = foundry.av.AVSettings;
+import Application = foundry.appv1.api.Application;
+import ApplicationV2 = foundry.applications.api.ApplicationV2;
+import ContextMenu = foundry.applications.ux.ContextMenu;
+
+type ApplicationConfig = HookConfigs.ApplicationConfig;
+type ApplicationV2Config = HookConfigs.ApplicationV2Config;
+type PlaceableObjectConfig = HookConfigs.PlaceableObjectConfig;
+type CanvasGroupConfig = HookConfigs.CanvasGroupConfig;
+type CanvasLayerConfig = HookConfigs.CanvasLayerConfig;
+type InteractionLayerConfig = HookConfigs.InteractionLayerConfig;
+type PlaceablesLayerConfig = HookConfigs.PlaceablesLayerConfig;
+
+// TODO(LukeAbby): Add warning for invalid configuration.
+// Grabs only valid items.
+type ApplicationName = {
+  [K in keyof ApplicationConfig]: K extends string ? (ApplicationConfig[K] extends Application.Any ? K : never) : never;
+}[keyof ApplicationConfig];
+
+type RenderApplicationHooks = {
+  [K in ApplicationName as `render${K}`]: Hooks.RenderApplication<ApplicationConfig[K]>;
+};
+
+type GetApplicationHeaderButtonsHooks = {
+  [K in ApplicationName as `get${K}HeaderButtons`]: Hooks.RenderApplication<ApplicationConfig[K]>;
+};
+
+type CloseApplicationHooks = {
+  [K in ApplicationName as `close${K}`]: Hooks.RenderApplication<ApplicationConfig[K]>;
+};
+
+type GetApplicationEntryContextHooks = {
+  [K in ApplicationName as `get${K}EntryContext`]: Hooks.GetEntryContext<ApplicationConfig[K]>;
+};
+
+interface ApplicationHooks
+  extends RenderApplicationHooks,
+    GetApplicationHeaderButtonsHooks,
+    CloseApplicationHooks,
+    GetApplicationEntryContextHooks {}
+
+// TODO(LukeAbby): Add warning for invalid configuration.
+// Grabs only valid items.
+type ApplicationV2Name = {
+  [K in keyof ApplicationV2Config]: K extends string
+    ? ApplicationV2Config[K] extends ApplicationV2.Any
+      ? K
+      : never
+    : never;
+}[keyof ApplicationV2Config];
+
+type RenderApplicationV2Hooks = {
+  [K in ApplicationV2Name as `render${K}`]: Hooks.RenderApplicationV2<ApplicationV2Config[K]>;
+};
+
+type GetHeaderControlsApplicationV2Hooks = {
+  [K in ApplicationV2Name as `getHeaderControls${K}`]: Hooks.GetHeaderControlsApplicationV2<ApplicationV2Config[K]>;
+};
+
+type GetApplicationV2ContextOptionsHooks = {
+  [K in ApplicationV2Name as `get${K}ContextOptions`]: Hooks.GetApplicationV2ContextOptions<ApplicationV2Config[K]>;
+};
+
+type CloseApplicationV2Hooks = {
+  [K in ApplicationV2Name as `close${K}`]: Hooks.CloseApplicationV2<ApplicationV2Config[K]>;
+};
+
+interface ApplicationV2Hooks
+  extends RenderApplicationV2Hooks,
+    GetHeaderControlsApplicationV2Hooks,
+    GetApplicationV2ContextOptionsHooks,
+    CloseApplicationV2Hooks {}
+
+type PreCreateDocumentHooks = {
+  [K in Document.Type as `preCreate${K}`]: Hooks.PreCreateDocument<Document.ImplementationFor<K>>;
+};
+
+type CreateDocumentHooks = {
+  [K in Document.Type as `create${K}`]: Hooks.CreateDocument<Document.ImplementationFor<K>>;
+};
+
+type PreUpdateDocumentHooks = {
+  [K in Document.Type as `preUpdate${K}`]: Hooks.PreCreateDocument<Document.ImplementationFor<K>>;
+};
+
+type UpdateDocumentHooks = {
+  [K in Document.Type as `update${K}`]: Hooks.UpdateDocument<Document.ImplementationFor<K>>;
+};
+
+type PreDeleteDocumentHooks = {
+  [K in Document.Type as `preDelete${K}`]: Hooks.PreDeleteDocument<Document.ImplementationFor<K>>;
+};
+
+type DeleteDocumentHooks = {
+  [K in Document.Type as `delete${K}`]: Hooks.DeleteDocument<Document.ImplementationFor<K>>;
+};
+
+interface DocumentHooks
+  extends PreCreateDocumentHooks,
+    CreateDocumentHooks,
+    PreUpdateDocumentHooks,
+    UpdateDocumentHooks,
+    PreDeleteDocumentHooks,
+    DeleteDocumentHooks {}
+
+// TODO(LukeAbby): Add warning for invalid configuration.
+// Grabs only valid items.
+type PlaceableObjectName = {
+  [K in keyof PlaceableObjectConfig]: K extends string
+    ? PlaceableObjectConfig[K] extends PlaceableObject.Any
+      ? K
+      : never
+    : never;
+}[keyof PlaceableObjectConfig];
+
+type DrawObjectHooks = {
+  [K in PlaceableObjectName as `draw${K}`]: Hooks.DrawObject<PlaceableObjectConfig[K]>;
+};
+
+type RefreshObjectHooks = {
+  [K in PlaceableObjectName as `refresh${K}`]: Hooks.RefreshObject<PlaceableObjectConfig[K]>;
+};
+
+type DestroyObjectHooks = {
+  [K in PlaceableObjectName as `destroy${K}`]: Hooks.DestroyObject<PlaceableObjectConfig[K]>;
+};
+
+type ControlObjectHooks = {
+  [K in PlaceableObjectName as `control${K}`]: Hooks.ControlObject<PlaceableObjectConfig[K]>;
+};
+
+type HoverObjectHooks = {
+  [K in PlaceableObjectName as `hover${K}`]: Hooks.HoverObject<PlaceableObjectConfig[K]>;
+};
+
+interface PlaceableObjectHooks
+  extends DrawObjectHooks,
+    RefreshObjectHooks,
+    DestroyObjectHooks,
+    ControlObjectHooks,
+    HoverObjectHooks {}
+
+// TODO(LukeAbby): Add warning for invalid configuration.
+// Grabs only valid items.
+type CanvasGroupName = {
+  [K in keyof CanvasGroupConfig]: K extends string
+    ? CanvasGroupConfig[K] extends CanvasGroupMixin.AnyMixed
+      ? K
+      : never
+    : never;
+}[keyof CanvasGroupConfig];
+
+type DrawCanvasGroupHooks = {
+  [K in CanvasGroupName as `draw${K}`]: Hooks.DrawGroup<CanvasGroupConfig[K]>;
+};
+
+type TearDownCanvasGroupHooks = {
+  [K in CanvasGroupName as `tearDown${K}`]: Hooks.TearDownGroup<CanvasGroupConfig[K]>;
+};
+
+interface CanvasGroupHooks extends DrawCanvasGroupHooks, TearDownCanvasGroupHooks {}
+
+// These configs are separate for convenience but they're all `CanvasLayer`s.
+interface AllCanvasLayers extends CanvasLayerConfig, InteractionLayerConfig, PlaceablesLayerConfig {}
+
+// TODO(LukeAbby): Add warning for invalid configuration.
+// Grabs only valid items.
+type CanvasLayerName = {
+  [K in keyof AllCanvasLayers]: K extends string
+    ? AllCanvasLayers[K] extends layers.CanvasLayer.Any
+      ? K
+      : never
+    : never;
+}[keyof AllCanvasLayers];
+
+type DrawCanvasLayerHooks = {
+  [K in CanvasLayerName as `draw${K}`]: Hooks.DrawLayer<AllCanvasLayers[K]>;
+};
+
+type TearDownCanvasLayerHooks = {
+  [K in CanvasLayerName as `tearDown${K}`]: Hooks.TearDownLayer<AllCanvasLayers[K]>;
+};
+
+interface CanvasLayerHooks extends DrawCanvasLayerHooks, TearDownCanvasLayerHooks {}
+
+// These configs are separate for convenience but they're both `CanvasLayer`s.
+interface AllInteractionLayers extends InteractionLayerConfig, PlaceablesLayerConfig {}
+
+// TODO(LukeAbby): Add warning for invalid configuration.
+// Grabs only valid items.
+type InteractionLayerName = {
+  [K in keyof AllInteractionLayers]: K extends string
+    ? AllInteractionLayers[K] extends layers.InteractionLayer.Any
+      ? K
+      : never
+    : never;
+}[keyof AllInteractionLayers];
+
+type ActivateInteractionLayerHooks = {
+  [K in InteractionLayerName as `activate${K}`]: Hooks.ActivateLayer<AllInteractionLayers[K]>;
+};
+
+type DeactivateInteractionLayerHooks = {
+  [K in InteractionLayerName as `deactivate${K}`]: Hooks.DeactivateLayer<AllInteractionLayers[K]>;
+};
+
+interface ActivateCanvasLayerHook {
+  // Foundry does not document.
+  activateCanvasLayer: (layer: AllInteractionLayers[InteractionLayerName]) => void;
+}
+
+interface InteractionLayerHooks
+  extends ActivateInteractionLayerHooks,
+    DeactivateInteractionLayerHooks,
+    ActivateCanvasLayerHook {}
+
+// TODO(LukeAbby): Add warning for invalid configuration.
+// Grabs only valid items.
+type PlaceableLayerName = {
+  [K in keyof PlaceablesLayerConfig]: K extends string
+    ? PlaceablesLayerConfig[K] extends layers.PlaceablesLayer.Any
+      ? K
+      : never
+    : never;
+}[keyof PlaceablesLayerConfig];
+
+type PastePlaceableLayerHooks = {
+  [K in PlaceableLayerName as `paste${layers.PlaceablesLayer.DocumentNameOf<PlaceablesLayerConfig[K]>}`]: Hooks.PastePlaceableObject<
+    layers.PlaceablesLayer.ObjectOf<PlaceablesLayerConfig[K]>
+  >;
+};
+
+interface PlaceableLayerHooks extends PastePlaceableLayerHooks {}
+
+interface DynamicHooks
+  extends ApplicationHooks,
+    ApplicationV2Hooks,
+    DocumentHooks,
+    PlaceableObjectHooks,
+    CanvasGroupHooks,
+    CanvasLayerHooks,
+    InteractionLayerHooks,
+    PlaceableLayerHooks {}
+
+export interface AllHooks extends DynamicHooks {
+  /** Core lifecycle */
+
+  /**
+   * A hook event that fires as Foundry is initializing, right before any initialization tasks have begun.
+   * @remarks This is called by {@linkcode Hooks.callAll}.
+   * @see {@link Game.initialize | `Game#initialize`}
+   */
+  init: () => void;
+
+  /**
+   * A hook event that fires once Localization translations have been loaded and are ready for use.
+   * @remarks This is called by {@linkcode Hooks.callAll}.
+   * @see {@link Localization.initialize | `Localization#initialize`}
+   */
+  i18nInit: () => void;
+
+  /**
+   * A hook event that fires when Foundry has finished initializing but
+   * before the game state has been set up. Fires before any Documents, UI
+   * applications, or the Canvas have been initialized.
+   * @remarks This is called by {@linkcode Hooks.callAll}.
+   * @see {@link Game.setupGame | `Game#setupGame`}
+   */
+  setup: () => void;
+
+  /**
+   * A hook event that fires when the game is fully ready.
+   * @remarks This is called by {@linkcode Hooks.callAll}.
+   * @see {@link Game.setupGame | `Game#setupGame`}
+   */
+  ready: () => void;
+
+  /**
+   * A hook event that fires whenever foundry experiences an error.
+   *
+   * @param location - The method where the error was caught.
+   * @param err      - The error.
+   * @param data     - Additional data that might be provided, based on the nature of the error.
+   *                   (default: `{}`)
+   * @remarks This is called by {@linkcode Hooks.callAll}.
+   * @see {@linkcode Hooks.onError}
+   */
+  error: (...args: ValueOf<Hooks.ErrorCallbackParameters>) => void;
+
+  /** Game */
+
+  /**
+   * A hook event that fires when the game is paused or un-paused.
+   * @param paused  - Is the game now paused (true) or un-paused (false)
+   * @param options - Options which modified the pause game request
+   * @remarks
+   * @see {@link Game.togglePause | `Game#togglePause`}
+   */
+  pauseGame: (paused: boolean, pauseOptions: foundry.Game.TogglePauseOptions) => void;
+
+  /**
+   * A hook event that fires when the World time has been updated.
+   * @param worldTime - The new canonical World time
+   * @param delta     - The time delta
+   * @param options   - Options passed from the requesting client where the change was made
+   * @param userId    - The ID of the User who advanced the time
+   * @remarks This is called by {@linkcode Hooks.callAll}.
+   * @see {@link GameTime.onUpdateWorldTime | `GameTime#onUpdateWorldTime`}
+   */
+  updateWorldTime: (
+    worldTime: number,
+    delta: number,
+    options: Setting.Database.UpdateOperation,
+    userId: string,
+  ) => void;
+
+  /** CanvasLifecycle */
+
+  /**
+   * A hook event that fires immediately prior to PIXI Application construction with the configuration parameters.
+   * @param canvasConfig - Canvas configuration parameters that will be used to initialize the PIXI.Application
+   * @remarks This is called by {@linkcode Hooks.callAll}.
+   */
+  canvasConfig: (canvasConfig: ConstructorParameters<typeof PIXI.Application>[0]) => void;
+
+  /**
+   * A hook event that fires when the Canvas is initialized.
+   * @param canvas - the Canvas instance being initialized
+   * @remarks This is called by {@linkcode Hooks.callAll}.
+   * @see {@link Canvas.draw | `Canvas#draw`}
+   */
+  canvasInit: (canvas: Canvas) => void;
+
+  /**
+   * A hook event that fires when the Canvas is panned.
+   * @param canvas - The Canvas instance
+   * @param view   - The applied camera position
+   * @remarks When called during animated panning, the callback is called on every tick.
+   * @remarks This is called by {@linkcode Hooks.callAll}.
+   * @see {@link Canvas.pan | `Canvas#pan`}
+   * @see {@link Canvas.animatePan | `Canvas#animatePan`}
+   */
+  canvasPan: (canvas: Canvas, view: Canvas.ViewPosition) => void;
+
+  /**
+   * A hook event that fires when the Canvas is ready.
+   * @param canvas - The Canvas which is now ready for use
+   * @remarks This is called by {@linkcode Hooks.call}.
+   * @see {@link Canvas.draw | `Canvas#draw`}
+   */
+  canvasReady: (canvas: Canvas) => boolean | void;
+
+  /**
+   * A hook event that fires when the Canvas is deactivated.
+   * @param canvas - The Canvas instance being deactivated
+   * @remarks This is called by {@linkcode Hooks.callAll}.
+   */
+  canvasTearDown: (canvas: Canvas) => void;
+
+  /**
+   * A hook event that fires when the Canvas is beginning to draw the canvas groups.
+   * @param canvas - The Canvas instance being drawn
+   * @remarks This is called by {@linkcode Hooks.callAll}.
+   */
+  canvasDraw: (canvas: Canvas) => void;
+
+  /**
+   * A hook event that fires when some useful data is dropped onto the Canvas.
+   * @param canvas - The Canvas
+   * @param data   - The data that has been dropped onto the Canvas
+   * @remarks This is called by {@linkcode Hooks.call}.
+   * @remarks An explicit return value of `false` prevents the Document being created.
+   * @see `Canvas.#_onDrop`
+   */
+  dropCanvasData: (canvas: Canvas, data: Hooks.DropData, event: DragEvent) => boolean | void;
+
+  /**
+   * A hook event that fires when objects are highlighted on the canvas.
+   * Callers may use this hook to apply their own modifications or enhancements to highlighted objects.
+   * @param active - Is the highlight state now active
+   * @see {@link Canvas.highlightObjects | `Canvas#highlightObjects``}
+   */
+  highlightObjects: (active: boolean) => void;
+
+  /** Application */
+
+  /**
+   * A hook event that fires when the Scene controls are initialized.
+   * @param controls - The SceneControl configurations
+   * @remarks This is called by {@linkcode Hooks.callAll}.
+   * @see {@link SceneControls._getControlButtons | `SceneControls#_getControlButtons`}
+   * TODO: This saw a major rework in v13 and needs individual attention
+   */
+  // getSceneControlButtons: (controls: foundry.applications.ui.SceneControls.Control[]) => void;
+
+  /**
+   * A hook event that fires whenever data is dropped into a Hotbar slot.
+   * The hook provides a reference to the Hotbar application, the dropped data, and the target slot.
+   * Default handling of the drop event can be prevented by returning false within the hooked function.
+   * @param hotbar - The Hotbar application instance
+   * @param data   - The dropped data object
+   * @param slot   - The target hotbar slot
+   * @remarks This is called by {@linkcode Hooks.call}.
+   * @remarks An explicit return value of `false` prevents the Document being created.
+   * @see {@link Hotbar._onDrop | `Hotbar#_onDrop`}
+   */
+  hotbarDrop: (hotbar: foundry.applications.ui.Hotbar, data: Macro.DropData, slot: number) => boolean | void;
+
+  /**
+   * A hook event that fires when the SceneNavigation menu is expanded or collapsed.
+   * @param nav       - The SceneNavigation application
+   * @param collapsed - Whether the navigation is now collapsed or not
+   * @remarks This is called by {@linkcode Hooks.callAll}.
+   * @see {@link SceneNavigation.expand | `SceneNavigation#expand`}
+   * @see {@link SceneNavigation.collapse | `SceneNavigation#collapse`}
+   */
+  collapseSceneNavigation: (nav: foundry.applications.ui.SceneNavigation, collapsed: boolean) => void;
+
+  /**
+   * A hook event that fires when the Sidebar is collapsed or expanded.
+   * @param sidebar   - The Sidebar application
+   * @param collapsed - Whether the Sidebar is now collapsed or not
+   * @remarks This is called by {@linkcode Hooks.callAll}.
+   * @see {@link Sidebar.expand | `Sidebar#expand`}
+   * @see {@link Sidebar.collapse | `Sidebar#collapse`}
+   */
+  collapseSidebar: (sidebar: foundry.applications.sidebar.Sidebar, collapsed: boolean) => void;
+
+  /**
+   * A hook event that fires when the Sidebar tab is changed.
+   * @param app - The SidebarTab application which is now active
+   * @remarks This is called by {@linkcode Hooks.callAll}.
+   * @see {@link Sidebar._onChangeTab | `Sidebar#_onChangeTab`}
+   */
+  changeSidebarTab: (app: foundry.applications.sidebar.AbstractSidebarTab) => void;
+
+  /** Active Effects */
+
+  /**
+   * A hook event that fires when a custom active effect is applied.
+   * @param actor  - The actor the active effect is being applied to
+   * @param change - The change data being applied
+   * @remarks This is called by {@linkcode Hooks.call}.
+   * @see {@link ActiveEffect._applyCustom | `ActiveEffect#_applyCustom`}
+   */
+  applyActiveEffect: (actor: Actor.Implementation, change: ActiveEffect.ChangeData) => boolean | void;
+
+  /** Compendium */
+
+  /**
+   * A hook event that fires whenever the contents of a Compendium pack were modified.
+   * This hook fires for all connected clients after the update has been processed.
+   *
+   * @param pack      - The Compendium pack being modified
+   * @param documents - The locally-cached Documents which were modified in the operation
+   * @param options   - Additional options which modified the modification request
+   * @param userId    - The ID of the User who triggered the modification workflow
+   * @remarks This is called by {@linkcode Hooks.callAll}.
+   * @see {@link foundry.documents.collections.CompendiumCollection._onModifyContents | `foundry.documents.collections.CompendiumCollection#_onModifyContents`}
+   */
+  updateCompendium: (
+    pack: foundry.documents.collections.CompendiumCollection.Any,
+    documents: Document.Any[],
+    options: Document.Database.UpdateOptions<DatabaseUpdateOperation>,
+    userId: string,
+  ) => void;
+
+  /** Token */
+
+  /**
+   * A hook event that fires when a token {@linkcode Token} should apply a specific status effect.
+   * @param token    - The token affected
+   * @param statusId - The status effect ID being applied, from CONFIG.specialStatusEffects.
+   * @param active   - Is the special status effect now active?
+   */
+  applyTokenStatusEffect: (token: Token.Implementation, statusId: string, active: boolean) => void;
+
+  /**
+   * A hook event that fires when a chat bubble is initially configured.
+   * @param token   - The speaking token
+   * @param html    - The HTML of the chat bubble
+   * @param message - The spoken message text
+   * @param options - Provided options which affect bubble appearance
+   * @returns May return false to prevent the calling workflow
+   */
+  chatBubbleHTML: (
+    token: Token.Implementation,
+    html: HTMLElement,
+    message: string,
+    options: foundry.canvas.animation.ChatBubbles.Options,
+  ) => boolean | void;
+
+  /**
+   * A hook event that fires when a token's resource bar attribute has been modified.
+   * @param data    - A object describing the modification
+   * @param updates - The update delta that will be applied to the Token's actor
+   * @returns whether the Actor should be updated
+   * @remarks This is called by {@linkcode Hooks.call}.
+   * @see {@link Actor.modifyTokenAttribute | `Actor#modifyTokenAttribute`}
+   * @see {@link Actor.update | `Actor#update`}
+   */
+  modifyTokenAttribute: (data: Actor.ModifyTokenAttributeData, updates: Record<string, number>) => boolean;
+
+  /**
+   * A hook event that fires when a token is targeted or un-targeted.
+   * @param user     - The User doing the targeting
+   * @param token    - The targeted Token
+   * @param targeted - Whether the Token has been targeted or untargeted
+   * @remarks This is called by {@linkcode Hooks.callAll}.
+   * @see {@link UserTargets._hook | `UserTargets#_hook`}
+   */
+  targetToken: (user: User.Implementation, token: Token.Implementation, targeted: boolean) => void;
+
+  /** Note */
+
+  /**
+   * A hook event that fires whenever a map note is double-clicked.
+   * The hook provides the note placeable and the arguments passed to the associated {@linkcode JournalSheet} render call.
+   * Hooked functions may modify the render arguments or cancel the render by returning false.
+   * @param note    - The note that was activated
+   * @param options - Options for rendering the associated {@linkcode JournalSheet}
+   * @remarks This is called by {@linkcode Hooks.call}.
+   */
+  activateNote: (
+    note: Note.Implementation,
+    options:
+      | foundry.appv1.sheets.JournalSheet.Options
+      | foundry.applications.sheets.journal.JournalEntrySheet.RenderOptions,
+  ) => true | false;
+
+  /** Cards */
+
+  /**
+   * A hook event that fires when Cards are dealt from a deck to other hands
+   * @param origin             - The origin Cards document
+   * @param destinations       - An array of destination Cards documents
+   * @param context            - Additional context which describes the operation
+   * @remarks This is called by {@linkcode Hooks.call}.
+   * @remarks An explicit return value of `false` prevents the operation.
+   */
+  dealCards: (
+    origin: Cards.Implementation,
+    destinations: Cards.Implementation[],
+    context: Cards.DealContext,
+  ) => boolean | void;
+
+  /**
+   * A hook event that fires when Cards are passed from one stack to another
+   * @param origin      - The origin Cards document
+   * @param destination - The destination Cards document
+   * @param context     - Additional context which describes the operation
+   * @remarks This is called by {@linkcode Hooks.call}.
+   * @remarks An explicit return value of `false` prevents the operation.
+   */
+  passCards: (
+    origin: Cards.Implementation,
+    destination: Cards.Implementation,
+    context: Cards.PassContext,
+  ) => boolean | void;
+
+  /**
+   * A hook event that fires when a stack of Cards are returned to the decks they originally came from.
+   * @param origin   - The origin Cards document.
+   * @param returned - The cards being returned.
+   * @param context  - Additional context which describes the operation.
+   */
+  returnCards: (
+    origin: Cards.Implementation,
+    returned: Card.Implementation[],
+    context: Cards.ReturnContext,
+  ) => boolean | void;
+
+  /** Actor */
+
+  /**
+   * A hook even that fires when package-provided art is applied to a compendium Document.
+   * @param documentClass - The Document class.
+   * @param source        - The Document's source data.
+   * @param pack          - The Document's compendium.
+   * @param art           - The art being applied.
+   * @remarks Called as part of _initializeSource, after data migration, cleaning, and shims
+   * @remarks Currently only called by Actor but comments are more generic
+   * @remarks This is called by {@linkcode Hooks.callAll}.
+   */
+  applyCompendiumArt: (
+    documentClass: Actor.ImplementationClass,
+    source: foundry.documents.BaseActor.CreateData,
+    pack: foundry.documents.collections.CompendiumCollection.Any,
+    art: CompendiumArt.Info,
+  ) => void;
+
+  /** ActorSheet */
+
+  /**
+   * A hook event that fires when some useful data is dropped onto an ActorSheet.
+   * @param actor - The Actor
+   * @param sheet - The ActorSheet application
+   * @param data  - The data that has been dropped onto the sheet
+   * @remarks This is called by {@linkcode Hooks.call}.
+   * @remarks An explicit return value of `false` prevents the Document being created.
+   * @see {@link ActorSheet._onDrop | `ActorSheet#_onDrop`}
+   */
+  dropActorSheetData: (
+    actor: Actor.Implementation,
+    sheet: foundry.appv1.sheets.ActorSheet.Any | foundry.applications.sheets.ActorSheetV2.Any,
+    data: foundry.appv1.sheets.ActorSheet.DropData,
+  ) => boolean | void;
+
+  /** CanvasVisibility */
+
+  /**
+   * A hook event that fires when the set of vision sources are initialized.
+   * @param sources - The collection of current vision sources
+   * @remarks This is called by {@linkcode Hooks.call}.
+   */
+  initializeVisionSources: (sources: Collection<PointVisionSource.Any>) => void;
+
+  /**
+   * A hook event that fires when the LightingLayer is refreshed.
+   * @param layer - the LightingLayer
+   * @remarks This is called by {@linkcode Hooks.callAll}.
+   * @see {@link LightingLayer.refresh | `LightingLayer#refresh`}
+   */
+  lightingRefresh: (layer: layers.LightingLayer) => void;
+
+  /**
+   * A hook event that fires when visibility is refreshed.
+   * @param visibility - The CanvasVisibility instance
+   * @remarks This is called by {@linkcode Hooks.callAll}.
+   */
+  visibilityRefresh: (visibility: CanvasVisibility) => void;
+
+  /**
+   * A hook event that fires during light source initialization.
+   * This hook can be used to add programmatic light sources to the Scene.
+   * @param source - The EffectsCanvasGroup where light sources are initialized
+   * @remarks This is called by {@linkcode Hooks.callAll}.
+   * @see {@link EffectsCanvasGroup.initializeLightSources | `EffectsCanvasGroup#initializeLightSources`}
+   */
+  initializeLightSources: (group: EffectsCanvasGroup) => void;
+
+  /**
+   * A hook event that fires during darkness source initialization.
+   * This hook can be used to add programmatic darkness sources to the Scene.
+   * @param group - The EffectsCanvasGroup where darkness sources are initialized
+   * @remarks This is called by {@linkcode Hooks.callAll}.
+   */
+  initializeDarknessSources: (group: EffectsCanvasGroup) => void;
+
+  /**
+   * A hook event that fires when the CanvasVisibility layer has been refreshed.
+   * @param visibility - The CanvasVisibility layer
+   * @remarks This is called by {@linkcode Hooks.callAll}.
+   * @see {@link CanvasVisibility.restrictVisibility | `CanvasVisibility#restrictVisibility`}
+   */
+  sightRefresh: (visibility: CanvasVisibility) => void;
+
+  /** Weather */
+
+  /**
+   * Initialize the weather container from a weather config object.
+   * @param weatherEffect        - The weather effects canvas layer
+   * @param weatherEffectsConfig - The weather effects config object
+   * @remarks This is called by {@linkcode Hooks.callAll}.
+   */
+  initializeWeatherEffects: (
+    weatherEffect: layers.WeatherEffects,
+    weatherEffectsConfig?: layers.WeatherEffects.EffectConfiguration | null,
+  ) => void;
+
+  /** Adventure */
+
+  /**
+   * A hook event that fires when Adventure data is being prepared for import.
+   * Modules may return false from this hook to take over handling of the import workflow.
+   * @param adventure - The Adventure document from which content is being imported
+   * @param formData  - Processed data from the importer form
+   * @param toCreate  - Adventure data which needs to be created in the World
+   * @param toUpdate  - Adventure data which needs to be updated in the World
+   * @returns False to prevent the core software from handling the import
+   * @remarks This is called by {@linkcode Hooks.call}.
+   */
+  preImportAdventure: (
+    adventure: Adventure.Implementation,
+    formData: Adventure.ImportOptions,
+    toCreate: Adventure.ImportData["toCreate"],
+    toUpdate: Adventure.ImportData["toUpdate"],
+  ) => boolean | void;
+
+  /**
+   * A hook event that fires after an Adventure has been imported into the World.
+   * @param adventure - The Adventure document from which content is being imported
+   * @param formData  - Processed data from the importer form
+   * @param toCreate  - Adventure data which needs to be created in the World
+   * @param toUpdate  - Adventure data which needs to be updated in the World
+   * @returns False to prevent the core software from handling the import
+   * @remarks This is called by {@linkcode Hooks.callAll}.
+   */
+  importAdventure: (
+    adventure: Adventure.Implementation,
+    formData: Adventure.ImportOptions,
+    created: Adventure.ImportResult["created"],
+    updated: Adventure.ImportResult["updated"],
+  ) => void;
+
+  /** Socket */
+
+  /**
+   * A hook event that fires whenever some other User joins or leaves the game session.
+   * @param user      - The User who connected or disconnected
+   * @param connected - Is the user now connected (true) or disconnected (false)
+   * @remarks This is called by {@linkcode Hooks.callAll}.
+   */
+  userConnected: (user: User.Implementation, connected: boolean) => void;
+
+  /** Combat */
+
+  /**
+   *  A hook event which fires when the turn order of a Combat encounter is progressed.
+   * This event fires on all clients after the database update has occurred for the Combat.
+   * @param combat  - The Combat encounter for which the turn order has changed
+   * @param prior   - The prior turn state
+   * @param current - The new turn state
+   * @remarks This is called by {@linkcode Hooks.callAll}.
+   */
+  combatTurnChange: (combat: Combat.Implementation, prior: Combat.HistoryData, current: Combat.HistoryData) => void;
+
+  /**
+   * A hook event that fires when a Combat encounter is started.
+   * This event fires on the initiating client before any database update occurs.
+   * @param combat     - The Combat encounter which is starting
+   * @param updateData - An object which contains Combat properties that will be updated. Can be mutated.
+   */
+  combatStart: (
+    combat: Combat.Implementation,
+    updateData: {
+      /** The initial round */
+      round: number;
+
+      /** The initial turn */
+      turn: number;
+    },
+  ) => void;
+
+  /**
+   * A hook event that fires when the turn of the Combat encounter changes.
+   * This event fires on the initiating client before any database update occurs.
+   * @param combat        - The Combat encounter which is advancing or rewinding its turn
+   * @param updateData    - An object which contains Combat properties that will be updated. Can be mutated.
+   * @param updateOptions - An object which contains options provided to the update method. Can be mutated.
+   */
+  combatTurn: (
+    combat: Combat.Implementation,
+    updateData: {
+      /** The current round of combat */
+      round: number;
+
+      /** The new turn number */
+      turn: number;
+    },
+    updateOptions: {
+      /** The amount of time in seconds that time is being advanced */
+      advanceTime: number;
+
+      /** A signed integer for whether the turn order is advancing or rewinding */
+      direction: number;
+    },
+  ) => void;
+
+  /**
+   * A hook event that fires when the round of the Combat encounter changes.
+   * @param combat        - The Combat encounter which is advancing or rewinding its round
+   * @param updateData    - An object which contains Combat properties that will be updated. Can be mutated.
+   * @param updateOptions - An object which contains options provided to the update method. Can be mutated.
+   */
+  combatRound: (
+    combat: Combat.Implementation,
+    updateData: {
+      /** The new round of combat */
+      round: number;
+
+      /** The new turn number */
+      turn: number;
+    },
+    updateOptions: {
+      /** The amount of time in seconds that time is being advanced */
+      advanceTime: number;
+
+      /** A signed integer for whether the turn order is advancing or rewinding */
+      direction: number;
+    },
+  ) => void;
+
+  /**
+   * A hook even that fires when a ProseMirrorMenu's drop-downs are initialized.
+   * The hook provides the ProseMirrorMenu instance and an object of drop-down configuration data.
+   * Hooked functions may append their own drop-downs or append entries to existing drop-downs.
+   * @param menu   - The ProseMirrorMenu instance.
+   * @param config - The drop-down config.
+   * @remarks This is called by {@linkcode Hooks.callAll}.
+   */
+  getProseMirrorMenuDropdowns: (
+    menu: ProseMirrorMenu,
+    config: {
+      format: ProseMirrorDropDown.Config;
+      fonts: ProseMirrorDropDown.Config;
+    },
+  ) => void;
+
+  /**
+   * A hook even that fires when a ProseMirrorMenu's buttons are initialized.
+   * The hook provides the ProseMirrorMenu instance and an array of button configuration data.
+   * Hooked functions may append their own buttons to the list.
+   * @param menu   - The ProseMirrorMenu instance
+   * @param config - The button configuration objects
+   * @remarks This is called by {@linkcode Hooks.callAll}.
+   */
+  // TODO: Having trouble finding the appropriate typing for the menu items? Also, where is this even called?
+  getProseMirrorMenuItems: (menu: ProseMirrorMenu, config: unknown[]) => void;
+
+  /**
+   * A hook event that fires whenever a ProseMirror editor is created.
+   * The hook provides the ProseMirror instance UUID, a list of plugins, and an object containing the provisional
+   * editor state, and a reference to the menu plugin.
+   * Hooked functions may append their own plugins or replace the state or menu plugin by replacing their references
+   * in the final argument.
+   *
+   * @param uuid    - A UUID that uniquely identifies this ProseMirror instance.
+   * @param plugins - A list of plugins that will be loaded.
+   * @param options - The provisional EditorState and ProseMirrorMenuPlugin.
+   * @remarks This is called by {@linkcode Hooks.callAll}.
+   * @see {@linkcode ProseMirrorEditor.create}
+   */
+  createProseMirrorEditor: (uuid: string, plugins: Record<string, Plugin>, options: { state: EditorState }) => void;
+
+  streamReady: () => void;
+
+  /**
+   * A hook event that fires when a package that is being watched by the hot reload system has a file changed.
+   * The hook provides the hot reload data related to the file change.
+   * Hooked functions may intercept the hot reload and prevent the core software from handling it by returning false.
+   * @param data - The hot reload data
+   * @remarks This is called by {@linkcode Hooks.call}.
+   */
+  hotReload: (data: Hooks.HotReloadData) => boolean | void;
+
+  /**
+   * A hook event that fires when a user sends a message through the ChatLog.
+   * @param chatLog  - The ChatLog instance
+   * @param message  - The trimmed message content
+   * @param chatData - The basic chat data
+   * @remarks This is called by {@linkcode Hooks.call}.
+   * @remarks An explicit return value of `false` prevents the chat message from being created.
+   * @see {@link ChatLog.processMessage | `ChatLog#processMessage`}
+   */
+  chatMessage: (
+    chatLog: foundry.applications.sidebar.tabs.ChatLog,
+    message: string,
+    chatData: {
+      /** The id of the User sending the message */
+      user: string;
+
+      /** The identified speaker data, see {@linkcode ChatMessage.getSpeaker} */
+      speaker: ReturnType<ChatMessage.ImplementationClass["getSpeaker"]>;
+    },
+  ) => boolean | void;
+
+  /**
+   * A hook event that fires for each ChatMessage which is rendered for addition to the ChatLog.
+   * This hook allows for final customization of the message HTML before it is added to the log.
+   * @param message - The ChatMessage document being rendered.
+   * @param html    - The pending HTML.
+   * @param context - The rendering context.
+   */
+  renderChatMessageHTML: (
+    message: ChatMessage.Implementation,
+    html: HTMLElement,
+    context: ChatMessage.MessageData,
+  ) => void;
+
+  /** Audio-Video */
+
+  // Individually implemented all three options for globalVolumeChanged
+
+  /**
+   * A hook event that fires when the user modifies a global volume slider.
+   * @param volume - The new volume level
+   * @remarks This is called by {@linkcode Hooks.callAll}.
+   * @see {@link AudioHelper._onChangeGlobalVolume | `AudioHelper#_onChangeGlobalVolume`}
+   */
+  globalAmbientVolumeChanged: (volume: number) => void;
+
+  /**
+   * A hook event that fires when the user modifies a global volume slider.
+   * @param volume - The new volume level
+   * @remarks This is called by {@linkcode Hooks.callAll}.
+   * @see {@link AudioHelper._onChangeGlobalVolume | `AudioHelper#_onChangeGlobalVolume`}
+   */
+  globalInterfaceVolumeChanged: (volume: number) => void;
+
+  /**
+   * A hook event that fires when the user modifies a global volume slider.
+   * @param volume - The new volume level
+   * @remarks This is called by {@linkcode Hooks.callAll}.
+   * @see {@link AudioHelper._onChangeGlobalVolume | `AudioHelper#_onChangeGlobalVolume`}
+   */
+  globalPlaylistVolumeChanged: (volume: number) => void;
+
+  /**
+   * A hook event that fires when the AV settings are changed.
+   * @param settings - The AVSettings manager
+   * @param changed  - The delta of the settings that have been changed
+   * @remarks This is called by {@linkcode Hooks.callAll}.
+   * @see {@link AVSettings._onSettingsChanged | `AVSettings#_onSettingsChanged`}
+   */
+  rtcSettingsChanged: (settings: AVSettings, changed: DeepPartial<AVSettings.Settings>) => void;
+
+  /** RollTableConfig */
+
+  /**
+   * A hook event that fires when some useful data is dropped onto a RollTableConfig.
+   * @param table  - The RollTable
+   * @param config - The RollTableConfig application
+   * @param data   - The data dropped onto the RollTableConfig
+   * @remarks This is called by {@linkcode Hooks.call}.
+   * @remarks An explicit return value of `false` prevents the Document being created.
+   * @see {@link RollTableConfig._onDrop | `RollTableConfig#_onDrop`}
+   */
+  dropRollTableSheetData: (
+    table: RollTable.Implementation,
+    config: foundry.applications.sheets.RollTableSheet.Any,
+    data: object,
+  ) => boolean | void;
+
+  /**
+   * A hook event that allows to pass custom dynamic ring configurations.
+   * @param ringConfig - The ring configuration instance
+   * @remarks This is called by {@linkcode Hooks.callAll}.
+   */
+  initializeDynamicTokenRingConfig: (ringConfig: TokenRingConfig) => void;
+
+  /**
+   * A hook event that fires when the context menu for a PlayersList entry is constructed.
+   * @param app            - The Application instance that the context menu is constructed in
+   * @param contextOptions - The context menu entries
+   * @remarks This is called by {@linkcode Hooks.call}.
+   * @see {@link PlayerList.activateListeners | `PlayerList#activateListeners`}
+   */
+  getUserContextOptions: (
+    app: foundry.applications.ui.Players,
+    contextOptions: ContextMenu.Entry<HTMLElement>[],
+  ) => boolean | void;
+}
 
 declare global {
   /**
-   * This namespace contains typescript specific type definitions for the {@link Hooks} callback functions. It contains an
-   * interface ({@link Hooks.StaticCallbacks}) for callbacks with static names. There are more function types in the
-   * namespace for the dynamic hooks, whose names are generated at runtime. There is also a union of all of the dynamic
-   * hooks ({@link Hooks.DynamicCallbacks}).
+   * This namespace contains typescript specific type definitions for the {@linkcode Hooks} callback functions. It contains an
+   * interface ({@linkcode Hooks.StaticCallbacks}) for callbacks with static names. There are more function types in the
+   * namespace for the dynamic hooks, whose names are generated at runtime.
    *
-   * Callback types remarked to be called with {@link Hooks.callAll} do not care about the return value of the callback.
-   * Callback types remarked to be called with {@link Hooks.call} do care about the return value and will stop executing
+   * Callback types remarked to be called with {@linkcode Hooks.callAll} do not care about the return value of the callback.
+   * Callback types remarked to be called with {@linkcode Hooks.call} do care about the return value and will stop executing
    * remaining callbacks if `false` is returned. If a callback type does not have such a remark, pay attention to the
    * return value documentation.
    *
@@ -48,789 +1013,104 @@ declare global {
    * ```
    */
   namespace Hooks {
-    interface OnOptions {
-      /** Only trigger the hooked function once */
-      once?: boolean;
-    }
+    interface HotReloadData {
+      /** The type of package which was modified */
+      packageType: string;
+
+      /** The id of the package which was modified */
+      packageId: string;
+
+      /** The updated stringified file content */
+      content: string;
 
-    interface StaticCallbacks {
-      /** Core lifecycle */
-
-      /**
-       * A hook event that fires as Foundry is initializing, right before any initialization tasks have begun.
-       * @remarks This is called by {@link Hooks.callAll}.
-       * @see {@link Game#initialize}
-       */
-      init: () => void;
-
-      /**
-       * A hook event that fires once Localization translations have been loaded and are ready for use.
-       * @remarks This is called by {@link Hooks.callAll}.
-       * @see {@link Localization#initialize}
-       */
-      i18nInit: () => void;
-
-      /**
-       * A hook event that fires when Foundry has finished initializing but
-       * before the game state has been set up. Fires before any Documents, UI
-       * applications, or the Canvas have been initialized.
-       * @remarks This is called by {@link Hooks.callAll}.
-       * @see {@link Game#setupGame}
-       */
-      setup: () => void;
-
-      /**
-       * A hook event that fires when the game is fully ready.
-       * @remarks This is called by {@link Hooks.callAll}.
-       * @see {@link Game#setupGame}
-       */
-      ready: () => void;
-
-      /**
-       * A hook event that fires whenever foundry experiences an error.
-       *
-       * @param location - The method where the error was caught.
-       * @param err      - The error.
-       * @param data     - Additional data that might be provided, based on the nature of the error.
-       *                   (default: `{}`)
-       * @remarks This is called by {@link Hooks.callAll}.
-       * @see {@link Hooks.onError}
-       */
-      error: (...args: ValueOf<ErrorCallbackParameters>) => void;
-
-      /** Game */
-
-      /**
-       * A hook event that fires when the game is paused or un-paused.
-       * @param paused - Is the game now paused (true) or un-paused (false)
-       * @remarks This is called by {@link Hooks.callAll}.
-       * @see {@link Game#togglePause}
-       */
-      pauseGame: (paused: boolean) => void;
-
-      /**
-       * A hook event that fires when the World time has been updated.
-       * @param worldTime - The new canonical World time
-       * @param delta     - The time delta
-       * @remarks This is called by {@link Hooks.callAll}.
-       * @see {@link GameTime#onUpdateWorldTime}
-       */
-      updateWorldTime: (worldTime: number, delta: number) => void;
-
-      /** CanvasLifecycle */
-
-      /**
-       * A hook event that fires immediately prior to PIXI Application construction with the configuration parameters.
-       * @param canvasConfig - Canvas configuration parameters that will be used to initialize the PIXI.Application
-       * @remarks This is called by {@link Hooks.callAll}.
-       */
-      canvasConfig: (canvasConfig: ConstructorParameters<typeof PIXI.Application>[0]) => void;
-
-      /**
-       * A hook event that fires when the Canvas is initialized.
-       * @param canvas - the Canvas instance being initialized
-       * @remarks This is called by {@link Hooks.callAll}.
-       * @see {@link Canvas#draw}
-       */
-      canvasInit: (canvas: Canvas) => void;
-
-      /**
-       * A hook event that fires when the Canvas is panned.
-       * @param canvas - The Canvas instance
-       * @param view   - The applied camera position
-       * @remarks When called during animated panning, the callback is called on every tick.
-       * @remarks This is called by {@link Hooks.callAll}.
-       * @see {@link Canvas#pan}
-       * @see {@link Canvas#animatePan}
-       */
-      canvasPan: (canvas: Canvas, view: Canvas.ViewPosition) => void;
-
-      /**
-       * A hook event that fires when the Canvas is ready.
-       * @param canvas - The Canvas which is now ready for use
-       * @remarks This is called by {@link Hooks.call}.
-       * @see {@link Canvas#draw}
-       */
-      canvasReady: (canvas: Canvas) => boolean | void;
-
-      /**
-       * A hook event that fires when the Canvas is deactivated.
-       * @param canvas - The Canvas instance being deactivated
-       * @remarks This is called by {@link Hooks.callAll}.
-       */
-      canvasTearDown: (canvas: Canvas) => void;
-
-      /**
-       * A hook event that fires when the Canvas is beginning to draw the canvas groups.
-       * @param canvas - The Canvas instance being drawn
-       * @remarks This is called by {@link Hooks.callAll}.
-       */
-      canvasDraw: (canvas: Canvas) => void;
-
-      /**
-       * A hook event that fires when some useful data is dropped onto the Canvas.
-       * @param canvas - The Canvas
-       * @param data   - The data that has been dropped onto the Canvas
-       * @remarks This is called by {@link Hooks.call}.
-       * @remarks An explicit return value of `false` prevents the Document being created.
-       * @see {@link Canvas#_onDrop}
-       */
-      dropCanvasData: (canvas: Canvas, data: TokenLayer.DropData | NotesLayer.DropData) => boolean | void;
-
-      /**
-       * A hook event that fires when objects are highlighted on the canvas.
-       * Callers may use this hook to apply their own modifications or enhancements to highlighted objects.
-       * @param active - Is the highlight state now active
-       * @see {@link Canvas#highlightObjects}
-       */
-      highlightObjects: (active: boolean) => void;
-
-      /** Application */
-
-      /**
-       * A hook event that fires when the Scene controls are initialized.
-       * @param controls - The SceneControl configurations
-       * @remarks This is called by {@link Hooks.callAll}.
-       * @see {@link SceneControls#_getControlButtons}
-       */
-      getSceneControlButtons: (controls: SceneControl[]) => void;
-
-      /**
-       * A hook event that fires whenever data is dropped into a Hotbar slot.
-       * The hook provides a reference to the Hotbar application, the dropped data, and the target slot.
-       * Default handling of the drop event can be prevented by returning false within the hooked function.
-       * @param hotbar - The Hotbar application instance
-       * @param data   - The dropped data object
-       * @param slot   - The target hotbar slot
-       * @remarks This is called by {@link Hooks.call}.
-       * @remarks An explicit return value of `false` prevents the Document being created.
-       * @see {@link Hotbar#_onDrop}
-       */
-      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.
-       * @param nav       - The SceneNavigation application
-       * @param collapsed - Whether the navigation is now collapsed or not
-       * @remarks This is called by {@link Hooks.callAll}.
-       * @see {@link SceneNavigation#expand}
-       * @see {@link SceneNavigation#collapse}
-       */
-      collapseSceneNavigation: (nav: SceneNavigation, collapsed: boolean) => void;
-
-      /**
-       * A hook event that fires when the Sidebar is collapsed or expanded.
-       * @param sidebar   - The Sidebar application
-       * @param collapsed - Whether the Sidebar is now collapsed or not
-       * @remarks This is called by {@link Hooks.callAll}.
-       * @see {@link Sidebar#expand}
-       * @see {@link Sidebar#collapse}
-       */
-      collapseSidebar: (sidebar: Sidebar, collapsed: boolean) => void;
-
-      /**
-       * A hook event that fires when the Sidebar tab is changed.
-       * @param app - The SidebarTab application which is now active
-       * @remarks This is called by {@link Hooks.callAll}.
-       * @see {@link Sidebar#_onChangeTab}
-       */
-      changeSidebarTab: (app: SidebarTab) => void;
-
-      /** Active Effects */
-
-      /**
-       * A hook event that fires when a custom active effect is applied.
-       * @param actor  - The actor the active effect is being applied to
-       * @param change - The change data being applied
-       * @remarks This is called by {@link Hooks.call}.
-       * @see {@link ActiveEffect#_applyCustom}
-       */
-      applyActiveEffect: (actor: Actor.ConfiguredInstance, change: ActiveEffect.EffectChangeData) => boolean | void;
-
-      /** Compendium */
-
-      /**
-       * A hook event that fires whenever the contents of a Compendium pack were modified.
-       * This hook fires for all connected clients after the update has been processed.
-       *
-       * @param pack      - The Compendium pack being modified
-       * @param documents - The locally-cached Documents which were modified in the operation
-       * @param options   - Additional options which modified the modification request
-       * @param userId    - The ID of the User who triggered the modification workflow
-       * @remarks This is called by {@link Hooks.callAll}.
-       * @see {@link CompendiumCollection#_onModifyContents}
-       */
-      updateCompendium: (
-        pack: CompendiumCollection.Any,
-        documents: Document.Any[],
-        options: Document.OnUpdateOptions<Document.Any["documentName"]>,
-        userId: string,
-      ) => void;
-
-      /** Token */
-
-      /**
-       * A hook event that fires when a token {@link Token} should apply a specific status effect.
-       * @param token    - The token affected
-       * @param statusId - The status effect ID being applied, from CONFIG.specialStatusEffects.
-       * @param active   - Is the special status effect now active?
-       */
-      applyTokenStatusEffect: (token: Token.ConfiguredInstance, statusId: string, active: boolean) => void;
-
-      /**
-       * A hook event that fires when a chat bubble is initially configured.
-       * @param token   - The speaking token
-       * @param html    - The HTML for the chat bubble
-       * @param message - The spoken message text
-       * @param options - additional options
-       * @remarks This is called when creating a {@link ChatBubble}, but before displaying it.
-       * @remarks This is called by {@link Hooks.call}.
-       * @remarks An explicit return value of `false` prevents the chat bubble being shown.
-       * @see {@link ChatBubbles#say}
-       */
-      chatBubble: (
-        token: Token,
-        html: JQuery,
-        message: string,
-        options: {
-          /** Whether to style the speech bubble as an emote */
-          emote: boolean;
-        },
-      ) => boolean | void;
-
-      /**
-       * A hook event that fires when a token's resource bar attribute has been modified.
-       * @param data    - A object describing the modification
-       * @param updates - The update delta that will be applied to the Token's actor
-       * @returns whether the Actor should be updated
-       * @remarks This is called by {@link Hooks.call}.
-       * @see {@link Actor#modifyTokenAttribute}
-       * @see {@link Actor#update}
-       */
-      modifyTokenAttribute: (
-        data: {
-          /** The attribute path */
-          attribute: string;
-
-          /** The target attribute value */
-          value: number;
-
-          /** Whether the number represents a relative change (true) or an absolute change (false) */
-          isDelta: boolean;
-
-          /** Whether the new value is part of an attribute bar, or just a direct value */
-          isBar: boolean;
-        },
-        updates: Record<string, number>,
-      ) => boolean;
-
-      /**
-       * A hook event that fires when a token is targeted or un-targeted.
-       * @param user     - The User doing the targeting
-       * @param token    - The targeted Token
-       * @param targeted - Whether the Token has been targeted or untargeted
-       * @remarks This is called by {@link Hooks.callAll}.
-       * @see {@link UserTargets#_hook}
-       */
-      targetToken: (
-        user: User.ConfiguredInstance,
-        token: Document.ConfiguredObjectClassForName<"Token">,
-        targeted: boolean,
-      ) => void;
-
-      /** Note */
-
-      /**
-       * A hook event that fires whenever a map note is double-clicked.
-       * The hook provides the note placeable and the arguments passed to the associated {@link JournalSheet} render call.
-       * Hooked functions may modify the render arguments or cancel the render by returning false.
-       * @param note    - The note that was activated
-       * @param options - Options for rendering the associated {@link JournalSheet}
-       * @remarks This is called by {@link Hooks.call}.
-       */
-      activateNote: (note: Note.ConfiguredInstance, options: JournalSheet.RenderOptions) => true | false;
-
-      /** Cards */
-
-      /**
-       * A hook event that fires when Cards are dealt from a deck to other hands
-       * @param origin             - The origin Cards document
-       * @param destinations       - An array of destination Cards documents
-       * @param context            - Additional context which describes the operation
-       * @remarks This is called by {@link Hooks.call}.
-       * @remarks An explicit return value of `false` prevents the operation.
-       */
-      dealCards: (
-        origin: Cards.ConfiguredInstance,
-        destinations: Cards.ConfiguredInstance[],
-        context: Cards.DealContext,
-      ) => boolean | void;
-
-      /**
-       * A hook event that fires when Cards are passed from one stack to another
-       * @param origin      - The origin Cards document
-       * @param destination - The destination Cards document
-       * @param context     - Additional context which describes the operation
-       * @remarks This is called by {@link Hooks.call}.
-       * @remarks An explicit return value of `false` prevents the operation.
-       */
-      passCards: (
-        origin: Cards.ConfiguredInstance,
-        destination: Cards.ConfiguredInstance,
-        context: Cards.DealContext,
-      ) => boolean | void;
-
-      /**
-       * A hook event that fires when a stack of Cards are returned to the decks they originally came from.
-       * @param origin   - The origin Cards document.
-       * @param returned - The cards being returned.
-       * @param context  - Additional context which describes the operation.
-       */
-      returnCards: (
-        origin: Cards.ConfiguredInstance,
-        returned: Card.ConfiguredInstance[],
-        context: Cards.ReturnContext,
-      ) => boolean | void;
-
-      /** Actor */
-
-      /**
-       * A hook even that fires when package-provided art is applied to a compendium Document.
-       * @param documentClass - The Document class.
-       * @param source        - The Document's source data.
-       * @param pack          - The Document's compendium.
-       * @param art           - The art being applied.
-       * @remarks Called as part of _initializeSource, after data migration, cleaning, and shims
-       * @remarks Currently only called by Actor but comments are more generic
-       * @remarks This is called by {@link Hooks.callAll}.
-       */
-      applyCompendiumArt: (
-        documentClass: Actor.ConfiguredClass,
-        source: foundry.documents.BaseActor.ConstructorData,
-        pack: CompendiumCollection.Any,
-        art: CompendiumArtInfo,
-      ) => void;
-
-      /** ActorSheet */
-
-      /**
-       * A hook event that fires when some useful data is dropped onto an ActorSheet.
-       * @param actor - The Actor
-       * @param sheet - The ActorSheet application
-       * @param data  - The data that has been dropped onto the sheet
-       * @remarks This is called by {@link Hooks.call}.
-       * @remarks An explicit return value of `false` prevents the Document being created.
-       * @see {@link ActorSheet#_onDrop}
-       */
-      dropActorSheetData: (
-        actor: Actor.ConfiguredInstance,
-        sheet: ActorSheet,
-        data: ActorSheet.DropData,
-      ) => boolean | void;
-
-      /** CanvasVisibility */
-
-      /**
-       * A hook event that fires when the set of vision sources are initialized.
-       * @param sources - The collection of current vision sources
-       * @remarks This is called by {@link Hooks.call}.
-       */
-      initializeVisionSources: (sources: Collection<PointVisionSource.Any>) => void;
-
-      /**
-       * A hook event that fires when the LightingLayer is refreshed.
-       * @param layer - the LightingLayer
-       * @remarks This is called by {@link Hooks.callAll}.
-       * @see {@link LightingLayer#refresh}
-       */
-      lightingRefresh: (layer: LightingLayer) => void;
-
-      /**
-       * A hook event that fires when visibility is refreshed.
-       * @param visibility - The CanvasVisibility instance
-       * @remarks This is called by {@link Hooks.callAll}.
-       */
-      visibilityRefresh: (visibility: CanvasVisibility) => void;
-
-      /**
-       * A hook event that fires during light source initialization.
-       * This hook can be used to add programmatic light sources to the Scene.
-       * @param source - The EffectsCanvasGroup where light sources are initialized
-       * @remarks This is called by {@link Hooks.callAll}.
-       * @see {@link EffectsCanvasGroup#initializeLightSources}
-       */
-      initializeLightSources: (group: EffectsCanvasGroup) => void;
-
-      /**
-       * A hook event that fires during darkness source initialization.
-       * This hook can be used to add programmatic darkness sources to the Scene.
-       * @param group - The EffectsCanvasGroup where darkness sources are initialized
-       * @remarks This is called by {@link Hooks.callAll}.
-       */
-      initializeDarknessSources: (group: EffectsCanvasGroup) => void;
-
-      /**
-       * A hook event that fires when the CanvasVisibility layer has been refreshed.
-       * @param visibility - The CanvasVisibility layer
-       * @remarks This is called by {@link Hooks.callAll}.
-       * @see {@link CanvasVisibility#restrictVisibility}
-       */
-      sightRefresh: (visibility: CanvasVisibility) => void;
-
-      /** Weather */
-
-      /**
-       * Initialize the weather container from a weather config object.
-       * @param weatherEffect        - The weather effects canvas layer
-       * @param weatherEffectsConfig - The weather effects config object
-       * @remarks This is called by {@link Hooks.callAll}.
-       */
-      initializeWeatherEffects: (
-        weatherEffect: WeatherEffects,
-        weatherEffectsConfig?: WeatherEffects.WeatherEffectsConfig | null,
-      ) => void;
-
-      /** Adventure */
-
-      /**
-       * A hook event that fires when Adventure data is being prepared for import.
-       * Modules may return false from this hook to take over handling of the import workflow.
-       * @param adventure - The Adventure document from which content is being imported
-       * @param formData  - Processed data from the importer form
-       * @param toCreate  - Adventure data which needs to be created in the World
-       * @param toUpdate  - Adventure data which needs to be updated in the World
-       * @returns False to prevent the core software from handling the import
-       * @remarks This is called by {@link Hooks.call}.
-       */
-      preImportAdventure: (
-        adventure: Adventure.ConfiguredInstance,
-        formData: object, // TODO: Improve this. Also relevant to `AdventureImporter#_updateObject`
-        toCreate: AdventureImportData["toCreate"],
-        toUpdate: AdventureImportData["toUpdate"],
-      ) => boolean | void;
-
-      /**
-       * A hook event that fires after an Adventure has been imported into the World.
-       * @param adventure - The Adventure document from which content is being imported
-       * @param formData  - Processed data from the importer form
-       * @param toCreate  - Adventure data which needs to be created in the World
-       * @param toUpdate  - Adventure data which needs to be updated in the World
-       * @returns False to prevent the core software from handling the import
-       * @remarks This is called by {@link Hooks.callAll}.
-       */
-      importAdventure: (
-        adventure: Adventure.ConfiguredInstance,
-        formData: object, // TODO: Improve this. Also relevant to `AdventureImporter#_updateObject`
-        toCreate: AdventureImportData["toCreate"],
-        toUpdate: AdventureImportData["toUpdate"],
-      ) => void;
-
-      /** Socket */
-
-      /**
-       * A hook event that fires whenever some other User joins or leaves the game session.
-       * @param user      - The User who connected or disconnected
-       * @param connected - Is the user now connected (true) or disconnected (false)
-       * @remarks This is called by {@link Hooks.callAll}.
-       */
-      userConnected: (user: User.ConfiguredInstance, connected: boolean) => void;
-
-      /** Combat */
-
-      /**
-       *  A hook event which fires when the turn order of a Combat encounter is progressed.
-       * This event fires on all clients after the database update has occurred for the Combat.
-       * @param combat  - The Combat encounter for which the turn order has changed
-       * @param prior   - The prior turn state
-       * @param current - The new turn state
-       * @remarks This is called by {@link Hooks.callAll}.
-       */
-      combatTurnChange: (
-        combat: Combat.ConfiguredInstance,
-        prior: Combat.HistoryData,
-        current: Combat.HistoryData,
-      ) => void;
-
-      /**
-       * A hook event that fires when a Combat encounter is started.
-       * This event fires on the initiating client before any database update occurs.
-       * @param combat     - The Combat encounter which is starting
-       * @param updateData - An object which contains Combat properties that will be updated. Can be mutated.
-       */
-      combatStart: (
-        combat: Combat.ConfiguredInstance,
-        updateData: {
-          /** The initial round */
-          round: number;
-          /** The initial turn */
-          turn: number;
-        },
-      ) => void;
-
-      /**
-       * A hook event that fires when the turn of the Combat encounter changes.
-       * This event fires on the initiating client before any database update occurs.
-       * @param combat        - The Combat encounter which is advancing or rewinding its turn
-       * @param updateData    - An object which contains Combat properties that will be updated. Can be mutated.
-       * @param updateOptions - An object which contains options provided to the update method. Can be mutated.
-       */
-      combatTurn: (
-        combat: Combat.ConfiguredInstance,
-        updateData: {
-          /** The current round of combat */
-          round: number;
-          /** The new turn number */
-          turn: number;
-        },
-        updateOptions: {
-          /** The amount of time in seconds that time is being advanced */
-          advanceTime: number;
-          /** A signed integer for whether the turn order is advancing or rewinding */
-          direction: number;
-        },
-      ) => void;
-
-      /**
-       * A hook event that fires when the round of the Combat encounter changes.
-       * @param combat        - The Combat encounter which is advancing or rewinding its round
-       * @param updateData    - An object which contains Combat properties that will be updated. Can be mutated.
-       * @param updateOptions - An object which contains options provided to the update method. Can be mutated.
-       */
-      combatRound: (
-        combat: Combat.ConfiguredInstance,
-        updateData: {
-          /** The new round of combat */
-          round: number;
-          /** The new turn number */
-          turn: number;
-        },
-        updateOptions: {
-          /** The amount of time in seconds that time is being advanced */
-          advanceTime: number;
-          /** A signed integer for whether the turn order is advancing or rewinding */
-          direction: number;
-        },
-      ) => void;
-
-      /** ProseMirror */
-
-      /**
-       * A hook even that fires when a ProseMirrorMenu's drop-downs are initialized.
-       * The hook provides the ProseMirrorMenu instance and an object of drop-down configuration data.
-       * Hooked functions may append their own drop-downs or append entries to existing drop-downs.
-       * @param menu   - The ProseMirrorMenu instance.
-       * @param config - The drop-down config.
-       * @remarks This is called by {@link Hooks.callAll}.
-       */
-      getProseMirrorMenuDropdowns: (
-        menu: ProseMirrorMenu,
-        config: {
-          format: ProseMirrorDropDown.Config;
-          fonts: ProseMirrorDropDown.Config;
-        },
-      ) => void;
-
-      /**
-       * A hook even that fires when a ProseMirrorMenu's buttons are initialized.
-       * The hook provides the ProseMirrorMenu instance and an array of button configuration data.
-       * Hooked functions may append their own buttons to the list.
-       * @param menu   - The ProseMirrorMenu instance
-       * @param config - The button configuration objects
-       * @remarks This is called by {@link Hooks.callAll}.
-       */
-      // TODO: Having trouble finding the appropriate typing for the menu items? Also, where is this even called?
-      getProseMirrorMenuItems: (menu: ProseMirrorMenu, config: unknown[]) => void;
-
-      /**
-       * A hook event that fires whenever a ProseMirror editor is created.
-       * The hook provides the ProseMirror instance UUID, a list of plugins, and an object containing the provisional
-       * editor state, and a reference to the menu plugin.
-       * Hooked functions may append their own plugins or replace the state or menu plugin by replacing their references
-       * in the final argument.
-       *
-       * @param uuid    - A UUID that uniquely identifies this ProseMirror instance.
-       * @param plugins - A list of plugins that will be loaded.
-       * @param options - The provisional EditorState and ProseMirrorMenuPlugin.
-       * @remarks This is called by {@link Hooks.callAll}.
-       * @see {@link ProseMirrorEditor.create}
-       */
-      createProseMirrorEditor: (uuid: string, plugins: Record<string, Plugin>, options: { state: EditorState }) => void;
-
-      /** HotReload */
-
-      /**
-       * A hook event that fires when a package that is being watched by the hot reload system has a file changed.
-       * The hook provides the hot reload data related to the file change.
-       * Hooked functions may intercept the hot reload and prevent the core software from handling it by returning false.
-       * @param data - The hot reload data
-       * @remarks This is called by {@link Hooks.call}.
-       */
-      hotReload: (data: HotReloadData) => boolean | void;
-
-      /** Chat */
-
-      /**
-       * A hook event that fires when a user sends a message through the ChatLog.
-       * @param chatLog  - The ChatLog instance
-       * @param message  - The trimmed message content
-       * @param chatData - The basic chat data
-       * @remarks This is called by {@link Hooks.call}.
-       * @remarks An explicit return value of `false` prevents the chat message from being created.
-       * @see {@link ChatLog#processMessage}
-       */
-      chatMessage: (
-        chatLog: ChatLog,
-        message: string,
-        chatData: {
-          /** The id of the User sending the message */
-          user: string;
-
-          /** The identified speaker data, see {@link ChatMessage.getSpeaker} */
-          speaker: ReturnType<ChatMessage.ConfiguredClass["getSpeaker"]>;
-        },
-      ) => boolean | void;
-
-      /**
-       * A hook event that fires for each ChatMessage which is rendered for addition to the ChatLog.
-       * This hook allows for final customization of the message HTML before it is added to the log.
-       * @param message        - The ChatMessage document being rendered
-       * @param html           - The pending HTML as a jQuery object
-       * @param messageData    - The input data provided for template rendering
-       * @remarks This is called by {@link Hooks.call}.
-       * @see {@link ChatMessage#render}
-       */
-      renderChatMessage: (
-        message: ChatMessage,
-        html: JQuery,
-        messageData: {
-          message: Document.ToObjectFalseType<ChatMessage.ConfiguredInstance>;
-          user: Game["user"];
-          author: User.ConfiguredInstance | null;
-          alias: string;
-          cssClass: string;
-          isWhisper: boolean;
-          canDelete: boolean;
-          whisperTo: string;
-          borderColor?: string;
-        },
-      ) => boolean | void;
-
-      /** Audio-Video */
-
-      // Individually implemented all three options for globalVolumeChanged
-
-      /**
-       * A hook event that fires when the user modifies a global volume slider.
-       * @param volume - The new volume level
-       * @remarks This is called by {@link Hooks.callAll}.
-       * @see {@link AudioHelper#_onChangeGlobalVolume}
-       */
-      globalAmbientVolumeChanged: (volume: number) => void;
-      /**
-       * A hook event that fires when the user modifies a global volume slider.
-       * @param volume - The new volume level
-       * @remarks This is called by {@link Hooks.callAll}.
-       * @see {@link AudioHelper#_onChangeGlobalVolume}
-       */
-      globalInterfaceVolumeChanged: (volume: number) => void;
-      /**
-       * A hook event that fires when the user modifies a global volume slider.
-       * @param volume - The new volume level
-       * @remarks This is called by {@link Hooks.callAll}.
-       * @see {@link AudioHelper#_onChangeGlobalVolume}
-       */
-      globalPlaylistVolumeChanged: (volume: number) => void;
-
-      /**
-       * A hook event that fires when the AV settings are changed.
-       * @param settings - The AVSettings manager
-       * @param changed  - The delta of the settings that have been changed
-       * @remarks This is called by {@link Hooks.callAll}.
-       * @see {@link AVSettings#_onSettingsChanged}
-       */
-      rtcSettingsChanged: (settings: AVSettings, changed: DeepPartial<AVSettings.Settings>) => void;
-
-      /** RollTableConfig */
-
-      /**
-       * A hook event that fires when some useful data is dropped onto a RollTableConfig.
-       * @param table  - The RollTable
-       * @param config - The RollTableConfig application
-       * @param data   - The data dropped onto the RollTableConfig
-       * @remarks This is called by {@link Hooks.call}.
-       * @remarks An explicit return value of `false` prevents the Document being created.
-       * @see {@link RollTableConfig#_onDrop}
-       */
-      dropRollTableSheetData: (
-        table: RollTable.ConfiguredInstance,
-        config: RollTableConfig,
-        data: object,
-      ) => boolean | void;
-
-      /**
-       * A hook event that allows to pass custom dynamic ring configurations.
-       * @param ringConfig - The ring configuration instance
-       * @remarks This is called by {@link Hooks.callAll}.
-       */
-      initializeDynamicTokenRingConfig: (ringConfig: foundry.canvas.tokens.TokenRingConfig) => void;
-
-      /** Specific implementations of GetEntryContext */
-
-      /**
-       * A hook event that fires when the context menu for a SceneNavigation entry is constructed.
-       * @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: (
-        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 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: (
-        app: foundry.applications.ui.Players,
-        contextOptions: foundry.applications.ux.ContextMenu.Entry<HTMLElement>[],
-      ) => boolean | void;
+      /** The relative file path which was modified */
+      path: string;
+
+      /** The file extension which was modified, e.g. "js", "css", "html" */
+      extension: "js" | "css" | "html" | "hbs" | (string & {});
     }
 
+    /**
+     * @deprecated Configuration is now in {@linkcode HookConfigs.HookConfig | fvtt-types/configuration/HookConfig}.
+     */
+    type StaticCallbacks = HookConfigs.HookConfig;
+
     /** Application */
 
+    /**
+     * A hook event that fires whenever an ApplicationV2 is rendered. Substitute the "ApplicationV2" in the hook event to
+     * target a specific ApplicationV2 type, for example "renderMyApplication". Each ApplicationV2 class in the inheritance
+     * chain will also fire this hook, i.e. "renderApplicationV2" will also fire.
+     * The hook provides the pending application HTML which will be added to the DOM.
+     * Hooked functions may modify that HTML or attach interactive listeners to it.
+     * @param application - The Application instance being rendered
+     * @param element     - The inner HTML of the document that will be displayed and may be modified
+     * @param context     - The application rendering context data
+     * @param options     - The application rendering options
+     */
+    type RenderApplicationV2<Application extends ApplicationV2.Any = ApplicationV2.Any> = (
+      application: Application,
+      // Note(LukeAbby): At some point it may be helpful to be more specific than HTMLElement.
+      // particular the default implementation the element associates with `options.tag`.
+      element: HTMLElement,
+      context: ApplicationV2.RenderContextOf<Application>,
+      options: ApplicationV2.RenderOptionsOf<Application>,
+    ) => void;
+
+    /**
+     * A hook event that fires whenever this ApplicationV2 is rendered to add controls to its header. Substitute the
+     * "ApplicationV2" in the hook event to target a specific ApplicationV2 type, for example "renderMyApplication".
+     * Each Application class in the inheritance chain will also fire this hook, i.e. "getHeaderControlsApplicationV2"
+     * will also fire.
+     * @param application - The Application instance being rendered
+     * @param controls    - The array of header control menu options
+     */
+    type GetHeaderControlsApplicationV2<Application extends ApplicationV2.Any = ApplicationV2.Any> = (
+      application: Application,
+      controls: ApplicationV2.HeaderControlsEntry,
+    ) => void;
+
+    type GetApplicationV2ContextOptions<Application extends ApplicationV2.Any = ApplicationV2.Any> = (
+      application: Application,
+      controls: ContextMenu.Entry<JQuery | HTMLElement>[],
+    ) => void;
+
+    /**
+     * A hook event that fires whenever this ApplicationV2 is closed. Substitute the "ApplicationV2" in the hook event to
+     * target a specific ApplicationV2 type, for example "closeMyApplication". Each ApplicationV2 class in the inheritance
+     * chain will also fire this hook, i.e. "closeApplicationV2" will also fire.
+     * @param application - The Application instance being closed
+     */
+    type CloseApplicationV2<Application extends ApplicationV2.Any = ApplicationV2.Any> = (app: Application) => void;
+
     /**
      * A hook event that fires whenever this Application is rendered.
      * The hook provides the pending application HTML which will be added to the DOM.
      * Hooked functions may modify that HTML or attach interactive listeners to it.
      *
-     * @param app   - The Application instance being rendered
-     * @param html  - The inner HTML of the document that will be displayed and may be modified
-     * @param data  - The object of data used when rendering the application
-     * @typeParam A - the type of the Application
+     * @param app  - The Application instance being rendered
+     * @param html - The inner HTML of the document that will be displayed and may be modified
+     * @param data - The object of data used when rendering the application
+     * @template A - the type of the Application
      * @remarks The name for this hook is dynamically created by joining "render" with the type name of the Application.
-     * @remarks This is called by {@link Hooks.callAll}.
-     * @see {@link Application#_render}
+     * @remarks This is called by {@linkcode Hooks.callAll}.
+     * @see {@link Application._render | `Application#_render`}
      */
     type RenderApplication<A extends Application.Any = Application.Any> = (
       app: A,
       html: JQuery,
-      data: ReturnType<A["getData"]> extends Promise<infer T> ? T : ReturnType<A["getData"]>,
+      data: Awaited<ReturnType<A["getData"]>>,
     ) => void;
 
     /**
      * A hook event that fires whenever this Application is first rendered to add buttons to its header.
      * @param app     - The Application instance being rendered
      * @param buttons - The array of header buttons which will be displayed
-     * @typeParam A   - the type of the Application
+     * @template A   - the type of the Application
      * @remarks The name for this hook is dynamically created by joining "get" with the type name of the Application and
      * "HeaderButtons".
-     * @remarks This is called by {@link Hooks.call}.
-     * @see {@link Application#_getHeaderButtons}
+     * @remarks This is called by {@linkcode Hooks.call}.
+     * @see {@link Application._getHeaderButtons | `Application#_getHeaderButtons`}
      */
     type GetApplicationHeaderButtons<A extends Application.Any = Application.Any> = (
       app: A,
@@ -841,36 +1121,24 @@ declare global {
      * A hook event that fires whenever this Application is closed.
      * @param app   - The Application instance being closed
      * @param html  - The application HTML when it is closed
-     * @typeParam A - the type of the Application
+     * @template 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.callAll}.
-     * @see {@link Application#close}
+     * @remarks This is called by {@linkcode Hooks.callAll}.
+     * @see {@link Application.close | `Application#close`}
      */
     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 */
 
     /**
-     * A hook event that fires when a {@link CanvasGroup} is drawn.
+     * A hook event that fires when a {@linkcode CanvasGroup} is drawn.
      * The dispatched event name replaces "Group" with the named CanvasGroup subclass, i.e. "drawPrimaryCanvasGroup".
      * @param group - The group being drawn
      */
     type DrawGroup<G extends CanvasGroupMixin.AnyMixed = CanvasGroupMixin.AnyMixed> = (group: G) => void;
 
     /**
-     * A hook event that fires when a {@link CanvasGroup} is deconstructed.
+     * A hook event that fires when a {@linkcode CanvasGroup} is deconstructed.
      * The dispatched event name replaces "Group" with the named CanvasGroup subclass, i.e. "tearDownPrimaryCanvasGroup".
      * @param group - The group being deconstructed
      */
@@ -879,67 +1147,72 @@ declare global {
     /** CanvasLayer */
 
     /**
-     * A hook event that fires when a {@link CanvasLayer} is initially drawn.
+     * A hook event that fires when a {@linkcode CanvasLayer} is initially drawn.
      * The dispatched event name replaces "Layer" with the named CanvasLayer subclass, i.e. "drawTokensLayer".
      * @param layer - The layer being drawn
-     * @typeParam L - the type of the CanvasLayer
+     * @template L - the type of the CanvasLayer
      */
-    type DrawLayer<L extends CanvasLayer = CanvasLayer> = (layer: L) => void;
+    type DrawLayer<L extends layers.CanvasLayer.Any = layers.CanvasLayer.Any> = (layer: L) => void;
 
     /**
-     * A hook event that fires when a {@link CanvasLayer} is deconstructed.
+     * A hook event that fires when a {@linkcode CanvasLayer} is deconstructed.
      * The dispatched event name replaces "Layer" with the named CanvasLayer subclass, i.e. "tearDownTokensLayer".
      * @param layer - The layer being deconstructed
-     * @typeParam L - the type of the CanvasLayer
+     * @template L - the type of the CanvasLayer
      */
-    type TearDownLayer<L extends CanvasLayer = CanvasLayer> = (layer: L) => void;
+    type TearDownLayer<L extends layers.CanvasLayer.Any = layers.CanvasLayer.Any> = (layer: L) => void;
 
     /**
-     * A hook event that fires when any PlaceableObject is pasted onto the
-     * Scene. Substitute the PlaceableObject name in the hook event to target a
+     * A hook event that fires when any PlaceableObject is pasted onto the Scene.
+     * Substitute the "PlaceableObject" in the hook event to target a
      * specific PlaceableObject type, for example "pasteToken".
-     * @param copied     - The PlaceableObjects that were copied
-     * @param createData - The new objects that will be added to the Scene
-     * @typeParam P      - the type of the PlaceableObject
+     * @param objects - The objects that were copied or cut
+     * @param data    - The create data if copied, or the update data if cut
+     * @param options - Additional options
      * @remarks The name for this hook is dynamically created by joining "paste" with the type name of the
      * PlaceableObject.
-     * @remarks This is called by {@link Hooks.call}.
-     * @see {@link PlaceablesLayer#pasteObjects}
+     * @remarks This is called by {@linkcode Hooks.call}.
+     * @see {@link PlaceablesLayer.pasteObjects | `PlaceablesLayer#pasteObjects`}
      */
-    type PastePlaceableObject<P extends PlaceableObject = PlaceableObject> = (
-      copied: P[],
-      createData: Array<P["document"]["_source"]>,
+    type PastePlaceableObject<P extends PlaceableObject.Any = PlaceableObject.Any> = (
+      objects: P[],
+      data: PlaceableObject.PasteObjectReturn<P["document"]>,
+      options: Hooks.PastePlaceableObjectOptions,
     ) => boolean | void;
-    /**  */
+
+    interface PastePlaceableObjectOptions {
+      /** Were the objects cut instead of copied? */
+      cut: boolean;
+    }
 
     /** PlaceableObject */
 
     /**
-     * A hook event that fires when a {@link PlaceableObject} is initially drawn.
+     * A hook event that fires when a {@linkcode PlaceableObject} is initially drawn.
      * The dispatched event name replaces "Object" with the named PlaceableObject subclass, i.e. "drawToken".
      * @param object - The object instance being drawn
-     * @typeParam P  - the type of the PlaceableObject
-     * @remarks This is called by {@link Hooks.callAll}
+     * @template P  - the type of the PlaceableObject
+     * @remarks This is called by {@linkcode Hooks.callAll}
      */
-    type DrawObject<P extends PlaceableObject = PlaceableObject> = (object: P) => void;
+    type DrawObject<P extends PlaceableObject.Any = PlaceableObject.Any> = (object: P) => void;
 
     /**
-     * A hook event that fires when a {@link PlaceableObject} is incrementally refreshed.
+     * A hook event that fires when a {@linkcode PlaceableObject} is incrementally refreshed.
      * The dispatched event name replaces "Object" with the named PlaceableObject subclass, i.e. "refreshToken".
      * @param object - The object instance being refreshed
-     * @typeParam P  - the type of the PlaceableObject
-     * @remarks This is called by {@link Hooks.callAll}
+     * @template P  - the type of the PlaceableObject
+     * @remarks This is called by {@linkcode Hooks.callAll}
      */
-    type RefreshObject<P extends PlaceableObject = PlaceableObject> = (object: P) => void;
+    type RefreshObject<P extends PlaceableObject.Any = PlaceableObject.Any> = (object: P) => void;
 
     /**
-     * A hook event that fires when a {@link PlaceableObject} is destroyed.
+     * A hook event that fires when a {@linkcode PlaceableObject} is destroyed.
      * The dispatched event name replaces "Object" with the named PlaceableObject subclass, i.e. "destroyToken".
      * @param object - The object instance being destroyed
-     * @typeParam P  - the type of the PlaceableObject
-     * @remarks This is called by {@link Hooks.callAll}
+     * @template P  - the type of the PlaceableObject
+     * @remarks This is called by {@linkcode Hooks.callAll}
      */
-    type DestroyObject<P extends PlaceableObject = PlaceableObject> = (object: P) => void;
+    type DestroyObject<P extends PlaceableObject.Any = PlaceableObject.Any> = (object: P) => void;
 
     /**
      * A hook event that fires when any PlaceableObject is selected or
@@ -947,14 +1220,14 @@ declare global {
      * target a specific PlaceableObject type, for example "controlToken".
      * @param object     - The PlaceableObject
      * @param controlled - Whether the PlaceableObject is selected or not
-     * @typeParam P      - the type of the PlaceableObject
+     * @template P      - the type of the PlaceableObject
      * @remarks The name for this hook is dynamically created by joining "control" and the type name of the
      * PlaceableObject.
-     * @remarks This is called by {@link Hooks.callAll}.
-     * @see {@link PlaceableObject#control}
-     * @see {@link PlaceableObject#release}
+     * @remarks This is called by {@linkcode Hooks.callAll}.
+     * @see {@link PlaceableObject.control | `PlaceableObject#control`}
+     * @see {@link PlaceableObject.release | `PlaceableObject#release`}
      */
-    type ControlObject<P extends PlaceableObject = PlaceableObject> = (object: P, controlled: boolean) => void;
+    type ControlObject<P extends PlaceableObject.Any = PlaceableObject.Any> = (object: P, controlled: boolean) => void;
 
     /**
      * A hook event that fires when any PlaceableObject is hovered over or out.
@@ -962,13 +1235,13 @@ declare global {
      * PlaceableObject type, for example "hoverToken".
      * @param object - The PlaceableObject
      * @param hover  - Whether the PlaceableObject is hovered over or not
-     * @typeParam P  - the type of the PlaceableObject
+     * @template P   - the type of the PlaceableObject
      * @remarks The name for this hook is dynamically created by joining "hover" and the type name of the PlaceableObject.
-     * @remarks This is called by {@link Hooks.callAll}.
-     * @see {@link PlaceableObject#_onHoverIn}
-     * @see {@link PlaceableObject#_onHoverOut}
+     * @remarks This is called by {@linkcode Hooks.callAll}.
+     * @see {@link PlaceableObject._onHoverIn | `PlaceableObject#_onHoverIn`}
+     * @see {@link PlaceableObject._onHoverOut | `PlaceableObject#_onHoverOut`}
      */
-    type HoverObject<P extends PlaceableObject = PlaceableObject> = (object: P, hover: boolean) => void;
+    type HoverObject<P extends PlaceableObject.Any = PlaceableObject.Any> = (object: P, hover: boolean) => void;
 
     /** Document */
 
@@ -984,20 +1257,41 @@ declare global {
      * @param data     - The initial data object provided to the document creation request
      * @param options  - Additional options which modify the creation request
      * @param userId   - The ID of the requesting user, always game.user.id
-     * @typeParam D    - the type of the Document constructor
+     * @template D    - the type of the Document constructor
      * @returns Explicitly return false to prevent creation of this Document
      * @remarks The name for this hook is dynamically created by joining "preCreate" with the name of the Document.
-     * @remarks This is called by {@link Hooks.call}.
-     * @see {@link ClientDatabaseBackend#_preCreateDocumentArray}
-     * @see {@link TokenDocument#_preUpdateTokenActor}
+     * @remarks This is called by {@linkcode Hooks.call}.
+     * @see {@link ClientDatabaseBackend._preCreateDocumentArray | `ClientDatabaseBackend#_preCreateDocumentArray`}
+     * @see {@link TokenDocument._preUpdateTokenActor | `TokenDocument#_preUpdateTokenActor`}
      */
-    type PreCreateDocument<D extends Document.AnyConstructor = Document.AnyConstructor> = (
-      document: Document.ToConfiguredInstance<D>,
-      data: ConstructorParameters<D>[0],
-      options: Document.PreCreateOptions<FixedInstanceType<D>["documentName"]>,
+    type PreCreateDocument<D extends Document.Any = Document.Any> = (
+      document: D,
+      data: Document.CreateDataForName<D["documentName"]>,
+      // TODO
+      options: Document.Database.PreCreateOptions<DatabaseCreateOperation>,
       userId: string,
     ) => boolean | void;
 
+    /**
+     * A hook event that fires for every embedded Document type after conclusion of a creation workflow.
+     * Substitute the Document name in the hook event to target a specific type, for example "createToken".
+     * This hook fires for all connected clients after the creation has been processed.
+     *
+     * @param document - The new Document instance which has been created
+     * @param options  - Additional options which modified the creation request
+     * @param userId   - The ID of the User who triggered the creation workflow
+     * @template D    - the type of the Document constructor
+     * @remarks The name for this hook is dynamically created by joining "create" and the type name of the Document.
+     * @remarks This is called by {@linkcode Hooks.callAll}.
+     * @see {@link ClientDatabaseBackend._postCreateDocumentCallbacks | `ClientDatabaseBackend#_postCreateDocumentCallbacks`}
+     * @see {@link TokenDocument._onUpdateTokenActor | `TokenDocument#_onUpdateTokenActor`}
+     */
+    type CreateDocument<D extends Document.Any = Document.Any> = (
+      document: D,
+      options: Document.Database.CreateOptionsFor<D["documentName"]>,
+      userId: string,
+    ) => void;
+
     /**
      * A hook event that fires for every Document type before execution of an update workflow. Substitute the Document
      * name in the hook event to target a specific Document type, for example "preUpdateActor". This hook only fires
@@ -1010,20 +1304,42 @@ declare global {
      * @param changed  - Differential data that will be used to update the document
      * @param options  - Additional options which modify the update request
      * @param userId   - The ID of the requesting user, always game.user.id
-     * @typeParam D    - the type of the Document constructor
+     * @template D    - the type of the Document constructor
      * @returns Explicitly return false to prevent update of this Document
      * @remarks The name for this hook is dynamically created by joining "preUpdate" with the type name of the Document.
-     * @remarks This is called {@link Hooks.call}.
-     * @see {@link ClientDatabaseBackend#_preUpdateDocumentArray}
-     * @see {@link TokenDocument#_preUpdateTokenActor}
+     * @remarks This is called {@linkcode Hooks.call}.
+     * @see {@link ClientDatabaseBackend._preUpdateDocumentArray | `ClientDatabaseBackend#_preUpdateDocumentArray`}
+     * @see {@link TokenDocument._preUpdateTokenActor | `TokenDocument#_preUpdateTokenActor`}
      */
-    type PreUpdateDocument<D extends Document.AnyConstructor = Document.AnyConstructor> = (
-      document: Document.ToConfiguredInstance<D>,
-      changed: DeepPartial<ConstructorParameters<D>[0]>,
-      options: Document.PreUpdateOptions<FixedInstanceType<D>["documentName"]>,
+    type PreUpdateDocument<D extends Document.Any = Document.Any> = (
+      document: D,
+      changed: Document.UpdateDataForName<D["documentName"]>,
+      options: Document.Database.PreUpdateOptions<DatabaseUpdateOperation>,
       userId: string,
     ) => boolean | void;
 
+    /**
+     * A hook event that fires for every Document type after conclusion of an update workflow.
+     * Substitute the Document name in the hook event to target a specific Document type, for example "updateActor".
+     * This hook fires for all connected clients after the update has been processed.
+     *
+     * @param document - The existing Document which was updated
+     * @param change   - Differential data that was used used to update the document
+     * @param options  - Additional options which modified the update request
+     * @param userId   - The ID of the User who triggered the update workflow
+     * @template D    - the type of the Document constructor
+     * @remarks The name for this hook is dynamically created by joining "update" with the type name of the Document.
+     * @remarks This is called by {@linkcode Hooks.callAll}.
+     * @see {@link ClientDatabaseBackend._postUpdateDocumentCallbacks | `ClientDatabaseBackend#_postUpdateDocumentCallbacks`}
+     * @see {@link TokenDocument._onUpdateTokenActor | `TokenDocument#_onUpdateTokenActor`}
+     */
+    type UpdateDocument<D extends Document.Any = Document.Any> = (
+      document: D,
+      change: Document.UpdateDataForName<D["documentName"]>,
+      options: Document.Database.UpdateOptionsFor<D["documentName"]>,
+      userId: string,
+    ) => void;
+
     /**
      * A hook event that fires for every Document type before execution of a deletion workflow. Substitute the
      * Document name in the hook event to target a specific Document type, for example "preDeleteActor". This hook
@@ -1035,61 +1351,19 @@ declare global {
      * @param document - The Document instance being deleted
      * @param options  - Additional options which modify the deletion request
      * @param userId   - The ID of the requesting user, always game.user.id
-     * @typeParam D    - the type of the Document constructor
+     * @template D    - the type of the Document constructor
      * @returns Explicitly return false to prevent deletion of this Document
      * @remarks The name for this hook is dynamically created by joining "preDelete" with the type name of the Document.
-     * @remarks This is called by {@link Hooks.call}.
-     * @see {@link ClientDatabaseBackend#_preDeleteDocumentArray}.
-     * @see {@link TokenDocument#_preUpdateTokenActor}
+     * @remarks This is called by {@linkcode Hooks.call}.
+     * @see {@link ClientDatabaseBackend._preDeleteDocumentArray | `ClientDatabaseBackend#_preDeleteDocumentArray`}.
+     * @see {@link TokenDocument._preUpdateTokenActor | `TokenDocument#_preUpdateTokenActor`}
      */
-    type PreDeleteDocument<D extends Document.AnyConstructor = Document.AnyConstructor> = (
-      document: Document.ToConfiguredInstance<D>,
-      options: Document.PreDeleteOptions<FixedInstanceType<D>["documentName"]>,
+    type PreDeleteDocument<D extends Document.Any = Document.Any> = (
+      document: D,
+      options: Document.Database.PreDeleteOperationInstance<DatabaseDeleteOperation>,
       userId: string,
     ) => boolean | void;
 
-    /**
-     * A hook event that fires for every embedded Document type after conclusion of a creation workflow.
-     * Substitute the Document name in the hook event to target a specific type, for example "createToken".
-     * This hook fires for all connected clients after the creation has been processed.
-     *
-     * @param document - The new Document instance which has been created
-     * @param options  - Additional options which modified the creation request
-     * @param userId   - The ID of the User who triggered the creation workflow
-     * @typeParam D    - the type of the Document constructor
-     * @remarks The name for this hook is dynamically created by joining "create" and the type name of the Document.
-     * @remarks This is called by {@link Hooks.callAll}.
-     * @see {@link ClientDatabaseBackend#_postCreateDocumentCallbacks}
-     * @see {@link TokenDocument#_onUpdateTokenActor}
-     */
-    type CreateDocument<D extends Document.AnyConstructor = Document.AnyConstructor> = (
-      document: Document.ToConfiguredInstance<D>,
-      options: Document.OnCreateOptions<FixedInstanceType<D>["documentName"]>,
-      userId: string,
-    ) => void;
-
-    /**
-     * A hook event that fires for every Document type after conclusion of an update workflow.
-     * Substitute the Document name in the hook event to target a specific Document type, for example "updateActor".
-     * This hook fires for all connected clients after the update has been processed.
-     *
-     * @param document - The existing Document which was updated
-     * @param change   - Differential data that was used used to update the document
-     * @param options  - Additional options which modified the update request
-     * @param userId   - The ID of the User who triggered the update workflow
-     * @typeParam D    - the type of the Document constructor
-     * @remarks The name for this hook is dynamically created by joining "update" with the type name of the Document.
-     * @remarks This is called by {@link Hooks.callAll}.
-     * @see {@link ClientDatabaseBackend#_postUpdateDocumentCallbacks}
-     * @see {@link TokenDocument#_onUpdateTokenActor}
-     */
-    type UpdateDocument<D extends Document.AnyConstructor = Document.AnyConstructor> = (
-      document: Document.ToConfiguredInstance<D>,
-      change: DeepPartial<ConstructorParameters<D>[0]>,
-      options: Document.OnUpdateOptions<FixedInstanceType<D>["documentName"]>,
-      userId: string,
-    ) => void;
-
     /**
      * A hook event that fires for every Document type after conclusion of an deletion workflow.
      * Substitute the Document name in the hook event to target a specific Document type, for example "deleteActor".
@@ -1098,15 +1372,15 @@ declare global {
      * @param document - The existing Document which was deleted
      * @param options  - Additional options which modified the deletion request
      * @param userId   - The ID of the User who triggered the deletion workflow
-     * @typeParam D    - the type of the Document constructor
+     * @template D    - the type of the Document constructor
      * @remarks The name for this hook is dynamically created by joining "delete" with the type name of the Document.
-     * @remarks This is called by {@link Hooks.callAll}.
-     * @see {@link ClientDatabaseBackend#_postDeleteDocumentCallbacks}
-     * @see {@link TokenDocument#_onUpdateTokenActor}
+     * @remarks This is called by {@linkcode Hooks.callAll}.
+     * @see {@link ClientDatabaseBackend._postDeleteDocumentCallbacks | `ClientDatabaseBackend#_postDeleteDocumentCallbacks`}
+     * @see {@link TokenDocument._onUpdateTokenActor | `TokenDocument#_onUpdateTokenActor`}
      */
-    type DeleteDocument<D extends Document.AnyConstructor = Document.AnyConstructor> = (
-      document: Document.ToConfiguredInstance<D>,
-      options: Document.OnDeleteOptions<FixedInstanceType<D>["documentName"]>,
+    type DeleteDocument<D extends Document.Any = Document.Any> = (
+      document: D,
+      options: Document.Database.DeleteOptionsFor<D["documentName"]>,
       userId: string,
     ) => void;
 
@@ -1115,9 +1389,9 @@ declare global {
     /**
      * A hook event that fires after RenderedPointSource shaders have initialized.
      * @param source - The RenderedEffectSource instance being initialized
-     * @typeParam RPS - the type of the RenderedPointSource
+     * @template RPS - the type of the RenderedPointSource
      * @remarks The name for this hook is dynamically created by wrapping the type name of the shader in `initialize` and `Shaders`.
-     * @remarks This is called by {@link Hooks.callAll}.
+     * @remarks This is called by {@linkcode Hooks.callAll}.
      */
     type InitializeRenderedEffectSourceShaders<RPS extends RenderedEffectSource.Any = RenderedEffectSource.Any> = (
       source: RPS,
@@ -1126,20 +1400,20 @@ declare global {
     /** InteractionLayer */
 
     /**
-     * A hook event that fires with a {@link InteractionLayer} becomes active.
+     * A hook event that fires with a {@linkcode InteractionLayer} becomes active.
      * The dispatched event name replaces "Layer" with the named InteractionLayer subclass, i.e. "activateTokensLayer".
      * @param layer - The layer becoming active
-     * @remarks This is called by {@link Hooks.callAll}.
+     * @remarks This is called by {@linkcode Hooks.callAll}.
      */
-    type ActivateLayer<L extends InteractionLayer = InteractionLayer> = (layer: L) => void;
+    type ActivateLayer<L extends layers.InteractionLayer = layers.InteractionLayer> = (layer: L) => void;
 
     /**
-     * A hook event that fires with a {@link InteractionLayer} becomes inactive.
+     * A hook event that fires with a {@linkcode InteractionLayer} becomes inactive.
      * The dispatched event name replaces "Layer" with the named InteractionLayer subclass, i.e. "deactivateTokensLayer".
      * @param layer - The layer becoming inactive
-     * @remarks This is called by {@link Hooks.callAll}.
+     * @remarks This is called by {@linkcode Hooks.callAll}.
      */
-    type DeactivateLayer<L extends InteractionLayer = InteractionLayer> = (layer: L) => void;
+    type DeactivateLayer<L extends layers.InteractionLayer = layers.InteractionLayer> = (layer: L) => void;
 
     /**
      * A hook event that fires when the context menu for entries in an Application is constructed. Substitute the
@@ -1147,72 +1421,16 @@ declare global {
      * "getActorDirectoryEntryContext".
      * @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 = (
-      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 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}
+     * @remarks This is called by {@linkcode Hooks.call}.
+     * @see {@linkcode ContextMenu.create}
      */
-    type GetSoundContextPlaylistDirectory = (
-      app: foundry.applications.sidebar.tabs.PlaylistDirectory,
-      entryOptions: foundry.applications.ux.ContextMenu.Entry<HTMLElement>[],
+    type GetEntryContext<Application extends Application.Any = Application.Any> = (
+      app: Application,
+      entryOptions: ContextMenu.Entry<HTMLElement | JQuery>[],
     ) => 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 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 = (
-      app: foundry.applications.sidebar.DocumentDirectory,
-      entryOptions: foundry.applications.ux.ContextMenu.Entry<HTMLElement>[],
-    ) => boolean | void;
-
-    type DynamicCallbacks =
-      | RenderApplication
-      | GetApplicationHeaderButtons
-      | CloseApplication
-      | DrawGroup
-      | TearDownGroup
-      | DrawLayer
-      | TearDownLayer
-      | PastePlaceableObject
-      | DrawObject
-      | ControlObject
-      | DestroyObject
-      | HoverObject
-      | PreCreateDocument
-      | PreUpdateDocument
-      | PreDeleteDocument
-      | CreateDocument
-      | UpdateDocument
-      | DeleteDocument
-      | InitializeRenderedEffectSourceShaders
-      | ActivateLayer
-      | DeactivateLayer
-      | GetEntryContext
-      | GetSoundContextPlaylistDirectory
-      | GetSidebarDirectoryFolderContext;
-
     interface ErrorCallbackParameters {
-      "Canvas#draw": [location: "Canvas#draw", err: Error, data: { layer: CanvasLayer }];
+      "Canvas#draw": [location: "Canvas#draw", err: Error, data: { layer: layers.CanvasLayer }];
       "Application#render": [location: "Application#render", err: Error, data: Application.RenderOptions];
       "Localization#_loadTranslationFile": [
         location: "Localization#_loadTranslationFile",
@@ -1249,5 +1467,11 @@ declare global {
         data: { id: string; documentName: string },
       ];
     }
+
+    type DropData =
+      | layers.TokenLayer.DropData
+      | layers.NotesLayer.DropData
+      | layers.SoundsLayer.DropData
+      | layers.TilesLayer.DropData;
   }
 }