@league-of-foundry-developers/foundry-vtt-types 13.340.0 → 13.345.1-beta.20250704.94554

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

@@ -1,8 +1,7 @@
 import type {
-  ConfiguredDocuments,
+  ConfiguredDocumentClass,
+  ConfiguredDocumentInstance,
   ConfiguredMetadata,
-  DefaultDocuments,
-  ConstructorData,
 } from "../../../types/documentConfiguration.d.mts";
 import type {
   GetKey,
@@ -11,15 +10,29 @@ import type {
   MustConform,
   ToMethod,
   AnyObject,
-  DeepPartial,
   EmptyObject,
   InexactPartial,
   RemoveIndexSignatures,
   FixedInstanceType,
-} from "../../../utils/index.d.mts";
+  NullishProps,
+  DiscriminatedUnion,
+  PickValue,
+  Identity,
+  Brand,
+  AnyMutableObject,
+  MaybePromise,
+  Override,
+} 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.d.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,
@@ -31,22 +44,35 @@ import type {
 } from "./_types.d.mts";
 import type DataModel from "./data.mts";
 import type DocumentSocketResponse from "./socket.d.mts";
-
-type DataSchema = foundry.data.fields.DataSchema;
+import type EmbeddedCollection from "./embedded-collection.d.mts";
 
 export default Document;
 
+type InexactPartialExcept<T extends object, RequiredKey> = {
+  [K in keyof T as Extract<K, RequiredKey>]: T[K];
+} & {
+  [K in keyof T as Exclude<K, RequiredKey>]?: T[K] | undefined;
+};
+
 type _ClassMustBeAssignableToInternal = MustConform<typeof Document, Document.Internal.Constructor>;
 type _InstanceMustBeAssignableToInternal = MustConform<Document.Any, Document.Internal.Instance.Any>;
 
-type _ConfigurationFailureClassMustBeAssignableToInternal = MustConform<
-  Document.ConfigurationFailureClass,
-  Document.Internal.Constructor
->;
-type _ConfigurationFailureInstanceMustBeAssignableToInternal = MustConform<
-  Document.ConfigurationFailureInstance,
-  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.
@@ -56,30 +82,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 [Document.Internal.DocumentBrand]: true;
-
-  [Document.Internal.DocumentName]: DocumentName;
-  [Document.Internal.Schema]: Schema;
-  [Document.Internal.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.
@@ -94,16 +116,9 @@ 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;
-
-  protected _initialize(options?: any): void;
-
-  /**
-   * A mapping of singleton embedded Documents which exist in this model.
-   */
-  readonly singletons: Record<string, Document.AnyChild<this>>;
+  static get schema(): SchemaField.Any;
 
-  protected static override _initializationOrder(): Generator<[string, DataField.Any]>;
+  protected static override _initializationOrder(): Generator<[string, DataField.Any], void, undefined>;
 
   /**
    * Default metadata which applies to each instance of this Document type.
@@ -111,23 +126,30 @@ declare abstract class Document<
    * ```typescript
    * {
    *   name: "Document",
+   *   label: "DOCUMENT.Document"
+   *   coreTypes: [BASE_DOCUMENT_TYPE],
    *   collection: "documents",
+   *   embedded: {},
+   *   hasTypeData: false,
    *   indexed: false,
    *   compendiumIndexFields: [],
-   *   label: "DOCUMENT.Document",
-   *   coreTypes: [],
-   *   embedded: {},
    *   permissions: {
-   *     create: "ASSISTANT",
-   *     update: "ASSISTANT",
-   *     delete: "ASSISTANT"
+   *     view: "LIMITED"       // At least limited permission is required to view the Document
+   *     create: "ASSISTANT",  // Assistants or Gamemasters can create Documents
+   *     update: "ASSISTANT",  // Document owners can update Documents (this includes GM users)
+   *     delete: "ASSISTANT"   // Assistants or Gamemasters can create Documents
    *   },
-   *   preserveOnImport: ["_id", "sort", "ownership"],
+   *   preserveOnImport: ["_id", "sort", "ownership", folder],
    *   schemaVersion: undefined
    * }
    * ```
    */
-  static metadata: Readonly<Document.Metadata.Any>;
+  static metadata: Document.Metadata.Any;
+
+  /**
+   * @defaultValue `["DOCUMENT"]`
+   */
+  static override LOCALIZATION_PREFIXES: string[];
 
   /**
    * The database backend used to execute operations and handle results
@@ -137,7 +159,7 @@ declare abstract class Document<
   /**
    * Return a reference to the implemented subclass of this base document type.
    */
-  static get implementation(): Document.AnyConstructor;
+  static get implementation(): Document.Internal.Constructor;
 
   /**
    * The base document definition that this document class extends from.
@@ -152,12 +174,12 @@ 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".
    */
-  static get documentName(): string;
+  static get documentName(): Document.Type;
 
   /**
    * The canonical name of this Document type, for example "Actor".
@@ -166,26 +188,30 @@ 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;
 
+  _id: string | null;
+
   /**
    * The canonical identifier for this Document
    */
@@ -196,27 +222,43 @@ declare abstract class Document<
    */
   get isEmbedded(): boolean;
 
+  /**
+   * Is this document in a compendium?
+   */
+  get inCompendium(): boolean;
+
   /**
    * A Universally Unique Identifier (uuid) for this Document instance.
    */
   get uuid(): string;
 
   /**
-   * Test whether a given User has a sufficient role in order to create Documents of this type in general.
+   * Test whether a given User has sufficient permissions to create Documents of this type in general. This does not
+   * guarantee that the User is able to create all Documents of this type, as certain document-specific requirements
+   * may also be present.
+   *
+   * Generally speaking, this method is used to verify whether a User should be presented with the option to create
+   * Documents of this type in the UI.
    * @param user - The User being tested
    * @returns Does the User have a sufficient role to create?
    */
-  static canUserCreate(user: User): 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.
-   * This method returns the value recorded in Document ownership, regardless of the User's role.
+   * Get the explicit permission level that a User has over this Document, a value in {@link CONST.DOCUMENT_OWNERSHIP_LEVELS | `CONST.DOCUMENT_OWNERSHIP_LEVELS`}.
+   * Compendium content ignores the ownership field in favor of User role-based ownership. Otherwise, Documents use
+   * granular per-User ownership definitions and Embedded Documents defer to their parent ownership.
+   *
+   * This method returns the value recorded in Document ownership, regardless of the User's role, for example a
+   * GAMEMASTER user might still return a result of NONE if they are not explicitly denoted as having a level.
+   *
    * 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?: User): 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
@@ -224,28 +266,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: User,
-    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: User, 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.
@@ -254,40 +299,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
-  ): Save extends true ? Promise<this> : this;
+  // data: not null (property access), context: not null (destructured)
+  override clone<Save extends boolean | null | undefined = undefined>(
+    data?: SchemaField.UpdateData<Schema>,
+    context?: Document.CloneContext<Save>,
+  ): Document.Clone<this, Save>;
 
   /**
    * 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.
@@ -323,16 +350,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<NoInfer<T>>>,
-    operation?: InexactPartial<
-      Omit<Document.Database.OperationOf<NoInfer<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.
@@ -368,14 +391,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<NoInfer<T>>>>,
-    operation?: InexactPartial<
-      Omit<Document.Database.OperationOf<FixedInstanceType<NoInfer<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.
@@ -413,18 +434,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<Document.Database.OperationOf<FixedInstanceType<NoInfer<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 {@linkcode 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: `{}`)
@@ -449,55 +468,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<NoInfer<T>> | Document.ConstructorDataFor<NoInfer<T>>[],
-    operation?: InexactPartial<
-      Omit<Document.Database.OperationOf<NoInfer<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 {@linkcode 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<Document.Database.OperationOf<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 {@linkcode 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<Document.Database.OperationOf<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.
@@ -516,7 +536,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
@@ -524,9 +544,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"])
    */
-  getEmbeddedCollection<EmbeddedName extends foundry.CONST.EMBEDDED_DOCUMENT_TYPES>(
-    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.
@@ -536,26 +555,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 {@linkcode Document.createDocuments}
    * @param embeddedName - The name of the embedded Document type
    * @param data         - An array of data objects used to create multiple documents
    *                       (default: `[]`)
@@ -563,23 +572,18 @@ declare abstract class Document<
    *                       (default: `{}`)
    * @returns An array of created Document instances
    */
-  // 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<Document.Database.OperationOf<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 {@linkcode 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: `[]`)
@@ -587,33 +591,34 @@ declare abstract class Document<
    *                       (default: `{}`)
    * @returns An array of updated Document instances
    */
-  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 {@linkcode 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
    */
-  deleteEmbeddedDocuments<EmbeddedName extends foundry.CONST.EMBEDDED_DOCUMENT_TYPES>(
-    embeddedName: EmbeddedName,
-    ids: Array<string>,
-    operation?: Document.Database.OperationOf<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>], void, undefined>;
 
   /**
    * Get the value of a "flag" for this document
@@ -623,10 +628,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.
@@ -646,11 +648,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
@@ -658,22 +656,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: User,
-  ): 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.
@@ -682,48 +676,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<NoInfer<T>>[],
-    operation: Document.Database.OperationOf<NoInfer<T>["metadata"]["name"], "create">,
-    user: User,
+  // 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: Document.ToConfiguredInstance<NoInfer<T>>[],
-    operation: Document.Database.OperationOf<NoInfer<T>["metadata"]["name"], "create">,
-    user: User,
+  // 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>;
 
   /**
@@ -734,11 +724,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: User,
-  ): 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.
@@ -747,49 +733,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.InnerUpdateData<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: Document.ToConfiguredInstance<NoInfer<T>>[],
-    operation: Document.Database.OperationOf<FixedInstanceType<NoInfer<T>>["documentName"], "update">,
-    user: User,
+  // 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: Document.ToConfiguredInstance<NoInfer<T>>[],
-    operation: Document.Database.OperationOf<FixedInstanceType<NoInfer<T>>["documentName"], "update">,
-    user: User,
+  // 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>;
 
   /**
@@ -799,7 +781,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: User): 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.
@@ -807,17 +789,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
@@ -825,50 +807,50 @@ declare abstract class Document<
    * @returns Return false to cancel the deletion operation entirely
    * @internal
    */
-  protected static _preDeleteOperation<T extends Document.AnyConstructor>(
-    this: T,
-    documents: Document.ToConfiguredInstance<NoInfer<T>>[],
-    operation: Document.Database.OperationOf<FixedInstanceType<NoInfer<T>>["documentName"], "delete">,
-    user: User,
+  // 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: Document.ToConfiguredInstance<NoInfer<T>>[],
-    operation: Document.Database.OperationOf<FixedInstanceType<NoInfer<T>>["documentName"], "delete">,
-    user: User,
+  // 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.
-   */
-  static LOG_V10_COMPATIBILITY_WARNINGS: boolean;
-
-  /**
-   * @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;
-
   /**
    * 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.
@@ -877,15 +859,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,
@@ -894,89 +877,60 @@ 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<NoInfer<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<NoInfer<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<NoInfer<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[]);
-
-  // 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 [Document.Internal.DocumentBrand]: true;
-
-  flags?: unknown;
 
-  getFlag(scope: never, key: never): any;
+  " fvtt_types_internal_document_name": DocumentName;
+  " fvtt_types_internal_document_schema": Schema;
+  " fvtt_types_internal_document_parent": Parent;
 }
 
-// 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 {
-  static [Document.Internal.DocumentBrand]: true;
+// 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);
+
+  // Note(LukeAbby): This uses `object` instead of `AnyObject` to avoid more thorough evaluation of
+  // the involved types which can cause a loop.
+  _source: object;
 }
 
 declare namespace Document {
-  /** Any Document, except for Settings */
-  type Any = AnyDocument;
-  type AnyConstructor = typeof AnyDocument;
+  interface Any extends AnyDocument {}
+  interface AnyStored extends Document.Internal.Stored<Any> {}
+  interface AnyValid extends AnyDocument {
+    get invalid(): false;
+  }
+  interface AnyInvalid extends Document.Internal.Invalid<AnyValid> {}
 
-  type ConfigurationFailureClass = typeof ConfigurationFailure;
-  type ConfigurationFailureInstance = ConfigurationFailure;
+  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"
-    | "RegionBehavior"
-    | "Region"
-    | "RollTable"
-    | "Scene"
-    | "Setting"
-    | "TableResult"
-    | "User"
-    // All placeables also have a corresponding document class.
-    | PlaceableType;
+  type Type = CONST.ALL_DOCUMENT_TYPES;
 
   type PlaceableType =
     | "AmbientLight"
@@ -989,8 +943,79 @@ declare namespace Document {
     | "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"
+    | "CombatantGroup"
+    | "Item"
+    | "JournalEntryPage"
+    | "RegionBehavior";
+
   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">
+    : // ESLint doesn't know that `DataModelConfig` and `SourceConfig` are meant to be declaration merged into.
+      // Therefore it hastily thinks the results are always `never`.
+      // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents, @typescript-eslint/no-duplicate-type-constituents
+      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 "CombatantGroup" ? CombatantGroup.OfType<SubType & CombatantGroup.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 {@linkcode 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 =
@@ -1001,18 +1026,66 @@ declare namespace Document {
     | "ChatMessage"
     | "Combat"
     | "Combatant"
+    | "CombatantGroup"
     | "Item"
     | "JournalEntryPage"
     | "RegionBehavior";
 
-  type EmbeddableNamesFor<ConcreteDocument extends Document.Internal.Instance.Any> = {
-    [K in keyof ConfiguredDocuments]: IsParentOf<
-      ConcreteDocument,
-      FixedInstanceType<ConfiguredDocuments[K]>
-    > extends true
-      ? K
-      : never;
-  };
+  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];
+  }
+
+  /**
+   * @internal
+   */
+  interface _WorldCollectionMap {
+    Actor: foundry.documents.collections.Actors.Configured;
+    Cards: foundry.documents.collections.CardStacks;
+    Combat: foundry.documents.collections.CombatEncounters;
+    FogExploration: foundry.documents.collections.FogExplorations;
+    Folder: foundry.documents.collections.Folders;
+    Item: foundry.documents.collections.Items;
+    JournalEntry: foundry.documents.collections.Journal;
+    Macro: foundry.documents.collections.Macros;
+    ChatMessage: foundry.documents.collections.ChatMessages;
+    Playlist: foundry.documents.collections.Playlists;
+    Scene: foundry.documents.collections.Scenes;
+    Setting: foundry.documents.collections.WorldSettings;
+    RollTable: foundry.documents.collections.RollTables;
+    User: foundry.documents.collections.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,
@@ -1024,19 +1097,8 @@ declare namespace Document {
 
   // Documented at https://gist.github.com/LukeAbby/c7420b053d881db4a4d4496b95995c98
   namespace Internal {
-    const DocumentBrand: unique symbol;
-
-    const DocumentName: unique symbol;
-    const Schema: unique symbol;
-    const Parent: unique symbol;
-
-    // This metadata is called "simple" because where there should be proper references to the
-    // current document there is instead `Document.Any`. This helps simplify loops.
-    // Use cases should be limited to when these references aren't needed.
-    type SimpleMetadata<Name extends Document.Type> = ConfiguredMetadata<Document.Any>[Name];
-
-    type Constructor = (abstract new (arg0: never, ...args: never[]) => Instance.Any) & {
-      [DocumentBrand]: true;
+    type Constructor = (abstract new (...args: never) => Instance.Any) & {
+      documentName: Document.Type;
     };
 
     interface Instance<
@@ -1044,127 +1106,320 @@ declare namespace Document {
       Schema extends DataSchema,
       Parent extends Document.Internal.Instance.Any | null,
     > {
-      [DocumentName]: DocumentName;
-      [Schema]: Schema;
-      [Parent]: Parent;
+      " fvtt_types_internal_document_name": DocumentName;
+      " fvtt_types_internal_document_schema": Schema;
+      " fvtt_types_internal_document_parent": Parent;
     }
 
-    type DocumentNameFor<ConcreteInstance extends Instance.Any> = ConcreteInstance[typeof DocumentName];
+    type DocumentNameFor<ConcreteInstance extends Instance.Any> =
+      ConcreteInstance[" fvtt_types_internal_document_name"];
 
-    type SchemaFor<ConcreteInstance extends Instance.Any> = ConcreteInstance[typeof Schema];
+    type SchemaFor<ConcreteInstance extends Instance.Any> = ConcreteInstance[" fvtt_types_internal_document_schema"];
 
-    type ParentFor<ConcreteInstance extends Instance.Any> = ConcreteInstance[typeof Parent];
+    type ParentFor<ConcreteInstance extends Instance.Any> = ConcreteInstance[" fvtt_types_internal_document_parent"];
 
     namespace Instance {
-      type Any = Instance<any, any, any>;
+      interface Any extends Instance<any, any, any> {}
 
       type Complete<T extends Any> = T extends Document.Any ? T : never;
     }
-  }
 
-  /** Any Document, that is a child of the given parent Document. */
-  type AnyChild<Parent extends Any | null> = Document<any, any, Parent>;
+    // Note(LukeAbby): `Configured` is not checked for validity. This means that it's easy to
+    // accidently misconfigure without warning. However it helps stymy some circularities this way.
+    // This is also why `LazyDocument` takes a callback.
+    // See: https://gist.github.com/LukeAbby/a7892327633587ba89e760b599572322
+    type OfType<Configured, LazyDocument extends () => unknown> = "document" extends keyof Configured
+      ? Configured["document"]
+      : ReturnType<LazyDocument>;
+
+    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;
+    };
 
-  /**
-   * Returns the type of the constructor data for the given {@link foundry.abstract.Document}.
-   */
-  type ConstructorDataFor<T extends Document.Internal.Constructor> = ConstructorDataForSchema<
-    T extends { defineSchema: () => infer R extends DataSchema } ? R : never
-  >;
+    type SystemOfType<SystemMap extends Record<SubType, object>, SubType extends string> =
+      | DiscriminatedUnion<SystemMap[SubType]>
+      | (SubType extends ModuleSubType | "base" ? UnknownSystem : never);
 
-  // TODO(LukeAbby): Actually make this distinguishable from `Document.ConstructorDataFor` and `Document.ConstructorDataForSchema`.
-  type UpdateDataFor<T extends Document.Internal.Constructor> = ConstructorDataForSchema<
-    T extends { defineSchema: () => infer R extends DataSchema } ? R : never
-  >;
+    // TODO(LukeAbby): Improve the type display with a helper here.
+    type Stored<D extends Document.Any> = Override<
+      D,
+      {
+        id: string;
+        _id: string;
+        _source: Override<D["_source"], { _id: string }>;
+      }
+    >;
+
+    // @ts-expect-error - This pattern is inherently an error.
+    interface Invalid<D extends Document.Any> extends _Invalid, D {}
+
+    /** @internal */
+    interface _Invalid {
+      _source: object;
+      system?: object | undefined;
+      get invalid(): true;
+    }
+
+    interface DropData<DocumentType extends Document.Type> {
+      /**
+       * The data used to create a new document.
+       * At least one of `data` and `uuid` must be set.
+       */
+      data?: Document.CreateDataForName<DocumentType>;
+
+      /**
+       * The uuid of an existing document.
+       * At least one of `data` and `uuid` must be set.
+       */
+      // TODO: Handle as part of the UUID update.
+      uuid?: string;
+    }
+  }
+
+  /** Any Document, that is a child of the given parent Document. */
+  // 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>;
 
   // 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 "CombatantGroup" ? CombatantGroup.CreateData : never)
+    | (DocumentType extends "FogExploration" ? FogExploration.CreateData : never)
+    | (DocumentType extends "Folder" ? Folder.CreateData : never)
+    | (DocumentType extends "Item" ? Item.CreateData : never)
+    | (DocumentType extends "JournalEntryCategory" ? JournalEntryCategory.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 "CombatantGroup" ? CombatantGroup.UpdateData : never)
+    | (DocumentType extends "FogExploration" ? FogExploration.UpdateData : never)
+    | (DocumentType extends "Folder" ? Folder.UpdateData : never)
+    | (DocumentType extends "Item" ? Item.UpdateData : never)
+    | (DocumentType extends "JournalEntryCategory" ? JournalEntryCategory.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);
+
+  type SourceForName<DocumentType extends Document.Type> =
+    | (DocumentType extends "ActiveEffect" ? ActiveEffect.Source : never)
+    | (DocumentType extends "ActorDelta" ? ActorDelta.Source : never)
+    | (DocumentType extends "Actor" ? Actor.Source : never)
+    | (DocumentType extends "Adventure" ? Adventure.Source : never)
+    | (DocumentType extends "Card" ? Card.Source : never)
+    | (DocumentType extends "Cards" ? Cards.Source : never)
+    | (DocumentType extends "ChatMessage" ? ChatMessage.Source : never)
+    | (DocumentType extends "Combat" ? Combat.Source : never)
+    | (DocumentType extends "Combatant" ? Combatant.Source : never)
+    | (DocumentType extends "CombatantGroup" ? CombatantGroup.Source : never)
+    | (DocumentType extends "FogExploration" ? FogExploration.Source : never)
+    | (DocumentType extends "Folder" ? Folder.Source : never)
+    | (DocumentType extends "Item" ? Item.Source : never)
+    | (DocumentType extends "JournalEntryCategory" ? JournalEntryCategory.Source : never)
+    | (DocumentType extends "JournalEntryPage" ? JournalEntryPage.Source : never)
+    | (DocumentType extends "JournalEntry" ? JournalEntry.Source : never)
+    | (DocumentType extends "Macro" ? Macro.Source : never)
+    | (DocumentType extends "PlaylistSound" ? PlaylistSound.Source : never)
+    | (DocumentType extends "Playlist" ? Playlist.Source : never)
+    | (DocumentType extends "RegionBehavior" ? RegionBehavior.Source : never)
+    | (DocumentType extends "RollTable" ? RollTable.Source : never)
+    | (DocumentType extends "Scene" ? Scene.Source : never)
+    | (DocumentType extends "Setting" ? Setting.Source : never)
+    | (DocumentType extends "TableResult" ? TableResult.Source : never)
+    | (DocumentType extends "User" ? User.Source : never)
+    | (DocumentType extends "AmbientLight" ? AmbientLightDocument.Source : never)
+    | (DocumentType extends "AmbientSound" ? AmbientSoundDocument.Source : never)
+    | (DocumentType extends "Drawing" ? DrawingDocument.Source : never)
+    | (DocumentType extends "MeasuredTemplate" ? MeasuredTemplateDocument.Source : never)
+    | (DocumentType extends "Note" ? NoteDocument.Source : never)
+    | (DocumentType extends "Region" ? NoteDocument.Source : never)
+    | (DocumentType extends "Tile" ? TileDocument.Source : never)
+    | (DocumentType extends "Token" ? TokenDocument.Source : never)
+    | (DocumentType extends "Wall" ? WallDocument.Source : never);
 
   type SystemConstructor = AnyConstructor & {
     metadata: { name: SystemType };
   };
 
-  type ConfiguredClassForName<Name extends Type> = MakeConform<
-    ConfiguredDocuments[Name],
-    Document.Internal.Constructor,
-    typeof ConfigurationFailure & DefaultDocuments[Name]
-  >;
-
-  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> = MakeConform<
-    ConfiguredDocuments[NameFor<ConcreteDocument>],
-    Document.AnyConstructor,
-    typeof ConfigurationFailure & DefaultDocuments[NameFor<ConcreteDocument>]
-  >;
-
-  type ToConfiguredInstance<ConcreteDocument extends Document.Internal.Constructor> = MakeConform<
-    FixedInstanceType<ConfiguredDocuments[NameFor<ConcreteDocument>]>,
-    Document.Any,
-    ConfigurationFailure & FixedInstanceType<DefaultDocuments[NameFor<ConcreteDocument>]>
+  type ToConfiguredClass<ConcreteDocument extends Document.Internal.Constructor> = ImplementationClassFor<
+    NameFor<ConcreteDocument>
   >;
 
-  type ToConfiguredStored<D extends Document.Internal.Constructor> = Stored<ToConfiguredInstance<D>>;
-
-  type Stored<D extends Document.Internal.Instance.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 Temporary<D extends Document.Internal.Instance.Any> = D extends Stored<infer U> ? U : D;
-
-  type NameFor<ConcreteDocument extends Document.Internal.Constructor> = ConcreteDocument extends {
-    readonly metadata: { readonly name: infer Name extends Type };
-  }
-    ? Name
-    : never;
-
-  type ConfiguredInstanceForName<Name extends Type> = MakeConform<
-    FixedInstanceType<ConfiguredDocuments[Name]>,
-    Document.Any
+  type ToConfiguredInstance<ConcreteDocument extends Document.Internal.Constructor> = ImplementationFor<
+    NameFor<ConcreteDocument>
   >;
 
-  type ConfiguredObjectClassForName<Name extends PlaceableType> = CONFIG[Name]["objectClass"];
-  type ConfiguredObjectInstanceForName<Name extends PlaceableType> = FixedInstanceType<CONFIG[Name]["objectClass"]>;
+  type TemporaryIf<D extends Document.Any, Temporary extends boolean | undefined> = Temporary extends true
+    ? D
+    : // eslint-disable-next-line @typescript-eslint/no-deprecated
+      Stored<D>;
+
+  type StoredForName<DocumentType extends Document.Type> =
+    | (DocumentType extends "ActiveEffect" ? ActiveEffect.Stored : never)
+    | (DocumentType extends "ActorDelta" ? ActorDelta.Stored : never)
+    | (DocumentType extends "Actor" ? Actor.Stored : never)
+    | (DocumentType extends "Adventure" ? Adventure.Stored : never)
+    | (DocumentType extends "Card" ? Card.Stored : never)
+    | (DocumentType extends "Cards" ? Cards.Stored : never)
+    | (DocumentType extends "ChatMessage" ? ChatMessage.Stored : never)
+    | (DocumentType extends "Combat" ? Combat.Stored : never)
+    | (DocumentType extends "Combatant" ? Combatant.Stored : never)
+    | (DocumentType extends "CombatantGroup" ? CombatantGroup.Stored : never)
+    | (DocumentType extends "FogExploration" ? FogExploration.Stored : never)
+    | (DocumentType extends "Folder" ? Folder.Stored : never)
+    | (DocumentType extends "Item" ? Item.Stored : never)
+    | (DocumentType extends "JournalEntryCategory" ? JournalEntryCategory.Stored : never)
+    | (DocumentType extends "JournalEntryPage" ? JournalEntryPage.Stored : never)
+    | (DocumentType extends "JournalEntry" ? JournalEntry.Stored : never)
+    | (DocumentType extends "Macro" ? Macro.Stored : never)
+    | (DocumentType extends "PlaylistSound" ? PlaylistSound.Stored : never)
+    | (DocumentType extends "Playlist" ? Playlist.Stored : never)
+    | (DocumentType extends "RegionBehavior" ? RegionBehavior.Stored : never)
+    | (DocumentType extends "RollTable" ? RollTable.Stored : never)
+    | (DocumentType extends "Scene" ? Scene.Stored : never)
+    | (DocumentType extends "Setting" ? Setting.Stored : never)
+    | (DocumentType extends "TableResult" ? TableResult.Stored : never)
+    | (DocumentType extends "User" ? User.Stored : never)
+    | (DocumentType extends "AmbientLight" ? AmbientLightDocument.Stored : never)
+    | (DocumentType extends "AmbientSound" ? AmbientSoundDocument.Stored : never)
+    | (DocumentType extends "Drawing" ? DrawingDocument.Stored : never)
+    | (DocumentType extends "MeasuredTemplate" ? MeasuredTemplateDocument.Stored : never)
+    | (DocumentType extends "Note" ? NoteDocument.Stored : never)
+    | (DocumentType extends "Region" ? NoteDocument.Stored : never)
+    | (DocumentType extends "Tile" ? TileDocument.Stored : never)
+    | (DocumentType extends "Token" ? TokenDocument.Stored : never)
+    | (DocumentType extends "Wall" ? WallDocument.Stored : never);
+
+  type InvalidForName<DocumentType extends Document.Type> =
+    | (DocumentType extends "ActiveEffect" ? ActiveEffect.Invalid : never)
+    | (DocumentType extends "ActorDelta" ? ActorDelta.Invalid : never)
+    | (DocumentType extends "Actor" ? Actor.Invalid : never)
+    | (DocumentType extends "Adventure" ? Adventure.Invalid : never)
+    | (DocumentType extends "Card" ? Card.Invalid : never)
+    | (DocumentType extends "Cards" ? Cards.Invalid : never)
+    | (DocumentType extends "ChatMessage" ? ChatMessage.Invalid : never)
+    | (DocumentType extends "Combat" ? Combat.Invalid : never)
+    | (DocumentType extends "Combatant" ? Combatant.Invalid : never)
+    | (DocumentType extends "CombatantGroup" ? CombatantGroup.Invalid : never)
+    | (DocumentType extends "FogExploration" ? FogExploration.Invalid : never)
+    | (DocumentType extends "Folder" ? Folder.Invalid : never)
+    | (DocumentType extends "Item" ? Item.Invalid : never)
+    | (DocumentType extends "JournalEntryCategory" ? JournalEntryCategory.Invalid : never)
+    | (DocumentType extends "JournalEntryPage" ? JournalEntryPage.Invalid : never)
+    | (DocumentType extends "JournalEntry" ? JournalEntry.Invalid : never)
+    | (DocumentType extends "Macro" ? Macro.Invalid : never)
+    | (DocumentType extends "PlaylistSound" ? PlaylistSound.Invalid : never)
+    | (DocumentType extends "Playlist" ? Playlist.Invalid : never)
+    | (DocumentType extends "RegionBehavior" ? RegionBehavior.Invalid : never)
+    | (DocumentType extends "RollTable" ? RollTable.Invalid : never)
+    | (DocumentType extends "Scene" ? Scene.Invalid : never)
+    | (DocumentType extends "Setting" ? Setting.Invalid : never)
+    | (DocumentType extends "TableResult" ? TableResult.Invalid : never)
+    | (DocumentType extends "User" ? User.Invalid : never)
+    | (DocumentType extends "AmbientLight" ? AmbientLightDocument.Invalid : never)
+    | (DocumentType extends "AmbientSound" ? AmbientSoundDocument.Invalid : never)
+    | (DocumentType extends "Drawing" ? DrawingDocument.Invalid : never)
+    | (DocumentType extends "MeasuredTemplate" ? MeasuredTemplateDocument.Invalid : never)
+    | (DocumentType extends "Note" ? NoteDocument.Invalid : never)
+    | (DocumentType extends "Region" ? NoteDocument.Invalid : never)
+    | (DocumentType extends "Tile" ? TileDocument.Invalid : never)
+    | (DocumentType extends "Token" ? TokenDocument.Invalid : never)
+    | (DocumentType extends "Wall" ? WallDocument.Invalid : never);
+
+  type NameFor<ConcreteDocument extends Document.Internal.Constructor> = ConcreteDocument["documentName"];
+
+  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"]>;
 
   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 _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>>;
@@ -1197,7 +1452,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<
@@ -1205,30 +1460,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> {
     /**
@@ -1314,187 +1605,846 @@ declare namespace Document {
     deleteAll?: boolean | undefined;
   }
 
-  type ModificationOptions = Omit<Document.ModificationContext<Document.Any | null>, "parent" | "pack">;
+  /** @internal */
+  type _CloneContext<Save extends boolean | null | undefined = boolean | null | undefined> = NullishProps<{
+    /**
+     * Save the clone to the World database?
+     * @defaultValue `false`
+     */
+    save: Save;
 
-  type PreCreateOptions<Name extends Type> = Omit<
-    Document.Database.OperationOf<Name, "create">,
-    "data" | "noHook" | "pack" | "parent"
-  >;
-  type OnCreateOptions<Name extends Type> = Omit<
-    Document.Database.OperationOf<Name, "create">,
-    "pack" | "parentUuid" | "syntheticActorUpdate"
-  >;
+    /**
+     * Keep the same ID of the original document
+     * @defaultValue `false`
+     */
+    keepId: boolean;
 
-  type PreUpdateOptions<Name extends Type> = Omit<
-    Document.Database.OperationOf<Name, "update">,
-    "updates" | "restoreDelta" | "noHook" | "parent" | "pack"
-  >;
-  type OnUpdateOptions<Name extends Type> = Omit<
-    Document.Database.OperationOf<Name, "update">,
-    "pack" | "parentUuid" | "syntheticActorUpdate"
-  >;
+    /**
+     * Track the clone source
+     * @defaultValue `false`
+     */
+    addSource: boolean;
+  }>;
 
-  type PreDeleteOptions<Name extends Type> = Omit<
-    Document.Database.OperationOf<Name, "delete">,
-    "ids" | "deleteAll" | "noHook" | "pack" | "parent"
-  >;
-  type OnDeleteOptions<Name extends Type> = Omit<
-    Document.Database.OperationOf<Name, "delete">,
-    "deleteAll" | "pack" | "parentUuid" | "syntheticActorUpdate"
-  >;
+  /**
+   * @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 PreUpsertOptions<Name extends Type> = PreCreateOptions<Name> | PreUpdateOptions<Name>;
-  type OnUpsertOptions<Name extends Type> = OnCreateOptions<Name> | OnUpdateOptions<Name>;
+  type ModificationOptions = Omit<Document.ModificationContext<Document.Any | null>, "parent" | "pack">;
 
   interface Metadata<out ThisType extends Document.Any> {
     readonly name: ThisType["documentName"];
-    readonly collection: string;
-    readonly indexed?: boolean | undefined;
-    readonly compendiumIndexFields?: readonly string[] | undefined;
     readonly label: string;
     readonly coreTypes: readonly string[];
-    readonly embedded: Record<string, string>;
+    readonly collection: string;
+    readonly embedded: {
+      [DocumentType in Document.Type]?: string;
+    };
     readonly permissions: {
-      create: string | ToMethod<(user: User, doc: ThisType, data: Document.ConstructorDataForName<Type>) => boolean>;
-      update: string | ToMethod<(user: User, doc: ThisType, data: Document.UpdateDataForName<Type>) => boolean>;
-      delete: string | ToMethod<(user: User, doc: ThisType, data: EmptyObject) => boolean>;
+      view: string | ToMethod<(user: User.Internal.Implementation, doc: ThisType, data: AnyObject) => 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 hasTypeData?: boolean;
+    readonly indexed: boolean;
+    readonly compendiumIndexFields: readonly string[];
+    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.
   }
 
   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 label: "DOCUMENT.Document";
+      readonly coreTypes: [CONST.BASE_DOCUMENT_TYPE];
+      readonly collection: "documents";
+      readonly embedded: EmptyObject;
+      readonly hasTypeData: false;
+      readonly indexed: false;
+      readonly compendiumIndexFields: [];
+      readonly permissions: {
+        view: "LIMITED";
         create: "ASSISTANT";
-        update: "ASSISTANT";
+        update: "OWNER";
         delete: "ASSISTANT";
       };
-      pack: null;
+      readonly preserveOnImport: ["_id", "sort", "ownership", "folder"];
     }
+
+    interface Embedded extends Identity<{ [K in Document.Type]?: string }> {}
+  }
+
+  type SheetClassFor<Name extends Document.Type> = MakeConform<
+    GetKey<GetKey<CONFIG, Name>, "sheetClass">,
+    AnyConstructor
+  >;
+
+  type LayerClassFor<Name extends Document.Type> = GetKey<GetKey<CONFIG, Name>, "layerClass">;
+
+  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 {@linkcode Document.createDocuments} */
+    type CreateOperation<Op extends DatabaseCreateOperation> = NullishProps<Omit<Op, "data" | "modifiedTime">>;
+
+    /** Used for {@linkcode Document.update} */
+    type UpdateOperation<Op extends DatabaseUpdateOperation> = InexactPartial<Omit<Op, "updates">>;
+
+    /** Used for {@linkcode Document.delete} */
+    type DeleteOperation<Op extends DatabaseDeleteOperation> = InexactPartial<Omit<Op, "ids">>;
+
+    /** Used for {@linkcode Document._preCreateOperation} */
+    type PreCreateOperationStatic<Op extends DatabaseCreateOperation> = InexactPartialExcept<
+      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 {@linkcode 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 {@linkcode Document._preUpdateOperation} */
+    type PreUpdateOperationStatic<Op extends DatabaseUpdateOperation> = InexactPartialExcept<
+      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 {@linkcode Document.deleteDocuments} */
+    type DeleteDocumentsOperation<Op extends DatabaseDeleteOperation> = NullishProps<Omit<Op, "ids" | "modifiedTime">>;
+
+    /** Used for {@linkcode Document.delete} */
+    type DeleteOperationInstance<Op extends DatabaseDeleteOperation> = InexactPartial<
+      Omit<Op, "ids" | "parent" | "pack">
+    >;
+
+    /** Used for {@linkcode Document._preDeleteOperation} */
+    type PreDeleteOperationStatic<Op extends DatabaseDeleteOperation> = InexactPartialExcept<
+      Op,
+      "modifiedTime" | "render" | "ids" | "deleteAll" | "noHook" | "pack" | "parent"
+    >;
+
+    /** Used for {@link Document._preDelete | `Document#_preDelete`} */
+    type PreDeleteOperationInstance<Op extends DatabaseDeleteOperation> = Omit<
+      InexactPartialExcept<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"
+    >;
+
+    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 "CombatantGroup" ? CombatantGroup.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 "JournalEntryCategory" ? JournalEntryCategory.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 CreateOperationForName<
+      DocumentType extends Document.Type,
+      Temporary extends boolean | undefined = undefined,
+    > =
+      | (DocumentType extends "ActiveEffect" ? ActiveEffect.Database.CreateOperation<Temporary> : never)
+      | (DocumentType extends "ActorDelta" ? ActorDelta.Database.CreateOperation<Temporary> : never)
+      | (DocumentType extends "Actor" ? Actor.Database.CreateOperation<Temporary> : never)
+      | (DocumentType extends "Adventure" ? Adventure.Database.CreateOperation<Temporary> : never)
+      | (DocumentType extends "Card" ? Card.Database.CreateOperation<Temporary> : never)
+      | (DocumentType extends "Cards" ? Cards.Database.CreateOperation<Temporary> : never)
+      | (DocumentType extends "ChatMessage" ? ChatMessage.Database.CreateOperation<Temporary> : never)
+      | (DocumentType extends "Combat" ? Combat.Database.CreateOperation<Temporary> : never)
+      | (DocumentType extends "Combatant" ? Combatant.Database.CreateOperation<Temporary> : never)
+      | (DocumentType extends "CombatantGroup" ? CombatantGroup.Database.CreateOperation<Temporary> : never)
+      | (DocumentType extends "FogExploration" ? FogExploration.Database.CreateOperation<Temporary> : never)
+      | (DocumentType extends "Folder" ? Folder.Database.CreateOperation<Temporary> : never)
+      | (DocumentType extends "Item" ? Item.Database.CreateOperation<Temporary> : never)
+      | (DocumentType extends "JournalEntryCategory" ? JournalEntryCategory.Database.CreateOperation<Temporary> : never)
+      | (DocumentType extends "JournalEntryPage" ? JournalEntryPage.Database.CreateOperation<Temporary> : never)
+      | (DocumentType extends "JournalEntry" ? JournalEntry.Database.CreateOperation<Temporary> : never)
+      | (DocumentType extends "Macro" ? Macro.Database.CreateOperation<Temporary> : never)
+      | (DocumentType extends "PlaylistSound" ? PlaylistSound.Database.CreateOperation<Temporary> : never)
+      | (DocumentType extends "Playlist" ? Playlist.Database.CreateOperation<Temporary> : never)
+      | (DocumentType extends "RegionBehavior" ? RegionBehavior.Database.CreateOperation<Temporary> : never)
+      | (DocumentType extends "RollTable" ? RollTable.Database.CreateOperation<Temporary> : never)
+      | (DocumentType extends "Scene" ? Scene.Database.CreateOperation<Temporary> : never)
+      | (DocumentType extends "Setting" ? Setting.Database.CreateOperation<Temporary> : never)
+      | (DocumentType extends "TableResult" ? TableResult.Database.CreateOperation<Temporary> : never)
+      | (DocumentType extends "User" ? User.Database.CreateOperation<Temporary> : never)
+      | (DocumentType extends "AmbientLight" ? AmbientLightDocument.Database.CreateOperation<Temporary> : never)
+      | (DocumentType extends "AmbientSound" ? AmbientSoundDocument.Database.CreateOperation<Temporary> : never)
+      | (DocumentType extends "Drawing" ? DrawingDocument.Database.CreateOperation<Temporary> : never)
+      | (DocumentType extends "MeasuredTemplate" ? MeasuredTemplateDocument.Database.CreateOperation<Temporary> : never)
+      | (DocumentType extends "Note" ? NoteDocument.Database.CreateOperation<Temporary> : never)
+      | (DocumentType extends "Region" ? RegionDocument.Database.CreateOperation<Temporary> : never)
+      | (DocumentType extends "Tile" ? TileDocument.Database.CreateOperation<Temporary> : never)
+      | (DocumentType extends "Token" ? TokenDocument.Database.CreateOperation<Temporary> : never)
+      | (DocumentType extends "Wall" ? WallDocument.Database.CreateOperation<Temporary> : 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 "CombatantGroup" ? CombatantGroup.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 "JournalEntryCategory" ? JournalEntryCategory.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 "CombatantGround" ? CombatantGroup.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 "JournalEntryCategory" ? JournalEntryCategory.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 "CombatantGroup" ? CombatantGroup.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 "JournalEntryCategory" ? JournalEntryCategory.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 "CombatantGroup" ? CombatantGroup.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 "JournalEntryCategory" ? JournalEntryCategory.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 "CombatantGroup" ? CombatantGroup.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 "JournalEntryCategory" ? JournalEntryCategory.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;
   }
 
   /**
-   * @deprecated {@link Document.Database.OperationOf | `Document.Database.OperationOf`}
+   * If a `parent` is required for a given Document's creation, its template must pass `NonNullable<X.Parent>` to `CreateDialogContext`
+   *
+   * @internal
    */
-  type DatabaseOperationsFor<
-    Name extends Document.Type,
-    ConcreteOperation extends Document.Database.Operation,
-  > = Document.Database.OperationOf<Name, ConcreteOperation>;
+  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;
+      };
 
-  type ConfiguredSheetClassFor<Name extends Document.Type> = MakeConform<
-    GetKey<GetKey<CONFIG, Name>, "sheetClass">,
-    AnyConstructor
+  /** @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> = InexactPartial<{
+    /**
+     * 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 | null;
+
+    /**
+     * 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 | null;
+  }> &
+    _PossibleSubtypeContext<DocumentName>;
+
+  // TODO(LukeAbby): Inline into each document.
+  type CreateDialogData<CreateData extends object> = InexactPartial<{
+    [K in keyof CreateData as Extract<K, "name" | "type" | "folder">]: CreateData[K];
+  }> &
+    Omit<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">[];
+        }>;
+
+  /** @deprecated in favor of {@linkcode CreateDialogOptions} */
+  type CreateDialogContext<
+    DocumentName extends Document.Type,
+    Parent extends Document.Any | null,
+  > = InexactPartial<foundry.appv1.api.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>;
+
+  type CreateDialogOptions<DocumentName extends Document.Type> =
+    InexactPartial<foundry.applications.api.DialogV2.PromptConfig> &
+      NullishProps<{
+        /**
+         * A template to use for the dialog contents instead of the default.
+         */
+        template: string;
+
+        /**
+         * Additional render context to provide to the template.
+         */
+        context: AnyObject;
+      }> &
+      _PossibleSubtypesContext<DocumentName>;
+
+  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;
+
+  /** @internal */
+  type _TestUserPermissionsOptions = NullishProps<{
+    /**
+     * Require the exact permission level requested?
+     * @defaultValue `false`
+     */
+    exact: boolean;
+  }>;
+
+  interface TestUserPermissionOptions extends _TestUserPermissionsOptions {}
+
+  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 ConfiguredObjectClassFor<Name extends Document.Type> = GetKey<GetKey<CONFIG, Name>, "objectClass">;
+  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;
+
+  type Clone<This extends Document.Any, Save extends boolean | null | undefined> = Save extends true
+    ? Promise<This>
+    : This;
+
+  /**
+   * The options for `fromDropData`. Foundry never uses these so the interface is currently empty.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+  interface DropDataOptions {}
+
+  type DropDataFor<Name extends Document.Type> = {
+    ActiveEffect: ActiveEffect.DropData;
+    ActorDelta: ActorDelta.DropData;
+    Actor: Actor.DropData;
+    Adventure: Adventure.DropData;
+    Card: Card.DropData;
+    Cards: Cards.DropData;
+    ChatMessage: ChatMessage.DropData;
+    Combat: Combat.DropData;
+    Combatant: Combatant.DropData;
+    CombatantGroup: CombatantGroup.DropData;
+    FogExploration: FogExploration.DropData;
+    Folder: Folder.DropData;
+    Item: Item.DropData;
+    JournalEntryCategory: JournalEntryCategory.DropData;
+    JournalEntryPage: JournalEntryPage.DropData;
+    JournalEntry: JournalEntry.DropData;
+    Macro: Macro.DropData;
+    PlaylistSound: PlaylistSound.DropData;
+    Playlist: Playlist.DropData;
+    RegionBehavior: RegionBehavior.DropData;
+    RollTable: RollTable.DropData;
+    Scene: Scene.DropData;
+    Setting: Setting.DropData;
+    TableResult: TableResult.DropData;
+    User: User.DropData;
+    AmbientLight: AmbientLightDocument.DropData;
+    AmbientSound: AmbientSoundDocument.DropData;
+    Drawing: DrawingDocument.DropData;
+    MeasuredTemplate: MeasuredTemplateDocument.DropData;
+    Note: NoteDocument.DropData;
+    Region: RegionDocument.DropData;
+    Tile: TileDocument.DropData;
+    Token: TokenDocument.DropData;
+    Wall: WallDocument.DropData;
+  }[Name];
+
+  /**
+   * @deprecated This type should not be used directly. Use `StoredForName` as this type does not account for anything declaration merged into `Stored`.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
+  type ToConfiguredStored<D extends Document.AnyConstructor> = Stored<ToConfiguredInstance<D>>;
+
+  /**
+   * @deprecated This type should not be used directly. Use `StoredForName` as this type does not account for anything declaration merged into `Stored`.
+   */
+  type Stored<D extends Document.Any> = Document.Internal.Stored<D>;
+
+  /**
+   * @deprecated This type should not be used directly. Use `InvalidForName` as this type does not account for anything declaration merged into `Invalid`.
+   */
+  type Invalid<D extends Document.Any> = Document.Internal.Invalid<D>;
+
+  /**
+   * @deprecated This type should not be used directly. Use `StoredForName` as this type does not account for anything declaration merged into `Stored`.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
+  type ToStored<D extends Document.AnyConstructor> = Stored<FixedInstanceType<D>>;
+
+  /**
+   * @deprecated This type should not be used directly. Use `StoredForName` as this type does not account for anything declaration merged into `Stored`.
+   */
+  type ToStoredIf<D extends Document.AnyConstructor, Temporary extends boolean | undefined> = Temporary extends true
+    ? FixedInstanceType<D>
+    : // eslint-disable-next-line @typescript-eslint/no-deprecated
+      ToConfiguredStored<D>;
+
+  /** @deprecated This type currently does not have a replacement as it was deemed too niche. If you have a use case for it let us know. */
+  type Temporary<D extends Document.Any> = D extends Internal.Stored<infer U> ? U : D;
+
+  /**
+   * @deprecated Replaced with {@linkcode Document.SheetClassFor}
+   */
+  export import ConfiguredSheetClassFor = Document.SheetClassFor;
+
+  /**
+   * @deprecated Replaced with {@linkcode Document.ObjectClassFor}
+   */
+  export import ConfiguredObjectClassFor = Document.ObjectClassFor;
 
-  type ConfiguredLayerClassFor<Name extends Document.Type> = GetKey<GetKey<CONFIG, Name>, "layerClass">;
+  /**
+   * @deprecated Replaced with {@linkcode Document.LayerClassFor}
+   */
+  export import ConfiguredLayerClassFor = Document.LayerClassFor;
+
+  /**
+   * Returns the type of the constructor data for the given {@linkcode foundry.abstract.Document}.
+   * @deprecated Replaced with {@linkcode CreateDataForName}
+   */
+  type CreateDataFor<T extends Document.Internal.Constructor> = SchemaField.CreateData<
+    T extends { defineSchema: () => infer R extends DataSchema } ? R : never
+  >;
 
+  /**
+   * @deprecated Replaced with {@linkcode UpdateDataForName}
+   */
+  type UpdateDataFor<T extends Document.Internal.Constructor> = SchemaField.UpdateData<
+    T extends { defineSchema: () => infer R extends DataSchema } ? R : never
+  >;
+
+  /**
+   * @deprecated Use `[Document].DropData` instead.
+   */
   type DropData<T extends Document.Any> = T extends { id: string | undefined }
-    ? DropData.Data<T> & DropData.UUID
-    : DropData.Data<T>;
+    ? // eslint-disable-next-line @typescript-eslint/no-deprecated
+      DropData.Data<T> & DropData.UUID
+    : // eslint-disable-next-line @typescript-eslint/no-deprecated
+      DropData.Data<T>;
 
   namespace DropData {
+    /**
+     * @deprecated - This type is likely too broad to be useful. Deprecated without replacement.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
     type Any = DropData<any>;
 
+    /**
+     * @deprecated - This type is a part of the drop data which is now gotten through
+     * `[Document].DropData`. Use that instead.
+     */
     interface Data<T extends Document.Any> {
       type: T["documentName"];
       data: T["_source"];
     }
 
+    /**
+     * @deprecated - This type is a part of the drop data which is now gotten through
+     * `[Document].DropData`. Use that instead.
+     */
     interface UUID {
       uuid: string;
     }
   }
 
-  namespace Database {
-    type Operation = "create" | "update" | "delete";
-
-    /* eslint-disable @typescript-eslint/no-empty-object-type */
-    interface Operations<
-      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>;
-    }
-    /* eslint-enable @typescript-eslint/no-empty-object-type */
-
-    /**
-     * This is a helper type that gets the right DatabaseOperation (including the
-     * proper options) for a particular Document type.
-     */
-    type OperationOf<
-      T extends Document.Type,
-      Operation extends Database.Operation,
-      // eslint-disable-next-line @typescript-eslint/no-deprecated
-    > = DatabaseOperationMap[T][Operation];
-  }
-}
-
-/** @deprecated {@link Document.Database.Operation | `Document.Database.Operation`} */
-export type Operation = Document.Database.Operation;
-
-/* eslint-disable @typescript-eslint/no-empty-object-type */
-/** @deprecated {@link Document.Database.Operations | `Document.Database.Operations`} */
-export type DocumentDatabaseOperations<
-  T extends Document.Internal.Instance.Any = Document.Internal.Instance.Any,
-  ExtraCreateOptions extends AnyObject = {},
-  ExtraUpdateOptions extends AnyObject = {},
-  ExtraDeleteOptions extends AnyObject = {},
-> = Document.Database.Operations<T, ExtraCreateOptions, ExtraUpdateOptions, ExtraDeleteOptions>;
-/* eslint-enable @typescript-eslint/no-empty-object-type */
+  /**
+   * @deprecated This type has been deprecated because of the inconsistent casing of "Subtype" instead of "SubType". Use {@linkcode Document.ModuleSubType} instead.
+   */
+  type ModuleSubtype = ModuleSubType;
 
-/**
- * @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;
-  ActorDelta: ActorDelta.DatabaseOperations;
-  Adventure: Adventure.DatabaseOperations;
-  AmbientLight: AmbientLightDocument.DatabaseOperations;
-  AmbientSound: AmbientSoundDocument.DatabaseOperations;
-  Card: Card.DatabaseOperations;
-  Cards: Cards.DatabaseOperations;
-  ChatMessage: ChatMessage.DatabaseOperations;
-  Combat: Combat.DatabaseOperations;
-  Combatant: Combatant.DatabaseOperations;
-  Drawing: DrawingDocument.DatabaseOperations;
-  FogExploration: FogExploration.DatabaseOperations;
-  Folder: Folder.DatabaseOperations;
-  Item: Item.DatabaseOperations;
-  JournalEntry: JournalEntry.DatabaseOperations;
-  JournalEntryPage: JournalEntryPage.DatabaseOperations;
-  Macro: Macro.DatabaseOperations;
-  MeasuredTemplate: MeasuredTemplateDocument.DatabaseOperations;
-  Note: NoteDocument.DatabaseOperations;
-  Playlist: Playlist.DatabaseOperations;
-  PlaylistSound: PlaylistSound.DatabaseOperations;
-  Region: ActiveEffect.DatabaseOperations;
-  RegionBehavior: ActiveEffect.DatabaseOperations;
-  RollTable: RollTable.DatabaseOperations;
-  Scene: Scene.DatabaseOperations;
-  Setting: Setting.DatabaseOperations;
-  TableResult: TableResult.DatabaseOperations;
-  Tile: TileDocument.DatabaseOperations;
-  Token: TokenDocument.DatabaseOperations;
-  User: User.DatabaseOperations;
-  Wall: WallDocument.DatabaseOperations;
+  /**
+   * @deprecated This type was used to simplify the logic behind `ConstructorArgs` but that's now being deprecated.
+   */
+  type ConstructorParameters<CreateData extends object | undefined, Parent extends Document.Any | null> = [
+    data?: CreateData,
+    context?: Document.ConstructionContext<Parent>,
+  ];
 }