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

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

@@ -1,12 +1,25 @@
-export {};
+import type { Identity } from "#utils";
+import type Document from "../../../common/abstract/document.d.mts";
 
 declare global {
   /**
    * The collection of Cards documents which exist within the active World.
    * This Collection is accessible within the Game object as game.cards.
-   * @see {@link Cards} The Cards document
+   * @see {@link Cards | `Cards`} The Cards document
    */
-  class CardStacks extends WorldCollection<typeof foundry.documents.BaseCards, "Cards"> {
+  class CardStacks extends WorldCollection<Cards.ImplementationClass, "Cards"> {
     static documentName: "Cards";
   }
+
+  namespace CardStacks {
+    interface Any extends AnyCardStacks {}
+    interface AnyConstructor extends Identity<typeof AnyCardStacks> {}
+
+    interface ConfiguredClass extends Document.ConfiguredCollectionClass<"Cards"> {}
+    interface Configured extends Document.ConfiguredCollection<"Cards"> {}
+  }
+}
+
+declare abstract class AnyCardStacks extends CardStacks {
+  constructor(...args: never);
 }

package/src/foundry/client/data/collections/combats.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 Combat documents which exist within the active World.
    * This Collection is accessible within the Game object as game.combats.
    *
-   * @see {@link Combat} The Combat document
-   * @see {@link CombatTracker} The CombatTracker sidebar directory
+   * @see {@link Combat | `Combat`} The Combat document
+   * @see {@link CombatTracker | `CombatTracker`} The CombatTracker sidebar directory
    */
-  class CombatEncounters extends WorldCollection<typeof foundry.documents.BaseCombat, "CombatEncounters"> {
+  class CombatEncounters extends WorldCollection<Combat.ImplementationClass, "CombatEncounters"> {
     static documentName: "Combat";
 
     /**
@@ -16,7 +17,7 @@ declare global {
      */
     static get settings(): ClientSettings.SettingInitializedType<"core", Combat.CONFIG_SETTING>;
 
-    override get directory(): (typeof ui)["combat"];
+    override get directory(): typeof ui.combat;
 
     /**
      * Get an Array of Combat instances which apply to the current canvas scene
@@ -31,7 +32,7 @@ declare global {
     /**
      * The currently viewed Combat encounter
      */
-    get viewed(): Document.Stored<Combat.ConfiguredInstance> | null;
+    get viewed(): Combat.Stored | null;
 
     /**
      * When a Token is deleted, remove it as a combatant from any combat encounters which included the Token
@@ -40,4 +41,16 @@ declare global {
      */
     protected _onDeleteToken(sceneId: string, tokenId: string): Promise<void>;
   }
+
+  namespace CombatEncounters {
+    interface Any extends AnyCombatEncounters {}
+    interface AnyConstructor extends Identity<typeof AnyCombatEncounters> {}
+
+    interface ConfiguredClass extends Document.ConfiguredCollectionClass<"Combat"> {}
+    interface Configured extends Document.ConfiguredCollection<"Combat"> {}
+  }
+}
+
+declare abstract class AnyCombatEncounters extends CombatEncounters {
+  constructor(...args: never);
 }

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

@@ -1,61 +1,34 @@
-import type { DeepPartial, EmptyObject, InexactPartial } from "../../../../types/utils.d.mts";
-import type {
-  DatabaseCreateOperation,
-  DatabaseDeleteOperation,
-  DatabaseUpdateOperation,
-} from "../../../common/abstract/_types.d.mts";
+import type { DeepPartial, EmptyObject, InexactPartial } from "#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 { 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>;
 
     /**
@@ -102,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
@@ -118,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;
@@ -155,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;
 
@@ -173,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.
@@ -196,16 +172,15 @@ 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
+     * @param user - The user being tested (default: `game.user`)
+     * @returns The ownership level in {@link CONST.DOCUMENT_OWNERSHIP_LEVELS | `CONST.DOCUMENT_OWNERSHIP_LEVELS`}
      */
-    getUserLevel(user?: User): foundry.CONST.DOCUMENT_OWNERSHIP_LEVELS;
+    // user: not null (parameter default only)
+    getUserLevel(user?: User.Implementation): CONST.DOCUMENT_OWNERSHIP_LEVELS;
 
     /**
      * Test whether a certain User has a requested permission level (or greater) over the Compendium pack
@@ -215,7 +190,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<{
         /**
@@ -229,14 +204,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.
@@ -244,7 +219,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
@@ -260,7 +235,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
@@ -273,7 +248,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
      */
@@ -290,10 +265,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.
@@ -304,14 +279,14 @@ declare global {
      *          null if the dialog was closed without making a choice.
      */
     importDialog(
-      options?: DialogOptions,
-    ): Promise<Document.Stored<Document.ConfiguredInstanceForName<T["type"]>>[] | null | false>;
+      options?: Dialog.Options,
+    ): 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.
@@ -330,12 +305,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>>;
 
     /**
@@ -374,33 +349,7 @@ declare global {
      */
     migrate(): Promise<this>;
 
-    // Note(LukeAbby): The override for `updateAll` become unreasonably long and don't add any changes and so has been omitted.
-
-    /**
-     * Follow-up actions taken when Documents within this Compendium pack are modified
-     * @internal
-     */
-    _onModifyContents(
-      action: "create",
-      documents: ClientDocument[],
-      result: Record<string, unknown>[],
-      operation: DatabaseCreateOperation<Document.ConfiguredInstanceForName<T["type"]>>,
-      user: User,
-    ): void;
-    _onModifyContents(
-      action: "update",
-      documents: ClientDocument[],
-      result: Record<string, unknown>[],
-      operation: DatabaseUpdateOperation<Document.ConfiguredInstanceForName<T["type"]>>,
-      user: User,
-    ): void;
-    _onModifyContents(
-      action: "delete",
-      documents: ClientDocument[],
-      result: string[],
-      operation: DatabaseDeleteOperation,
-      user: User,
-    ): void;
+    // Note(LukeAbby): The override for `updateAll` and `_onModifyContents` become unreasonably long and don't add any changes and so has been omitted.
 
     /**
      * @deprecated since v11, will be removed in v13
@@ -416,7 +365,7 @@ declare global {
   }
 
   namespace CompendiumCollection {
-    type Any = CompendiumCollection<any>;
+    interface Any extends CompendiumCollection<any> {}
 
     interface Configuration {
       ownership: InexactPartial<foundry.packages.BasePackage.OwnershipRecord>;
@@ -433,7 +382,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.
@@ -459,13 +408,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;
+    }
   }
 }
 
@@ -481,7 +464,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
      */
@@ -18,7 +18,7 @@ declare global {
   }
 
   namespace CompendiumPacks {
-    interface AlphabeticalSortEntry extends DirectoryCollection.AlphabeticalSortEntry {
+    interface AlphabeticalSortEntry extends DirectoryCollectionMixin.AlphabeticalSortEntry {
       metadata?: {
         label: string;
       };

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

@@ -1,11 +1,12 @@
-export {};
+import type { Identity } from "#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";
 
     /**
@@ -14,4 +15,16 @@ declare global {
      */
     static _activateSocketListeners(socket: Game["socket"]): void;
   }
+
+  namespace FogExplorations {
+    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(...args: never);
 }

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

@@ -1,13 +1,15 @@
+import type { Identity } from "#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,6 +30,18 @@ declare global {
      */
     protected _refreshJournalEntrySheets(): void;
 
-    render(force?: boolean, context?: ApplicationOptions): void;
+    render(force?: boolean, context?: Application.Options): void;
   }
+
+  namespace Folders {
+    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(...args: never);
 }

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

@@ -1,14 +1,27 @@
-export {};
+import type { Identity } from "#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 {
+    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(...args: never);
 }