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

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

@@ -1,20 +1,22 @@
 import type { AnyObject, DeepPartial, InexactPartial, FixedInstanceType } from "fvtt-types/utils";
-import type { DatabaseAction, DatabaseOperationMap } from "../../../common/abstract/_types.d.mts";
-import type Document from "../../../common/abstract/document.d.mts";
+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: FixedInstanceType<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: FixedInstanceType<T>["_source"][];
+    _source: FixedInstanceType<DocumentClass>["_source"][];
 
     /**
      * An Array of application references which will be automatically updated when the collection content changes
@@ -31,13 +33,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 +62,10 @@ declare global {
      * @param context - Document creation context
      */
     createDocument(
-      data: Document.ConstructorDataFor<T>,
-      context: Document.ConstructionContext<FixedInstanceType<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 +76,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 +92,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 +113,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 +126,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 +143,22 @@ declare global {
      */
     _onModifyContents<A extends DatabaseAction>(
       action: A,
-      documents: FixedInstanceType<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> {
@@ -214,5 +187,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, DropFirst, InexactPartial } from "fvtt-types/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 { DeepPartial, DropFirst, FixedInstanceType, GetKey, InexactPartial } from "fvtt-types/utils";
+import type Document from "#common/abstract/document.d.mts";
+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,46 +107,51 @@ 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.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 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)
+    >;
   }
 }

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

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

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

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

package/src/foundry/client/data/collections/combats.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 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";
 
     /**
@@ -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
@@ -42,11 +43,14 @@ declare global {
   }
 
   namespace CombatEncounters {
-    type Any = AnyCombatEncounters;
-    type AnyConstructor = typeof AnyCombatEncounters;
+    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(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }