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

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

@@ -1,41 +1,34 @@
 import type { Socket } from "socket.io-client";
-import type { ConfiguredModule, GetKey, EmptyObject, ValueOf, FixedInstanceType } from "fvtt-types/utils";
-import type BasePackage from "../common/packages/base-package.d.mts";
-import type { Document } from "../common/abstract/_module.d.mts";
-
-interface EarlierEvents {
-  none: never;
-  init: "none";
-  i18nInit: "none" | "init";
-  setup: "none" | "init" | "i18nInit";
-  ready: "none" | "init" | "i18nInit" | "setup";
-}
-
-type InitializationEvent = keyof EarlierEvents;
+import type {
+  ConfiguredModule,
+  GetKey,
+  EmptyObject,
+  ValueOf,
+  FixedInstanceType,
+  InitializationHook,
+  InitializedOn,
+} from "#utils";
+import type BasePackage from "#common/packages/base-package.d.mts";
+import type { Document } from "#common/abstract/_module.d.mts";
+import type { Canvas } from "#client/canvas/_module.d.mts";
+
+import AVMaster = foundry.av.AVMaster;
 
 // Must be called with all hooks in a union.
 // Do not increase the complexity of this type. If you do Game related types may get complex enough to complain about not being statically known.
-type GameInitialized<Data, MustRun extends InitializationEvent, RunEvents extends InitializationEvent, D = undefined> =
-  Extract<RunEvents, MustRun> extends never ? D : Data;
-
-type HooksRan<T extends InitializationEvent> = EarlierEvents[T] | T;
-
-// May be called with just one hook.
-type MaybeInitialized<Data, MustRun extends InitializationEvent> = GameInitialized<
-  Data,
-  MustRun,
-  HooksRan<ValidHooksRan>,
-  Data | undefined
->;
-
-type ValidHooksRan = Extract<keyof AssumeHookRan, InitializationEvent>;
+type SimpleInitializedOn<
+  InitializedTo,
+  MustRun extends InitializationHook,
+  RunHooks extends InitializationHook,
+  BeforeInitialization = undefined,
+> = Extract<RunHooks, MustRun> extends never ? BeforeInitialization : InitializedTo;
 
 /**
  * @privateRemarks In v12 many of these properties were mistakenly stripped of their readonly quality;
  *                 This is preserved in the types despite them being technically writable.
  *                 See https://github.com/foundryvtt/foundryvtt/issues/11813
  */
-declare class InternalGame<RunEvents extends InitializationEvent> {
+declare class InternalGame<RunEvents extends InitializationHook> {
   /**
    * @param view      - The named view which is active for this game instance.
    * @param data      - An object of all the World data vended by the server when the client first connects
@@ -73,12 +66,12 @@ declare class InternalGame<RunEvents extends InitializationEvent> {
   /**
    * 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.
@@ -90,7 +83,7 @@ declare class InternalGame<RunEvents extends InitializationEvent> {
    * A mapping of CompendiumCollection instances, one per Compendium pack.
    * @remarks Initialized just before the `"setup"` hook event is called.
    */
-  readonly packs: GameInitialized<CompendiumPacks, "setup", RunEvents>;
+  readonly packs: SimpleInitializedOn<foundry.documents.collections.CompendiumPacks, "setup", RunEvents>;
 
   /**
    * A registry of document sub-types and their respective data models.
@@ -114,7 +107,7 @@ declare class InternalGame<RunEvents extends InitializationEvent> {
    * The global document index.
    * @remarks Initialized just before the `"setup"` hook event is called.
    */
-  readonly documentIndex: GameInitialized<DocumentIndex, "setup", RunEvents>;
+  readonly documentIndex: SimpleInitializedOn<foundry.helpers.DocumentIndex, "setup", RunEvents>;
 
   /**
    * The UUID redirects tree.
@@ -126,8 +119,9 @@ declare class InternalGame<RunEvents extends InitializationEvent> {
    * A mapping of WorldCollection instances, one per primary Document type.
    * @remarks Initialized just before the `"setup"` hook event is called.
    */
-  readonly collections: GameInitialized<
-    foundry.utils.Collection<WorldCollection<Document.AnyConstructor, string>>,
+  // TODO(LukeAbby): Ideally this would be actually vary based upon `CollectionDocument`.
+  readonly collections: SimpleInitializedOn<
+    foundry.utils.Collection<foundry.documents.abstract.WorldCollection<Game.CollectionDocument, string>>,
     "setup",
     RunEvents
   >;
@@ -136,73 +130,73 @@ declare class InternalGame<RunEvents extends InitializationEvent> {
    * The collection of Actor documents which exists in the World.
    * @remarks Initialized just before the `"setup"` hook event.
    */
-  readonly actors: GameInitialized<ConfiguredCollectionClassForName<"Actor">, "setup", RunEvents>;
+  readonly actors: SimpleInitializedOn<ConfiguredCollectionClassForName<"Actor">, "setup", RunEvents>;
 
   /**
    * The collection of Cards documents which exists in the World.
    * @remarks Initialized just before the `"setup"` hook event.
    */
-  readonly cards: GameInitialized<ConfiguredCollectionClassForName<"Cards">, "setup", RunEvents>;
+  readonly cards: SimpleInitializedOn<ConfiguredCollectionClassForName<"Cards">, "setup", RunEvents>;
 
   /**
    * The collection of Combat documents which exists in the World.
    * @remarks Initialized just before the `"setup"` hook event.
    */
-  readonly combats: GameInitialized<ConfiguredCollectionClassForName<"Combat">, "setup", RunEvents>;
+  readonly combats: SimpleInitializedOn<ConfiguredCollectionClassForName<"Combat">, "setup", RunEvents>;
 
   /**
    * The collection of Folder documents which exists in the World.
    * @remarks Initialized just before the `"setup"` hook event.
    */
-  readonly folders: GameInitialized<ConfiguredCollectionClassForName<"Folder">, "setup", RunEvents>;
+  readonly folders: SimpleInitializedOn<ConfiguredCollectionClassForName<"Folder">, "setup", RunEvents>;
 
   /**
    * The collection of Item documents which exists in the World.
    * @remarks Initialized just before the `"setup"` hook event.
    */
-  readonly items: GameInitialized<ConfiguredCollectionClassForName<"Item">, "setup", RunEvents>;
+  readonly items: SimpleInitializedOn<ConfiguredCollectionClassForName<"Item">, "setup", RunEvents>;
 
   /**
    * The collection of JournalEntry documents which exists in the World.
    * @remarks Initialized just before the `"setup"` hook event.
    */
-  readonly journal: GameInitialized<ConfiguredCollectionClassForName<"JournalEntry">, "setup", RunEvents>;
+  readonly journal: SimpleInitializedOn<ConfiguredCollectionClassForName<"JournalEntry">, "setup", RunEvents>;
 
   /**
    * The collection of Macro documents which exists in the World.
    * @remarks Initialized just before the `"setup"` hook event.
    */
-  readonly macros: GameInitialized<ConfiguredCollectionClassForName<"Macro">, "setup", RunEvents>;
+  readonly macros: SimpleInitializedOn<ConfiguredCollectionClassForName<"Macro">, "setup", RunEvents>;
 
   /**
    * The collection of ChatMessage documents which exists in the World.
    * @remarks Initialized just before the `"setup"` hook event.
    */
-  readonly messages: GameInitialized<ConfiguredCollectionClassForName<"ChatMessage">, "setup", RunEvents>;
+  readonly messages: SimpleInitializedOn<ConfiguredCollectionClassForName<"ChatMessage">, "setup", RunEvents>;
 
   /**
    * The collection of Playlist documents which exists in the World.
    * @remarks Initialized just before the `"setup"` hook event.
    */
-  readonly playlists: GameInitialized<ConfiguredCollectionClassForName<"Playlist">, "setup", RunEvents>;
+  readonly playlists: SimpleInitializedOn<ConfiguredCollectionClassForName<"Playlist">, "setup", RunEvents>;
 
   /**
    * The collection of Scene documents which exists in the World.
    * @remarks Initialized just before the `"setup"` hook event.
    */
-  readonly scenes: GameInitialized<ConfiguredCollectionClassForName<"Scene">, "setup", RunEvents>;
+  readonly scenes: SimpleInitializedOn<ConfiguredCollectionClassForName<"Scene">, "setup", RunEvents>;
 
   /**
    * The collection of RollTable documents which exists in the World.
    * @remarks Initialized just before the `"setup"` hook event.
    */
-  readonly tables: GameInitialized<ConfiguredCollectionClassForName<"RollTable">, "setup", RunEvents>;
+  readonly tables: SimpleInitializedOn<ConfiguredCollectionClassForName<"RollTable">, "setup", RunEvents>;
 
   /**
    * The collection of User documents which exists in the World.
    * @remarks Initialized just before the `"setup"` hook event.
    */
-  readonly users: GameInitialized<ConfiguredCollectionClassForName<"User">, "setup", RunEvents>;
+  readonly users: SimpleInitializedOn<ConfiguredCollectionClassForName<"User">, "setup", RunEvents>;
 
   /**
    * The Release data for this version of Foundry
@@ -230,19 +224,19 @@ declare class InternalGame<RunEvents extends InitializationEvent> {
    * The user role permissions setting
    * @remarks Initialized just before the `"setup"` hook event.
    */
-  readonly permissions: GameInitialized<Game.Permissions, "setup", RunEvents>;
+  readonly permissions: SimpleInitializedOn<Game.Permissions, "setup", RunEvents>;
 
   /**
    * A flag for whether the Game has successfully reached the "ready" hook
    * @defaultValue `false`
    */
-  readonly ready: GameInitialized<true, "ready", RunEvents, false>;
+  readonly ready: SimpleInitializedOn<true, "ready", RunEvents, false>;
 
   /**
    * The singleton compendium art manager.
    * @remarks Initialized just before the `"setup"` hook event.
    */
-  readonly compendiumArt: foundry.helpers.CompendiumArt;
+  readonly compendiumArt: foundry.helpers.media.CompendiumArt;
 
   /**
    * A singleton instance of the Audio Helper class
@@ -253,87 +247,87 @@ declare class InternalGame<RunEvents extends InitializationEvent> {
    * A singleton reference to the Canvas object which may be used.
    * @remarks Initialized just before the `"ready"` hook event.
    */
-  readonly canvas: GameInitialized<Canvas, "ready", RunEvents>;
+  readonly canvas: SimpleInitializedOn<Canvas, "ready", RunEvents>;
 
   /**
    * The singleton Clipboard Helper.
    */
-  readonly clipboard: ClipboardHelper;
+  readonly clipboard: foundry.helpers.interaction.ClipboardHelper;
 
   /**
    * Localization support
    * @remarks Initialized just before the `"i18nInit"` hook event.
    */
-  readonly i18n: GameInitialized<Localization, "i18nInit", RunEvents>;
+  readonly i18n: SimpleInitializedOn<foundry.helpers.Localization, "i18nInit", RunEvents>;
 
   /**
    * 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: GameInitialized<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: GameInitialized<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: GameInitialized<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: GameInitialized<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: GameInitialized<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: GameInitialized<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: GameInitialized<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
@@ -426,7 +420,7 @@ declare class InternalGame<RunEvents extends InitializationEvent> {
   /**
    * @remarks Initialized just before the `"ready"` hook event.
    */
-  webrtc: GameInitialized<AVMaster, "ready", RunEvents>;
+  webrtc: SimpleInitializedOn<AVMaster, "ready", RunEvents>;
 
   /**
    * Initialize core UI elements
@@ -473,12 +467,12 @@ declare class InternalGame<RunEvents extends InitializationEvent> {
    *
    * @remarks Initialized just before the `"setup"` hook event.
    */
-  get user(): GameInitialized<Document.Stored<User.ConfiguredInstance>, "setup", RunEvents, null>;
+  get user(): SimpleInitializedOn<User.Stored, "setup", RunEvents, null>;
 
   /**
    * A convenience accessor for the currently viewed Combat encounter
    */
-  get combat(): CombatEncounters["viewed"];
+  get combat(): foundry.documents.collections.CombatEncounters["viewed"];
 
   /**
    * A state variable which tracks whether the game session is currently paused
@@ -491,20 +485,24 @@ declare class InternalGame<RunEvents extends InitializationEvent> {
   get activeTool(): string;
 
   /**
-   * Toggle the pause state of the game
-   * Trigger the `pauseGame` Hook when the paused state changes
-   * @param pause - The desired pause state; true for paused, false for un-paused
-   * @param push  - Push the pause state change to other connected clients? Requires an GM user.
-   *                (default: `false`)
+   * Toggle the pause state of the game, triggering the {@link hookEvents.pauseGame} hook when the paused
+   * state changes.
+   * @param pause   - The desired pause state; true for paused, false for un-paused
+   * @param options - Additional options which modify the pause operation
    * @returns The new paused state
    */
+  togglePause(pause: boolean, options?: Game.TogglePauseOptions): void;
+
+  /**
+   * @deprecated "You are passing the legacy `push` boolean to `Game#togglePause`. This is replaced by the `broadcast` option, for example `game.togglePause(true, {broadcast: true})`" (since v13 until v15)
+   */
   togglePause(pause: boolean, push?: boolean): void;
 
   /**
    * Open Character sheet for current token or controlled actor
    * @returns The ActorSheet which was toggled, or null if the User has no character
    */
-  toggleCharacterSheet(): ActorSheet | null;
+  toggleCharacterSheet(): foundry.appv1.sheets.ActorSheet.Any | foundry.applications.sheets.ActorSheetV2.Any | null;
 
   /**
    * Log out of the game session by returning to the Join screen
@@ -612,13 +610,13 @@ type _I18nInitGame = Game & InternalGame<"init" | "i18nInit">;
 type _SetupGame = Game & InternalGame<"init" | "i18nInit" | "setup">;
 type _ReadyGame = Game & InternalGame<"init" | "i18nInit" | "setup" | "ready">;
 
-declare global {
-  /**
-   * The core Game instance which encapsulates the data, settings, and states relevant for managing the game experience.
-   * The singleton instance of the Game class is available as the global variable game.
-   */
-  class Game extends InternalGame<any> {}
+/**
+ * The core Game instance which encapsulates the data, settings, and states relevant for managing the game experience.
+ * The singleton instance of the Game class is available as the global variable game.
+ */
+declare class Game extends InternalGame<any> {}
 
+declare global {
   // These helper types show `Game` at different points in its life cycle.
   // They're merged with `Game` to preserve the invariant `XYZGame instanceof Game`.
   // They're interfaces for easier user declaration merges as well as to give intellisense better names to use as the expanded type is intimidating.
@@ -627,157 +625,184 @@ declare global {
   interface I18nInitGame extends _I18nInitGame {}
   interface SetupGame extends _SetupGame {}
   interface ReadyGame extends _ReadyGame {}
+}
 
-  interface HotReloadData {
-    /** The type of package which was modified */
-    packageType: string;
+declare namespace Game {
+  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): foundry.packages.Module & ConfiguredModule<T>;
+  }
 
-    /** The id of the package which was modified */
-    packageId: string;
+  namespace Model {
+    /**
+     * Get the configured core and system type names for a specific document type.
+     *
+     * Because of module subtypes, extra types of the form `${moduleName}.${subtype}` are
+     * possible when `hasTypeData` is true.
+     *
+     * @template DocumentName - the type of the Document this data is for
+     */
+    type TypeNames<DocumentType extends Document.Type> = Document.SubTypesOf<DocumentType>;
+  }
 
-    /** The updated stringified file content */
-    content: string;
+  /** @internal */
+  type _Model = {
+    [DocumentType in Document.Type]: {
+      // The `& string` is helpful even though there should never be any numeric/symbol keys.
+      // This is because when `keyof Config<...>` is deferred then TypeScript does a bunch of proofs under the assumption that `SystemTypeNames` could be a `string | number` until proven otherwise.
+      // This causes issues where there shouldn't be, for example it has been observed to obstruct the resolution of the `Actor` class.
+      [SubType in Model.TypeNames<DocumentType>]: GetKey<GetKey<SourceConfig, DocumentType>, SubType, EmptyObject>;
+    };
+  };
+  interface Model extends _Model {}
 
-    /** The relative file path which was modified */
-    path: string;
+  interface PackageWarning {
+    /** @remarks The ID of the package, matches this objects key in {@linkcode Game.Data.packageWarnings} */
+    id: string;
 
-    /** The file extension which was modified, e.g. "js", "css", "html" */
-    extension: string;
+    /** @remarks From limited empirical sampling, only `false` if the package lacks a manifest */
+    reinstallable: boolean;
+
+    /**
+     * @remarks Not included if the package itself lacks a manifest (e.g JB2A patreon pack).
+     * Never seen explicitly `undefined`, only omitted, during testing.
+     */
+    manifest?: string | undefined;
+
+    /** @remarks Presumably `"world" | "system" | "module"`, but difficult to confirm. */
+    type: string;
+
+    /**
+     * Error messages.
+     */
+    error: string[];
+
+    /**
+     * Warning messages.
+     */
+    warning: string[];
   }
 
-  namespace Game {
-    interface ModuleCollection extends Collection<Module> {
-      /**
-       * Gets the module requested for by ID
-       * @see {@link ModuleConfig} to add custom properties to modules like APIs.
-       * @see {@link RequiredModules} to remove `undefined` from the return type for a given module
-       * @param id - The module ID to look up
-       */
-      get<T extends string>(id: T): Module & ConfiguredModule<T>;
-    }
-
-    namespace Model {
-      /**
-       * Get the configured core and system type names for a specific document type.
-       *
-       * Because of module subtypes, extra types of the form `${moduleName}.${subtype}` are
-       * possible when `hasTypeData` is true.
-       *
-       * @typeParam DocumentName - the type of the Document this data is for
-       */
-      type TypeNames<DocumentName extends Document.Type> =
-        | (string & keyof Model[DocumentName])
-        | (Document.Internal.SimpleMetadata<DocumentName> extends { readonly hasTypeData: true }
-            ? `${string}.${string}` & {}
-            : never);
-    }
-
-    type Model = {
-      [DocumentType in Document.Type]: {
-        // The `& string` is helpful even though there should never be any numeric/symbol keys.
-        // This is because when `keyof Config<...>` is deferred then TypeScript does a bunch of proofs under the assumption that `SystemTypeNames` could be a `string | number` until proven otherwise.
-        // This causes issues where there shouldn't be, for example it has been observed to obstruct the resolution of the `Actor` class.
-        [SubType in
-          | Document.CoreTypesForName<DocumentType>
-          | keyof GetKey<DataModelConfig, DocumentType, unknown>
-          | keyof GetKey<SourceConfig, DocumentType, unknown> as SubType & string]: GetKey<
-          GetKey<SourceConfig, DocumentType>,
-          SubType,
-          EmptyObject
-        >;
-      };
+  type Data = {
+    activeUsers: string[];
+    addresses: {
+      local: string;
+      remote?: string | undefined;
+      remoteIsAccessible: boolean | null;
     };
-
-    type Data = {
-      activeUsers: string[];
-      addresses: {
-        local: string;
-        remote?: string | undefined;
-        remoteIsAccessible: boolean | null;
-      };
-      coreUpdate: {
-        channel: string | null;
-        couldReachWebsite: boolean;
-        hasUpdate: boolean;
-        slowResponse: boolean;
-        version: string | null;
-        willDisableModules: boolean;
-      };
-      demoMode: boolean;
-      files: {
-        s3?: {
-          endpoint: {
-            protocol: string;
-            host: string;
-            port: number;
-            hostname: string;
-            pathname: string;
-            path: string;
-            href: string;
-          };
-          buckets: string[];
-        } | null;
-        storages: ("public" | "data" | "s3")[];
-      };
-      modules: Module["_source"][];
-      options: {
-        language: string;
-        port: number;
-        routePrefix: string | null;
-        updateChannel: string;
-      };
-      packageWarnings: Record<string, unknown>;
-      packs: Array<
-        PackageCompendiumData & {
-          /** @deprecated since v11 */
-          private?: boolean;
-          system?: string | undefined;
-          type: foundry.CONST.COMPENDIUM_DOCUMENT_TYPES;
-          packageName: BasePackage["_source"]["id"];
-          packageType: BasePackage["type"];
-          id: string;
-        }
-      >;
-      paused: boolean;
-      release: foundry.config.ReleaseData["_source"];
-      system: System["_source"];
-      systemUpdate: {
-        hasUpdate: boolean;
-        version: string;
-      };
-      // TODO: I think this is only for configurable types
-      template: Record<Document.Type, DocumentTemplate> | null;
-      // TODO: This is also inheriting the configured types,
-      // but is only filled in if there's `template.json`
-      model: Model;
-      userId: string;
-      world: World["_source"];
-    } & {
-      [DocumentType in  // eslint-disable-next-line @typescript-eslint/no-deprecated
-        | foundry.CONST.DOCUMENT_TYPES
-        | "Setting" as Document.ConfiguredClassForName<DocumentType>["metadata"]["collection"]]?: FixedInstanceType<
-        Document.ConfiguredClassForName<DocumentType>
-      >["_source"][];
+    coreUpdate: {
+      channel: string | null;
+      couldReachWebsite: boolean;
+      hasUpdate: boolean;
+      slowResponse: boolean;
+      version: string | null;
+      willDisableModules: boolean;
     };
-
-    type Permissions = {
-      [Key in keyof typeof foundry.CONST.USER_PERMISSIONS]: foundry.CONST.USER_ROLES[];
+    demoMode: boolean;
+    files: {
+      s3?: {
+        endpoint: {
+          protocol: string;
+          host: string;
+          port: number;
+          hostname: string;
+          pathname: string;
+          path: string;
+          href: string;
+        };
+        buckets: string[];
+      } | null;
+      storages: ("public" | "data" | "s3")[];
+    };
+    modules: foundry.packages.Module["_source"][];
+    options: {
+      language: string;
+      port: number;
+      routePrefix: string | null;
+      updateChannel: string;
+    };
+    packageWarnings: Record<string, PackageWarning>;
+    packs: Array<
+      PackageCompendiumData & {
+        /** @deprecated since v11 */
+        private?: boolean;
+        system?: string | undefined;
+        type: foundry.CONST.COMPENDIUM_DOCUMENT_TYPES;
+        packageName: BasePackage["_source"]["id"];
+        packageType: BasePackage["type"];
+        id: string;
+      }
+    >;
+    paused: boolean;
+    release: foundry.config.ReleaseData["_source"];
+    system: foundry.packages.System["_source"];
+    systemUpdate: {
+      hasUpdate: boolean;
+      version: string;
     };
+    // TODO: I think this is only for configurable types
+    template: Record<Document.Type, DocumentTemplate> | null;
+    // TODO: This is also inheriting the configured types,
+    // but is only filled in if there's `template.json`
+    model: Model;
+    userId: string;
+    world: foundry.packages.World["_source"];
+  } & {
+    [DocumentType in  // eslint-disable-next-line @typescript-eslint/no-deprecated
+      | foundry.CONST.DOCUMENT_TYPES
+      | "Setting" as Document.ImplementationClassFor<DocumentType>["metadata"]["collection"]]?: FixedInstanceType<
+      Document.ImplementationClassFor<DocumentType>
+    >["_source"][];
+  };
 
-    type View = ValueOf<typeof foundry.CONST.GAME_VIEWS>;
+  type Permissions = {
+    [Key in keyof typeof foundry.CONST.USER_PERMISSIONS]: foundry.CONST.USER_ROLES[];
+  };
+
+  type View = ValueOf<typeof foundry.CONST.GAME_VIEWS>;
+
+  interface TogglePauseOptions {
+    /**
+     * Broadcast the pause state change to other connected clients?
+     * Broadcasting to other clients can only be done by a GM user.
+     * @defaultValue `false`
+     */
+    broadcast?: boolean | undefined;
+
+    /**
+     * The ID of the user who triggered the pause operation. This is
+     * populated automatically by the game server.
+     */
+    userId?: string | undefined;
   }
 
-  /**
-   * @defaultValue `undefined`
-   * Initialized just before the `"init"` hook event.
-   */
-  let canvas: MaybeInitialized<Canvas, "init">;
+  // Note(LukeAbby): See `Game#initializeDocuments`'s `initOrder`.
+  type CollectionDocument =
+    | "User"
+    | "Folder"
+    | "Actor"
+    | "Item"
+    | "Scene"
+    | "Combat"
+    | "JournalEntry"
+    | "Macro"
+    | "Playlist"
+    | "RollTable"
+    | "Cards"
+    | "ChatMessage";
+}
 
+declare global {
   /**
    * @defaultValue `undefined`
-   * Initialized just before the `"ready"` hook event.
+   * Initialized just before the `"init"` hook event.
    */
-  let keyboard: MaybeInitialized<KeyboardManager, "ready">;
+  let canvas: InitializedOn<Canvas, "init">;
 }
 
 type ConfiguredCollectionClassForName<Name extends foundry.CONST.WORLD_DOCUMENT_TYPES> = FixedInstanceType<
@@ -788,3 +813,5 @@ interface DocumentTemplate {
   htmlFields: string[];
   types: string[];
 }
+
+export default Game;