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

package/src/foundry/common/abstract/document.d.mts

@@ -1,47 +1,76 @@
 import type {
-  ConfiguredDocuments,
+  ConfigurationFailure,
+  ConfiguredDocumentClass,
+  ConfiguredDocumentInstance,
   ConfiguredMetadata,
-  DefaultDocuments,
-  ConstructorData,
+  CreateData,
 } from "../../../types/documentConfiguration.d.mts";
 import type {
-  DatabaseOperationsFor,
   GetKey,
   InterfaceToObject,
   MakeConform,
   MustConform,
   ToMethod,
-} from "../../../types/helperTypes.mts";
-import type {
   AnyObject,
-  DeepPartial,
   EmptyObject,
   InexactPartial,
   RemoveIndexSignatures,
-} from "../../../types/utils.mts";
-import type { documents } from "../../client-esm/client.d.mts";
+  FixedInstanceType,
+  NullishProps,
+  AllKeysOf,
+  DiscriminatedUnion,
+  SimpleMerge,
+  PickValue,
+  Identity,
+  Brand,
+  AnyMutableObject,
+  MaybePromise,
+} from "#utils";
 import type * as CONST from "../constants.mts";
-import type { DataField, EmbeddedCollectionField, EmbeddedDocumentField } from "../data/fields.d.mts";
-import type { fields } from "../data/module.mts";
+import type {
+  DataSchema,
+  DataField,
+  DocumentStatsField,
+  EmbeddedCollectionField,
+  EmbeddedDocumentField,
+  SchemaField,
+  TypeDataField,
+} from "../data/fields.d.mts";
 import type { LogCompatibilityWarningOptions } from "../utils/logging.mts";
 import type {
+  DatabaseAction,
   DatabaseCreateOperation,
   DatabaseDeleteOperation,
   DatabaseGetOperation,
   DatabaseUpdateOperation,
+  DocumentSocketRequest,
 } from "./_types.d.mts";
 import type DataModel from "./data.mts";
+import type DocumentSocketResponse from "./socket.d.mts";
+import type EmbeddedCollection from "./embedded-collection.d.mts";
 
 export default Document;
 
-declare const __DocumentBrand: unique symbol;
-
-declare const __Schema: unique symbol;
-declare const __Parent: unique symbol;
-
 type _ClassMustBeAssignableToInternal = MustConform<typeof Document, Document.Internal.Constructor>;
 type _InstanceMustBeAssignableToInternal = MustConform<Document.Any, Document.Internal.Instance.Any>;
 
+// Note(LukeAbby): Properties from `Schema` technically derive from `DataModel`. This means that if
+// `name?: string` etc. were to be put in `Document` directly they'd actually override the schema.
+// Therefore this workaround is used to force `DataModel` to override the properties.
+declare const _InternalDocument: (new (...args: any[]) => {
+  // TODO: removing undefined breaks everything, but should be valid to do, investigate
+  name?: string | null | undefined;
+
+  // `{}` is used so that `{}` and the actual shape of `system` are merged.
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+  system?: {} | undefined;
+  _stats?: DocumentStatsField.InitializedData | undefined;
+
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+  flags?: {} | undefined;
+}) &
+  typeof DataModel;
+
 /**
  * An extension of the base DataModel which defines a Document.
  * Documents are special in that they are persisted to the database and referenced by _id.
@@ -50,29 +79,26 @@ declare abstract class Document<
   DocumentName extends Document.Type,
   Schema extends DataSchema,
   Parent extends Document.Any | null = null,
-> extends DataModel<Schema, Parent, InterfaceToObject<Document.ConstructionContext<Parent>>> {
-  static [__DocumentBrand]: never;
-
-  [__Schema]: Schema;
-  [__Parent]: Parent;
-
+> extends _InternalDocument<Schema, Parent, InterfaceToObject<Document.ConstructionContext<Parent>>> {
   /**
    * @param data    - Initial data provided to construct the Document
    * @param context - Construction context options
    */
-  constructor(data?: fields.SchemaField.InnerConstructorType<Schema>, context?: Document.ConstructionContext<Parent>);
+  // Note: The constructor has been replaced with `never` in `Document` itself because it never makes
+  // sense to try to construct `new Document(...)` directly. Not only is it an abstract class but
+  // also it varies based upon the `Schema`. While this could be supported it also simplifies
+  // typechecking and helps stymy circularities.
+  constructor(...args: never);
 
   override parent: Parent;
 
-  protected override _configure(options?: {
-    pack?: string | null | undefined;
-    parentCollection?: string | null | undefined;
-  }): void;
+  // options: not null (destructured)
+  protected override _configure(options?: Document.ConfigureOptions): void;
 
   /**
    * An immutable reverse-reference to the name of the collection that this Document exists in on its parent, if any.
    */
-  readonly parentCollection: string | null;
+  readonly parentCollection: Document.MetadataFor<DocumentName>["collection"] | null;
 
   /**
    * An immutable reference to a containing Compendium collection to which this Document belongs.
@@ -87,9 +113,10 @@ declare abstract class Document<
   /**
    * Ensure that all Document classes share the same schema of their base declaration.
    */
-  static get schema(): foundry.data.fields.SchemaField.Any;
+  static get schema(): SchemaField.Any;
 
-  protected _initialize(options?: any): void;
+  // options: not null (parameter default only)
+  protected _initialize(options?: Document.InitializeOptions): void;
 
   /**
    * A mapping of singleton embedded Documents which exist in this model.
@@ -120,7 +147,7 @@ declare abstract class Document<
    * }
    * ```
    */
-  static metadata: Readonly<Document.Metadata.Any>;
+  static metadata: Document.Metadata.Any;
 
   /**
    * The database backend used to execute operations and handle results
@@ -130,8 +157,6 @@ declare abstract class Document<
   /**
    * Return a reference to the implemented subclass of this base document type.
    */
-  // Referencing the concrete class the config is not possible because accessors cannot be generic and there is not
-  // static polymorphic this type
   static get implementation(): Document.AnyConstructor;
 
   /**
@@ -147,7 +172,7 @@ declare abstract class Document<
   /**
    * The named collection to which this Document belongs.
    */
-  get collectionName(): Document.Internal.SimpleMetadata<DocumentName>["collection"];
+  get collectionName(): Document.MetadataFor<DocumentName>["collection"];
 
   /**
    * The canonical name of this Document type, for example "Actor".
@@ -161,23 +186,25 @@ declare abstract class Document<
 
   /**
    * The allowed types which may exist for this Document class
-   * @remarks Document.TYPES is overly generic so subclasses don't cause problems
    */
   static get TYPES(): string[];
 
   /**
    * Does this Document support additional subtypes?
    */
-  static get hasTypeData(): boolean;
+  static get hasTypeData(): undefined | true;
 
   /**
    * The Embedded Document hierarchy for this Document.
    */
-  static get hierarchy(): Record<string, EmbeddedCollectionField<any, any> | EmbeddedDocumentField<any>>;
+  static get hierarchy(): Record<string, EmbeddedCollectionField.Any | EmbeddedDocumentField.Any>;
 
   /**
    * Identify the collection in a parent Document that this Document exists belongs to, if any.
    * @param parentCollection - An explicitly provided parent collection name.
+   * @remarks If passed a value for `parentCollection`, simply returns that value
+   *
+   * Foundry marked `@internal`
    */
   _getParentCollection(parentCollection?: string): string | null;
 
@@ -201,17 +228,18 @@ declare abstract class Document<
    * @param user - The User being tested
    * @returns Does the User have a sufficient role to create?
    */
-  static canUserCreate(user: foundry.documents.BaseUser): boolean;
+  static canUserCreate(user: User.Implementation): boolean;
 
   /**
-   * Get the explicit permission level that a specific User has over this Document, a value in CONST.DOCUMENT_OWNERSHIP_LEVELS.
+   * Get the explicit permission level that a specific User has over this Document, a value in {@link CONST.DOCUMENT_OWNERSHIP_LEVELS | `CONST.DOCUMENT_OWNERSHIP_LEVELS`}.
    * This method returns the value recorded in Document ownership, regardless of the User's role.
    * To test whether a user has a certain capability over the document, testUserPermission should be used.
-   * @param user - The User being tested
-   *               (default: `game.user`)
+   * @param user - The User being tested (default: `game.user`)
    * @returns A numeric permission level from CONST.DOCUMENT_OWNERSHIP_LEVELS or null
+   *
+   * @privateRemarks Making this just `User.Implementation` causes circularities
    */
-  getUserLevel(user?: foundry.documents.BaseUser): CONST.DOCUMENT_OWNERSHIP_LEVELS | null;
+  getUserLevel(user?: User.Internal.Implementation | null): CONST.DOCUMENT_OWNERSHIP_LEVELS | null;
 
   /**
    * Test whether a certain User has a requested permission level (or greater) over the Document
@@ -219,28 +247,31 @@ declare abstract class Document<
    * @param permission - The permission level from DOCUMENT_PERMISSION_LEVELS to test
    * @param options    - Additional options involved in the permission test
    * @returns Does the user have this permission level over the Document?
+   *
+   * @privateRemarks Making this just `User.Implementation` causes circularities
    */
+  // options: not null (destructured)
   testUserPermission(
-    user: foundry.documents.BaseUser,
-    permission: keyof typeof CONST.DOCUMENT_OWNERSHIP_LEVELS | CONST.DOCUMENT_OWNERSHIP_LEVELS,
-    options?: InexactPartial<{
-      /**
-       * Require the exact permission level requested?
-       * @defaultValue `false`
-       */
-      exact: boolean;
-    }>,
+    user: User.Internal.Implementation,
+    permission: Document.ActionPermission,
+    options?: Document.TestUserPermissionOptions,
   ): boolean;
 
   /**
    * Test whether a given User has permission to perform some action on this Document
    * @param user   - The User attempting modification
    * @param action - The attempted action
-   * @param data   - Data involved in the attempted action
-   *                 (default: `{}`)
+   * @param data   - Data involved in the attempted action (default: `{}`)
    * @returns Does the User have permission?
+   *
+   * @privateRemarks Making this just `User.Implementation` causes circularities
    */
-  canUserModify(user: foundry.documents.BaseUser, action: "create" | "update" | "delete", data?: object): boolean;
+  // data: not null (parameter default only)
+  canUserModify<Action extends "create" | "update" | "delete">(
+    user: User.Internal.Implementation,
+    action: Action,
+    data?: Document.CanUserModifyData<Schema, Action>,
+  ): boolean;
 
   /**
    * Clone a document, creating a new document by combining current data with provided overrides.
@@ -249,40 +280,22 @@ declare abstract class Document<
    * @param context - Additional context options passed to the create method
    * @returns The cloned Document instance
    */
-  override clone<Save extends boolean = false>(
-    data?: fields.SchemaField.AssignmentType<Schema, EmptyObject>,
-    context?: InexactPartial<
-      {
-        /**
-         * Save the clone to the World database?
-         * @defaultValue `false`
-         */
-        save: Save;
-
-        /**
-         * Keep the same ID of the original document
-         * @defaultValue `false`
-         */
-        keepId: boolean;
-
-        /**
-         * Track the clone source
-         * @defaultValue `false`
-         */
-        addSource: boolean;
-      } & Document.ConstructionContext<this["parent"]>
-    >, // FIXME(LukeAbby): Adding Document.Stored to the return causes a recursive type error in Scene
+  // data: not null (property access), context: not null (destructured)
+  override clone<Save extends boolean | null | undefined = false>(
+    data?: SchemaField.UpdateData<Schema>,
+    context?: Document.CloneContext<Save>,
   ): Save extends true ? Promise<this> : this;
 
   /**
    * For Documents which include game system data, migrate the system data object to conform to its latest data model.
    * The data model is defined by the template.json specification included by the game system.
    * @returns The migrated system data object
+   * @throws If this document type either doesn't have subtypes or it does but the one on this document is a DataModel
    */
   migrateSystemData(): object;
 
-  override toObject(source: true): this["_source"];
-  override toObject(source?: boolean): ReturnType<this["schema"]["toObject"]>;
+  /** @remarks `Document#toObject` calls `this.constructor.shimData()` on the data before returning */
+  override toObject(source?: boolean | null): SchemaField.SourceData<Schema>;
 
   /**
    * Create multiple Documents using provided input data.
@@ -318,14 +331,12 @@ declare abstract class Document<
    * const data = [{name: "Compendium Actor", type: "character", img: "path/to/profile.jpg"}];
    * const created = await Actor.createDocuments(data, {pack: "mymodule.mypack"});
    * ```
+   *
+   * @remarks If a document is skipped by a hook or `_preCreate` then that element is skipped in the
+   * return type. This means that you receive only documents that were actually created.
    */
-  static createDocuments<T extends Document.AnyConstructor, Temporary extends boolean | undefined>(
-    this: T,
-    data: Array<Document.ConstructorDataFor<T>>,
-    operation?: InexactPartial<Omit<DatabaseOperationsFor<T["metadata"]["name"], "create">, "data">> & {
-      temporary?: Temporary;
-    },
-  ): Promise<Document.ToStoredIf<T, Temporary>[] | undefined>;
+  // Note: This uses `never` because it's unsound to try to do `Document.createDocuments` directly.
+  static createDocuments(data: never, operation?: never): Promise<Document.Any[]>;
 
   /**
    * Update multiple Document instances using provided differential data.
@@ -361,12 +372,12 @@ declare abstract class Document<
    * const actor = await pack.getDocument(documentId);
    * const updated = await Actor.updateDocuments([{_id: actor.id, name: "New Name"}], {pack: "mymodule.mypack"});
    * ```
+   *
+   * @remarks If a document is skipped by a hook or `_preCreate` then that element is skipped in the
+   * return type. This means that you receive only documents that were actually updated.
    */
-  static updateDocuments<T extends Document.AnyConstructor>(
-    this: T,
-    updates?: Array<DeepPartial<Document.UpdateDataFor<T>>>,
-    operation?: InexactPartial<Omit<DatabaseOperationsFor<InstanceType<T>["documentName"], "update">, "updates">>,
-  ): Promise<Document.ToConfiguredInstance<T>[]>;
+  // Note: This uses `never` because it's unsound to try to do `Document.updateDocuments`
+  static updateDocuments(updates: never, operation?: never): Promise<Document.Any[]>;
 
   /**
    * Delete one or multiple existing Documents using an array of provided ids.
@@ -404,16 +415,16 @@ declare abstract class Document<
    * const actor = await pack.getDocument(documentId);
    * const deleted = await Actor.deleteDocuments([actor.id], {pack: "mymodule.mypack"});
    * ```
+   *
+   * @remarks If a document is skipped by a hook or `_preDelete` then that element is skipped in the
+   * return type. This means that you receive only documents that were actually deleted.
    */
-  static deleteDocuments<T extends Document.AnyConstructor>(
-    this: T,
-    ids?: string[],
-    operation?: InexactPartial<Omit<DatabaseOperationsFor<InstanceType<T>["documentName"], "delete">, "ids">>,
-  ): Promise<Document.ToConfiguredInstance<T>[]>;
+  // Note: This uses `never` because it's unsound to try to pass the operation for `Document.deleteDocument`
+  static deleteDocuments(ids?: readonly string[], operation?: never): Promise<Document.Any[]>;
 
   /**
    * Create a new Document using provided input data, saving it to the database.
-   * @see {@link Document.createDocuments}
+   * @see {@link Document.createDocuments | `Document.createDocuments`}
    * @param data      - Initial data used to create this Document, or a Document instance to persist.
    * @param operation - Parameters of the creation operation
    *                    (default: `{}`)
@@ -438,53 +449,56 @@ declare abstract class Document<
    * const created = await Item.create(data, {pack: "mymodule.mypack"});
    * ```
    *
-   * @remarks If no document has actually been created, the returned {@link Promise} resolves to `undefined`.
+   * @remarks If the document creation is skipped by a hook or `_preCreate` then `undefined` is
+   * returned.
    */
-  static create<T extends Document.AnyConstructor, Temporary extends boolean | undefined>(
-    this: T,
-    data: Document.ConstructorDataFor<T> | Document.ConstructorDataFor<T>[],
-    operation?: InexactPartial<Omit<DatabaseOperationsFor<T["metadata"]["name"], "create">, "data">> & {
-      temporary?: Temporary;
-    },
-  ): Promise<Document.ToStoredIf<T, Temporary> | undefined>;
+  // Note: This uses `never` because it's unsound to try to call `Document.create` directly.
+  // TODO: This can take an array of data and return an array of documents, in addition to its current typing
+  static create(data: never, operation?: never): Promise<Document.Any | undefined>;
 
   /**
    * Update this Document using incremental data, saving it to the database.
-   * @see {@link Document.updateDocuments}
+   * @see {@link Document.updateDocuments | `Document.updateDocuments`}
    * @param data      - Differential update data which modifies the existing values of this document data
    *                    (default: `{}`)
    * @param operation - Parameters of the update operation
    *                    (default: `{}`)
    * @returns The updated Document instance
    *
-   * @remarks If no document has actually been updated, the returned {@link Promise} resolves to `undefined`.
+   * @remarks If the document update is skipped by a hook or `_preUpdate` then `undefined` is
+   * returned.
    */
-  update(
-    // TODO: Determine if this is Partial, DeepPartial, or InexactPartial.
-    data?: Partial<Document.ConstructorDataForSchema<Schema>>,
-    operation?: InexactPartial<Omit<DatabaseOperationsFor<DocumentName, "update">, "updates">>,
-  ): Promise<this | undefined>;
+  // Note: This uses `never` because it's unsound to try to call `Document#update` directly.
+  update(data: never, operation: never): Promise<this | undefined>;
 
   /**
    * Delete this Document, removing it from the database.
-   * @see {@link Document.deleteDocuments}
+   * @see {@link Document.deleteDocuments | `Document.deleteDocuments`}
    * @param operation - Parameters of the deletion operation
    *                    (default: `{}`)
    * @returns The deleted Document instance
    *
-   * @remarks If no document has actually been deleted, the returned {@link Promise} resolves to `undefined`.
+   * @remarks If the document deletion is skipped by a hook or `_preUpdate` then `undefined` is
+   * returned.
    */
-  delete(
-    operation?: InexactPartial<Omit<DatabaseOperationsFor<DocumentName, "delete">, "ids">>,
-  ): Promise<this | undefined>;
+  // Note: This uses `never` because it's unsound to try to call `Document#delete` directly.
+  delete(operation: never): Promise<this | undefined>;
 
   /**
    * Get a World-level Document of this type by its id.
    * @param documentId - The Document ID
-   * @param options    - Additional options which customize the request
+   * @param operation  - Additional options which customize the request
    * @returns The retrieved Document, or null
+   *
+   * @remarks If the Document is in a compendium (i.e `operation.pack` is provided), returns the index
+   * entry (or `null`), instead of the Document.
+   *
+   * {@link FogExploration.get | `FogExploration.get`} can possibly forward args and return to/from
+   * {@link FogExploration.load | `FogExploration.load`}, which accounts for the `Promise<>` part
+   * of the return; All other documents return `SomeDoc.Implementation | null`
    */
-  static get(documentId: string, options?: InexactPartial<DatabaseGetOperation>): Document.Any | null;
+  // TODO: Type for possible index entry return
+  static get(documentId: string, operation?: Document.Database.GetOptions): MaybePromise<Document.Any | null>;
 
   /**
    * A compatibility method that returns the appropriate name of an embedded collection within this Document.
@@ -503,7 +517,7 @@ declare abstract class Document<
    * // returns "items"
    * ```
    */
-  static getCollectionName(name: string): string | null;
+  static getCollectionName(name: never): string | null;
 
   /**
    * Obtain a reference to the Array of source data within the data object for a certain embedded Document name
@@ -511,10 +525,8 @@ declare abstract class Document<
    * @returns The Collection instance of embedded Documents of the requested type
    * @remarks Usually returns some form of DocumentCollection, but not always (e.g. Token["actors"])
    */
-  // TODO: After regions are defined, change first parameter to `extends foundry.CONST.EMBEDDED_DOCUMENT_TYPES`
-  getEmbeddedCollection<
-    EmbeddedName extends Exclude<foundry.CONST.EMBEDDED_DOCUMENT_TYPES, "Region" | "RegionBehavior">,
-  >(embeddedName: EmbeddedName): Collection<Document.ConfiguredInstanceForName<EmbeddedName>>;
+  // Note: This uses `never` because it's unsound to try to call `Document#getEmbeddedCollection` directly.
+  getEmbeddedCollection(embeddedName: never): unknown;
 
   /**
    * Get an embedded document by its id from a named collection in the parent document.
@@ -524,26 +536,16 @@ declare abstract class Document<
    * @returns The retrieved embedded Document instance, or undefined
    * @throws If the embedded collection does not exist, or if strict is true and the Embedded Document could not be found.
    */
+  // Note: This uses `never` because it's unsound to try to call `Document#getEmbeddedDocument` directly.
   getEmbeddedDocument(
-    embeddedName: string,
+    embeddedName: never,
     id: string,
-    options: InexactPartial<{
-      /**
-       * Throw an Error if the requested id does not exist. See Collection#get
-       * @defaultValue `false`
-       */
-      strict: boolean;
-      /**
-       * Allow retrieving an invalid Embedded Document.
-       * @defaultValue `false`
-       */
-      invalid: boolean;
-    }>,
-  ): Document.AnyChild<this> | undefined;
+    options: Document.GetEmbeddedDocumentOptions,
+  ): Document.Any | undefined;
 
   /**
    * Create multiple embedded Document instances within this parent Document using provided input data.
-   * @see {@link Document.createDocuments}
+   * @see {@link Document.createDocuments | `Document.createDocuments`}
    * @param embeddedName - The name of the embedded Document type
    * @param data         - An array of data objects used to create multiple documents
    *                       (default: `[]`)
@@ -551,24 +553,18 @@ declare abstract class Document<
    *                       (default: `{}`)
    * @returns An array of created Document instances
    */
-  // TODO: After regions are defined, change first parameter to `extends foundry.CONST.EMBEDDED_DOCUMENT_TYPES`
-  // TODO: I think we could do a better job on all the embedded methods of limiting the types here based on the
-  //   allowed embedded types of the parent (vs. allowing any document to create embedded
-  //   documents of any type)
-  createEmbeddedDocuments<
-    EmbeddedName extends foundry.CONST.EMBEDDED_DOCUMENT_TYPES,
-    Temporary extends boolean | undefined,
-  >(
-    embeddedName: EmbeddedName,
-    data?: Array<Document.ConstructorDataForName<Extract<EmbeddedName, Document.Type>>>,
-    operation?: InexactPartial<DatabaseOperationsFor<Extract<EmbeddedName, Document.Type>, "create">> & {
-      temporary?: Temporary;
-    },
-  ): Promise<Array<Document.ConfiguredInstanceForName<Extract<EmbeddedName, Document.Type>>> | undefined>;
+  // Note: This uses `never` because it's unsound to try to call `Document#createEmbeddedDocuments` directly.
+  // Note(LukeAbby): Returns `unknown` instead of `Promise<Array<Document.AnyStored> | undefined>` to stymy errors.
+  createEmbeddedDocuments(
+    embeddedName: never,
+    // Note: Not optional because `createEmbeddedDocuments("Actor")` does effectively nothing.
+    data: never,
+    operation?: never,
+  ): unknown;
 
   /**
    * Update multiple embedded Document instances within a parent Document using provided differential data.
-   * @see {@link Document.updateDocuments}
+   * @see {@link Document.updateDocuments | `Document.updateDocuments`}
    * @param embeddedName - The name of the embedded Document type
    * @param updates      - An array of differential data objects, each used to update a single Document
    *                       (default: `[]`)
@@ -576,37 +572,34 @@ declare abstract class Document<
    *                       (default: `{}`)
    * @returns An array of updated Document instances
    */
-  // TODO: After regions are defined, change first parameter to `extends foundry.CONST.EMBEDDED_DOCUMENT_TYPES`
-  updateEmbeddedDocuments<EmbeddedName extends foundry.CONST.EMBEDDED_DOCUMENT_TYPES>(
-    embeddedName: EmbeddedName,
-    updates?: Array<AnyObject>,
-    context?: Document.ModificationContext<this["parent"]>,
-  ): Promise<Array<Document.Stored<Document.ConfiguredInstanceForName<Extract<EmbeddedName, Document.Type>>>>>;
+  // Note: This uses `never` because it's unsound to try to call `Document#updateEmbeddedDocuments` directly.
+  // Note(LukeAbby): Returns `unknown` instead of `Promise<Array<Document.AnyStored> | undefined>` to stymy errors.
+  updateEmbeddedDocuments(
+    embeddedName: never,
+    // Note: Not optional because `updateEmbeddedDocuments("Actor")` does effectively nothing.
+    updates: never,
+    context?: never,
+  ): unknown;
 
   /**
    * Delete multiple embedded Document instances within a parent Document using provided string ids.
-   * @see {@link Document.deleteDocuments}
+   * @see {@link Document.deleteDocuments | `Document.deleteDocuments`}
    * @param embeddedName - The name of the embedded Document type
    * @param ids          - An array of string ids for each Document to be deleted
    * @param operation    - Parameters of the database deletion workflow
    *                       (default: `{}`)
    * @returns An array of deleted Document instances
    */
-  // TODO: After regions are defined, change first parameter to `extends foundry.CONST.EMBEDDED_DOCUMENT_TYPES`
-  deleteEmbeddedDocuments<
-    EmbeddedName extends Exclude<foundry.CONST.EMBEDDED_DOCUMENT_TYPES, "Region" | "RegionBehavior">,
-  >(
-    embeddedName: EmbeddedName,
-    ids: Array<string>,
-    operation?: DatabaseOperationsFor<DocumentName, "delete">,
-  ): Promise<Array<Document.Stored<Document.ConfiguredInstanceForName<EmbeddedName>>>>;
+  // Note: This uses `never` because it's unsound to try to call `Document#deleteEmbeddedDocuments` directly.
+  // Note(LukeAbby): Returns `unknown` instead of `Promise<Array<Document.AnyStored> | undefined>` to stymy errors.
+  deleteEmbeddedDocuments(embeddedName: never, ids: Array<string>, operation?: never): unknown;
 
   /**
    * Iterate over all embedded Documents that are hierarchical children of this Document.
    * @param _parentPath - A parent field path already traversed
    * @remarks Not called within Foundry's client-side code, likely exists for server documents
    */
-  traverseEmbeddedDocuments(_parentPath?: string): Generator<[string, Document.Any]>;
+  traverseEmbeddedDocuments(_parentPath?: string): Generator<[string, Document.AnyChild<this>]>;
 
   /**
    * Get the value of a "flag" for this document
@@ -616,10 +609,7 @@ declare abstract class Document<
    * @param key   - The flag key
    * @returns The flag value
    */
-  getFlag<
-    S extends Document.FlagKeyOf<Document.ConfiguredFlagsForName<DocumentName>>,
-    K extends Document.FlagKeyOf<Document.FlagGetKey<Document.ConfiguredFlagsForName<DocumentName>, S>>,
-  >(scope: S, key: K): Document.GetFlag<DocumentName, S, K>;
+  getFlag(scope: never, key: never): unknown;
 
   /**
    * Assign a "flag" to this document.
@@ -639,11 +629,7 @@ declare abstract class Document<
    * @param value - The flag value
    * @returns A Promise resolving to the updated document
    */
-  setFlag<
-    S extends Document.FlagKeyOf<Document.ConfiguredFlagsForName<DocumentName>>,
-    K extends Document.FlagKeyOf<Document.FlagGetKey<Document.ConfiguredFlagsForName<DocumentName>, S>>,
-    V extends Document.GetFlag<DocumentName, S, K>,
-  >(scope: S, key: K, value: V): Promise<this>;
+  setFlag(scope: never, key: never, value: never): Promise<this>;
 
   /**
    * Remove a flag assigned to the document
@@ -651,22 +637,18 @@ declare abstract class Document<
    * @param key   - The flag key
    * @returns The updated document instance
    */
-  unsetFlag(scope: string, key: string): Promise<this>;
+  unsetFlag(scope: never, key: never): Promise<this>;
 
   /**
    * Pre-process a creation operation for a single Document instance.
    * Pre-operation events only occur for the client which requested the operation.
-   * Modifications to the pending Document instance must be performed using {@link Document#updateSource}.
+   * Modifications to the pending Document instance must be performed using {@link Document.updateSource | `Document#updateSource`}.
    * @param data    - The initial data object provided to the document creation request
    * @param options - Additional options which modify the creation request
    * @param user    - The User requesting the document creation
    * @returns Return false to exclude this Document from the creation operation
    */
-  protected _preCreate(
-    data: fields.SchemaField.AssignmentType<Schema>,
-    options: Document.PreCreateOptions<DocumentName>,
-    user: foundry.documents.BaseUser,
-  ): Promise<boolean | void>;
+  protected _preCreate(data: never, options: never, user: User.Internal.Implementation): Promise<boolean | void>;
 
   /**
    * Post-process a creation operation for a single Document instance.
@@ -675,48 +657,44 @@ declare abstract class Document<
    * @param options - Additional options which modify the creation request
    * @param userId  - The id of the User requesting the document update
    */
-  protected _onCreate(
-    data: fields.SchemaField.InnerAssignmentType<Schema>,
-    options: Document.OnCreateOptions<DocumentName>,
-    userId: string,
-  ): void;
+  protected _onCreate(data: never, options: never, userId: string): MaybePromise<void>;
 
   /**
    * Pre-process a creation operation, potentially altering its instructions or input data. Pre-operation events only
    * occur for the client which requested the operation.
    *
-   * This batch-wise workflow occurs after individual {@link Document#_preCreate} workflows and provides a final
+   * This batch-wise workflow occurs after individual {@link Document._preCreate | `Document#_preCreate`} workflows and provides a final
    * pre-flight check before a database operation occurs.
    *
    * Modifications to pending documents must mutate the documents array or alter individual document instances using
-   * {@link Document#updateSource}.
+   * {@link Document.updateSource | `Document#updateSource`}.
    * @param documents - Pending document instances ot be created
    * @param operation - Parameters of the database creation operation
    * @param user      - The User requesting the creation operation
    * @returns Return false to cancel the creation operation entirely
    */
-  protected static _preCreateOperation<T extends Document.AnyConstructor>(
-    this: T,
-    documents: Document.ToConfiguredInstance<T>[],
-    operation: DatabaseOperationsFor<T["metadata"]["name"], "create">,
-    user: foundry.documents.BaseUser,
+  // Note: This uses `never` because it's unsound to try to do `Document._preCreateOperation` directly.
+  protected static _preCreateOperation(
+    documents: never[],
+    operation: never,
+    user: User.Internal.Implementation,
   ): Promise<boolean | void>;
 
   /**
    * Post-process a creation operation, reacting to database changes which have occurred. Post-operation events occur
    * for all connected clients.
    *
-   * This batch-wise workflow occurs after individual {@link Document#_onCreate} workflows.
+   * This batch-wise workflow occurs after individual {@link Document._onCreate | `Document#_onCreate`} workflows.
    *
    * @param documents - The Document instances which were created
    * @param operation - Parameters of the database creation operation
    * @param user      - The User who performed the creation operation
    */
-  protected static _onCreateOperation<T extends Document.AnyConstructor>(
-    this: T,
-    documents: InstanceType<Document.ConfiguredClass<T>>[],
-    operation: DatabaseOperationsFor<T["metadata"]["name"], "create">,
-    user: foundry.documents.BaseUser,
+  // Note: This uses `never` because it's unsound to try to do `Document._onCreateOperation` directly.
+  protected static _onCreateOperation(
+    documents: never,
+    operation: never,
+    user: User.Internal.Implementation,
   ): Promise<void>;
 
   /**
@@ -727,11 +705,7 @@ declare abstract class Document<
    * @param user    - The User requesting the document update
    * @returns A return value of false indicates the update operation should be cancelled
    */
-  protected _preUpdate(
-    changed: fields.SchemaField.AssignmentType<Schema>,
-    options: Document.PreUpdateOptions<DocumentName>,
-    user: foundry.documents.BaseUser,
-  ): Promise<boolean | void>;
+  protected _preUpdate(changed: never, options: never, user: User.Internal.Implementation): Promise<boolean | void>;
 
   /**
    * Perform follow-up operations after a Document of this type is updated.
@@ -740,49 +714,45 @@ declare abstract class Document<
    * @param options - Additional options which modify the update request
    * @param userId  - The id of the User requesting the document update
    */
-  protected _onUpdate(
-    changed: fields.SchemaField.InnerAssignmentType<Schema>,
-    options: Document.OnUpdateOptions<DocumentName>,
-    userId: string,
-  ): void;
+  protected _onUpdate(changed: never, options: never, userId: string): MaybePromise<void>;
 
   /**
    * Pre-process an update operation, potentially altering its instructions or input data. Pre-operation events only
    * occur for the client which requested the operation.
    *
-   * This batch-wise workflow occurs after individual {@link Document#_preUpdate} workflows and provides a final
+   * This batch-wise workflow occurs after individual {@link Document._preUpdate | `Document#_preUpdate`} workflows and provides a final
    * pre-flight check before a database operation occurs.
    *
    * Modifications to the requested updates are performed by mutating the data array of the operation.
-   * {@link Document#updateSource}.
+   * {@link Document.updateSource | `Document#updateSource`}.
    *
    * @param documents - Document instances to be updated
    * @param operation - Parameters of the database update operation
    * @param user      - The User requesting the update operation
    * @returns Return false to cancel the update operation entirely
    */
-  protected static _preUpdateOperation<T extends Document.AnyConstructor>(
-    this: T,
-    documents: InstanceType<Document.ConfiguredClass<T>>[],
-    operation: DatabaseOperationsFor<InstanceType<T>["documentName"], "update">,
-    user: foundry.documents.BaseUser,
+  // Note: This uses `never` because it's unsound to try to do `Document._preUpdateOperation` directly.
+  protected static _preUpdateOperation(
+    documents: never,
+    operation: never,
+    user: User.Internal.Implementation,
   ): Promise<boolean | void>;
 
   /**
    * Post-process an update operation, reacting to database changes which have occurred. Post-operation events occur
    * for all connected clients.
    *
-   * This batch-wise workflow occurs after individual {@link Document#_onUpdate} workflows.
+   * This batch-wise workflow occurs after individual {@link Document._onUpdate | `Document#_onUpdate`} workflows.
    *
    * @param documents - The Document instances which were updated
    * @param operation - Parameters of the database update operation
    * @param user      - The User who performed the update operation
    */
-  protected static _onUpdateOperation<T extends Document.AnyConstructor>(
-    this: T,
-    documents: InstanceType<Document.ConfiguredClass<T>>[],
-    operation: DatabaseOperationsFor<InstanceType<T>["documentName"], "update">,
-    user: foundry.documents.BaseUser,
+  // Note: This uses `never` because it's unsound to try to do `Document._onUpdateOperation` directly.
+  protected static _onUpdateOperation(
+    documents: never,
+    operation: never,
+    user: User.Internal.Implementation,
   ): Promise<void>;
 
   /**
@@ -792,10 +762,7 @@ declare abstract class Document<
    * @param user    - The User requesting the document deletion
    * @returns A return value of false indicates the delete operation should be cancelled
    */
-  protected _preDelete(
-    options: Document.PreDeleteOptions<DocumentName>,
-    user: foundry.documents.BaseUser,
-  ): Promise<boolean | void>;
+  protected _preDelete(options: never, user: User.Internal.Implementation): Promise<boolean | void>;
 
   /**
    * Perform follow-up operations after a Document of this type is deleted.
@@ -803,17 +770,17 @@ declare abstract class Document<
    * @param options - Additional options which modify the deletion request
    * @param userId  - The id of the User requesting the document update
    */
-  protected _onDelete(options: Document.OnDeleteOptions<DocumentName>, userId: string): void;
+  protected _onDelete(options: never, userId: string): MaybePromise<void>;
 
   /**
    * Pre-process a deletion operation, potentially altering its instructions or input data. Pre-operation events only
    * occur for the client which requested the operation.
    *
-   * This batch-wise workflow occurs after individual {@link Document#_preDelete} workflows and provides a final
+   * This batch-wise workflow occurs after individual {@link Document._preDelete | `Document#_preDelete`} workflows and provides a final
    * pre-flight check before a database operation occurs.
    *
    * Modifications to the requested deletions are performed by mutating the operation object.
-   * {@link Document#updateSource}.
+   * {@link Document.updateSource | `Document#updateSource`}.
    *
    * @param documents - Document instances to be deleted
    * @param operation - Parameters of the database update operation
@@ -821,50 +788,64 @@ declare abstract class Document<
    * @returns Return false to cancel the deletion operation entirely
    * @internal
    */
-  protected static _preDeleteOperation<T extends Document.AnyConstructor>(
-    this: T,
-    documents: Array<Document.ToConfiguredInstance<T>>,
-    operation: DatabaseOperationsFor<InstanceType<T>["documentName"], "delete">,
-    user: foundry.documents.BaseUser,
+  // Note: This uses `never` because it's unsound to try to do `Document._preDeleteOperation` directly.
+  protected static _preDeleteOperation(
+    documents: never,
+    operation: never,
+    user: User.Internal.Implementation,
   ): Promise<unknown>;
 
   /**
    * Post-process a deletion operation, reacting to database changes which have occurred. Post-operation events occur
    * for all connected clients.
    *
-   * This batch-wise workflow occurs after individual {@link Document#_onDelete} workflows.
+   * This batch-wise workflow occurs after individual {@link Document._onDelete | `Document#_onDelete`} workflows.
    *
    * @param documents - The Document instances which were deleted
    * @param operation - Parameters of the database deletion operation
    * @param user      - The User who performed the deletion operation
    */
-  protected static _onDeleteOperation<T extends Document.AnyConstructor>(
-    this: T,
-    documents: Array<Document.ToConfiguredInstance<T>>,
-    operation: DatabaseOperationsFor<InstanceType<T>["documentName"], "delete">,
-    user: foundry.documents.BaseUser,
+  // Note: This uses `never` because it's unsound to try to do `Document._onDeleteOperation` directly.
+  protected static _onDeleteOperation(
+    documents: never,
+    operation: never,
+    user: User.Internal.Implementation,
   ): Promise<unknown>;
 
   /**
-   * Configure whether V10 Document Model migration warnings should be logged for this class.
+   * @deprecated since v10, no specified end
+   * @remarks "You are accessing the "data" field of which was deprecated in v10 and replaced with "system".
+   * Continued usage of pre-v10 ".data" paths is no longer supported"
+   *
+   * @throws An error with the above deprecation warning, if this Document's schema has a `system` field
    */
-  static LOG_V10_COMPATIBILITY_WARNINGS: boolean;
+  get data(): never;
 
   /**
    * @deprecated since v11, will be removed in v13
    * @remarks "You are accessing `Document.hasSystemData` which is deprecated. Please use `Document.hasTypeData` instead."
    */
-  static get hasSystemData(): boolean;
+  static get hasSystemData(): undefined | true;
 
   /**
    * A reusable helper for adding migration shims.
    */
-  protected static _addDataFieldShims(data: object, shims: object, options: object): unknown;
-
+  // options: not null (parameter default only in _addDataFieldShim)
+  protected static _addDataFieldShims(
+    data: AnyMutableObject,
+    shims: Record<string, string>,
+    options?: Document.DataFieldShimOptions,
+  ): void;
   /**
    * A reusable helper for adding a migration shim
    */
-  protected static _addDataFieldShim(data: object, oldKey: string, newKey: string, options?: object): unknown;
+  // options: not null (parameter default only)
+  protected static _addDataFieldShim(
+    data: AnyMutableObject,
+    oldKey: string,
+    newKey: string,
+    options?: Document.DataFieldShimOptions,
+  ): void;
 
   /**
    * Define a simple migration from one field name to another.
@@ -873,15 +854,16 @@ declare abstract class Document<
    * @param oldKey - The old field name
    * @param newKey - The new field name
    * @param apply  - An application function, otherwise the old value is applied
-   * @internal
+   * @remarks Foundry marked `@internal`
    */
   protected static _addDataFieldMigration(
-    data: object,
+    data: AnyMutableObject,
     oldKey: string,
     newKey: string,
-    apply?: (data: object) => any,
+    apply?: (data: AnyMutableObject) => unknown,
   ): unknown;
 
+  // options: not null (destructured where forwarded)
   protected static _logDataFieldMigration(
     oldKey: string,
     newKey: string,
@@ -890,81 +872,58 @@ declare abstract class Document<
 
   /**
    * @deprecated since v12, will be removed in v14
-   * @remarks `"The Document._onCreateDocuments static method is deprecated in favor of Document._onCreateOperation"`
+   * @remarks "The `Document._onCreateDocuments` static method is deprecated in favor of {@link Document._onCreateOperation | `Document._onCreateOperation`}"
    */
-  protected static _onCreateDocuments<T extends Document.AnyConstructor>(
-    this: T,
-    documents: Array<Document.ToConfiguredInstance<T>>,
+  // Note: This uses `never` because it's unsound to try to do `Document._onCreateDocuments` directly.
+  protected static _onCreateDocuments(
+    documents: never,
     context: Document.ModificationContext<Document.Any | null>,
   ): Promise<void>;
 
   /**
    * @deprecated since v12, will be removed in v14
-   * @remarks `"The Document._onUpdateDocuments static method is deprecated in favor of Document._onUpdateOperation"`
+   * @remarks "The `Document._onUpdateDocuments` static method is deprecated in favor of {@link Document._onUpdateOperation | `Document._onUpdateOperation`}"
    */
-  protected static _onUpdateDocuments<T extends Document.AnyConstructor>(
-    this: T,
-    documents: Array<Document.ToConfiguredInstance<T>>,
+  // Note: This uses `never` because it's unsound to try to do `Document._onUpdateDocuments` directly.
+  protected static _onUpdateDocuments(
+    documents: never,
     context: Document.ModificationContext<Document.Any | null>,
   ): Promise<unknown>;
 
   /**
    * @deprecated since v12, will be removed in v14
-   * @remarks `"The Document._onDeleteDocuments static method is deprecated in favor of Document._onDeleteOperation"`
+   * @remarks "The `Document._onDeleteDocuments` static method is deprecated in favor of {@link Document._onDeleteOperation | `Document._onDeleteOperation`}"
    */
-  protected static _onDeleteDocuments<T extends Document.AnyConstructor>(
-    this: T,
-    documents: Array<Document.ToConfiguredInstance<T>>,
+  // Note: This uses `never` because it's unsound to try to do `Document._onDeleteDocuments` directly.
+  protected static _onDeleteDocuments(
+    documents: never,
     context: Document.ModificationContext<Document.Any | null>,
   ): Promise<unknown>;
-}
 
-declare abstract class AnyDocument extends Document<any, any, any> {
-  constructor(arg0: never, ...args: never[]);
+  static " fvtt_types_internal_document_name_static": Document.Type;
 
-  // Note(LukeAbby): Specifically adding the `__DocumentBrand` should be redundant but in practice it seems to help tsc more efficiently deduce that it's actually inheriting from `Document`.
-  // This is odd but probably is because it bails from looking up the parent class properties at times or something.
-  static [__DocumentBrand]: never;
+  " fvtt_types_internal_document_name": DocumentName;
+  " fvtt_types_internal_document_schema": Schema;
+  " fvtt_types_internal_document_parent": Parent;
+}
 
-  flags?: unknown;
+// An empty schema is the most accurate because index signatures are stripped.
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+declare abstract class AnyDocument extends Document<Document.Type, {}, Document.Any | null> {
+  constructor(...args: never);
 
-  getFlag(scope: never, key: never): any;
+  // Note(LukeAbby): This uses `object` instead of `AnyObject` to avoid more thorough evaluation of
+  // the involved types which can cause a loop.
+  _source: object;
 }
 
-// Note(LukeAbby): The point of this class is to show up in intellisense.
-// When something fails to be configured it should be replaced with `typeof ConfigurationFailure & typeof Item` or whatever the relevant class is.
-// This helps to minimize the number of errors that appears in a repo with broken configuration as they can be very misleading and confusing.
-declare abstract class ConfigurationFailure extends AnyDocument {}
-
 declare namespace Document {
-  /** Any Document, except for Settings */
-  type Any = AnyDocument;
+  interface Any extends AnyDocument {}
+  interface AnyStored extends Stored<Any> {}
+  interface AnyValid extends AnyDocument {}
+  interface AnyConstructor extends Identity<typeof AnyDocument> {}
 
-  type Type =
-    | "ActiveEffect"
-    | "ActorDelta"
-    | "Actor"
-    | "Adventure"
-    | "Card"
-    | "Cards"
-    | "ChatMessage"
-    | "Combat"
-    | "Combatant"
-    | "FogExploration"
-    | "Folder"
-    | "Item"
-    | "JournalEntryPage"
-    | "JournalEntry"
-    | "Macro"
-    | "PlaylistSound"
-    | "Playlist"
-    | "RollTable"
-    | "Scene"
-    | "Setting"
-    | "TableResult"
-    | "User"
-    // All placeables also have a corresponding document class.
-    | PlaceableType;
+  type Type = CONST.ALL_DOCUMENT_TYPES;
 
   type PlaceableType =
     | "AmbientLight"
@@ -972,12 +931,89 @@ declare namespace Document {
     | "Drawing"
     | "MeasuredTemplate"
     | "Note"
+    | "Region"
     | "Tile"
     | "Token"
     | "Wall";
 
+  type PrimaryType = CONST.PRIMARY_DOCUMENT_TYPES;
+  type EmbeddedType = CONST.EMBEDDED_DOCUMENT_TYPES;
+  type WorldType = CONST.WORLD_DOCUMENT_TYPES;
+  type CompendiumType = CONST.COMPENDIUM_DOCUMENT_TYPES;
+
+  type WithSubTypes = WithSystem | "Folder" | "Macro" | "TableResult";
+
+  type WithSystem =
+    | "ActiveEffect"
+    | "ActorDelta"
+    | "Actor"
+    | "Card"
+    | "Cards"
+    | "ChatMessage"
+    | "Combat"
+    | "Combatant"
+    | "Item"
+    | "JournalEntryPage"
+    | "RegionBehavior";
+
+  // The `data` parameter has a default of `{}`. This means it's optional in that scenario.
+  // Note(LukeAbby): Update when `ParameterWithDefaults` is added.
+  // `CreateData` also should be updated to allow `undefined` directly.
+  type ConstructorParameters<CreateData extends object | undefined, Parent extends Document.Any | null> = [
+    // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+    {},
+  ] extends [CreateData]
+    ? [data?: CreateData, context?: Document.ConstructionContext<Parent>]
+    : [data: CreateData, context?: Document.ConstructionContext<Parent>];
+
   type CoreTypesForName<Name extends Type> = string &
-    GetKey<Document.Internal.SimpleMetadata<Name>, "coreTypes", ["base"]>[number];
+    GetKey<Document.MetadataFor<Name>, "coreTypes", [CONST.BASE_DOCUMENT_TYPE]>[number];
+
+  type ConfiguredSubTypesOf<Name extends Type> = Name extends "ActorDelta"
+    ? ConfiguredSubTypesOf<"Actor">
+    : string & (keyof GetKey<DataModelConfig, Name, unknown> | keyof GetKey<SourceConfig, Name, unknown>);
+
+  type SubTypesOf<Name extends Type> = Name extends "ActorDelta"
+    ? SubTypesOf<"Actor">
+    :
+        | Document.CoreTypesForName<Name>
+        | ConfiguredSubTypesOf<Name>
+        | (Document.MetadataFor<Name> extends { readonly hasTypeData: true } ? Document.ModuleSubtype : never);
+
+  type ModuleSubtype = Brand<`${string}.${string}`, "Document.ModuleSubtype">;
+
+  type OfType<Name extends WithSubTypes, SubType extends SubTypesOf<Name>> =
+    | (Name extends "ActiveEffect" ? ActiveEffect.OfType<SubType & ActiveEffect.SubType> : never)
+    | (Name extends "ActorDelta" ? ActorDelta.OfType<SubType & ActorDelta.SubType> : never)
+    | (Name extends "Actor" ? Actor.OfType<SubType & Actor.SubType> : never)
+    | (Name extends "Card" ? Card.OfType<SubType & Card.SubType> : never)
+    | (Name extends "Cards" ? Cards.OfType<SubType & Cards.SubType> : never)
+    | (Name extends "ChatMessage" ? ChatMessage.OfType<SubType & ChatMessage.SubType> : never)
+    | (Name extends "Combat" ? Combat.OfType<SubType & Combat.SubType> : never)
+    | (Name extends "Combatant" ? Combatant.OfType<SubType & Combatant.SubType> : never)
+    | (Name extends "Folder" ? Folder.OfType<SubType & Folder.SubType> : never)
+    | (Name extends "Item" ? Item.OfType<SubType & Item.SubType> : never)
+    | (Name extends "JournalEntryPage" ? JournalEntryPage.OfType<SubType & JournalEntryPage.SubType> : never)
+    | (Name extends "Macro" ? Macro.OfType<SubType & Macro.SubType> : never)
+    | (Name extends "RegionBehavior" ? RegionBehavior.OfType<SubType & RegionBehavior.SubType> : never)
+    | (Name extends "TableResult" ? TableResult.OfType<SubType & TableResult.SubType> : never);
+
+  /**
+   * With the existence of custom module subtypes a system can no longer rely on their configured types being the only ones.
+   * A module can provide its own custom type though it is always of the form `${moduleName}.${subType}` so the `.` is a pretty
+   * strong indicator.
+   *
+   * `UnknownSourceData` covers the case where it's configured without a data model.
+   * See {@link UnknownSystem | `UnknownSystem`} for other possibilities.
+   */
+  interface UnknownSourceData extends AnyObject {
+    type: ModuleSubtype;
+  }
+
+  /**
+   * With the existence of custom module subtypes a system can no longer rely on their configured types being the only ones.
+   */
+  type UnknownSystem = UnknownSourceData | TypeDataField.UnknownTypeDataModel | DataModel.UnknownDataModel;
 
   // TODO: Probably a way to auto-determine this
   type SystemType =
@@ -989,170 +1025,324 @@ declare namespace Document {
     | "Combat"
     | "Combatant"
     | "Item"
-    | "JournalEntryPage";
+    | "JournalEntryPage"
+    | "RegionBehavior";
+
+  namespace Embedded {
+    type CollectionNameFor<
+      Embedded extends Document.Metadata.Embedded,
+      CollectionName extends Document.Embedded.CollectionName<Embedded>,
+    > = Extract<GetKey<Metadata.Embedded, CollectionName, CollectionName>, Document.Type>;
+
+    type DocumentFor<
+      Embedded extends Document.Metadata.Embedded,
+      CollectionName extends Document.Embedded.CollectionName<Embedded>,
+    > = Document.ImplementationFor<CollectionNameFor<Embedded, CollectionName>>;
+
+    type CollectionFor<
+      Parent extends Document.Any,
+      Embedded extends Document.Metadata.Embedded,
+      CollectionName extends Document.Embedded.CollectionName<Embedded>,
+    > = EmbeddedCollection<DocumentFor<Embedded, CollectionName>, Parent>;
+
+    type CollectionName<Embedded extends Document.Metadata.Embedded> = {
+      [K in keyof Embedded]: K extends Document.Type ? Extract<K | Embedded[K], string> : never;
+    }[keyof Embedded];
+  }
 
-  type EmbeddableNamesFor<ConcreteDocument extends Document.Internal.Instance.Any> = {
-    [K in keyof ConfiguredDocuments]: IsParentOf<ConcreteDocument, InstanceType<ConfiguredDocuments[K]>> extends true
-      ? K
-      : never;
-  };
+  /**
+   * @internal
+   */
+  interface _WorldCollectionMap {
+    Actor: Actors.Configured;
+    Cards: CardStacks;
+    Combat: CombatEncounters;
+    FogExploration: FogExplorations;
+    Folder: Folders;
+    Item: Items;
+    JournalEntry: Journal;
+    Macro: Macros;
+    ChatMessage: Messages;
+    Playlist: Playlists;
+    Scene: Scenes;
+    Setting: WorldSettings;
+    RollTable: RollTables;
+    User: Users;
+  }
+
+  type WorldCollectionFor<Name extends Document.WorldType> = _WorldCollectionMap[Name];
+
+  // Note(LukeAbby): Will be updated with the CONFIG revamp.
+  type ConfiguredCollectionClass<Name extends Document.Type> = CONFIG extends {
+    readonly [K in Name]: {
+      readonly documentClass?: infer DocumentClass;
+    };
+  }
+    ? DocumentClass
+    : never;
+
+  // Note(LukeAbby): Will be updated with the CONFIG revamp.
+  type ConfiguredCollection<Name extends Document.Type> = FixedInstanceType<ConfiguredCollectionClass<Name>>;
 
   type IsParentOf<
     ParentDocument extends Document.Internal.Instance.Any,
     ChildDocument extends Document.Internal.Instance.Any,
   > = ParentDocument extends Internal.ParentFor<ChildDocument> ? true : false;
 
+  type SocketRequest<Action extends DatabaseAction> = DocumentSocketRequest<Action>;
+  type SocketResponse<Action extends DatabaseAction> = DocumentSocketResponse<Action>;
+
   // Documented at https://gist.github.com/LukeAbby/c7420b053d881db4a4d4496b95995c98
   namespace Internal {
-    type SimpleMetadata<Name extends Document.Type> = ConfiguredMetadata<Document.Any>[Name];
-
-    type Constructor = (abstract new (arg0: never, ...args: never[]) => Instance.Any) & {
-      [__DocumentBrand]: never;
+    type Constructor = (abstract new (...args: never) => Instance.Any) & {
+      " fvtt_types_internal_document_name_static": Document.Type;
     };
 
-    interface Instance<Schema extends DataSchema, Parent extends Document.Internal.Instance.Any | null> {
-      [__Schema]: Schema;
-      [__Parent]: Parent;
+    interface Instance<
+      DocumentName extends Document.Type,
+      Schema extends DataSchema,
+      Parent extends Document.Internal.Instance.Any | null,
+    > {
+      " fvtt_types_internal_document_name": DocumentName;
+      " fvtt_types_internal_document_schema": Schema;
+      " fvtt_types_internal_document_parent": Parent;
     }
 
-    type SchemaFor<ConcreteInstance extends Instance.Any> = ConcreteInstance[typeof __Schema];
+    type DocumentNameFor<ConcreteInstance extends Instance.Any> =
+      ConcreteInstance[" fvtt_types_internal_document_name"];
 
-    type ParentFor<ConcreteInstance extends Instance.Any> = ConcreteInstance[typeof __Parent];
+    type SchemaFor<ConcreteInstance extends Instance.Any> = ConcreteInstance[" fvtt_types_internal_document_schema"];
+
+    type ParentFor<ConcreteInstance extends Instance.Any> = ConcreteInstance[" fvtt_types_internal_document_parent"];
 
     namespace Instance {
-      type Any = Instance<any, any>;
+      interface Any extends Instance<any, any, any> {}
 
       type Complete<T extends Any> = T extends Document.Any ? T : never;
     }
+
+    type OfType<Configured, Document extends Document.Any> = Configured extends { document: infer D }
+      ? D extends Document
+        ? D
+        : FixedInstanceType<ConfigurationFailure[Document["documentName"]]>
+      : Document;
+
+    type SystemMap<Name extends Document.WithSystem> = _SystemMap<
+      Name,
+      GetKey<DataModelConfig, Name>,
+      GetKey<SourceConfig, Name>
+    >;
+
+    type _SystemMap<Name extends Document.WithSystem, DataModel, SourceData> = {
+      [SubType in SubTypesOf<Name>]: DataModel extends {
+        [K in SubType]: abstract new (...args: infer _) => infer Model;
+      }
+        ? Model
+        : SourceData extends {
+              [K in SubType]: infer Source;
+            }
+          ? Source
+          : SubType extends Document.ModuleSubtype
+            ? // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+              {}
+            : UnknownSystem;
+    };
+
+    type SystemOfType<SystemMap extends Record<SubType, object>, SubType extends string> =
+      | DiscriminatedUnion<SystemMap[SubType]>
+      | (SubType extends ModuleSubtype ? UnknownSystem : never);
   }
 
   /** Any Document, that is a child of the given parent Document. */
-  type AnyChild<Parent extends Any | null> = Document<any, any, Parent>;
+  // An empty schema is the most appropriate type due to removing index signatures.
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+  type AnyChild<Parent extends Any | null> = Document<Document.Type, {}, Parent>;
 
-  type AnyConstructor = typeof AnyDocument;
+  /**
+   * @deprecated {@link Document.CreateDataFor | `Document.CreateDataFor`}
+   */
+  type ConstructorDataFor<T extends Document.Internal.Constructor> = SchemaField.CreateData<
+    T extends { defineSchema: () => infer R extends DataSchema } ? R : never
+  >;
 
   /**
-   * Returns the type of the constructor data for the given {@link foundry.abstract.Document}.
+   * Returns the type of the constructor data for the given {@link foundry.abstract.Document | `foundry.abstract.Document`}.
    */
-  type ConstructorDataFor<T extends Document.Internal.Constructor> = ConstructorDataForSchema<
+  type CreateDataFor<T extends Document.Internal.Constructor> = SchemaField.CreateData<
     T extends { defineSchema: () => infer R extends DataSchema } ? R : never
   >;
 
-  // TODO(LukeAbby): Actually make this distinguishable from `Document.ConstructorDataFor` and `Document.ConstructorDataForSchema`.
-  type UpdateDataFor<T extends Document.Internal.Constructor> = ConstructorDataForSchema<
+  type UpdateDataFor<T extends Document.Internal.Constructor> = SchemaField.UpdateData<
     T extends { defineSchema: () => infer R extends DataSchema } ? R : never
   >;
 
   // These helper types exist to help break a loop
-  type ConstructorDataForName<T extends Document.Type> = ConstructorData[T];
-  type UpdateDataForName<T extends Document.Type> = ConstructorData[T];
 
-  type ConstructorDataForSchema<Schema extends DataSchema> =
-    foundry.data.fields.SchemaField.InnerAssignmentType<Schema>;
+  type CreateDataForName<DocumentType extends Document.Type> =
+    | (DocumentType extends "ActiveEffect" ? ActiveEffect.CreateData : never)
+    | (DocumentType extends "ActorDelta" ? ActorDelta.CreateData : never)
+    | (DocumentType extends "Actor" ? Actor.CreateData : never)
+    | (DocumentType extends "Adventure" ? Adventure.CreateData : never)
+    | (DocumentType extends "Card" ? Card.CreateData : never)
+    | (DocumentType extends "Cards" ? Cards.CreateData : never)
+    | (DocumentType extends "ChatMessage" ? ChatMessage.CreateData : never)
+    | (DocumentType extends "Combat" ? Combat.CreateData : never)
+    | (DocumentType extends "Combatant" ? Combatant.CreateData : never)
+    | (DocumentType extends "FogExploration" ? FogExploration.CreateData : never)
+    | (DocumentType extends "Folder" ? Folder.CreateData : never)
+    | (DocumentType extends "Item" ? Item.CreateData : never)
+    | (DocumentType extends "JournalEntryPage" ? JournalEntryPage.CreateData : never)
+    | (DocumentType extends "JournalEntry" ? JournalEntry.CreateData : never)
+    | (DocumentType extends "Macro" ? Macro.CreateData : never)
+    | (DocumentType extends "PlaylistSound" ? PlaylistSound.CreateData : never)
+    | (DocumentType extends "Playlist" ? Playlist.CreateData : never)
+    | (DocumentType extends "RegionBehavior" ? RegionBehavior.CreateData : never)
+    | (DocumentType extends "RollTable" ? RollTable.CreateData : never)
+    | (DocumentType extends "Scene" ? Scene.CreateData : never)
+    | (DocumentType extends "Setting" ? Setting.CreateData : never)
+    | (DocumentType extends "TableResult" ? TableResult.CreateData : never)
+    | (DocumentType extends "User" ? User.CreateData : never)
+    | (DocumentType extends "AmbientLight" ? AmbientLightDocument.CreateData : never)
+    | (DocumentType extends "AmbientSound" ? AmbientSoundDocument.CreateData : never)
+    | (DocumentType extends "Drawing" ? DrawingDocument.CreateData : never)
+    | (DocumentType extends "MeasuredTemplate" ? MeasuredTemplateDocument.CreateData : never)
+    | (DocumentType extends "Note" ? NoteDocument.CreateData : never)
+    | (DocumentType extends "Region" ? RegionDocument.CreateData : never)
+    | (DocumentType extends "Tile" ? TileDocument.CreateData : never)
+    | (DocumentType extends "Token" ? TokenDocument.CreateData : never)
+    | (DocumentType extends "Wall" ? WallDocument.CreateData : never);
+
+  type UpdateDataForName<DocumentType extends Document.Type> =
+    | (DocumentType extends "ActiveEffect" ? ActiveEffect.UpdateData : never)
+    | (DocumentType extends "ActorDelta" ? ActorDelta.UpdateData : never)
+    | (DocumentType extends "Actor" ? Actor.UpdateData : never)
+    | (DocumentType extends "Adventure" ? Adventure.UpdateData : never)
+    | (DocumentType extends "Card" ? Card.UpdateData : never)
+    | (DocumentType extends "Cards" ? Cards.UpdateData : never)
+    | (DocumentType extends "ChatMessage" ? ChatMessage.UpdateData : never)
+    | (DocumentType extends "Combat" ? Combat.UpdateData : never)
+    | (DocumentType extends "Combatant" ? Combatant.UpdateData : never)
+    | (DocumentType extends "FogExploration" ? FogExploration.UpdateData : never)
+    | (DocumentType extends "Folder" ? Folder.UpdateData : never)
+    | (DocumentType extends "Item" ? Item.UpdateData : never)
+    | (DocumentType extends "JournalEntryPage" ? JournalEntryPage.UpdateData : never)
+    | (DocumentType extends "JournalEntry" ? JournalEntry.UpdateData : never)
+    | (DocumentType extends "Macro" ? Macro.UpdateData : never)
+    | (DocumentType extends "PlaylistSound" ? PlaylistSound.UpdateData : never)
+    | (DocumentType extends "Playlist" ? Playlist.UpdateData : never)
+    | (DocumentType extends "RegionBehavior" ? RegionBehavior.UpdateData : never)
+    | (DocumentType extends "RollTable" ? RollTable.UpdateData : never)
+    | (DocumentType extends "Scene" ? Scene.UpdateData : never)
+    | (DocumentType extends "Setting" ? Setting.UpdateData : never)
+    | (DocumentType extends "TableResult" ? TableResult.UpdateData : never)
+    | (DocumentType extends "User" ? User.UpdateData : never)
+    | (DocumentType extends "AmbientLight" ? AmbientLightDocument.UpdateData : never)
+    | (DocumentType extends "AmbientSound" ? AmbientSoundDocument.UpdateData : never)
+    | (DocumentType extends "Drawing" ? DrawingDocument.UpdateData : never)
+    | (DocumentType extends "MeasuredTemplate" ? MeasuredTemplateDocument.UpdateData : never)
+    | (DocumentType extends "Note" ? NoteDocument.UpdateData : never)
+    | (DocumentType extends "Region" ? NoteDocument.UpdateData : never)
+    | (DocumentType extends "Tile" ? TileDocument.UpdateData : never)
+    | (DocumentType extends "Token" ? TokenDocument.UpdateData : never)
+    | (DocumentType extends "Wall" ? WallDocument.UpdateData : never);
+
+  /**
+   * @deprecated {@link SchemaField.CreateData | `SchemaField.CreateData`}
+   */
+  type ConstructorDataForSchema<Schema extends DataSchema> = SchemaField.CreateData<Schema>;
 
   type SystemConstructor = AnyConstructor & {
     metadata: { name: SystemType };
   };
 
-  // TODO(LukeAbby): Look into this. Inconsistent name, deprecate?
-  type ConfiguredClass<T extends { metadata: Metadata.Any }> = ConfiguredClassForName<T["metadata"]["name"]>;
-
-  type ConfiguredClassForName<Name extends Type> = MakeConform<
-    ConfiguredDocuments[Name],
-    typeof ConfigurationFailure & DefaultDocuments[Name]
+  type ToConfiguredClass<ConcreteDocument extends Document.Internal.Constructor> = ImplementationClassFor<
+    NameFor<ConcreteDocument>
   >;
 
-  type SubTypesOf<T extends Type> =
-    ConfiguredInstanceForName<T> extends { type: infer Types } ? Types : typeof foundry.CONST.BASE_DOCUMENT_TYPE;
-
-  // NOTE(LukeAbby): This type is less DRY than it could be to avoid undue complexity in such a critical helpeer.
-  // This has _many_ times been seen to cause loops so this type is written in an intentionally more paranoid way.
-  // The reason for the verbosity and repetition is to avoid eagerly evaluating any branches that might cause a loop.
-  type ToConfiguredClass<ConcreteDocument extends Document.Internal.Constructor> =
-    NameFor<ConcreteDocument> extends keyof DocumentClassConfig
-      ? MakeConform<
-          ConfiguredDocuments[NameFor<ConcreteDocument>],
-          typeof ConfigurationFailure & DefaultDocuments[NameFor<ConcreteDocument>]
-        >
-      : DefaultDocuments[NameFor<ConcreteDocument>];
-
-  type ToConfiguredInstance<ConcreteDocument extends Document.Internal.Constructor> =
-    ConfiguredDocuments[NameFor<ConcreteDocument>] extends Document.AnyConstructor
-      ? _CheckConfiguredInstance<
-          NameFor<ConcreteDocument>,
-          InstanceType<ConfiguredDocuments[NameFor<ConcreteDocument>]>
-        >
-      : InstanceType<DefaultDocuments[NameFor<ConcreteDocument>]>;
-
-  /**
-   * @internal
-   */
-  type _CheckConfiguredInstance<Name extends Document.Type, T> = T extends Document.Any
-    ? T
-    : ConfigurationFailure & DefaultDocuments[Name];
+  type ToConfiguredInstance<ConcreteDocument extends Document.Internal.Constructor> = MakeConform<
+    FixedInstanceType<ConfiguredDocumentClass[NameFor<ConcreteDocument>]>,
+    Document.Any
+    // TODO(LukeAbby): Look into if there's a way to do this without causing circular loops.
+    // FixedInstanceType<ConfigurationFailure[Name]>
+  >;
 
-  type ToConfiguredStored<D extends Document.Internal.Constructor> = Stored<ToConfiguredInstance<D>>;
+  type ToConfiguredStored<D extends Document.AnyConstructor> = Stored<ToConfiguredInstance<D>>;
 
-  type Stored<D extends Document.Internal.Instance.Any> = D & {
+  type Stored<D extends Document.Any> = D & {
     id: string;
     _id: string;
     _source: GetKey<D, "_source"> & { _id: string };
   };
 
-  type ToStoredIf<
-    D extends Document.Internal.Constructor,
-    Temporary extends boolean | undefined,
-  > = Temporary extends true ? ToConfiguredStored<D> : ToConfiguredInstance<D>;
+  type Invalid<D extends Document.Any> = SimpleMerge<
+    D,
+    {
+      id: string;
+      _id: string;
+      _source: object;
+      system: object;
+    }
+  >;
 
-  type Temporary<D extends Document.Internal.Instance.Any> = D extends Stored<infer U> ? U : D;
+  type ToStored<D extends Document.AnyConstructor> = Stored<FixedInstanceType<D>>;
 
-  type NameFor<ConcreteDocument extends Document.Internal.Constructor> = ConcreteDocument extends {
-    readonly metadata: { readonly name: infer Name extends Type };
-  }
-    ? Name
-    : never;
+  type ToStoredIf<D extends Document.AnyConstructor, Temporary extends boolean | undefined> = Temporary extends true
+    ? FixedInstanceType<D>
+    : ToConfiguredStored<D>;
 
-  type ConfiguredInstanceForName<Name extends Type> = MakeConform<
-    InstanceType<ConfiguredDocuments[Name]>,
-    Document.Any
-  >;
+  /** @deprecated {@link Document.TemporaryIf | `Document.TemporaryIf`} */
+  type StoredIf<D extends Document.Any, Temporary extends boolean | undefined> = TemporaryIf<D, Temporary>;
+
+  type TemporaryIf<D extends Document.Any, Temporary extends boolean | undefined> = Temporary extends true
+    ? D
+    : Stored<D>;
 
-  type ConfiguredObjectClassForName<Name extends PlaceableType> = CONFIG[Name]["objectClass"];
-  type ConfiguredObjectInstanceForName<Name extends PlaceableType> = InstanceType<CONFIG[Name]["objectClass"]>;
+  type Temporary<D extends Document.Any> = D extends Stored<infer U> ? U : D;
+
+  type NameFor<ConcreteDocument extends Document.Internal.Constructor> =
+    ConcreteDocument[" fvtt_types_internal_document_name_static"];
+
+  type ImplementationFor<Name extends Type> = ConfiguredDocumentInstance[Name];
+  type ImplementationClassFor<Name extends Type> = ConfiguredDocumentClass[Name];
+
+  type ObjectClassFor<Name extends PlaceableType> = CONFIG[Name]["objectClass"];
+  type ObjectFor<Name extends PlaceableType> = FixedInstanceType<CONFIG[Name]["objectClass"]>;
+
+  /**
+   * @deprecated {@link ObjectClassFor | `ObjectClassFor`}
+   */
+  type ConfiguredObjectClassForName<Name extends PlaceableType> = ObjectClassFor<Name>;
+
+  /**
+   * @deprecated {@link ObjectFor | `ObjectFor`}
+   */
+  type ConfiguredObjectInstanceForName<Name extends PlaceableType> = ObjectFor<Name>;
 
   type ConfiguredDataForName<Name extends Type> = GetKey<DataConfig, Name, EmptyObject>;
 
   type ConfiguredSourceForName<Name extends Type> = GetKey<SourceConfig, Name, EmptyObject>;
 
-  type ConfiguredFlagsForName<Name extends Type> = GetKey<FlagConfig, Name, EmptyObject>;
-
-  type ToObjectFalseType<T extends Document.Internal.Instance.Any> = T extends {
-    toObject: (source: false) => infer U;
-  }
-    ? U
-    : T;
+  // The type `{}` is useful here because in an intersection it reduces down to nothing unlike `EmptyObject`.
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+  type ConfiguredFlagsForName<Name extends Type> = GetKey<FlagConfig, Name, {}>;
 
   type SchemaFor<ConcreteDocument extends Internal.Instance.Any> =
-    ConcreteDocument extends Internal.Instance<infer Schema, any> ? Schema : never;
+    ConcreteDocument extends Internal.Instance<infer _1, infer Schema, infer _2> ? Schema : never;
 
-  type MetadataFor<ConcreteDocument extends Document.Internal.Instance.Any> =
-    ConfiguredMetadata<ConcreteDocument>[ConcreteDocument extends {
-      readonly documentName: infer Name extends Document.Type;
-    }
-      ? Name
-      : never];
+  type MetadataFor<Name extends Document.Type> = ConfiguredMetadata[Name];
 
   type CollectionRecord<Schema extends DataSchema> = {
-    [Key in keyof Schema]: Schema[Key] extends fields.EmbeddedCollectionField.Any ? Schema[Key] : never;
+    [Key in keyof Schema]: Schema[Key] extends EmbeddedCollectionField.Any ? Schema[Key] : never;
   };
 
   type Flags<ConcreteDocument extends Internal.Instance.Any> = OptionsForSchema<SchemaFor<ConcreteDocument>>;
 
-  interface OptionsInFlags<Options extends DataFieldOptions.Any> {
+  /** @internal */
+  interface OptionsInFlags<Options extends DataField.Options.Any> {
     readonly flags?: DataField<Options, any>;
   }
 
-  // These  types only exists to simplify solving the `Document` type. Using `Document.Flags<this>` means the constraint `this extends Document.Any` has to be proved.
+  // These types only exists to simplify solving the `Document` type. Using `Document.Flags<this>` means the constraint `this extends Document.Any` has to be proved.
   // This is much more complex than proving the constraint for `Document.FlagsInternal<Schema>` that `Schema extends DataSchema`.
 
   // TODO: This needs to use the derived flags not just how they're initialized.
@@ -1175,7 +1365,7 @@ declare namespace Document {
   type FlagGetKey<T, K extends PropertyKey> = T extends unknown ? (K extends keyof T ? T[K] : never) : never;
 
   // Note(LukeAbby): It's at times been very important for `GetFlag` to be covariant over `ConcreteSchema`.
-  // If it isn't then issues arise where the `Document` type ends up becoming invaraint.
+  // If it isn't then issues arise where the `Document` type ends up becoming invariant.
   // Currently it is actually contravariant over `ConcreteSchema` and this may cause issues (because of the usage of `keyof`).
   // Unfortunately it's not easy to avoid because the typical `GetKey` trick has issues between `never`, not defined at all, and `unknown` etc.
   type GetFlag<Name extends Document.Type, S extends string, K extends string> = FlagGetKey<
@@ -1183,30 +1373,66 @@ declare namespace Document {
     K
   >;
 
-  interface ConstructionContext<Parent extends Document.Any | null> {
+  interface CoreFlags {
+    core?: {
+      sheetLock?: boolean;
+      sheetClass?: string;
+    };
+  }
+
+  /** @internal */
+  type _ConstructionContext<Parent extends Document.Any | null> = NullishProps<{
     /**
      * The parent Document of this one, if this one is embedded
      * @defaultValue `null`
      */
-    parent?: Parent | undefined;
+    parent: Parent;
 
     /**
      * The compendium collection ID which contains this Document, if any
      * @defaultValue `null`
      */
-    pack?: string | null | undefined;
+    pack: string;
 
     /**
      * Whether to validate initial data strictly?
      * @defaultValue `true`
      */
-    strict?: boolean | null | undefined;
+    strict: boolean;
 
     /**
-     * An immutable reverse-reference to the name of the collection that thi8s Document exists in on its parent, if any.
+     * An immutable reverse-reference to the name of the collection that this Document exists in on its parent, if any.
+     * @privateRemarks Omitted from the typedef, inferred from usage in {@link Document._configure | `Document#_configure`}
+     * (and included in the construction context rather than `ConfigureOptions` due to being passed to construction in
+     * {@link foundry.abstract.EmbeddedCollection.createDocument | `EmbeddedCollection#createDocument`})
      */
-    parentCollection?: string | null | undefined;
-  }
+    parentCollection: string;
+  }>;
+
+  /**
+   * Foundry does not include the properties from the DataModel construction context in `DocumentConstructionContext`,
+   * but they're all still valid.
+   *
+   * `strict` is omitted from the DataModel interface so the Document interface's property
+   * description takes precedence.
+   */
+  interface ConstructionContext<Parent extends Document.Any | null = Document.Any | null>
+    extends Omit<DataModel._ConstructionContext, "strict">,
+      _ConstructionContext<Parent> {}
+
+  /** `DataModel#constructor` pulls `parent` and `strict` out of the passed context before forwarding to `#_configure` */
+  interface ConfigureOptions extends Omit<ConstructionContext, "parent" | "strict"> {}
+
+  /** `DataModel#constructor` pulls `parent` out of the passed context before forwarding to `#_initializeSource` */
+  interface InitializeOptions extends Omit<ConstructionContext, "parent"> {}
+
+  /**
+   * `DataModel#constructor` pulls `parent` out of the passed context before forwarding to `#_initializeSource`
+   * @privateRemarks `Document` doesn't override `_initializeSource`, but at least one specific document does (Actor only, as of v12);
+   * Without an override, this is handled by the `& ExtraConstructorOptions` in the `DataModel` signature, but with one,
+   * a manually combined interface is needed.
+   */
+  interface InitializeSourceOptions extends DataModel.InitializeSourceOptions, Omit<ConstructionContext, "parent"> {}
 
   interface ModificationContext<Parent extends Document.Any | null> {
     /**
@@ -1292,102 +1518,756 @@ declare namespace Document {
     deleteAll?: boolean | undefined;
   }
 
+  /** @internal */
+  type _CloneContext<Save extends boolean | null | undefined = boolean | null | undefined> = NullishProps<{
+    /**
+     * Save the clone to the World database?
+     * @defaultValue `false`
+     */
+    save: Save;
+
+    /**
+     * Keep the same ID of the original document
+     * @defaultValue `false`
+     */
+    keepId: boolean;
+
+    /**
+     * Track the clone source
+     * @defaultValue `false`
+     */
+    addSource: boolean;
+  }>;
+
+  /**
+   * @privateRemarks Since we've lost the ExtraConstructorOptions type param, we have to extend
+   * the (parentless) construction context
+   */
+  interface CloneContext<Save extends boolean | null | undefined = boolean | null | undefined>
+    extends _CloneContext<Save>,
+      Omit<Document.ConstructionContext, "parent"> {}
+
   type ModificationOptions = Omit<Document.ModificationContext<Document.Any | null>, "parent" | "pack">;
 
+  /* eslint-disable @typescript-eslint/no-deprecated */
+  /** @deprecated Use {@link Database.PreCreateOptions | `Database.PreCreateOptions`} */
   type PreCreateOptions<Name extends Type> = Omit<
-    DatabaseOperationsFor<Name, "create">,
+    Document.Database.OperationOf<Name, "create">,
     "data" | "noHook" | "pack" | "parent"
   >;
+
+  /** @deprecated Use {@link Database.CreateOptions | `Database.CreateOptions`}  */
   type OnCreateOptions<Name extends Type> = Omit<
-    DatabaseOperationsFor<Name, "create">,
+    Document.Database.OperationOf<Name, "create">,
     "pack" | "parentUuid" | "syntheticActorUpdate"
   >;
 
+  /** @deprecated Use {@link Database.PreUpdateOptions | `Database.PreUpdateOperation`}  */
   type PreUpdateOptions<Name extends Type> = Omit<
-    DatabaseOperationsFor<Name, "update">,
+    Document.Database.OperationOf<Name, "update">,
     "updates" | "restoreDelta" | "noHook" | "parent" | "pack"
   >;
+
+  /** @deprecated Use {@link Database.UpdateOptions | `Database.OnUpdateOperation`} */
   type OnUpdateOptions<Name extends Type> = Omit<
-    DatabaseOperationsFor<Name, "update">,
+    Document.Database.OperationOf<Name, "update">,
     "pack" | "parentUuid" | "syntheticActorUpdate"
   >;
 
+  /** @deprecated Use {@link Database.PreDeleteOperationInstance | `Database.PreDeleteOperationInstance`} */
   type PreDeleteOptions<Name extends Type> = Omit<
-    DatabaseOperationsFor<Name, "delete">,
+    Document.Database.OperationOf<Name, "delete">,
     "ids" | "deleteAll" | "noHook" | "pack" | "parent"
   >;
+
+  /** @deprecated Use {@link Database.DeleteOptions | `Database.OnDeleteOptions`} */
   type OnDeleteOptions<Name extends Type> = Omit<
-    DatabaseOperationsFor<Name, "delete">,
+    Document.Database.OperationOf<Name, "delete">,
     "deleteAll" | "pack" | "parentUuid" | "syntheticActorUpdate"
   >;
 
+  /** @deprecated Use {@link Database.PreCreateOptions | `Database.PreCreateOptions`} or {@link Database.PreUpdateOptions | `Database.PreUpdateOperation`}*/
   type PreUpsertOptions<Name extends Type> = PreCreateOptions<Name> | PreUpdateOptions<Name>;
+
+  /** @deprecated Use {@link Database.CreateOptions | `Database.CreateOptions`} or {@link Database.UpdateOptions | `Database.OnUpdateOperation`} */
   type OnUpsertOptions<Name extends Type> = OnCreateOptions<Name> | OnUpdateOptions<Name>;
+  /* eslint-enable @typescript-eslint/no-deprecated */
 
   interface Metadata<out ThisType extends Document.Any> {
     readonly name: ThisType["documentName"];
     readonly collection: string;
-    readonly indexed?: boolean | undefined;
-    readonly compendiumIndexFields?: readonly string[] | undefined;
+    readonly indexed: boolean;
+    readonly compendiumIndexFields: readonly string[];
     readonly label: string;
     readonly coreTypes: readonly string[];
-    readonly embedded: Record<string, string>;
+    readonly embedded: {
+      [DocumentType in Document.Type]?: string;
+    };
     readonly permissions: {
-      create:
-        | string
-        | ToMethod<
-            (user: foundry.documents.BaseUser, doc: ThisType, data: Document.ConstructorDataForName<Type>) => boolean
-          >;
-      update:
-        | string
-        | ToMethod<
-            (user: foundry.documents.BaseUser, doc: ThisType, data: Document.UpdateDataForName<Type>) => boolean
-          >;
-      delete: string | ToMethod<(user: foundry.documents.BaseUser, doc: ThisType, data: EmptyObject) => boolean>;
+      create: string | ToMethod<(user: User.Internal.Implementation, doc: ThisType, data: AnyObject) => boolean>;
+      update: string | ToMethod<(user: User.Internal.Implementation, doc: ThisType, data: AnyObject) => boolean>;
+      delete: string | ToMethod<(user: User.Internal.Implementation, doc: ThisType, data: EmptyObject) => boolean>;
     };
-    readonly preserveOnImport?: readonly string[] | undefined;
-    readonly schemaVersion: string | undefined;
-    readonly labelPlural: string; // This is not set for the Document class but every class that implements Document actually provides it.
-    readonly types: readonly string[];
-    readonly hasSystemData: boolean;
+    readonly preserveOnImport: readonly string[];
+    readonly schemaVersion?: string | undefined;
+    readonly labelPlural?: string; // This is not set for the Document class but every class that implements Document actually provides it.
+    readonly types?: readonly string[];
+    readonly hasSystemData?: boolean;
   }
 
   namespace Metadata {
-    type Any = Metadata<any>;
-
-    export interface Default {
-      name: "Document";
-      collection: "documents";
-      label: "DOCUMENT.Document";
-      coreTypes: [typeof foundry.CONST.BASE_DOCUMENT_TYPE];
-      types: [];
-      embedded: EmptyObject;
-      hasSystemData: false;
-      permissions: {
+    interface Any extends Metadata<any> {}
+
+    interface Default {
+      readonly name: "Document";
+      readonly collection: "documents";
+      readonly indexed: false;
+      readonly compendiumIndexFields: [];
+      readonly label: "DOCUMENT.Document";
+      readonly coreTypes: [CONST.BASE_DOCUMENT_TYPE];
+      readonly embedded: EmptyObject;
+      readonly permissions: {
         create: "ASSISTANT";
         update: "ASSISTANT";
         delete: "ASSISTANT";
       };
-      pack: null;
+      readonly preserveOnImport: ["_id", "sort", "ownership"];
     }
+
+    interface Embedded extends Identity<{ [K in Document.Type]?: string }> {}
   }
-}
 
-export type Operation = "create" | "update" | "delete";
-
-/* eslint-disable @typescript-eslint/no-empty-object-type */
-export interface DocumentDatabaseOperations<
-  T extends Document.Internal.Instance.Any = Document.Internal.Instance.Any,
-  ExtraCreateOptions extends AnyObject = {},
-  ExtraUpdateOptions extends AnyObject = {},
-  ExtraDeleteOptions extends AnyObject = {},
-> {
-  create: DatabaseCreateOperation<T> & InexactPartial<ExtraCreateOptions>;
-  update: DatabaseUpdateOperation<T> & InexactPartial<ExtraUpdateOptions>;
-  delete: DatabaseDeleteOperation & InexactPartial<ExtraDeleteOptions>;
+  type ConfiguredSheetClassFor<Name extends Document.Type> = MakeConform<
+    GetKey<GetKey<CONFIG, Name>, "sheetClass">,
+    AnyConstructor
+  >;
+
+  type ConfiguredObjectClassFor<Name extends Document.Type> = GetKey<GetKey<CONFIG, Name>, "objectClass">;
+
+  type ConfiguredLayerClassFor<Name extends Document.Type> = GetKey<GetKey<CONFIG, Name>, "layerClass">;
+
+  type DropData<T extends Document.Any> = T extends { id: string | undefined }
+    ? DropData.Data<T> & DropData.UUID
+    : DropData.Data<T>;
+
+  namespace DropData {
+    type Any = DropData<any>;
+
+    interface Data<T extends Document.Any> {
+      type: T["documentName"];
+      data: T["_source"];
+    }
+
+    interface UUID {
+      uuid: string;
+    }
+  }
+
+  namespace Database {
+    type Operation = "create" | "update" | "delete";
+
+    /**
+     * @privateRemarks Foundry types {@link Document.get | `Document.get`} as taking a {@link DatabaseGetOperation | `DatabaseGetOperation`}
+     * but it only ever looks for `pack`
+     */
+    interface GetOptions extends Pick<DatabaseGetOperation, "pack"> {}
+
+    /** Used for {@link Document.createDocuments | `Document.createDocuments`} */
+    type CreateOperation<Op extends DatabaseCreateOperation> = NullishProps<Omit<Op, "data" | "modifiedTime">>;
+
+    /** Used for {@link Document.update | `Document.update`} */
+    type UpdateOperation<Op extends DatabaseUpdateOperation> = InexactPartial<Omit<Op, "updates">>;
+
+    /** Used for {@link Document.delete | `Document.delete`} */
+    type DeleteOperation<Op extends DatabaseDeleteOperation> = InexactPartial<Omit<Op, "ids">>;
+
+    /** Used for {@link Document._preCreateOperation | `Document._preCreateOperation`} */
+    type PreCreateOperationStatic<Op extends DatabaseCreateOperation> = InexactPartial<
+      Op,
+      Exclude<AllKeysOf<Op>, "modifiedTime" | "render" | "renderSheet" | "data" | "noHook" | "pack" | "parent">
+    >;
+
+    /** Used for {@link Document._preCreate | `Document#_preCreate`} */
+    type PreCreateOptions<Op extends DatabaseCreateOperation> = Omit<
+      PreCreateOperationStatic<Op>,
+      "data" | "noHook" | "pack" | "parent"
+    >;
+
+    /** Used for {@link Document._onCreate | `Document#_onCreate`} */
+    type CreateOptions<Op extends DatabaseCreateOperation> = Omit<
+      Op,
+      "data" | "pack" | "parentUuid" | "syntheticActorUpdate"
+    >;
+
+    /** Used for {@link Document.updateDocuments | `Document.updateDocuments`} */
+    type UpdateDocumentsOperation<Op extends DatabaseUpdateOperation> = NullishProps<
+      Omit<Op, "updates" | "modifiedTime">
+    >;
+
+    /** Used for {@link Document.update | `Document#update`} */
+    type UpdateOperationInstance<Op extends DatabaseUpdateOperation> = InexactPartial<
+      Omit<Op, "updates" | "parent" | "pack">
+    >;
+
+    /** Used for {@link Document._preUpdateOperation | `Document._preUpdateOperation`} */
+    type PreUpdateOperationStatic<Op extends DatabaseUpdateOperation> = InexactPartial<
+      Op,
+      Exclude<
+        AllKeysOf<Op>,
+        "modifiedTime" | "diff" | "recursive" | "render" | "updates" | "restoreDelta" | "noHook" | "pack" | "parent"
+      >
+    >;
+
+    /** Used for {@link Document._preUpdate | `Document#_preUpdate`} */
+    type PreUpdateOptions<Op extends DatabaseUpdateOperation> = Omit<
+      PreUpdateOperationStatic<Op>,
+      "updates" | "restoreDelta" | "noHook" | "pack" | "parent"
+    >;
+
+    /** Used for {@link Document._onUpdate | `Document#_onUpdate`} */
+    type UpdateOptions<Op extends DatabaseUpdateOperation> = Omit<
+      Op,
+      "updates" | "pack" | "parentUuid" | "syntheticActorUpdate"
+    >;
+
+    /** Used for {@link Document.deleteDocuments | `Document.deleteDocuments`} */
+    type DeleteDocumentsOperation<Op extends DatabaseDeleteOperation> = NullishProps<Omit<Op, "ids" | "modifiedTime">>;
+
+    /** Used for {@link Document.delete | `Document.delete`} */
+    type DeleteOperationInstance<Op extends DatabaseDeleteOperation> = InexactPartial<
+      Omit<Op, "ids" | "parent" | "pack">
+    >;
+
+    /** Used for {@link Document._preDeleteOperation | `Document._preDeleteOperation`} */
+    type PreDeleteOperationStatic<Op extends DatabaseDeleteOperation> = InexactPartial<
+      Op,
+      Exclude<AllKeysOf<Op>, "modifiedTime" | "render" | "ids" | "deleteAll" | "noHook" | "pack" | "parent">
+    >;
+
+    /** Used for {@link Document._preDelete | `Document#_preDelete`} */
+    type PreDeleteOperationInstance<Op extends DatabaseDeleteOperation> = Omit<
+      InexactPartial<Op, Exclude<AllKeysOf<Op>, "modifiedTime" | "render">>,
+      "ids" | "deleteAll" | "noHook" | "pack" | "parent"
+    >;
+
+    /** Used for {@link Document._onDelete | `Document#_onDelete`} */
+    type DeleteOptions<Op extends DatabaseDeleteOperation> = Omit<
+      Op,
+      "ids" | "deleteAll" | "pack" | "parentUuid" | "syntheticActorUpdate"
+    >;
+
+    /**
+     * This is a helper type that gets the right DatabaseOperation (including the
+     * proper options) for a particular Document type.
+     *
+     * @deprecated This is no longer used internally inside fvtt-types. If you have use for it please file an issue.
+     */
+    type OperationOf<T extends Document.Type, Operation extends Database.Operation> =
+      | (Operation extends "create" ? DatabaseOperationCreateMap[T] : never)
+      | (Operation extends "update" ? DatabaseOperationUpdateMap[T] : never)
+      | (Operation extends "delete" ? DatabaseOperationDeleteMap[T] : never);
+
+    /**
+     * @deprecated See individual document's namespaces.
+     */
+    interface Operations<
+      _T extends Document.Internal.Instance.Any = Document.Internal.Instance.Any,
+      _ExtraCreateOptions extends AnyObject = any,
+      _ExtraUpdateOptions extends AnyObject = any,
+      _ExtraDeleteOptions extends AnyObject = any,
+    > {
+      create: AnyObject;
+      update: AnyObject;
+      delete: AnyObject;
+    }
+
+    type CreateForName<DocumentType extends Document.Type> =
+      | (DocumentType extends "ActiveEffect" ? ActiveEffect.Database.Create : never)
+      | (DocumentType extends "ActorDelta" ? ActorDelta.Database.Create : never)
+      | (DocumentType extends "Actor" ? Actor.Database.Create : never)
+      | (DocumentType extends "Adventure" ? Adventure.Database.Create : never)
+      | (DocumentType extends "Card" ? Card.Database.Create : never)
+      | (DocumentType extends "Cards" ? Cards.Database.Create : never)
+      | (DocumentType extends "ChatMessage" ? ChatMessage.Database.Create : never)
+      | (DocumentType extends "Combat" ? Combat.Database.Create : never)
+      | (DocumentType extends "Combatant" ? Combatant.Database.Create : never)
+      | (DocumentType extends "FogExploration" ? FogExploration.Database.Create : never)
+      | (DocumentType extends "Folder" ? Folder.Database.Create : never)
+      | (DocumentType extends "Item" ? Item.Database.Create : never)
+      | (DocumentType extends "JournalEntryPage" ? JournalEntryPage.Database.Create : never)
+      | (DocumentType extends "JournalEntry" ? JournalEntry.Database.Create : never)
+      | (DocumentType extends "Macro" ? Macro.Database.Create : never)
+      | (DocumentType extends "PlaylistSound" ? PlaylistSound.Database.Create : never)
+      | (DocumentType extends "Playlist" ? Playlist.Database.Create : never)
+      | (DocumentType extends "RegionBehavior" ? RegionBehavior.Database.Create : never)
+      | (DocumentType extends "RollTable" ? RollTable.Database.Create : never)
+      | (DocumentType extends "Scene" ? Scene.Database.Create : never)
+      | (DocumentType extends "Setting" ? Setting.Database.Create : never)
+      | (DocumentType extends "TableResult" ? TableResult.Database.Create : never)
+      | (DocumentType extends "User" ? User.Database.Create : never)
+      | (DocumentType extends "AmbientLight" ? AmbientLightDocument.Database.Create : never)
+      | (DocumentType extends "AmbientSound" ? AmbientSoundDocument.Database.Create : never)
+      | (DocumentType extends "Drawing" ? DrawingDocument.Database.Create : never)
+      | (DocumentType extends "MeasuredTemplate" ? MeasuredTemplateDocument.Database.Create : never)
+      | (DocumentType extends "Note" ? NoteDocument.Database.Create : never)
+      | (DocumentType extends "Region" ? RegionDocument.Database.Create : never)
+      | (DocumentType extends "Tile" ? TileDocument.Database.Create : never)
+      | (DocumentType extends "Token" ? TokenDocument.Database.Create : never)
+      | (DocumentType extends "Wall" ? WallDocument.Database.Create : never);
+
+    type UpdateOperationForName<DocumentType extends Document.Type> =
+      | (DocumentType extends "ActiveEffect" ? ActiveEffect.Database.UpdateOperation : never)
+      | (DocumentType extends "ActorDelta" ? ActorDelta.Database.UpdateOperation : never)
+      | (DocumentType extends "Actor" ? Actor.Database.UpdateOperation : never)
+      | (DocumentType extends "Adventure" ? Adventure.Database.UpdateOperation : never)
+      | (DocumentType extends "Card" ? Card.Database.UpdateOperation : never)
+      | (DocumentType extends "Cards" ? Cards.Database.UpdateOperation : never)
+      | (DocumentType extends "ChatMessage" ? ChatMessage.Database.UpdateOperation : never)
+      | (DocumentType extends "Combat" ? Combat.Database.UpdateOperation : never)
+      | (DocumentType extends "Combatant" ? Combatant.Database.UpdateOperation : never)
+      | (DocumentType extends "FogExploration" ? FogExploration.Database.UpdateOperation : never)
+      | (DocumentType extends "Folder" ? Folder.Database.UpdateOperation : never)
+      | (DocumentType extends "Item" ? Item.Database.UpdateOperation : never)
+      | (DocumentType extends "JournalEntryPage" ? JournalEntryPage.Database.UpdateOperation : never)
+      | (DocumentType extends "JournalEntry" ? JournalEntry.Database.UpdateOperation : never)
+      | (DocumentType extends "Macro" ? Macro.Database.UpdateOperation : never)
+      | (DocumentType extends "PlaylistSound" ? PlaylistSound.Database.UpdateOperation : never)
+      | (DocumentType extends "Playlist" ? Playlist.Database.UpdateOperation : never)
+      | (DocumentType extends "RegionBehavior" ? RegionBehavior.Database.UpdateOperation : never)
+      | (DocumentType extends "RollTable" ? RollTable.Database.UpdateOperation : never)
+      | (DocumentType extends "Scene" ? Scene.Database.UpdateOperation : never)
+      | (DocumentType extends "Setting" ? Setting.Database.UpdateOperation : never)
+      | (DocumentType extends "TableResult" ? TableResult.Database.UpdateOperation : never)
+      | (DocumentType extends "User" ? User.Database.UpdateOperation : never)
+      | (DocumentType extends "AmbientLight" ? AmbientLightDocument.Database.UpdateOperation : never)
+      | (DocumentType extends "AmbientSound" ? AmbientSoundDocument.Database.UpdateOperation : never)
+      | (DocumentType extends "Drawing" ? DrawingDocument.Database.UpdateOperation : never)
+      | (DocumentType extends "MeasuredTemplate" ? MeasuredTemplateDocument.Database.UpdateOperation : never)
+      | (DocumentType extends "Note" ? NoteDocument.Database.UpdateOperation : never)
+      | (DocumentType extends "Region" ? RegionDocument.Database.UpdateOperation : never)
+      | (DocumentType extends "Tile" ? TileDocument.Database.UpdateOperation : never)
+      | (DocumentType extends "Token" ? TokenDocument.Database.UpdateOperation : never)
+      | (DocumentType extends "Wall" ? WallDocument.Database.UpdateOperation : never);
+
+    type DeleteOperationForName<DocumentType extends Document.Type> =
+      | (DocumentType extends "ActiveEffect" ? ActiveEffect.Database.DeleteOperation : never)
+      | (DocumentType extends "ActorDelta" ? ActorDelta.Database.DeleteOperation : never)
+      | (DocumentType extends "Actor" ? Actor.Database.DeleteOperation : never)
+      | (DocumentType extends "Adventure" ? Adventure.Database.DeleteOperation : never)
+      | (DocumentType extends "Card" ? Card.Database.DeleteOperation : never)
+      | (DocumentType extends "Cards" ? Cards.Database.DeleteOperation : never)
+      | (DocumentType extends "ChatMessage" ? ChatMessage.Database.DeleteOperation : never)
+      | (DocumentType extends "Combat" ? Combat.Database.DeleteOperation : never)
+      | (DocumentType extends "Combatant" ? Combatant.Database.DeleteOperation : never)
+      | (DocumentType extends "FogExploration" ? FogExploration.Database.DeleteOperation : never)
+      | (DocumentType extends "Folder" ? Folder.Database.DeleteOperation : never)
+      | (DocumentType extends "Item" ? Item.Database.DeleteOperation : never)
+      | (DocumentType extends "JournalEntryPage" ? JournalEntryPage.Database.DeleteOperation : never)
+      | (DocumentType extends "JournalEntry" ? JournalEntry.Database.DeleteOperation : never)
+      | (DocumentType extends "Macro" ? Macro.Database.DeleteOperation : never)
+      | (DocumentType extends "PlaylistSound" ? PlaylistSound.Database.DeleteOperation : never)
+      | (DocumentType extends "Playlist" ? Playlist.Database.DeleteOperation : never)
+      | (DocumentType extends "RegionBehavior" ? RegionBehavior.Database.DeleteOperation : never)
+      | (DocumentType extends "RollTable" ? RollTable.Database.DeleteOperation : never)
+      | (DocumentType extends "Scene" ? Scene.Database.DeleteOperation : never)
+      | (DocumentType extends "Setting" ? Setting.Database.DeleteOperation : never)
+      | (DocumentType extends "TableResult" ? TableResult.Database.DeleteOperation : never)
+      | (DocumentType extends "User" ? User.Database.DeleteOperation : never)
+      | (DocumentType extends "AmbientLight" ? AmbientLightDocument.Database.DeleteOperation : never)
+      | (DocumentType extends "AmbientSound" ? AmbientSoundDocument.Database.DeleteOperation : never)
+      | (DocumentType extends "Drawing" ? DrawingDocument.Database.DeleteOperation : never)
+      | (DocumentType extends "MeasuredTemplate" ? MeasuredTemplateDocument.Database.DeleteOperation : never)
+      | (DocumentType extends "Note" ? NoteDocument.Database.DeleteOperation : never)
+      | (DocumentType extends "Region" ? RegionDocument.Database.DeleteOperation : never)
+      | (DocumentType extends "Tile" ? TileDocument.Database.DeleteOperation : never)
+      | (DocumentType extends "Token" ? TokenDocument.Database.DeleteOperation : never)
+      | (DocumentType extends "Wall" ? WallDocument.Database.DeleteOperation : never);
+
+    type CreateOptionsFor<DocumentType extends Document.Type> =
+      | (DocumentType extends "ActiveEffect" ? ActiveEffect.Database.CreateOptions : never)
+      | (DocumentType extends "ActorDelta" ? ActorDelta.Database.CreateOptions : never)
+      | (DocumentType extends "Actor" ? Actor.Database.CreateOptions : never)
+      | (DocumentType extends "Adventure" ? Adventure.Database.CreateOptions : never)
+      | (DocumentType extends "Card" ? Card.Database.CreateOptions : never)
+      | (DocumentType extends "Cards" ? Cards.Database.CreateOptions : never)
+      | (DocumentType extends "ChatMessage" ? ChatMessage.Database.CreateOptions : never)
+      | (DocumentType extends "Combat" ? Combat.Database.CreateOptions : never)
+      | (DocumentType extends "Combatant" ? Combatant.Database.CreateOptions : never)
+      | (DocumentType extends "FogExploration" ? FogExploration.Database.CreateOptions : never)
+      | (DocumentType extends "Folder" ? Folder.Database.CreateOptions : never)
+      | (DocumentType extends "Item" ? Item.Database.CreateOptions : never)
+      | (DocumentType extends "JournalEntryPage" ? JournalEntryPage.Database.CreateOptions : never)
+      | (DocumentType extends "JournalEntry" ? JournalEntry.Database.CreateOptions : never)
+      | (DocumentType extends "Macro" ? Macro.Database.CreateOptions : never)
+      | (DocumentType extends "PlaylistSound" ? PlaylistSound.Database.CreateOptions : never)
+      | (DocumentType extends "Playlist" ? Playlist.Database.CreateOptions : never)
+      | (DocumentType extends "RegionBehavior" ? RegionBehavior.Database.CreateOptions : never)
+      | (DocumentType extends "RollTable" ? RollTable.Database.CreateOptions : never)
+      | (DocumentType extends "Scene" ? Scene.Database.CreateOptions : never)
+      | (DocumentType extends "Setting" ? Setting.Database.CreateOptions : never)
+      | (DocumentType extends "TableResult" ? TableResult.Database.CreateOptions : never)
+      | (DocumentType extends "User" ? User.Database.CreateOptions : never)
+      | (DocumentType extends "AmbientLight" ? AmbientLightDocument.Database.CreateOptions : never)
+      | (DocumentType extends "AmbientSound" ? AmbientSoundDocument.Database.CreateOptions : never)
+      | (DocumentType extends "Drawing" ? DrawingDocument.Database.CreateOptions : never)
+      | (DocumentType extends "MeasuredTemplate" ? MeasuredTemplateDocument.Database.CreateOptions : never)
+      | (DocumentType extends "Note" ? NoteDocument.Database.CreateOptions : never)
+      | (DocumentType extends "Region" ? RegionDocument.Database.CreateOptions : never)
+      | (DocumentType extends "Tile" ? TileDocument.Database.CreateOptions : never)
+      | (DocumentType extends "Token" ? TokenDocument.Database.CreateOptions : never)
+      | (DocumentType extends "Wall" ? WallDocument.Database.CreateOptions : never);
+
+    type UpdateOptionsFor<DocumentType extends Document.Type> =
+      | (DocumentType extends "ActiveEffect" ? ActiveEffect.Database.UpdateOptions : never)
+      | (DocumentType extends "ActorDelta" ? ActorDelta.Database.UpdateOptions : never)
+      | (DocumentType extends "Actor" ? Actor.Database.UpdateOptions : never)
+      | (DocumentType extends "Adventure" ? Adventure.Database.UpdateOptions : never)
+      | (DocumentType extends "Card" ? Card.Database.UpdateOptions : never)
+      | (DocumentType extends "Cards" ? Cards.Database.UpdateOptions : never)
+      | (DocumentType extends "ChatMessage" ? ChatMessage.Database.UpdateOptions : never)
+      | (DocumentType extends "Combat" ? Combat.Database.UpdateOptions : never)
+      | (DocumentType extends "Combatant" ? Combatant.Database.UpdateOptions : never)
+      | (DocumentType extends "FogExploration" ? FogExploration.Database.UpdateOptions : never)
+      | (DocumentType extends "Folder" ? Folder.Database.UpdateOptions : never)
+      | (DocumentType extends "Item" ? Item.Database.UpdateOptions : never)
+      | (DocumentType extends "JournalEntryPage" ? JournalEntryPage.Database.UpdateOptions : never)
+      | (DocumentType extends "JournalEntry" ? JournalEntry.Database.UpdateOptions : never)
+      | (DocumentType extends "Macro" ? Macro.Database.UpdateOptions : never)
+      | (DocumentType extends "PlaylistSound" ? PlaylistSound.Database.UpdateOptions : never)
+      | (DocumentType extends "Playlist" ? Playlist.Database.UpdateOptions : never)
+      | (DocumentType extends "RegionBehavior" ? RegionBehavior.Database.UpdateOptions : never)
+      | (DocumentType extends "RollTable" ? RollTable.Database.UpdateOptions : never)
+      | (DocumentType extends "Scene" ? Scene.Database.UpdateOptions : never)
+      | (DocumentType extends "Setting" ? Setting.Database.UpdateOptions : never)
+      | (DocumentType extends "TableResult" ? TableResult.Database.UpdateOptions : never)
+      | (DocumentType extends "User" ? User.Database.UpdateOptions : never)
+      | (DocumentType extends "AmbientLight" ? AmbientLightDocument.Database.UpdateOptions : never)
+      | (DocumentType extends "AmbientSound" ? AmbientSoundDocument.Database.UpdateOptions : never)
+      | (DocumentType extends "Drawing" ? DrawingDocument.Database.UpdateOptions : never)
+      | (DocumentType extends "MeasuredTemplate" ? MeasuredTemplateDocument.Database.UpdateOptions : never)
+      | (DocumentType extends "Note" ? NoteDocument.Database.UpdateOptions : never)
+      | (DocumentType extends "Region" ? RegionDocument.Database.UpdateOptions : never)
+      | (DocumentType extends "Tile" ? TileDocument.Database.UpdateOptions : never)
+      | (DocumentType extends "Token" ? TokenDocument.Database.UpdateOptions : never)
+      | (DocumentType extends "Wall" ? WallDocument.Database.UpdateOptions : never);
+
+    type DeleteOptionsFor<DocumentType extends Document.Type> =
+      | (DocumentType extends "ActiveEffect" ? ActiveEffect.Database.DeleteOptions : never)
+      | (DocumentType extends "ActorDelta" ? ActorDelta.Database.DeleteOptions : never)
+      | (DocumentType extends "Actor" ? Actor.Database.DeleteOptions : never)
+      | (DocumentType extends "Adventure" ? Adventure.Database.DeleteOptions : never)
+      | (DocumentType extends "Card" ? Card.Database.DeleteOptions : never)
+      | (DocumentType extends "Cards" ? Cards.Database.DeleteOptions : never)
+      | (DocumentType extends "ChatMessage" ? ChatMessage.Database.DeleteOptions : never)
+      | (DocumentType extends "Combat" ? Combat.Database.DeleteOptions : never)
+      | (DocumentType extends "Combatant" ? Combatant.Database.DeleteOptions : never)
+      | (DocumentType extends "FogExploration" ? FogExploration.Database.DeleteOptions : never)
+      | (DocumentType extends "Folder" ? Folder.Database.DeleteOptions : never)
+      | (DocumentType extends "Item" ? Item.Database.DeleteOptions : never)
+      | (DocumentType extends "JournalEntryPage" ? JournalEntryPage.Database.DeleteOptions : never)
+      | (DocumentType extends "JournalEntry" ? JournalEntry.Database.DeleteOptions : never)
+      | (DocumentType extends "Macro" ? Macro.Database.DeleteOptions : never)
+      | (DocumentType extends "PlaylistSound" ? PlaylistSound.Database.DeleteOptions : never)
+      | (DocumentType extends "Playlist" ? Playlist.Database.DeleteOptions : never)
+      | (DocumentType extends "RegionBehavior" ? RegionBehavior.Database.DeleteOptions : never)
+      | (DocumentType extends "RollTable" ? RollTable.Database.DeleteOptions : never)
+      | (DocumentType extends "Scene" ? Scene.Database.DeleteOptions : never)
+      | (DocumentType extends "Setting" ? Setting.Database.DeleteOptions : never)
+      | (DocumentType extends "TableResult" ? TableResult.Database.DeleteOptions : never)
+      | (DocumentType extends "User" ? User.Database.DeleteOptions : never)
+      | (DocumentType extends "AmbientLight" ? AmbientLightDocument.Database.DeleteOptions : never)
+      | (DocumentType extends "AmbientSound" ? AmbientSoundDocument.Database.DeleteOptions : never)
+      | (DocumentType extends "Drawing" ? DrawingDocument.Database.DeleteOptions : never)
+      | (DocumentType extends "MeasuredTemplate" ? MeasuredTemplateDocument.Database.DeleteOptions : never)
+      | (DocumentType extends "Note" ? NoteDocument.Database.DeleteOptions : never)
+      | (DocumentType extends "Region" ? RegionDocument.Database.DeleteOptions : never)
+      | (DocumentType extends "Tile" ? TileDocument.Database.DeleteOptions : never)
+      | (DocumentType extends "Token" ? TokenDocument.Database.DeleteOptions : never)
+      | (DocumentType extends "Wall" ? WallDocument.Database.DeleteOptions : never);
+  }
+
+  interface DataFieldShimOptions {
+    /**
+     * A string to log as a compatibility warning on accessing the `oldKey`
+     */
+    warning?: string | null | undefined;
+
+    /**
+     * @remarks Foundry uses `if ("value" in options)` to determine whether to override the default value.
+     */
+    value?: unknown;
+  }
+
+  /**
+   * @internal
+   * If a `parent` is required for a given Document's creation, its template must pass `NonNullable<X.Parent>` to `CreateDialogContext`
+   */
+  type ParentContext<Parent extends Document.Any | null> = Parent extends null
+    ? {
+        /** A parent document within which the created Document should belong */
+        parent?: Parent | undefined;
+      }
+    : {
+        /** A parent document within which the created Document should belong */
+        parent: Parent;
+      };
+
+  /** @internal */
+  type _PossibleSubtypeContext<DocumentName extends Document.Type> =
+    GetKey<Document.MetadataFor<DocumentName>, "hasTypeData"> extends true
+      ? NullishProps<{
+          /**
+           * The sub-type of the document
+           * @remarks Pulls from `CONFIG[documentName].typeLabels?.[type]` if provided. Ignored if falsey.
+           */
+          type: Document.SubTypesOf<DocumentName>;
+        }>
+      : {
+          /** @deprecated This Document type does not support subtypes */
+          type?: never;
+        };
+
+  type DefaultNameContext<DocumentName extends Document.Type, Parent extends Document.Any | null> = NullishProps<{
+    /**
+     * A compendium pack within which the Document should be created
+     * @remarks Only used to generate the list of existing names to check against when incrementing the index for the `(number)` suffix.
+     * Ignored if falsey, or if `parent` is provided and truthy.
+     */
+    pack: string;
+
+    /**
+     * A parent document within which the created Document should belong
+     * @remarks Only used to generate the list of existing names to check against when incrementing the index for the `(number)` suffix.
+     * Ignored if falsey.
+     */
+    parent: Parent;
+  }> &
+    _PossibleSubtypeContext<DocumentName>;
+
+  type CreateDialogData<CreateData extends object> = InexactPartial<
+    CreateData,
+    Extract<AllKeysOf<CreateData>, "name" | "type" | "folder">
+  >;
+
+  /** @internal */
+  type _PossibleSubtypesContext<DocumentName extends Document.Type> =
+    GetKey<Document.MetadataFor<DocumentName>, "hasTypeData"> extends true
+      ? {
+          /** @deprecated This Document type does not support subtypes */
+          types?: never;
+        }
+      : NullishProps<{
+          /**
+           * A restriction the selectable sub-types of the Dialog.
+           * @remarks Only checked if the document has `static TYPES` of length \> 1 (i.e it both `hasTypeData` and has
+           * at least one non-`"base"` type registered). The computed list will always exclude {@link CONST.BASE_DOCUMENT_TYPE | `CONST.BASE_DOCUMENT_TYPE`},
+           * so it is disallowed in this whitelist.
+           */
+          types: Exclude<Document.SubTypesOf<DocumentName>, "base">[];
+        }>;
+
+  type CreateDialogContext<
+    DocumentName extends Document.Type,
+    Parent extends Document.Any | null,
+  > = InexactPartial<Dialog.Options> &
+    NullishProps<{
+      /**
+       * A compendium pack within which the Document should be created
+       * @remarks Only checked if `parent` is falsey, and only used to generate the list of folders for the dialog
+       */
+      pack: string;
+    }> &
+    _PossibleSubtypesContext<DocumentName> &
+    ParentContext<Parent>;
+
+  interface FromImportContext<Parent extends Document.Any | null> extends Omit<ConstructionContext<Parent>, "strict"> {
+    /**
+     * Strict validation is enabled by default.
+     * @defaultValue `true`
+     * @remarks Not allowed to be `undefined` as that would produce `false`, not the expected default of `true`, due to being spread
+     * into an object with `strict: true`, then passed to {@link Document.fromSource | `Document.fromSource`}, where the parameter
+     * default is `false`
+     */
+    strict?: boolean | null;
+  }
+
+  type ActionPermission = keyof typeof CONST.DOCUMENT_OWNERSHIP_LEVELS | CONST.DOCUMENT_OWNERSHIP_LEVELS;
+
+  /** @deprecated Use {@linkcode Document.ActionPermission} instead */
+  type TestableOwnershipLevel = ActionPermission;
+
+  /** @internal */
+  type _TestUserPermissionsOptions = NullishProps<{
+    /**
+     * Require the exact permission level requested?
+     * @defaultValue `false`
+     */
+    exact: boolean;
+  }>;
+
+  interface TestUserPermissionOptions extends _TestUserPermissionsOptions {}
+
+  /**
+   * @deprecated {@link ImplementationFor | `ImplementationFor`}
+   */
+  type ConfiguredInstanceForName<Name extends Type> = ImplementationFor<Name>;
+
+  /**
+   * @deprecated {@link ImplementationClassFor | `ImplementationClassFor`}
+   */
+  type ConfiguredClassForName<Name extends Type> = ImplementationClassFor<Name>;
+
+  /**
+   * @deprecated {@link SchemaField.SourceData | `SchemaField.SourceData<Schema>`}
+   */
+  type ToObjectFalseType<T extends Document.Internal.Instance.Any> = T extends {
+    toObject: (source: false) => infer U;
+  }
+    ? U
+    : T;
+
+  /**
+   * @deprecated {@link Document.Database.OperationOf | `Document.Database.OperationOf`}
+   */
+  type DatabaseOperationsFor<
+    Name extends Document.Type,
+    ConcreteOperation extends Document.Database.Operation,
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
+  > = Document.Database.OperationOf<Name, ConcreteOperation>;
+
+  /**
+   * @deprecated {@link CreateDataForName | `CreateDataForName`}
+   */
+  type ConstructorDataForName<T extends Document.Type> = CreateData[T];
+
+  type CanUserModifyData<Schema extends DataSchema, Action extends "create" | "update" | "delete"> =
+    | (Action extends "create" ? SchemaField.CreateData<Schema> : never)
+    | (Action extends "update" ? SchemaField.UpdateData<Schema> : never)
+    | (Action extends "delete" ? EmptyObject : never);
+
+  /**
+   * @internal
+   */
+  type _GetEmbeddedDocumentOptions = InexactPartial<{
+    /**
+     * Throw an Error if the requested id does not exist. See {@link Collection.get | `Collection#get`}
+     * @defaultValue `false`
+     */
+    strict: boolean;
+
+    /**
+     * Allow retrieving an invalid Embedded Document.
+     * @defaultValue `false`
+     */
+    invalid: boolean;
+  }>;
+
+  interface GetEmbeddedDocumentOptions extends _GetEmbeddedDocumentOptions {}
+
+  /**
+   * Gets the hierarchical fields in the schema. Hardcoded to whatever Foundry fields are hierarchical
+   * as there is no way to access the a static property of a custom fields from an instance.
+   */
+  type HierarchyOf<Schema extends DataSchema> = PickValue<
+    Schema,
+    EmbeddedCollectionField.Any | EmbeddedDocumentField.Any
+  >;
+
+  type PreCreateDescendantDocumentsArgs<
+    Parent extends Document.AnyStored,
+    DirectDescendant extends Document.Any,
+    Embedded extends Document.Metadata.Embedded,
+  > = DirectDescendant extends unknown
+    ? [
+        parent: Parent,
+        collection: Embedded[DirectDescendant["documentName"]],
+        data: Document.CreateDataForName<DirectDescendant["documentName"]>[],
+        options: Document.Database.CreateOptionsFor<DirectDescendant["documentName"]>,
+        userId: string,
+      ]
+    : never;
+
+  type OnCreateDescendantDocumentsArgs<
+    Parent extends Document.AnyStored,
+    DirectDescendant extends Document.Any,
+    Embedded extends Document.Metadata.Embedded,
+  > = DirectDescendant extends unknown
+    ? [
+        parent: Parent,
+        collection: Embedded[DirectDescendant["documentName"]],
+        documents: DirectDescendant[],
+        data: Document.CreateDataForName<DirectDescendant["documentName"]>[],
+        options: Document.Database.CreateOptionsFor<DirectDescendant["documentName"]>,
+        userId: string,
+      ]
+    : never;
+
+  type PreUpdateDescendantDocumentsArgs<
+    Parent extends Document.AnyStored,
+    DirectDescendant extends Document.Any,
+    Embedded extends Document.Metadata.Embedded,
+  > = DirectDescendant extends unknown
+    ? [
+        parent: Parent,
+        collection: Embedded[DirectDescendant["documentName"]],
+        changes: Document.UpdateDataForName<DirectDescendant["documentName"]>[],
+        options: Document.Database.UpdateOptionsFor<DirectDescendant["documentName"]>,
+        userId: string,
+      ]
+    : never;
+
+  type OnUpdateDescendantDocumentsArgs<
+    Parent extends Document.AnyStored,
+    DirectDescendant extends Document.Any,
+    Embedded extends Document.Metadata.Embedded,
+  > = DirectDescendant extends unknown
+    ? [
+        parent: Parent,
+        collection: Embedded[DirectDescendant["documentName"]],
+        documents: DirectDescendant[],
+        changes: Document.UpdateDataForName<DirectDescendant["documentName"]>[],
+        options: Document.Database.UpdateOptionsFor<DirectDescendant["documentName"]>,
+        userId: string,
+      ]
+    : never;
+
+  type PreDeleteDescendantDocumentsArgs<
+    Parent extends Document.AnyStored,
+    DirectDescendant extends Document.Any,
+    Embedded extends Document.Metadata.Embedded,
+  > = DirectDescendant extends unknown
+    ? [
+        parent: Parent,
+        collection: Embedded[DirectDescendant["documentName"]],
+        ids: string[],
+        options: Document.Database.DeleteOptionsFor<DirectDescendant["documentName"]>,
+        userId: string,
+      ]
+    : never;
+
+  type OnDeleteDescendantDocumentsArgs<
+    Parent extends Document.AnyStored,
+    DirectDescendant extends Document.Any,
+    Embedded extends Document.Metadata.Embedded,
+  > = DirectDescendant extends unknown
+    ? [
+        parent: Parent,
+        collection: Embedded[DirectDescendant["documentName"]],
+        documents: DirectDescendant[],
+        ids: string[],
+        options: Document.Database.DeleteOptionsFor<DirectDescendant["documentName"]>,
+        userId: string,
+      ]
+    : never;
 }
-/* eslint-enable @typescript-eslint/no-empty-object-type */
 
+/** @deprecated {@link Document.Database.Operation | `Document.Database.Operation`} */
+export type Operation = Document.Database.Operation;
+
+/* eslint-disable @typescript-eslint/no-deprecated */
+/**
+ * @deprecated if you want to get individual operations see {@link Document.Database.OperationOf | `Document.Database.OperationOf`}
+ */
 export interface DatabaseOperationMap {
   ActiveEffect: ActiveEffect.DatabaseOperations;
   Actor: Actor.DatabaseOperations;
@@ -1411,9 +2291,8 @@ export interface DatabaseOperationMap {
   Note: NoteDocument.DatabaseOperations;
   Playlist: Playlist.DatabaseOperations;
   PlaylistSound: PlaylistSound.DatabaseOperations;
-  // TODO: Add these once documents are done
-  // Region: ActiveEffect.DatabaseOperations;
-  // RegionBehavior: ActiveEffect.DatabaseOperations;
+  Region: RegionDocument.DatabaseOperations;
+  RegionBehavior: RegionBehavior.DatabaseOperations;
   RollTable: RollTable.DatabaseOperations;
   Scene: Scene.DatabaseOperations;
   Setting: Setting.DatabaseOperations;
@@ -1423,3 +2302,109 @@ export interface DatabaseOperationMap {
   User: User.DatabaseOperations;
   Wall: WallDocument.DatabaseOperations;
 }
+/* eslint-enable @typescript-eslint/no-deprecated */
+
+interface DatabaseOperationCreateMap {
+  ActiveEffect: ActiveEffect.Database.Create;
+  Actor: Actor.Database.Create;
+  ActorDelta: ActorDelta.Database.Create;
+  Adventure: Adventure.Database.Create;
+  AmbientLight: AmbientLightDocument.Database.Create;
+  AmbientSound: AmbientSoundDocument.Database.Create;
+  Card: Card.Database.Create;
+  Cards: Cards.Database.Create;
+  ChatMessage: ChatMessage.Database.Create;
+  Combat: Combat.Database.Create;
+  Combatant: Combatant.Database.Create;
+  Drawing: DrawingDocument.Database.Create;
+  FogExploration: FogExploration.Database.Create;
+  Folder: Folder.Database.Create;
+  Item: Item.Database.Create;
+  JournalEntry: JournalEntry.Database.Create;
+  JournalEntryPage: JournalEntryPage.Database.Create;
+  Macro: Macro.Database.Create;
+  MeasuredTemplate: MeasuredTemplateDocument.Database.Create;
+  Note: NoteDocument.Database.Create;
+  Playlist: Playlist.Database.Create;
+  PlaylistSound: PlaylistSound.Database.Create;
+  Region: RegionDocument.Database.Create;
+  RegionBehavior: RegionBehavior.Database.Create;
+  RollTable: RollTable.Database.Create;
+  Scene: Scene.Database.Create;
+  Setting: Setting.Database.Create;
+  TableResult: TableResult.Database.Create;
+  Tile: TileDocument.Database.Create;
+  Token: TokenDocument.Database.Create;
+  User: User.Database.Create;
+  Wall: WallDocument.Database.Create;
+}
+
+interface DatabaseOperationUpdateMap {
+  ActiveEffect: ActiveEffect.Database.Update;
+  Actor: Actor.Database.Update;
+  ActorDelta: ActorDelta.Database.Update;
+  Adventure: Adventure.Database.Update;
+  AmbientLight: AmbientLightDocument.Database.Update;
+  AmbientSound: AmbientSoundDocument.Database.Update;
+  Card: Card.Database.Update;
+  Cards: Cards.Database.Update;
+  ChatMessage: ChatMessage.Database.Update;
+  Combat: Combat.Database.Update;
+  Combatant: Combatant.Database.Update;
+  Drawing: DrawingDocument.Database.Update;
+  FogExploration: FogExploration.Database.Update;
+  Folder: Folder.Database.Update;
+  Item: Item.Database.Update;
+  JournalEntry: JournalEntry.Database.Update;
+  JournalEntryPage: JournalEntryPage.Database.Update;
+  Macro: Macro.Database.Update;
+  MeasuredTemplate: MeasuredTemplateDocument.Database.Update;
+  Note: NoteDocument.Database.Update;
+  Playlist: Playlist.Database.Update;
+  PlaylistSound: PlaylistSound.Database.Update;
+  Region: RegionDocument.Database.Update;
+  RegionBehavior: RegionBehavior.Database.Update;
+  RollTable: RollTable.Database.Update;
+  Scene: Scene.Database.Update;
+  Setting: Setting.Database.Update;
+  TableResult: TableResult.Database.Update;
+  Tile: TileDocument.Database.Update;
+  Token: TokenDocument.Database.Update;
+  User: User.Database.Update;
+  Wall: WallDocument.Database.Update;
+}
+
+interface DatabaseOperationDeleteMap {
+  ActiveEffect: ActiveEffect.Database.Delete;
+  Actor: Actor.Database.Delete;
+  ActorDelta: ActorDelta.Database.Delete;
+  Adventure: Adventure.Database.Delete;
+  AmbientLight: AmbientLightDocument.Database.Delete;
+  AmbientSound: AmbientSoundDocument.Database.Delete;
+  Card: Card.Database.Delete;
+  Cards: Cards.Database.Delete;
+  ChatMessage: ChatMessage.Database.Delete;
+  Combat: Combat.Database.Delete;
+  Combatant: Combatant.Database.Delete;
+  Drawing: DrawingDocument.Database.Delete;
+  FogExploration: FogExploration.Database.Delete;
+  Folder: Folder.Database.Delete;
+  Item: Item.Database.Delete;
+  JournalEntry: JournalEntry.Database.Delete;
+  JournalEntryPage: JournalEntryPage.Database.Delete;
+  Macro: Macro.Database.Delete;
+  MeasuredTemplate: MeasuredTemplateDocument.Database.Delete;
+  Note: NoteDocument.Database.Delete;
+  Playlist: Playlist.Database.Delete;
+  PlaylistSound: PlaylistSound.Database.Delete;
+  Region: RegionDocument.Database.Delete;
+  RegionBehavior: RegionBehavior.Database.Delete;
+  RollTable: RollTable.Database.Delete;
+  Scene: Scene.Database.Delete;
+  Setting: Setting.Database.Delete;
+  TableResult: TableResult.Database.Delete;
+  Tile: TileDocument.Database.Delete;
+  Token: TokenDocument.Database.Delete;
+  User: User.Database.Delete;
+  Wall: WallDocument.Database.Delete;
+}