@league-of-foundry-developers/foundry-vtt-types 13.340.0 → 13.340.1

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

@@ -1,15 +1,15 @@
-import type { DeepPartial } from "fvtt-types/utils";
-import type Document from "../../../common/abstract/document.d.mts";
+import type { DeepPartial, Identity } from "fvtt-types/utils";
+import type Document from "#common/abstract/document.d.mts";
 
 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,15 +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 {
-    type Any = AnyPlaylists;
-    type AnyConstructor = typeof AnyPlaylists;
+    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(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

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

@@ -1,32 +1,32 @@
-import type { InexactPartial } from "fvtt-types/utils";
-import type Document from "../../../common/abstract/document.d.mts";
+import type { Identity } from "fvtt-types/utils";
+import type Document from "#common/abstract/document.d.mts";
 
 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,33 +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 {
-    type Any = AnyScenes;
-    type AnyConstructor = typeof AnyScenes;
+    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(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

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

@@ -1,13 +1,14 @@
-export {};
+import type { Identity } from "fvtt-types/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;
@@ -28,11 +29,14 @@ declare global {
   }
 
   namespace WorldSettings {
-    type Any = AnyWorldSettings;
-    type AnyConstructor = typeof AnyWorldSettings;
+    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(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

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

@@ -1,14 +1,15 @@
-export {};
+import type { Identity } from "fvtt-types/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;
@@ -20,11 +21,14 @@ declare global {
   }
 
   namespace RollTables {
-    type Any = AnyRollTables;
-    type AnyConstructor = typeof AnyRollTables;
+    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(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

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

@@ -1,21 +1,21 @@
-import type { InexactPartial } from "fvtt-types/utils";
-import type Document from "../../../common/abstract/document.d.mts";
+import type { Identity, InexactPartial } from "fvtt-types/utils";
+import type Document from "#common/abstract/document.d.mts";
 
 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,9 +34,9 @@ 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;
 
     /**
@@ -49,11 +49,14 @@ declare global {
   }
 
   namespace Users {
-    type Any = AnyUsers;
-    type AnyConstructor = typeof AnyUsers;
+    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(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }