@league-of-foundry-developers/foundry-vtt-types 12.331.3-beta → 12.331.5

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

@@ -1,21 +1,24 @@
-import type { InexactPartial } from "../../../../types/utils.d.mts";
+import type { InexactPartial, Identity } from "#utils";
+import type Document from "../../../common/abstract/document.d.mts";
 
 declare global {
   /**
    * The singleton collection of JournalEntry documents which exist within the active World.
    * This Collection is accessible within the Game object as game.journal.
    *
-   * @see {@link JournalEntry} The JournalEntry document
-   * @see {@link JournalDirectory} The JournalDirectory sidebar directory
+   * @see {@link JournalEntry | `JournalEntry`} The JournalEntry document
+   * @see {@link JournalDirectory | `JournalDirectory`} The JournalDirectory sidebar directory
    */
-  class Journal extends WorldCollection<typeof foundry.documents.BaseJournalEntry, "Journal"> {
+  class Journal extends WorldCollection<JournalEntry.ImplementationClass, "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 | JournalEntryPage>(doc: T): Promise<T | void>;
+    static showDialog<T extends JournalEntry.Implementation | JournalEntryPage.Implementation>(
+      doc: T,
+    ): Promise<T | void>;
 
     /**
      * Show the JournalEntry or JournalEntryPage to connected players.
@@ -26,7 +29,7 @@ declare global {
      * @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 | JournalEntryPage>(
+    static show<T extends JournalEntry.Implementation | JournalEntryPage.Implementation>(
       doc: T,
       options?: InexactPartial<{
         /**
@@ -49,7 +52,7 @@ declare global {
 
     /**
      * Open Socket listeners which transact JournalEntry data
-     * @remarks This is not marked as protected because it is used in {@link Game#activateSocketListeners}
+     * @remarks This is not marked as protected because it is used in {@link Game.activateSocketListeners | `Game#activateSocketListeners`}
      */
     protected static _activateSocketListeners(socket: io.Socket): void;
 
@@ -61,4 +64,16 @@ declare global {
      */
     protected static _showEntry(uuid: string, force?: boolean): Promise<void>;
   }
+
+  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);
 }

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

@@ -1,32 +1,34 @@
-import type { InexactPartial } from "../../../../types/utils.d.mts";
+import type { Identity } from "#utils";
+import type Document from "../../../common/abstract/document.d.mts";
 
 declare global {
   /**
    * The singleton collection of Macro documents which exist within the active World.
    * This Collection is accessible within the Game object as game.macros.
    *
-   * @see {@link Macro} The Macro document
-   * @see {@link MacroDirectory} The MacroDirectory sidebar directory
+   * @see {@link Macro | `Macro`} The Macro document
+   * @see {@link MacroDirectory | `MacroDirectory`} The MacroDirectory sidebar directory
    */
-  class Macros extends WorldCollection<typeof foundry.documents.BaseMacro, "Macros"> {
+  class Macros extends WorldCollection<Macro.ImplementationClass, "Macros"> {
     static documentName: "Macro";
 
     override get directory(): typeof ui.macros;
 
-    override fromCompendium<
-      FolderOpt extends boolean = false,
-      SortOpt extends boolean = true,
-      OwnershipOpt extends boolean = false,
-      IdOpt extends boolean = false,
-    >(
-      document: Macro.ConfiguredInstance | foundry.documents.BaseMacro.ConstructorData,
-      options?: InexactPartial<WorldCollection.FromCompendiumOptions<FolderOpt, SortOpt, OwnershipOpt, IdOpt>>,
-    ): Omit<
-      Macro["_source"],
-      | ClientDocument.OmitProperty<FolderOpt, "folder">
-      | ClientDocument.OmitProperty<SortOpt, "sort" | "navigation" | "navOrder">
-      | ClientDocument.OmitProperty<OwnershipOpt, "ownership">
-      | (IdOpt extends false ? "_id" : never)
-    >;
+    override fromCompendium<Options extends WorldCollection.FromCompendiumOptions | undefined>(
+      document: Macro.Implementation | Macro.CreateData,
+      options?: Options,
+    ): WorldCollection.FromCompendiumReturnType<Macro.ImplementationClass, Options>;
   }
+
+  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);
 }

package/src/foundry/client/data/collections/messages.d.mts

@@ -1,3 +1,4 @@
+import type { Identity } from "#utils";
 import type Document from "../../../common/abstract/document.d.mts";
 
 declare global {
@@ -5,10 +6,10 @@ declare global {
    * The singleton collection of ChatMessage documents which exist within the active World.
    * This Collection is accessible within the Game object as game.messages.
    *
-   * @see {@link ChatMessage} The ChatMessage document
-   * @see {@link ChatLog} The ChatLog sidebar directory
+   * @see {@link ChatMessage | `ChatMessage`} The ChatMessage document
+   * @see {@link ChatLog | `ChatLog`} The ChatLog sidebar directory
    */
-  class Messages extends WorldCollection<typeof foundry.documents.BaseChatMessage, "Messages"> {
+  class Messages extends WorldCollection<ChatMessage.ImplementationClass, "Messages"> {
     static documentName: "ChatMessage";
 
     override get directory(): typeof ui.chat;
@@ -19,7 +20,7 @@ declare global {
      * If requested, dispatch a Chat Bubble UI for the newly created message
      * @param message - The ChatMessage document to say
      */
-    sayBubble(message: ChatMessage.ConfiguredInstance): void;
+    sayBubble(message: ChatMessage.Implementation): void;
 
     /**
      * Handle export of the chat log to a text file
@@ -28,8 +29,20 @@ declare global {
 
     /**
      * Allow for bulk deletion of all chat messages, confirm first with a yes/no dialog.
-     * @see {@link Dialog.confirm}
+     * @see {@link Dialog.confirm | `Dialog.confirm`}
      */
-    flush(): Promise<Promise<Document.Stored<ChatMessage.ConfiguredInstance>[]> | false | null>;
+    flush(): Promise<Promise<ChatMessage.Stored[]> | false | null>;
   }
+
+  namespace Messages {
+    interface Any extends AnyMessages {}
+    interface AnyConstructor extends Identity<typeof AnyMessages> {}
+
+    interface ConfiguredClass extends Document.ConfiguredCollectionClass<"ChatMessage"> {}
+    interface Configured extends Document.ConfiguredCollection<"ChatMessage"> {}
+  }
+}
+
+declare abstract class AnyMessages extends Messages {
+  constructor(...args: never);
 }

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

@@ -1,4 +1,4 @@
-import type { DeepPartial } from "../../../../types/utils.d.mts";
+import type { DeepPartial, Identity } from "#utils";
 import type Document from "../../../common/abstract/document.d.mts";
 
 declare global {
@@ -6,10 +6,10 @@ declare global {
    * The singleton collection of Playlist documents which exist within the active World.
    * This Collection is accessible within the Game object as game.playlists.
    *
-   * @see {@link Playlist} The Playlist document
-   * @see {@link PlaylistDirectory} The PlaylistDirectory sidebar directory
+   * @see {@link Playlist | `Playlist`} The Playlist document
+   * @see {@link PlaylistDirectory | `PlaylistDirectory`} The PlaylistDirectory sidebar directory
    */
-  class Playlists extends WorldCollection<typeof foundry.documents.BasePlaylist, "Playlists"> {
+  class Playlists extends WorldCollection<Playlist.ImplementationClass, "Playlists"> {
     static documentName: "Playlist";
 
     /**
@@ -27,6 +27,18 @@ declare global {
      * @param scene - The Scene document being updated
      * @param data  - The incremental update data
      */
-    protected _onChangeScene(scene: Document.Stored<Scene>, data: DeepPartial<Scene["_source"]>): Promise<void>;
+    protected _onChangeScene(scene: Scene.Stored, data: DeepPartial<Scene.Implementation["_source"]>): Promise<void>;
   }
+
+  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);
 }

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

@@ -1,4 +1,4 @@
-import type { InexactPartial } from "../../../../types/utils.d.mts";
+import type { Identity } from "#utils";
 import type Document from "../../../common/abstract/document.d.mts";
 
 declare global {
@@ -6,27 +6,27 @@ declare global {
    * The singleton collection of Scene documents which exist within the active World.
    * This Collection is accessible within the Game object as game.scenes.
    *
-   * @see {@link Scene} The Scene document
-   * @see {@link SceneDirectory} The SceneDirectory sidebar directory
+   * @see {@link Scene | `Scene`} The Scene document
+   * @see {@link SceneDirectory | `SceneDirectory`} The SceneDirectory sidebar directory
    */
-  class Scenes extends WorldCollection<typeof foundry.documents.BaseScene, "Scenes"> {
+  class Scenes extends WorldCollection<Scene.ImplementationClass, "Scenes"> {
     static documentName: "Scene";
 
     /**
      * Return a reference to the Scene which is currently active
      */
-    get active(): Document.Stored<Scene.ConfiguredInstance> | undefined;
+    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(): Document.Stored<Scene.ConfiguredInstance> | undefined;
+    get current(): Scene.Stored | undefined;
 
     /**
      * Return a reference to the Scene which is currently viewed
      */
-    get viewed(): Document.Stored<Scene.ConfiguredInstance> | undefined;
+    get viewed(): Scene.Stored | undefined;
 
     /**
      * Handle pre-loading the art assets for a Scene
@@ -37,7 +37,7 @@ declare global {
      */
     preload(sceneId: string, push?: boolean): io.Socket | Promise<unknown[]>;
 
-    /** @remarks This is not marked as protected because it is used in {@link Game#activateSocketListeners} */
+    /** @remarks This is not marked as protected because it is used in {@link Game.activateSocketListeners | `Game#activateSocketListeners`} */
     static _activateSocketListeners(socket: io.Socket): void;
 
     /**
@@ -45,24 +45,21 @@ declare global {
      */
     protected static _pullToScene(sceneId: string): void;
 
-    override fromCompendium<
-      FolderOpt extends boolean = false,
-      SortOpt extends boolean = true,
-      OwnershipOpt extends boolean = false,
-      IdOpt extends boolean = false,
-      StateOpt extends boolean = false,
-    >(
-      document: Scene.ConfiguredInstance | foundry.documents.BaseScene.ConstructorData,
-      options?: InexactPartial<
-        WorldCollection.FromCompendiumOptions<FolderOpt, SortOpt, OwnershipOpt, IdOpt, StateOpt>
-      >,
-    ): Omit<
-      Scene["_source"],
-      | ClientDocument.OmitProperty<FolderOpt, "folder">
-      | ClientDocument.OmitProperty<SortOpt, "sort" | "navigation" | "navOrder">
-      | ClientDocument.OmitProperty<OwnershipOpt, "ownership">
-      | (IdOpt extends false ? "_id" : never)
-      | ClientDocument.OmitProperty<StateOpt, "active">
-    >;
+    override fromCompendium<Options extends WorldCollection.FromCompendiumOptions | undefined>(
+      document: Scene.Implementation | Scene.CreateData,
+      options?: Options,
+    ): WorldCollection.FromCompendiumReturnType<Scene.ImplementationClass, Options>;
   }
+
+  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);
 }

package/src/foundry/client/data/collections/settings.d.mts

@@ -1,13 +1,14 @@
-export {};
+import type { Identity } from "#utils";
+import type Document from "../../../common/abstract/document.d.mts";
 
 declare global {
   /**
    * The Collection of Setting documents which exist within the active World.
    * This collection is accessible as game.settings.storage.get("world")
    *
-   * @see {@link Setting} The Setting document
+   * @see {@link Setting | `Setting`} The Setting document
    */
-  class WorldSettings extends WorldCollection<typeof foundry.documents.BaseSetting, "WorldSettings"> {
+  class WorldSettings extends WorldCollection<Setting.ImplementationClass, "WorldSettings"> {
     static documentName: "Setting";
 
     override get directory(): null;
@@ -26,4 +27,16 @@ declare global {
      */
     getItem(key: string): string | null;
   }
+
+  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);
 }

package/src/foundry/client/data/collections/tables.d.mts

@@ -1,21 +1,34 @@
-export {};
+import type { Identity } from "#utils";
+import type Document from "../../../common/abstract/document.d.mts";
 
 declare global {
   /**
    * The singleton collection of RollTable documents which exist within the active World.
    * This Collection is accessible within the Game object as game.tables.
    *
-   * @see {@link RollTable} The RollTable document
-   * @see {@link RollTableDirectory} The RollTableDirectory sidebar directory
+   * @see {@link RollTable | `RollTable`} The RollTable document
+   * @see {@link RollTableDirectory | `RollTableDirectory`} The RollTableDirectory sidebar directory
    */
-  class RollTables extends WorldCollection<typeof foundry.documents.BaseRollTable, "RollTables"> {
+  class RollTables extends WorldCollection<RollTable.ImplementationClass, "RollTables"> {
     static documentName: "RollTable";
 
-    override get directory(): (typeof ui)["tables"];
+    override get directory(): typeof ui.tables;
 
     /**
      * Register world settings related to RollTable documents
      */
     static registerSettings(): void;
   }
+
+  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);
 }

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

@@ -1,4 +1,4 @@
-import type { InexactPartial } from "../../../../types/utils.d.mts";
+import type { Identity } from "#utils";
 import type Document from "../../../common/abstract/document.d.mts";
 
 declare global {
@@ -6,16 +6,16 @@ declare global {
    * The singleton collection of User documents which exist within the active World.
    * This Collection is accessible within the Game object as game.users.
    *
-   * @see {@link User} The User document
+   * @see {@link User | `User`} The User document
    */
-  class Users extends WorldCollection<typeof foundry.documents.BaseUser, "Users"> {
-    constructor(data?: User["_source"][]);
+  class Users extends WorldCollection<User.ImplementationClass, "Users"> {
+    constructor(data?: User.Source[]);
 
     /**
      * The User document of the currently connected user
      * @defaultValue `null`
      */
-    current: Document.Stored<User.ConfiguredInstance> | null;
+    current: User.Stored | null;
 
     /**
      * Initialize the Map object and all its contained documents
@@ -34,17 +34,29 @@ declare global {
      * 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.ConfiguredInstance | null;
+    get activeGM(): User.Implementation | null;
 
-    /** @remarks This is not marked as protected because it is used in {@link Game#activateSocketListeners} */
+    /** @remarks This is not marked as protected because it is used in {@link Game.activateSocketListeners | `Game#activateSocketListeners`} */
     static _activateSocketListeners(socket: io.Socket): void;
 
     /**
      * Handle receipt of activity data from another User connected to the Game session
      * @param userId       - The User id who generated the activity data
-     * @param activityData - The object of activity data
-     *                       (default: `{}`)
+     * @param activityData - The object of activity data (default: `{}`)
      */
-    protected static _handleUserActivity(userId: string, activityData?: InexactPartial<User.ActivityData>): void;
+    // activityData: not null (parameter default only)
+    protected static _handleUserActivity(userId: string, activityData?: User.ActivityData): void;
   }
+
+  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);
 }