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

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

@@ -1,119 +0,0 @@
-import type { FixedInstanceType, Mixin } from "fvtt-types/utils";
-
-/**
- * An extension of the Collection class which adds behaviors specific to tree-based collections of entries and folders.
- */
-declare class DirectoryCollection {
-  /** @privateRemarks All mixin classses 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, Collection.Methods.Any>;
-
-  /**
-   * The built tree structure of the DocumentCollection
-   */
-  get tree(): DirectoryCollectionMixin.TreeNode<this["contents"]>;
-
-  /**
-   * The current search mode for this collection
-   */
-  get searchMode(): foundry.CONST.DIRECTORY_SEARCH_MODES;
-
-  /**
-   * Toggle the search mode for this collection between "name" and "full" text search
-   */
-  toggleSearchMode(): void;
-
-  /**
-   * The current sort mode used to order the top level entries in this collection
-   */
-  // TODO: Should have a helper type for these sorting modes or something
-  get sortingMode(): "m" | "a";
-
-  /**
-   * Toggle the sorting mode for this collection between "a" (Alphabetical) and "m" (Manual by sort property)
-   */
-  toggleSortingMode(): void;
-
-  /**
-   * The maximum depth of folder nesting which is allowed in this collection
-   * @defaultValue `CONST.FOLDER_MAX_DEPTH`
-   */
-  get maxFolderDepth(): number;
-
-  /**
-   * Return a reference to list of entries which are visible to the User in this tree
-   */
-  protected _getVisibleTreeContents(): this["contents"];
-
-  /**
-   * Initialize the tree by categorizing folders and entries into a hierarchical tree structure.
-   */
-  initializeTree(): void;
-
-  /**
-   * Creates the list of Folder options in this Collection in hierarchical order
-   * for populating the options of a select tag.
-   */
-  protected _formatFolderSelectOptions(): { id: string; name: string }[];
-
-  /**
-   * Sort two Entries by name, alphabetically.
-   * @param a - Some Entry
-   * @param b - Some other Entry
-   * @returns The sort order between entries a and b
-   */
-  protected static _sortAlphabetical(
-    a: DirectoryCollectionMixin.AlphabeticalSortEntry,
-    b: DirectoryCollectionMixin.AlphabeticalSortEntry,
-  ): number;
-
-  /**
-   * Sort two Entries using their numeric sort fields.
-   * @param a - Some Entry
-   * @param b - Some other Entry
-   * @returns The sort order between Entries a and b
-   */
-  protected static _sortStandard(
-    a: DirectoryCollectionMixin.StandardSortEntry,
-    b: DirectoryCollectionMixin.StandardSortEntry,
-  ): number;
-}
-
-declare global {
-  /**
-   * A mixin which adds directory functionality to a DocumentCollection, such as folders, tree structures, and sorting.
-   * @param BaseCollection - The base collection class to extend
-   * @returns A Collection mixed with DirectoryCollection functionality
-   */
-  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> {}
-
-    type BaseClass = foundry.utils.Collection.AnyConstructor;
-
-    interface TreeNode<T> {
-      children: TreeNode<T>[];
-      depth: number;
-      entries: T[];
-      folder: Folder.Implementation;
-      root: boolean;
-      visible: boolean;
-    }
-
-    type AlphabeticalSortEntry = { name: string } & object;
-    type StandardSortEntry = { sort: number } & object;
-  }
-}

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

@@ -1,242 +0,0 @@
-import type { AnyObject, DeepPartial, InexactPartial, FixedInstanceType } from "fvtt-types/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<
-    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<DocumentClass>["_source"][];
-
-    /**
-     * An Array of application references which will be automatically updated when the collection content changes
-     * @defaultValue `[]`
-     */
-    apps: Application.Any[];
-
-    /**
-     * Initialize the DocumentCollection by constructing any initially provided Document instances
-     * @internal
-     */
-    protected _initialize(): void;
-
-    /**
-     * A reference to the Document class definition which is contained within this DocumentCollection.
-     */
-    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(): DocumentClass["metadata"]["name"];
-
-    /**
-     * The base Document type which is contained within this DocumentCollection
-     */
-    static documentName: string;
-
-    /**
-     * Record the set of document ids where the Document was not initialized because of invalid source data
-     */
-    invalidDocumentIds: Set<string>;
-
-    /**
-     * The Collection class name
-     */
-    get name(): Name;
-
-    /**
-     * Instantiate a Document for inclusion in the Collection.
-     * @param data    - The Document data
-     * @param context - Document creation context
-     */
-    createDocument(
-      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.
-     * @param id - A document ID with invalid source data.
-     * @param options - Additional options to configure retrieval.
-     * @returns An in-memory instance for the invalid Document
-     * @throws If strict is true and the requested ID is not in the set of invalid IDs for this collection.
-     */
-    getInvalid(
-      id: string,
-      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.ToStored<DocumentClass>): this;
-
-    /** @remarks Actually returns void */
-    delete: (id: string) => boolean;
-
-    /**
-     * Render any Applications associated with this DocumentCollection.
-     */
-    render(force?: boolean, options?: Application.Options): void;
-
-    /**
-     * Get the searchable fields for a given document or index, based on its data model
-     * @param documentName    - The document type name
-     * @param documentSubtype - The document subtype name
-     * @param isEmbedded      - Whether the document is an embedded object
-     * @returns The dot-delimited property paths of searchable fields
-     */
-    // TODO: Could significantly improve this with type defs
-    static getSearchableFields<T extends foundry.abstract.Document.Type>(
-      documentName: T,
-      documentSubtype?: foundry.abstract.Document.SubTypesOf<T>,
-      isEmbedded?: boolean,
-    ): Set<string>;
-
-    /**
-     * Find all Documents which match a given search term using a full-text search against their indexed HTML fields and their name.
-     * If filters are provided, results are filtered to only those that match the provided values.
-     * @param search   - An object configuring the search
-     */
-    search(search?: DocumentCollection.SearchOptions): FixedInstanceType<DocumentClass>[];
-
-    /**
-     * Update all objects in this DocumentCollection with a provided transformation.
-     * Conditionally filter to only apply to Entities which match a certain condition.
-     * @param transformation - An object of data or function to apply to all matched objects
-     * @param condition      - A function which tests whether to target each object
-     *                         (default: `null`)
-     * @param options        - Additional options passed to Document.updateDocuments
-     *                         (default: `{}`)
-     * @returns An array of updated data once the operation is complete
-     */
-    updateAll(
-      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"]>;
-
-    /**
-     * Follow-up actions to take when a database operation modifies Documents in this DocumentCollection.
-     * @param action    - The database action performed
-     * @param documents - The array of modified Documents
-     * @param result    - The result of the database operation
-     * @param operation - Database operation details
-     * @param user      - The User who performed the operation
-     */
-    _onModifyContents<A extends DatabaseAction>(
-      action: A,
-      documents: Document.ToStored<DocumentClass>[],
-      result: readonly AnyObject[] | readonly string[],
-      operation: DatabaseOperationMap[A],
-      user: User.Implementation,
-    ): void;
-  }
-
-  namespace DocumentCollection {
-    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> {
-        documentType: T["metadata"]["name"];
-        documents: Document.ToConfiguredStored<T>[];
-
-        /** @deprecated The "entities" render context is deprecated. Please use "documents" instead. */
-        get entities(): this["documents"];
-
-        /** @deprecated The "entityType" render context is deprecated. Please use "documentType" instead. */
-        get entityType(): this["documentType"];
-      }
-
-      interface Create<T extends Document.AnyConstructor> extends Base<T> {
-        action: "create";
-        data: (FixedInstanceType<T>["_source"] & { _id: string })[];
-      }
-
-      interface Update<T extends Document.AnyConstructor> extends Base<T> {
-        action: "update";
-        data: (DeepPartial<FixedInstanceType<T>["_source"]> & { _id: string })[];
-      }
-
-      interface Delete<T extends Document.AnyConstructor> extends Base<T> {
-        action: "delete";
-        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/index.d.mts

@@ -1,5 +0,0 @@
-import "./canvas-document.d.mts";
-import "./client-document.d.mts";
-import "./directory-collection-mixin.d.mts";
-import "./document-collection.d.mts";
-import "./world-collection.d.mts";

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

@@ -1,157 +0,0 @@
-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 | `Game#collections`}
-   */
-  abstract class WorldCollection<
-    DocumentClass extends Document.AnyConstructor,
-    Name extends string,
-  > extends DirectoryCollectionMixin(DocumentCollection)<DocumentClass, Name> {
-    /**
-     * Reference the set of Folders which contain documents in this collection
-     */
-    get folders(): Collection<Folder.Stored>;
-
-    /**
-     * Return a reference to the SidebarDirectory application for this WorldCollection.
-     * @remarks
-     * 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>]
-      :
-          | (DocumentClass["metadata"]["name"] extends foundry.CONST.FOLDER_DOCUMENT_TYPES
-              ? DocumentDirectory<DocumentClass["metadata"]["name"]>
-              : never)
-          | SidebarTab
-          | undefined
-          | null;
-
-    /**
-     * Return a reference to the singleton instance of this WorldCollection, or null if it has not yet been created.
-     */
-    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`.
-
-    // 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.
-     * @param pack       - The CompendiumCollection instance from which to import
-     * @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 | `WorldCollection.fromCompendium`} and {@link Document.create | `Document.create`} methods
-     *                     (default: `{}`)
-     * @returns The imported Document instance
-     */
-
-    /**
-     * @privateRemarks We've added everything in WorldCollection.FromCompendiumOptions to DatabaseCreateOperation
-     * because they get passed through to Document.create() by this function.  So the
-     * union type isn't really needed.  Leaving it because it feels like foundry will pull
-     * those back out in the future (and we could miss it because we added them to
-     * DatabaseCreateOperation but the foundry typedef doesn't have them).
-     */
-    importFromCompendium(
-      pack: CompendiumCollection<CompendiumCollection.Metadata & { type: DocumentClass["metadata"]["name"] }>,
-      id: string,
-      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
-     * @param document - The source Document, or a plain data object
-     * @param options  - Additional options which modify how the document is imported
-     *                   (default: `{}`)
-     * @returns The processed data ready for world Document creation
-     * @remarks FromCompendiumOptions is inflated to account for expanded downstream use
-     */
-    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 | `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
-     * Actors.registerSheet("dnd5e", ActorSheet5eCharacter, { types: ["character], makeDefault: true });
-     * ```
-     */
-    static registerSheet(...args: DropFirst<Parameters<typeof DocumentSheetConfig.registerSheet>>): void;
-
-    /**
-     * Unregister a Document sheet class, removing it from the list of available sheet Applications to use.
-     * 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);
-     */
-    static unregisterSheet(...args: DropFirst<Parameters<typeof DocumentSheetConfig.unregisterSheet>>): void;
-
-    /**
-     * Return an array of currently registered sheet classes for this Document type.
-     * @remarks
-     * 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 {
-      /**
-       * Clear the currently assigned folder
-       * @defaultValue `false`
-       */
-      clearFolder?: boolean | undefined;
-
-      /**
-       * Clear the currently sort order
-       * @defaultValue `true`
-       */
-      clearSort?: boolean | undefined;
-
-      /**
-       * Clear Document ownership
-       * @defaultValue `true`
-       */
-      clearOwnership?: boolean | undefined;
-
-      /**
-       * Retain the Document ID from the source Compendium
-       * @defaultValue `false`
-       */
-      keepId?: boolean | undefined;
-
-      /** @remarks used by Scenes#fromCompendium */
-      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,51 +0,0 @@
-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 | `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<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.Implementation>>;
-
-    static documentName: "Actor";
-
-    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);
-}

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

@@ -1,25 +0,0 @@
-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 | `Cards`} The Cards document
-   */
-  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,56 +0,0 @@
-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 | `Combat`} The Combat document
-   * @see {@link CombatTracker | `CombatTracker`} The CombatTracker sidebar directory
-   */
-  class CombatEncounters extends WorldCollection<Combat.ImplementationClass, "CombatEncounters"> {
-    static documentName: "Combat";
-
-    /**
-     * Provide the settings object which configures the Combat document
-     */
-    static get settings(): ClientSettings.SettingInitializedType<"core", Combat.CONFIG_SETTING>;
-
-    override get directory(): typeof ui.combat;
-
-    /**
-     * Get an Array of Combat instances which apply to the current canvas scene
-     */
-    get combats(): ReturnType<this["filter"]>;
-
-    /**
-     * The currently active Combat instance
-     */
-    get active(): ReturnType<this["find"]>;
-
-    /**
-     * The currently viewed Combat encounter
-     */
-    get viewed(): Combat.Stored | null;
-
-    /**
-     * When a Token is deleted, remove it as a combatant from any combat encounters which included the Token
-     * @param sceneId - The Scene id within which a Token is being deleted
-     * @param tokenId - The Token id being deleted
-     */
-    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);
-}