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

package/src/foundry/client/data/abstract/directory-collection-mixin.d.mts

@@ -1,43 +1,25 @@
-import type { Mixin } from "../../../../types/utils.d.mts";
-import type Document from "../../../common/abstract/document.d.mts";
-
-type DirectoryCollectionMixin_DocumentCollection_Static = DirectoryCollection<DirectoryCollection.DirectoryTypes> &
-  DocumentCollection<Document.AnyConstructor, string>;
-
-export interface DirectoryCollectionMixin_DocumentCollection_Interface
-  extends DirectoryCollectionMixin_DocumentCollection_Static {
-  new <T extends Document.AnyConstructor, Name extends string>(
-    ...args: ConstructorParameters<typeof DocumentCollection>
-  ): DirectoryCollection<Document.ToConfiguredInstance<T>> & DocumentCollection<Document.ToConfiguredClass<T>, Name>;
-}
-
-type DirectoryCollectionMixin_Collection_Static = DirectoryCollection<DirectoryCollection.DirectoryTypes> &
-  Collection<CompendiumCollection<CompendiumCollection.Metadata>>;
-
-export interface DirectoryCollectionMixin_Collection_Interface extends DirectoryCollectionMixin_Collection_Static {
-  new (
-    ...args: ConstructorParameters<typeof Collection>
-  ): DirectoryCollection<CompendiumCollection<CompendiumCollection.Metadata>> &
-    Collection<CompendiumCollection<CompendiumCollection.Metadata>>;
-}
+import type { FixedInstanceType, Mixin } from "#utils";
 
 /**
  * An extension of the Collection class which adds behaviors specific to tree-based collections of entries and folders.
  */
-// TODO: T should probably extend a subset of documents | CompendiumCollection
-declare class DirectoryCollection<T extends DirectoryCollection.DirectoryTypes> {
-  /** @privateRemarks All mixin classses need a constructor like this */
+declare class DirectoryCollection {
+  /** @privateRemarks All mixin classes need a constructor like this */
   constructor(...args: any[]);
 
+  // Note(LukeAbby): This isn't really a property on this class but rather it exists on `Collection`.
+  // However since this is only used when merged with a Collection class, it's fine to define it here.
+  contents: readonly unknown[];
+
   /**
    * Reference the set of Folders which contain documents in this collection
    */
-  get folders(): Collection<Folder.Stored>;
+  get folders(): Collection<Folder.Stored, Collection.Methods.Any>;
 
   /**
    * The built tree structure of the DocumentCollection
    */
-  get tree(): DirectoryCollection.TreeNode<T>;
+  get tree(): DirectoryCollectionMixin.TreeNode<this["contents"]>;
 
   /**
    * The current search mode for this collection
@@ -69,7 +51,7 @@ declare class DirectoryCollection<T extends DirectoryCollection.DirectoryTypes>
   /**
    * Return a reference to list of entries which are visible to the User in this tree
    */
-  protected _getVisibleTreeContents(): T[];
+  protected _getVisibleTreeContents(): this["contents"];
 
   /**
    * Initialize the tree by categorizing folders and entries into a hierarchical tree structure.
@@ -89,8 +71,8 @@ declare class DirectoryCollection<T extends DirectoryCollection.DirectoryTypes>
    * @returns The sort order between entries a and b
    */
   protected static _sortAlphabetical(
-    a: DirectoryCollection.AlphabeticalSortEntry,
-    b: DirectoryCollection.AlphabeticalSortEntry,
+    a: DirectoryCollectionMixin.AlphabeticalSortEntry,
+    b: DirectoryCollectionMixin.AlphabeticalSortEntry,
   ): number;
 
   /**
@@ -100,8 +82,8 @@ declare class DirectoryCollection<T extends DirectoryCollection.DirectoryTypes>
    * @returns The sort order between Entries a and b
    */
   protected static _sortStandard(
-    a: DirectoryCollection.StandardSortEntry,
-    b: DirectoryCollection.StandardSortEntry,
+    a: DirectoryCollectionMixin.StandardSortEntry,
+    b: DirectoryCollectionMixin.StandardSortEntry,
   ): number;
 }
 
@@ -111,20 +93,22 @@ declare global {
    * @param BaseCollection - The base collection class to extend
    * @returns A Collection mixed with DirectoryCollection functionality
    */
-  function DirectoryCollectionMixin<
-    T extends DirectoryCollection.DirectoryTypes,
-    BaseCollection extends foundry.utils.Collection.AnyConstructor,
-  >(BaseCollection: BaseCollection): Mixin<typeof DirectoryCollection<T>, BaseCollection>;
+  function DirectoryCollectionMixin<BaseCollection extends foundry.utils.Collection.AnyConstructor>(
+    BaseCollection: BaseCollection,
+  ): Mixin<typeof DirectoryCollection, BaseCollection>;
+
+  namespace DirectoryCollectionMixin {
+    interface AnyMixedConstructor
+      extends ReturnType<typeof DirectoryCollectionMixin<foundry.utils.Collection.AnyConstructor>> {}
+    interface AnyMixed extends FixedInstanceType<AnyMixedConstructor> {}
 
-  namespace DirectoryCollection {
-    // TODO: Refine type based on CONST.FOLDER_DOCUMENT_TYPES
-    type DirectoryTypes = object;
+    type BaseClass = foundry.utils.Collection.AnyConstructor;
 
     interface TreeNode<T> {
       children: TreeNode<T>[];
       depth: number;
       entries: T[];
-      folder: Folder;
+      folder: Folder.Implementation;
       root: boolean;
       visible: boolean;
     }

package/src/foundry/client/data/abstract/document-collection.d.mts

@@ -1,26 +1,32 @@
-import type { AnyObject, DeepPartial, InexactPartial } from "../../../../types/utils.d.mts";
-import type { DatabaseAction, DatabaseOperationMap } from "../../../common/abstract/_types.d.mts";
+import type { AnyObject, DeepPartial, InexactPartial, FixedInstanceType } from "#utils";
+import type {
+  DatabaseAction,
+  DatabaseOperationMap,
+  DatabaseUpdateOperation,
+} from "../../../common/abstract/_types.d.mts";
 import type Document from "../../../common/abstract/document.d.mts";
 
 declare global {
   /**
    * An abstract subclass of the Collection container which defines a collection of Document instances.
    */
-  class DocumentCollection<T extends Document.AnyConstructor, Name extends string> extends foundry.utils.Collection<
-    Document.ToConfiguredStored<T>
-  > {
-    constructor(data: InstanceType<T>["_source"][]);
+  class DocumentCollection<
+    DocumentClass extends Document.AnyConstructor,
+    Name extends string,
+    Methods extends Collection.Methods.Any = DocumentCollection.Methods<DocumentClass>,
+  > extends foundry.utils.Collection<Document.ToStored<DocumentClass>, Methods> {
+    constructor(data: FixedInstanceType<DocumentClass>["_source"][]);
 
     /**
      * The source data array from which the Documents in the WorldCollection are created
      */
-    _source: InstanceType<T>["_source"][];
+    _source: FixedInstanceType<DocumentClass>["_source"][];
 
     /**
      * An Array of application references which will be automatically updated when the collection content changes
      * @defaultValue `[]`
      */
-    apps: Application[];
+    apps: Application.Any[];
 
     /**
      * Initialize the DocumentCollection by constructing any initially provided Document instances
@@ -31,13 +37,13 @@ declare global {
     /**
      * A reference to the Document class definition which is contained within this DocumentCollection.
      */
-    get documentClass(): Document.ToConfiguredClass<T>;
+    get documentClass(): DocumentClass;
 
     /**
      * A reference to the named Document class which is contained within this DocumentCollection.
      * @remarks This accessor is abstract: A subclass of DocumentCollection must implement the documentName getter
      */
-    get documentName(): Document.ToConfiguredClass<T>["metadata"]["name"];
+    get documentName(): DocumentClass["metadata"]["name"];
 
     /**
      * The base Document type which is contained within this DocumentCollection
@@ -60,9 +66,10 @@ declare global {
      * @param context - Document creation context
      */
     createDocument(
-      data: Document.ConstructorDataFor<T>,
-      context: Document.ConstructionContext<InstanceType<T>>,
-    ): Document.ToConfiguredInstance<T>;
+      data: Document.CreateDataFor<DocumentClass>,
+      // TODO: Should be `Document.ParentOf<T>` or some equivalent.
+      context: Document.ConstructionContext<Document.Any | null>,
+    ): DocumentClass;
 
     /**
      * Obtain a temporary Document instance for a document id which currently has invalid source data.
@@ -73,36 +80,15 @@ declare global {
      */
     getInvalid(
       id: string,
-      options?: InexactPartial<{
-        /**
-         * Throw an Error if the requested ID is not in the set of invalid IDs for this collection.
-         */
-        strict: boolean;
-      }>,
-    ): unknown;
-
-    get(
-      key: string,
-      options?: InexactPartial<{
-        /**
-         * Throw an Error if the requested Embedded Document does not exist.
-         * @defaultValue `false`
-         */
-        strict: false;
-        /**
-         * Allow retrieving an invalid Embedded Document.
-         * @defaultValue `false`
-         */
-        invalid: false;
-      }>,
-    ): Document.ToConfiguredStored<T> | undefined;
-    get(key: string, options: { strict: true; invalid?: false }): Document.ToConfiguredStored<T>;
-    get(key: string, options: { strict?: boolean; invalid: true }): unknown;
+      options?: DocumentCollection.GetInvalidOptions,
+    ): Document.Invalid<FixedInstanceType<DocumentClass>>;
+
+    get: Methods["get"];
 
     /**
      * @remarks The parameter `id` is ignored, instead `document.id` is used as the key.
      */
-    set(id: string, document: Document.ToConfiguredStored<T>): this;
+    set(id: string, document: Document.ToStored<DocumentClass>): this;
 
     /** @remarks Actually returns void */
     delete: (id: string) => boolean;
@@ -110,7 +96,7 @@ declare global {
     /**
      * Render any Applications associated with this DocumentCollection.
      */
-    render(force?: boolean, options?: ApplicationOptions): void;
+    render(force?: boolean, options?: Application.Options): void;
 
     /**
      * Get the searchable fields for a given document or index, based on its data model
@@ -131,25 +117,7 @@ declare global {
      * If filters are provided, results are filtered to only those that match the provided values.
      * @param search   - An object configuring the search
      */
-    search(
-      search?: InexactPartial<{
-        /**
-         * A case-insensitive search string
-         * @defaultValue `""`
-         */
-        query: string;
-        /**
-         * An array of filters to apply
-         * @defaultValue `[]`
-         */
-        filters: FieldFilter[];
-        /**
-         * An array of document IDs to exclude from search results
-         * @defaultValue `[]`
-         */
-        exclude: string[];
-      }>,
-    ): Document.ToConfiguredInstance<T>[];
+    search(search?: DocumentCollection.SearchOptions): FixedInstanceType<DocumentClass>[];
 
     /**
      * Update all objects in this DocumentCollection with a provided transformation.
@@ -162,9 +130,11 @@ declare global {
      * @returns An array of updated data once the operation is complete
      */
     updateAll(
-      transformation: Document.UpdateDataFor<T> | ((doc: Document.ToConfiguredStored<T>) => Document.UpdateDataFor<T>),
-      condition?: ((obj: Document.ToConfiguredStored<T>) => boolean) | null,
-      options?: Document.OnUpdateOptions<T["metadata"]["name"]>,
+      transformation:
+        | Document.UpdateDataFor<DocumentClass>
+        | ((doc: Document.ToStored<DocumentClass>) => Document.UpdateDataFor<DocumentClass>),
+      condition?: ((obj: Document.ToStored<DocumentClass>) => boolean) | null,
+      options?: Document.Database.UpdateDocumentsOperation<DatabaseUpdateOperation>,
     ): ReturnType<this["documentClass"]["updateDocuments"]>;
 
     /**
@@ -177,15 +147,22 @@ declare global {
      */
     _onModifyContents<A extends DatabaseAction>(
       action: A,
-      documents: InstanceType<T>[],
-      result: AnyObject[] | readonly string[],
+      documents: Document.ToStored<DocumentClass>[],
+      result: readonly AnyObject[] | readonly string[],
       operation: DatabaseOperationMap[A],
-      user: User.ConfiguredInstance,
+      user: User.Implementation,
     ): void;
   }
 
   namespace DocumentCollection {
-    type Any = DocumentCollection<any, any>;
+    interface Any extends DocumentCollection<Document.AnyConstructor, string> {}
+
+    interface Methods<T extends Document.AnyConstructor> {
+      get<Options extends DocumentCollection.GetOptions>(
+        key: string,
+        options?: Options,
+      ): DocumentCollection.GetReturnType<T, Options>;
+    }
 
     namespace RenderContext {
       interface Base<T extends Document.AnyConstructor> {
@@ -201,12 +178,12 @@ declare global {
 
       interface Create<T extends Document.AnyConstructor> extends Base<T> {
         action: "create";
-        data: (InstanceType<T>["_source"] & { _id: string })[];
+        data: (FixedInstanceType<T>["_source"] & { _id: string })[];
       }
 
       interface Update<T extends Document.AnyConstructor> extends Base<T> {
         action: "update";
-        data: (DeepPartial<InstanceType<T>["_source"]> & { _id: string })[];
+        data: (DeepPartial<FixedInstanceType<T>["_source"]> & { _id: string })[];
       }
 
       interface Delete<T extends Document.AnyConstructor> extends Base<T> {
@@ -214,5 +191,56 @@ declare global {
         data: string[];
       }
     }
+
+    /** @internal */
+    interface _SearchOptions {
+      /**
+       * A case-insensitive search string
+       * @defaultValue `""`
+       */
+      query: string;
+
+      /**
+       * An array of filters to apply
+       * @defaultValue `[]`
+       */
+      filters: SearchFilter.FieldFilter[];
+
+      /**
+       * An array of document IDs to exclude from search results
+       * @defaultValue `[]`
+       */
+      exclude: string[];
+    }
+
+    interface SearchOptions extends InexactPartial<_SearchOptions> {}
+
+    interface GetInvalidOptions {
+      /**
+       * Throw an Error if the requested ID is not in the set of invalid IDs for this collection.
+       */
+      strict?: boolean | undefined;
+    }
+
+    interface GetOptions extends Collection.GetOptions {
+      /**
+       * Allow retrieving an invalid Embedded Document.
+       * @defaultValue `false`
+       */
+      invalid?: boolean | undefined;
+    }
+
+    type GetReturnType<
+      ConcreteDocument extends Document.AnyConstructor,
+      Options extends GetOptions,
+    > = Collection.GetReturnType<_ApplyInvalid<FixedInstanceType<ConcreteDocument>, Options["invalid"]>, Options>;
+
+    /** @internal */
+    type _ApplyInvalid<
+      ConcreteDocument extends Document.Any,
+      Invalid extends boolean | undefined,
+    > = Invalid extends true
+      ? Document.Invalid<ConcreteDocument> | Document.Stored<ConcreteDocument>
+      : Document.Stored<ConcreteDocument>;
   }
 }

package/src/foundry/client/data/abstract/world-collection.d.mts

@@ -1,19 +1,17 @@
-import type { DeepPartial, InexactPartial } from "../../../../types/utils.d.mts";
+import type { DeepPartial, DropFirst, FixedInstanceType, GetKey, Identity, InexactPartial } from "#utils";
 import type Document from "../../../common/abstract/document.d.mts";
-import type { DirectoryCollectionMixin_DocumentCollection_Interface } from "./directory-collection-mixin.d.mts";
-
-declare const DirectoryCollectionMixin_DocumentCollection: DirectoryCollectionMixin_DocumentCollection_Interface;
+import type { DatabaseCreateOperation } from "../../../common/abstract/_types.d.mts";
 
 declare global {
   /**
    * A collection of world-level Document objects with a singleton instance per primary Document type.
    * Each primary Document type has an associated subclass of WorldCollection which contains them.
-   * @see {@link Game#collections}
+   * @see {@link Game.collections | `Game#collections`}
    */
   abstract class WorldCollection<
-    T extends Document.AnyConstructor,
+    DocumentClass extends Document.AnyConstructor,
     Name extends string,
-  > extends DirectoryCollectionMixin_DocumentCollection<T, Name> {
+  > extends DirectoryCollectionMixin(DocumentCollection)<DocumentClass, Name> {
     /**
      * Reference the set of Folders which contain documents in this collection
      */
@@ -22,14 +20,14 @@ declare global {
     /**
      * Return a reference to the SidebarDirectory application for this WorldCollection.
      * @remarks
-     * In the case where `Lowercase<Name>` is not a property of {@link ui}, this actually always returns `undefined`,
-     * but {@link RollTables} overrides this, so we need to allow a wider return type.
+     * In the case where `Lowercase<Name>` is not a property of {@link ui | `ui`}, this actually always returns `undefined`,
+     * but {@link RollTables | `RollTables`} overrides this, so we need to allow a wider return type.
      */
     get directory(): Lowercase<Name> extends keyof typeof ui
       ? (typeof ui)[Lowercase<Name>]
       :
-          | (Document.ToConfiguredClass<T>["metadata"]["name"] extends foundry.CONST.FOLDER_DOCUMENT_TYPES
-              ? DocumentDirectory<Document.ToConfiguredClass<T>["metadata"]["name"]>
+          | (DocumentClass["metadata"]["name"] extends foundry.CONST.FOLDER_DOCUMENT_TYPES
+              ? DocumentDirectory<DocumentClass["metadata"]["name"]>
               : never)
           | SidebarTab
           | undefined
@@ -40,7 +38,9 @@ declare global {
      */
     static get instance(): WorldCollection<Document.AnyConstructor, any>; // TODO: Find a way to type this more concretely. One option would be to separate the static and non static side of this class, which allows accessing the the static this type to use the `documentName`.
 
-    protected override _getVisibleTreeContents(): Document.ToConfiguredInstance<T>[];
+    // Note(LukeAbby): Due to the usage of `this["contents"]` in the parent class the override has
+    // to stay like this.
+    protected override _getVisibleTreeContents(): this["contents"];
 
     /**
      * Import a Document from a Compendium collection, adding it to the current World.
@@ -48,7 +48,7 @@ declare global {
      * @param id         - The ID of the compendium entry to import
      * @param updateData - Optional additional data used to modify the imported Document before it is created
      *                     (default: `{}`)
-     * @param options    - Optional arguments passed to the {@link WorldCollection#fromCompendium} and {@link Document.create} methods
+     * @param options    - Optional arguments passed to the {@link WorldCollection.fromCompendium | `WorldCollection.fromCompendium`} and {@link Document.create | `Document.create`} methods
      *                     (default: `{}`)
      * @returns The imported Document instance
      */
@@ -61,13 +61,13 @@ declare global {
      * DatabaseCreateOperation but the foundry typedef doesn't have them).
      */
     importFromCompendium(
-      pack: CompendiumCollection<
-        CompendiumCollection.Metadata & { type: Document.ToConfiguredClass<T>["metadata"]["name"] }
-      >,
+      pack: CompendiumCollection<CompendiumCollection.Metadata & { type: DocumentClass["metadata"]["name"] }>,
       id: string,
-      updateData?: DeepPartial<Document.ToConfiguredInstance<T>["_source"]>,
-      options?: InexactPartial<Document.OnCreateOptions<T["metadata"]["name"]> & WorldCollection.FromCompendiumOptions>,
-    ): Promise<Document.ToConfiguredStored<T>>;
+      updateData?: DeepPartial<FixedInstanceType<DocumentClass>["_source"]>,
+      options?: InexactPartial<
+        Document.Database.CreateOperation<DatabaseCreateOperation> & WorldCollection.FromCompendiumOptions
+      >,
+    ): Promise<Document.ToStored<DocumentClass>>;
 
     /**
      * Apply data transformations when importing a Document from a Compendium pack
@@ -77,26 +77,15 @@ declare global {
      * @returns The processed data ready for world Document creation
      * @remarks FromCompendiumOptions is inflated to account for expanded downstream use
      */
-    fromCompendium<
-      FolderOpt extends boolean = false,
-      SortOpt extends boolean = true,
-      OwnershipOpt extends boolean = false,
-      IdOpt extends boolean = false,
-    >(
-      document: Document.ToConfiguredInstance<T> | Document.ConstructorDataFor<T>,
-      options?: InexactPartial<WorldCollection.FromCompendiumOptions<FolderOpt, SortOpt, OwnershipOpt, IdOpt>>,
-    ): Omit<
-      Document.ToConfiguredInstance<T>["_source"],
-      | ClientDocument.OmitProperty<FolderOpt, "folder">
-      | ClientDocument.OmitProperty<SortOpt, "sort" | "navigation" | "navOrder">
-      | ClientDocument.OmitProperty<OwnershipOpt, "ownership">
-      | (IdOpt extends false ? "_id" : never)
-    >;
+    fromCompendium<Options extends WorldCollection.FromCompendiumOptions | undefined>(
+      document: FixedInstanceType<DocumentClass> | Document.CreateDataFor<DocumentClass>,
+      options?: Options,
+    ): WorldCollection.FromCompendiumReturnType<DocumentClass, Options>;
 
     /**
      * Register a Document sheet class as a candidate which can be used to display Documents of a given type.
-     * See {@link DocumentSheetConfig.registerSheet} for details.
-     * @see DocumentSheetConfig.registerSheet
+     * See {@link DocumentSheetConfig.registerSheet | `DocumentSheetConfig.registerSheet`} for details.
+     * @see {@link DocumentSheetConfig.registerSheet | `DocumentSheetConfig.registerSheet`}
      *
      * @example <caption>Register a new ActorSheet subclass for use with certain Actor types.</caption>
      * ```typescript
@@ -107,8 +96,8 @@ declare global {
 
     /**
      * Unregister a Document sheet class, removing it from the list of available sheet Applications to use.
-     * See {@link DocumentSheetConfig.unregisterSheet} for details.
-     * @see DocumentSheetConfig.unregisterSheet
+     * See {@link DocumentSheetConfig.unregisterSheet | `DocumentSheetConfig.unregisterSheet`} for details.
+     * @see {@link DocumentSheetConfig.unregisterSheet | `DocumentSheetConfig.unregisterSheet`}
      *
      * @example <caption>Deregister the default ActorSheet subclass to replace it with others.</caption>
      * Actors.unregisterSheet("core", ActorSheet);
@@ -118,48 +107,58 @@ declare global {
     /**
      * Return an array of currently registered sheet classes for this Document type.
      * @remarks
-     * This is documented to return only {@link DocumentSheet}s but {@link DrawingConfig} is just a
-     * {@link FormApplication}. See https://gitlab.com/foundrynet/foundryvtt/-/issues/6454.
+     * This is documented to return only {@link DocumentSheet | `DocumentSheet`}s but {@link DrawingConfig | `DrawingConfig`} is just a
+     * {@link FormApplication | `FormApplication`}. See https://gitlab.com/foundrynet/foundryvtt/-/issues/6454.
      */
-    static get registeredSheets(): FormApplication[];
+    static get registeredSheets(): FormApplication.Any[];
   }
 
   namespace WorldCollection {
-    interface FromCompendiumOptions<
-      FolderOpt extends boolean = false,
-      SortOpt extends boolean = true,
-      OwnershipOpt extends boolean = false,
-      IdOpt extends boolean = false,
-      StateOpt extends boolean = false,
-    > {
+    interface Any extends AnyWorldCollection {}
+    interface AnyConstructor extends Identity<typeof AnyWorldCollection> {}
+
+    interface FromCompendiumOptions {
       /**
        * Clear the currently assigned folder
        * @defaultValue `false`
        */
-      clearFolder: FolderOpt;
+      clearFolder?: boolean | undefined;
 
       /**
        * Clear the currently sort order
        * @defaultValue `true`
        */
-      clearSort: SortOpt;
+      clearSort?: boolean | undefined;
 
       /**
        * Clear Document ownership
        * @defaultValue `true`
        */
-      clearOwnership: OwnershipOpt;
+      clearOwnership?: boolean | undefined;
 
       /**
        * Retain the Document ID from the source Compendium
        * @defaultValue `false`
        */
-      keepId: IdOpt;
+      keepId?: boolean | undefined;
 
       /** @remarks used by Scenes#fromCompendium */
-      clearState: StateOpt;
+      clearState?: boolean | undefined;
     }
+
+    type FromCompendiumReturnType<
+      DocumentClass extends Document.AnyConstructor,
+      Options extends FromCompendiumOptions | undefined,
+    > = Omit<
+      FixedInstanceType<DocumentClass>["_source"],
+      | ClientDocument._OmitProperty<GetKey<Options, "clearFolder", undefined>, false, "folder">
+      | ClientDocument._OmitProperty<GetKey<Options, "clearSort", undefined>, true, "sort" | "navigation" | "navOrder">
+      | ClientDocument._OmitProperty<GetKey<Options, "clearOwnership", undefined>, true, "ownership">
+      | (GetKey<Options, "keepId", undefined> extends true ? never : never)
+    >;
   }
 }
 
-type DropFirst<T extends Array<unknown>> = T extends [unknown, ...infer V] ? V : T;
+declare abstract class AnyWorldCollection extends WorldCollection<Document.AnyConstructor, string> {
+  constructor(...args: never[]);
+}

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

@@ -1,49 +1,51 @@
-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 Actor documents which exist within the active World.
    * This Collection is accessible within the Game object as game.actors.
    *
-   * @see {@link Actor} The Actor document
-   * @see {@link ActorDirectory} The ActorDirectory sidebar directory
+   * @see {@link Actor | `Actor`} The Actor document
+   * @see {@link ActorDirectory | `ActorDirectory`} The ActorDirectory sidebar directory
    *
    * @example <caption>Retrieve an existing Actor by its id</caption>
    * ```typescript
    * let actor = game.actors.get(actorId);
    * ```
    */
-  class Actors extends WorldCollection<typeof foundry.documents.BaseActor, "Actors"> {
+  class Actors extends WorldCollection<Actor.ImplementationClass, "Actors"> {
     /**
      * A mapping of synthetic Token Actors which are currently active within the viewed Scene.
      * Each Actor is referenced by the Token.id.
      */
-    get tokens(): Partial<Record<string, Actor.ConfiguredInstance>>;
+    get tokens(): Partial<Record<string, Actor.Implementation>>;
 
     static documentName: "Actor";
 
-    override fromCompendium<
-      FolderOpt extends boolean = false,
-      SortOpt extends boolean = true,
-      OwnershipOpt extends boolean = false,
-      IdOpt extends boolean = false,
-    >(
-      document: Actor.ConfiguredInstance | foundry.documents.BaseActor.ConstructorData,
-      options?: InexactPartial<
-        WorldCollection.FromCompendiumOptions<FolderOpt, SortOpt, OwnershipOpt, IdOpt> & {
-          /**
-           * Clear prototype token data to allow default token settings to be applied.
-           * @defaultValue `true`
-           */
-          clearPrototypeToken: boolean;
-        }
-      >,
-    ): Omit<
-      Actor["_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: Actor.Implementation | foundry.documents.BaseActor.CreateData,
+      options?: Options,
+    ): WorldCollection.FromCompendiumReturnType<Actor.ImplementationClass, Options>;
   }
+
+  namespace Actors {
+    interface Any extends AnyActors {}
+    interface AnyConstructor extends Identity<typeof AnyActors> {}
+
+    interface ConfiguredClass extends Document.ConfiguredCollectionClass<"Actor"> {}
+    interface Configured extends Document.ConfiguredCollection<"Actor"> {}
+
+    interface FromCompendiumOptions extends WorldCollection.FromCompendiumOptions {
+      /**
+       * Clear prototype token data to allow default token settings to be applied.
+       * @defaultValue `true`
+       */
+      clearPrototypeToken: boolean;
+    }
+  }
+}
+
+declare abstract class AnyActors extends Actors {
+  constructor(...args: never);
 }