Repository: League-of-Foundry-Developers/foundry-vtt-types
Pull request #3361 (2025-06-02 06:59:42)

Removing client core
Finished off the client/core classes by properly removing them & migrating any remaining classes out of it.


Patch:
diff --git a/src/configuration/configuration.d.mts b/src/configuration/configuration.d.mts
index 517b83e23..558ef7300 100644
--- a/src/configuration/configuration.d.mts
+++ b/src/configuration/configuration.d.mts
@@ -267,7 +267,7 @@ export interface SettingConfig {
   "core.globalAmbientVolume": number;
   "core.globalInterfaceVolume": number;
   "core.globalPlaylistVolume": number;
-  "core.keybindings": Record<string, ClientKeybindings.KeybindingActionBinding[]>;
+  "core.keybindings": Record<string, foundry.helpers.interaction.ClientKeybindings.KeybindingActionBinding[]>;
   "core.language": fields.StringField<{
     required: true;
     blank: false;
diff --git a/src/configuration/globals.d.mts b/src/configuration/globals.d.mts
index aacc95149..2d36b0008 100644
--- a/src/configuration/globals.d.mts
+++ b/src/configuration/globals.d.mts
@@ -72,7 +72,6 @@ export import ChromaColorationShader = globalThis.ChromaColorationShader;
 export import ClientDocument = globalThis.ClientDocument;
 export import ClientIssues = globalThis.ClientIssues;
 export import ClientKeybindings = globalThis.ClientKeybindings;
-export import ClientPackage = globalThis.ClientPackage;
 export import ClientPackageMixin = globalThis.ClientPackageMixin;
 export import ClientSettings = globalThis.ClientSettings;
 export import ClipperLib = globalThis.ClipperLib;
diff --git a/src/foundry/client/av/clients/index.d.mts b/src/foundry/client/av/clients/index.d.mts
deleted file mode 100644
index f1acab6d9..000000000
--- a/src/foundry/client/av/clients/index.d.mts
+++ /dev/null
@@ -1,1 +0,0 @@
-import "./simplepeer.d.mts";
diff --git a/src/foundry/client/av/index.d.mts b/src/foundry/client/av/index.d.mts
deleted file mode 100644
index 1c29a0346..000000000
--- a/src/foundry/client/av/index.d.mts
+++ /dev/null
@@ -1,4 +0,0 @@
-import "./client.d.mts";
-import "./clients/index.d.mts";
-import "./master.d.mts";
-import "./settings.d.mts";
diff --git a/src/foundry/client/av/master.d.mts b/src/foundry/client/av/master.d.mts
index a549de26f..1a8eb31a4 100644
--- a/src/foundry/client/av/master.d.mts
+++ b/src/foundry/client/av/master.d.mts
@@ -1,5 +1,6 @@
 import type { DeepPartial, FixedInstanceType } from "#utils";
 
+import KeyboardManager = foundry.helpers.interaction.KeyboardManager;
 import AVSettings = foundry.av.AVSettings;
 import type AVConfig from "#client/applications/settings/menus/av-config.mjs";
 
diff --git a/src/foundry/client/client.d.mts b/src/foundry/client/client.d.mts
index 1c1e3b1a1..4bcc0b776 100644
--- a/src/foundry/client/client.d.mts
+++ b/src/foundry/client/client.d.mts
@@ -7,7 +7,7 @@ import "#common/primitives/_module.mjs";
 import * as _CONST from "#common/constants.mjs";
 import * as _abstract from "#common/abstract/_module.mjs";
 import * as _documents from "#common/documents/_module.mjs";
-import * as _packages from "#common/packages/_module.mjs";
+import * as _packages from "#client/packages/_module.mjs";
 // utils is exported here in the foundry file
 import * as _config from "#common/config.mjs";
 import * as _prosemirror from "#common/prosemirror/_module.mjs";
@@ -24,6 +24,7 @@ import * as _canvas from "./canvas/_module.mjs";
 import * as _helpers from "./helpers/_module.mjs";
 import * as _data from "./data/_module.mjs";
 import * as _dice from "./dice/_module.mjs";
+import * as _nue from "./nue/_module.mjs";
 import * as _utils from "./utils/_module.mjs"; // moved here to match other client exports
 
 /**
@@ -98,6 +99,8 @@ export * as data from "./data/_module.mjs";
  */
 export * as dice from "./dice/_module.mjs";
 
+export * as nue from "./nue/_module.mjs";
+
 /**
  * Shared importable types.
  */
@@ -183,6 +186,8 @@ declare global {
      * A module for parsing and executing dice roll syntax.
      */
     export import dice = _dice;
+
+    export import nue = _nue;
   }
 
   /**
@@ -190,12 +195,20 @@ declare global {
    */
   export import CONST = _CONST;
 
+  // Blessed globals - will remain global without deprecation
+
   // Color is currently handled in src/foundry/client/head.d.mts
 
   export import Collection = _utils.Collection;
 
   export import Roll = _dice.Roll;
 
+  export import fromUuid = foundry.utils.fromUuid;
+  export import fromUuidSync = foundry.utils.fromUuidSync;
+  export import getDocumentClass = foundry.utils.getDocumentClass;
+  // Hooks are a blessed global
+  // export import Hooks = foundry.helpers.Hooks;
+
   // Programmatic foundry deprecations
   // While Foundry has the benefit of applying deprecations purely programmatically,
   // We must list them one by one. This is that section, organized as best can be.
@@ -802,61 +815,61 @@ declare global {
    * @deprecated "You are accessing the global {@linkcode AsyncWorker} which is now namespaced under {@linkcode foundry.helpers.AsyncWorker}"
    * (since v13 will be removed in v15)
    */
-  // export import AsyncWorker = foundry.helpers.AsyncWorker;
+  export import AsyncWorker = foundry.helpers.AsyncWorker;
 
   /**
    * @deprecated "You are accessing the global {@linkcode ClientIssues} which is now namespaced under {@linkcode foundry.helpers.ClientIssues}"
    * (since v13 will be removed in v15)
    */
-  // export import ClientIssues = foundry.helpers.ClientIssues;
+  export import ClientIssues = foundry.helpers.ClientIssues;
 
   /**
    * @deprecated "You are accessing the global {@linkcode ClientKeybindings} which is now namespaced under {@linkcode foundry.helpers.interaction.ClientKeybindings}"
    * (since v13 will be removed in v15)
    */
-  // export import ClientKeybindings = foundry.helpers.interaction.ClientKeybindings;
+  export import ClientKeybindings = foundry.helpers.interaction.ClientKeybindings;
 
   /**
    * @deprecated "You are accessing the global {@linkcode ClientSettings} which is now namespaced under {@linkcode foundry.helpers.ClientSettings}"
    * (since v13 will be removed in v15)
    */
-  // export import ClientSettings = foundry.helpers.ClientSettings;
+  export import ClientSettings = foundry.helpers.ClientSettings;
 
   /**
    * @deprecated "You are accessing the global {@linkcode ClipboardHelper} which is now namespaced under {@linkcode foundry.helpers.interaction.ClipboardHelper}"
    * (since v13 will be removed in v15)
    */
-  // export import ClipboardHelper = foundry.helpers.interaction.ClipboardHelper;
+  export import ClipboardHelper = foundry.helpers.interaction.ClipboardHelper;
 
   /**
    * @deprecated "You are accessing the global {@linkcode DocumentIndex} which is now namespaced under {@linkcode foundry.helpers.DocumentIndex}"
    * (since v13 will be removed in v15)
    */
-  // export import DocumentIndex = foundry.helpers.DocumentIndex;
+  export import DocumentIndex = foundry.helpers.DocumentIndex;
 
   /**
    * @deprecated "You are accessing the global {@linkcode GameTime} which is now namespaced under {@linkcode foundry.helpers.GameTime}"
    * (since v13 will be removed in v15)
    */
-  // export import GameTime = foundry.helpers.GameTime;
+  export import GameTime = foundry.helpers.GameTime;
 
   /**
    * @deprecated "You are accessing the global {@linkcode GamepadManager} which is now namespaced under {@linkcode foundry.helpers.interaction.GamepadManager}"
    * (since v13 will be removed in v15)
    */
-  // export import GamepadManager = foundry.helpers.interaction.GamepadManager;
+  export import GamepadManager = foundry.helpers.interaction.GamepadManager;
 
   /**
    * @deprecated "You are accessing the global {@linkcode ImageHelper} which is now namespaced under {@linkcode foundry.helpers.media.ImageHelper}"
    * (since v13 will be removed in v15)
    */
-  // export import ImageHelper = foundry.helpers.media.ImageHelper;
+  export import ImageHelper = foundry.helpers.media.ImageHelper;
 
   /**
    * @deprecated "You are accessing the global {@linkcode KeyboardManager} which is now namespaced under {@linkcode foundry.helpers.interaction.KeyboardManager}"
    * (since v13 will be removed in v15)
    */
-  // export import KeyboardManager = foundry.helpers.interaction.KeyboardManager;
+  export import KeyboardManager = foundry.helpers.interaction.KeyboardManager;
 
   /**
    * @deprecated "You are accessing the global {@linkcode Localization} which is now namespaced under {@linkcode foundry.helpers.Localization}"
@@ -868,32 +881,121 @@ declare global {
    * @deprecated "You are accessing the global {@linkcode MouseManager} which is now namespaced under {@linkcode foundry.helpers.interaction.MouseManager}"
    * (since v13 will be removed in v15)
    */
-  // export import MouseManager = foundry.helpers.interaction.MouseManager;
+  export import MouseManager = foundry.helpers.interaction.MouseManager;
 
   /**
    * @deprecated "You are accessing the global {@linkcode SocketInterface} which is now namespaced under {@linkcode foundry.helpers.SocketInterface}"
    * (since v13 will be removed in v15)
    */
-  // export import SocketInterface = foundry.helpers.SocketInterface;
+  export import SocketInterface = foundry.helpers.SocketInterface;
 
   /**
    * @deprecated "You are accessing the global {@linkcode TooltipManager} which is now namespaced under {@linkcode foundry.helpers.interaction.TooltipManager.implementation}"
    * (since v13 will be removed in v15)
    * @privateRemarks TODO: This should return the configured class
    */
-  // export import TooltipManager = foundry.helpers.interaction.TooltipManager;
+  export import TooltipManager = foundry.helpers.interaction.TooltipManager;
 
   /**
    * @deprecated "You are accessing the global {@linkcode VideoHelper} which is now namespaced under {@linkcode foundry.helpers.media.VideoHelper}"
    * (since v13 will be removed in v15)
    */
-  // export import VideoHelper = foundry.helpers.media.VideoHelper;
+  export import VideoHelper = foundry.helpers.media.VideoHelper;
 
   /**
    * @deprecated "You are accessing the global {@linkcode WorkerManager} which is now namespaced under {@linkcode foundry.helpers.WorkerManager}"
    * (since v13 will be removed in v15)
    */
-  // export import WorkerManager = foundry.helpers.WorkerManager;
+  export import WorkerManager = foundry.helpers.WorkerManager;
+
+  /**
+   * @deprecated "You are accessing the global {@linkcode SortingHelpers} which is now namespaced under {@linkcode foundry.utils.SortingHelpers}"
+   * (since v13 will be removed in v15)
+   */
+  export import SortingHelpers = foundry.utils.SortingHelpers;
+
+  /**
+   * @deprecated "You are accessing the global {@linkcode saveDataToFile} which is now namespaced under {@linkcode foundry.utils.saveDataToFile}"
+   * (since v13 will be removed in v15)
+   */
+  export import saveDataToFile = foundry.utils.saveDataToFile;
+
+  /**
+   * @deprecated "You are accessing the global {@linkcode readTextFromFile} which is now namespaced under {@linkcode foundry.utils.readTextFromFile}"
+   * (since v13 will be removed in v15)
+   */
+  export import readTextFromFile = foundry.utils.readTextFromFile;
+
+  /**
+   * @deprecated "You are accessing the global {@linkcode NewUserExperience} which is now namespaced under {@linkcode foundry.nue.NewUserExperienceManager}"
+   * (since v13 will be removed in v15)
+   */
+  export import NewUserExperience = foundry.nue.NewUserExperienceManager;
+
+  /**
+   * @deprecated "You are accessing the global {@linkcode Tours} which is now namespaced under {@linkcode foundry.nue.ToursCollection}"
+   * (since v13 will be removed in v15)
+   */
+  export import Tours = foundry.nue.ToursCollection;
+
+  /**
+   * @deprecated "You are accessing the global {@linkcode Tour} which is now namespaced under {@linkcode foundry.nue.Tour}"
+   * (since v13 will be removed in v15)
+   */
+  export import Tour = foundry.nue.Tour;
+
+  /**
+   * @deprecated "You are accessing the global {@linkcode CanvasTour} which is now namespaced under {@linkcode foundry.nue.tours.CanvasTour}"
+   * (since v13 will be removed in v15)
+   */
+  export import CanvasTour = foundry.nue.tours.CanvasTour;
+
+  /**
+   * @deprecated "You are accessing the global {@linkcode SetupTour} which is now namespaced under {@linkcode foundry.nue.tours.SetupTour}"
+   * (since v13 will be removed in v15)
+   */
+  export import SetupTour = foundry.nue.tours.SetupTour;
+
+  /**
+   * @deprecated "You are accessing the global {@linkcode SidebarTour} which is now namespaced under {@linkcode foundry.nue.tours.SidebarTour}"
+   * (since v13 will be removed in v15)
+   */
+  export import SidebarTour = foundry.nue.tours.SidebarTour;
+
+  /**
+   * @deprecated "You are accessing the global {@linkcode ClientPackageMixin} which is now namespaced under {@linkcode foundry.packages.ClientPackageMixin}"
+   * (since v13 will be removed in v15)
+   */
+  export import ClientPackageMixin = foundry.packages.ClientPackageMixin;
+
+  /**
+   * @deprecated The ClientPackage namespace has been adjusted to ClientPackageMixin
+   */
+  export import ClientPackage = foundry.packages.ClientPackageMixin;
+
+  /**
+   * @deprecated "You are accessing the global {@linkcode Module} which is now namespaced under {@linkcode foundry.packages.Module}"
+   * (since v13 will be removed in v15)
+   */
+  export import Module = foundry.packages.Module;
+
+  /**
+   * @deprecated "You are accessing the global {@linkcode System} which is now namespaced under {@linkcode foundry.packages.System}"
+   * (since v13 will be removed in v15)
+   */
+  export import System = foundry.packages.System;
+
+  /**
+   * @deprecated "You are accessing the global {@linkcode World} which is now namespaced under {@linkcode foundry.packages.World}"
+   * (since v13 will be removed in v15)
+   */
+  export import World = foundry.packages.World;
+
+  /**
+   * @deprecated "You are accessing the global {@linkcode PACKAGE_TYPES} which is now namespaced under {@linkcode foundry.packages.PACKAGE_TYPES}"
+   * (since v13 will be removed in v15)
+   */
+  export import PACKAGE_TYPES = foundry.packages.PACKAGE_TYPES;
 
   // v12 deprecations
 
diff --git a/src/foundry/client/core/clipboard.d.mts b/src/foundry/client/core/clipboard.d.mts
deleted file mode 100644
index ec9316b42..000000000
--- a/src/foundry/client/core/clipboard.d.mts
+++ /dev/null
@@ -1,20 +0,0 @@
-export {};
-
-declare global {
-  /**
-   * A helper class to manage requesting clipboard permissions and provide common functionality for working with the
-   * clipboard.
-   */
-  class ClipboardHelper {
-    /**
-     * @throws `"You may not re-initialize the singleton ClipboardHelper. Use game.clipboard instead."`
-     */
-    constructor();
-
-    /**
-     * Copies plain text to the clipboard in a cross-browser compatible way.
-     * @param text - The text to copy.
-     */
-    copyPlainText(text: string): Promise<void>;
-  }
-}
diff --git a/src/foundry/client/core/document-index.d.mts b/src/foundry/client/core/document-index.d.mts
deleted file mode 100644
index e3c524019..000000000
--- a/src/foundry/client/core/document-index.d.mts
+++ /dev/null
@@ -1,130 +0,0 @@
-import type Document from "#common/abstract/document.d.mts";
-import type { DOCUMENT_OWNERSHIP_LEVELS } from "#common/constants.d.mts";
-
-declare global {
-  /**
-   * This class is responsible for indexing all documents available in the world and storing them in a word tree structure
-   * that allows for fast searching.
-   */
-  class DocumentIndex {
-    constructor();
-
-    /**
-     * A collection of WordTree structures for each document type.
-     * @defaultValue `{}`
-     */
-    trees: Record<string, foundry.utils.WordTree>;
-
-    /**
-     * A reverse-lookup of a document's UUID to its parent node in the word tree.
-     * @defaultValue `{}`
-     */
-    uuids: Record<string, foundry.utils.StringTree.StringTreeNode<DocumentIndex.Leaf>>;
-
-    /**
-     * Returns a Promise that resolves when the indexing process is complete.
-     */
-    get ready(): Promise<void> | null;
-
-    /**
-     * Index all available documents in the world and store them in a word tree.
-     */
-    index(): Promise<void>;
-
-    /**
-     * Return entries that match the given string prefix.
-     * @param prefix  - The prefix.
-     * @param options - Additional options to configure behaviour.
-     * @returns A number of entries that have the given prefix, grouped by document type.
-     */
-    lookup(
-      prefix: string,
-      options?: {
-        /**
-         * The maximum number of items per document type to retrieve. It is important to set this
-         * value as very short prefixes will naturally match large numbers of entries. (default: `10`)
-         * (default: `10`)
-         */
-        limit?: number;
-
-        /**
-         * Optionally provide an array of document types. Only entries of that type
-         * will be searched for. (default: `[]`)
-         */
-        documentTypes?: string[];
-
-        /**
-         * A filter function to apply to each candidate entry.
-         */
-        filterEntries?: foundry.utils.StringTree.StringTreeEntryFilter;
-
-        /**
-         * Only return entries that the user meets this ownership level for.
-         */
-        ownership?: DOCUMENT_OWNERSHIP_LEVELS;
-      },
-    ): Record<string, foundry.utils.WordTree.WordTreeEntry[]>;
-
-    /**
-     * Add an entry to the index.
-     * @param doc - The document entry.
-     */
-    addDocument(doc: foundry.abstract.Document.Any): void;
-
-    /**
-     * Remove an entry from the index.
-     * @param doc - The document entry.
-     */
-    removeDocument(doc: foundry.abstract.Document.Any): void;
-
-    /**
-     * Replace an entry in the index with an updated one.
-     * @param doc - The document entry.
-     */
-    replaceDocument(doc: foundry.abstract.Document.Any): void;
-
-    /**
-     * Add a leaf node to the word tree index.
-     * @param doc     - The document or compendium index entry to add.
-     * @param options - Additional information for indexing.
-     * @internal
-     */
-    protected _addLeaf(
-      doc: foundry.abstract.Document.Any,
-      options?: {
-        /** The compendium that the index belongs to. */
-        pack?: CompendiumCollection.Any;
-      },
-    ): void;
-
-    /**
-     * Aggregate the compendium index and add it to the word tree index.
-     * @param pack - The compendium pack.
-     * @internal
-     */
-    protected _indexCompendium(pack: CompendiumCollection.Any): void;
-
-    /**
-     * Add all of a parent document's embedded documents to the index.
-     * @param parent - The parent document.
-     * @internal
-     */
-    protected _indexEmbeddedDocuments(parent: foundry.abstract.Document.Any): void;
-
-    /**
-     * Aggregate all documents and embedded documents in a world collection and add them to the index.
-     * @param documentName - The name of the documents to index.
-     * @internal
-     */
-    protected _indexWorldCollection(documentName: string): void;
-  }
-
-  namespace DocumentIndex {
-    interface Leaf {
-      // TODO(LukeAbby): This appears to be possible to be a compendium index entry.
-      doc: Document.Any;
-      documentName: string;
-      uuid: string;
-    }
-  }
-}
diff --git a/src/foundry/client/core/gamepad.d.mts b/src/foundry/client/core/gamepad.d.mts
deleted file mode 100644
index 7ac9bc6ba..000000000
--- a/src/foundry/client/core/gamepad.d.mts
+++ /dev/null
@@ -1,76 +0,0 @@
-export {};
-
-declare global {
-  /** Management class for Gamepad events */
-  class GamepadManager {
-    constructor();
-
-    /**
-     * @defaultValue `null`
-     * @internal
-     */
-    protected _gamepadPoller: number | null;
-
-    /**
-     * The connected Gamepads
-     * @internal
-     */
-    protected _connectedGamepads: Map<string, GamepadManager.ConnectedGamepad>;
-
-    /**
-     * How often Gamepad polling should check for button presses
-     * @defaultValue `100`
-     */
-    static GAMEPAD_POLLER_INTERVAL_MS: number;
-
-    /**
-     * Begin listening to gamepad events.
-     */
-    protected _activateListeners(): void;
-
-    /**
-     * Handles a Gamepad Connection event, adding its info to the poll list
-     * @param event - The originating Event
-     * @internal
-     */
-    protected _onGamepadConnect(event: GamepadEvent): void;
-
-    /**
-     * Handles a Gamepad Disconnect event, removing it from consideration for polling
-     * @param event - The originating Event
-     * @internal
-     */
-    protected _onGamepadDisconnect(event: GamepadEvent): void;
-
-    /**
-     * Polls all Connected Gamepads for updates. If they have been updated, checks status of Axis and Buttons,
-     * firing off Keybinding Contexts as appropriate
-     * @internal
-     */
-    protected _pollGamepads(): void;
-
-    /**
-     * Converts a Gamepad Input event into a KeyboardEvent, then fires it
-     * @param gamepadId - The string representation of the Gamepad Input
-     * @param up        - True if the Input is pressed or active
-     * @param repeat    - True if the Input is being held
-     *                    (default: `false`)
-     * @internal
-     */
-    protected _handleGamepadInput(gamepadId: string, up: boolean, repeat?: boolean): void;
-  }
-
-  namespace GamepadManager {
-    /**
-     * Connected Gamepad info
-     * @remarks Copied from `resources/app/common/types.mjs`
-     */
-    interface ConnectedGamepad {
-      /** A map of axes values */
-      axes: Map<string, number>;
-
-      /** The Set of pressed Buttons */
-      activeButtons: Set<string>;
-    }
-  }
-}
diff --git a/src/foundry/client/core/hooks.d.mts b/src/foundry/client/core/hooks.d.mts
deleted file mode 100644
index 67b1d95e5..000000000
--- a/src/foundry/client/core/hooks.d.mts
+++ /dev/null
@@ -1,206 +0,0 @@
-import type { AnyFunction } from "#utils";
-import type { Hooks as HookConfig } from "#configuration";
-
-declare global {
-  /**
-   * A simple event framework used throughout Foundry Virtual Tabletop.
-   * When key actions or events occur, a "hook" is defined where user-defined callback functions can execute.
-   * This class manages the registration and execution of hooked callback functions.
-   */
-  class Hooks {
-    /**
-     * A mapping of hook events which have functions registered to them.
-     */
-    static get events(): Hooks.HookedFunction[];
-
-    /**
-     * Register a callback handler which should be triggered when a hook is triggered.
-     *
-     * @param hook    - The unique name of the hooked event
-     * @param fn      - The callback function which should be triggered when the hook event occurs
-     * @param options - Options which customize hook registration
-     * @returns An ID number of the hooked function which can be used to turn off the hook later
-     */
-    static on<K extends keyof HookConfig.HookConfig>(
-      hook: K,
-      fn: HookConfig.HookConfig[K],
-      options?: Hooks.OnOptions,
-    ): number;
-
-    /**
-     * @deprecated These hooks are now designed to be automatically inferred.
-     */
-    // eslint-disable-next-line @typescript-eslint/no-deprecated
-    static on<H extends Hooks.DynamicCallbacks>(hook: string, fn: H, options?: Hooks.OnOptions): number;
-
-    /**
-     * @deprecated This hook has been deprecated. See the hook's definition for more details.
-     */
-    static on<K extends keyof HookConfig.DeprecatedHookConfig>(
-      hook: K,
-      fn: HookConfig.DeprecatedHookConfig[K],
-      options?: Hooks.OnOptions,
-    ): number;
-
-    /**
-     * @deprecated Please merge into {@linkcode HookConfig.HookConfig | "fvtt-types/configuration/Hooks.HookConfig"} instead.
-     */
-    static on<H extends AnyFunction>(hook: string, fn: H, options?: Hooks.OnOptions): number;
-
-    /**
-     * Register a callback handler for an event which is only triggered once the first time the event occurs.
-     * An alias for Hooks.on with `{once: true}`
-     * @param hook - The unique name of the hooked event
-     * @param fn   - The callback function which should be triggered when the hook event occurs
-     * @returns An ID number of the hooked function which can be used to turn off the hook later
-     */
-    static once<K extends keyof HookConfig.HookConfig>(hook: K, fn: HookConfig.HookConfig[K]): number;
-
-    /**
-     * @deprecated These hooks are now designed to be automatically inferred.
-     */
-    // eslint-disable-next-line @typescript-eslint/no-deprecated
-    static once<H extends Hooks.DynamicCallbacks>(hook: string, fn: H): number;
-
-    /**
-     * @deprecated This hook has been deprecated. See the hook's definition for more details.
-     */
-    static once<K extends keyof HookConfig.DeprecatedHookConfig>(
-      hook: K,
-      fn: HookConfig.DeprecatedHookConfig[K],
-      options?: Hooks.OnOptions,
-    ): number;
-
-    static once<H extends AnyFunction>(hook: string, fn: H): number;
-
-    /**
-     * Unregister a callback handler for a particular hook event
-     *
-     * @param hook - The unique name of the hooked event
-     * @param fn   - The function, or ID number for the function, that should be turned off
-     */
-    static off<K extends keyof HookConfig.HookConfig>(hook: K, fn: number | HookConfig.HookConfig[K]): void;
-
-    /**
-     * @deprecated These hooks are now designed to be automatically inferred.
-     */
-    // eslint-disable-next-line @typescript-eslint/no-deprecated
-    static off<H extends Hooks.DynamicCallbacks>(hook: string, fn: number | H): void;
-
-    /**
-     * @deprecated This hook has been deprecated. See the hook's definition for more details.
-     */
-    static off<K extends keyof HookConfig.DeprecatedHookConfig>(
-      hook: K,
-      fn: number | HookConfig.DeprecatedHookConfig[K],
-      options?: Hooks.OnOptions,
-    ): void;
-
-    /**
-     * @deprecated Please merge into {@linkcode HookConfig.HookConfig | "fvtt-types/configuration/Hooks.HookConfig"} instead.
-     */
-    static off<H extends AnyFunction>(hook: string, fn: number | H): void;
-
-    /**
-     * Call all hook listeners in the order in which they were registered
-     * Hooks called this way can not be handled by returning false and will always trigger every hook callback.
-     *
-     * @param hook - The hook being triggered
-     * @param args - Arguments passed to the hook callback functions
-     */
-    static callAll<K extends keyof HookConfig.HookConfig>(hook: K, ...args: Parameters<HookConfig.HookConfig[K]>): true;
-
-    /**
-     * @deprecated These hooks are now designed to be automatically inferred.
-     */
-    // eslint-disable-next-line @typescript-eslint/no-deprecated
-    static callAll<H extends Hooks.DynamicCallbacks>(hook: string, ...args: Parameters<H>): true;
-
-    /**
-     * @deprecated This hook has been deprecated. See the hook's definition for more details.
-     */
-    static callAll<K extends keyof HookConfig.DeprecatedHookConfig>(
-      hook: K,
-      ...args: Parameters<HookConfig.DeprecatedHookConfig[K]>
-    ): true;
-
-    /**
-     * @deprecated Please merge into {@linkcode HookConfig.HookConfig | "fvtt-types/configuration/Hooks.HookConfig"} instead.
-     */
-    static callAll<H extends (...args: unknown[]) => unknown>(hook: string, ...args: Parameters<H>): true;
-
-    /**
-     * Call hook listeners in the order in which they were registered.
-     * Continue calling hooks until either all have been called or one returns false.
-     *
-     * Hook listeners which return false denote that the original event has been adequately handled and no further
-     * hooks should be called.
-     *
-     * @param hook - The hook being triggered
-     * @param args - Arguments passed to the hook callback functions
-     */
-    static call<K extends keyof HookConfig.HookConfig>(hook: K, ...args: Parameters<HookConfig.HookConfig[K]>): boolean;
-
-    /**
-     * @deprecated These hooks are now designed to be automatically inferred.
-     */
-    // eslint-disable-next-line @typescript-eslint/no-deprecated
-    static call<H extends Hooks.DynamicCallbacks>(hook: string, ...args: Parameters<H>): boolean;
-
-    /**
-     * @deprecated This hook has been deprecated. See the hook's definition for more details.
-     */
-    static call<K extends keyof HookConfig.DeprecatedHookConfig>(
-      hook: K,
-      ...args: Parameters<HookConfig.DeprecatedHookConfig[K]>
-    ): boolean;
-
-    /**
-     * @deprecated Please merge into {@linkcode HookConfig.HookConfig | "fvtt-types/configuration/Hooks.HookConfig"} instead.
-     */
-    static call<H extends (...args: unknown[]) => unknown>(hook: string, ...args: Parameters<H>): boolean;
-
-    /**
-     * Notify subscribers that an error has occurred within foundry.
-     * @param location - The method where the error was caught.
-     * @param error    - The error.
-     * @param options  - Additional options to configure behaviour.
-     */
-    static onError(location: string, error: Error, { msg, notify, log, ...data }?: Hooks.OnError): void;
-  }
-
-  namespace Hooks {
-    interface HookedFunction {
-      hook: string;
-      id: number;
-      fn: AnyFunction;
-      once: boolean;
-    }
-
-    interface OnError {
-      /**
-       * Additional data to pass to the hook subscribers.
-       * @defaultValue `{}`
-       */
-      [key: string]: unknown;
-
-      /**
-       * A message which should prefix the resulting error or notification.
-       * @defaultValue `""`
-       */
-      msg?: string | undefined;
-
-      /**
-       * The level at which to log the error to console (if at all).
-       * @defaultValue `null`
-       */
-      notify?: keyof NonNullable<typeof ui.notifications> | null | undefined;
-
-      /**
-       * The level at which to spawn a notification in the UI (if at all).
-       * @defaultValue `null`
-       */
-      log?: keyof typeof console | null | undefined;
-    }
-  }
-}
diff --git a/src/foundry/client/core/image.d.mts b/src/foundry/client/core/image.d.mts
deleted file mode 100644
index 61cb0be8f..000000000
--- a/src/foundry/client/core/image.d.mts
+++ /dev/null
@@ -1,248 +0,0 @@
-import type { InexactPartial, NullishProps } from "#utils";
-
-declare global {
-  /**
-   * A helper class to provide common functionality for working with Image objects
-   */
-  class ImageHelper {
-    /**
-     * Create thumbnail preview for a provided image path.
-     * @param src     - The string URL or DisplayObject of the texture to render to a thumbnail
-     * @param options - Additional named options passed to the {@linkcode ImageHelper.compositeCanvasTexture} method
-     *                  (default: `{}`)
-     * @returns The parsed and converted thumbnail data
-     */
-    static createThumbnail(
-      src: string | PIXI.DisplayObject,
-      options?: ImageHelper.CreateThumbnailOptions,
-    ): Promise<ImageHelper.ThumbnailReturn> | null;
-
-    /**
-     * Test whether a source file has a supported image extension type
-     * @param src - A requested image source path
-     * @returns Does the filename end with a valid image extension?
-     */
-    static hasImageExtension(src: string): boolean;
-
-    /**
-     * Composite a canvas object by rendering it to a single texture
-     * @param object  - The DisplayObject to render to a texture
-     * @param options - Additional named options
-     *                  (default: `{}`)
-     * @returns The composite Texture object
-     */
-    static compositeCanvasTexture(object: PIXI.DisplayObject, options?: ImageHelper.CompositeOptions): PIXI.Texture;
-
-    /**
-     * Extract a texture to a base64 PNG string
-     * @param texture - The Texture object to extract
-     * @param options - (default: `{}`)
-     * @returns A base64 png string of the texture
-     */
-    static textureToImage(texture: PIXI.Texture, options?: ImageHelper.TextureToImageOptions): Promise<string>;
-
-    /**
-     * Asynchronously convert a DisplayObject container to base64 using Canvas#toBlob and FileReader
-     * @param target  - A PIXI display object to convert
-     * @param type    - The requested mime type of the output, default is image/png
-     * @param quality - A number between 0 and 1 for image quality if image/jpeg or image/webp
-     * @returns A processed base64 string
-     * @privateRemarks Foundry doesn't mark `type` or `quality` as optional, but they're passed directly to `this.canvasToBase64`, where they *are* optional.
-     */
-    static pixiToBase64(
-      target: PIXI.DisplayObject,
-      type?: foundry.CONST.IMAGE_FILE_EXTENSIONS,
-      quality?: number,
-    ): Promise<string>;
-
-    /**
-     * Asynchronously convert a canvas element to base64.
-     * @param type    - (default: `"image/png"`)
-     * @param quality - JPEG or WEBP compression from 0 to 1. Default is 0.92.
-     * @returns The base64 string of the canvas.
-     */
-    static canvasToBase64(
-      canvas: HTMLCanvasElement,
-      type?: foundry.CONST.IMAGE_FILE_EXTENSIONS,
-      quality?: number,
-    ): Promise<string>;
-
-    /**
-     * Upload a base64 image string to a persisted data storage location
-     * @param base64   - The base64 string
-     * @param fileName - The file name to upload
-     * @param filePath - The file path where the file should be uploaded
-     * @param options  - Additional options which affect uploading
-     * @returns A promise which resolves to the FilePicker upload response
-     */
-    static uploadBase64(
-      base64: string,
-      fileName: string,
-      filePath: string,
-      options?: ImageHelper.UploadBase64Options,
-    ): Promise<ReturnType<typeof FilePicker.upload>>;
-
-    /**
-     * Create a canvas element containing the pixel data.
-     * @param pixels - Buffer used to create the image data.
-     * @param width  - Buffered image width.
-     * @param height - Buffered image height.
-     */
-    static pixelsToCanvas(
-      pixels: Uint8ClampedArray,
-      width: number,
-      height: number,
-      options: ImageHelper.PixelsToCanvasOptions,
-    ): HTMLCanvasElement;
-  }
-
-  namespace ImageHelper {
-    /**
-     * Helper type to simplify NullishProps usage.
-     *
-     * @remarks Letting this be NullishProps instead of InexactPartial because despite `tx` and `ty` only
-     * having defaults via `{=0}`, they either get overwritten or `*=`ed which casts null to `0`, their default anyway.
-     *
-     * @internal
-     */
-    type _CompositeOptions = NullishProps<{
-      /**
-       * Center the texture in the rendered frame?
-       * @defaultValue `true`
-       */
-      center: boolean;
-
-      /**
-       * The desired height of the output texture
-       * @defaultValue The height of the object passed to {@linkcode ImageHelper.compositeCanvasTexture}
-       */
-      height: number;
-
-      /**
-       * A horizontal translation to apply to the object
-       * @defaultValue `0`
-       */
-      tx: number;
-
-      /**
-       * A vertical translation to apply to the object
-       * @defaultValue `0`
-       */
-      ty: number;
-
-      /**
-       * The desired width of the output texture
-       * @defaultValue The width of the object passed to {@linkcode ImageHelper.compositeCanvasTexture}
-       */
-      width: number;
-    }>;
-
-    /**
-     * An interface for options for the {@linkcode ImageHelper.createThumbnail} and {@linkcode ImageHelper.compositeCanvasTexture}
-     * methods.
-     */
-    interface CompositeOptions extends _CompositeOptions {}
-
-    interface CreateThumbnailOptions extends ImageHelper.CompositeOptions, ImageHelper.TextureToImageOptions {}
-
-    type Format = "image/png" | "image/jpeg" | "image/webp";
-
-    /**
-     * Helper type to simplify NullishProps usage
-     * @remarks Letting this be NullishProps, as, after testing, passing null values to `HTMLCanvasElement#toBlob()`,
-     * where these eventually end up, doesn't break anything and seems to apply the defaults
-     *
-     * @internal
-     */
-    type _TextureToImageOptions = NullishProps<{
-      /**
-       * Image format, e.g. "image/jpeg" or "image/webp".
-       * @defaultValue `"image/png"`
-       */
-      format: Format;
-
-      /**
-       * JPEG or WEBP compression from 0 to 1. Default is 0.92.
-       * @defaultValue `0.92`
-       */
-      quality: number;
-    }>;
-
-    interface TextureToImageOptions extends _TextureToImageOptions {}
-
-    /**
-     * Intermediary type to simplify use of optionality- and nullish-permissiveness-modifying helpers
-     *
-     * @internal
-     */
-    type _UploadBase64Options = InexactPartial<{
-      /**
-       * The data storage location to which the file should be uploaded
-       * @remarks Can't be null because it's passed directly to `FilePicker.upload` and its only default is via signature default value
-       * @defaultValue `"data"`
-       */
-      storage: FilePicker.SourceType;
-    }> &
-      NullishProps<{
-        /**
-         * The MIME type of the file being uploaded
-         * @remarks Will be extracted from the base64 data, if not provided.
-         */
-        type: foundry.CONST.IMAGE_FILE_EXTENSIONS;
-
-        /**
-         * Display a UI notification when the upload is processed.
-         * @defaultValue `true`
-         */
-        notify: boolean;
-      }>;
-
-    interface UploadBase64Options extends _UploadBase64Options {}
-
-    /**
-     * An interface for return values of the {@linkcode ImageHelper.createThumbnail} method.
-     */
-    interface ThumbnailReturn {
-      /**
-       * The height of the {@linkcode PIXI.Sprite}, created by {@linkcode ImageHelper.createThumbnail}
-       */
-      height: number;
-
-      /**
-       * The originally passed `string` URL or DisplayObject
-       */
-      src: string | PIXI.DisplayObject;
-
-      /**
-       * The Texture, returned from {@linkcode ImageHelper.compositeCanvasTexture}, with `destroy(true)` already called on it.
-       */
-      texture: PIXI.Texture;
-
-      /**
-       * The base64 encoded image data, returned from {@linkcode ImageHelper.textureToImage}
-       */
-      thumb: string;
-
-      /**
-       * The width of the {@linkcode PIXI.Sprite}, created by {@linkcode ImageHelper.createThumbnail}
-       */
-      width: number;
-    }
-
-    type _PixelsToCanvasOptions = NullishProps<{
-      /**
-       * The element to use.
-       * @remarks If not provided, a new HTMLCanvasElement is created.
-       */
-      element: HTMLCanvasElement;
-
-      /** Specified width for the element (default to buffer image width). */
-      ew: number;
-
-      /** Specified height for the element (default to buffer image height). */
-      eh: number;
-    }>;
-
-    interface PixelsToCanvasOptions extends _PixelsToCanvasOptions {}
-  }
-}
diff --git a/src/foundry/client/core/index.d.mts b/src/foundry/client/core/index.d.mts
deleted file mode 100644
index 4b58acf3d..000000000
--- a/src/foundry/client/core/index.d.mts
+++ /dev/null
@@ -1,21 +0,0 @@
-import "./clipboard.d.mts";
-import "./document-index.d.mts";
-import "./gamepad.d.mts";
-import "./hooks.d.mts";
-import "./image.d.mts";
-import "./issues.d.mts";
-import "./keybindings.d.mts";
-import "./keyboard.d.mts";
-import "./mouse.d.mts";
-import "./nue.d.mts";
-import "./packages.d.mts";
-import "./settings.d.mts";
-import "./socket.d.mts";
-import "./sorting.d.mts";
-import "./time.d.mts";
-import "./tooltip.d.mts";
-import "./tour.d.mts";
-import "./tours.d.mts";
-import "./utils.d.mts";
-import "./video.d.mts";
-import "./workers.d.mts";
diff --git a/src/foundry/client/core/issues.d.mts b/src/foundry/client/core/issues.d.mts
deleted file mode 100644
index 72734a74d..000000000
--- a/src/foundry/client/core/issues.d.mts
+++ /dev/null
@@ -1,102 +0,0 @@
-import type Document from "#common/abstract/document.d.mts";
-import type { DataModelValidationError } from "#common/data/validation-failure.d.mts";
-
-declare global {
-  /**
-   * A class responsible for tracking issues in the current world.
-   */
-  class ClientIssues {
-    // placeholder private member
-    #clientIssues: true;
-
-    /**
-     * Detect and display warnings for known performance issues which may occur due to the user's hardware or browser
-     * configuration.
-     * @internal
-     */
-    _detectWebGLIssues(): void;
-
-    /**
-     * Add an invalid Document to the module-provided sub-type counts.
-     * @param cls               - The Document class.
-     * @param source            - The Document's source data.
-     * @internal
-     *
-     * @remarks official documentation says "invalid", but the document can be valid, it is simply not yet validated.
-     */
-    _countDocumentSubType(
-      cls: Document.Any,
-      source: unknown,
-      options?: {
-        /**
-         * Decrement the counter rather than incrementing it.
-         * @defaultValue `false`
-         */
-        decrement?: boolean | undefined;
-      },
-    ): void;
-
-    /**
-     * Track a validation failure that occurred in a WorldCollection.
-     * @param collection - The parent collection.
-     * @param source     - The Document's source data.
-     * @param error      - The validation error.
-     * @internal
-     */
-    _trackValidationFailures(
-      collection: WorldCollection<Document.Type, string>,
-      source: unknown,
-      error: DataModelValidationError,
-    ): void;
-
-    /**
-     * Detect and record certain usability error messages which are likely to result in the user having a bad experience.
-     * @internal
-     */
-    _detectUsabilityIssues(): void;
-
-    /**
-     * Get the Document sub-type counts for a given module.
-     * @param module - The module or its ID.
-     */
-    getSubTypeCountsFor(module: Module | string): ClientIssues.ModuleSubTypeCounts | undefined;
-
-    /**
-     * Retrieve all sub-type counts in the world.
-     */
-    getAllSubtypeCounts(): IterableIterator<[string, ClientIssues.ModuleSubTypeCounts]>;
-
-    /**
-     * Retrieve the tracked validation failures.
-     */
-    get validationFailures(): Record<Document.Type, Record<string, { name: string; error: DataModelValidationError }>>;
-
-    /**
-     * Retrieve the tracked usability issues.
-     */
-    get usabilityIssues(): Record<string, ClientIssues.UsabilityIssue>;
-
-    /**
-     * Retrieve package compatibility issues.
-     */
-    get packageCompatibilityIssues(): { error: string[]; warning: string[] };
-  }
-
-  namespace ClientIssues {
-    interface UsabilityIssue {
-      /** The pre-localized message to display in relation to the usability issue. */
-      message: string;
-
-      /** The severity of the issue, either "error", "warning", or "info". */
-      severity: "error" | "warning" | "info";
-
-      /** Parameters to supply to the localization. */
-      params?: Record<string, object> | undefined;
-    }
-
-    /**
-     * An object structure of document types at the top level, with a count of different sub-types for that document type.
-     */
-    interface ModuleSubTypeCounts extends Record<Document.Type, Record<string, number>> {}
-  }
-}
diff --git a/src/foundry/client/core/keybindings.d.mts b/src/foundry/client/core/keybindings.d.mts
deleted file mode 100644
index 06d4f663d..000000000
--- a/src/foundry/client/core/keybindings.d.mts
+++ /dev/null
@@ -1,415 +0,0 @@
-import type { LazyUnknown, ValueOf } from "#utils";
-
-import Game = foundry.Game;
-
-declare global {
-  /**
-   * A class responsible for managing defined game keybinding.
-   * Each keybinding is a string key/value pair belonging to a certain namespace and a certain store scope.
-   *
-   * When Foundry Virtual Tabletop is initialized, a singleton instance of this class is constructed within the global
-   * Game object as as game.keybindings.
-   *
-   * @see {@linkcode Game.keybindings}
-   * @see {@linkcode SettingKeybindingConfig}
-   * @see {@linkcode KeybindingsConfig}
-   */
-  class ClientKeybindings {
-    constructor();
-
-    /** Registered Keybinding actions */
-    actions: Map<string, ClientKeybindings.KeybindingActionConfig>;
-
-    /** A mapping of a string key to possible Actions that might execute off it */
-    activeKeys: Map<string, ClientKeybindings.KeybindingAction[]>;
-
-    /**
-     * A stored cache of Keybind Actions Ids to Bindings
-     * @remarks This is only undefined before the "ready" hook.
-     */
-    bindings: Map<string, ClientKeybindings.KeybindingActionBinding[]> | undefined;
-
-    /**
-     * A count of how many registered keybindings there are
-     * @internal
-     * @defaultValue `0`
-     */
-    protected _registered: number;
-
-    /**
-     * A timestamp which tracks the last time a pan operation was performed
-     * @internal
-     * @defaultValue `0`
-     */
-    protected _moveTime: number;
-
-    static MOVEMENT_DIRECTIONS: ClientKeybindings.MovementDirections;
-
-    static ZOOM_DIRECTIONS: ClientKeybindings.ZoomDirections;
-
-    /**
-     * An alias of the movement key set tracked by the keyboard
-     */
-    get moveKeys(): Set<string>;
-
-    /** Initializes the keybinding values for all registered actions */
-    initialize(): void;
-
-    /**
-     * Register a new keybinding
-     *
-     * @param namespace - The namespace the Keybinding Action belongs to
-     * @param action    - A unique machine-readable id for the Keybinding Action
-     * @param data      - Configuration for keybinding data
-     *
-     * @example Define a keybinding which shows a notification
-     * ```typescript
-     * game.keybindings.register("myModule", "showNotification", {
-     *   name: "My Settings Keybinding",
-     *   hint: "A description of what will occur when the Keybinding is executed.",
-     *   uneditable: [
-     *     {
-     *       key: "Digit1",
-     *       modifiers: ["Control"]
-     *     }
-     *   ],
-     *   editable: [
-     *     {
-     *       key: "F1"
-     *     }
-     *   ],
-     *   onDown: () => { ui.notifications.info("Pressed!") },
-     *   onUp: () => {},
-     *   restricted: true,                         // Restrict this Keybinding to gamemaster only?
-     *   reservedModifiers: ["Alt""],              // If the ALT modifier is pressed, the notification is permanent instead of temporary
-     *   precedence: CONST.KEYBINDING_PRECEDENCE.NORMAL
-     * }
-     * ```
-     * @throws if called after `this.bindings` has been initialized.
-     */
-    register(namespace: string, action: string, data: ClientKeybindings.KeybindingActionConfig): void;
-
-    /**
-     * Get the current Bindings of a given namespace's Keybinding Action
-     *
-     * @param namespace - The namespace under which the setting is registered
-     * @param action    - The keybind action to retrieve
-     *
-     * @example Retrieve the current Keybinding Action Bindings
-     * ```typescript
-     * game.keybindings.get("myModule", "showNotification");
-     * ```
-     */
-    get(namespace: string, action: string): ClientKeybindings.KeybindingActionBinding[];
-
-    /**
-     * Set the editable Bindings of a Keybinding Action for a certain namespace and Action
-     *
-     * @param namespace - The namespace under which the Keybinding is registered
-     * @param action    - The Keybinding action to set
-     * @param bindings  - The Bindings to assign to the Keybinding
-     *
-     * @example Update the current value of a keybinding
-     * ```typescript
-     * game.keybindings.set("myModule", "showNotification", [
-     *     {
-     *       key: "F2",
-     *       modifiers: [ "CONTROL" ]
-     *     }
-     * ]);
-     * ```
-     * @remarks Passing `undefined` or nothing as `bindings` resets to the default.
-     */
-    set(namespace: string, action: string, bindings?: ClientKeybindings.KeybindingActionBinding[]): Promise<void>;
-
-    /** Reset all client keybindings back to their default configuration. */
-    resetDefaults(): Promise<void>;
-
-    /**
-     * A helper method that, when given a value, ensures that the returned value is a standardized Binding array
-     * @param values - An array of keybinding assignments to be validated
-     * @returns An array of keybinding assignments confirmed as valid
-     * @internal
-     */
-    protected static _validateBindings(
-      values: Array<ClientKeybindings.KeybindingActionBinding>,
-    ): Array<Required<ClientKeybindings.KeybindingActionBinding>>;
-
-    /**
-     * Validate that assigned modifiers are allowed
-     * @param keys - An array of modifiers which may be valid
-     * @returns An array of modifiers which are confirmed as valid
-     * @internal
-     */
-    protected static _validateModifiers(keys: string[]): string[];
-
-    /**
-     * Compares two Keybinding Actions based on their Order
-     * @param a - The first Keybinding Action
-     * @param b - the second Keybinding Action
-     * @internal
-     */
-    static _compareActions(a: ClientKeybindings.KeybindingAction, b: ClientKeybindings.KeybindingAction): number;
-
-    /**
-     * Register core keybindings.
-     * @param view           - The active game view
-     */
-    protected _registerCoreKeybindings(view: Game.View): void;
-
-    /**
-     * Handle Select all action
-     * @param context - The context data of the event
-     * @internal
-     */
-    protected static _onSelectAllObjects(context?: KeyboardManager.KeyboardEventContext): boolean;
-
-    /**
-     * Handle Cycle View actions
-     * @param context - The context data of the event
-     * @internal
-     */
-    protected static _onCycleView(context: KeyboardManager.KeyboardEventContext): boolean;
-
-    /**
-     * Handle Dismiss actions
-     * @param context - The context data of the event
-     * @internal
-     */
-    protected static _onDismiss(context?: KeyboardManager.KeyboardEventContext): Promise<boolean>;
-
-    /**
-     * Open Character sheet for current token or controlled actor
-     * @param context - The context data of the event
-     * @internal
-     */
-    protected static _onToggleCharacterSheet(
-      context?: KeyboardManager.KeyboardEventContext,
-    ): ReturnType<Game["toggleCharacterSheet"]>;
-
-    /**
-     * Handle action to target the currently hovered token.
-     * @param context - The context data of the event
-     * @internal
-     */
-    protected static _onTarget(context: KeyboardManager.KeyboardEventContext): boolean;
-
-    /**
-     * Handle DELETE Keypress Events
-     * @param context - The context data of the event
-     * @internal
-     */
-    protected static _onDelete(context?: KeyboardManager.KeyboardEventContext): boolean;
-
-    /**
-     * Handle keyboard movement once a small delay has elapsed to allow for multiple simultaneous key-presses.
-     * @param context - The context data of the event
-     * @param layer   - The active InteractionLayer instance
-     * @internal
-     */
-    protected _handleMovement(context: KeyboardManager.KeyboardEventContext, layer: InteractionLayer): void;
-
-    /** Handle panning the canvas using CTRL + directional keys */
-    protected _handleCanvasPan(): ReturnType<Canvas["animatePan"]>;
-
-    /**
-     * Handle Measured Ruler Movement Action
-     * @param context - The context data of the event
-     * @internal
-     */
-    protected static _onMeasuredRulerMovement(context?: KeyboardManager.KeyboardEventContext): boolean | void;
-
-    /**
-     * Handle Pause Action
-     * @param context - The context data of the event
-     * @internal
-     */
-    protected static _onPause(context?: KeyboardManager.KeyboardEventContext): true;
-
-    /**
-     * Handle Highlight action
-     * @param context - The context data of the event
-     * @internal
-     */
-    protected static _onHighlight(context?: KeyboardManager.KeyboardEventContext): boolean;
-
-    /**
-     * Handle Pan action
-     * @param context            - The context data of the event
-     * @param movementDirections - The Directions being panned in
-     * @internal
-     */
-    protected _onPan(
-      context: KeyboardManager.KeyboardEventContext,
-      movementDirections: ClientKeybindings.MovementDirection[],
-    ): boolean;
-
-    /**
-     * Handle Macro executions
-     * @param context - The context data of the event
-     * @internal
-     */
-    protected static _onMacroExecute(
-      context: KeyboardManager.KeyboardEventContext,
-      number: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 0,
-    ): boolean;
-
-    /**
-     * Handle Macro page swaps
-     * @param context - The context data of the event
-     * @internal
-     */
-    protected static _onMacroPageSwap(context: KeyboardManager.KeyboardEventContext, page: number): true;
-
-    /**
-     * Handle action to copy data to clipboard
-     * @param context - The context data of the event
-     * @internal
-     */
-    protected static _onCopy(context?: KeyboardManager.KeyboardEventContext): boolean;
-
-    /**
-     * Handle Paste action
-     * @param context - The context data of the event
-     * @internal
-     */
-    protected static _onPaste(context: KeyboardManager.KeyboardEventContext): boolean;
-
-    /**
-     * Handle Undo action
-     * @param context - The context data of the event
-     * @internal
-     */
-    protected static _onUndo(context?: KeyboardManager.KeyboardEventContext): boolean;
-
-    /**
-     * Handle presses to keyboard zoom keys
-     * @param context       - The context data of the event
-     * @param zoomDirection - The direction to zoom
-     * @internal
-     */
-    protected static _onZoom(
-      context: KeyboardManager.KeyboardEventContext | LazyUnknown,
-      zoomDirection: ClientKeybindings.ZoomDirection,
-    ): boolean;
-
-    /**
-     * Bring the chat window into view and focus the input
-     * @param context - The context data of the event
-     * @internal
-     */
-    static _onFocusChat(context: KeyboardManager.KeyboardEventContext): boolean;
-  }
-
-  namespace ClientKeybindings {
-    /**
-     * A Client Keybinding Action Configuration
-     * @remarks Copied from `resources/app/common/types.mjs`
-     */
-    interface KeybindingActionConfig {
-      /** The namespace within which the action was registered */
-      namespace?: string;
-
-      /** The human readable name */
-      name: string;
-
-      /** An additional human readable hint */
-      hint?: string | undefined;
-
-      /** The default bindings that can never be changed nor removed. */
-      uneditable?: KeybindingActionBinding[] | undefined;
-
-      /** The default bindings that can be changed by the user. */
-      editable?: KeybindingActionBinding[] | undefined;
-
-      /** A function to execute when a key down event occurs. If True is returned, the event is consumed and no further keybinds execute. */
-      onDown?: ((ctx: KeyboardManager.KeyboardEventContext) => boolean | void) | undefined;
-
-      /** A function to execute when a key up event occurs. If True is returned, the event is consumed and no further keybinds execute. */
-      onUp?: ((ctx: KeyboardManager.KeyboardEventContext) => boolean | void) | undefined;
-
-      /** If True, allows Repeat events to execute the Action's onDown. Defaults to false. */
-      repeat?: boolean | undefined;
-
-      /** If true, only a GM can edit and execute this Action */
-      restricted?: boolean | undefined;
-
-      /** Modifiers such as [ "CONTROL" ] that can be also pressed when executing this Action. Prevents using one of these modifiers as a Binding. */
-      reservedModifiers?: string[] | undefined;
-
-      /** The preferred precedence of running this Keybinding Action */
-      precedence?: number | undefined; // TODO: KEYBINDING_PRECEDENCE?
-
-      /** The recorded registration order of the action */
-      order?: number | undefined;
-    }
-
-    /**
-     * A Client Keybinding Action Binding
-     * @remarks Copied from `resources/app/common/types.mjs`
-     */
-    interface KeybindingActionBinding {
-      /** A numeric index which tracks this bindings position during form rendering */
-      index?: number | undefined;
-
-      /** The KeyboardEvent#code value from https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/code/code_values */
-      key: string;
-
-      /** An array of modifiers keys from KeyboardManager.MODIFIER_KEYS which are required for this binding to be activated */
-      modifiers?: string[] | undefined;
-    }
-
-    /**
-     * An action that can occur when a key is pressed
-     * @remarks Copied from `resources/app/common/types.mjs`
-     */
-    interface KeybindingAction {
-      /** The namespaced machine identifier of the Action */
-      action: string;
-
-      /** The Keyboard key */
-      key: string;
-
-      /** The human readable name */
-      name: string;
-
-      /** Required modifiers */
-      requiredModifiers: string[];
-
-      /** Optional (reserved) modifiers */
-      optionalModifiers: string[];
-
-      /** The handler that executes onDown */
-      onDown?: ((ctx: KeyboardManager.KeyboardEventContext) => boolean | void) | undefined;
-
-      /** The handler that executes onUp */
-      onUp?: ((ctx: KeyboardManager.KeyboardEventContext) => boolean | void) | undefined;
-
-      /** If True, allows Repeat events to execute this Action's onDown */
-      repeat: boolean;
-
-      /** If true, only a GM can execute this Action */
-      restricted: boolean;
-
-      /** The registration precedence */
-      precedence: number;
-
-      /** The registration order */
-      order: number;
-    }
-
-    interface MovementDirections {
-      UP: "up";
-      LEFT: "left";
-      DOWN: "down";
-      RIGHT: "right";
-    }
-    type MovementDirection = ValueOf<MovementDirections>;
-
-    interface ZoomDirections {
-      IN: "in";
-      OUT: "out";
-    }
-    type ZoomDirection = ValueOf<ZoomDirections>;
-  }
-}
diff --git a/src/foundry/client/core/keyboard.d.mts b/src/foundry/client/core/keyboard.d.mts
deleted file mode 100644
index ebcbae176..000000000
--- a/src/foundry/client/core/keyboard.d.mts
+++ /dev/null
@@ -1,271 +0,0 @@
-export {};
-
-declare global {
-  /**
-   * A set of helpers and management functions for dealing with user input from keyboard events.
-   * {@link https://keycode.info/}
-   */
-  class KeyboardManager {
-    constructor();
-
-    /**
-     * Begin listening to keyboard events.
-     */
-    protected _activateListeners(): void;
-
-    /**
-     * The set of key codes which are currently depressed (down)
-     */
-    downKeys: Set<string>;
-
-    /**
-     * The set of movement keys which were recently pressed
-     */
-    moveKeys: Set<string>;
-
-    /**
-     * Allowed modifier keys
-     */
-    static MODIFIER_KEYS: {
-      CONTROL: "Control";
-      SHIFT: "Shift";
-      ALT: "Alt";
-    };
-
-    /**
-     * Track which KeyboardEvent#code presses associate with each modifier
-     */
-    static MODIFIER_CODES: {
-      Alt: ["AltLeft", "AltRight"];
-      Control: ["ControlLeft", "ControlRight", "MetaLeft", "MetaRight", "Meta", "OsLeft", "OsRight"];
-      Shift: ["ShiftLeft", "ShiftRight"];
-    };
-
-    /**
-     * Key codes which are "protected" and should not be used because they are reserved for browser-level actions.
-     */
-    static PROTECTED_KEYS: ["F5", "F11", "F12", "PrintScreen", "ScrollLock", "NumLock", "CapsLock"];
-
-    /** The OS-specific string display for what their Command key is */
-    static CONTROL_KEY_STRING: "⌘" | "Control";
-
-    /**
-     * A special mapping of how special KeyboardEvent#code values should map to displayed strings or symbols.
-     * Values in this configuration object override any other display formatting rules which may be applied.
-     */
-    static KEYCODE_DISPLAY_MAPPING: {
-      ArrowLeft: "←" | "🡸";
-      ArrowRight: "→" | "🡺";
-      ArrowUp: "↑" | "🡹";
-      ArrowDown: "↓" | "🡻";
-      Backquote: "`";
-      Backslash: "\\";
-      BracketLeft: "[";
-      BracketRight: "]";
-      Comma: ",";
-      Control: (typeof KeyboardManager)["CONTROL_KEY_STRING"];
-      Equal: "=";
-      Meta: "⌘" | "⊞";
-      MetaLeft: "⌘" | "⊞";
-      MetaRight: "⌘" | "⊞";
-      OsLeft: "⌘" | "⊞";
-      OsRight: "⌘" | "⊞";
-      Minus: "-";
-      NumpadAdd: "Numpad+";
-      NumpadSubtract: "Numpad-";
-      Period: ".";
-      Quote: "'";
-      Semicolon: ";";
-      Slash: "/";
-    };
-
-    /**
-     * Test whether an HTMLElement currently has focus.
-     * If so we normally don't want to process keybinding actions.
-     */
-    get hasFocus(): boolean;
-
-    /**
-     * Emulates a key being pressed, triggering the Keyboard event workflow.
-     * @param up       - If True, emulates the `keyup` Event. Else, the `keydown` event
-     * @param code     - The KeyboardEvent#code which is being pressed
-     * @param altKey   - Emulate the ALT modifier as pressed
-     *                   (default: `false`)
-     * @param ctrlKey  - Emulate the CONTROL modifier as pressed
-     *                   (default: `false`)
-     * @param shiftKey - Emulate the SHIFT modifier as pressed
-     *                   (default: `false`)
-     * @param repeat   - Emulate this as a repeat event
-     *                   (default: `false`)
-     * @param force    - Force the event to be handled.
-     *                   (default: `false`)
-     */
-    static emulateKeypress(
-      up: boolean,
-      key: string,
-      {
-        altKey,
-        ctrlKey,
-        shiftKey,
-        repeat,
-        force,
-      }?: { altKey?: boolean; ctrlKey?: boolean; shiftKey?: boolean; repeat?: boolean; force?: boolean },
-    ): KeyboardManager.KeyboardEventContext;
-
-    /**
-     * Format a KeyboardEvent#code into a displayed string.
-     * @param code - The input code
-     * @returns The displayed string for this code
-     */
-    static getKeycodeDisplayString(code: string): string;
-
-    /**
-     * Get a standardized keyboard context for a given event.
-     * Every individual keypress is uniquely identified using the KeyboardEvent#code property.
-     * A list of possible key codes is documented here: https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/code/code_values
-     *
-     * @param event - The originating keypress event
-     * @param up    - A flag for whether the key is down or up
-     *                (default: `false`)
-     * @returns The standardized context of the event
-     */
-    static getKeyboardEventContext(event: KeyboardEvent, up: boolean): KeyboardManager.KeyboardEventContext;
-
-    /**
-     * Report whether a modifier in KeyboardManager.MODIFIER_KEYS is currently actively depressed.
-     * @param modifier - A modifier in MODIFIER_KEYS
-     * @returns Is this modifier key currently down (active)?
-     */
-    isModifierActive(modifier: string): boolean;
-
-    /**
-     * Report whether a core action key is currently actively depressed.
-     * @param action       - The core action to verify (ex: "target")
-     * @returns              Is this core action key currently down (active)?
-     */
-    isCoreActionKeyActive(action: string): boolean;
-
-    /**
-     * Converts a Keyboard Context event into a string representation, such as "C" or "Control+C"
-     * @param context          - The standardized context of the event
-     * @param includeModifiers - If True, includes modifiers in the string representation
-     *                           (default: `true`)
-     * @internal
-     */
-    protected static _getContextDisplayString(
-      context: KeyboardManager.KeyboardEventContext,
-      includeModifiers?: boolean,
-    ): string;
-
-    /**
-     * Given a standardized pressed key, find all matching registered Keybind Actions.
-     * @param context - A standardized keyboard event context
-     * @returns The matched Keybind Actions. May be empty.
-     * @internal
-     */
-    static _getMatchingActions(context: KeyboardManager.KeyboardEventContext): ClientKeybindings.KeybindingAction[];
-
-    /**
-     * Test whether a keypress context matches the registration for a keybinding action
-     * @param action  - The keybinding action
-     * @param context - The keyboard event context
-     * @returns Does the context match the action requirements?
-     * @internal
-     */
-    protected static _testContext(
-      action: ClientKeybindings.KeybindingAction,
-      context: KeyboardManager.KeyboardEventContext,
-    ): boolean;
-
-    /**
-     * Given a registered Keybinding Action, executes the action with a given event and context
-     *
-     * @param keybind - The registered Keybinding action to execute
-     * @param context - The gathered context of the event
-     * @returns Returns true if the keybind was consumed
-     * @internal
-     */
-    protected static _executeKeybind(
-      keybind: ClientKeybindings.KeybindingAction,
-      context: KeyboardManager.KeyboardEventContext,
-    ): boolean;
-
-    /**
-     * Processes a keyboard event context, checking it against registered keybinding actions
-     * @param context - The keyboard event context
-     * @internal
-     */
-    protected _processKeyboardContext(context: KeyboardManager.KeyboardEventContext): void;
-
-    /**
-     * Reset tracking for which keys are in the down and released states
-     * @internal
-     */
-    protected _reset(): void;
-
-    /**
-     * Emulate a key-up event for any currently down keys. When emulating, we go backwards such that combinations such as
-     * "CONTROL + S" emulate the "S" first in order to capture modifiers.
-     * @param force - Force the keyup events to be handled.
-     */
-    releaseKeys({ force }?: { force: boolean }): void;
-
-    /**
-     * Handle a key press into the down position
-     * @param event - The originating keyboard event
-     * @param up    - A flag for whether the key is down or up
-     * @internal
-     */
-    protected _handleKeyboardEvent(event: KeyboardEvent, up: boolean): void;
-
-    /**
-     * Input events do not fire with isComposing = false at the end of a composition event in Chrome
-     * See: https://github.com/w3c/uievents/issues/202
-     */
-    protected _onCompositionEnd(event: CompositionEvent): void;
-
-    /**
-     * Release any down keys when focusing a form element.
-     * @param event - The focus event.
-     */
-    protected _onFocusIn(event: FocusEvent): void;
-  }
-
-  namespace KeyboardManager {
-    /**
-     * Keyboard event context
-     * @remarks Copied from `resources/app/common/types.mjs`
-     */
-    interface KeyboardEventContext {
-      /** The normalized string key, such as "A" */
-      key: string;
-
-      /** The originating keypress event */
-      event: KeyboardEvent;
-
-      /** Is the Shift modifier being pressed */
-      isShift: boolean;
-
-      /** Is the Control or Meta modifier being processed */
-      isControl: boolean;
-
-      /** Is the Alt modifier being pressed */
-      isAlt: boolean;
-
-      /** Are any of the modifiers being pressed */
-      hasModifier: boolean;
-
-      /** A list of string modifiers applied to this context, such as [ "CONTROL" ] */
-      modifiers: string[];
-
-      /** True if the Key is Up, else False if down */
-      up: boolean;
-
-      /** True if the given key is being held down such that it is automatically repeating. */
-      repeat: boolean;
-
-      /** The executing Keybinding Action. May be undefined until the action is known. */
-      action?: string | undefined;
-    }
-  }
-}
diff --git a/src/foundry/client/core/mouse.d.mts b/src/foundry/client/core/mouse.d.mts
deleted file mode 100644
index e58ec6531..000000000
--- a/src/foundry/client/core/mouse.d.mts
+++ /dev/null
@@ -1,28 +0,0 @@
-export {};
-
-declare global {
-  /** Management class for Mouse events */
-  class MouseManager {
-    constructor();
-
-    /**
-     * Specify a rate limit for mouse wheel to gate repeated scrolling.
-     * This is especially important for continuous scrolling mice which emit hundreds of events per second.
-     * This designates a minimum number of milliseconds which must pass before another wheel event is handled
-     * @defaultValue `50`
-     */
-    static MOUSE_WHEEL_RATE_LIMIT: number;
-
-    /**
-     * Begin listening to mouse events.
-     */
-    protected _activateListeners(): void;
-
-    /**
-     * Master mouse-wheel event handler
-     * @param event - The mouse wheel event
-     * @internal
-     */
-    protected _onWheel(event: MouseEvent): void;
-  }
-}
diff --git a/src/foundry/client/core/nue.d.mts b/src/foundry/client/core/nue.d.mts
deleted file mode 100644
index 7172215cc..000000000
--- a/src/foundry/client/core/nue.d.mts
+++ /dev/null
@@ -1,38 +0,0 @@
-export {};
-
-declare global {
-  /**
-   * Responsible for managing the New User Experience workflows.
-   */
-  class NewUserExperience {
-    constructor();
-
-    /**
-     * Initialize the new user experience.
-     * Currently, this generates some chat messages with hints for getting started if we detect this is a new world.
-     */
-    initialize(): void;
-
-    /**
-     * Add event listeners to the chat card links.
-     * @param msg  - The ChatMessage being rendered.
-     * @param html - The HTML content of the message.
-     * @internal
-     */
-    protected _activateListeners(msg: ChatMessage.Implementation, html: JQuery): void;
-
-    /**
-     * Perform some special action triggered by clicking on a link in a NUE chat card.
-     * @param event - The click event.
-     * @internal
-     */
-    protected _onActionLink(event: Event): void;
-
-    /**
-     * Switch to the appropriate tab when a user clicks on a link in the chat message.
-     * @param event - The click event.
-     * @internal
-     */
-    protected _onTabLink(event: Event): void;
-  }
-}
diff --git a/src/foundry/client/core/packages.d.mts b/src/foundry/client/core/packages.d.mts
deleted file mode 100644
index ab5ff32fc..000000000
--- a/src/foundry/client/core/packages.d.mts
+++ /dev/null
@@ -1,526 +0,0 @@
-import type { FixedInstanceType, Mixin } from "#utils";
-import type { CONST } from "#client/client.d.mts";
-import type BasePackage from "#common/packages/base-package.d.mts";
-import type AdditionalTypesField from "#common/packages/sub-types.d.mts";
-import type DataModel from "#common/abstract/data.mjs";
-
-import fields = foundry.data.fields;
-import Game = foundry.Game;
-
-declare class ClientPackage {
-  /** @privateRemarks All mixin classses should accept anything for its constructor. */
-  constructor(...args: any[]);
-
-  /**
-   * Is this package marked as a favorite?
-   * This boolean is currently only populated as true in the /setup view of the software.
-   */
-  favorite: false;
-
-  /**
-   * Associate package availability with certain badge for client-side display.
-   */
-  getVersionBadge(): ClientPackage.PackageCompatibilityBadge | null;
-
-  /**
-   * Determine a version badge for the provided compatibility data.
-   * @param availability - The availability level.
-   * @param data         - The compatibility data.
-   * @param options      - (default: `{}`)
-   */
-  static getVersionBadge(
-    availability: CONST.PACKAGE_AVAILABILITY_CODES,
-    data: Partial<PackageManifestData>,
-    options: ClientPackage.GetVersionBadgeOptions,
-  ): ClientPackage.PackageCompatibilityBadge | null;
-
-  /**
-   * List missing dependencies and format them for display.
-   * @param availability - The availability level.
-   * @param data         - The compatibility data.
-   * @param options      - (default: `{}`)
-   */
-  static _formatBadDependenciesTooltip(
-    availability: CONST.PACKAGE_AVAILABILITY_CODES,
-    data: Partial<PackageManifestData>,
-    options: ClientPackage.FormatBadDependenciesTooltipOptions,
-  ): string;
-
-  /**
-   * List missing dependencies and format them for display.
-   * @param availability - The availability level.
-   * @param data         - The compatibility data.
-   * @param options      - (default: `{}`)
-   */
-  static _formatIncompatibleSystemsTooltip(
-    availability: CONST.PACKAGE_AVAILABILITY_CODES,
-    data: Partial<PackageManifestData>,
-    options: ClientPackage.FormatIncompatibleSystemsTooltipOptions,
-  ): string;
-
-  /**
-   * When a package has been installed, add it to the local game data.
-   */
-  install(): void;
-
-  /**
-   * When a package has been uninstalled, remove it from the local game data.
-   */
-  uninstall(): void;
-
-  /**
-   * Remove a package from the local game data when it has been uninstalled.
-   * @param id - The package ID.
-   */
-  static uninstall(id: string): void;
-
-  /**
-   * Retrieve the latest Package manifest from a provided remote location.
-   * @param manifest - A remote manifest URL to load
-   * @param options  - Additional options which affect package construction
-   * @returns A Promise which resolves to a constructed ServerPackage instance
-   * @throws An error if the retrieved manifest data is invalid
-   */
-  static fromRemoteManifest(
-    manifest: string,
-    options: ClientPackage.FromRemoteManifestOptions,
-  ): Promise<ClientPackage | null>;
-}
-
-declare global {
-  namespace ClientPackage {
-    interface PackageCompatibilityBadge {
-      type: "safe" | "unsafe" | "warning" | "neutral" | "error";
-      tooltip: string;
-      label?: string;
-      icon?: string;
-    }
-
-    interface ModuleCreateData extends Module.CreateData {
-      active: boolean;
-    }
-
-    interface SystemCreateData extends foundry.packages.BaseSystem.CreateData {
-      strictDataCleaning?: boolean;
-    }
-
-    interface GetVersionBadgeOptions {
-      /**
-       * A specific collection of modules to test availability against. Tests against the currently installed modules by default.
-       */
-      modules?: Collection<Module>;
-
-      /**
-       * A specific collection of systems to test availability against. Tests against the currently installed systems by default.
-       */
-      systems?: Collection<System>;
-    }
-
-    interface FormatBadDependenciesTooltipOptions {
-      /**
-       * A specific collection of modules to test availability against. Tests against the currently installed modules by default.
-       */
-      modules?: Collection<Module> | undefined;
-
-      /**
-       * A specific collection of systems to test availability against. Tests against the currently installed systems by default.
-       */
-      systems?: Collection<System> | undefined;
-    }
-
-    interface FormatIncompatibleSystemsTooltipOptions {
-      /**
-       * A specific collection of systems to test availability against. Tests against the currently installed systems by default.
-       */
-      systems?: Collection<System> | undefined;
-    }
-
-    interface FromRemoteManifestOptions {
-      /**
-       * Whether to construct the remote package strictly
-       * @defaultValue `true`
-       */
-      strict?: boolean | undefined;
-    }
-  }
-
-  /**
-   * A client-side mixin used for all Package types.
-   * @param BasePackage - The parent BasePackage class being mixed
-   * @returns A BasePackage subclass mixed with ClientPackage features
-   */
-  function ClientPackageMixin<BaseClass extends ClientPackageMixin.BaseClass>(
-    BasePackage: BaseClass,
-  ): Mixin<typeof ClientPackage, BaseClass>;
-
-  namespace ClientPackageMixin {
-    interface AnyMixedConstructor extends ReturnType<typeof ClientPackageMixin<BaseClass>> {}
-    interface AnyMixed extends FixedInstanceType<AnyMixedConstructor> {}
-
-    type BaseClass = BasePackage.Internal.Constructor;
-  }
-
-  class Module extends ClientPackageMixin(foundry.packages.BaseModule) {
-    constructor(data: ClientPackage.ModuleCreateData, options: unknown);
-
-    /**
-     * Is this package currently active?
-     */
-    readonly active: boolean;
-  }
-
-  namespace Module {
-    /**
-     * The data put in {@linkcode DataModel._source}. This data is what was
-     * persisted to the database and therefore it must be valid JSON.
-     *
-     * For example a {@link fields.SetField | `SetField`} is persisted to the database as an array
-     * but initialized as a {@linkcode Set}.
-     */
-    interface Source extends fields.SchemaField.SourceData<Schema> {}
-
-    /**
-     * The data necessary to create a data model. Used in places like {@linkcode Module.create}
-     * and {@link Module | `new Module(...)`}.
-     *
-     * For example a {@link fields.SetField | `SetField`} can accept any {@linkcode Iterable}
-     * with the right values. This means you can pass a `Set` instance, an array of values,
-     * a generator, or any other iterable.
-     */
-    interface CreateData extends fields.SchemaField.CreateData<Schema> {}
-
-    /**
-     * The data after a {@linkcode DataModel} has been initialized, for example
-     * {@link Module.name | `Module#name`}.
-     *
-     * This is data transformed from {@linkcode Module.Source} and turned into more
-     * convenient runtime data structures. For example a {@link fields.SetField | `SetField`} is
-     * persisted to the database as an array of values but at runtime it is a `Set` instance.
-     */
-    interface InitializedData extends fields.SchemaField.InitializedData<Schema> {}
-
-    /**
-     * The data used to update a document, for example {@link Module.update | `Module#update`}.
-     * It is a distinct type from {@link Module.CreateData | `DeepPartial<Module.CreateData>`} because
-     * it has different rules for `null` and `undefined`.
-     */
-    interface UpdateData extends fields.SchemaField.UpdateData<Schema> {}
-
-    /**
-     * The schema for {@linkcode Module}. This is the source of truth for how an Module document
-     * must be structured.
-     *
-     * Foundry uses this schema to validate the structure of the {@linkcode Module}. For example
-     * a {@link fields.StringField | `StringField`} will enforce that the value is a string. More
-     * complex fields like {@link fields.SetField | `SetField`} goes through various conversions
-     * starting as an array in the database, initialized as a set, and allows updates with any
-     * iterable.
-     */
-    interface Schema extends BasePackage.Schema {
-      /**
-       * The current package version
-       * @remarks Actually defined in BasePackage but defined here to avoid conflict with BaseWorld
-       */
-      version: fields.StringField<{ required: true; blank: false; initial: "0" }>;
-
-      /**
-       * Does this module provide a translation for the core software?
-       */
-      coreTranslation: fields.BooleanField;
-
-      /**
-       * A library module provides no user-facing functionality and is solely for use by other modules. Loaded before any system or module scripts.
-       */
-      library: fields.BooleanField;
-
-      /**
-       * Additional document sub-types provided by this module.
-       */
-      documentTypes: AdditionalTypesField;
-    }
-  }
-
-  class System extends ClientPackageMixin(foundry.packages.BaseSystem) {
-    constructor(data: ClientPackage.SystemCreateData, options: unknown);
-
-    // options: not null (parameter default only, destructured in super)
-    protected override _configure(options?: DataModel.ConfigureOptions): void;
-
-    /**
-     * @deprecated since v12, will be removed in v14
-     * @remarks `"System#template is deprecated in favor of System#documentTypes"`
-     */
-    get template(): Game["model"];
-  }
-
-  namespace System {
-    /**
-     * The data put in {@linkcode DataModel._source}. This data is what was
-     * persisted to the database and therefore it must be valid JSON.
-     *
-     * For example a {@link fields.SetField | `SetField`} is persisted to the database as an array
-     * but initialized as a {@linkcode Set}.
-     */
-    interface Source extends fields.SchemaField.SourceData<Schema> {}
-
-    /**
-     * The data necessary to create a data model. Used in places like {@linkcode System.create}
-     * and {@link System | `new System(...)`}.
-     *
-     * For example a {@link fields.SetField | `SetField`} can accept any {@linkcode Iterable}
-     * with the right values. This means you can pass a `Set` instance, an array of values,
-     * a generator, or any other iterable.
-     */
-    interface CreateData extends fields.SchemaField.CreateData<Schema> {}
-
-    /**
-     * The data after a {@linkcode DataModel} has been initialized, for example
-     * {@link System.name | `System#name`}.
-     *
-     * This is data transformed from {@linkcode System.Source} and turned into more
-     * convenient runtime data structures. For example a {@link fields.SetField | `SetField`} is
-     * persisted to the database as an array of values but at runtime it is a `Set` instance.
-     */
-    interface InitializedData extends fields.SchemaField.InitializedData<Schema> {}
-
-    /**
-     * The data used to update a document, for example {@link System.update | `System#update`}.
-     * It is a distinct type from {@link System.CreateData | `DeepPartial<System.CreateData>`} because
-     * it has different rules for `null` and `undefined`.
-     */
-    interface UpdateData extends fields.SchemaField.UpdateData<Schema> {}
-
-    /**
-     * The schema for {@linkcode System}. This is the source of truth for how an System document
-     * must be structured.
-     *
-     * Foundry uses this schema to validate the structure of the {@linkcode System}. For example
-     * a {@link fields.StringField | `StringField`} will enforce that the value is a string. More
-     * complex fields like {@link fields.SetField | `SetField`} goes through various conversions
-     * starting as an array in the database, initialized as a set, and allows updates with any
-     * iterable.
-     */
-    interface Schema extends BasePackage.Schema {
-      /**
-       * The current package version
-       * @remarks Actually defined in BasePackage but defined here to avoid conflict with BaseWorld
-       */
-      version: fields.StringField<{ required: true; blank: false; initial: "0" }>;
-
-      /**
-       * Additional document subtypes provided by this system.
-       */
-      documentTypes: AdditionalTypesField;
-
-      /**
-       * A web URL or local file path which provides a default background banner for worlds which are created using this system
-       */
-      background: fields.StringField<{ required: false; blank: false }>;
-
-      /**
-       * A default initiative formula used for this system
-       */
-      initiative: fields.StringField;
-
-      /**
-       * The default grid settings to use for Scenes in this system
-       */
-      grid: fields.SchemaField<{
-        /** A default grid type to use for Scenes in this system */
-        type: fields.NumberField<{
-          required: true;
-          choices: typeof foundry.CONST.GRID_TYPES;
-          initial: typeof foundry.CONST.GRID_TYPES.SQUARE;
-        }>;
-
-        /** A default distance measurement to use for Scenes in this system */
-        distance: fields.NumberField<{
-          required: true;
-          nullable: false;
-          positive: true;
-          initial: 1;
-        }>;
-
-        /** A default unit of measure to use for distance measurement in this system */
-        units: fields.StringField<{
-          required: true;
-        }>;
-
-        /** The default rule used by this system for diagonal measurement on square grids */
-        diagonals: fields.NumberField<{
-          required: true;
-          choices: typeof foundry.CONST.GRID_DIAGONALS;
-          initial: typeof foundry.CONST.GRID_DIAGONALS.EQUIDISTANT;
-        }>;
-      }>;
-
-      /**
-       * An Actor data attribute path to use for Token primary resource bars
-       */
-      primaryTokenAttribute: fields.StringField;
-
-      /**
-       * An Actor data attribute path to use for Token secondary resource bars
-       */
-      secondaryTokenAttribute: fields.StringField;
-
-      /**
-       * A default distance measurement to use for Scenes in this system
-       * @deprecated since v12
-       */
-      gridDistance: fields.NumberField;
-
-      /**
-       * A default unit of measure to use for distance measurement in this system
-       * @deprecated since v12
-       */
-      gridUnits: fields.NumberField;
-    }
-  }
-
-  class World extends ClientPackageMixin(foundry.packages.BaseWorld) {
-    static override getVersionBadge(
-      availability: CONST.PACKAGE_AVAILABILITY_CODES,
-      data: Partial<PackageManifestData>,
-      options: World.GetVersionBadgeOptions,
-    ): ClientPackage.PackageCompatibilityBadge | null;
-
-    /**
-     * Provide data for a system badge displayed for the world which reflects the system ID and its availability
-     * @param system - A specific system to use, otherwise use the installed system.
-     */
-    getSystemBadge(system?: System): ClientPackage.PackageCompatibilityBadge | null;
-
-    static override _formatBadDependenciesTooltip(
-      availability: CONST.PACKAGE_AVAILABILITY_CODES,
-      data: Partial<PackageManifestData>,
-      options: World.FormatBadDependenciesTooltip,
-    ): string;
-  }
-
-  namespace World {
-    /**
-     * The data put in {@linkcode DataModel._source}. This data is what was
-     * persisted to the database and therefore it must be valid JSON.
-     *
-     * For example a {@link fields.SetField | `SetField`} is persisted to the database as an array
-     * but initialized as a {@linkcode Set}.
-     */
-    interface Source extends fields.SchemaField.SourceData<Schema> {}
-
-    /**
-     * The data necessary to create a data model. Used in places like {@linkcode World.create}
-     * and {@link World | `new World(...)`}.
-     *
-     * For example a {@link fields.SetField | `SetField`} can accept any {@linkcode Iterable}
-     * with the right values. This means you can pass a `Set` instance, an array of values,
-     * a generator, or any other iterable.
-     */
-    interface CreateData extends fields.SchemaField.CreateData<Schema> {}
-
-    /**
-     * The data after a {@linkcode DataModel} has been initialized, for example
-     * {@link World.name | `World#name`}.
-     *
-     * This is data transformed from {@linkcode World.Source} and turned into more
-     * convenient runtime data structures. For example a {@link fields.SetField | `SetField`} is
-     * persisted to the database as an array of values but at runtime it is a `Set` instance.
-     */
-    interface InitializedData extends fields.SchemaField.InitializedData<Schema> {}
-
-    /**
-     * The data used to update a document, for example {@link World.update | `World#update`}.
-     * It is a distinct type from {@link World.CreateData | `DeepPartial<World.CreateData>`} because
-     * it has different rules for `null` and `undefined`.
-     */
-    interface UpdateData extends fields.SchemaField.UpdateData<Schema> {}
-
-    /**
-     * The schema for {@linkcode World}. This is the source of truth for how an World document
-     * must be structured.
-     *
-     * Foundry uses this schema to validate the structure of the {@linkcode World}. For example
-     * a {@link fields.StringField | `StringField`} will enforce that the value is a string. More
-     * complex fields like {@link fields.SetField | `SetField`} goes through various conversions
-     * starting as an array in the database, initialized as a set, and allows updates with any
-     * iterable.
-     */
-    interface Schema extends BasePackage.Schema {
-      /**
-       * The game system name which this world relies upon
-       */
-      system: fields.StringField<{ required: true; blank: false }>;
-
-      /**
-       * A web URL or local file path which provides a background banner image
-       */
-      background: fields.StringField<{ required: false; blank: false }>;
-
-      /**
-       * The theme to use for this world's join page.
-       */
-      joinTheme: fields.StringField<{
-        required: false;
-        initial: undefined;
-        nullable: false;
-        blank: false;
-        choices: typeof foundry.CONST.WORLD_JOIN_THEMES;
-      }>;
-
-      /**
-       * The version of the core software for which this world has been migrated
-       */
-      coreVersion: fields.StringField<{ required: true; blank: false }>;
-
-      /**
-       * The version of the game system for which this world has been migrated
-       */
-      systemVersion: fields.StringField<{ required: true; blank: false; initial: "0" }>;
-
-      lastPlayed: fields.StringField;
-
-      playtime: fields.NumberField<{ integer: true; min: 0; initial: 0 }>;
-
-      /**
-       * An ISO datetime string when the next game session is scheduled to occur
-       */
-      nextSession: fields.StringField<{ blank: false; nullable: true; initial: null }>;
-
-      /**
-       * Should user access keys be reset as part of the next launch?
-       */
-      resetKeys: fields.BooleanField<{ required: false; initial: undefined }>;
-
-      /**
-       * Should the world launch in safe mode?
-       */
-      safeMode: fields.BooleanField<{ required: false; initial: undefined }>;
-
-      version: fields.StringField<{ required: true; blank: false; nullable: true; initial: null }>;
-    }
-
-    interface GetVersionBadgeOptions {
-      /**
-       * A specific collection of modules to test availability against. Tests against the currently installed modules by default.
-       */
-      modules?: Collection<Module> | undefined;
-
-      /**
-       * A specific collection of systems to test availability against. Tests against the currently installed systems by default.
-       */
-      systems?: Collection<System> | undefined;
-    }
-
-    interface FormatBadDependenciesTooltip {
-      /**
-       * A specific collection of modules to test availability against. Tests against the currently installed modules by default.
-       */
-      modules?: Collection<Module> | undefined;
-
-      /**
-       * A specific collection of systems to test availability against. Tests against the currently installed systems by default.
-       */
-      systems?: Collection<System> | undefined;
-    }
-  }
-}
diff --git a/src/foundry/client/core/settings.d.mts b/src/foundry/client/core/settings.d.mts
deleted file mode 100644
index f35f0f517..000000000
--- a/src/foundry/client/core/settings.d.mts
+++ /dev/null
@@ -1,405 +0,0 @@
-import type { AnyArray, AnyObject, InexactPartial, FixedInstanceType } from "#utils";
-import type ApplicationV2 from "#client/applications/api/application.d.mts";
-import type FormApplication from "#client/appv1/api/form-application-v1.mjs";
-import type { CustomFormInput } from "#client/applications/forms/fields.d.mts";
-import type DataModel from "#common/abstract/data.d.mts";
-import type { DataField } from "#common/data/fields.d.mts";
-
-declare global {
-  /**
-   * A class responsible for managing defined game settings or settings menus.
-   * Each setting is a string key/value pair belonging to a certain package and a certain store scope.
-   *
-   * When Foundry Virtual Tabletop is initialized, a singleton instance of this class is constructed within the global
-   * Game object as as game.settings.
-   *
-   * @see {@link Game.settings | `Game#settings`}
-   * @see {@linkcode Settings}
-   * @see {@linkcode SettingsConfig}
-   */
-  class ClientSettings {
-    constructor(worldSettings?: Setting.Implementation["_source"][]);
-
-    /**
-     * A object of registered game settings for this scope
-     */
-    settings: Map<keyof globalThis.SettingConfig & (string & {}), ClientSettings.SettingConfig>;
-
-    /**
-     * Registered settings menus which trigger secondary applications
-     */
-    menus: Map<string, ClientSettings.SettingSubmenuConfig>;
-
-    /**
-     * The storage interfaces used for persisting settings
-     * Each storage interface shares the same API as window.localStorage
-     * @remarks This is a lie, it doesn't actually have the same interface...
-     */
-    storage: Map<string, Storage | WorldSettings>;
-
-    /**
-     * Return a singleton instance of the Game Settings Configuration app
-     */
-    get sheet(): foundry.applications.settings.SettingsConfig;
-
-    /**
-     * Register a new game setting under this setting scope
-     *
-     * @param namespace - The namespace under which the setting is registered
-     * @param key       - The key name for the setting under the namespace
-     * @param data      - Configuration for setting data
-     *
-     * @example Register a client setting
-     * ```js
-     * game.settings.register("myModule", "myClientSetting", {
-     *   name: "Register a Module Setting with Choices",
-     *   hint: "A description of the registered setting and its behavior.",
-     *   scope: "client",     // This specifies a client-stored setting
-     *   config: true,        // This specifies that the setting appears in the configuration view
-     *   requiresReload: true // This will prompt the user to reload the application for the setting to take effect.
-     *   type: String,
-     *   choices: {           // If choices are defined, the resulting setting will be a select menu
-     *     "a": "Option A",
-     *     "b": "Option B"
-     *   },
-     *   default: "a",        // The default value for the setting
-     *   onChange: value => { // A callback function which triggers when the setting is changed
-     *     console.log(value)
-     *   }
-     * });
-     * ```
-     *
-     * @example Register a world setting
-     * ```js
-     * game.settings.register("myModule", "myWorldSetting", {
-     *   name: "Register a Module Setting with a Range slider",
-     *   hint: "A description of the registered setting and its behavior.",
-     *   scope: "world",      // This specifies a world-level setting
-     *   config: true,        // This specifies that the setting appears in the configuration view
-     *   requiresReload: true // This will prompt the GM to have all clients reload the application for the setting to
-     *                        // take effect.
-     *   type: new foundry.fields.NumberField({nullable: false, min: 0, max: 100, step: 10}),
-     *   default: 50,         // The default value for the setting
-     *   onChange: value => { // A callback function which triggers when the setting is changed
-     *     console.log(value)
-     *   }
-     * });
-     * ```
-     */
-    register<
-      T extends ClientSettings.Type,
-      N extends ClientSettings.Namespace = ClientSettings.Namespace,
-      K extends ClientSettings.KeyFor<N> = ClientSettings.KeyFor<N>,
-    >(namespace: N, key: K, data: ClientSettings.RegisterData<T, N, K>): void;
-
-    /**
-     * Register a new sub-settings menu
-     *
-     * @param namespace - The namespace under which the menu is registered
-     * @param key       - The key name for the setting under the namespace module
-     * @param data      - Configuration for setting data
-     * @template N     - The namespace under which the menu is registered, as a type
-     * @template K     - The key name for the setting under the namespace module, as a type
-     *
-     * @example Define a settings submenu which handles advanced configuration needs
-     * ```typescript
-     * game.settings.registerMenu("myModule", "mySettingsMenu", {
-     *   name: "My Settings Submenu",
-     *   label: "Settings Menu Label",      // The text label used in the button
-     *   hint: "A description of what will occur in the submenu dialog.",
-     *   icon: "fas fa-bars",               // A Font Awesome icon used in the submenu button
-     *   type: MySubmenuApplicationClass,   // A FormApplication subclass which should be created
-     *   restricted: true                   // Restrict this submenu to gamemaster only?
-     * });
-     * ```
-     */
-    registerMenu<N extends string, K extends string>(namespace: N, key: K, data: ClientSettings.RegisterSubmenu): void;
-
-    /**
-     * Get the value of a game setting for a certain namespace and setting key
-     *
-     * @param namespace - The namespace under which the setting is registered
-     * @param key       - The setting key to retrieve
-     * @template N     - The namespace under which the setting is registered, as a type
-     * @template K     - The setting key to retrieve, as a type
-     *
-     * @example Retrieve the current setting value
-     * ```typescript
-     * game.settings.get("myModule", "myClientSetting");
-     * ```
-     */
-    get<N extends ClientSettings.Namespace, K extends ClientSettings.KeyFor<N>>(
-      namespace: N,
-      key: K,
-    ): ClientSettings.SettingInitializedType<N, K>;
-
-    /**
-     * Set the value of a game setting for a certain namespace and setting key
-     *
-     * @param namespace - The namespace under which the setting is registered
-     * @param key       - The setting key to retrieve
-     * @param value     - The data to assign to the setting key
-     * @param options   - Additional options passed to the server when updating world-scope settings
-     * @template N     - The namespace under which the setting is registered, as a type
-     * @template K     - The setting key to retrieve, as a type
-     * @template V     - The type of the value being set
-     * @returns         - The assigned setting value
-     *
-     * @example
-     * ```typescript
-     * // Update the current value of a setting
-     * game.settings.set("myModule", "myClientSetting", "b");
-     * ```
-     */
-    set<N extends ClientSettings.Namespace, K extends ClientSettings.KeyFor<N>>(
-      namespace: N,
-      key: K,
-      value: ClientSettings.SettingCreateData<N, K>,
-      options?: Setting.Database.CreateOperation<undefined | false> | Setting.Database.UpdateOperation,
-    ): Promise<ClientSettings.SettingInitializedType<N, K>>;
-  }
-
-  namespace ClientSettings {
-    type Namespace = GetNamespaces<keyof globalThis.SettingConfig>;
-    type KeyFor<N extends Namespace> = GetKeys<N, keyof globalThis.SettingConfig>;
-
-    interface RegisterData<
-      T extends ClientSettings.Type,
-      N extends ClientSettings.Namespace,
-      K extends ClientSettings.KeyFor<N>,
-    > extends _RegisterData<_RegisterType<T, N, K>> {}
-
-    /**
-     * @internal
-     */
-    type _RegisterType<
-      T extends ClientSettings.Type,
-      N extends ClientSettings.Namespace,
-      K extends ClientSettings.KeyFor<N>,
-    > = ClientSettings.Type extends T ? ConfiguredType<N, K> : NoInfer<T>;
-
-    /**
-     * @internal
-     */
-    type _RegisterData<T extends ClientSettings.Type> = InexactPartial<Omit<SettingConfig<T>, "key" | "namespace">>;
-
-    /**
-     * A TypeScript type is a type for a setting that only exists at compile time.
-     * For example `string` does not correspond to a real runtime value like `String` does.
-     */
-    type TypeScriptType = string | number | boolean | symbol | bigint | AnyArray | AnyObject;
-
-    type RuntimeType = DataField.Any | DataModel.AnyConstructor | SettingFunction | SettingConstructor;
-
-    type Type = TypeScriptType | RuntimeType;
-
-    type ToRuntimeType<T extends Type> =
-      | (T extends RuntimeType ? T : never)
-      | (T extends string ? typeof String : never)
-      | (T extends number ? typeof Number : never)
-      | (T extends boolean ? typeof Boolean : never)
-      | (T extends symbol ? typeof Symbol : never)
-      | (T extends bigint ? typeof BigInt : never)
-      | (T extends readonly (infer V)[] ? typeof Array<V> : never)
-      | (T extends AnyObject ? typeof Object : never);
-
-    type SettingCreateData<N extends Namespace, K extends KeyFor<N>> = ToSettingCreateData<ConfiguredType<N, K>>;
-
-    type ToSettingCreateData<T extends Type> = ReplaceUndefinedWithNull<
-      | SettingType<T>
-      // TODO(LukeAbby): The `fromSource` function is called with `strict` which changes how fallback behaviour works. See `ClientSettings#set`
-      | (T extends (abstract new (...args: infer _1) => infer Instance extends DataModel.Any) ? Instance : never)
-    >;
-
-    type SettingInitializedType<N extends Namespace, K extends KeyFor<N>> = ToSettingInitializedType<
-      ConfiguredType<N, K>
-    >;
-
-    type ToSettingInitializedType<T extends Type> = ReplaceUndefinedWithNull<
-      SettingType<T> | (T extends DataModel.Any ? T : never)
-    >;
-
-    /**
-     * @internal
-     */
-    interface _SettingConfig<RuntimeType extends ClientSettings.RuntimeType, CreateData, InitializedData> {
-      /** A unique machine-readable id for the setting */
-      key: string;
-
-      /** The namespace the setting belongs to */
-      namespace: string;
-
-      /** The human readable name */
-      name?: string | undefined;
-
-      /** An additional human readable hint */
-      hint?: string | undefined;
-
-      /**
-       * The scope the Setting is stored in, either World or Client
-       * @defaultValue `"client"`
-       */
-      scope: "world" | "client";
-
-      /** Indicates if this Setting should render in the Config application */
-      config?: boolean | undefined;
-
-      /** The JS Type that the Setting is storing */
-      type?: RuntimeType;
-
-      /** For string Types, defines the allowable values */
-      choices?: CreateData extends string
-        ? {
-            readonly [K in CreateData]?: string;
-          }
-        : never;
-
-      /** For numeric Types, defines the allowable range */
-      range?: CreateData extends number
-        ? {
-            max: number;
-            min: number;
-            step: number;
-          }
-        : never;
-
-      /** The default value */
-      default: CreateData;
-
-      /** Whether setting requires Foundry to be reloaded on change  */
-      requiresReload?: boolean;
-
-      /** Executes when the value of this Setting changes */
-      onChange?: (value: InitializedData) => void;
-
-      /**
-       * A custom form field input used in conjunction with a DataField type
-       */
-      input?: CustomFormInput | undefined;
-    }
-
-    /**
-     * A Client Setting
-     * @remarks Copied from `resources/app/common/types.mjs`
-     * @remarks Not to be confused with {@linkcode globalThis.SettingConfig} which is how you register setting types in this project
-     */
-    interface SettingConfig<T extends Type = (value: unknown) => unknown>
-      extends _SettingConfig<ToRuntimeType<T>, ToSettingInitializedType<T>, ToSettingCreateData<T>> {}
-
-    /**
-     * A Client Setting Submenu
-     * @remarks Copied from `resources/app/common/types.mjs`
-     */
-    interface SettingSubmenuConfig {
-      key: string;
-
-      namespace: string;
-
-      /** The human-readable name */
-      name?: string | undefined;
-
-      /** An additional human-readable hint */
-      label?: string | undefined;
-
-      /** An additional human readable hint */
-      hint?: string | undefined;
-
-      /** The classname of an Icon to render */
-      icon?: string | undefined;
-
-      /** The FormApplication or ApplicationV2 to render */
-      // In SettingsConfig#_onClickSubmenu this type is constructed and not given any options.
-      type: (new () => FormApplication.Any) | (new () => ApplicationV2.Any);
-
-      /** If true, only a GM can edit this Setting */
-      restricted?: boolean | undefined;
-    }
-
-    interface RegisterSubmenu {
-      /** The human readable name */
-      name: string;
-
-      /** The human readable label */
-      label: string;
-
-      /** An additional human readable hint */
-      hint: string;
-
-      /** The classname of an Icon to render */
-      icon: string;
-
-      /**
-       * The FormApplication class to render
-       *
-       * @privateRemarks The phrase "TODO better typing" in the original documentation was stripped.
-       */
-      type: (new () => FormApplication.Any) | (new () => ApplicationV2.Any);
-
-      /** If true, only a GM can edit this Setting */
-      restricted: boolean;
-    }
-
-    /**
-     * @deprecated Replaced with {@linkcode ClientSettings.SettingInitializedType}.
-     */
-    export import SettingAssignmentType = ClientSettings.SettingInitializedType;
-
-    /**
-     * @deprecated Replaced with {@linkcode ClientSettings.ToSettingInitializedType}.
-     */
-    export import ToSettingAssignmentType = ClientSettings.ToSettingInitializedType;
-  }
-}
-
-type SettingFunction = (value: never) => unknown;
-type SettingConstructor = new (value: never) => unknown;
-
-// Matches what's in `Setting#PRIMITIVE_TYPES`.
-// Foundry itself uses this nomenclature despite the fact that it's a misnomer.
-type PRIMITIVE_TYPES = readonly [
-  typeof String,
-  typeof Number,
-  typeof Boolean,
-  typeof Array,
-  typeof Symbol,
-  typeof BigInt,
-];
-
-// A type can be both a constructor and a function at once.
-// Foundry prioritizes the constructor over the function unless it's in `Setting#PRIMITIVE_TYPES`.
-type ConstructorToSettingType<T extends SettingConstructor> = T extends PRIMITIVE_TYPES[number]
-  ? PrimitiveConstructorToSettingType<T>
-  : FixedInstanceType<T>;
-
-// In theory this is just the `ReturnType<T>`.
-// However the function end of `Array` returns `any[]` while `Object` returns `any`.
-// To increase safety they're special cased here.
-type PrimitiveConstructorToSettingType<T extends PRIMITIVE_TYPES[number]> = T extends typeof Array
-  ? AnyArray
-  : T extends typeof Object
-    ? AnyObject
-    : ReturnType<T>;
-
-// The `& keyof SettingConfig` is necessary because otherwise the fact that `K` depends on `N`
-// will confuse TypeScript and make it think that `${N}.${K}` can be invalid keys like
-// "core.moduleSetting" but in reality that would be disallowed by the dependent constraint of `K`.
-type ConfiguredType<
-  N extends ClientSettings.Namespace,
-  K extends ClientSettings.KeyFor<N>,
-> = globalThis.SettingConfig[`${N}.${K}` & keyof globalThis.SettingConfig];
-
-type SettingType<T extends ClientSettings.Type> =
-  // Note(LukeAbby): This isn't written as `T extends ClientSettings.TypeScriptType ? T : never` because then types like `DataField.Any` would be matched.
-  | (T extends ClientSettings.RuntimeType ? never : T)
-  // TODO(LukeAbby): The `validate` function is called with `strict` which changes how fallback behavior works. See `ClientSettings#set`
-  // eslint-disable-next-line @typescript-eslint/no-deprecated
-  | (T extends DataField.Any ? DataField.AssignmentTypeFor<T> : never)
-  | (T extends SettingConstructor ? ConstructorToSettingType<T> : T extends SettingFunction ? ReturnType<T> : never);
-
-// TODO(LukeAbby): The exact semantics for when `undefined` is replaced with `null` are unclear.
-type ReplaceUndefinedWithNull<T> = T extends undefined ? null : T;
-
-type GetNamespaces<SettingPath extends PropertyKey> = SettingPath extends `${infer Scope}.${string}` ? Scope : never;
-type GetKeys<N extends string, SettingPath extends PropertyKey> = SettingPath extends `${N}.${infer Name}`
-  ? Name
-  : never;
diff --git a/src/foundry/client/core/socket.d.mts b/src/foundry/client/core/socket.d.mts
deleted file mode 100644
index bdad673d1..000000000
--- a/src/foundry/client/core/socket.d.mts
+++ /dev/null
@@ -1,62 +0,0 @@
-import type { AnyObject } from "#utils";
-import type { DatabaseOperationMap, DocumentSocketRequest } from "#common/abstract/_types.d.mts";
-
-declare global {
-  class SocketInterface {
-    /**
-     * Standardize the way that socket messages are dispatched and their results are handled
-     * @param eventName - The socket event name being handled
-     * @param request   - Request data provided to the Socket event
-     * @returns A Promise which resolves to the SocketResponse
-     */
-    static dispatch<DatabaseAction extends keyof DatabaseOperationMap>(
-      eventName: string,
-      request: DocumentSocketRequest<DatabaseAction> | CompendiumCollection.ManageCompendiumRequest,
-    ): Promise<SocketInterface.SocketResponse>;
-  }
-
-  namespace SocketInterface {
-    /** @remarks Copied from `resources/app/common/types.mjs` */
-    type RequestData = AnyObject | AnyObject[] | string | readonly string[];
-
-    /** @remarks Copied from `resources/app/common/types.mjs` */
-    interface SocketRequest {
-      /** Additional options applied to the request */
-      options?: AnyObject | undefined;
-      broadcast?: boolean | undefined;
-    }
-
-    /** @remarks Copied from `resources/app/common/types.mjs` */
-    interface SocketResponse {
-      /**
-       * The initial request
-       */
-      request: SocketRequest;
-
-      /**
-       * An error, if one occurred
-       */
-      error?: Error | undefined;
-
-      /**
-       * The status of the request
-       */
-      status?: string | undefined;
-
-      /**
-       * The ID of the requesting User
-       */
-      userId?: string | undefined;
-
-      /**
-       * Data returned as a result of the request
-       */
-      data?: RequestData | undefined;
-
-      /**
-       * An Array of created data objects
-       */
-      result?: AnyObject[] | readonly string[] | undefined;
-    }
-  }
-}
diff --git a/src/foundry/client/core/sorting.d.mts b/src/foundry/client/core/sorting.d.mts
deleted file mode 100644
index 07186b1cb..000000000
--- a/src/foundry/client/core/sorting.d.mts
+++ /dev/null
@@ -1,76 +0,0 @@
-export {};
-
-declare global {
-  /**
-   * A collection of functions related to sorting objects within a parent container.
-   */
-  class SortingHelpers {
-    /**
-     * Given a source object to sort, a target to sort relative to, and an Array of siblings in the container:
-     * Determine the updated sort keys for the source object, or all siblings if a reindex is required.
-     * Return an Array of updates to perform, it is up to the caller to dispatch these updates.
-     * Each update is structured as:
-     * ```typescript
-     * {
-     *   target: object,
-     *   update: {sortKey: sortValue}
-     * }
-     * ```
-     *
-     * @param source  - source object being sorted
-     * @param options - Options which modify the sort behavior
-     * @template T   - the type of the source and target object
-     *
-     * @returns An Array of updates for the caller of the helper function to perform
-     */
-    static performIntegerSort<T, SortKey extends string = "sort">(
-      source: T,
-      options?: SortingHelpers.SortOptions<T, SortKey>,
-    ): Array<{
-      target: T;
-      update: {
-        [Key in SortKey]: number;
-      };
-    }>;
-
-    /**
-     * Given an ordered Array of siblings and a target position, return the [min,max] indices to sort before the target
-     */
-    protected static _sortBefore<T>(siblings: T[], idx: number, sortKey: string): [T, T];
-
-    /**
-     * Given an ordered Array of siblings and a target position, return the [min,max] indices to sort after the target
-     */
-    protected static _sortAfter<T>(siblings: T[], idx: number, sortKey: string): [T, T];
-  }
-
-  namespace SortingHelpers {
-    interface SortOptions<T, SortKey extends string = "sort"> {
-      /**
-       * The target object relative which to sort
-       * @defaultValue `null`
-       */
-      target?: T | null | undefined;
-
-      /**
-       * The sorted Array of siblings which share the same sorted container
-       * @defaultValue `[]`
-       */
-      siblings?: T[] | undefined;
-
-      /**
-       * The name of the data property within the source object which defines the sort key
-       * @defaultValue `"sort"`
-       */
-      sortKey?: SortKey | undefined;
-
-      /**
-       * Whether to explicitly sort before (true) or sort after (false). If nothing is passed
-       * the sort order will be automatically determined, preferring before.
-       *
-       * @defaultValue `true`
-       */
-      sortBefore?: boolean | undefined;
-    }
-  }
-}
diff --git a/src/foundry/client/core/time.d.mts b/src/foundry/client/core/time.d.mts
deleted file mode 100644
index 1130a2173..000000000
--- a/src/foundry/client/core/time.d.mts
+++ /dev/null
@@ -1,76 +0,0 @@
-export {};
-
-declare global {
-  /**
-   * A singleton class {@link game.time | `game#time`} which keeps the official Server and World time stamps.
-   * Uses a basic implementation of https://www.geeksforgeeks.org/cristians-algorithm/ for synchronization.
-   */
-  class GameTime {
-    constructor(socket?: io.Socket | null);
-
-    /**
-     * The most recently synchronized timestamps retrieved from the server.
-     * @defaultValue `{}`
-     */
-    protected _time: GameTime.Timestamps;
-
-    /**
-     * The average one-way latency across the most recent 5 trips
-     * @defaultValue `0`
-     */
-    protected _dt: number;
-
-    /**
-     * The most recent five synchronization durations
-     * @defaultValue `[]`
-     */
-    protected _dts: number[];
-
-    /**
-     * The amount of time to delay before re-syncing the official server time.
-     * @defaultValue `1000 * 60 * 5`
-     */
-    static SYNC_INTERVAL_MS: number;
-
-    /**
-     * The current server time based on the last synchronization point and the approximated one-way latency.
-     */
-    get serverTime(): number;
-
-    /**
-     * The current World time based on the last recorded value of the core.time setting
-     */
-    get worldTime(): number;
-
-    /**
-     * Advance the game time by a certain number of seconds
-     * @param seconds - The number of seconds to advance (or rewind if negative) by
-     * @param options - Additional options passed to game.settings.set
-     * @returns The new game time
-     */
-    advance(
-      seconds: number,
-      options?: Setting.Database.CreateOperation<false | undefined> | Setting.Database.UpdateOperation,
-    ): Promise<number>;
-
-    /**
-     * Synchronize the local client game time with the official time kept by the server
-     * @param socket - The connected server Socket instance
-     */
-    sync(socket?: io.Socket | null): Promise<this>;
-
-    /**
-     * Handle follow-up actions when the official World time is changed
-     * @param worldTime - The new canonical World time.
-     */
-    onUpdateWorldTime(worldTime: number): void;
-  }
-
-  namespace GameTime {
-    interface Timestamps {
-      clientTime: number;
-      serverTime: number;
-      worldTime: number;
-    }
-  }
-}
diff --git a/src/foundry/client/core/tooltip.d.mts b/src/foundry/client/core/tooltip.d.mts
deleted file mode 100644
index 5cf02bf06..000000000
--- a/src/foundry/client/core/tooltip.d.mts
+++ /dev/null
@@ -1,205 +0,0 @@
-import type { ValueOf } from "#utils";
-
-declare global {
-  /**
-   * A singleton Tooltip Manager class responsible for rendering and positioning a dynamic tooltip element which is
-   * accessible as `game.tooltip`.
-   *
-   * @see {@linkcode Game.tooltip}
-   *
-   * @example API Usage
-   * ```typescript
-   * game.tooltips.activate(htmlElement, {text: "Some tooltip text", direction: "UP"});
-   * game.tooltips.deactivate();
-   * ```
-   *
-   * @example HTML Usage
-   * ```html
-   * <span data-tooltip="Some Tooltip" data-tooltip-direction="LEFT">I have a tooltip</span>
-   * <ol data-tooltip-direction="RIGHT">
-   *   <li data-tooltip="The First One">One</li>
-   *   <li data-tooltip="The Second One">Two</li>
-   *   <li data-tooltip="The Third One">Three</li>
-   * </ol>
-   * ```
-   */
-  class TooltipManager {
-    /**
-     * A cached reference to the global tooltip element
-     */
-    tooltip: HTMLElement;
-
-    /**
-     * A reference to the HTML element which is currently tool-tipped, if any.
-     */
-    element: HTMLElement | null;
-
-    /**
-     * An amount of margin which is used to offset tooltips from their anchored element.
-     * @defaultValue `5`
-     */
-    static TOOLTIP_MARGIN_PX: number;
-
-    /**
-     * The number of milliseconds delay which activates a tooltip on a "long hover".
-     * @defaultValue `500`
-     */
-    static TOOLTIP_ACTIVATION_MS: number;
-
-    /**
-     * The directions in which a tooltip can extend, relative to its tool-tipped element.
-     */
-    static TOOLTIP_DIRECTIONS: {
-      UP: "UP";
-      DOWN: "DOWN";
-      LEFT: "LEFT";
-      RIGHT: "RIGHT";
-      CENTER: "CENTER";
-    };
-
-    /**
-     * The number of pixels buffer around a locked tooltip zone before they should be dismissed.
-     * @defaultValue `50`
-     */
-    static LOCKED_TOOLTIP_BUFFER_PX: number;
-
-    /**
-     * Activate interactivity by listening for hover events on HTML elements which have a data-tooltip defined.
-     */
-    activateEventListeners(): void;
-
-    /**
-     * Activate the tooltip for a hovered HTML element which defines a tooltip localization key.
-     * @param element - The HTML element being hovered.
-     * @param options - Additional options which can override tooltip behavior. (default: `{}`)
-     */
-    activate(
-      element: HTMLElement,
-      options?: {
-        /**
-         * Explicit tooltip text to display. If this is not provided the tooltip text is
-         * acquired from the elements data-tooltip attribute. This text will be
-         * automatically localized
-         */
-        text?: string;
-
-        /**
-         * An explicit tooltip expansion direction. If this is not provided the direction is acquired
-         * from the data-tooltip-direction attribute of the element or one of its parents.
-         */
-        direction?: TooltipManager.TOOLTIP_DIRECTIONS;
-
-        /**
-         * An optional, space-separated list of CSS classes to apply to the activated
-         * tooltip. If this is not provided, the CSS classes are acquired from the
-         * data-tooltip-class attribute of the element or one of its parents.
-         */
-        cssClass?: string;
-
-        /** An optional boolean to lock the tooltip after creation. Defaults to false. */
-        locked?: boolean;
-
-        /** Explicit HTML content to inject into the tooltip rather than using tooltip text. */
-        content?: HTMLElement;
-      },
-    ): void;
-
-    /**
-     * Deactivate the tooltip from a previously hovered HTML element.
-     * @internal
-     */
-    deactivate(): void;
-
-    /**
-     * Clear any pending activation workflow.
-     * @internal
-     */
-    clearPending(): void;
-
-    /**
-     * Lock the current tooltip.
-     */
-    lockTooltip(): HTMLElement;
-
-    /**
-     * Handle a request to lock the current tooltip.
-     * @param event - The click event.
-     */
-    protected _onLockTooltip(event: MouseEvent): void;
-
-    /**
-     * Handle dismissing a locked tooltip.
-     * @param event - The click event.
-     */
-    protected _onLockedTooltipDismiss(event: MouseEvent): void;
-
-    /**
-     * Dismiss a given locked tooltip.
-     * @param element - The locked tooltip to dismiss.
-     */
-    dismissLockedTooltip(element: HTMLElement): void;
-
-    /**
-     * Dismiss the set of active locked tooltips.
-     */
-    dismissLockedTooltips(): void;
-
-    /**
-     * Create a locked tooltip at the given position.
-     * @param position - A position object with coordinates for where the tooltip should be placed
-     * @param text     - Explicit tooltip text or HTML to display.
-     * @param options  - Additional options which can override tooltip behavior.
-     */
-    createLockedTooltip(
-      position: {
-        /** Explicit top position for the tooltip */
-        top?: string;
-
-        /** Explicit right position for the tooltip */
-        right?: string;
-
-        /** Explicit bottom position for the tooltip */
-        bottom?: string;
-
-        /** Explicit left position for the tooltip */
-        left?: string;
-      },
-      text: string,
-      options?: {
-        /** An optional, space-separated list of CSS classes to apply to the activated  tooltip. */
-        cssClass: string;
-      },
-    ): HTMLElement;
-
-    /**
-     * If an explicit tooltip expansion direction was not specified, figure out a valid direction based on the bounds
-     * of the target element and the screen.
-     */
-    protected _determineDirection(): ValueOf<Pick<typeof TooltipManager.TOOLTIP_DIRECTIONS, "UP" | "DOWN">>;
-
-    /**
-     * Set tooltip position relative to an HTML element using an explicitly provided data-tooltip-direction.
-     * @param direction - The tooltip expansion direction specified by the element or a parent element.
-     */
-    protected _setAnchor(direction: TooltipManager.TOOLTIP_DIRECTIONS): void;
-
-    /**
-     * Apply inline styling rules to the tooltip for positioning and text alignment.
-     * @param position - An object of positioning data, supporting top, right, bottom, left, and textAlign
-     */
-    protected _setStyle(position?: {
-      top?: null | number;
-      right?: null | number;
-      bottom?: null;
-      left?: null;
-      textAlign?: string;
-    }): void;
-  }
-
-  namespace TooltipManager {
-    /**
-     * The directions in which a tooltip can extend, relative to its tool-tipped element.
-     */
-    type TOOLTIP_DIRECTIONS = ValueOf<(typeof TooltipManager)["TOOLTIP_DIRECTIONS"]>;
-  }
-}
diff --git a/src/foundry/client/core/tour.d.mts b/src/foundry/client/core/tour.d.mts
deleted file mode 100644
index 3a4e703f3..000000000
--- a/src/foundry/client/core/tour.d.mts
+++ /dev/null
@@ -1,283 +0,0 @@
-import type { ValueOf } from "#utils";
-
-export { Tour };
-
-declare global {
-  namespace Tour {
-    type STATUS = ValueOf<typeof Tour.STATUS>;
-
-    /** A step in a Tour */
-    interface Step {
-      /** A machine-friendly id of the Tour Step */
-      id: string;
-
-      /** A DOM selector which denotes an element to highlight during this step */
-      selector?: string;
-
-      /** The title of the step, displayed in the tooltip header */
-      title: string;
-
-      /** Raw HTML content displayed during the step */
-      content: string;
-
-      /** How the tooltip for the step should be displayed relative to the target elemen */
-      tooltipDirection?: TooltipManager.TOOLTIP_DIRECTIONS;
-
-      /** Whether the Step is restricted to the GM only */
-      restricted?: boolean;
-    }
-
-    /** Tour configuration data */
-    interface Config {
-      /** The namespace this Tour belongs to. Typically, the name of the package which implements the tour should be used */
-      namespace?: string;
-
-      /** A machine-friendly id of the Tour, must be unique within the provided namespace */
-      id?: string;
-
-      /** A human-readable name for this Tour */
-      title: string;
-
-      /** A human-readable description of this Tour */
-      description?: string;
-
-      /** The list of Tour Steps */
-      steps: Tour.Step[];
-
-      /** A map of translations for the Tour that should be merged into the default translations */
-      localization?: foundry.helpers.Localization.Translations;
-
-      /** Whether the Tour is restricted to the GM only */
-      restricted?: boolean;
-
-      /** Whether the Tour should be displayed in the Manage Tours UI */
-      display?: boolean;
-
-      /** Whether the Tour can be resumed or if it always needs to start from the beginning */
-      canBeResumed?: boolean;
-
-      /**
-       * A list of namespaced Tours that might be suggested to the user when this Tour is completed.
-       * The first non-completed Tour in the array will be recommended.
-       */
-      suggestedNextTours?: string[];
-    }
-  }
-
-  /**
-   * A Tour that shows a series of guided steps.
-   */
-  class Tour {
-    /**
-     * @param config - The configuration of the Tour
-     */
-    constructor(
-      config: Tour.Config,
-      { id, namespace }?: { id?: Tour.Config["id"]; namespace?: Tour.Config["namespace"] },
-    );
-
-    /**
-     * The configuration of the tour. Cloned to avoid mutating the original configuration.
-     */
-    config: Tour.Config;
-
-    static STATUS: Readonly<{
-      UNSTARTED: "unstarted";
-      IN_PROGRESS: "in-progress";
-      COMPLETED: "completed";
-    }>;
-
-    /**
-     * Indicates if a Tour is currently in progress.
-     */
-    static get tourInProgress(): boolean;
-
-    /**
-     * Returns the active tour, if any.
-     */
-    static get activeTour(): Tour | null;
-
-    /**
-     * Handle a movement action to either progress or regress the Tour.
-     * @param movementDirections - The Directions being moved in
-     */
-    static onMovementAction(movementDirections: string[]): boolean;
-
-    /**
-     * The HTMLElement which is the focus of the current tour step.
-     */
-    targetElement: HTMLElement | undefined;
-
-    /**
-     * The HTMLElement that fades out the rest of the screen
-     */
-    fadeElement: HTMLElement | undefined;
-
-    /**
-     * The HTMLElement that blocks input while a Tour is active
-     */
-    overlayElement: HTMLElement | undefined;
-
-    /**
-     * Padding around a Highlighted Element
-     * @defaultValue `10`
-     */
-    static HIGHLIGHT_PADDING: number;
-
-    /**
-     * The unique identifier of the tour.
-     */
-    get id(): string | undefined;
-
-    set id(value: string | undefined);
-
-    /**
-     * The human-readable title for the tour.
-     */
-    get title(): string;
-
-    /**
-     * The human-readable description of the tour.
-     */
-    get description(): string | undefined;
-
-    /**
-     * The package namespace for the tour.
-     */
-    get namespace(): string | undefined;
-
-    set namespace(value: string | undefined);
-
-    /**
-     * The key the Tour is stored under in game.tours, of the form `${namespace}.${id}`
-     */
-    get key(): string;
-
-    /**
-     * The configuration of tour steps
-     */
-    get steps(): Tour.Step[];
-
-    /**
-     * Return the current Step, or null if the tour has not yet started.
-     */
-    get currentStep(): Tour.Step | null;
-
-    /**
-     * The index of the current step; -1 if the tour has not yet started, or null if the tour is finished.
-     */
-    get stepIndex(): number | null;
-
-    /**
-     * Returns True if there is a next Tour.Step
-     */
-    get hasNext(): boolean;
-
-    /**
-     * Returns True if there is a previous Tour.Step
-     */
-    get hasPrevious(): boolean;
-
-    /**
-     * Return whether this Tour is currently eligible to be started?
-     * This is useful for tours which can only be used in certain circumstances, like if the canvas is active.
-     */
-    get canStart(): boolean;
-
-    /**
-     * The current status of the Tour
-     */
-    get status(): Tour.STATUS;
-
-    /**
-     * Advance the tour to a completed state.
-     */
-    complete(): Promise<void>;
-
-    /**
-     * Exit the tour at the current step.
-     */
-    exit(): void;
-
-    /**
-     * Reset the Tour to an un-started state.
-     */
-    reset(): Promise<void>;
-
-    /**
-     * Start the Tour at its current step, or at the beginning if the tour has not yet been started.
-     */
-    start(): Promise<void>;
-
-    /**
-     * Progress the Tour to the next step.
-     */
-    next(): Promise<void>;
-
-    /**
-     * Rewind the Tour to the previous step.
-     */
-    previous(): Promise<void>;
-
-    /**
-     * Progresses to a given Step
-     * @param stepIndex - The step to progress to
-     */
-    progress(stepIndex: number): Promise<void>;
-
-    /**
-     * Query the DOM for the target element using the provided selector
-     * @param selector - A CSS selector
-     * @returns The target element, or null if not found
-     */
-    protected _getTargetElement(selector: string): Element | null;
-
-    /**
-     * Creates and returns a Tour by loading a JSON file
-     * @param filepath - The path to the JSON file
-     */
-    static fromJSON(filepath: string): Promise<Tour>;
-
-    /**
-     * Set-up operations performed before a step is shown.
-     * @abstract
-     */
-    protected _preStep(): Promise<void>;
-
-    /**
-     * Clean-up operations performed after a step is completed.
-     * @abstract
-     */
-    protected _postStep(): Promise<void>;
-
-    /**
-     * Renders the current Step of the Tour
-     */
-    protected _renderStep(): Promise<void>;
-
-    /**
-     * Handle Tour Button clicks
-     * @param event - A click event
-     * @internal
-     */
-    protected _onButtonClick(event: MouseEvent): Promise<void>;
-
-    /**
-     * Saves the current progress of the Tour to a world setting
-     * @internal
-     */
-    protected _saveProgress(): void;
-
-    /**
-     * Returns the User's current progress of this Tour
-     * @internal
-     */
-    protected _loadProgress(): null | number;
-
-    /**
-     * Reloads the Tour's current step from the saved progress
-     * @internal
-     */
-    _reloadProgress(): void;
-  }
-}
diff --git a/src/foundry/client/core/tours.d.mts b/src/foundry/client/core/tours.d.mts
deleted file mode 100644
index fa150cc5e..000000000
--- a/src/foundry/client/core/tours.d.mts
+++ /dev/null
@@ -1,22 +0,0 @@
-export {};
-
-declare global {
-  /**
-   * A singleton Tour Collection class responsible for registering and activating Tours, accessible as game.tours
-   * @see {@linkcode Game.tours}
-   */
-  class Tours extends foundry.utils.Collection<Tour> {
-    /** @throws `"You can only have one TourManager instance"` */
-    constructor();
-
-    /**
-     * Register a new Tour
-     * @param namespace - The namespace of the Tour
-     * @param id        - The machine-readable id of the Tour
-     * @param tour      - The constructed Tour
-     */
-    register(namespace: string, id: string, tour: Tour): void;
-
-    override set(key: string, tour: Tour): this;
-  }
-}
diff --git a/src/foundry/client/core/utils.d.mts b/src/foundry/client/core/utils.d.mts
deleted file mode 100644
index ad654f8bf..000000000
--- a/src/foundry/client/core/utils.d.mts
+++ /dev/null
@@ -1,101 +0,0 @@
-import type { AnyObject, MustBeValidUuid } from "#utils";
-import type Document from "#common/abstract/document.d.mts";
-
-declare const __Unset: unique symbol;
-
-type __UnsetDocument = Document.Any & {
-  [__Unset]: true;
-};
-
-declare class InvalidUuid extends foundry.abstract.Document<any, any, any> {}
-
-type FromUuid<Uuid extends string> = Uuid extends `${string}.${string}.${infer Rest}`
-  ? FromUuid<Rest>
-  : Uuid extends `${infer DocumentType extends Document.Type}.${string}`
-    ? Document.ImplementationFor<DocumentType>
-    : InvalidUuid;
-
-// TODO(LukeAbby): The usage of `Document.Type` when it's unset will not be necessary once `Document.Any` is more type safe.
-type FromUuidValidate<
-  ConcreteDocument extends Document.Any,
-  Uuid extends string,
-> = __UnsetDocument extends ConcreteDocument
-  ? MustBeValidUuid<Uuid, Document.Type>
-  : string extends Uuid
-    ? string
-    : MustBeValidUuid<Uuid, ConcreteDocument["documentName"]>;
-
-declare global {
-  /**
-   * Export data content to be saved to a local file
-   * @param data     - Data content converted to a string
-   * @param type     - The type of
-   * @param filename - The filename of the resulting download
-   */
-  function saveDataToFile(data: string, type: string, filename: string): void;
-
-  /**
-   * Read text data from a user provided File object
-   * @param file - A File object
-   * @returns A Promise which resolves to the loaded text data
-   */
-  function readTextFromFile(file: File): Promise<string>;
-
-  interface FromUuidOptions {
-    /** A Document to resolve relative UUIDs against. */
-    relative?: ClientDocument;
-
-    /** Allow retrieving an invalid Document. (default: `false`) */
-    invalid?: boolean;
-  }
-
-  /**
-   * Retrieve an Entity or Embedded Entity by its Universally Unique Identifier (uuid).
-   * @param uuid    - The uuid of the Entity or Embedded Entity to retrieve
-   * @param options - Options to configure how a UUID is resolved.
-   */
-  function fromUuid<ConcreteDocument extends Document.Any = __UnsetDocument, const Uuid extends string = string>(
-    uuid: FromUuidValidate<ConcreteDocument, Uuid> | null | undefined,
-    options?: FromUuidOptions,
-  ): Promise<(__UnsetDocument extends ConcreteDocument ? FromUuid<Uuid> : ConcreteDocument) | null>;
-
-  interface FromUuidSyncOptions {
-    /** A Document to resolve relative UUIDs against. */
-    relative?: ClientDocument;
-
-    /** Allow retrieving an invalid Document. (default: `false`) */
-    invalid?: boolean;
-
-    /** Throw an error if the UUID cannot be resolved synchronously. (default: `true`) */
-    strict?: boolean;
-  }
-
-  /**
-   * Retrieve a Document by its Universally Unique Identifier (uuid) synchronously. If the uuid resolves to a compendium
-   * document, that document's index entry will be returned instead.
-   * @param uuid    - The uuid of the Document to retrieve.
-   * @param options - Options to configure how a UUID is resolved.
-   * @returns The Document or its index entry if it resides in a Compendium, otherwise null.
-   * @throws If the uuid resolves to a Document that cannot be retrieved synchronously.
-   */
-  function fromUuidSync<ConcreteDocument extends Document.Any = __UnsetDocument, const Uuid extends string = string>(
-    uuid: FromUuidValidate<ConcreteDocument, Uuid> | null | undefined,
-    options?: FromUuidSyncOptions,
-  ): (__UnsetDocument extends ConcreteDocument ? FromUuid<Uuid> : ConcreteDocument) | AnyObject | null;
-
-  /**
-   * Resolve a series of embedded document UUID parts against a parent Document.
-   * @param parent - The parent Document.
-   * @param parts  - A series of Embedded Document UUID parts.
-   * @returns The resolved Embedded Document.
-   * @internal
-   */
-  function _resolveEmbedded(parent: foundry.abstract.Document.Any, parts: string[]): foundry.abstract.Document.Any;
-
-  /**
-   * Return a reference to the Document class implementation which is configured for use.
-   * @param documentName - The canonical Document name, for example "Actor"
-   * @returns configured Document class implementation
-   */
-  function getDocumentClass<Name extends Document.Type>(documentName: Name): Document.ImplementationClassFor<Name>;
-}
diff --git a/src/foundry/client/core/video.d.mts b/src/foundry/client/core/video.d.mts
deleted file mode 100644
index d76ded811..000000000
--- a/src/foundry/client/core/video.d.mts
+++ /dev/null
@@ -1,161 +0,0 @@
-import "youtube";
-
-declare global {
-  /**
-   * A helper class to provide common functionality for working with HTML5 video objects
-   * A singleton instance of this class is available as `game.video`
-   */
-  class VideoHelper {
-    /** @throws `"You may not re-initialize the singleton VideoHelper. Use game.video instead."` */
-    constructor();
-
-    /**
-     * A user gesture must be registered before video playback can begin.
-     * This Set records the video elements which await such a gesture.
-     */
-    pending: Set<HTMLVideoElement>;
-
-    /**
-     * A mapping of base64 video thumbnail images
-     * @defaultValue an empty Map
-     */
-    thumbs: Map<string, string>;
-
-    /**
-     * A flag for whether video playback is currently locked by awaiting a user gesture
-     * @defaultValue `true`
-     */
-    locked: boolean;
-
-    /**
-     * Store a Promise while the YouTube API is initializing.
-     */
-    #youTubeReady: Promise<void>;
-
-    /**
-     * The YouTube URL regex.
-     */
-    #youTubeRegex: RegExp;
-
-    /**
-     * Return the HTML element which provides the source for a loaded texture.
-     * @param mesh - The rendered mesh
-     * @returns The source HTML element
-     */
-    getSourceElement(mesh: PIXI.Sprite | SpriteMesh): HTMLImageElement | HTMLVideoElement | null;
-
-    /**
-     * Get the video element source corresponding to a Sprite or SpriteMesh.
-     * @param object - The PIXI source
-     * @returns The source video element or null
-     */
-    getVideoSource(object: PIXI.Sprite | PIXI.Texture | SpriteMesh): HTMLVideoElement | null;
-
-    /**
-     * Clone a video texture so that it can be played independently of the original base texture.
-     * @param source - The video element source
-     * @returns An unlinked PIXI.Texture which can be played independently
-     */
-    cloneTexture(source: HTMLVideoElement): Promise<PIXI.Texture>;
-
-    /**
-     * Check if a source has a video extension.
-     * @param src - The source.
-     * @returns If the source has a video extension or not.
-     */
-    static hasVideoExtension(src: string): boolean;
-
-    /**
-     * Play a single video source
-     * If playback is not yet enabled, add the video to the pending queue
-     * @param video   - The VIDEO element to play
-     * @param options - Additional options for modifying video playback (default: `{}`)
-     */
-    play(
-      video: HTMLVideoElement,
-      options?: {
-        /**
-         * Should the video be playing? Otherwise, it will be paused
-         * @defaultValue `true`
-         */
-        playing?: boolean;
-
-        /**
-         * Should the video loop?
-         * @defaultValue `true`
-         */
-        loop?: boolean;
-
-        /** A specific timestamp between 0 and the video duration to begin playback */
-        offset?: number;
-
-        /** Desired volume level of the video's audio channel (if any) */
-        volume?: number;
-      },
-    ): void;
-
-    /**
-     * Stop a single video source
-     * @param video - The VIDEO element to stop
-     */
-    stop(video: HTMLVideoElement): void;
-
-    /**
-     * Register an event listener to await the first mousemove gesture and begin playback once observed
-     * A user interaction must involve a mouse click or keypress.
-     * Listen for any of these events, and handle the first observed gesture.
-     */
-    awaitFirstGesture(): void;
-
-    /**
-     * Handle the first observed user gesture
-     * We need a slight delay because unfortunately Chrome is stupid and doesn't always acknowledge the gesture fast enough.
-     * @param event - The mouse-move event which enables playback
-     * @internal
-     */
-    protected _onFirstGesture(event: Event): void;
-
-    /**
-     * Create and cache a static thumbnail to use for the video.
-     * The thumbnail is cached using the video file path or URL.
-     * @param src     - The source video URL
-     * @param options - Thumbnail creation options, including width and height
-     * @returns The created and cached base64 thumbnail image, or a placeholder image if the canvas is
-     *          disabled and no thumbnail can be generated.
-     */
-    createThumbnail(src: string, options: ImageHelper.CompositeOptions): Promise<string>;
-
-    /**
-     * Lazily-load the YouTube API and retrieve a Player instance for a given iframe.
-     * @param id     - The iframe ID.
-     * @param config - A player config object. See {@link https://developers.google.com/youtube/iframe_api_reference} for reference.
-     */
-    getYouTubePlayer(id: string, config?: YT.PlayerOptions): Promise<YT.Player>;
-
-    /**
-     * Retrieve a YouTube video ID from a URL.
-     * @param url - The URL.
-     */
-    getYouTubeId(url: string): string;
-
-    /**
-     * Take a URL to a YouTube video and convert it into a URL suitable for embedding in a YouTube iframe.
-     * @param url  - The URL to convert.
-     * @param vars - YouTube player parameters. (default: `{}`)
-     * @returns The YouTube embed URL.
-     */
-    getYouTubeEmbedURL(url: string, vars?: YT.PlayerVars): string;
-
-    /**
-     * Test a URL to see if it points to a YouTube video.
-     * @param url - The URL to test. (default: `""`)
-     */
-    isYouTubeURL(url?: string): boolean;
-
-    /**
-     * Inject the YouTube API into the page.
-     * @returns A Promise that resolves when the API has initialized.
-     */
-    #injectYouTubeAPI(): Promise<void>;
-  }
-}
diff --git a/src/foundry/client/core/workers.d.mts b/src/foundry/client/core/workers.d.mts
deleted file mode 100644
index 6f69cb7cf..000000000
--- a/src/foundry/client/core/workers.d.mts
+++ /dev/null
@@ -1,129 +0,0 @@
-import type { AnyArray, AnyFunction, ValueOf } from "#utils";
-
-// TODO: smarter types for named functions
-declare global {
-  /**
-   * An asynchronous web Worker which can load user-defined functions and await execution using Promises.
-   * @param name    - The worker name to be initialized
-   * @param options - Worker initialization options (default: `{}`)
-   */
-  class AsyncWorker extends Worker {
-    constructor(name: string, options?: AsyncWorker.Options);
-
-    name: string;
-
-    /**
-     * A path reference to the JavaScript file which provides companion worker-side functionality.
-     * @defaultValue `"scripts/worker.js"`
-     */
-    static WORKER_HARNESS_JS: string;
-
-    /**
-     * A Promise which resolves once the Worker is ready to accept tasks
-     */
-    get ready(): Promise<void>;
-
-    /**
-     * An auto-incrementing task index.
-     * @defaultValue `0`
-     * @internal
-     */
-    protected _taskIndex: number;
-
-    /**
-     * Load a function onto a given Worker.
-     * The function must be a pure function with no external dependencies or requirements on global scope.
-     * @param functionName - The name of the function to load
-     * @param functionRef  - A reference to the function that should be loaded
-     * @returns A Promise which resolves once the Worker has loaded the function.
-     */
-    loadFunction(functionName: string, functionRef: AnyFunction): Promise<unknown>;
-
-    /**
-     * Execute a task on a specific Worker.
-     * @param functionName - The named function to execute on the worker. This function must first have been loaded.
-     * @param args         - An array of parameters with which to call the requested function (default: `[]`)
-     * @param transfer     - An array of transferable objects which are transferred to the worker thread.
-     *                       See https://developer.mozilla.org/en-US/docs/Glossary/Transferable_objects
-     *                       (default: `[]`)
-     * @returns A Promise which resolves with the returned result of the function once complete.
-     */
-    executeFunction(functionName: string, args?: AnyArray, transfer?: AnyArray): Promise<unknown>;
-  }
-
-  namespace AsyncWorker {
-    interface WorkerTask {
-      [key: string]: unknown;
-
-      /** An incrementing task ID used to reference task progress */
-      taskId?: number;
-
-      /** The task action being performed, from WorkerManager.WORKER_TASK_ACTIONS */
-      action: ValueOf<typeof WorkerManager.WORKER_TASK_ACTIONS>;
-    }
-  }
-
-  /**
-   * A client-side class responsible for managing a set of web workers.
-   * This interface is accessed as a singleton instance via game.workers.
-   * @see {@link Game.workers | `Game#workers`}
-   */
-  class WorkerManager extends Map<string, AsyncWorker> {
-    constructor();
-
-    /**
-     * Supported worker task actions
-     */
-    static WORKER_TASK_ACTIONS: Readonly<{
-      INIT: "init";
-      LOAD: "load";
-      EXECUTE: "execute";
-    }>;
-
-    /**
-     * Create a new named Worker.
-     * @param name   - The named Worker to create
-     * @param config - Worker configuration parameters passed to the AsyncWorker constructor
-     * @returns The created AsyncWorker which is ready to accept tasks
-     */
-    createWorker(name: string, config?: AsyncWorker.Options): Promise<AsyncWorker>;
-
-    /**
-     * Retire a current Worker, terminating it immediately.
-     * @see {@link Worker.terminate | `Worker#terminate`}
-     * @param name - The named worker to terminate
-     */
-    retireWorker(name: string): void;
-
-    /**
-     * Get a currently active Worker by name.
-     * @param name - The named Worker to retrieve
-     * @returns The AsyncWorker instance
-     * @deprecated since v11, will be removed in v13
-     * @remarks `"WorkerManager#getWorker is deprecated in favor of WorkerManager#get"`
-     * @remarks Throws an error if the name is not in the internal map, while `get` does not.
-     */
-    getWorker(name: string): AsyncWorker;
-  }
-
-  namespace AsyncWorker {
-    interface Options {
-      /**
-       * Should the worker run in debug mode?
-       * @defaultValue `false`
-       */
-      debug?: boolean | undefined;
-
-      /**
-       * Should the worker automatically load the primitives library?
-       * @defaultValue `false`
-       */
-      loadPrimitives?: boolean | undefined;
-
-      /**
-       * Should the worker operates in script modes? Optional scripts.
-       */
-      scripts?: string[] | undefined;
-    }
-  }
-}
diff --git a/src/foundry/client/data/abstract/client-document.d.mts b/src/foundry/client/data/abstract/client-document.d.mts
index 4a2269de6..982329efc 100644
--- a/src/foundry/client/data/abstract/client-document.d.mts
+++ b/src/foundry/client/data/abstract/client-document.d.mts
@@ -600,7 +600,7 @@ declare global {
   // TODO: Namespaces typically match the Mixin, not the non-exported class, but we're exporting the class for type reasons,
   // TODO: so this is an exception?
   namespace ClientDocument {
-    interface SortOptions<T, SortKey extends string = "sort"> extends SortingHelpers.SortOptions<T, SortKey> {
+    interface SortOptions<T, SortKey extends string = "sort"> extends foundry.utils.SortOptions<T, SortKey> {
       /**
        * Additional data changes which are applied to each sorted document
        * @defaultValue `{}`
diff --git a/src/foundry/client/data/collections/combats.d.mts b/src/foundry/client/data/collections/combats.d.mts
index be74f7438..d1071d583 100644
--- a/src/foundry/client/data/collections/combats.d.mts
+++ b/src/foundry/client/data/collections/combats.d.mts
@@ -15,7 +15,7 @@ declare global {
     /**
      * Provide the settings object which configures the Combat document
      */
-    static get settings(): ClientSettings.SettingInitializedType<"core", Combat.CONFIG_SETTING>;
+    static get settings(): foundry.helpers.ClientSettings.SettingInitializedType<"core", Combat.CONFIG_SETTING>;
 
     override get directory(): typeof ui.combat;
 
diff --git a/src/foundry/client/data/collections/compendium-collection.d.mts b/src/foundry/client/data/collections/compendium-collection.d.mts
index 276d78f71..b09713b79 100644
--- a/src/foundry/client/data/collections/compendium-collection.d.mts
+++ b/src/foundry/client/data/collections/compendium-collection.d.mts
@@ -1,6 +1,7 @@
 import type { DeepPartial, EmptyObject, InexactPartial, SimpleMerge } from "#utils";
 import type Document from "#common/abstract/document.d.mts";
 
+import SocketInterface = foundry.helpers.SocketInterface;
 import Game = foundry.Game;
 
 declare global {
diff --git a/src/foundry/client/data/documents/combat.d.mts b/src/foundry/client/data/documents/combat.d.mts
index 14e64dd03..8454d19d7 100644
--- a/src/foundry/client/data/documents/combat.d.mts
+++ b/src/foundry/client/data/documents/combat.d.mts
@@ -602,7 +602,7 @@ declare global {
     /** Return the object of settings which modify the Combat Tracker behavior */
     // Type is copied here to avoid recursion issue
     // TODO: Make the setting name configurable?
-    get settings(): ClientSettings.SettingInitializedType<"core", Combat.CONFIG_SETTING>;
+    get settings(): foundry.helpers.ClientSettings.SettingInitializedType<"core", Combat.CONFIG_SETTING>;
 
     /** Has this combat encounter been started? */
     get started(): boolean;
diff --git a/src/foundry/client/data/documents/scene.d.mts b/src/foundry/client/data/documents/scene.d.mts
index d159dbd77..df06b606e 100644
--- a/src/foundry/client/data/documents/scene.d.mts
+++ b/src/foundry/client/data/documents/scene.d.mts
@@ -2,7 +2,8 @@ import type { InexactPartial, Merge } from "#utils";
 import type { documents } from "#client/client.d.mts";
 import type Document from "#common/abstract/document.d.mts";
 import type { DataSchema } from "#common/data/fields.d.mts";
-import type { LightData, TextureData } from "#common/data/data.mjs";
+import type { LightData, TextureData } from "#common/data/data.d.mts";
+import type ImageHelper from "#client/helpers/media/image-helper.d.mts";
 
 import fields = foundry.data.fields;
 
diff --git a/src/foundry/client/game.d.mts b/src/foundry/client/game.d.mts
index c983982e5..0144562a9 100644
--- a/src/foundry/client/game.d.mts
+++ b/src/foundry/client/game.d.mts
@@ -65,12 +65,12 @@ declare class InternalGame<RunEvents extends InitializationHook> {
   /**
    * The game World which is currently active.
    */
-  readonly world: World;
+  readonly world: foundry.packages.World;
 
   /**
    * The System which is used to power this game World.
    */
-  readonly system: System;
+  readonly system: foundry.packages.System;
 
   /**
    * A Map of active Modules which are currently eligible to be enabled in this World.
@@ -106,7 +106,7 @@ declare class InternalGame<RunEvents extends InitializationHook> {
    * The global document index.
    * @remarks Initialized just before the `"setup"` hook event is called.
    */
-  readonly documentIndex: SimpleInitializedOn<DocumentIndex, "setup", RunEvents>;
+  readonly documentIndex: SimpleInitializedOn<foundry.helpers.DocumentIndex, "setup", RunEvents>;
 
   /**
    * The UUID redirects tree.
@@ -250,7 +250,7 @@ declare class InternalGame<RunEvents extends InitializationHook> {
   /**
    * The singleton Clipboard Helper.
    */
-  readonly clipboard: ClipboardHelper;
+  readonly clipboard: foundry.helpers.interaction.ClipboardHelper;
 
   /**
    * Localization support
@@ -261,71 +261,71 @@ declare class InternalGame<RunEvents extends InitializationHook> {
   /**
    * The singleton instance of the ClientIssues manager.
    */
-  readonly issues: ClientIssues;
+  readonly issues: foundry.helpers.ClientIssues;
 
   /**
    * The Gamepad Manager
    * @remarks Initialized just before the `"ready"` hook event.
    */
-  readonly gamepad: SimpleInitializedOn<GamepadManager, "ready", RunEvents>;
+  readonly gamepad: SimpleInitializedOn<foundry.helpers.interaction.GamepadManager, "ready", RunEvents>;
 
   /**
    * The Keyboard Manager
    * @remarks Initialized just before the `"ready"` hook event.
    */
-  readonly keyboard: SimpleInitializedOn<KeyboardManager, "ready", RunEvents>;
+  readonly keyboard: SimpleInitializedOn<foundry.helpers.interaction.KeyboardManager, "ready", RunEvents>;
 
   /**
    * Client keybindings which are used to configure application behavior
    * @remarks Initialized just before the `"ready"` hook event.
    */
-  readonly keybindings: SimpleInitializedOn<ClientKeybindings, "ready", RunEvents>;
+  readonly keybindings: SimpleInitializedOn<foundry.helpers.interaction.ClientKeybindings, "ready", RunEvents>;
 
   /**
    * The Mouse Manager
    * @remarks Initialized just before the `"ready"` hook event.
    */
-  readonly mouse: SimpleInitializedOn<MouseManager, "ready", RunEvents>;
+  readonly mouse: SimpleInitializedOn<foundry.helpers.interaction.MouseManager, "ready", RunEvents>;
 
   /**
    * The New User Experience manager.
    * @remarks Initialized just after the `"ready"` hook event.
    */
-  readonly nue: NewUserExperience;
+  readonly nue: foundry.nue.NewUserExperienceManager;
 
   /**
    * Client settings which are used to configure application behavior
    * @remarks Settings are registered between `"init"` and `"i18nInit"` hook events.
    */
-  readonly settings: ClientSettings;
+  readonly settings: foundry.helpers.ClientSettings;
 
   /**
    * A singleton GameTime instance which manages the progression of time within the game world.
    */
-  readonly time: GameTime;
+  readonly time: foundry.helpers.GameTime;
 
   /**
    * A singleton instance of the TooltipManager class
    * @remarks Initialized just before the `"setup"` hook events is called.
    */
-  readonly tooltip: SimpleInitializedOn<TooltipManager, "setup", RunEvents>;
+  readonly tooltip: SimpleInitializedOn<foundry.helpers.interaction.TooltipManager, "setup", RunEvents>;
 
   /**
    * A singleton instance of the Tour collection class
    * @remarks Initialized just before the `"setup"` hook events is called.
    */
-  readonly tours: SimpleInitializedOn<Tours, "setup", RunEvents>;
+  readonly tours: SimpleInitializedOn<foundry.nue.ToursCollection, "setup", RunEvents>;
 
   /**
    * A singleton instance of the Video Helper class
    * @remarks Initialized just before the `"setup"` hook events is called.
    */
-  readonly video: SimpleInitializedOn<VideoHelper, "setup", RunEvents>;
+  readonly video: SimpleInitializedOn<foundry.helpers.media.VideoHelper, "setup", RunEvents>;
 
   /**
    * A singleton web Worker manager.
    */
-  readonly workers: WorkerManager;
+  readonly workers: foundry.helpers.WorkerManager;
 
   /**
    * Fetch World data and return a Game instance
@@ -626,14 +626,14 @@ declare global {
 }
 
 declare namespace Game {
-  interface ModuleCollection extends Collection<Module> {
+  interface ModuleCollection extends Collection<foundry.packages.Module> {
     /**
      * Gets the module requested for by ID
      * @see {@linkcode ModuleConfig} to add custom properties to modules like APIs.
      * @see {@linkcode RequiredModules} to remove `undefined` from the return type for a given module
      * @param id - The module ID to look up
      */
-    get<T extends string>(id: T): Module & ConfiguredModule<T>;
+    get<T extends string>(id: T): foundry.packages.Module & ConfiguredModule<T>;
   }
 
   namespace Model {
@@ -690,7 +690,7 @@ declare namespace Game {
       } | null;
       storages: ("public" | "data" | "s3")[];
     };
-    modules: Module["_source"][];
+    modules: foundry.packages.Module["_source"][];
     options: {
       language: string;
       port: number;
@@ -711,7 +711,7 @@ declare namespace Game {
     >;
     paused: boolean;
     release: foundry.config.ReleaseData["_source"];
-    system: System["_source"];
+    system: foundry.packages.System["_source"];
     systemUpdate: {
       hasUpdate: boolean;
       version: string;
@@ -722,7 +722,7 @@ declare namespace Game {
     // but is only filled in if there's `template.json`
     model: Model;
     userId: string;
-    world: World["_source"];
+    world: foundry.packages.World["_source"];
   } & {
     [DocumentType in  // eslint-disable-next-line @typescript-eslint/no-deprecated
       | foundry.CONST.DOCUMENT_TYPES
diff --git a/src/foundry/client/helpers/client-issues.d.mts b/src/foundry/client/helpers/client-issues.d.mts
index 581cf336a..da89c4b48 100644
--- a/src/foundry/client/helpers/client-issues.d.mts
+++ b/src/foundry/client/helpers/client-issues.d.mts
@@ -58,7 +58,7 @@ declare class ClientIssues {
    * Get the Document sub-type counts for a given module.
    * @param module - The module or its ID.
    */
-  getSubTypeCountsFor(module: Module | string): ClientIssues.ModuleSubTypeCounts | undefined;
+  getSubTypeCountsFor(module: foundry.packages.Module | string): ClientIssues.ModuleSubTypeCounts | undefined;
 
   /**
    * Retrieve all sub-type counts in the world.
diff --git a/src/foundry/client/helpers/hooks.d.mts b/src/foundry/client/helpers/hooks.d.mts
index ead4b8a06..3a196a829 100644
--- a/src/foundry/client/helpers/hooks.d.mts
+++ b/src/foundry/client/helpers/hooks.d.mts
@@ -1,11 +1,209 @@
+import type { AnyFunction } from "#utils";
+import type { Hooks as HookConfig } from "#configuration";
+
 /**
  * A simple event framework used throughout Foundry Virtual Tabletop.
  * When key actions or events occur, a "hook" is defined where user-defined callback functions can execute.
  * This class manages the registration and execution of hooked callback functions.
- * @remarks TODO: Stub
+ * @remarks TODO: Evaluate if this should remove from declare global - complicated by interaction with `src/foundry/client/hooks.d.mts`
  */
-declare class Hooks {}
+declare global {
+  class Hooks {
+    /**
+     * A mapping of hook events which have functions registered to them.
+     */
+    static get events(): Hooks.HookedFunction[];
+
+    /**
+     * Register a callback handler which should be triggered when a hook is triggered.
+     *
+     * @param hook    - The unique name of the hooked event
+     * @param fn      - The callback function which should be triggered when the hook event occurs
+     * @param options - Options which customize hook registration
+     * @returns An ID number of the hooked function which can be used to turn off the hook later
+     */
+    static on<K extends keyof HookConfig.HookConfig>(
+      hook: K,
+      fn: HookConfig.HookConfig[K],
+      options?: Hooks.OnOptions,
+    ): number;
+
+    /**
+     * @deprecated These hooks are now designed to be automatically inferred.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
+    static on<H extends Hooks.DynamicCallbacks>(hook: string, fn: H, options?: Hooks.OnOptions): number;
+
+    /**
+     * @deprecated This hook has been deprecated. See the hook's definition for more details.
+     */
+    static on<K extends keyof HookConfig.DeprecatedHookConfig>(
+      hook: K,
+      fn: HookConfig.DeprecatedHookConfig[K],
+      options?: Hooks.OnOptions,
+    ): number;
+
+    /**
+     * @deprecated Please merge into {@linkcode HookConfig.HookConfig | "fvtt-types/configuration/Hooks.HookConfig"} instead.
+     */
+    static on<H extends AnyFunction>(hook: string, fn: H, options?: Hooks.OnOptions): number;
+
+    /**
+     * Register a callback handler for an event which is only triggered once the first time the event occurs.
+     * An alias for Hooks.on with `{once: true}`
+     * @param hook - The unique name of the hooked event
+     * @param fn   - The callback function which should be triggered when the hook event occurs
+     * @returns An ID number of the hooked function which can be used to turn off the hook later
+     */
+    static once<K extends keyof HookConfig.HookConfig>(hook: K, fn: HookConfig.HookConfig[K]): number;
+
+    /**
+     * @deprecated These hooks are now designed to be automatically inferred.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
+    static once<H extends Hooks.DynamicCallbacks>(hook: string, fn: H): number;
+
+    /**
+     * @deprecated This hook has been deprecated. See the hook's definition for more details.
+     */
+    static once<K extends keyof HookConfig.DeprecatedHookConfig>(
+      hook: K,
+      fn: HookConfig.DeprecatedHookConfig[K],
+      options?: Hooks.OnOptions,
+    ): number;
+
+    static once<H extends AnyFunction>(hook: string, fn: H): number;
+
+    /**
+     * Unregister a callback handler for a particular hook event
+     *
+     * @param hook - The unique name of the hooked event
+     * @param fn   - The function, or ID number for the function, that should be turned off
+     */
+    static off<K extends keyof HookConfig.HookConfig>(hook: K, fn: number | HookConfig.HookConfig[K]): void;
+
+    /**
+     * @deprecated These hooks are now designed to be automatically inferred.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
+    static off<H extends Hooks.DynamicCallbacks>(hook: string, fn: number | H): void;
+
+    /**
+     * @deprecated This hook has been deprecated. See the hook's definition for more details.
+     */
+    static off<K extends keyof HookConfig.DeprecatedHookConfig>(
+      hook: K,
+      fn: number | HookConfig.DeprecatedHookConfig[K],
+      options?: Hooks.OnOptions,
+    ): void;
+
+    /**
+     * @deprecated Please merge into {@linkcode HookConfig.HookConfig | "fvtt-types/configuration/Hooks.HookConfig"} instead.
+     */
+    static off<H extends AnyFunction>(hook: string, fn: number | H): void;
+
+    /**
+     * Call all hook listeners in the order in which they were registered
+     * Hooks called this way can not be handled by returning false and will always trigger every hook callback.
+     *
+     * @param hook - The hook being triggered
+     * @param args - Arguments passed to the hook callback functions
+     */
+    static callAll<K extends keyof HookConfig.HookConfig>(hook: K, ...args: Parameters<HookConfig.HookConfig[K]>): true;
+
+    /**
+     * @deprecated These hooks are now designed to be automatically inferred.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
+    static callAll<H extends Hooks.DynamicCallbacks>(hook: string, ...args: Parameters<H>): true;
+
+    /**
+     * @deprecated This hook has been deprecated. See the hook's definition for more details.
+     */
+    static callAll<K extends keyof HookConfig.DeprecatedHookConfig>(
+      hook: K,
+      ...args: Parameters<HookConfig.DeprecatedHookConfig[K]>
+    ): true;
+
+    /**
+     * @deprecated Please merge into {@linkcode HookConfig.HookConfig | "fvtt-types/configuration/Hooks.HookConfig"} instead.
+     */
+    static callAll<H extends (...args: unknown[]) => unknown>(hook: string, ...args: Parameters<H>): true;
+
+    /**
+     * Call hook listeners in the order in which they were registered.
+     * Continue calling hooks until either all have been called or one returns false.
+     *
+     * Hook listeners which return false denote that the original event has been adequately handled and no further
+     * hooks should be called.
+     *
+     * @param hook - The hook being triggered
+     * @param args - Arguments passed to the hook callback functions
+     */
+    static call<K extends keyof HookConfig.HookConfig>(hook: K, ...args: Parameters<HookConfig.HookConfig[K]>): boolean;
+
+    /**
+     * @deprecated These hooks are now designed to be automatically inferred.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
+    static call<H extends Hooks.DynamicCallbacks>(hook: string, ...args: Parameters<H>): boolean;
+
+    /**
+     * @deprecated This hook has been deprecated. See the hook's definition for more details.
+     */
+    static call<K extends keyof HookConfig.DeprecatedHookConfig>(
+      hook: K,
+      ...args: Parameters<HookConfig.DeprecatedHookConfig[K]>
+    ): boolean;
+
+    /**
+     * @deprecated Please merge into {@linkcode HookConfig.HookConfig | "fvtt-types/configuration/Hooks.HookConfig"} instead.
+     */
+    static call<H extends (...args: unknown[]) => unknown>(hook: string, ...args: Parameters<H>): boolean;
+
+    /**
+     * Notify subscribers that an error has occurred within foundry.
+     * @param location - The method where the error was caught.
+     * @param error    - The error.
+     * @param options  - Additional options to configure behaviour.
+     */
+    static onError(location: string, error: Error, { msg, notify, log, ...data }?: Hooks.OnError): void;
+  }
+
+  namespace Hooks {
+    interface HookedFunction {
+      hook: string;
+      id: number;
+      fn: AnyFunction;
+      once: boolean;
+    }
+
+    interface OnError {
+      /**
+       * Additional data to pass to the hook subscribers.
+       * @defaultValue `{}`
+       */
+      [key: string]: unknown;
+
+      /**
+       * A message which should prefix the resulting error or notification.
+       * @defaultValue `""`
+       */
+      msg?: string | undefined;
+
+      /**
+       * The level at which to log the error to console (if at all).
+       * @defaultValue `null`
+       */
+      notify?: keyof NonNullable<typeof ui.notifications> | null | undefined;
 
-declare namespace Hooks {}
+      /**
+       * The level at which to spawn a notification in the UI (if at all).
+       * @defaultValue `null`
+       */
+      log?: keyof typeof console | null | undefined;
+    }
+  }
+}
 
 export default Hooks;
diff --git a/src/foundry/client/helpers/interaction/client-keybindings.d.mts b/src/foundry/client/helpers/interaction/client-keybindings.d.mts
index c6ea105fe..221a00288 100644
--- a/src/foundry/client/helpers/interaction/client-keybindings.d.mts
+++ b/src/foundry/client/helpers/interaction/client-keybindings.d.mts
@@ -1,4 +1,5 @@
 import type { LazyUnknown, ValueOf } from "#utils";
+import type KeyboardManager from "./keyboard-manager.d.mts";
 
 /**
  * A class responsible for managing defined game keybinding.
diff --git a/src/foundry/client/helpers/interaction/keyboard-manager.d.mts b/src/foundry/client/helpers/interaction/keyboard-manager.d.mts
index 9940cdb03..459cc7a07 100644
--- a/src/foundry/client/helpers/interaction/keyboard-manager.d.mts
+++ b/src/foundry/client/helpers/interaction/keyboard-manager.d.mts
@@ -1,3 +1,5 @@
+import type ClientKeybindings from "./client-keybindings.mjs";
+
 /**
  * A set of helpers and management functions for dealing with user input from keyboard events.
  * {@link https://keycode.info/}
diff --git a/src/foundry/client/helpers/interaction/tooltip-manager.d.mts b/src/foundry/client/helpers/interaction/tooltip-manager.d.mts
index b16857df7..2b425e4a6 100644
--- a/src/foundry/client/helpers/interaction/tooltip-manager.d.mts
+++ b/src/foundry/client/helpers/interaction/tooltip-manager.d.mts
@@ -193,6 +193,12 @@ declare class TooltipManager {
     left?: null;
     textAlign?: string;
   }): void;
+
+  /**
+   * Retrieve the configured TooltipManager implementation
+   * @privateRemarks TODO: Config.ux handling
+   */
+  static get implementation(): typeof TooltipManager;
 }
 
 declare namespace TooltipManager {
diff --git a/src/foundry/client/helpers/localization.d.mts b/src/foundry/client/helpers/localization.d.mts
index 189e0ff76..b45fa8590 100644
--- a/src/foundry/client/helpers/localization.d.mts
+++ b/src/foundry/client/helpers/localization.d.mts
@@ -111,7 +111,10 @@ declare class Localization {
    * @param lang - The target language to filter on
    * @returns An array of translation file paths
    */
-  protected _filterLanguagePaths(pkg: World | Module | System, lang: string): string[];
+  protected _filterLanguagePaths(
+    pkg: foundry.packages.World | foundry.packages.Module | foundry.packages.System,
+    lang: string,
+  ): string[];
 
   /**
    * Load a single translation file and return its contents as processed JSON
diff --git a/src/foundry/client/helpers/media/video-helper.d.mts b/src/foundry/client/helpers/media/video-helper.d.mts
index 1a4d0a625..22a3639d0 100644
--- a/src/foundry/client/helpers/media/video-helper.d.mts
+++ b/src/foundry/client/helpers/media/video-helper.d.mts
@@ -122,7 +122,7 @@ declare class VideoHelper {
    * @returns The created and cached base64 thumbnail image, or a placeholder image if the canvas is
    *          disabled and no thumbnail can be generated.
    */
-  createThumbnail(src: string, options: ImageHelper.CompositeOptions): Promise<string>;
+  createThumbnail(src: string, options: foundry.helpers.media.ImageHelper.CompositeOptions): Promise<string>;
 
   /**
    * Lazily-load the YouTube API and retrieve a Player instance for a given iframe.
diff --git a/src/foundry/client/hooks.d.mts b/src/foundry/client/hooks.d.mts
index 338e9a470..9a43ebff2 100644
--- a/src/foundry/client/hooks.d.mts
+++ b/src/foundry/client/hooks.d.mts
@@ -10,8 +10,9 @@ import type {
   DatabaseDeleteOperation,
   DatabaseUpdateOperation,
 } from "#common/abstract/_types.d.mts";
-import type CompendiumArt from "#client/helpers/media/compendium-art.mjs";
+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 AVSettings = foundry.av.AVSettings;
 import Application = foundry.appv1.api.Application;
diff --git a/src/foundry/client/index.d.mts b/src/foundry/client/index.d.mts
index 53ee4bd5c..7386790db 100644
--- a/src/foundry/client/index.d.mts
+++ b/src/foundry/client/index.d.mts
@@ -1,11 +1,8 @@
-import "./av/index.d.mts";
 import "./config.d.mts";
-import "./core/index.d.mts";
 import "./data/index.d.mts";
 import "./game.d.mts";
 import "./head.d.mts";
 import "./hooks.d.mts";
 import "./pixi/index.d.mts";
 import "./tail.d.mts";
-import "./tours/index.d.mts";
 import "./ui/index.d.mts";
diff --git a/src/foundry/client/nue/tour.d.mts b/src/foundry/client/nue/tour.d.mts
index 993b5f88c..47390c950 100644
--- a/src/foundry/client/nue/tour.d.mts
+++ b/src/foundry/client/nue/tour.d.mts
@@ -245,7 +245,7 @@ declare namespace Tour {
     selector?: string | undefined;
 
     /** How the tooltip for the step should be displayed relative to the target element. If omitted, the best direction will be attempted to be auto-selected. */
-    tooltipDirection?: TooltipManager.TOOLTIP_DIRECTIONS | undefined;
+    tooltipDirection?: foundry.helpers.interaction.TooltipManager.TOOLTIP_DIRECTIONS | undefined;
 
     /** Whether the Step is restricted to the GM only. Defaults to false. */
     restricted?: boolean | undefined;
diff --git a/src/foundry/client/packages/_module.d.mts b/src/foundry/client/packages/_module.d.mts
index 5b63eb2c0..547f701b5 100644
--- a/src/foundry/client/packages/_module.d.mts
+++ b/src/foundry/client/packages/_module.d.mts
@@ -8,7 +8,7 @@ import System from "./system.mjs";
 import World from "./world.mjs";
 
 export * as types from "./_types.mjs";
-// export * from "#common/packages/_module.mjs";
+export * from "#common/packages/_module.mjs";
 export { default as ClientPackageMixin } from "./client-package.mjs";
 export { Module, System, World };
 
diff --git a/src/foundry/client/packages/client-package.d.mts b/src/foundry/client/packages/client-package.d.mts
index 8eafcf72d..75272c4df 100644
--- a/src/foundry/client/packages/client-package.d.mts
+++ b/src/foundry/client/packages/client-package.d.mts
@@ -1,11 +1,154 @@
+import type { FixedInstanceType, Mixin } from "#utils";
+import type { CONST } from "#client/client.d.mts";
+import type BasePackage from "#common/packages/base-package.d.mts";
+import type Module from "./module.d.mts";
+import type System from "./system.d.mts";
+
 /**
  * A client-side mixin used for all Package types.
  * @param BasePackage - The parent BasePackage class being mixed
  * @returns A BasePackage subclass mixed with ClientPackage features
- * @remarks TODO: Stub
  */
-declare function ClientPackageMixin(BasePackage: unknown): unknown;
+declare function ClientPackageMixin<BaseClass extends ClientPackageMixin.BaseClass>(
+  BasePackage: BaseClass,
+): Mixin<typeof ClientPackageMixin.ClientPackage, BaseClass>;
+
+declare namespace ClientPackageMixin {
+  interface AnyMixedConstructor extends ReturnType<typeof ClientPackageMixin<BaseClass>> {}
+  interface AnyMixed extends FixedInstanceType<AnyMixedConstructor> {}
+
+  type BaseClass = BasePackage.Internal.Constructor;
+
+  interface PackageCompatibilityBadge {
+    type: "safe" | "unsafe" | "warning" | "neutral" | "error";
+    tooltip: string;
+    label?: string;
+    icon?: string;
+  }
+
+  interface ModuleCreateData extends Module.CreateData {
+    active: boolean;
+  }
+
+  interface SystemCreateData extends foundry.packages.BaseSystem.CreateData {
+    strictDataCleaning?: boolean;
+  }
+
+  interface GetVersionBadgeOptions {
+    /**
+     * A specific collection of modules to test availability against. Tests against the currently installed modules by default.
+     */
+    modules?: Collection<Module>;
+
+    /**
+     * A specific collection of systems to test availability against. Tests against the currently installed systems by default.
+     */
+    systems?: Collection<System>;
+  }
+
+  interface FormatBadDependenciesTooltipOptions {
+    /**
+     * A specific collection of modules to test availability against. Tests against the currently installed modules by default.
+     */
+    modules?: Collection<Module> | undefined;
+
+    /**
+     * A specific collection of systems to test availability against. Tests against the currently installed systems by default.
+     */
+    systems?: Collection<System> | undefined;
+  }
+
+  interface FormatIncompatibleSystemsTooltipOptions {
+    /**
+     * A specific collection of systems to test availability against. Tests against the currently installed systems by default.
+     */
+    systems?: Collection<System> | undefined;
+  }
+
+  interface FromRemoteManifestOptions {
+    /**
+     * Whether to construct the remote package strictly
+     * @defaultValue `true`
+     */
+    strict?: boolean | undefined;
+  }
+
+  class ClientPackage {
+    /** @privateRemarks All mixin classses should accept anything for its constructor. */
+    constructor(...args: any[]);
+
+    /**
+     * Is this package marked as a favorite?
+     * This boolean is currently only populated as true in the /setup view of the software.
+     */
+    favorite: false;
+
+    /**
+     * Associate package availability with certain badge for client-side display.
+     */
+    getVersionBadge(): PackageCompatibilityBadge | null;
+
+    /**
+     * Determine a version badge for the provided compatibility data.
+     * @param availability - The availability level.
+     * @param data         - The compatibility data.
+     * @param options      - (default: `{}`)
+     */
+    static getVersionBadge(
+      availability: CONST.PACKAGE_AVAILABILITY_CODES,
+      data: Partial<PackageManifestData>,
+      options: GetVersionBadgeOptions,
+    ): PackageCompatibilityBadge | null;
+
+    /**
+     * List missing dependencies and format them for display.
+     * @param availability - The availability level.
+     * @param data         - The compatibility data.
+     * @param options      - (default: `{}`)
+     */
+    static _formatBadDependenciesTooltip(
+      availability: CONST.PACKAGE_AVAILABILITY_CODES,
+      data: Partial<PackageManifestData>,
+      options: FormatBadDependenciesTooltipOptions,
+    ): string;
+
+    /**
+     * List missing dependencies and format them for display.
+     * @param availability - The availability level.
+     * @param data         - The compatibility data.
+     * @param options      - (default: `{}`)
+     */
+    static _formatIncompatibleSystemsTooltip(
+      availability: CONST.PACKAGE_AVAILABILITY_CODES,
+      data: Partial<PackageManifestData>,
+      options: FormatIncompatibleSystemsTooltipOptions,
+    ): string;
+
+    /**
+     * When a package has been installed, add it to the local game data.
+     */
+    install(): void;
+
+    /**
+     * When a package has been uninstalled, remove it from the local game data.
+     */
+    uninstall(): void;
+
+    /**
+     * Remove a package from the local game data when it has been uninstalled.
+     * @param id - The package ID.
+     */
+    static uninstall(id: string): void;
 
-declare namespace ClientPackageMixin {}
+    /**
+     * Retrieve the latest Package manifest from a provided remote location.
+     * @param manifest - A remote manifest URL to load
+     * @param options  - Additional options which affect package construction
+     * @returns A Promise which resolves to a constructed ServerPackage instance
+     * @throws An error if the retrieved manifest data is invalid
+     */
+    static fromRemoteManifest(manifest: string, options: FromRemoteManifestOptions): Promise<ClientPackage | null>;
+  }
+}
 
 export default ClientPackageMixin;
diff --git a/src/foundry/client/packages/module.d.mts b/src/foundry/client/packages/module.d.mts
index 01481f68c..9ba32b38c 100644
--- a/src/foundry/client/packages/module.d.mts
+++ b/src/foundry/client/packages/module.d.mts
@@ -1,8 +1,87 @@
-/**
- * @remarks TODO: Stub
- */
-declare class Module {}
+import type BasePackage from "#common/packages/base-package.d.mts";
+import type AdditionalTypesField from "#common/packages/sub-types.d.mts";
+import type ClientPackageMixin from "./client-package.d.mts";
 
-declare namespace Module {}
+import fields = foundry.data.fields;
+
+declare class Module extends ClientPackageMixin(foundry.packages.BaseModule) {
+  constructor(data: ClientPackageMixin.ModuleCreateData, options: unknown);
+
+  /**
+   * Is this package currently active?
+   */
+  readonly active: boolean;
+}
+
+declare namespace Module {
+  /**
+   * The data put in {@linkcode DataModel._source}. This data is what was
+   * persisted to the database and therefore it must be valid JSON.
+   *
+   * For example a {@link fields.SetField | `SetField`} is persisted to the database as an array
+   * but initialized as a {@linkcode Set}.
+   */
+  interface Source extends fields.SchemaField.SourceData<Schema> {}
+
+  /**
+   * The data necessary to create a data model. Used in places like {@linkcode Module.create}
+   * and {@link Module | `new Module(...)`}.
+   *
+   * For example a {@link fields.SetField | `SetField`} can accept any {@linkcode Iterable}
+   * with the right values. This means you can pass a `Set` instance, an array of values,
+   * a generator, or any other iterable.
+   */
+  interface CreateData extends fields.SchemaField.CreateData<Schema> {}
+
+  /**
+   * The data after a {@linkcode DataModel} has been initialized, for example
+   * {@link Module.name | `Module#name`}.
+   *
+   * This is data transformed from {@linkcode Module.Source} and turned into more
+   * convenient runtime data structures. For example a {@link fields.SetField | `SetField`} is
+   * persisted to the database as an array of values but at runtime it is a `Set` instance.
+   */
+  interface InitializedData extends fields.SchemaField.InitializedData<Schema> {}
+
+  /**
+   * The data used to update a document, for example {@link Module.update | `Module#update`}.
+   * It is a distinct type from {@link Module.CreateData | `DeepPartial<Module.CreateData>`} because
+   * it has different rules for `null` and `undefined`.
+   */
+  interface UpdateData extends fields.SchemaField.UpdateData<Schema> {}
+
+  /**
+   * The schema for {@linkcode Module}. This is the source of truth for how an Module document
+   * must be structured.
+   *
+   * Foundry uses this schema to validate the structure of the {@linkcode Module}. For example
+   * a {@link fields.StringField | `StringField`} will enforce that the value is a string. More
+   * complex fields like {@link fields.SetField | `SetField`} goes through various conversions
+   * starting as an array in the database, initialized as a set, and allows updates with any
+   * iterable.
+   */
+  interface Schema extends BasePackage.Schema {
+    /**
+     * The current package version
+     * @remarks Actually defined in BasePackage but defined here to avoid conflict with BaseWorld
+     */
+    version: fields.StringField<{ required: true; blank: false; initial: "0" }>;
+
+    /**
+     * Does this module provide a translation for the core software?
+     */
+    coreTranslation: fields.BooleanField;
+
+    /**
+     * A library module provides no user-facing functionality and is solely for use by other modules. Loaded before any system or module scripts.
+     */
+    library: fields.BooleanField;
+
+    /**
+     * Additional document sub-types provided by this module.
+     */
+    documentTypes: AdditionalTypesField;
+  }
+}
 
 export default Module;
diff --git a/src/foundry/client/packages/system.d.mts b/src/foundry/client/packages/system.d.mts
index 47629b39d..30482d4ba 100644
--- a/src/foundry/client/packages/system.d.mts
+++ b/src/foundry/client/packages/system.d.mts
@@ -1,8 +1,147 @@
-/**
- * @remarks TODO: Stub
- */
-declare class System {}
+import type BasePackage from "#common/packages/base-package.d.mts";
+import type AdditionalTypesField from "#common/packages/sub-types.d.mts";
+import type DataModel from "#common/abstract/data.mjs";
+import type ClientPackageMixin from "./client-package.d.mts";
 
-declare namespace System {}
+import fields = foundry.data.fields;
+import Game = foundry.Game;
+
+declare class System extends ClientPackageMixin(foundry.packages.BaseSystem) {
+  constructor(data: ClientPackageMixin.SystemCreateData, options: unknown);
+
+  // options: not null (parameter default only, destructured in super)
+  protected override _configure(options?: DataModel.ConfigureOptions): void;
+
+  /**
+   * @deprecated since v12, will be removed in v14
+   * @remarks `"System#template is deprecated in favor of System#documentTypes"`
+   */
+  get template(): Game["model"];
+}
+
+declare namespace System {
+  /**
+   * The data put in {@linkcode DataModel._source}. This data is what was
+   * persisted to the database and therefore it must be valid JSON.
+   *
+   * For example a {@link fields.SetField | `SetField`} is persisted to the database as an array
+   * but initialized as a {@linkcode Set}.
+   */
+  interface Source extends fields.SchemaField.SourceData<Schema> {}
+
+  /**
+   * The data necessary to create a data model. Used in places like {@linkcode System.create}
+   * and {@link System | `new System(...)`}.
+   *
+   * For example a {@link fields.SetField | `SetField`} can accept any {@linkcode Iterable}
+   * with the right values. This means you can pass a `Set` instance, an array of values,
+   * a generator, or any other iterable.
+   */
+  interface CreateData extends fields.SchemaField.CreateData<Schema> {}
+
+  /**
+   * The data after a {@linkcode DataModel} has been initialized, for example
+   * {@link System.name | `System#name`}.
+   *
+   * This is data transformed from {@linkcode System.Source} and turned into more
+   * convenient runtime data structures. For example a {@link fields.SetField | `SetField`} is
+   * persisted to the database as an array of values but at runtime it is a `Set` instance.
+   */
+  interface InitializedData extends fields.SchemaField.InitializedData<Schema> {}
+
+  /**
+   * The data used to update a document, for example {@link System.update | `System#update`}.
+   * It is a distinct type from {@link System.CreateData | `DeepPartial<System.CreateData>`} because
+   * it has different rules for `null` and `undefined`.
+   */
+  interface UpdateData extends fields.SchemaField.UpdateData<Schema> {}
+
+  /**
+   * The schema for {@linkcode System}. This is the source of truth for how an System document
+   * must be structured.
+   *
+   * Foundry uses this schema to validate the structure of the {@linkcode System}. For example
+   * a {@link fields.StringField | `StringField`} will enforce that the value is a string. More
+   * complex fields like {@link fields.SetField | `SetField`} goes through various conversions
+   * starting as an array in the database, initialized as a set, and allows updates with any
+   * iterable.
+   */
+  interface Schema extends BasePackage.Schema {
+    /**
+     * The current package version
+     * @remarks Actually defined in BasePackage but defined here to avoid conflict with BaseWorld
+     */
+    version: fields.StringField<{ required: true; blank: false; initial: "0" }>;
+
+    /**
+     * Additional document subtypes provided by this system.
+     */
+    documentTypes: AdditionalTypesField;
+
+    /**
+     * A web URL or local file path which provides a default background banner for worlds which are created using this system
+     */
+    background: fields.StringField<{ required: false; blank: false }>;
+
+    /**
+     * A default initiative formula used for this system
+     */
+    initiative: fields.StringField;
+
+    /**
+     * The default grid settings to use for Scenes in this system
+     */
+    grid: fields.SchemaField<{
+      /** A default grid type to use for Scenes in this system */
+      type: fields.NumberField<{
+        required: true;
+        choices: typeof foundry.CONST.GRID_TYPES;
+        initial: typeof foundry.CONST.GRID_TYPES.SQUARE;
+      }>;
+
+      /** A default distance measurement to use for Scenes in this system */
+      distance: fields.NumberField<{
+        required: true;
+        nullable: false;
+        positive: true;
+        initial: 1;
+      }>;
+
+      /** A default unit of measure to use for distance measurement in this system */
+      units: fields.StringField<{
+        required: true;
+      }>;
+
+      /** The default rule used by this system for diagonal measurement on square grids */
+      diagonals: fields.NumberField<{
+        required: true;
+        choices: typeof foundry.CONST.GRID_DIAGONALS;
+        initial: typeof foundry.CONST.GRID_DIAGONALS.EQUIDISTANT;
+      }>;
+    }>;
+
+    /**
+     * An Actor data attribute path to use for Token primary resource bars
+     */
+    primaryTokenAttribute: fields.StringField;
+
+    /**
+     * An Actor data attribute path to use for Token secondary resource bars
+     */
+    secondaryTokenAttribute: fields.StringField;
+
+    /**
+     * A default distance measurement to use for Scenes in this system
+     * @deprecated since v12
+     */
+    gridDistance: fields.NumberField;
+
+    /**
+     * A default unit of measure to use for distance measurement in this system
+     * @deprecated since v12
+     */
+    gridUnits: fields.NumberField;
+  }
+}
 
 export default System;
diff --git a/src/foundry/client/packages/world.d.mts b/src/foundry/client/packages/world.d.mts
index e33d1ccf7..697c8720c 100644
--- a/src/foundry/client/packages/world.d.mts
+++ b/src/foundry/client/packages/world.d.mts
@@ -1,8 +1,155 @@
-/**
- * @remarks TODO: Stub
- */
-declare class World {}
+import type { CONST } from "#client/client.d.mts";
+import type BasePackage from "#common/packages/base-package.d.mts";
+import type ClientPackageMixin from "./client-package.d.mts";
+import type Module from "./module.d.mts";
+import type System from "./system.d.mts";
 
-declare namespace World {}
+import fields = foundry.data.fields;
+
+declare class World extends ClientPackageMixin(foundry.packages.BaseWorld) {
+  static override getVersionBadge(
+    availability: CONST.PACKAGE_AVAILABILITY_CODES,
+    data: Partial<PackageManifestData>,
+    options: World.GetVersionBadgeOptions,
+  ): ClientPackageMixin.PackageCompatibilityBadge | null;
+
+  /**
+   * Provide data for a system badge displayed for the world which reflects the system ID and its availability
+   * @param system - A specific system to use, otherwise use the installed system.
+   */
+  getSystemBadge(system?: System): ClientPackageMixin.PackageCompatibilityBadge | null;
+
+  static override _formatBadDependenciesTooltip(
+    availability: CONST.PACKAGE_AVAILABILITY_CODES,
+    data: Partial<PackageManifestData>,
+    options: World.FormatBadDependenciesTooltip,
+  ): string;
+}
+
+declare namespace World {
+  /**
+   * The data put in {@linkcode DataModel._source}. This data is what was
+   * persisted to the database and therefore it must be valid JSON.
+   *
+   * For example a {@link fields.SetField | `SetField`} is persisted to the database as an array
+   * but initialized as a {@linkcode Set}.
+   */
+  interface Source extends fields.SchemaField.SourceData<Schema> {}
+
+  /**
+   * The data necessary to create a data model. Used in places like {@linkcode World.create}
+   * and {@link World | `new World(...)`}.
+   *
+   * For example a {@link fields.SetField | `SetField`} can accept any {@linkcode Iterable}
+   * with the right values. This means you can pass a `Set` instance, an array of values,
+   * a generator, or any other iterable.
+   */
+  interface CreateData extends fields.SchemaField.CreateData<Schema> {}
+
+  /**
+   * The data after a {@linkcode DataModel} has been initialized, for example
+   * {@link World.name | `World#name`}.
+   *
+   * This is data transformed from {@linkcode World.Source} and turned into more
+   * convenient runtime data structures. For example a {@link fields.SetField | `SetField`} is
+   * persisted to the database as an array of values but at runtime it is a `Set` instance.
+   */
+  interface InitializedData extends fields.SchemaField.InitializedData<Schema> {}
+
+  /**
+   * The data used to update a document, for example {@link World.update | `World#update`}.
+   * It is a distinct type from {@link World.CreateData | `DeepPartial<World.CreateData>`} because
+   * it has different rules for `null` and `undefined`.
+   */
+  interface UpdateData extends fields.SchemaField.UpdateData<Schema> {}
+
+  /**
+   * The schema for {@linkcode World}. This is the source of truth for how an World document
+   * must be structured.
+   *
+   * Foundry uses this schema to validate the structure of the {@linkcode World}. For example
+   * a {@link fields.StringField | `StringField`} will enforce that the value is a string. More
+   * complex fields like {@link fields.SetField | `SetField`} goes through various conversions
+   * starting as an array in the database, initialized as a set, and allows updates with any
+   * iterable.
+   */
+  interface Schema extends BasePackage.Schema {
+    /**
+     * The game system name which this world relies upon
+     */
+    system: fields.StringField<{ required: true; blank: false }>;
+
+    /**
+     * A web URL or local file path which provides a background banner image
+     */
+    background: fields.StringField<{ required: false; blank: false }>;
+
+    /**
+     * The theme to use for this world's join page.
+     */
+    joinTheme: fields.StringField<{
+      required: false;
+      initial: undefined;
+      nullable: false;
+      blank: false;
+      choices: typeof foundry.CONST.WORLD_JOIN_THEMES;
+    }>;
+
+    /**
+     * The version of the core software for which this world has been migrated
+     */
+    coreVersion: fields.StringField<{ required: true; blank: false }>;
+
+    /**
+     * The version of the game system for which this world has been migrated
+     */
+    systemVersion: fields.StringField<{ required: true; blank: false; initial: "0" }>;
+
+    lastPlayed: fields.StringField;
+
+    playtime: fields.NumberField<{ integer: true; min: 0; initial: 0 }>;
+
+    /**
+     * An ISO datetime string when the next game session is scheduled to occur
+     */
+    nextSession: fields.StringField<{ blank: false; nullable: true; initial: null }>;
+
+    /**
+     * Should user access keys be reset as part of the next launch?
+     */
+    resetKeys: fields.BooleanField<{ required: false; initial: undefined }>;
+
+    /**
+     * Should the world launch in safe mode?
+     */
+    safeMode: fields.BooleanField<{ required: false; initial: undefined }>;
+
+    version: fields.StringField<{ required: true; blank: false; nullable: true; initial: null }>;
+  }
+
+  interface GetVersionBadgeOptions {
+    /**
+     * A specific collection of modules to test availability against. Tests against the currently installed modules by default.
+     */
+    modules?: Collection<Module> | undefined;
+
+    /**
+     * A specific collection of systems to test availability against. Tests against the currently installed systems by default.
+     */
+    systems?: Collection<System> | undefined;
+  }
+
+  interface FormatBadDependenciesTooltip {
+    /**
+     * A specific collection of modules to test availability against. Tests against the currently installed modules by default.
+     */
+    modules?: Collection<Module> | undefined;
+
+    /**
+     * A specific collection of systems to test availability against. Tests against the currently installed systems by default.
+     */
+    systems?: Collection<System> | undefined;
+  }
+}
 
 export default World;
diff --git a/src/foundry/client/pixi/layers/controls/ruler.d.mts b/src/foundry/client/pixi/layers/controls/ruler.d.mts
index 83611e8c1..37b194086 100644
--- a/src/foundry/client/pixi/layers/controls/ruler.d.mts
+++ b/src/foundry/client/pixi/layers/controls/ruler.d.mts
@@ -344,7 +344,7 @@ declare global {
      * Move the Token along the measured path when the move key is pressed.
      * @remarks `context` is unused in 12.331
      */
-    protected _onMoveKeyDown(context: KeyboardManager.KeyboardEventContext): void;
+    protected _onMoveKeyDown(context: foundry.helpers.interaction.KeyboardManager.KeyboardEventContext): void;
   }
 
   namespace Ruler {
diff --git a/src/foundry/client/pixi/workers/texture-worker.d.mts b/src/foundry/client/pixi/workers/texture-worker.d.mts
index 0b2ef6b88..edd84bcd5 100644
--- a/src/foundry/client/pixi/workers/texture-worker.d.mts
+++ b/src/foundry/client/pixi/workers/texture-worker.d.mts
@@ -12,7 +12,7 @@ declare global {
    * Wrapper for a web worker meant to convert a pixel buffer to the specified image format
    * and quality and return a base64 image
    */
-  class TextureCompressor extends AsyncWorker {
+  class TextureCompressor extends foundry.helpers.AsyncWorker {
     /**
      * @param name   - The worker name to be initialized
      *                 (default: `"Texture Compressor"`)
diff --git a/src/foundry/client/tours/canvas-tour.d.mts b/src/foundry/client/tours/canvas-tour.d.mts
deleted file mode 100644
index 17906d9ff..000000000
--- a/src/foundry/client/tours/canvas-tour.d.mts
+++ /dev/null
@@ -1,9 +0,0 @@
-import type { Tour } from "../core/tour.d.mts";
-
-declare global {
-  class CanvasTour extends Tour {
-    override start(): Promise<void>;
-    override get canStart(): boolean;
-    protected override _preStep(): Promise<void>;
-  }
-}
diff --git a/src/foundry/client/tours/index.d.mts b/src/foundry/client/tours/index.d.mts
deleted file mode 100644
index 3b20f849a..000000000
--- a/src/foundry/client/tours/index.d.mts
+++ /dev/null
@@ -1,3 +0,0 @@
-import "./canvas-tour.d.mts";
-import "./setup-tour.d.mts";
-import "./sidebar-tour.d.mts";
diff --git a/src/foundry/client/tours/setup-tour.d.mts b/src/foundry/client/tours/setup-tour.d.mts
deleted file mode 100644
index dc16576ac..000000000
--- a/src/foundry/client/tours/setup-tour.d.mts
+++ /dev/null
@@ -1,28 +0,0 @@
-import type { Tour } from "../core/tour.d.mts";
-
-declare global {
-  class SetupTour extends Tour {
-    constructor(
-      config: SetupTour.Config,
-      { id, namespace }?: { id?: SetupTour.Config["id"]; namespace?: SetupTour.Config["namespace"] },
-    );
-    config: SetupTour.Config;
-
-    focusedApp: foundry.appv1.api.Application.Any | foundry.applications.api.ApplicationV2.Any;
-    override get canStart(): boolean;
-    override get steps(): Tour.Step[];
-    protected override _preStep(): Promise<void>;
-    private _installingASystem(): Promise<void>;
-    private _creatingAWorld(): Promise<void>;
-  }
-
-  namespace SetupTour {
-    interface Config extends Tour.Config {
-      /**
-       * Whether to close all open windows before beginning the tour.
-       * @defaultValue `true`
-       */
-      closeWindows: boolean;
-    }
-  }
-}
diff --git a/src/foundry/client/tours/sidebar-tour.d.mts b/src/foundry/client/tours/sidebar-tour.d.mts
deleted file mode 100644
index 98247d25a..000000000
--- a/src/foundry/client/tours/sidebar-tour.d.mts
+++ /dev/null
@@ -1,9 +0,0 @@
-import type { Tour } from "../core/tour.d.mts";
-
-declare global {
-  class SidebarTour extends Tour {
-    override start(): Promise<void>;
-    protected override _preStep(): Promise<void>;
-    _updateSidebarTab(): Promise<void>;
-  }
-}
diff --git a/src/foundry/client/utils/_module.d.mts b/src/foundry/client/utils/_module.d.mts
index 1534bc890..70e3bfdbe 100644
--- a/src/foundry/client/utils/_module.d.mts
+++ b/src/foundry/client/utils/_module.d.mts
@@ -3,5 +3,21 @@
 // While `.mts` could work, to avoid `import-x/no-unresolved` from erroring `.mjs` is used.
 /* eslint-disable import-x/extensions */
 
+import type { SortOptions as OriginalSortOptions, performIntegerSort } from "./helpers.mjs";
+
 export * from "#common/utils/_module.mjs";
 export * from "./helpers.mjs";
+
+/**
+ * @deprecated since v13
+ * @remarks With the move to ESM, foundry no longer appears to need/want classes that only exist to host static functions in a namespace
+ */
+declare const SortingHelpers: {
+  performIntegerSort: typeof performIntegerSort;
+};
+
+declare namespace SortingHelpers {
+  interface SortOptions<T, SortKey extends string = "sort"> extends OriginalSortOptions<T, SortKey> {}
+}
+
+export { SortingHelpers };
diff --git a/src/foundry/client/utils/helpers.d.mts b/src/foundry/client/utils/helpers.d.mts
index c560cff46..f14eaa293 100644
--- a/src/foundry/client/utils/helpers.d.mts
+++ b/src/foundry/client/utils/helpers.d.mts
@@ -1,3 +1,6 @@
+import type { AnyObject, MustBeValidUuid, NullishProps } from "#utils";
+import type Document from "#common/abstract/document.d.mts";
+
 /**
  * Clean a provided HTML fragment, closing unbalanced tags and stripping some undesirable properties
  * @param raw - A raw HTML string
@@ -5,9 +8,199 @@
  */
 export function cleanHTML(raw: string): string;
 
+/**
+ * Export data content to be saved to a local file
+ * @param data     - Data content converted to a string
+ * @param type     - The type of
+ * @param filename - The filename of the resulting download
+ */
+export function saveDataToFile(data: string, type: string, filename: string): void;
+
+/**
+ * Read text data from a user provided File object
+ * @param file - A File object
+ * @returns A Promise which resolves to the loaded text data
+ */
+export function readTextFromFile(file: File): Promise<string>;
+
+export interface FromUuidOptions {
+  /** A Document to resolve relative UUIDs against. */
+  relative?: ClientDocument;
+
+  /** Allow retrieving an invalid Document. (default: `false`) */
+  invalid?: boolean;
+}
+
+/**
+ * Retrieve an Entity or Embedded Entity by its Universally Unique Identifier (uuid).
+ * @param uuid    - The uuid of the Entity or Embedded Entity to retrieve
+ * @param options - Options to configure how a UUID is resolved.
+ */
+export function fromUuid<ConcreteDocument extends Document.Any = __UnsetDocument, const Uuid extends string = string>(
+  uuid: FromUuidValidate<ConcreteDocument, Uuid> | null | undefined,
+  options?: FromUuidOptions,
+): Promise<(__UnsetDocument extends ConcreteDocument ? FromUuid<Uuid> : ConcreteDocument) | null>;
+
+export interface FromUuidSyncOptions {
+  /** A Document to resolve relative UUIDs against. */
+  relative?: ClientDocument;
+
+  /** Allow retrieving an invalid Document. (default: `false`) */
+  invalid?: boolean;
+
+  /** Throw an error if the UUID cannot be resolved synchronously. (default: `true`) */
+  strict?: boolean;
+}
+
+/**
+ * Retrieve a Document by its Universally Unique Identifier (uuid) synchronously. If the uuid resolves to a compendium
+ * document, that document's index entry will be returned instead.
+ * @param uuid    - The uuid of the Document to retrieve.
+ * @param options - Options to configure how a UUID is resolved.
+ * @returns The Document or its index entry if it resides in a Compendium, otherwise null.
+ * @throws If the uuid resolves to a Document that cannot be retrieved synchronously.
+ */
+export function fromUuidSync<
+  ConcreteDocument extends Document.Any = __UnsetDocument,
+  const Uuid extends string = string,
+>(
+  uuid: FromUuidValidate<ConcreteDocument, Uuid> | null | undefined,
+  options?: FromUuidSyncOptions,
+): (__UnsetDocument extends ConcreteDocument ? FromUuid<Uuid> : ConcreteDocument) | AnyObject | null;
+
+declare const __Unset: unique symbol;
+
+type __UnsetDocument = Document.Any & {
+  [__Unset]: true;
+};
+
+declare class InvalidUuid extends foundry.abstract.Document<any, any, any> {}
+
+type FromUuid<Uuid extends string> = Uuid extends `${string}.${string}.${infer Rest}`
+  ? FromUuid<Rest>
+  : Uuid extends `${infer DocumentType extends Document.Type}.${string}`
+    ? Document.ImplementationFor<DocumentType>
+    : InvalidUuid;
+
+// TODO(LukeAbby): The usage of `Document.Type` when it's unset will not be necessary once `Document.Any` is more type safe.
+type FromUuidValidate<
+  ConcreteDocument extends Document.Any,
+  Uuid extends string,
+> = __UnsetDocument extends ConcreteDocument
+  ? MustBeValidUuid<Uuid, Document.Type>
+  : string extends Uuid
+    ? string
+    : MustBeValidUuid<Uuid, ConcreteDocument["documentName"]>;
+
+/**
+ * Return a reference to the Document class implementation which is configured for use.
+ * @param documentName - The canonical Document name, for example "Actor"
+ * @returns configured Document class implementation
+ */
+export function getDocumentClass<Name extends Document.Type>(documentName: Name): Document.ImplementationClassFor<Name>;
+
+/**
+ * Return a reference to the PlaceableObject class implementation which is configured for use.
+ * @param documentName - The canonical Document name, for example "Actor"
+ * @returns The configured PlaceableObject class implementation
+ * @privateRemarks Consider if the generic should be broader; this returns undefined, rather than errors, if the Name isn't a placeable type
+ */
+export function getPlaceableObjectClass<Name extends Document.PlaceableType>(
+  documentName: Name,
+): Document.ObjectClassFor<Name>;
+
+export interface SortOptions<T, SortKey extends string = "sort"> {
+  /**
+   * The target object relative which to sort
+   * @defaultValue `null`
+   */
+  target?: T | null | undefined;
+
+  /**
+   * The sorted Array of siblings which share the same sorted container
+   * @defaultValue `[]`
+   */
+  siblings?: T[] | undefined;
+
+  /**
+   * The name of the data property within the source object which defines the sort key
+   * @defaultValue `"sort"`
+   */
+  sortKey?: SortKey | undefined;
+
+  /**
+   * Whether to explicitly sort before (true) or sort after (false). If nothing is passed
+   * the sort order will be automatically determined, preferring before.
+   *
+   * @defaultValue `true`
+   */
+  sortBefore?: boolean | undefined;
+}
+
+/**
+ * Given a source object to sort, a target to sort relative to, and an Array of siblings in the container:
+ * Determine the updated sort keys for the source object, or all siblings if a reindex is required.
+ * Return an Array of updates to perform, it is up to the caller to dispatch these updates.
+ * Each update is structured as:
+ * ```typescript
+ * {
+ *   target: object,
+ *   update: {sortKey: sortValue}
+ * }
+ * ```
+ *
+ * @param source  - source object being sorted
+ * @param options - Options which modify the sort behavior
+ * @template T   - the type of the source and target object
+ *
+ * @returns An Array of updates for the caller of the helper function to perform
+ */
+export function performIntegerSort<T, SortKey extends string = "sort">(
+  source: T,
+  options?: SortOptions<T, SortKey>,
+): Array<{
+  target: T;
+  update: {
+    [Key in SortKey]: number;
+  };
+}>;
+
+/**
+ * Express a timestamp as a relative string
+ * @param timeStamp - A timestamp string or Date object to be formatted as a relative time
+ * @returns A string expression for the relative time
+ */
+export function timeSince(timeStamp: Date | string): string;
+
 /**
  * Parse an HTML string, returning a processed HTMLElement or HTMLCollection.
  * A single HTMLElement is returned if the provided string contains only a single top-level element.
  * An HTMLCollection is returned if the provided string contains multiple top-level elements.
  */
 export function parseHTML(htmlString: string): HTMLCollection | HTMLElement;
+
+/**
+ * Return a URL with a cache-busting query parameter appended.
+ * @param src - The source URL being attempted
+ * @returns The new URL, or false on a failure.
+ */
+export function getCacheBustURL(src: string): string | false;
+
+/** @internal */
+type _FetchResourceOptions = NullishProps<{
+  /**
+   * Append a cache-busting query parameter to the request.
+   * @defaultValue `false`
+   */
+  bustCache: boolean;
+}>;
+
+interface FetchResourceOptions extends _FetchResourceOptions {}
+
+/**
+ * Use the Fetch API to retrieve a resource and return a Blob instance for it.
+ * @param src     - The resource URL
+ * @param options - Options to configure the loading behaviour.
+ * @returns A Blob containing the loaded data
+ */
+export function fetchResource(src: string, options?: FetchResourceOptions): Promise<Blob>;
diff --git a/src/foundry/common/_types.d.mts b/src/foundry/common/_types.d.mts
index d41dcd219..d644741ad 100644
--- a/src/foundry/common/_types.d.mts
+++ b/src/foundry/common/_types.d.mts
@@ -3,6 +3,10 @@
 import type { AnyConcreteConstructor, AnyConstructor, AnyFunction } from "#utils";
 import type { Document } from "./abstract/_module.d.mts";
 
+import ClientSettings = foundry.helpers.ClientSettings;
+import ClientKeybindings = foundry.helpers.interaction.ClientKeybindings;
+import SocketInterface = foundry.helpers.SocketInterface;
+
 export {};
 
 // After seeing that none of these types add anything or are even exported a
@@ -67,9 +71,9 @@ type KeybindingActionBinding = ClientKeybindings.KeybindingActionBinding;
 
 type KeybindingAction = ClientKeybindings.KeybindingAction;
 
-type KeyboardEventContext = KeyboardManager.KeyboardEventContext;
+type KeyboardEventContext = foundry.helpers.interaction.KeyboardManager.KeyboardEventContext;
 
-type ConnectedGamepad = GamepadManager.ConnectedGamepad;
+type ConnectedGamepad = foundry.helpers.interaction.GamepadManager.ConnectedGamepad;
 
 type RequestData = SocketInterface.RequestData;
 
diff --git a/src/foundry/common/abstract/type-data.d.mts b/src/foundry/common/abstract/type-data.d.mts
index 33a852514..68ef15476 100644
--- a/src/foundry/common/abstract/type-data.d.mts
+++ b/src/foundry/common/abstract/type-data.d.mts
@@ -234,7 +234,7 @@ declare abstract class TypeDataModel<
   [__BaseData]: RemoveIndexSignatures<BaseData>;
   [__DerivedData]: RemoveIndexSignatures<DerivedData>;
 
-  modelProvider: System | Module | null;
+  modelProvider: foundry.packages.System | foundry.packages.Module | null;
 
   /**
    * A set of localization prefix paths which are used by this data model.
diff --git a/src/foundry/common/data/fields.d.mts b/src/foundry/common/data/fields.d.mts
index d4c60ea35..7691af516 100644
--- a/src/foundry/common/data/fields.d.mts
+++ b/src/foundry/common/data/fields.d.mts
@@ -4771,7 +4771,7 @@ declare class TypeDataField<
    * Return the package that provides the sub-type for the given model.
    * @param model - The model instance created for this sub-type.
    */
-  static getModelProvider(model: DataModel.Any): System | Module | null;
+  static getModelProvider(model: DataModel.Any): foundry.packages.System | foundry.packages.Module | null;
 
   /**
    * A convenience accessor for the name of the document type associated with this TypeDataField
diff --git a/src/foundry/common/packages/base-package.d.mts b/src/foundry/common/packages/base-package.d.mts
index d5d7767a1..226c558be 100644
--- a/src/foundry/common/packages/base-package.d.mts
+++ b/src/foundry/common/packages/base-package.d.mts
@@ -604,7 +604,7 @@ declare class BasePackage<
    * @param modulesCollection - A collection which defines the set of available modules
    * @returns Are all required dependencies satisfied?
    */
-  _testRequiredDependencies(modulesCollection: Collection<Module>): Promise<boolean>;
+  _testRequiredDependencies(modulesCollection: Collection<foundry.packages.Module>): Promise<boolean>;
 
   /**
    * Test compatibility of a package's supported systems.
@@ -613,7 +613,7 @@ declare class BasePackage<
    *          are compatible or if the package has no supported systems.
    *          Returns false otherwise, or if no supported systems are installed.
    */
-  _testSupportedSystems(systemCollection: Collection<System>): Promise<boolean>;
+  _testSupportedSystems(systemCollection: Collection<foundry.packages.System>): Promise<boolean>;
 
   /**
    * Determine if a dependency is within the given compatibility range.
diff --git a/src/foundry/common/packages/base-world.d.mts b/src/foundry/common/packages/base-world.d.mts
index fa205357b..70dec2c16 100644
--- a/src/foundry/common/packages/base-world.d.mts
+++ b/src/foundry/common/packages/base-world.d.mts
@@ -49,14 +49,14 @@ declare class BaseWorld extends BasePackage<BaseWorld.Schema> {
        * against. Tests against the currently installed modules by
        * default.
        */
-      modules: Collection<Module>;
+      modules: Collection<foundry.packages.Module>;
 
       /**
        * A specific collection of modules to test availability
        * against. Tests against the currently installed modules by
        * default.
        */
-      systems: Collection<System>;
+      systems: Collection<foundry.packages.System>;
 
       /**
        * Ignore the world's own core software compatibility and
diff --git a/src/foundry/common/utils/helpers.d.mts b/src/foundry/common/utils/helpers.d.mts
index 707273c8c..43e34edb0 100644
--- a/src/foundry/common/utils/helpers.d.mts
+++ b/src/foundry/common/utils/helpers.d.mts
@@ -446,13 +446,6 @@ export function parseS3URL(key: string): { bucket: string | null; keyPrefix: str
  */
 export function randomID(length?: number): string;
 
-/**
- * Express a timestamp as a relative string
- * @param timeStamp - A timestamp string or Date object to be formatted as a relative time
- * @returns A string expression for the relative time
- */
-export function timeSince(timeStamp: Date | string): string;
-
 /**
  * Format a file size to an appropriate order of magnitude.
  * @param size    - The size in bytes.
diff --git a/src/types/config.d.mts b/src/types/config.d.mts
index afa1a5d3d..02bc2bfa0 100644
--- a/src/types/config.d.mts
+++ b/src/types/config.d.mts
@@ -31,7 +31,7 @@ type MustBeValid<T extends ValidDataModel> = T;
 type _TestValidDataModelConfig = MustConform<DataModelConfig, ValidDataModel>;
 
 interface ValidSettingConfig {
-  readonly [K: string]: ClientSettings.Type;
+  readonly [K: string]: foundry.helpers.ClientSettings.Type;
 }
 
 type _TestValidSettingConfig = MustConform<InterfaceToObject<SettingConfig>, ValidSettingConfig>;


Test patch:
diff --git a/tests/foundry/client/core/mouse.test-d.ts b/tests/foundry/client/core/mouse.test-d.ts
deleted file mode 100644
index 02de55165..000000000
--- a/tests/foundry/client/core/mouse.test-d.ts
+++ /dev/null
@@ -1,5 +0,0 @@
-import { expectTypeOf } from "vitest";
-
-// const mouseManager = new MouseManager();
-
-expectTypeOf(MouseManager.MOUSE_WHEEL_RATE_LIMIT).toEqualTypeOf<number>();
diff --git a/tests/foundry/client/core/packages.test-d.ts b/tests/foundry/client/core/packages.test-d.ts
deleted file mode 100644
index fd0e063d0..000000000
--- a/tests/foundry/client/core/packages.test-d.ts
+++ /dev/null
@@ -1,60 +0,0 @@
-import { expectTypeOf } from "vitest";
-
-declare const mod: Module;
-expectTypeOf(mod.favorite).toEqualTypeOf<false>();
-expectTypeOf(mod.getVersionBadge()).toEqualTypeOf<ClientPackage.PackageCompatibilityBadge | null>();
-expectTypeOf(mod.install()).toEqualTypeOf<void>();
-expectTypeOf(mod.uninstall()).toEqualTypeOf<void>();
-expectTypeOf(mod.active).toEqualTypeOf<boolean>();
-
-expectTypeOf(
-  Module.getVersionBadge(CONST.PACKAGE_AVAILABILITY_CODES.MISSING_DEPENDENCY, {}, {}),
-).toEqualTypeOf<ClientPackage.PackageCompatibilityBadge | null>();
-expectTypeOf(Module.uninstall("")).toEqualTypeOf<void>();
-
-let clientPackage = await Module.fromRemoteManifest("", { strict: true });
-if (clientPackage) {
-  expectTypeOf(clientPackage.favorite).toEqualTypeOf<false>();
-  expectTypeOf(clientPackage.getVersionBadge()).toEqualTypeOf<ClientPackage.PackageCompatibilityBadge | null>();
-  expectTypeOf(clientPackage.install()).toEqualTypeOf<void>();
-  expectTypeOf(clientPackage.uninstall()).toEqualTypeOf<void>();
-}
-
-declare const system: System;
-expectTypeOf(system.favorite).toEqualTypeOf<false>();
-expectTypeOf(system.getVersionBadge()).toEqualTypeOf<ClientPackage.PackageCompatibilityBadge | null>();
-expectTypeOf(system.install()).toEqualTypeOf<void>();
-expectTypeOf(system.uninstall()).toEqualTypeOf<void>();
-
-expectTypeOf(
-  System.getVersionBadge(CONST.PACKAGE_AVAILABILITY_CODES.MISSING_DEPENDENCY, {}, {}),
-).toEqualTypeOf<ClientPackage.PackageCompatibilityBadge | null>();
-expectTypeOf(System.uninstall("")).toEqualTypeOf<void>();
-
-clientPackage = await System.fromRemoteManifest("", { strict: true });
-if (clientPackage) {
-  expectTypeOf(clientPackage.favorite).toEqualTypeOf<false>();
-  expectTypeOf(clientPackage.getVersionBadge()).toEqualTypeOf<ClientPackage.PackageCompatibilityBadge | null>();
-  expectTypeOf(clientPackage.install()).toEqualTypeOf<void>();
-  expectTypeOf(clientPackage.uninstall()).toEqualTypeOf<void>();
-}
-
-declare const world: World;
-expectTypeOf(world.favorite).toEqualTypeOf<false>();
-expectTypeOf(world.getVersionBadge()).toEqualTypeOf<ClientPackage.PackageCompatibilityBadge | null>();
-expectTypeOf(world.install()).toEqualTypeOf<void>();
-expectTypeOf(world.uninstall()).toEqualTypeOf<void>();
-expectTypeOf(world.getSystemBadge()).toEqualTypeOf<ClientPackage.PackageCompatibilityBadge | null>();
-
-expectTypeOf(
-  World.getVersionBadge(CONST.PACKAGE_AVAILABILITY_CODES.MISSING_DEPENDENCY, {}, {}),
-).toEqualTypeOf<ClientPackage.PackageCompatibilityBadge | null>();
-expectTypeOf(World.uninstall("")).toEqualTypeOf<void>();
-
-clientPackage = await World.fromRemoteManifest("", { strict: true });
-if (clientPackage) {
-  expectTypeOf(clientPackage.favorite).toEqualTypeOf<false>();
-  expectTypeOf(clientPackage.getVersionBadge()).toEqualTypeOf<ClientPackage.PackageCompatibilityBadge | null>();
-  expectTypeOf(clientPackage.install()).toEqualTypeOf<void>();
-  expectTypeOf(clientPackage.uninstall()).toEqualTypeOf<void>();
-}
diff --git a/tests/foundry/client/core/sorting.test-d.ts b/tests/foundry/client/core/sorting.test-d.ts
deleted file mode 100644
index 01574b509..000000000
--- a/tests/foundry/client/core/sorting.test-d.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-import { expectTypeOf } from "vitest";
-
-interface SortingStructure {
-  target: number;
-  update: {
-    sortKey: number;
-  };
-}
-
-declare const input: SortingStructure;
-expectTypeOf(SortingHelpers.performIntegerSort(input, {})).toEqualTypeOf<
-  Array<{ target: SortingStructure; update: { sort: number } }>
->();
diff --git a/tests/foundry/client/core/issues.test-d.ts b/tests/foundry/client/helpers/client-issues.test-d.ts
similarity index 100%
rename from tests/foundry/client/core/issues.test-d.ts
rename to tests/foundry/client/helpers/client-issues.test-d.ts
diff --git a/tests/foundry/client/core/settings.test-d.ts b/tests/foundry/client/helpers/client-settings.test-d.ts
similarity index 100%
rename from tests/foundry/client/core/settings.test-d.ts
rename to tests/foundry/client/helpers/client-settings.test-d.ts
diff --git a/tests/foundry/client/core/document-index.test-d.ts b/tests/foundry/client/helpers/document-index.test-d.ts
similarity index 100%
rename from tests/foundry/client/core/document-index.test-d.ts
rename to tests/foundry/client/helpers/document-index.test-d.ts
diff --git a/tests/foundry/client/core/hooks.test-d.ts b/tests/foundry/client/helpers/hooks.test-d.ts
similarity index 95%
rename from tests/foundry/client/core/hooks.test-d.ts
rename to tests/foundry/client/helpers/hooks.test-d.ts
index b5be7f37a..3d88a8c82 100644
--- a/tests/foundry/client/core/hooks.test-d.ts
+++ b/tests/foundry/client/helpers/hooks.test-d.ts
@@ -1,6 +1,6 @@
 import { expectTypeOf } from "vitest";
 
-expectTypeOf(Hooks.events).toEqualTypeOf<Hooks.HookedFunction[]>();
+expectTypeOf(foundry.helpers.Hooks.events).toEqualTypeOf<Hooks.HookedFunction[]>();
 expectTypeOf(Hooks.on("", () => {})).toEqualTypeOf<number>();
 expectTypeOf(Hooks.once("", () => {})).toEqualTypeOf<number>();
 expectTypeOf(Hooks.off("", () => {})).toEqualTypeOf<void>();
diff --git a/tests/foundry/client/core/keybindings.test-d.ts b/tests/foundry/client/helpers/interaction/client-keybindings.test-d.ts
similarity index 100%
rename from tests/foundry/client/core/keybindings.test-d.ts
rename to tests/foundry/client/helpers/interaction/client-keybindings.test-d.ts
diff --git a/tests/foundry/client/core/clipboard.test-d.ts b/tests/foundry/client/helpers/interaction/clipboard-helper.test-d.ts
similarity index 100%
rename from tests/foundry/client/core/clipboard.test-d.ts
rename to tests/foundry/client/helpers/interaction/clipboard-helper.test-d.ts
diff --git a/tests/foundry/client/core/gamepad.test-d.ts b/tests/foundry/client/helpers/interaction/gamepad-manager.test-d.ts
similarity index 100%
rename from tests/foundry/client/core/gamepad.test-d.ts
rename to tests/foundry/client/helpers/interaction/gamepad-manager.test-d.ts
diff --git a/tests/foundry/client/core/keyboard.test-d.ts b/tests/foundry/client/helpers/interaction/keyboard-manager.test-d.ts
similarity index 100%
rename from tests/foundry/client/core/keyboard.test-d.ts
rename to tests/foundry/client/helpers/interaction/keyboard-manager.test-d.ts
diff --git a/tests/foundry/client/helpers/interaction/mouse-manager.test-d.ts b/tests/foundry/client/helpers/interaction/mouse-manager.test-d.ts
new file mode 100644
index 000000000..332d31bf8
--- /dev/null
+++ b/tests/foundry/client/helpers/interaction/mouse-manager.test-d.ts
@@ -0,0 +1,5 @@
+import { expectTypeOf } from "vitest";
+
+// const mouseManager = new MouseManager();
+
+expectTypeOf(foundry.helpers.interaction.MouseManager.MOUSE_WHEEL_RATE_LIMIT).toEqualTypeOf<number>();
diff --git a/tests/foundry/client/core/tooltip.test-d.ts b/tests/foundry/client/helpers/interaction/tooltip-manager.test-d.ts
similarity index 100%
rename from tests/foundry/client/core/tooltip.test-d.ts
rename to tests/foundry/client/helpers/interaction/tooltip-manager.test-d.ts
diff --git a/tests/foundry/client/core/image.test-d.ts b/tests/foundry/client/helpers/media/image-helper.test-d.ts
similarity index 100%
rename from tests/foundry/client/core/image.test-d.ts
rename to tests/foundry/client/helpers/media/image-helper.test-d.ts
diff --git a/tests/foundry/client/core/video.test-d.ts b/tests/foundry/client/helpers/media/video-helper.test-d.ts
similarity index 100%
rename from tests/foundry/client/core/video.test-d.ts
rename to tests/foundry/client/helpers/media/video-helper.test-d.ts
diff --git a/tests/foundry/client/core/socket.test-d.ts b/tests/foundry/client/helpers/socket-interface.test-d.ts
similarity index 100%
rename from tests/foundry/client/core/socket.test-d.ts
rename to tests/foundry/client/helpers/socket-interface.test-d.ts
diff --git a/tests/foundry/client/core/time.test-d.ts b/tests/foundry/client/helpers/time.test-d.ts
similarity index 100%
rename from tests/foundry/client/core/time.test-d.ts
rename to tests/foundry/client/helpers/time.test-d.ts
diff --git a/tests/foundry/client/core/workers.test-d.ts b/tests/foundry/client/helpers/workers.test-d.ts
similarity index 100%
rename from tests/foundry/client/core/workers.test-d.ts
rename to tests/foundry/client/helpers/workers.test-d.ts
diff --git a/tests/foundry/client/core/nue.test-d.ts b/tests/foundry/client/nue/nue-manager.test-d.ts
similarity index 53%
rename from tests/foundry/client/core/nue.test-d.ts
rename to tests/foundry/client/nue/nue-manager.test-d.ts
index 6307bd118..9df5485af 100644
--- a/tests/foundry/client/core/nue.test-d.ts
+++ b/tests/foundry/client/nue/nue-manager.test-d.ts
@@ -1,5 +1,6 @@
 import { expectTypeOf } from "vitest";
 
-const newUserExperience = new NewUserExperience();
+new NewUserExperience();
+const newUserExperience = new foundry.nue.NewUserExperienceManager();
 
 expectTypeOf(newUserExperience.initialize()).toEqualTypeOf<void>();
diff --git a/tests/foundry/client/core/tour.test-d.ts b/tests/foundry/client/nue/tour.test-d.ts
similarity index 100%
rename from tests/foundry/client/core/tour.test-d.ts
rename to tests/foundry/client/nue/tour.test-d.ts
diff --git a/tests/foundry/client/core/tours.test-d.ts b/tests/foundry/client/nue/tours-collection.test-d.ts
similarity index 75%
rename from tests/foundry/client/core/tours.test-d.ts
rename to tests/foundry/client/nue/tours-collection.test-d.ts
index c9169ab8b..bbccccb38 100644
--- a/tests/foundry/client/core/tours.test-d.ts
+++ b/tests/foundry/client/nue/tours-collection.test-d.ts
@@ -1,7 +1,8 @@
 import { expectTypeOf } from "vitest";
 
 declare const tour: Tour;
-const tours = new Tours();
+new Tours();
+const tours = new foundry.nue.ToursCollection();
 
 expectTypeOf(tours.register("", "", tour)).toEqualTypeOf<void>();
 expectTypeOf(tours.set("", tour)).toEqualTypeOf<Tours>();
diff --git a/tests/foundry/client/packages/module.test-d.ts b/tests/foundry/client/packages/module.test-d.ts
new file mode 100644
index 000000000..b5e489568
--- /dev/null
+++ b/tests/foundry/client/packages/module.test-d.ts
@@ -0,0 +1,21 @@
+import { expectTypeOf } from "vitest";
+
+declare const mod: Module;
+expectTypeOf(mod.favorite).toEqualTypeOf<false>();
+expectTypeOf(mod.getVersionBadge()).toEqualTypeOf<ClientPackage.PackageCompatibilityBadge | null>();
+expectTypeOf(mod.install()).toEqualTypeOf<void>();
+expectTypeOf(mod.uninstall()).toEqualTypeOf<void>();
+expectTypeOf(mod.active).toEqualTypeOf<boolean>();
+
+expectTypeOf(
+  Module.getVersionBadge(CONST.PACKAGE_AVAILABILITY_CODES.MISSING_DEPENDENCY, {}, {}),
+).toEqualTypeOf<ClientPackage.PackageCompatibilityBadge | null>();
+expectTypeOf(Module.uninstall("")).toEqualTypeOf<void>();
+
+const clientPackage = await Module.fromRemoteManifest("", { strict: true });
+if (clientPackage) {
+  expectTypeOf(clientPackage.favorite).toEqualTypeOf<false>();
+  expectTypeOf(clientPackage.getVersionBadge()).toEqualTypeOf<ClientPackage.PackageCompatibilityBadge | null>();
+  expectTypeOf(clientPackage.install()).toEqualTypeOf<void>();
+  expectTypeOf(clientPackage.uninstall()).toEqualTypeOf<void>();
+}
diff --git a/tests/foundry/client/packages/system.test-d.ts b/tests/foundry/client/packages/system.test-d.ts
new file mode 100644
index 000000000..6457e0530
--- /dev/null
+++ b/tests/foundry/client/packages/system.test-d.ts
@@ -0,0 +1,20 @@
+import { expectTypeOf } from "vitest";
+
+declare const system: System;
+expectTypeOf(system.favorite).toEqualTypeOf<false>();
+expectTypeOf(system.getVersionBadge()).toEqualTypeOf<ClientPackage.PackageCompatibilityBadge | null>();
+expectTypeOf(system.install()).toEqualTypeOf<void>();
+expectTypeOf(system.uninstall()).toEqualTypeOf<void>();
+
+expectTypeOf(
+  System.getVersionBadge(CONST.PACKAGE_AVAILABILITY_CODES.MISSING_DEPENDENCY, {}, {}),
+).toEqualTypeOf<ClientPackage.PackageCompatibilityBadge | null>();
+expectTypeOf(System.uninstall("")).toEqualTypeOf<void>();
+
+const clientPackage = await System.fromRemoteManifest("", { strict: true });
+if (clientPackage) {
+  expectTypeOf(clientPackage.favorite).toEqualTypeOf<false>();
+  expectTypeOf(clientPackage.getVersionBadge()).toEqualTypeOf<ClientPackage.PackageCompatibilityBadge | null>();
+  expectTypeOf(clientPackage.install()).toEqualTypeOf<void>();
+  expectTypeOf(clientPackage.uninstall()).toEqualTypeOf<void>();
+}
diff --git a/tests/foundry/client/packages/world.test-d.ts b/tests/foundry/client/packages/world.test-d.ts
new file mode 100644
index 000000000..7e5aae9b7
--- /dev/null
+++ b/tests/foundry/client/packages/world.test-d.ts
@@ -0,0 +1,21 @@
+import { expectTypeOf } from "vitest";
+
+declare const world: World;
+expectTypeOf(world.favorite).toEqualTypeOf<false>();
+expectTypeOf(world.getVersionBadge()).toEqualTypeOf<ClientPackage.PackageCompatibilityBadge | null>();
+expectTypeOf(world.install()).toEqualTypeOf<void>();
+expectTypeOf(world.uninstall()).toEqualTypeOf<void>();
+expectTypeOf(world.getSystemBadge()).toEqualTypeOf<ClientPackage.PackageCompatibilityBadge | null>();
+
+expectTypeOf(
+  World.getVersionBadge(CONST.PACKAGE_AVAILABILITY_CODES.MISSING_DEPENDENCY, {}, {}),
+).toEqualTypeOf<ClientPackage.PackageCompatibilityBadge | null>();
+expectTypeOf(World.uninstall("")).toEqualTypeOf<void>();
+
+const clientPackage = await World.fromRemoteManifest("", { strict: true });
+if (clientPackage) {
+  expectTypeOf(clientPackage.favorite).toEqualTypeOf<false>();
+  expectTypeOf(clientPackage.getVersionBadge()).toEqualTypeOf<ClientPackage.PackageCompatibilityBadge | null>();
+  expectTypeOf(clientPackage.install()).toEqualTypeOf<void>();
+  expectTypeOf(clientPackage.uninstall()).toEqualTypeOf<void>();
+}
diff --git a/tests/foundry/client/core/utils.test-d.ts b/tests/foundry/client/utils/helpers.test-d.ts
similarity index 86%
rename from tests/foundry/client/core/utils.test-d.ts
rename to tests/foundry/client/utils/helpers.test-d.ts
index 138becb77..6541c9f22 100644
--- a/tests/foundry/client/core/utils.test-d.ts
+++ b/tests/foundry/client/utils/helpers.test-d.ts
@@ -6,8 +6,6 @@ expectTypeOf(saveDataToFile("", "", "")).toEqualTypeOf<void>();
 declare const file: File;
 expectTypeOf(readTextFromFile(file)).toEqualTypeOf<Promise<string>>();
 
-declare const actor: Actor.Implementation;
-expectTypeOf(_resolveEmbedded(actor, [])).toEqualTypeOf<foundry.abstract.Document.Any>();
 expectTypeOf(getDocumentClass("Actor")).toEqualTypeOf<Actor.ImplementationClass>();
 expectTypeOf(getDocumentClass("Item")).toEqualTypeOf<Item.ImplementationClass>();
 
@@ -37,3 +35,15 @@ fromUuidSync("invalid");
 
 // @ts-expect-error - The error emitted here is subpar. Would benefit from throw types.
 fromUuidSync("Item.uuid1.Abc.uuid2");
+
+interface SortingStructure {
+  target: number;
+  update: {
+    sortKey: number;
+  };
+}
+
+declare const input: SortingStructure;
+expectTypeOf(SortingHelpers.performIntegerSort(input, {})).toEqualTypeOf<
+  Array<{ target: SortingStructure; update: { sort: number } }>
+>();