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

package/src/foundry/client/documents/collections/journal.d.mts

@@ -0,0 +1,78 @@
+import type { InexactPartial, Identity } from "#utils";
+import type Document from "#common/abstract/document.d.mts";
+
+/**
+ * The singleton collection of JournalEntry documents which exist within the active World.
+ * This Collection is accessible within the Game object as game.journal.
+ *
+ * @see {@linkcode JournalEntry} The JournalEntry document
+ * @see {@linkcode JournalDirectory} The JournalDirectory sidebar directory
+ */
+declare class Journal extends foundry.documents.abstract.WorldCollection<"JournalEntry", "Journal"> {
+  static documentName: "JournalEntry";
+
+  /**
+   * Display a dialog which prompts the user to show a JournalEntry or JournalEntryPage to other players.
+   * @param doc - The JournalEntry or JournalEntryPage to show.
+   */
+  static showDialog<T extends JournalEntry.Implementation | JournalEntryPage.Implementation>(doc: T): Promise<void>;
+
+  /**
+   * Show the JournalEntry or JournalEntryPage to connected players.
+   * By default, the document will only be shown to players who have permission to observe it.
+   * If the force parameter is passed, the document will be shown to all players regardless of normal permission.
+   * @param doc     - The JournalEntry or JournalEntryPage to show.
+   * @param options - Additional options to configure behaviour.
+   * @returns A Promise that resolves back to the shown document once the request is processed.
+   * @throws If the user does not own the document they are trying to show.
+   */
+  static show<T extends JournalEntry.Implementation | JournalEntryPage.Implementation>(
+    doc: T,
+    options?: InexactPartial<{
+      /**
+       * Display the entry to all players regardless of normal permissions.
+       */
+      force: boolean;
+
+      /**
+       * An optional list of user IDs to show the document to. Otherwise it will be shown to all connected clients.
+       */
+      users: string[];
+    }>,
+  ): Promise<T | void>;
+
+  /**
+   * Share an image with connected players.
+   * @param src    - The image URL to share.
+   * @param config - Image sharing configuration.
+   */
+  static showImage(src: string, config?: InexactPartial<foundry.applications.apps.ImagePopout.ShareImageConfig>): void;
+
+  /**
+   * Open Socket listeners which transact JournalEntry data
+   * @remarks This is not marked as protected because it is used in {@link Game.activateSocketListeners | `Game#activateSocketListeners`}
+   */
+  protected static _activateSocketListeners(socket: io.Socket): void;
+
+  /**
+   * Handle a received request to show a JournalEntry or JournalEntryPage to the current client
+   * @param uuid - The UUID of the document to display for other players
+   * @param force   - Display the document regardless of normal permissions
+   *                  (default: `true`)
+   */
+  protected static _showEntry(uuid: string, force?: boolean): Promise<void>;
+}
+
+declare namespace Journal {
+  interface Any extends AnyJournal {}
+  interface AnyConstructor extends Identity<typeof AnyJournal> {}
+
+  interface ConfiguredClass extends Document.ConfiguredCollectionClass<"JournalEntry"> {}
+  interface Configured extends Document.ConfiguredCollection<"JournalEntry"> {}
+}
+
+declare abstract class AnyJournal extends Journal {
+  constructor(...args: never);
+}
+
+export default Journal;

package/src/foundry/client/documents/collections/macros.d.mts

@@ -0,0 +1,34 @@
+import type { Identity } from "#utils";
+import type Document from "#common/abstract/document.d.mts";
+
+/**
+ * The singleton collection of Macro documents which exist within the active World.
+ * This Collection is accessible within the Game object as game.macros.
+ *
+ * @see {@linkcode Macro} The Macro document
+ * @see {@linkcode MacroDirectory} The MacroDirectory sidebar directory
+ */
+declare class Macros extends foundry.documents.abstract.WorldCollection<"Macro", "Macros"> {
+  static documentName: "Macro";
+
+  override get directory(): typeof ui.macros;
+
+  override fromCompendium<Options extends foundry.documents.abstract.WorldCollection.FromCompendiumOptions | undefined>(
+    document: Macro.Implementation | Macro.CreateData,
+    options?: Options,
+  ): foundry.documents.abstract.WorldCollection.FromCompendiumReturnType<"Macro", Options>;
+}
+
+declare namespace Macros {
+  interface Any extends AnyMacros {}
+  interface AnyConstructor extends Identity<typeof AnyMacros> {}
+
+  interface ConfiguredClass extends Document.ConfiguredCollectionClass<"Macro"> {}
+  interface Configured extends Document.ConfiguredCollection<"Macro"> {}
+}
+
+declare abstract class AnyMacros extends Macros {
+  constructor(...args: never);
+}
+
+export default Macros;

package/src/foundry/client/documents/collections/playlists.d.mts

@@ -0,0 +1,45 @@
+import type { Identity } from "#utils";
+import type Document from "#common/abstract/document.d.mts";
+
+/**
+ * The singleton collection of Playlist documents which exist within the active World.
+ * This Collection is accessible within the Game object as game.playlists.
+ *
+ * @see {@linkcode Playlist} The Playlist document
+ * @see {@linkcode PlaylistDirectory} The PlaylistDirectory sidebar directory
+ */
+declare class Playlists extends foundry.documents.abstract.WorldCollection<"Playlist", "Playlists"> {
+  static documentName: "Playlist";
+
+  /**
+   * Return the subset of Playlist documents which are currently playing
+   */
+  get playing(): Playlist.Implementation[];
+
+  /**
+   * Perform one-time initialization to begin playback of audio.
+   */
+  initialize(): Promise<void>;
+
+  /**
+   * Handle changes to a Scene to determine whether to trigger changes to Playlist documents.
+   * @param scene      - The new active Scene
+   * @param priorScene - The previously active Scene
+   * @internal
+   */
+  protected _onChangeScene(scene: Scene.Stored | null, priorScene: Scene.Stored | null): Promise<void>;
+}
+
+declare namespace Playlists {
+  interface Any extends AnyPlaylists {}
+  interface AnyConstructor extends Identity<typeof AnyPlaylists> {}
+
+  interface ConfiguredClass extends Document.ConfiguredCollectionClass<"Playlist"> {}
+  interface Configured extends Document.ConfiguredCollection<"Playlist"> {}
+}
+
+declare abstract class AnyPlaylists extends Playlists {
+  constructor(...args: never);
+}
+
+export default Playlists;

package/src/foundry/client/documents/collections/roll-tables.d.mts

@@ -0,0 +1,34 @@
+import type { Identity } from "#utils";
+import type Document from "#common/abstract/document.d.mts";
+
+/**
+ * The singleton collection of RollTable documents which exist within the active World.
+ * This Collection is accessible within the Game object as game.tables.
+ *
+ * @see {@linkcode RollTable} The RollTable document
+ * @see {@linkcode RollTableDirectory} The RollTableDirectory sidebar directory
+ */
+declare class RollTables extends foundry.documents.abstract.WorldCollection<"RollTable", "RollTables"> {
+  static documentName: "RollTable";
+
+  override get directory(): typeof ui.tables;
+
+  /**
+   * Register world settings related to RollTable documents
+   */
+  static registerSettings(): void;
+}
+
+declare namespace RollTables {
+  interface Any extends AnyRollTables {}
+  interface AnyConstructor extends Identity<typeof AnyRollTables> {}
+
+  interface ConfiguredClass extends Document.ConfiguredCollectionClass<"RollTable"> {}
+  interface Configured extends Document.ConfiguredCollection<"RollTable"> {}
+}
+
+declare abstract class AnyRollTables extends RollTables {
+  constructor(...args: never);
+}
+
+export default RollTables;

package/src/foundry/client/documents/collections/scenes.d.mts

@@ -0,0 +1,63 @@
+import type { Identity } from "#utils";
+import type Document from "#common/abstract/document.d.mts";
+
+/**
+ * The singleton collection of Scene documents which exist within the active World.
+ * This Collection is accessible within the Game object as game.scenes.
+ *
+ * @see {@linkcode Scene} The Scene document
+ * @see {@linkcode SceneDirectory} The SceneDirectory sidebar directory
+ */
+declare class Scenes extends foundry.documents.abstract.WorldCollection<"Scene", "Scenes"> {
+  static documentName: "Scene";
+
+  /**
+   * Return a reference to the Scene which is currently active
+   */
+  get active(): Scene.Stored | undefined;
+
+  /**
+   * Return the current Scene target.
+   * This is the viewed scene if the canvas is active, otherwise it is the currently active scene.
+   */
+  get current(): Scene.Stored | undefined;
+
+  /**
+   * Return a reference to the Scene which is currently viewed
+   */
+  get viewed(): Scene.Stored | undefined;
+
+  /**
+   * Handle pre-loading the art assets for a Scene
+   *
+   * @param sceneId - The Scene id to begin loading
+   * @param push    - Trigger other connected clients to also pre-load Scene resources
+   *                  (default: `false`)
+   */
+  preload(sceneId: string, push?: boolean): io.Socket | Promise<unknown[]>;
+
+  /** @remarks This is not marked as protected because it is used in {@link Game.activateSocketListeners | `Game#activateSocketListeners`} */
+  static _activateSocketListeners(socket: io.Socket): void;
+
+  /** @deprecated Foundry made this method truly private in v13 (this warning will be removed in v14) */
+  protected static _pullToScene(sceneId: never): never;
+
+  override fromCompendium<Options extends foundry.documents.abstract.WorldCollection.FromCompendiumOptions | undefined>(
+    document: Scene.Implementation | Scene.CreateData,
+    options?: Options,
+  ): foundry.documents.abstract.WorldCollection.FromCompendiumReturnType<"Scene", Options>;
+}
+
+declare namespace Scenes {
+  interface Any extends AnyScenes {}
+  interface AnyConstructor extends Identity<typeof AnyScenes> {}
+
+  interface ConfiguredClass extends Document.ConfiguredCollectionClass<"Scene"> {}
+  interface Configured extends Document.ConfiguredCollection<"Scene"> {}
+}
+
+declare abstract class AnyScenes extends Scenes {
+  constructor(...args: never);
+}
+
+export default Scenes;

package/src/foundry/client/documents/collections/users.d.mts

@@ -0,0 +1,72 @@
+import type { Identity } from "#utils";
+import type Document from "#common/abstract/document.d.mts";
+
+/**
+ * The singleton collection of User documents which exist within the active World.
+ * This Collection is accessible within the Game object as game.users.
+ *
+ * @see {@linkcode User} The User document
+ */
+declare class Users extends foundry.documents.abstract.WorldCollection<"User", "Users"> {
+  constructor(data?: User.Source[]);
+
+  /**
+   * The User document of the currently connected user
+   * @defaultValue `null`
+   */
+  current: User.Stored | null;
+
+  /**
+   * Initialize the Map object and all its contained documents
+   * @internal
+   */
+  protected _initialize(): void;
+
+  static documentName: "User";
+
+  /**
+   * Get the users with player roles
+   */
+  get players(): ReturnType<this["filter"]>;
+
+  /**
+   * Get one User who is an active Gamemaster (non-assistant if possible), or null if no active GM is available.
+   * This can be useful for workflows which occur on all clients, but where only one user should take action.
+   */
+  get activeGM(): User.Implementation | null;
+
+  /**
+   * Get the designated User among the Users that satisfy the given condition.
+   * Returns `null` if no Users satisfy the given condition.
+   * Returns a User with the highest role among the qualifying Users.
+   * Qualifying Users aren't necessary active Users unless it is part of the condition.
+   * @example
+   * // Get the designated User for creating Tokens that is active
+   * ```js
+   * const user = game.users.getDesignatedUser(user => user.active && user.can("TOKEN_CREATE"));
+   * ```
+   * @param condition - The condition the Users must satisfy
+   * @returns The designated User or `null`
+   */
+  getDesignatedUser(condition: (user: User.Implementation) => boolean): User.Implementation | null;
+
+  /** @remarks This is not marked as protected because it is used in {@link Game.activateSocketListeners | `Game#activateSocketListeners`} */
+  static _activateSocketListeners(socket: io.Socket): void;
+
+  /** @deprecated Foundry made this method truly private in v13 (this warning will be removed in v14) */
+  static _handleUserActivity(userId: never, activityData?: never): never;
+}
+
+declare namespace Users {
+  interface Any extends AnyUsers {}
+  interface AnyConstructor extends Identity<typeof AnyUsers> {}
+
+  interface ConfiguredClass extends Document.ConfiguredCollectionClass<"User"> {}
+  interface Configured extends Document.ConfiguredCollection<"User"> {}
+}
+
+declare abstract class AnyUsers extends Users {
+  constructor(...args: never);
+}
+
+export default Users;

package/src/foundry/client/documents/collections/world-settings.d.mts

@@ -0,0 +1,44 @@
+import type { Identity } from "#utils";
+import type Document from "#common/abstract/document.d.mts";
+
+/**
+ * The Collection of Setting documents which exist within the active World.
+ * This collection is accessible as game.settings.storage.get("world")
+ *
+ * @see {@linkcode Setting} The Setting document
+ */
+declare class WorldSettings extends foundry.documents.abstract.WorldCollection<"Setting", "WorldSettings"> {
+  static documentName: "Setting";
+
+  override get directory(): null;
+
+  /**
+   * Return the Setting or Keybind document with the given key.
+   * @param key  - The setting key
+   * @param user - For user-scoped settings, the user ID. (default `null`)
+   * @returns The Setting.
+   */
+  getSetting(key: string, user?: string | null): ReturnType<this["find"]>;
+
+  /**
+   * Return the serialized value of the world setting as a string
+   * @param key  - The setting key
+   * @param user - For user-scoped settings, the user ID.
+   * @returns The serialized setting string
+   */
+  getItem(key: string, user?: string): string | null;
+}
+
+declare namespace WorldSettings {
+  interface Any extends AnyWorldSettings {}
+  interface AnyConstructor extends Identity<typeof AnyWorldSettings> {}
+
+  interface ConfiguredClass extends Document.ConfiguredCollectionClass<"Setting"> {}
+  interface Configured extends Document.ConfiguredCollection<"Setting"> {}
+}
+
+declare abstract class AnyWorldSettings extends WorldSettings {
+  constructor(...args: never);
+}
+
+export default WorldSettings;