@league-of-foundry-developers/foundry-vtt-types 12.331.2-beta → 13.340.0

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

@@ -5,43 +5,49 @@ import type {
   ConstructorData,
 } from "../../../types/documentConfiguration.d.mts";
 import type {
-  DatabaseOperationsFor,
   GetKey,
   InterfaceToObject,
   MakeConform,
   MustConform,
   ToMethod,
-} from "../../../types/helperTypes.mts";
-import type {
   AnyObject,
   DeepPartial,
   EmptyObject,
   InexactPartial,
   RemoveIndexSignatures,
-} from "../../../types/utils.mts";
-import type { documents } from "../../client-esm/client.d.mts";
+  FixedInstanceType,
+} from "../../../utils/index.d.mts";
 import type * as CONST from "../constants.mts";
 import type { DataField, EmbeddedCollectionField, EmbeddedDocumentField } from "../data/fields.d.mts";
-import type { fields } from "../data/module.mts";
+import type { fields } from "../data/_module.d.mts";
 import type { LogCompatibilityWarningOptions } from "../utils/logging.mts";
 import type {
+  DatabaseAction,
   DatabaseCreateOperation,
   DatabaseDeleteOperation,
   DatabaseGetOperation,
   DatabaseUpdateOperation,
+  DocumentSocketRequest,
 } from "./_types.d.mts";
 import type DataModel from "./data.mts";
+import type DocumentSocketResponse from "./socket.d.mts";
 
-export default Document;
-
-declare const __DocumentBrand: unique symbol;
+type DataSchema = foundry.data.fields.DataSchema;
 
-declare const __Schema: unique symbol;
-declare const __Parent: unique symbol;
+export default Document;
 
 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
+>;
+
 /**
  * An extension of the base DataModel which defines a Document.
  * Documents are special in that they are persisted to the database and referenced by _id.
@@ -51,10 +57,11 @@ declare abstract class Document<
   Schema extends DataSchema,
   Parent extends Document.Any | null = null,
 > extends DataModel<Schema, Parent, InterfaceToObject<Document.ConstructionContext<Parent>>> {
-  static [__DocumentBrand]: never;
+  static [Document.Internal.DocumentBrand]: true;
 
-  [__Schema]: Schema;
-  [__Parent]: Parent;
+  [Document.Internal.DocumentName]: DocumentName;
+  [Document.Internal.Schema]: Schema;
+  [Document.Internal.Parent]: Parent;
 
   /**
    * @param data    - Initial data provided to construct the Document
@@ -130,8 +137,6 @@ declare abstract class Document<
   /**
    * Return a reference to the implemented subclass of this base document type.
    */
-  // Referencing the concrete class the config is not possible because accessors cannot be generic and there is not
-  // static polymorphic this type
   static get implementation(): Document.AnyConstructor;
 
   /**
@@ -157,7 +162,7 @@ declare abstract class Document<
   /**
    * The canonical name of this Document type, for example "Actor".
    */
-  get documentName(): Document.Internal.SimpleMetadata<DocumentName>["name"];
+  get documentName(): DocumentName;
 
   /**
    * The allowed types which may exist for this Document class
@@ -201,7 +206,7 @@ declare abstract class Document<
    * @param user - The User being tested
    * @returns Does the User have a sufficient role to create?
    */
-  static canUserCreate(user: foundry.documents.BaseUser): boolean;
+  static canUserCreate(user: User): boolean;
 
   /**
    * Get the explicit permission level that a specific User has over this Document, a value in CONST.DOCUMENT_OWNERSHIP_LEVELS.
@@ -211,7 +216,7 @@ declare abstract class Document<
    *               (default: `game.user`)
    * @returns A numeric permission level from CONST.DOCUMENT_OWNERSHIP_LEVELS or null
    */
-  getUserLevel(user?: foundry.documents.BaseUser): CONST.DOCUMENT_OWNERSHIP_LEVELS | null;
+  getUserLevel(user?: User): CONST.DOCUMENT_OWNERSHIP_LEVELS | null;
 
   /**
    * Test whether a certain User has a requested permission level (or greater) over the Document
@@ -221,7 +226,7 @@ declare abstract class Document<
    * @returns Does the user have this permission level over the Document?
    */
   testUserPermission(
-    user: foundry.documents.BaseUser,
+    user: User,
     permission: keyof typeof CONST.DOCUMENT_OWNERSHIP_LEVELS | CONST.DOCUMENT_OWNERSHIP_LEVELS,
     options?: InexactPartial<{
       /**
@@ -240,7 +245,7 @@ declare abstract class Document<
    *                 (default: `{}`)
    * @returns Does the User have permission?
    */
-  canUserModify(user: foundry.documents.BaseUser, action: "create" | "update" | "delete", data?: object): boolean;
+  canUserModify(user: User, action: "create" | "update" | "delete", data?: object): boolean;
 
   /**
    * Clone a document, creating a new document by combining current data with provided overrides.
@@ -321,8 +326,10 @@ declare abstract class Document<
    */
   static createDocuments<T extends Document.AnyConstructor, Temporary extends boolean | undefined>(
     this: T,
-    data: Array<Document.ConstructorDataFor<T>>,
-    operation?: InexactPartial<Omit<DatabaseOperationsFor<T["metadata"]["name"], "create">, "data">> & {
+    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>;
@@ -364,8 +371,10 @@ declare abstract class Document<
    */
   static updateDocuments<T extends Document.AnyConstructor>(
     this: T,
-    updates?: Array<DeepPartial<Document.UpdateDataFor<T>>>,
-    operation?: InexactPartial<Omit<DatabaseOperationsFor<InstanceType<T>["documentName"], "update">, "updates">>,
+    updates?: Array<DeepPartial<Document.UpdateDataFor<NoInfer<T>>>>,
+    operation?: InexactPartial<
+      Omit<Document.Database.OperationOf<FixedInstanceType<NoInfer<T>>["documentName"], "update">, "updates">
+    >,
   ): Promise<Document.ToConfiguredInstance<T>[]>;
 
   /**
@@ -408,7 +417,9 @@ declare abstract class Document<
   static deleteDocuments<T extends Document.AnyConstructor>(
     this: T,
     ids?: string[],
-    operation?: InexactPartial<Omit<DatabaseOperationsFor<InstanceType<T>["documentName"], "delete">, "ids">>,
+    operation?: InexactPartial<
+      Omit<Document.Database.OperationOf<FixedInstanceType<NoInfer<T>>["documentName"], "delete">, "ids">
+    >,
   ): Promise<Document.ToConfiguredInstance<T>[]>;
 
   /**
@@ -442,8 +453,10 @@ declare abstract class Document<
    */
   static create<T extends Document.AnyConstructor, Temporary extends boolean | undefined>(
     this: T,
-    data: Document.ConstructorDataFor<T> | Document.ConstructorDataFor<T>[],
-    operation?: InexactPartial<Omit<DatabaseOperationsFor<T["metadata"]["name"], "create">, "data">> & {
+    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>;
@@ -462,7 +475,7 @@ declare abstract class Document<
   update(
     // TODO: Determine if this is Partial, DeepPartial, or InexactPartial.
     data?: Partial<Document.ConstructorDataForSchema<Schema>>,
-    operation?: InexactPartial<Omit<DatabaseOperationsFor<DocumentName, "update">, "updates">>,
+    operation?: InexactPartial<Omit<Document.Database.OperationOf<DocumentName, "update">, "updates">>,
   ): Promise<this | undefined>;
 
   /**
@@ -475,7 +488,7 @@ declare abstract class Document<
    * @remarks If no document has actually been deleted, the returned {@link Promise} resolves to `undefined`.
    */
   delete(
-    operation?: InexactPartial<Omit<DatabaseOperationsFor<DocumentName, "delete">, "ids">>,
+    operation?: InexactPartial<Omit<Document.Database.OperationOf<DocumentName, "delete">, "ids">>,
   ): Promise<this | undefined>;
 
   /**
@@ -511,10 +524,9 @@ declare abstract class Document<
    * @returns The Collection instance of embedded Documents of the requested type
    * @remarks Usually returns some form of DocumentCollection, but not always (e.g. Token["actors"])
    */
-  // TODO: After regions are defined, change first parameter to `extends foundry.CONST.EMBEDDED_DOCUMENT_TYPES`
-  getEmbeddedCollection<
-    EmbeddedName extends Exclude<foundry.CONST.EMBEDDED_DOCUMENT_TYPES, "Region" | "RegionBehavior">,
-  >(embeddedName: EmbeddedName): Collection<Document.ConfiguredInstanceForName<EmbeddedName>>;
+  getEmbeddedCollection<EmbeddedName extends foundry.CONST.EMBEDDED_DOCUMENT_TYPES>(
+    embeddedName: EmbeddedName,
+  ): Collection<Document.ConfiguredInstanceForName<EmbeddedName>>;
 
   /**
    * Get an embedded document by its id from a named collection in the parent document.
@@ -551,7 +563,6 @@ declare abstract class Document<
    *                       (default: `{}`)
    * @returns An array of created Document instances
    */
-  // TODO: After regions are defined, change first parameter to `extends foundry.CONST.EMBEDDED_DOCUMENT_TYPES`
   // TODO: I think we could do a better job on all the embedded methods of limiting the types here based on the
   //   allowed embedded types of the parent (vs. allowing any document to create embedded
   //   documents of any type)
@@ -561,7 +572,7 @@ declare abstract class Document<
   >(
     embeddedName: EmbeddedName,
     data?: Array<Document.ConstructorDataForName<Extract<EmbeddedName, Document.Type>>>,
-    operation?: InexactPartial<DatabaseOperationsFor<Extract<EmbeddedName, Document.Type>, "create">> & {
+    operation?: InexactPartial<Document.Database.OperationOf<Extract<EmbeddedName, Document.Type>, "create">> & {
       temporary?: Temporary;
     },
   ): Promise<Array<Document.ConfiguredInstanceForName<Extract<EmbeddedName, Document.Type>>> | undefined>;
@@ -576,7 +587,6 @@ declare abstract class Document<
    *                       (default: `{}`)
    * @returns An array of updated Document instances
    */
-  // TODO: After regions are defined, change first parameter to `extends foundry.CONST.EMBEDDED_DOCUMENT_TYPES`
   updateEmbeddedDocuments<EmbeddedName extends foundry.CONST.EMBEDDED_DOCUMENT_TYPES>(
     embeddedName: EmbeddedName,
     updates?: Array<AnyObject>,
@@ -592,13 +602,10 @@ declare abstract class Document<
    *                       (default: `{}`)
    * @returns An array of deleted Document instances
    */
-  // TODO: After regions are defined, change first parameter to `extends foundry.CONST.EMBEDDED_DOCUMENT_TYPES`
-  deleteEmbeddedDocuments<
-    EmbeddedName extends Exclude<foundry.CONST.EMBEDDED_DOCUMENT_TYPES, "Region" | "RegionBehavior">,
-  >(
+  deleteEmbeddedDocuments<EmbeddedName extends foundry.CONST.EMBEDDED_DOCUMENT_TYPES>(
     embeddedName: EmbeddedName,
     ids: Array<string>,
-    operation?: DatabaseOperationsFor<DocumentName, "delete">,
+    operation?: Document.Database.OperationOf<DocumentName, "delete">,
   ): Promise<Array<Document.Stored<Document.ConfiguredInstanceForName<EmbeddedName>>>>;
 
   /**
@@ -665,7 +672,7 @@ declare abstract class Document<
   protected _preCreate(
     data: fields.SchemaField.AssignmentType<Schema>,
     options: Document.PreCreateOptions<DocumentName>,
-    user: foundry.documents.BaseUser,
+    user: User,
   ): Promise<boolean | void>;
 
   /**
@@ -697,9 +704,9 @@ declare abstract class Document<
    */
   protected static _preCreateOperation<T extends Document.AnyConstructor>(
     this: T,
-    documents: InstanceType<Document.ConfiguredClass<T>>[],
-    operation: DatabaseOperationsFor<T["metadata"]["name"], "create">,
-    user: foundry.documents.BaseUser,
+    documents: Document.ToConfiguredInstance<NoInfer<T>>[],
+    operation: Document.Database.OperationOf<NoInfer<T>["metadata"]["name"], "create">,
+    user: User,
   ): Promise<boolean | void>;
 
   /**
@@ -714,9 +721,9 @@ declare abstract class Document<
    */
   protected static _onCreateOperation<T extends Document.AnyConstructor>(
     this: T,
-    documents: InstanceType<Document.ConfiguredClass<T>>[],
-    operation: DatabaseOperationsFor<T["metadata"]["name"], "create">,
-    user: foundry.documents.BaseUser,
+    documents: Document.ToConfiguredInstance<NoInfer<T>>[],
+    operation: Document.Database.OperationOf<NoInfer<T>["metadata"]["name"], "create">,
+    user: User,
   ): Promise<void>;
 
   /**
@@ -730,7 +737,7 @@ declare abstract class Document<
   protected _preUpdate(
     changed: fields.SchemaField.AssignmentType<Schema>,
     options: Document.PreUpdateOptions<DocumentName>,
-    user: foundry.documents.BaseUser,
+    user: User,
   ): Promise<boolean | void>;
 
   /**
@@ -741,7 +748,7 @@ declare abstract class Document<
    * @param userId  - The id of the User requesting the document update
    */
   protected _onUpdate(
-    changed: fields.SchemaField.InnerAssignmentType<Schema>,
+    changed: fields.SchemaField.InnerUpdateData<Schema>,
     options: Document.OnUpdateOptions<DocumentName>,
     userId: string,
   ): void;
@@ -763,9 +770,9 @@ declare abstract class Document<
    */
   protected static _preUpdateOperation<T extends Document.AnyConstructor>(
     this: T,
-    documents: InstanceType<Document.ConfiguredClass<T>>[],
-    operation: DatabaseOperationsFor<InstanceType<T>["documentName"], "update">,
-    user: foundry.documents.BaseUser,
+    documents: Document.ToConfiguredInstance<NoInfer<T>>[],
+    operation: Document.Database.OperationOf<FixedInstanceType<NoInfer<T>>["documentName"], "update">,
+    user: User,
   ): Promise<boolean | void>;
 
   /**
@@ -780,9 +787,9 @@ declare abstract class Document<
    */
   protected static _onUpdateOperation<T extends Document.AnyConstructor>(
     this: T,
-    documents: InstanceType<Document.ConfiguredClass<T>>[],
-    operation: DatabaseOperationsFor<InstanceType<T>["documentName"], "update">,
-    user: foundry.documents.BaseUser,
+    documents: Document.ToConfiguredInstance<NoInfer<T>>[],
+    operation: Document.Database.OperationOf<FixedInstanceType<NoInfer<T>>["documentName"], "update">,
+    user: User,
   ): Promise<void>;
 
   /**
@@ -792,10 +799,7 @@ declare abstract class Document<
    * @param user    - The User requesting the document deletion
    * @returns A return value of false indicates the delete operation should be cancelled
    */
-  protected _preDelete(
-    options: Document.PreDeleteOptions<DocumentName>,
-    user: foundry.documents.BaseUser,
-  ): Promise<boolean | void>;
+  protected _preDelete(options: Document.PreDeleteOptions<DocumentName>, user: User): Promise<boolean | void>;
 
   /**
    * Perform follow-up operations after a Document of this type is deleted.
@@ -823,9 +827,9 @@ declare abstract class Document<
    */
   protected static _preDeleteOperation<T extends Document.AnyConstructor>(
     this: T,
-    documents: Array<Document.ToConfiguredInstance<T>>,
-    operation: DatabaseOperationsFor<InstanceType<T>["documentName"], "delete">,
-    user: foundry.documents.BaseUser,
+    documents: Document.ToConfiguredInstance<NoInfer<T>>[],
+    operation: Document.Database.OperationOf<FixedInstanceType<NoInfer<T>>["documentName"], "delete">,
+    user: User,
   ): Promise<unknown>;
 
   /**
@@ -840,9 +844,9 @@ declare abstract class Document<
    */
   protected static _onDeleteOperation<T extends Document.AnyConstructor>(
     this: T,
-    documents: Array<Document.ToConfiguredInstance<T>>,
-    operation: DatabaseOperationsFor<InstanceType<T>["documentName"], "delete">,
-    user: foundry.documents.BaseUser,
+    documents: Document.ToConfiguredInstance<NoInfer<T>>[],
+    operation: Document.Database.OperationOf<FixedInstanceType<NoInfer<T>>["documentName"], "delete">,
+    user: User,
   ): Promise<unknown>;
 
   /**
@@ -894,7 +898,7 @@ declare abstract class Document<
    */
   protected static _onCreateDocuments<T extends Document.AnyConstructor>(
     this: T,
-    documents: Array<Document.ToConfiguredInstance<T>>,
+    documents: Array<Document.ToConfiguredInstance<NoInfer<T>>>,
     context: Document.ModificationContext<Document.Any | null>,
   ): Promise<void>;
 
@@ -904,7 +908,7 @@ declare abstract class Document<
    */
   protected static _onUpdateDocuments<T extends Document.AnyConstructor>(
     this: T,
-    documents: Array<Document.ToConfiguredInstance<T>>,
+    documents: Array<Document.ToConfiguredInstance<NoInfer<T>>>,
     context: Document.ModificationContext<Document.Any | null>,
   ): Promise<unknown>;
 
@@ -914,7 +918,7 @@ declare abstract class Document<
    */
   protected static _onDeleteDocuments<T extends Document.AnyConstructor>(
     this: T,
-    documents: Array<Document.ToConfiguredInstance<T>>,
+    documents: Array<Document.ToConfiguredInstance<NoInfer<T>>>,
     context: Document.ModificationContext<Document.Any | null>,
   ): Promise<unknown>;
 }
@@ -922,9 +926,9 @@ declare abstract class Document<
 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`.
+  // Note(LukeAbby): Specifically adding the `DocumentBrand` should be redundant but in practice it seems to help tsc more efficiently deduce that it's actually inheriting from `Document`.
   // This is odd but probably is because it bails from looking up the parent class properties at times or something.
-  static [__DocumentBrand]: never;
+  static [Document.Internal.DocumentBrand]: true;
 
   flags?: unknown;
 
@@ -934,11 +938,17 @@ declare abstract class AnyDocument extends Document<any, any, any> {
 // Note(LukeAbby): The point of this class is to show up in intellisense.
 // When something fails to be configured it should be replaced with `typeof ConfigurationFailure & typeof Item` or whatever the relevant class is.
 // This helps to minimize the number of errors that appears in a repo with broken configuration as they can be very misleading and confusing.
-declare abstract class ConfigurationFailure extends AnyDocument {}
+declare abstract class ConfigurationFailure extends AnyDocument {
+  static [Document.Internal.DocumentBrand]: true;
+}
 
 declare namespace Document {
   /** Any Document, except for Settings */
   type Any = AnyDocument;
+  type AnyConstructor = typeof AnyDocument;
+
+  type ConfigurationFailureClass = typeof ConfigurationFailure;
+  type ConfigurationFailureInstance = ConfigurationFailure;
 
   type Type =
     | "ActiveEffect"
@@ -958,6 +968,8 @@ declare namespace Document {
     | "Macro"
     | "PlaylistSound"
     | "Playlist"
+    | "RegionBehavior"
+    | "Region"
     | "RollTable"
     | "Scene"
     | "Setting"
@@ -972,6 +984,7 @@ declare namespace Document {
     | "Drawing"
     | "MeasuredTemplate"
     | "Note"
+    | "Region"
     | "Tile"
     | "Token"
     | "Wall";
@@ -989,10 +1002,14 @@ declare namespace Document {
     | "Combat"
     | "Combatant"
     | "Item"
-    | "JournalEntryPage";
+    | "JournalEntryPage"
+    | "RegionBehavior";
 
   type EmbeddableNamesFor<ConcreteDocument extends Document.Internal.Instance.Any> = {
-    [K in keyof ConfiguredDocuments]: IsParentOf<ConcreteDocument, InstanceType<ConfiguredDocuments[K]>> extends true
+    [K in keyof ConfiguredDocuments]: IsParentOf<
+      ConcreteDocument,
+      FixedInstanceType<ConfiguredDocuments[K]>
+    > extends true
       ? K
       : never;
   };
@@ -1002,25 +1019,44 @@ declare namespace Document {
     ChildDocument extends Document.Internal.Instance.Any,
   > = ParentDocument extends Internal.ParentFor<ChildDocument> ? true : false;
 
+  type SocketRequest<Action extends DatabaseAction> = DocumentSocketRequest<Action>;
+  type SocketResponse<Action extends DatabaseAction> = DocumentSocketResponse<Action>;
+
   // Documented at https://gist.github.com/LukeAbby/c7420b053d881db4a4d4496b95995c98
   namespace Internal {
+    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]: never;
+      [DocumentBrand]: true;
     };
 
-    interface Instance<Schema extends DataSchema, Parent extends Document.Internal.Instance.Any | null> {
-      [__Schema]: Schema;
-      [__Parent]: Parent;
+    interface Instance<
+      DocumentName extends Document.Type,
+      Schema extends DataSchema,
+      Parent extends Document.Internal.Instance.Any | null,
+    > {
+      [DocumentName]: DocumentName;
+      [Schema]: Schema;
+      [Parent]: Parent;
     }
 
-    type SchemaFor<ConcreteInstance extends Instance.Any> = ConcreteInstance[typeof __Schema];
+    type DocumentNameFor<ConcreteInstance extends Instance.Any> = ConcreteInstance[typeof DocumentName];
+
+    type SchemaFor<ConcreteInstance extends Instance.Any> = ConcreteInstance[typeof Schema];
 
-    type ParentFor<ConcreteInstance extends Instance.Any> = ConcreteInstance[typeof __Parent];
+    type ParentFor<ConcreteInstance extends Instance.Any> = ConcreteInstance[typeof Parent];
 
     namespace Instance {
-      type Any = Instance<any, any>;
+      type Any = Instance<any, any, any>;
 
       type Complete<T extends Any> = T extends Document.Any ? T : never;
     }
@@ -1029,8 +1065,6 @@ declare namespace Document {
   /** Any Document, that is a child of the given parent Document. */
   type AnyChild<Parent extends Any | null> = Document<any, any, Parent>;
 
-  type AnyConstructor = typeof AnyDocument;
-
   /**
    * Returns the type of the constructor data for the given {@link foundry.abstract.Document}.
    */
@@ -1054,25 +1088,28 @@ declare namespace Document {
     metadata: { name: SystemType };
   };
 
-  type ConfiguredClass<T extends { metadata: Metadata.Any }> = ConfiguredClassForName<T["metadata"]["name"]>;
-
   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<
-    // NOTE(LukeAbby): This avoids calling `Document.ToConfiguredClass` because that checks the static side of the class which can be expensive and even lead to loops.
-    InstanceType<ConfiguredDocuments[NameFor<ConcreteDocument>]>,
-    ConfigurationFailure & InstanceType<DefaultDocuments[NameFor<ConcreteDocument>]>
+    FixedInstanceType<ConfiguredDocuments[NameFor<ConcreteDocument>]>,
+    Document.Any,
+    ConfigurationFailure & FixedInstanceType<DefaultDocuments[NameFor<ConcreteDocument>]>
   >;
 
   type ToConfiguredStored<D extends Document.Internal.Constructor> = Stored<ToConfiguredInstance<D>>;
@@ -1097,12 +1134,12 @@ declare namespace Document {
     : never;
 
   type ConfiguredInstanceForName<Name extends Type> = MakeConform<
-    InstanceType<ConfiguredDocuments[Name]>,
+    FixedInstanceType<ConfiguredDocuments[Name]>,
     Document.Any
   >;
 
   type ConfiguredObjectClassForName<Name extends PlaceableType> = CONFIG[Name]["objectClass"];
-  type ConfiguredObjectInstanceForName<Name extends PlaceableType> = InstanceType<CONFIG[Name]["objectClass"]>;
+  type ConfiguredObjectInstanceForName<Name extends PlaceableType> = FixedInstanceType<CONFIG[Name]["objectClass"]>;
 
   type ConfiguredDataForName<Name extends Type> = GetKey<DataConfig, Name, EmptyObject>;
 
@@ -1117,7 +1154,7 @@ declare namespace Document {
     : T;
 
   type SchemaFor<ConcreteDocument extends Internal.Instance.Any> =
-    ConcreteDocument extends Internal.Instance<infer Schema, any> ? Schema : never;
+    ConcreteDocument extends Internal.Instance<infer _1, infer Schema, infer _2> ? Schema : never;
 
   type MetadataFor<ConcreteDocument extends Document.Internal.Instance.Any> =
     ConfiguredMetadata<ConcreteDocument>[ConcreteDocument extends {
@@ -1132,11 +1169,12 @@ declare namespace Document {
 
   type Flags<ConcreteDocument extends Internal.Instance.Any> = OptionsForSchema<SchemaFor<ConcreteDocument>>;
 
-  interface OptionsInFlags<Options extends DataFieldOptions.Any> {
+  /** @internal */
+  interface OptionsInFlags<Options extends DataField.Options.Any> {
     readonly flags?: DataField<Options, any>;
   }
 
-  // These  types only exists to simplify solving the `Document` type. Using `Document.Flags<this>` means the constraint `this extends Document.Any` has to be proved.
+  // These types only exists to simplify solving the `Document` type. Using `Document.Flags<this>` means the constraint `this extends Document.Any` has to be proved.
   // This is much more complex than proving the constraint for `Document.FlagsInternal<Schema>` that `Schema extends DataSchema`.
 
   // TODO: This needs to use the derived flags not just how they're initialized.
@@ -1279,29 +1317,29 @@ declare namespace Document {
   type ModificationOptions = Omit<Document.ModificationContext<Document.Any | null>, "parent" | "pack">;
 
   type PreCreateOptions<Name extends Type> = Omit<
-    DatabaseOperationsFor<Name, "create">,
+    Document.Database.OperationOf<Name, "create">,
     "data" | "noHook" | "pack" | "parent"
   >;
   type OnCreateOptions<Name extends Type> = Omit<
-    DatabaseOperationsFor<Name, "create">,
+    Document.Database.OperationOf<Name, "create">,
     "pack" | "parentUuid" | "syntheticActorUpdate"
   >;
 
   type PreUpdateOptions<Name extends Type> = Omit<
-    DatabaseOperationsFor<Name, "update">,
+    Document.Database.OperationOf<Name, "update">,
     "updates" | "restoreDelta" | "noHook" | "parent" | "pack"
   >;
   type OnUpdateOptions<Name extends Type> = Omit<
-    DatabaseOperationsFor<Name, "update">,
+    Document.Database.OperationOf<Name, "update">,
     "pack" | "parentUuid" | "syntheticActorUpdate"
   >;
 
   type PreDeleteOptions<Name extends Type> = Omit<
-    DatabaseOperationsFor<Name, "delete">,
+    Document.Database.OperationOf<Name, "delete">,
     "ids" | "deleteAll" | "noHook" | "pack" | "parent"
   >;
   type OnDeleteOptions<Name extends Type> = Omit<
-    DatabaseOperationsFor<Name, "delete">,
+    Document.Database.OperationOf<Name, "delete">,
     "deleteAll" | "pack" | "parentUuid" | "syntheticActorUpdate"
   >;
 
@@ -1317,17 +1355,9 @@ declare namespace Document {
     readonly coreTypes: readonly string[];
     readonly embedded: Record<string, string>;
     readonly permissions: {
-      create:
-        | string
-        | ToMethod<
-            (user: foundry.documents.BaseUser, doc: ThisType, data: Document.ConstructorDataForName<Type>) => boolean
-          >;
-      update:
-        | string
-        | ToMethod<
-            (user: foundry.documents.BaseUser, doc: ThisType, data: Document.UpdateDataForName<Type>) => boolean
-          >;
-      delete: string | ToMethod<(user: foundry.documents.BaseUser, doc: ThisType, data: EmptyObject) => boolean>;
+      create: string | ToMethod<(user: User, 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>;
     };
     readonly preserveOnImport?: readonly string[] | undefined;
     readonly schemaVersion: string | undefined;
@@ -1355,23 +1385,85 @@ declare namespace Document {
       pack: null;
     }
   }
+
+  /**
+   * @deprecated {@link Document.Database.OperationOf | `Document.Database.OperationOf`}
+   */
+  type DatabaseOperationsFor<
+    Name extends Document.Type,
+    ConcreteOperation extends Document.Database.Operation,
+  > = Document.Database.OperationOf<Name, ConcreteOperation>;
+
+  type ConfiguredSheetClassFor<Name extends Document.Type> = MakeConform<
+    GetKey<GetKey<CONFIG, Name>, "sheetClass">,
+    AnyConstructor
+  >;
+
+  type ConfiguredObjectClassFor<Name extends Document.Type> = GetKey<GetKey<CONFIG, Name>, "objectClass">;
+
+  type ConfiguredLayerClassFor<Name extends Document.Type> = GetKey<GetKey<CONFIG, Name>, "layerClass">;
+
+  type DropData<T extends Document.Any> = T extends { id: string | undefined }
+    ? DropData.Data<T> & DropData.UUID
+    : DropData.Data<T>;
+
+  namespace DropData {
+    type Any = DropData<any>;
+
+    interface Data<T extends Document.Any> {
+      type: T["documentName"];
+      data: T["_source"];
+    }
+
+    interface UUID {
+      uuid: string;
+    }
+  }
+
+  namespace Database {
+    type Operation = "create" | "update" | "delete";
+
+    /* 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];
+  }
 }
 
-export type Operation = "create" | "update" | "delete";
+/** @deprecated {@link Document.Database.Operation | `Document.Database.Operation`} */
+export type Operation = Document.Database.Operation;
 
 /* eslint-disable @typescript-eslint/no-empty-object-type */
-export interface DocumentDatabaseOperations<
+/** @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 = {},
-> {
-  create: DatabaseCreateOperation<T> & InexactPartial<ExtraCreateOptions>;
-  update: DatabaseUpdateOperation<T> & InexactPartial<ExtraUpdateOptions>;
-  delete: DatabaseDeleteOperation & InexactPartial<ExtraDeleteOptions>;
-}
+> = Document.Database.Operations<T, ExtraCreateOptions, ExtraUpdateOptions, ExtraDeleteOptions>;
 /* eslint-enable @typescript-eslint/no-empty-object-type */
 
+/**
+ * @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;
@@ -1395,9 +1487,8 @@ export interface DatabaseOperationMap {
   Note: NoteDocument.DatabaseOperations;
   Playlist: Playlist.DatabaseOperations;
   PlaylistSound: PlaylistSound.DatabaseOperations;
-  // TODO: Add these once documents are done
-  // Region: ActiveEffect.DatabaseOperations;
-  // RegionBehavior: ActiveEffect.DatabaseOperations;
+  Region: ActiveEffect.DatabaseOperations;
+  RegionBehavior: ActiveEffect.DatabaseOperations;
   RollTable: RollTable.DatabaseOperations;
   Scene: Scene.DatabaseOperations;
   Setting: Setting.DatabaseOperations;