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

package/src/foundry/client/data/collections/compendium-collection.d.mts

@@ -1,56 +1,34 @@
 import type { DeepPartial, EmptyObject, InexactPartial } from "fvtt-types/utils";
-import type Document from "../../../common/abstract/document.d.mts";
-import type { DirectoryCollectionMixin_DocumentCollection_Interface } from "../abstract/directory-collection-mixin.d.mts";
-
-declare const DirectoryCollectionMixin_DocumentCollection: DirectoryCollectionMixin_DocumentCollection_Interface;
+import type Document from "#common/abstract/document.d.mts";
+import type { DatabaseCreateOperation } from "#common/abstract/_types.d.mts";
 
 declare global {
-  interface ManageCompendiumRequest extends SocketInterface.SocketRequest {
-    /**
-     * The request action.
-     */
-    action: string;
-
-    /**
-     * The compendium creation data, or the ID of the compendium to delete.
-     */
-    data: PackageCompendiumData | string;
-
-    /**
-     * Additional options.
-     */
-    options?: Record<string, unknown>;
-  }
-
-  // @ts-expect-error Bad inheritance
-  interface ManageCompendiumResponse extends SocketInterface.SocketResponse {
-    /**
-     * The original request.
-     */
-    request: ManageCompendiumRequest;
+  /**
+   * @deprecated {@link CompendiumCollection.ManageCompendiumRequest | `CompendiumCollection.ManageCompendiumRequest`}
+   */
+  type ManageCompendiumRequest = CompendiumCollection.ManageCompendiumRequest;
 
-    /**
-     * The compendium creation data, or the collection name of the deleted compendium.
-     */
-    result: PackageCompendiumData | string;
-  }
+  /**
+   * @deprecated {@link CompendiumCollection.ManageCompendiumResponse | `CompendiumCollection.ManageCompendiumResponse`}
+   */
+  type ManageCompendiumResponse = CompendiumCollection.ManageCompendiumResponse;
 
   /**
    * A collection of Document objects contained within a specific compendium pack.
    * Each Compendium pack has its own associated instance of the CompendiumCollection class which contains its contents.
    *
-   * @see {@link Game#packs}
+   * @see {@link Game.packs | `Game#packs`}
    */
-  class CompendiumCollection<
-    T extends CompendiumCollection.Metadata,
-  > extends DirectoryCollectionMixin_DocumentCollection<Document.ConfiguredClassForName<T["type"]>, T["name"]> {
+  class CompendiumCollection<T extends CompendiumCollection.Metadata> extends DirectoryCollectionMixin(
+    DocumentCollection,
+  )<Document.ImplementationClassFor<T["type"]>, T["name"]> {
     /** @param metadata - The compendium metadata, an object provided by game.data */
     constructor(metadata: CompendiumCollection.ConstructorMetadata<T>);
 
     /** The compendium metadata which defines the compendium content and location */
     metadata: T;
 
-    /**  A subsidiary collection which contains the more minimal index of the pack */
+    /** A subsidiary collection which contains the more minimal index of the pack */
     index: IndexTypeForMetadata<T>;
 
     /**
@@ -97,14 +75,14 @@ declare global {
     /**
      * Get the Folder that this Compendium is displayed within
      */
-    get folder(): (Folder.ConfiguredInstance & { type: "Compendium" }) | null;
+    get folder(): (Folder.Implementation & { type: "Compendium" }) | null;
 
     /**
      * Assign this CompendiumCollection to be organized within a specific Folder.
      * @param folder - The desired Folder within the World or null to clear the folder
      * @returns A promise which resolves once the transaction is complete
      */
-    setFolder(folder: Folder | string | null): Promise<void>;
+    setFolder(folder: Folder.Implementation | string | null): Promise<void>;
 
     /**
      * Get the sort order for this Compendium
@@ -113,7 +91,10 @@ declare global {
 
     // Note(LukeAbby): The override for `_getVisibleTreeContents` become unreasonably long and don't add any changes and so has been omitted.
 
-    static _sortStandard(a: number, b: number): number;
+    static _sortStandard(
+      a: DirectoryCollectionMixin.StandardSortEntry,
+      b: DirectoryCollectionMixin.StandardSortEntry,
+    ): number;
 
     /** Access the compendium configuration data for this pack */
     get config(): CompendiumCollection.Configuration | EmptyObject;
@@ -150,7 +131,7 @@ declare global {
 
     // NOTE(LukeAbby): This override was disabled for the time being because it's erroring.
     // Thankfully it doesn't actually change its parent class's signature.
-    // set(id: string, document: Document.Stored<Document.ConfiguredInstanceForName<T["type"]>>): this;
+    // set(id: string, document: Document.Stored<Document.ImplementationFor<T["type"]>>): this;
 
     delete: (id: string) => boolean;
 
@@ -168,7 +149,7 @@ declare global {
      * @param id -  The requested Document id
      * @returns The retrieved Document instance
      */
-    getDocument(id: string): Promise<Document.Stored<Document.ConfiguredInstanceForName<T["type"]>> | undefined | null>;
+    getDocument(id: string): Promise<Document.Stored<Document.ImplementationFor<T["type"]>> | undefined | null>;
 
     /**
      * Load multiple documents from the Compendium pack using a provided query object.
@@ -191,16 +172,14 @@ declare global {
      * await pack.getDocuments({ type__in: ["weapon", "armor"] });
      * ```
      */
-    getDocuments(
-      query?: Record<string, unknown>,
-    ): Promise<Document.Stored<Document.ConfiguredInstanceForName<T["type"]>>[]>;
+    getDocuments(query?: Record<string, unknown>): Promise<Document.Stored<Document.ImplementationFor<T["type"]>>[]>;
 
     /**
      * Get the ownership level that a User has for this Compendium pack.
      * @param user - The user being tested
      * @returns The ownership level in CONST.DOCUMENT_OWNERSHIP_LEVELS
      */
-    getUserLevel(user?: User): foundry.CONST.DOCUMENT_OWNERSHIP_LEVELS;
+    getUserLevel(user?: User.Implementation): foundry.CONST.DOCUMENT_OWNERSHIP_LEVELS;
 
     /**
      * Test whether a certain User has a requested permission level (or greater) over the Compendium pack
@@ -210,7 +189,7 @@ declare global {
      * @returns Does the user have this permission level over the Compendium pack?
      */
     testUserPermission(
-      user: User,
+      user: User.Implementation,
       permission: string | number,
       options?: InexactPartial<{
         /**
@@ -224,14 +203,14 @@ declare global {
     /**
      * Import a Document into this Compendium Collection.
      * @param document - The existing Document you wish to import
-     * @param options  - Additional options which modify how the data is imported. See {@link ClientDocument#toCompendium}
+     * @param options  - Additional options which modify how the data is imported. See {@link ClientDocument.toCompendium | `ClientDocument#toCompendium`}
      *                   (default: `{}`)
      * @returns The imported Document instance
      */
     importDocument(
-      document: Document.ConfiguredInstanceForName<T["type"]>,
-      options?: InexactPartial<ClientDocument.CompendiumExportOptions>,
-    ): Promise<Document.Stored<Document.ConfiguredInstanceForName<T["type"]>> | undefined>;
+      document: Document.ImplementationFor<T["type"]>,
+      options?: InexactPartial<ClientDocument.ToCompendiumOptions>,
+    ): Promise<Document.Stored<Document.ImplementationFor<T["type"]>> | undefined>;
 
     /**
      * Import a Folder into this Compendium Collection.
@@ -239,7 +218,7 @@ declare global {
      * @param options - Additional options which modify how the data is imported.
      */
     importFolder(
-      folder: Folder,
+      folder: Folder.Implementation,
       options?: InexactPartial<{
         /**
          * Import any parent folders which are not already present in the Compendium
@@ -255,7 +234,7 @@ declare global {
      * @param options - Additional options which modify how the data is imported.
      */
     importFolders(
-      folders: Folder[],
+      folders: Folder.Implementation[],
       options?: InexactPartial<{
         /**
          * Import any parent folders which are not already present in the Compendium
@@ -268,7 +247,7 @@ declare global {
     /**
      * Fully import the contents of a Compendium pack into a World folder.
      * @param options    - Options which modify the import operation. Additional options are forwarded to
-     *                     {@link WorldCollection#fromCompendium} and {@link Document.createDocuments}
+     *                     {@link WorldCollection.fromCompendium | `WorldCollection#fromCompendium`} and {@link Document.createDocuments | `Document.createDocuments`}
      *                     (default: `{}`)
      * @returns The imported Documents, now existing within the World
      */
@@ -285,10 +264,10 @@ declare global {
            * @defaultValue `""`
            * */
           folderName: string;
-        } & Document.OnCreateOptions<this["metadata"]["type"]> &
+        } & Document.Database.CreateOperation<DatabaseCreateOperation> &
           WorldCollection.FromCompendiumOptions
       >,
-    ): Promise<Document.Stored<Document.ConfiguredInstanceForName<T["type"]>>[]>;
+    ): Promise<Document.Stored<Document.ImplementationFor<T["type"]>>[]>;
 
     /**
      * Provide a dialog form that prompts the user to import the full contents of a Compendium pack into the World.
@@ -300,13 +279,13 @@ declare global {
      */
     importDialog(
       options?: Dialog.Options,
-    ): Promise<Document.Stored<Document.ConfiguredInstanceForName<T["type"]>>[] | null | false>;
+    ): Promise<Document.Stored<Document.ImplementationFor<T["type"]>>[] | null | false>;
 
     /**
      * Add a Document to the index, capturing it's relevant index attributes
      * @param document -The document to index
      */
-    indexDocument(document: Document.Stored<Document.ConfiguredInstanceForName<T["type"]>>): void;
+    indexDocument(document: Document.Stored<Document.ImplementationFor<T["type"]>>): void;
 
     /**
      * Prompt the gamemaster with a dialog to configure ownership of this Compendium pack.
@@ -325,12 +304,12 @@ declare global {
      * Create a new Compendium Collection using provided metadata.
      * @param metadata - The compendium metadata used to create the new pack
      * @param options - Additional options which modify the Compendium creation request
-     *                  default `{}`
+     *                  (default: `{}`)
      */
     static createCompendium<T extends CompendiumCollection.Metadata>(
-      this: abstract new (arg0: never, ...args: never[]) => CompendiumCollection<T>,
+      this: abstract new (...args: never) => CompendiumCollection<T>,
       metadata: CompendiumCollection.CreateCompendiumMetadata<NoInfer<T>>,
-      options?: Document.OnCreateOptions<T["type"]>,
+      options?: unknown,
     ): Promise<CompendiumCollection<T>>;
 
     /**
@@ -385,7 +364,7 @@ declare global {
   }
 
   namespace CompendiumCollection {
-    type Any = CompendiumCollection<any>;
+    interface Any extends CompendiumCollection<any> {}
 
     interface Configuration {
       ownership: InexactPartial<foundry.packages.BasePackage.OwnershipRecord>;
@@ -402,7 +381,7 @@ declare global {
     // The type that's passed to `new CompendiumCollection(...)`
     type ConstructorMetadata<T extends CompendiumCollection.Metadata> = T & {
       index: IndexTypeForMetadata<T>;
-      folders: Folder[];
+      folders: Folder.Implementation[];
     };
 
     // The type that appears in `compendium.metadata` after initialization.
@@ -428,13 +407,47 @@ declare global {
        * An array of fields to return as part of the index
        * @defaultValue `[]`
        */
-      fields?: (keyof Document.ConfiguredInstanceForName<T["type"]>["_source"])[];
+      fields?: (keyof Document.ImplementationFor<T["type"]>["_source"])[];
     }
 
     // TODO: Improve automatic index properties based on document type
     type IndexEntry<T extends CompendiumCollection.Metadata> = { _id: string; uuid: string } & DeepPartial<
-      Document.ConfiguredInstanceForName<T["type"]>["_source"]
+      Document.ImplementationFor<T["type"]>["_source"]
     >;
+
+    type ForDocument<Name extends Document.Type> = Name extends unknown
+      ? CompendiumCollection<Metadata & { type: Name }>
+      : never;
+
+    interface ManageCompendiumRequest extends SocketInterface.SocketRequest {
+      /**
+       * The request action.
+       */
+      action: string;
+
+      /**
+       * The compendium creation data, or the ID of the compendium to delete.
+       */
+      data: PackageCompendiumData | string;
+
+      /**
+       * Additional options.
+       */
+      options?: Record<string, unknown>;
+    }
+
+    // @ts-expect-error Bad inheritance
+    interface ManageCompendiumResponse extends SocketInterface.SocketResponse {
+      /**
+       * The original request.
+       */
+      request: ManageCompendiumRequest;
+
+      /**
+       * The compendium creation data, or the collection name of the deleted compendium.
+       */
+      result: PackageCompendiumData | string;
+    }
   }
 }
 
@@ -450,7 +463,7 @@ interface ImportAllOptions {
    * */
   folderName?: string | undefined;
   /**
-   * Additional options forwarded to {@link WorldCollection#fromCompendium} and {@link Document.createDocuments}
+   * Additional options forwarded to {@link WorldCollection.fromCompendium | `WorldCollection#fromCompendium`} and {@link Document.createDocuments | `Document.createDocuments`}
    * @defaultValue `{}`
    */
   options?: (Document.ModificationContext<Document.Any | null> & WorldCollection.FromCompendiumOptions) | undefined;

package/src/foundry/client/data/collections/compendium-folders.d.mts

@@ -4,14 +4,14 @@ declare global {
   /**
    * A Collection of Folder documents within a Compendium pack.
    */
-  class CompendiumFolderCollection extends DocumentCollection<typeof Folder, "Folders"> {
-    constructor(pack: CompendiumPacks, data: Folder["_source"][]);
+  class CompendiumFolderCollection extends DocumentCollection<Folder.ImplementationClass, "Folders"> {
+    constructor(pack: CompendiumPacks, data: Folder.Source[]);
 
     pack: CompendiumPacks;
 
     get documentName(): "Folder";
 
-    override render(force?: boolean, options?: ApplicationOptions): void;
+    override render(force?: boolean, options?: Application.Options): void;
 
     /**
      * @privateRemarks Possible this causes depth issues, this is just a small extension in the code with no meaningful transformations
@@ -19,9 +19,9 @@ declare global {
     // updateAll(
     //   transformation:
     //     | DeepPartial<Folder["_source"]>
-    //     | ((doc: foundry.abstract.Document.Stored<Folder>) => DeepPartial<Folder["_source"]>),
-    //   condition?: ((obj: foundry.abstract.Document.Stored<Folder>) => boolean) | null,
+    //     | ((doc: foundry.abstract.Folder.Stored) => DeepPartial<Folder["_source"]>),
+    //   condition?: ((obj: foundry.abstract.Folder.Stored) => boolean) | null,
     //   options?: foundry.abstract.Document.OnUpdateOptions<"Folder">,
-    // ): Promise<Folder.ConfiguredInstance[]>;
+    // ): Promise<Folder.Implementation[]>;
   }
 }

package/src/foundry/client/data/collections/compendium-packs.d.mts

@@ -1,9 +1,9 @@
-import type { DirectoryCollectionMixin_Collection_Interface } from "../abstract/directory-collection-mixin.d.mts";
-
-declare const DirectoryCollectionMixin_Collection: DirectoryCollectionMixin_Collection_Interface;
+export {};
 
 declare global {
-  class CompendiumPacks extends DirectoryCollectionMixin_Collection {
+  class CompendiumPacks extends DirectoryCollectionMixin(Collection)<
+    CompendiumCollection<CompendiumCollection.Metadata>
+  > {
     /**
      * Get a Collection of Folders which contain Compendium Packs
      */

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

@@ -1,11 +1,12 @@
-export {};
+import type { Identity } from "fvtt-types/utils";
+import type Document from "#common/abstract/document.d.mts";
 
 declare global {
   /**
    * The singleton collection of FogExploration documents which exist within the active World.
-   * @see {@link FogExploration} The FogExploration document
+   * @see {@link FogExploration | `FogExploration`} The FogExploration document
    */
-  class FogExplorations extends WorldCollection<typeof foundry.documents.BaseFogExploration, "FogExplorations"> {
+  class FogExplorations extends WorldCollection<FogExploration.ImplementationClass, "FogExplorations"> {
     static documentName: "FogExploration";
 
     /**
@@ -16,11 +17,14 @@ declare global {
   }
 
   namespace FogExplorations {
-    type Any = AnyFogExplorations;
-    type AnyConstructor = typeof AnyFogExplorations;
+    interface Any extends AnyFogExplorations {}
+    interface AnyConstructor extends Identity<typeof AnyFogExplorations> {}
+
+    interface ConfiguredClass extends Document.ConfiguredCollectionClass<"FogExploration"> {}
+    interface Configured extends Document.ConfiguredCollection<"FogExploration"> {}
   }
 }
 
 declare abstract class AnyFogExplorations extends FogExplorations {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

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

@@ -1,13 +1,15 @@
-import type { DatabaseAction, DatabaseOperationMap } from "../../../common/abstract/_types.d.mts";
+import type { Identity } from "fvtt-types/utils";
+import type { DatabaseAction, DatabaseOperationMap } from "#common/abstract/_types.d.mts";
+import type Document from "#common/abstract/document.d.mts";
 
 declare global {
   /**
    * The singleton collection of Folder documents which exist within the active World.
    * This Collection is accessible within the Game object as game.fog.
    *
-   * @see {@link Folder} The Folder document
+   * @see {@link Folder | `Folder`} The Folder document
    */
-  class Folders extends WorldCollection<typeof foundry.documents.BaseFolder, "Folders"> {
+  class Folders extends WorldCollection<Folder.ImplementationClass, "Folders"> {
     static documentName: "Folder";
 
     /**
@@ -17,10 +19,10 @@ declare global {
 
     _onModifyContents<A extends DatabaseAction>(
       action: A,
-      documents: Folder.ConfiguredInstance[],
-      result: foundry.documents.BaseFolder.UpdateData[] | readonly string[],
+      documents: readonly Folder.Implementation[],
+      result: readonly foundry.documents.BaseFolder.UpdateData[] | readonly string[],
       operation: DatabaseOperationMap[A],
-      user: User.ConfiguredInstance,
+      user: User.Implementation,
     ): void;
 
     /**
@@ -28,15 +30,18 @@ declare global {
      */
     protected _refreshJournalEntrySheets(): void;
 
-    render(force?: boolean, context?: ApplicationOptions): void;
+    render(force?: boolean, context?: Application.Options): void;
   }
 
   namespace Folders {
-    type Any = AnyFolders;
-    type AnyConstructor = typeof AnyFolders;
+    interface Any extends AnyFolders {}
+    interface AnyConstructor extends Identity<typeof AnyFolders> {}
+
+    interface ConfiguredClass extends Document.ConfiguredCollectionClass<"Folder"> {}
+    interface Configured extends Document.ConfiguredCollection<"Folder"> {}
   }
 }
 
 declare abstract class AnyFolders extends Folders {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

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

@@ -1,23 +1,27 @@
-export {};
+import type { Identity } from "fvtt-types/utils";
+import type Document from "#common/abstract/document.d.mts";
 
 declare global {
   /**
    * The singleton collection of Item documents which exist within the active World.
    * This Collection is accessible within the Game object as game.items.
    *
-   * @see {@link Item} The Item document
-   * @see {@link ItemDirectory} The ItemDirectory sidebar directory
+   * @see {@link Item | `Item`} The Item document
+   * @see {@link ItemDirectory | `ItemDirectory`} The ItemDirectory sidebar directory
    */
-  class Items extends WorldCollection<typeof foundry.documents.BaseItem, "Items"> {
+  class Items extends WorldCollection<Item.ImplementationClass, "Items"> {
     static documentName: "Item";
   }
 
   namespace Items {
-    type Any = AnyItems;
-    type AnyConstructor = typeof AnyItems;
+    interface Any extends AnyItems {}
+    interface AnyConstructor extends Identity<typeof AnyItems> {}
+
+    interface ConfiguredClass extends Document.ConfiguredCollectionClass<"Item"> {}
+    interface Configured extends Document.ConfiguredCollection<"Item"> {}
   }
 }
 
 declare abstract class AnyItems extends Items {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

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

@@ -1,21 +1,24 @@
-import type { InexactPartial } from "fvtt-types/utils";
+import type { InexactPartial, Identity } from "fvtt-types/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;
 
@@ -63,11 +66,14 @@ declare global {
   }
 
   namespace Journal {
-    type Any = AnyJournal;
-    type AnyConstructor = typeof AnyJournal;
+    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(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

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

@@ -1,41 +1,34 @@
-import type { InexactPartial } from "fvtt-types/utils";
+import type { Identity } from "fvtt-types/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 {
-    type Any = AnyMacros;
-    type AnyConstructor = typeof AnyMacros;
+    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(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

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

@@ -1,14 +1,15 @@
-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 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,17 +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 {
-    type Any = AnyMessages;
-    type AnyConstructor = typeof AnyMessages;
+    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(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }