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

package/src/foundry/client/core/hooks.d.mts

@@ -1,4 +1,4 @@
-import type { AnyFunction } from "../../../types/utils.d.mts";
+import type { AnyFunction } from "fvtt-types/utils";
 
 export {};
 
@@ -28,7 +28,7 @@ declare global {
       options?: Hooks.OnOptions,
     ): number;
     static on<H extends Hooks.DynamicCallbacks>(hook: string, fn: H, options?: Hooks.OnOptions): number;
-    static on<H extends (...args: any) => any>(hook: string, fn: H, options?: Hooks.OnOptions): number;
+    static on<H extends AnyFunction>(hook: string, fn: H, options?: Hooks.OnOptions): number;
 
     /**
      * Register a callback handler for an event which is only triggered once the first time the event occurs.

package/src/foundry/client/core/image.d.mts

@@ -1,10 +1,9 @@
-import type { InexactPartial, NullishProps } from "../../../types/utils.d.mts";
+import type { InexactPartial, NullishProps } from "fvtt-types/utils";
 
 declare global {
   /**
    * A helper class to provide common functionality for working with Image objects
    */
-  // eslint-disable-next-line @typescript-eslint/no-extraneous-class
   class ImageHelper {
     /**
      * Create thumbnail preview for a provided image path.

package/src/foundry/client/core/keybindings.d.mts

@@ -1,4 +1,4 @@
-import type { ValueOf } from "../../../types/utils.d.mts";
+import type { LazyUnknown, ValueOf } from "fvtt-types/utils";
 
 declare global {
   /**
@@ -287,7 +287,7 @@ declare global {
      * @internal
      */
     protected static _onZoom(
-      context: KeyboardManager.KeyboardEventContext | unknown,
+      context: KeyboardManager.KeyboardEventContext | LazyUnknown,
       zoomDirection: ClientKeybindings.ZoomDirection,
     ): boolean;
 

package/src/foundry/client/core/packages.d.mts

@@ -1,4 +1,4 @@
-import type { InexactPartial, Mixin } from "../../../types/utils.d.mts";
+import type { FixedInstanceType, InexactPartial, Mixin } from "fvtt-types/utils";
 import type { CONST } from "../../client-esm/client.d.mts";
 import type BasePackage from "../../common/packages/base-package.d.mts";
 
@@ -136,10 +136,17 @@ declare global {
    * @param BasePackage - The parent BasePackage class being mixed
    * @returns A BasePackage subclass mixed with ClientPackage features
    */
-  function ClientPackageMixin<BaseClass extends BasePackage.Internal.Constructor>(
+  function ClientPackageMixin<BaseClass extends ClientPackageMixin.BaseClass>(
     BasePackage: BaseClass,
   ): Mixin<typeof ClientPackage, BaseClass>;
 
+  namespace ClientPackageMixin {
+    type AnyMixedConstructor = ReturnType<typeof ClientPackageMixin<BaseClass>>;
+    interface AnyMixed extends FixedInstanceType<AnyMixedConstructor> {}
+
+    type BaseClass = BasePackage.Internal.Constructor;
+  }
+
   class Module extends ClientPackageMixin(foundry.packages.BaseModule) {
     constructor(data: ClientPackage.ModuleConstructorData, options: unknown);
 

package/src/foundry/client/core/settings.d.mts

@@ -1,5 +1,4 @@
-import type { ConformRecord } from "../../../types/helperTypes.d.mts";
-import type { AnyArray, AnyObject, DeepPartial, InexactPartial } from "../../../types/utils.d.mts";
+import type { AnyArray, AnyObject, InexactPartial, FixedInstanceType } from "fvtt-types/utils";
 import type ApplicationV2 from "../../client-esm/applications/api/application.d.mts";
 import type { CustomFormInput } from "../../client-esm/applications/forms/fields.d.mts";
 import type DataModel from "../../common/abstract/data.d.mts";
@@ -24,7 +23,7 @@ declare global {
     /**
      * A object of registered game settings for this scope
      */
-    settings: Map<keyof _SettingConfigRecord & string, ClientSettings.SettingConfig>;
+    settings: Map<keyof globalThis.SettingConfig & (string & {}), ClientSettings.SettingConfig>;
 
     /**
      * Registered settings menus which trigger secondary applications
@@ -87,11 +86,15 @@ declare global {
      * });
      * ```
      */
-    register<N extends ClientSettings.Namespace, K extends ClientSettings.Key, T extends ClientSettings.Type>(
+    register<
+      T extends ClientSettings.Type,
+      N extends ClientSettings.Namespace = ClientSettings.Namespace,
+      K extends ClientSettings.KeyFor<N> = ClientSettings.KeyFor<N>,
+    >(
       namespace: N,
       key: K,
       data: ClientSettings.Type extends T
-        ? ClientSettings.RegisterOptions<_SettingConfigRecord[`${N}.${K}`]>
+        ? ClientSettings.RegisterOptions<globalThis.SettingConfig[`${N}.${K}` & keyof SettingConfig]>
         : ClientSettings.RegisterOptions<NoInfer<T>>,
     ): void;
 
@@ -131,7 +134,7 @@ declare global {
      * game.settings.get("myModule", "myClientSetting");
      * ```
      */
-    get<N extends ClientSettings.Namespace, K extends ClientSettings.Key>(
+    get<N extends ClientSettings.Namespace, K extends ClientSettings.KeyFor<N>>(
       namespace: N,
       key: K,
     ): ClientSettings.SettingInitializedType<N, K>;
@@ -154,7 +157,7 @@ declare global {
      * game.settings.set("myModule", "myClientSetting", "b");
      * ```
      */
-    set<N extends ClientSettings.Namespace, K extends ClientSettings.Key>(
+    set<N extends ClientSettings.Namespace, K extends ClientSettings.KeyFor<N>>(
       namespace: N,
       key: K,
       value: ClientSettings.SettingAssignmentType<N, K>,
@@ -163,8 +166,8 @@ declare global {
   }
 
   namespace ClientSettings {
-    type Namespace = GetNamespaces<keyof _SettingConfigRecord>;
-    type Key = GetKeys<keyof _SettingConfigRecord>;
+    type Namespace = GetNamespaces<keyof globalThis.SettingConfig>;
+    type KeyFor<N extends Namespace> = GetKeys<N, keyof globalThis.SettingConfig>;
 
     /**
      * A compile type is a type for a setting that only exists at compile time.
@@ -187,14 +190,21 @@ declare global {
       | (T extends readonly (infer V)[] ? typeof Array<V> : never)
       | (T extends AnyObject ? typeof Object : never);
 
-    type SettingAssignmentType<N extends Namespace, K extends Key> = ToSettingAssignmentType<ConfiguredType<N, K>>;
+    type SettingAssignmentType<N extends Namespace, K extends KeyFor<N>> = ToSettingAssignmentType<
+      ConfiguredType<N, K>
+    >;
     type ToSettingAssignmentType<T extends Type> = ReplaceUndefinedWithNull<
       | SettingType<T>
       // TODO(LukeAbby): The `fromSource` function is called with `strict` which changes how fallback behaviour works. See `ClientSettings#set`
-      | (T extends DataModel.AnyConstructor ? DataModel.ConstructorDataFor<InstanceType<T>> : never)
+      // Note(LukeAbby): This doesn't use `InstanceType` because of this TypeScript issue: https://github.com/microsoft/TypeScript/issues/60839
+      | (T extends (abstract new (...args: infer _1) => infer Instance extends DataModel.Any)
+          ? DataModel.ConstructorDataFor<Instance>
+          : never)
     >;
 
-    type SettingInitializedType<N extends Namespace, K extends Key> = ToSettingInitializedType<ConfiguredType<N, K>>;
+    type SettingInitializedType<N extends Namespace, K extends KeyFor<N>> = ToSettingInitializedType<
+      ConfiguredType<N, K>
+    >;
     type ToSettingInitializedType<T extends Type> = ReplaceUndefinedWithNull<
       SettingType<T> | (T extends DataModel.Any ? T : never)
     >;
@@ -290,20 +300,14 @@ declare global {
       icon?: string | undefined;
 
       /** The FormApplication or ApplicationV2 to render */
-      type:
-        | (new () => FormApplication.Any)
-        | (new (options?: DeepPartial<ApplicationV2.Configuration>) => ApplicationV2.Any);
+      // In SettingsConfig#_onClickSubmenu this type is constructed and not given any options.
+      type: (new () => FormApplication.Any) | (new () => ApplicationV2.Any);
 
       /** If true, only a GM can edit this Setting */
       restricted?: boolean | undefined;
     }
 
     type RegisterSubmenu = Omit<SettingSubmenuConfig, "key" | "namespace">;
-
-    /**
-     * @deprecated - {@link globalThis.SettingConfig | `SettingConfig`}
-     */
-    interface Values extends globalThis.SettingConfig {}
   }
 }
 
@@ -325,7 +329,7 @@ type PRIMITIVE_TYPES = readonly [
 // Foundry prioritizes the constructor over the function unless it's in `Setting#PRIMITIVE_TYPES`.
 type ConstructorToSettingType<T extends SettingConstructor> = T extends PRIMITIVE_TYPES[number]
   ? PrimitiveConstructorToSettingType<T>
-  : InstanceType<T>;
+  : FixedInstanceType<T>;
 
 // In theory this is just the `ReturnType<T>`.
 // However the function end of `Array` returns `any[]` while `Object` returns `any`.
@@ -336,15 +340,18 @@ type PrimitiveConstructorToSettingType<T extends PRIMITIVE_TYPES[number]> = T ex
     ? AnyObject
     : ReturnType<T>;
 
+// The `& keyof SettingConfig` is necessary because otherwise the fact that `K` depends on `N`
+// will confuse TypeScript and make it think that `${N}.${K}` can be invalid keys like
+// "core.moduleSetting" but in reality that would be disallowed by the dependent constraint of `K`.
 type ConfiguredType<
   N extends ClientSettings.Namespace,
-  K extends ClientSettings.Key,
-> = _SettingConfigRecord[`${N}.${K}`];
+  K extends ClientSettings.KeyFor<N>,
+> = globalThis.SettingConfig[`${N}.${K}` & keyof SettingConfig];
 
 type SettingType<T extends ClientSettings.Type> =
   // Note(LukeAbby): This isn't written as `T extends ClientSettings.TypeScriptType ? T : never` because then types like `DataField.Any` would be matched.
   | (T extends ClientSettings.RuntimeType ? never : T)
-  // TODO(LukeAbby): The `validate` function is called with `strict` which changes how fallback behaviour works. See `ClientSettings#set`
+  // TODO(LukeAbby): The `validate` function is called with `strict` which changes how fallback behavior works. See `ClientSettings#set`
   | (T extends DataField.Any ? DataField.AssignmentTypeFor<T> : never)
   | (T extends SettingConstructor ? ConstructorToSettingType<T> : T extends SettingFunction ? ReturnType<T> : never);
 
@@ -352,10 +359,6 @@ type SettingType<T extends ClientSettings.Type> =
 type ReplaceUndefinedWithNull<T> = T extends undefined ? null : T;
 
 type GetNamespaces<SettingPath extends PropertyKey> = SettingPath extends `${infer Scope}.${string}` ? Scope : never;
-type GetKeys<SettingPath extends PropertyKey> = SettingPath extends `${string}.${infer Name}` ? Name : never;
-
-type _SettingConfigRecord = ConformRecord<
-  // Refers to the deprecated interface so that merging works both ways.
-  ClientSettings.Values,
-  ClientSettings.Type
->;
+type GetKeys<N extends string, SettingPath extends PropertyKey> = SettingPath extends `${N}.${infer Name}`
+  ? Name
+  : never;

package/src/foundry/client/core/socket.d.mts

@@ -1,4 +1,4 @@
-import type { AnyObject } from "../../../types/utils.d.mts";
+import type { AnyObject } from "fvtt-types/utils";
 import type { DatabaseOperationMap, DocumentSocketRequest } from "../../common/abstract/_types.d.mts";
 
 declare global {

package/src/foundry/client/core/sorting.d.mts

@@ -1,4 +1,4 @@
-import type { InexactPartial } from "../../../types/utils.d.mts";
+import type { InexactPartial } from "fvtt-types/utils";
 
 declare global {
   /**

package/src/foundry/client/core/tooltip.d.mts

@@ -1,4 +1,4 @@
-import type { ValueOf } from "../../../types/utils.d.mts";
+import type { ValueOf } from "fvtt-types/utils";
 
 declare global {
   /**

package/src/foundry/client/core/tour.d.mts

@@ -1,4 +1,4 @@
-import type { ValueOf } from "../../../types/utils.d.mts";
+import type { ValueOf } from "fvtt-types/utils";
 
 export { Tour };
 

package/src/foundry/client/core/utils.d.mts

@@ -1,4 +1,29 @@
-import type { GetKey } from "../../../types/helperTypes.d.mts";
+import type { AnyObject, MustBeValidUuid } from "fvtt-types/utils";
+import type Document from "../../common/abstract/document.d.mts";
+
+declare const __Unset: unique symbol;
+
+type __UnsetDocument = Document.Any & {
+  [__Unset]: true;
+};
+
+declare class InvalidUuid extends foundry.abstract.Document<any, any, any> {}
+
+type FromUuid<Uuid extends string> = Uuid extends `${string}.${string}.${infer Rest}`
+  ? FromUuid<Rest>
+  : Uuid extends `${infer DocumentType extends Document.Type}.${string}`
+    ? Document.ConfiguredInstanceForName<DocumentType>
+    : InvalidUuid;
+
+// TODO(LukeAbby): The usage of `Document.Type` when it's unset will not be necessary once `Document.Any` is more type safe.
+type FromUuidValidate<
+  ConcreteDocument extends Document.Any,
+  Uuid extends string,
+> = __UnsetDocument extends ConcreteDocument
+  ? MustBeValidUuid<Uuid, Document.Type>
+  : string extends Uuid
+    ? string
+    : MustBeValidUuid<Uuid, ConcreteDocument["documentName"]>;
 
 declare global {
   /**
@@ -21,15 +46,15 @@ declare global {
    * @param uuid    - The uuid of the Entity or Embedded Entity to retrieve
    * @param options - Options to configure how a UUID is resolved.
    */
-  function fromUuid(
-    uuid: string,
+  function fromUuid<ConcreteDocument extends Document.Any = __UnsetDocument, const Uuid extends string = string>(
+    uuid: FromUuidValidate<ConcreteDocument, Uuid> | null | undefined,
     options?: {
       /** A Document to resolve relative UUIDs against. */
       relative?: ClientDocument;
       /** Allow retrieving an invalid Document. (default: `false`) */
       invalid?: boolean;
     },
-  ): Promise<foundry.abstract.Document.Any | null>;
+  ): Promise<(__UnsetDocument extends ConcreteDocument ? FromUuid<Uuid> : ConcreteDocument) | null>;
 
   /**
    * Retrieve a Document by its Universally Unique Identifier (uuid) synchronously. If the uuid resolves to a compendium
@@ -39,8 +64,8 @@ declare global {
    * @returns The Document or its index entry if it resides in a Compendium, otherwise null.
    * @throws If the uuid resolves to a Document that cannot be retrieved synchronously.
    */
-  function fromUuidSync(
-    uuid: string,
+  function fromUuidSync<ConcreteDocument extends Document.Any = __UnsetDocument, const Uuid extends string = string>(
+    uuid: FromUuidValidate<ConcreteDocument, Uuid> | null | undefined,
     options?: {
       /** A Document to resolve relative UUIDs against. */
       relative?: ClientDocument;
@@ -49,7 +74,7 @@ declare global {
       /** Throw an error if the UUID cannot be resolved synchronously. (default: `true`) */
       strict?: boolean;
     },
-  ): foundry.abstract.Document.Any | Record<string, unknown> | null;
+  ): (__UnsetDocument extends ConcreteDocument ? FromUuid<Uuid> : ConcreteDocument) | AnyObject | null;
 
   /**
    * Resolve a series of embedded document UUID parts against a parent Document.
@@ -65,7 +90,5 @@ declare global {
    * @param documentName - The canonical Document name, for example "Actor"
    * @returns configured Document class implementation
    */
-  function getDocumentClass<DocumentName extends string>(
-    documentName: DocumentName,
-  ): GetKey<GetKey<CONFIG, DocumentName, never>, "documentClass", undefined>;
+  function getDocumentClass<Name extends Document.Type>(documentName: Name): Document.ConfiguredClassForName<Name>;
 }

package/src/foundry/client/core/video.d.mts

@@ -1,4 +1,4 @@
-export {};
+import "youtube";
 
 declare global {
   /**

package/src/foundry/client/core/workers.d.mts

@@ -1,4 +1,4 @@
-import type { ValueOf } from "../../../types/utils.d.mts";
+import type { ValueOf } from "fvtt-types/utils";
 
 // TODO: smarter types for named functions
 declare global {

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

@@ -1,24 +1,28 @@
-import type { Mixin } from "../../../../types/utils.d.mts";
+import type { FixedInstanceType, Mixin } from "fvtt-types/utils";
 import type Document from "../../../common/abstract/document.d.mts";
-import type { ClientDocument } from "./client-document.d.mts";
+import type { InternalClientDocument } from "./client-document.d.mts";
 
 declare class CanvasDocument<
-  BaseDocument extends Document<any, any, Scene.ConfiguredInstance | null>,
-> extends ClientDocument<BaseDocument> {
+  BaseDocument extends Document.Internal.Instance.Any,
+  PlaceableType extends Document.PlaceableType = Extract<
+    Document.Internal.DocumentNameFor<BaseDocument>,
+    Document.PlaceableType
+  >,
+> extends InternalClientDocument<BaseDocument> {
   /** @privateRemarks All mixin classses should accept anything for its constructor. */
   constructor(...args: any[]);
 
   /**
    * A lazily constructed PlaceableObject instance which can represent this Document on the game canvas.
    */
-  get object(): Document.ConfiguredObjectInstanceForName<BaseDocument["documentName"]> | null;
+  get object(): Document.ConfiguredObjectInstanceForName<PlaceableType> | null;
 
   /**
    * A reference to the PlaceableObject instance which represents this Embedded Document.
    * @internal
    * @defaultValue `null`
    */
-  protected _object: Document.ConfiguredObjectInstanceForName<BaseDocument["documentName"]> | null;
+  protected _object: Document.ConfiguredObjectInstanceForName<PlaceableType> | null;
 
   /**
    * Has this object been deliberately destroyed as part of the deletion workflow?
@@ -30,7 +34,7 @@ declare class CanvasDocument<
   /**
    * A reference to the CanvasLayer which contains Document objects of this type.
    */
-  get layer(): InstanceType<PlaceablesLayer.ConfiguredClassForName<BaseDocument["documentName"]>>;
+  get layer(): FixedInstanceType<PlaceablesLayer.ConfiguredClassForName<PlaceableType>>;
 
   /**
    * An indicator for whether this document is currently rendered on the game canvas.
@@ -48,22 +52,29 @@ declare namespace CanvasDocument {
 }
 
 declare global {
-  /**
-   * @deprecated {@link CanvasDocument.Any | `CanvasDocument.Any`}
-   */
-  type CanvasDocument = ReturnType<typeof CanvasDocumentMixin>;
-
   /**
    * A specialized sub-class of the ClientDocumentMixin which is used for document types that are intended to be represented upon the game Canvas.
    */
+  // TODO(LukeAbby): The constraint here should ideally be something like `Document<Document.PlaceableType, any, Scene.ConfiguredInstance | null>` but this causes circularities.
   function CanvasDocumentMixin<BaseClass extends Document.Internal.Constructor>(
     Base: BaseClass,
-  ): typeof AnyDocument & Mixin<typeof CanvasDocument<InstanceType<BaseClass>>, BaseClass>;
+  ): typeof AnyDocument & Mixin<typeof CanvasDocument<FixedInstanceType<BaseClass>>, BaseClass>;
 }
 
 // This is yet another `AnyDocument` type.
 // It exists specifically because the `Document.AnyConstructor` type is too safe to be merged in with a mixin.
 // The `arg0: never, ...args: never[]` trick trips up the base constructor check and so this one with an actual `...args: any[]` one is used instead.
-declare class AnyDocument extends Document<any, any, any> {
+//
+// `{}` is used to avoid merging `DataSchema` with the real schema.
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+declare class AnyDocument extends Document<any, {}, Document.Any | null> {
   constructor(...args: any[]);
+
+  // 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;
 }

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

@@ -1,8 +1,9 @@
-import type { ConstructorOf, DeepPartial, InexactPartial, Mixin, ValueOf } from "../../../../types/utils.d.mts";
+import type { DeepPartial, InexactPartial, Mixin, FixedInstanceType } from "fvtt-types/utils";
 import type { DatabaseCreateOperation } from "../../../common/abstract/_types.d.mts";
+import type DataModel from "../../../common/abstract/data.d.mts";
 import type Document from "../../../common/abstract/document.d.mts";
 
-declare class ClientDocument<BaseDocument extends Document.Internal.Instance.Any = Document.Any> {
+declare class InternalClientDocument<BaseDocument extends Document.Internal.Instance.Any = Document.Any> {
   /** @privateRemarks All mixin classses should accept anything for its constructor. */
   constructor(...args: any[]);
 
@@ -13,13 +14,15 @@ declare class ClientDocument<BaseDocument extends Document.Internal.Instance.Any
    * @see {@link Document#render}
    * @defaultValue `{}`
    */
-  readonly apps: Record<string, Application | foundry.applications.api.ApplicationV2>;
+  readonly apps: Record<string, Application.Any | foundry.applications.api.ApplicationV2.Any>;
 
   /**
    * A cached reference to the FormApplication instance used to configure this Document.
    * @defaultValue `null`
    */
-  protected readonly _sheet: FormApplication | null; // TODO: Replace with InstanceType<ConfiguredSheetClass<T>> once the circular reference problem has been solved
+  protected readonly _sheet: FixedInstanceType<
+    Document.ConfiguredSheetClassFor<Document.Internal.DocumentNameFor<BaseDocument>>
+  > | null;
 
   static name: "ClientDocumentMixin";
 
@@ -72,12 +75,12 @@ declare class ClientDocument<BaseDocument extends Document.Internal.Instance.Any
    * actor.permission; // 2
    * ```
    */
-  get permission(): ValueOf<typeof CONST.DOCUMENT_OWNERSHIP_LEVELS>;
+  get permission(): CONST.DOCUMENT_OWNERSHIP_LEVELS;
 
   /**
    * Lazily obtain a FormApplication instance used to configure this Document, or null if no sheet is available.
    */
-  get sheet(): FormApplication | foundry.applications.api.ApplicationV2 | null;
+  get sheet(): FormApplication.Any | foundry.applications.api.ApplicationV2.Any | null;
 
   /**
    * A boolean indicator for whether or not the current game User has at least limited visibility for this Document.
@@ -88,7 +91,10 @@ declare class ClientDocument<BaseDocument extends Document.Internal.Instance.Any
   /**
    * Obtain the FormApplication class constructor which should be used to configure this Document.
    */
-  protected _getSheetClass(): ConstructorOf<FormApplication | foundry.applications.api.ApplicationV2> | null;
+  protected _getSheetClass():
+    | FormApplication.AnyConstructor
+    | foundry.applications.api.ApplicationV2.AnyConstructor
+    | null;
 
   /**
    * Safely prepare data for a Document, catching any errors.
@@ -290,7 +296,7 @@ declare class ClientDocument<BaseDocument extends Document.Internal.Instance.Any
     parent: ClientDocument,
     collection: string,
     documents: ClientDocument[],
-    ids: string,
+    ids: string[],
     options: Document.OnDeleteOptions<any> & InexactPartial<{ render: boolean }>,
     userId: string,
   ): void;
@@ -337,9 +343,9 @@ declare class ClientDocument<BaseDocument extends Document.Internal.Instance.Any
   static createDialog<T extends Document.AnyConstructor>(
     this: T,
     data?: DeepPartial<Document.ConstructorDataFor<NoInfer<T>> & Record<string, unknown>>,
-    context?: Pick<DatabaseCreateOperation<InstanceType<NoInfer<T>>>, "parent" | "pack"> &
+    context?: Pick<DatabaseCreateOperation<FixedInstanceType<NoInfer<T>>>, "parent" | "pack"> &
       InexactPartial<
-        DialogOptions & {
+        Dialog.Options & {
           /** A restriction the selectable sub-types of the Dialog. */
           types: string[];
         }
@@ -352,7 +358,7 @@ declare class ClientDocument<BaseDocument extends Document.Internal.Instance.Any
    *                  (default: `{}`)
    * @returns A Promise which resolves to the deleted Document
    */
-  deleteDialog(options?: Partial<DialogOptions>): Promise<this | false | null | undefined>;
+  deleteDialog(options?: Partial<Dialog.Options>): Promise<this | false | null | undefined>;
 
   /**
    * Export document data to a JSON file which can be saved by the client and later imported into a different session.
@@ -363,7 +369,7 @@ declare class ClientDocument<BaseDocument extends Document.Internal.Instance.Any
   /**
    * Serialize salient information about this Document when dragging it.
    */
-  toDragData(): DropData<BaseDocument>;
+  toDragData(): Document.DropData<Document.Internal.Instance.Complete<BaseDocument>>;
 
   /**
    * A helper function to handle obtaining the relevant Document from dropped data provided via a DataTransfer event.
@@ -378,7 +384,7 @@ declare class ClientDocument<BaseDocument extends Document.Internal.Instance.Any
    */
   static fromDropData<T extends Document.AnyConstructor>(
     this: T,
-    data: DropData<InstanceType<NoInfer<T>>>,
+    data: Document.DropData<FixedInstanceType<NoInfer<T>>>,
     options?: FromDropDataOptions,
   ): Promise<Document.ToConfiguredInstance<T> | undefined>;
 
@@ -402,8 +408,8 @@ declare class ClientDocument<BaseDocument extends Document.Internal.Instance.Any
   static fromImport<T extends Document.AnyConstructor>(
     this: T,
     source: Record<string, unknown>,
-    context?: Document.ConstructionContext<Document.Any | null> & DataValidationOptions,
-  ): Promise<InstanceType<T>>;
+    context?: Document.ConstructionContext<Document.Any | null> & DataModel.DataValidationOptions,
+  ): Promise<FixedInstanceType<T>>;
   /**
    * Update this Document using a provided JSON string.
    * @param json - JSON data string
@@ -596,10 +602,21 @@ declare class ClientDocument<BaseDocument extends Document.Internal.Instance.Any
   ): void;
 }
 
-declare const _ClientDocument: ClientDocument;
+type _ClientDocumentType = InternalClientDocument & Document.AnyConstructor;
+declare const _ClientDocument: _ClientDocumentType;
+
+type ClientDocumentMixinBaseClass = Document.Internal.Constructor;
 
 declare global {
-  type ClientDocument = typeof _ClientDocument;
+  /**
+   * This class does not really exist at runtime. It's here for types only.
+   */
+  class ClientDocument extends _ClientDocument {
+    // This may have be removed at some point in the future if it causes issues but the idea is to
+    // prevent operations like `new ClientDocument()` or `extends ClientDocument` because this does
+    // is not a class that really exists at runtime.
+    private constructor(...args: any[]);
+  }
 
   /**
    * A mixin which extends each Document definition with specialized client-side behaviors.
@@ -612,7 +629,7 @@ declare global {
   // Note(LukeAbby): The seemingly redundant merging in of `typeof AnyDocument` makes it easier for tsc to recognize that anything extending `ClientDocumentMixin` is also a document.
   function ClientDocumentMixin<BaseClass extends Document.Internal.Constructor>(
     Base: BaseClass,
-  ): typeof AnyDocument & Mixin<typeof ClientDocument<InstanceType<BaseClass>>, BaseClass>;
+  ): typeof AnyDocument & Mixin<typeof InternalClientDocument<FixedInstanceType<BaseClass>>, BaseClass>;
 
   namespace ClientDocument {
     interface SortOptions<T, SortKey extends string = "sort"> extends SortingHelpers.SortOptions<T, SortKey> {
@@ -682,31 +699,23 @@ declare global {
   }
 }
 
-export type DropData<T extends Document.Internal.Instance.Any> = T extends { id: string | undefined }
-  ? InternalData<T> & DropData.UUID
-  : InternalData<T>;
-
-declare namespace DropData {
-  type Any = DropData<any>;
-
-  interface Data<T extends Document.Any> {
-    type: T["documentName"];
-    data: T["_source"];
-  }
-
-  interface UUID {
-    uuid: string;
-  }
-}
-
 // This is yet another `AnyDocument` type.
 // It exists specifically because the `Document.AnyConstructor` type is too safe to be merged in with a mixin.
 // The `arg0: never, ...args: never[]` trick trips up the base constructor check and so this one with an actual `...args: any[]` one is used instead.
-declare class AnyDocument extends Document<any, any, any> {
+//
+// `{}` is used to avoid merging `DataSchema` with the real schema.
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+declare class AnyDocument extends Document<any, {}, any> {
   constructor(...args: any[]);
-}
 
-type InternalData<T extends Document.Internal.Instance.Any> = DropData.Data<Document.Internal.Instance.Complete<T>>;
+  // 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;
+}
 
 interface FromDropDataOptions {
   /**