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

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

@@ -7,9 +7,12 @@ import type {
   FixedInstanceType,
   InitializationHook,
   InitializedOn,
-} from "fvtt-types/utils";
+} 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.
@@ -63,12 +66,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.
@@ -80,7 +83,7 @@ declare class InternalGame<RunEvents extends InitializationHook> {
    * A mapping of CompendiumCollection instances, one per Compendium pack.
    * @remarks Initialized just before the `"setup"` hook event is called.
    */
-  readonly packs: SimpleInitializedOn<CompendiumPacks, "setup", RunEvents>;
+  readonly packs: SimpleInitializedOn<foundry.documents.collections.CompendiumPacks, "setup", RunEvents>;
 
   /**
    * A registry of document sub-types and their respective data models.
@@ -104,7 +107,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.
@@ -116,8 +119,9 @@ declare class InternalGame<RunEvents extends InitializationHook> {
    * A mapping of WorldCollection instances, one per primary Document type.
    * @remarks Initialized just before the `"setup"` hook event is called.
    */
+  // TODO(LukeAbby): Ideally this would be actually vary based upon `CollectionDocument`.
   readonly collections: SimpleInitializedOn<
-    foundry.utils.Collection<WorldCollection<Document.AnyConstructor, string>>,
+    foundry.utils.Collection<foundry.documents.abstract.WorldCollection<Game.CollectionDocument, string>>,
     "setup",
     RunEvents
   >;
@@ -232,7 +236,7 @@ declare class InternalGame<RunEvents extends InitializationHook> {
    * 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
@@ -248,82 +252,82 @@ declare class InternalGame<RunEvents extends InitializationHook> {
   /**
    * 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: SimpleInitializedOn<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: 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
@@ -468,7 +472,7 @@ declare class InternalGame<RunEvents extends InitializationHook> {
   /**
    * 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
@@ -481,20 +485,24 @@ declare class InternalGame<RunEvents extends InitializationHook> {
   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
@@ -602,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.
@@ -617,133 +625,184 @@ declare global {
   interface I18nInitGame extends _I18nInitGame {}
   interface SetupGame extends _SetupGame {}
   interface ReadyGame extends _ReadyGame {}
+}
 
-  /** @deprecated {@link Hooks.HotReloadData | `HotReloadData`} */
-  type HotReloadData = Hooks.HotReloadData;
-
-  namespace Game {
-    interface ModuleCollection extends Collection<Module> {
-      /**
-       * Gets the module requested for by ID
-       * @see {@link ModuleConfig | `ModuleConfig`} to add custom properties to modules like APIs.
-       * @see {@link RequiredModules | `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<DocumentType extends Document.Type> = Document.SubTypesOf<DocumentType>;
-    }
-
-    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 {}
-
-    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.ImplementationClassFor<DocumentType>["metadata"]["collection"]]?: FixedInstanceType<
-        Document.ImplementationClassFor<DocumentType>
-      >["_source"][];
+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>;
+  }
+
+  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>;
+  }
+
+  /** @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 {}
+
+  interface PackageWarning {
+    /** @remarks The ID of the package, matches this objects key in {@linkcode Game.Data.packageWarnings} */
+    id: 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;
 
-    type Permissions = {
-      [Key in keyof typeof foundry.CONST.USER_PERMISSIONS]: foundry.CONST.USER_ROLES[];
+    /** @remarks Presumably `"world" | "system" | "module"`, but difficult to confirm. */
+    type: string;
+
+    /**
+     * Error messages.
+     */
+    error: string[];
+
+    /**
+     * Warning messages.
+     */
+    warning: string[];
+  }
+
+  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: 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;
   }
 
+  // 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 `"init"` hook event.
    */
   let canvas: InitializedOn<Canvas, "init">;
-
-  /**
-   * @defaultValue `undefined`
-   * Initialized just before the `"ready"` hook event.
-   */
-  let keyboard: InitializedOn<KeyboardManager, "ready">;
 }
 
 type ConfiguredCollectionClassForName<Name extends foundry.CONST.WORLD_DOCUMENT_TYPES> = FixedInstanceType<
@@ -754,3 +813,5 @@ interface DocumentTemplate {
   htmlFields: string[];
   types: string[];
 }
+
+export default Game;

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

@@ -1,8 +1,8 @@
-import type { EarlierHook, FixedInstanceType, InitializationHook } from "fvtt-types/utils";
+import type { EarlierHook, FixedInstanceType, InitializationHook } from "#utils";
 
 type ValidRanHooks = Extract<keyof AssumeHookRan, InitializationHook>;
 
-type _UninitializedGame = { [K in keyof Game]?: never };
+type _UninitializedGame = { [K in keyof foundry.Game]?: never };
 
 interface UninitializedGame extends _UninitializedGame {}
 
@@ -55,13 +55,7 @@ declare global {
       }[]
     | null;
 
-  /**
-   * A collection of application instances
-   * @remarks
-   * - All of the elements of {@link ui | `ui`} except for `context` and `window` are initialized between the `"setup"` and `"ready"` hook events.
-   * - In the `/stream` view, only `chat` is initialized but none of the other {@link Application | `Application`}s.
-   */
-  let ui: {
+  interface UI {
     /**
      * @remarks
      * Initialized whenever a {@link foundry.applications.ux.ContextMenu | `ContextMenu`} is opened, deleted when it's closed again.
@@ -71,8 +65,16 @@ declare global {
     /**
      * @defaultValue `{}`
      */
-    windows: Record<number, Application.Any>;
-  } & MaybeUI;
+    windows: Record<number, foundry.appv1.api.Application.Any>;
+  }
+
+  /**
+   * A collection of application instances
+   * @remarks
+   * - All of the elements of {@linkcode ui} except for `context` and `window` are initialized between the `"setup"` and `"ready"` hook events.
+   * - In the `/stream` view, only `chat` is initialized but none of the other {@linkcode Application}s.
+   */
+  let ui: UI & MaybeUI;
 
   /**
    * The client side console logger

package/src/foundry/client/helpers/_module.d.mts

@@ -0,0 +1,16 @@
+// In Foundry itself this file contains re-exports of these other modules.
+// Therefore it has a runtime effect and uses `.mjs` instead of `.d.mts`.
+// While `.mts` could work, to avoid `import-x/no-unresolved` from erroring `.mjs` is used.
+/* eslint-disable import-x/extensions */
+
+export * as interaction from "./interaction/_module.mjs";
+export * as media from "./media/_module.mjs";
+export * as types from "./_types.mjs";
+export { AsyncWorker, WorkerManager } from "./workers.mjs";
+export { default as ClientIssues } from "./client-issues.mjs";
+export { default as ClientSettings } from "./client-settings.mjs";
+export { default as DocumentIndex } from "./document-index.mjs";
+export { default as GameTime } from "./time.mjs";
+export { default as Hooks } from "./hooks.mjs";
+export { default as Localization } from "./localization.mjs";
+export { default as SocketInterface } from "./socket-interface.mjs";

package/src/foundry/client/helpers/_types.d.mts

@@ -0,0 +1,17 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import type CompendiumArt from "./media/compendium-art.d.mts";
+
+export {};
+
+// After seeing that none of these types add anything or are even exported a
+// very reasonable question may be: Why on earth does this file exist?
+//
+// Well this is the file in which Foundry defines these types. We don't house
+// them here because it has poor discoverability. It's also just nice to
+// have as reference to keep us synced with the latest version of Foundry.
+
+type CompendiumArtInfo = CompendiumArt.Info;
+
+type CompendiumArtMapping = CompendiumArt.Mapping;
+
+type CompendiumArtDescriptor = CompendiumArt.Descriptor;