Repository: League-of-Foundry-Developers/foundry-vtt-types
Pull request #3226 (2025-03-10 07:17:54)

Update Canvas Document Schemas and associated changes
Updated the formdata types for the Config apps, deleted a couple apps that got v2'd  in v12 already, made TextureData work with help from luke


Patch:
diff --git a/src/configuration/globals.d.mts b/src/configuration/globals.d.mts
index 228215c7e..43d354461 100644
--- a/src/configuration/globals.d.mts
+++ b/src/configuration/globals.d.mts
@@ -39,10 +39,8 @@ export import AlertPing = globalThis.AlertPing;
 export import AlphaBlurFilter = globalThis.AlphaBlurFilter;
 export import AlphaBlurFilterPass = globalThis.AlphaBlurFilterPass;
 export import AmbientLight = globalThis.AmbientLight;
-export import AmbientLightConfig = globalThis.AmbientLightConfig;
 export import AmbientLightDocument = globalThis.AmbientLightDocument;
 export import AmbientSound = globalThis.AmbientSound;
-export import AmbientSoundConfig = globalThis.AmbientSoundConfig;
 export import AmbientSoundDocument = globalThis.AmbientSoundDocument;
 export import AmplificationBackgroundVisionShader = globalThis.AmplificationBackgroundVisionShader;
 export import AmplificationSamplerShader = globalThis.AmplificationSamplerShader;
diff --git a/src/foundry/client/apps/app.d.mts b/src/foundry/client/apps/app.d.mts
index d084622f2..d4dbc5a1f 100644
--- a/src/foundry/client/apps/app.d.mts
+++ b/src/foundry/client/apps/app.d.mts
@@ -604,6 +604,6 @@ declare global {
   }
 }
 
-declare abstract class AnyApplication extends Application<any> {
+declare abstract class AnyApplication extends Application<ApplicationOptions> {
   constructor(arg0: never, ...args: never[]);
 }
diff --git a/src/foundry/client/apps/placeables/drawing-config.d.mts b/src/foundry/client/apps/placeables/drawing-config.d.mts
index 6f83d2afd..e770e2b4d 100644
--- a/src/foundry/client/apps/placeables/drawing-config.d.mts
+++ b/src/foundry/client/apps/placeables/drawing-config.d.mts
@@ -57,27 +57,32 @@ declare global {
       configureDefault: boolean;
     }
 
-    interface FormData {
-      author: string;
-      bezierFactor: DrawingDocument["bezierFactor"];
-      fillAlpha: DrawingDocument["fillAlpha"];
-      fillColor: DrawingDocument["fillColor"];
-      fillType: DrawingDocument["fillType"];
-      fontFamily: DrawingDocument["fontFamily"];
-      fontSize: DrawingDocument["fontSize"];
+    /** @internal */
+    type _FormData = Pick<
+      DrawingDocument,
+      | "author"
+      | "bezierFactor"
+      | "elevation"
+      | "fillAlpha"
+      | "fillColor"
+      | "fillType"
+      | "fontFamily"
+      | "fontSize"
+      | "rotation"
+      | "sort"
+      | "strokeAlpha"
+      | "strokeColor"
+      | "strokeWidth"
+      | "text"
+      | "textAlpha"
+      | "textColor"
+      | "texture"
+      | "x"
+      | "y"
+    >;
+    interface FormData extends _FormData {
       "shape.height": DrawingDocument["shape"]["height"];
-      rotation: DrawingDocument["rotation"];
-      strokeAlpha: DrawingDocument["strokeAlpha"];
-      strokeColor: DrawingDocument["strokeColor"];
-      strokeWidth: DrawingDocument["strokeWidth"];
-      text: DrawingDocument["text"];
-      textAlpha: DrawingDocument["textAlpha"];
-      textColor: DrawingDocument["textColor"];
-      texture: DrawingDocument["texture"];
       "shape.width": DrawingDocument["shape"]["width"];
-      x: DrawingDocument["x"];
-      y: DrawingDocument["y"];
-      z: DrawingDocument["z"];
     }
   }
 }
diff --git a/src/foundry/client/apps/placeables/index.d.mts b/src/foundry/client/apps/placeables/index.d.mts
index 3498965b8..b7a480def 100644
--- a/src/foundry/client/apps/placeables/index.d.mts
+++ b/src/foundry/client/apps/placeables/index.d.mts
@@ -1,8 +1,6 @@
 import "./drawing-config.d.mts";
 import "./drawing-hud.d.mts";
-import "./light-config.d.mts";
 import "./note-config.d.mts";
-import "./sound-config.d.mts";
 import "./tile-config.d.mts";
 import "./tile-hud.d.mts";
 import "./token-config.d.mts";
diff --git a/src/foundry/client/apps/placeables/light-config.d.mts b/src/foundry/client/apps/placeables/light-config.d.mts
deleted file mode 100644
index 606b27847..000000000
--- a/src/foundry/client/apps/placeables/light-config.d.mts
+++ /dev/null
@@ -1,100 +0,0 @@
-import type { InterfaceToObject, AnyObject, DeepPartial, MaybePromise } from "fvtt-types/utils";
-
-declare global {
-  /**
-   * The Application responsible for configuring a single AmbientLight document within a parent Scene.
-   * @typeParam Options - the type of the options object
-   */
-  class AmbientLightConfig<
-    Options extends
-      DocumentSheet.Options<AmbientLightDocument.Implementation> = DocumentSheet.Options<AmbientLightDocument.Implementation>,
-  > extends DocumentSheet<Options, AmbientLightDocument.Implementation> {
-    /**
-     * Maintain a copy of the original to show a real-time preview of changes.
-     */
-    preview: AmbientLightDocument.Implementation;
-
-    /**
-     * @defaultValue
-     * ```typescript
-     * foundry.utils.mergeObject(super.defaultOptions, {
-     *   id: "ambient-light-config",
-     *   classes: ["sheet", "ambient-light-config"],
-     *   title: "LIGHT.ConfigTitle",
-     *   template: "templates/scene/ambient-light-config.html",
-     *   width: 480,
-     *   height: "auto",
-     *   tabs: [{navSelector: ".tabs", contentSelector: "form", initial: "basic"}]
-     * });
-     * ```
-     */
-    static override get defaultOptions(): DocumentSheet.Options<AmbientLightDocument.Implementation>;
-
-    protected override _render(force?: boolean, options?: Application.RenderOptions<Options>): Promise<void>;
-
-    override getData(options?: Partial<Options>): MaybePromise<object>;
-
-    override close(options?: Application.CloseOptions): Promise<void>;
-
-    override activateListeners(html: JQuery): void;
-
-    /**
-     * Preview the change caused by a change on the form by refreshing the display of the light source
-     */
-    protected _onChangeInput(event: JQuery.ChangeEvent): Promise<void>;
-
-    protected _onResetForm(event: PointerEvent): void;
-
-    /**
-     * Preview changes to the AmbientLight document as if they were true document updates.
-     * @param change - A change to preview
-     */
-    protected _previewChanges(change: DeepPartial<AmbientLightDocument["_source"]>): void;
-
-    /**
-     * Restore the true data for the AmbientLight document when the form is submitted or closed.
-     */
-    protected _resetPreview(): void;
-
-    protected override _onChangeTab(event: MouseEvent | null, tabs: Tabs, active: string): void;
-
-    protected override _getSubmitData(updateData?: AnyObject | null): InterfaceToObject<AmbientLightConfig.FormData>;
-
-    protected override _updateObject(event: Event, formData: AmbientLightConfig.FormData): Promise<unknown>;
-
-    /**
-     * Refresh the display of the AmbientLight object
-     * @internal
-     */
-    protected _refresh(): void;
-  }
-
-  namespace AmbientLightConfig {
-    interface Any extends AmbientLightConfig<any> {}
-
-    interface FormData {
-      x: AmbientLightDocument["x"];
-      y: AmbientLightDocument["y"];
-      rotation: AmbientLightDocument["rotation"];
-      walls: AmbientLightDocument["walls"];
-      vision: AmbientLightDocument["vision"];
-      "config.dim": AmbientLightDocument["config"]["dim"];
-      "config.bright": AmbientLightDocument["config"]["bright"];
-      "config.angle": AmbientLightDocument["config"]["angle"];
-      "config.color": AmbientLightDocument["config"]["color"];
-      "config.alpha": AmbientLightDocument["config"]["alpha"];
-      "config.darkness.min": AmbientLightDocument["config"]["darkness"]["min"];
-      "config.darkness.max": AmbientLightDocument["config"]["darkness"]["max"];
-      "config.animation.type": AmbientLightDocument["config"]["animation"]["type"];
-      "config.animation.speed": AmbientLightDocument["config"]["animation"]["speed"];
-      "config.animation.reverse": AmbientLightDocument["config"]["animation"]["reverse"];
-      "config.animation.intensity": AmbientLightDocument["config"]["animation"]["intensity"];
-      "config.coloration": AmbientLightDocument["config"]["coloration"];
-      "config.luminosity": AmbientLightDocument["config"]["luminosity"];
-      "config.attenuation": AmbientLightDocument["config"]["attenuation"];
-      "config.saturation": AmbientLightDocument["config"]["saturation"];
-      "config.contrast": AmbientLightDocument["config"]["contrast"];
-      "config.shadows": AmbientLightDocument["config"]["shadows"];
-    }
-  }
-}
diff --git a/src/foundry/client/apps/placeables/note-config.d.mts b/src/foundry/client/apps/placeables/note-config.d.mts
index 97ea78969..a8d36f435 100644
--- a/src/foundry/client/apps/placeables/note-config.d.mts
+++ b/src/foundry/client/apps/placeables/note-config.d.mts
@@ -47,19 +47,29 @@ declare global {
   namespace NoteConfig {
     interface Any extends NoteConfig<any> {}
 
-    interface FormData {
-      entryId: NoteDocument["entryId"];
-      fontFamily: NoteDocument["fontFamily"];
-      fontSize: NoteDocument["fontSize"];
+    /** @internal */
+    type _FormData = Pick<
+      NoteDocument,
+      | "elevation"
+      | "entryId"
+      | "fontFamily"
+      | "fontSize"
+      | "global"
+      | "iconSize"
+      | "pageId"
+      | "sort"
+      | "text"
+      | "textAnchor"
+      | "textColor"
+      | "x"
+      | "y"
+    >;
+
+    interface FormData extends _FormData {
       "icon.selected": NoteDocument["texture"]["src"];
-      "icon.custom": NoteDocument["texture"]["src"];
-      iconSize: NoteDocument["iconSize"];
-      iconTint: NoteDocument["texture"]["tint"];
-      text: NoteDocument["text"];
-      textAnchor: NoteDocument["textAnchor"];
-      textColor: NoteDocument["textColor"];
-      x: NoteDocument["x"];
-      y: NoteDocument["y"];
+
+      /** @remarks Only appears in the form data if `icon.selected` is set to "Custom" (`""` value) */
+      "icon.custom"?: NoteDocument["texture"]["src"];
     }
   }
 }
diff --git a/src/foundry/client/apps/placeables/sound-config.d.mts b/src/foundry/client/apps/placeables/sound-config.d.mts
deleted file mode 100644
index 5e3ceea9d..000000000
--- a/src/foundry/client/apps/placeables/sound-config.d.mts
+++ /dev/null
@@ -1,44 +0,0 @@
-import type { MaybePromise } from "fvtt-types/utils";
-
-declare global {
-  /**
-   * The Application responsible for configuring a single AmbientSound document within a parent Scene.
-   * @typeParam Options - the type of the options object
-   */
-  class AmbientSoundConfig<
-    Options extends
-      DocumentSheet.Options<AmbientSoundDocument.Implementation> = DocumentSheet.Options<AmbientSoundDocument.Implementation>,
-  > extends DocumentSheet<Options, AmbientSoundDocument.Implementation> {
-    /**
-     * @defaultValue
-     * ```typescript
-     * foundry.utils.mergeObject(super.defaultOptions, {
-     *   title: "SOUND.ConfigTitle",
-     *   template: "templates/scene/sound-config.html",
-     *   width: 480
-     * });
-     * ```
-     */
-    static get defaultOptions(): DocumentSheet.Options<AmbientSoundDocument.Implementation>;
-
-    override get title(): string;
-
-    override getData(options?: Partial<Options>): MaybePromise<object>; // TODO: Implement GetDataReturnType
-
-    protected override _updateObject(event: Event, formData: AmbientSoundConfig.FormData): Promise<unknown>;
-
-    override close(options?: Application.CloseOptions): Promise<void>;
-  }
-
-  namespace AmbientSoundConfig {
-    interface Any extends AmbientSoundConfig<any> {}
-
-    type FormData = Pick<
-      foundry.documents.BaseAmbientSound,
-      "easing" | "path" | "volume" | "x" | "y" | "radius" | "walls"
-    > & {
-      "darkness.min": AmbientSoundDocument["darkness"]["min"];
-      "darkness.max": AmbientSoundDocument["darkness"]["max"];
-    };
-  }
-}
diff --git a/src/foundry/client/apps/placeables/tile-config.d.mts b/src/foundry/client/apps/placeables/tile-config.d.mts
index 35c375324..d20ad6580 100644
--- a/src/foundry/client/apps/placeables/tile-config.d.mts
+++ b/src/foundry/client/apps/placeables/tile-config.d.mts
@@ -37,12 +37,22 @@ declare global {
   namespace TileConfig {
     interface Any extends TileConfig<any> {}
 
-    type FormData = Pick<TileDocument, "alpha" | "height" | "rotation" | "width" | "x" | "y" | "overhead" | "roof"> & {
-      "texture.src": string | null;
-      "texture.scaleX": number | null;
-      "texture.scaleY": number | null;
-      "texture.tint": string;
-    };
+    /** @internal */
+    type _FormData = Pick<TileDocument, "alpha" | "elevation" | "height" | "rotation" | "sort" | "width" | "x" | "y">;
+
+    interface FormData extends _FormData {
+      "occlusion.alpha": TileDocument["occlusion"]["alpha"];
+      "occlusion.mode": TileDocument["occlusion"]["mode"];
+      "restrictions.light": TileDocument["restrictions"]["light"];
+      "restrictions.weather": TileDocument["restrictions"]["weather"];
+      "texture.src": TileDocument["texture"]["src"];
+      "texture.scaleX": TileDocument["texture"]["scaleX"];
+      "texture.scaleY": TileDocument["texture"]["scaleY"];
+      "texture.tint": TileDocument["texture"]["tint"];
+      "video.autoplay": TileDocument["video"]["autoplay"];
+      "video.loop": TileDocument["video"]["loop"];
+      "video.volume": TileDocument["video"]["volume"];
+    }
 
     interface Options extends DocumentSheet.Options<TileDocument.Implementation> {
       /**
diff --git a/src/foundry/client/apps/placeables/token-config.d.mts b/src/foundry/client/apps/placeables/token-config.d.mts
index 9b769f0b4..79304a11a 100644
--- a/src/foundry/client/apps/placeables/token-config.d.mts
+++ b/src/foundry/client/apps/placeables/token-config.d.mts
@@ -1,5 +1,4 @@
 import type { InterfaceToObject, AnyObject, Identity } from "fvtt-types/utils";
-import type StringTerm from "../../../client-esm/dice/terms/string.d.mts";
 
 declare global {
   /**
@@ -141,42 +140,61 @@ declare global {
     interface Any extends AnyTokenConfig {}
     interface AnyConstructor extends Identity<typeof AnyTokenConfig> {}
 
-    interface FormData {
-      // TODO: Update
-      actorId: string;
-      actorLink: boolean;
-      alternateImages?: string;
-      alpha: number;
-      "bar1.attribute": string;
-      "bar2.attribute": string;
-      brightLight: number | null;
-      brightSight: number | null;
-      dimLight: number | null;
-      dimSight: number | null;
-      displayBars: foundry.CONST.TOKEN_DISPLAY_MODES;
-      displayName: foundry.CONST.TOKEN_DISPLAY_MODES;
-      disposition: foundry.CONST.TOKEN_DISPOSITIONS;
-      elevation: number | null;
-      height: number | null;
-      img: string;
-      lightAlpha: number;
-      lightAngle: number | null;
-      "lightAnimation.intensity": number;
-      "lightAnimation.speed": number;
-      "lightAnimation.type": string;
-      lightColor: string;
-      lockRotation: boolean;
-      mirrorX: boolean;
-      mirrorY: boolean;
-      name: StringTerm;
-      rotation: number | null;
-      scale: number;
-      sightAngle: number | null;
-      tint: string;
-      vision: boolean;
-      width: number | null;
-      x: number | null;
-      y: number | null;
+    /** @internal */
+    type _FormData = Pick<
+      TokenDocument,
+      | "actorId"
+      | "actorLink"
+      | "alpha"
+      | "detectionModes"
+      | "displayBars"
+      | "displayName"
+      | "disposition"
+      | "elevation"
+      | "lockRotation"
+      | "name"
+      | "rotation"
+      | "sort"
+      | "x"
+      | "y"
+    >;
+
+    interface FormData extends _FormData {
+      "bar1.attribute": TokenDocument["bar1"]["attribute"];
+      "bar2.attribute": TokenDocument["bar2"]["attribute"];
+      "light.alpha": TokenDocument["light"]["alpha"];
+      "light.angle": TokenDocument["light"]["angle"];
+      "light.animation.intensity": TokenDocument["light"]["animation"]["intensity"];
+      "light.animation.reverse": TokenDocument["light"]["animation"]["reverse"];
+      "light.animation.speed": TokenDocument["light"]["animation"]["speed"];
+      "light.animation.type": TokenDocument["light"]["animation"]["type"];
+      "light.attenuation": TokenDocument["light"]["attenuation"];
+      "light.bright": TokenDocument["light"]["bright"];
+      "light.color": TokenDocument["light"]["color"];
+      "light.coloration": TokenDocument["light"]["coloration"];
+      "light.contrast": TokenDocument["light"]["contrast"];
+      "light.dim": TokenDocument["light"]["dim"];
+      "light.luminosity": TokenDocument["light"]["luminosity"];
+      "light.saturation": TokenDocument["light"]["saturation"];
+      "light.shadows": TokenDocument["light"]["shadows"];
+      "occludable.radius": TokenDocument["occludable"]["radius"];
+      "ring.colors.background": TokenDocument["ring"]["colors"]["background"];
+      "ring.colors.ring": TokenDocument["ring"]["colors"]["ring"];
+      "ring.effects": TokenDocument["ring"]["effects"];
+      "ring.enabled": TokenDocument["ring"]["enabled"];
+      "ring.subject.scale": TokenDocument["ring"]["subject"]["scale"];
+      "ring.subject.texture": TokenDocument["ring"]["subject"]["texture"];
+      "sight.attenuation": TokenDocument["sight"]["attenuation"];
+      "sight.color": TokenDocument["sight"]["color"];
+      "sight.contrast": TokenDocument["sight"]["contrast"];
+      "sight.enabled": TokenDocument["sight"]["enabled"];
+      "texture.anchorX": TokenDocument["texture"]["anchorX"];
+      "texture.anchorY": TokenDocument["texture"]["anchorY"];
+      "texture.fit": TokenDocument["texture"]["fit"];
+      "texture.scaleX": TokenDocument["texture"]["scaleX"];
+      "texture.scaleY": TokenDocument["texture"]["scaleY"];
+      "texture.src": TokenDocument["texture"]["src"];
+      "texture.tint": TokenDocument["texture"]["tint"];
     }
   }
 
diff --git a/src/foundry/client/apps/placeables/wall-config.d.mts b/src/foundry/client/apps/placeables/wall-config.d.mts
index 989b17977..7f16637ba 100644
--- a/src/foundry/client/apps/placeables/wall-config.d.mts
+++ b/src/foundry/client/apps/placeables/wall-config.d.mts
@@ -1,4 +1,4 @@
-import type { MaybePromise } from "fvtt-types/utils";
+import type { AnyObject, InterfaceToObject, MaybePromise } from "fvtt-types/utils";
 
 declare global {
   /**
@@ -43,7 +43,7 @@ declare global {
 
     protected _onChangeInput(event: JQuery.ChangeEvent<any, any, any, any>): Promise<void | object>;
 
-    protected _getSubmitData(updateData?: object | null): WallConfig.FormData;
+    protected _getSubmitData(updateData?: AnyObject | null): InterfaceToObject<WallConfig.FormData>;
 
     protected override _updateObject(event: Event, formData: WallConfig.FormData): Promise<unknown>;
   }
@@ -51,14 +51,14 @@ declare global {
   namespace WallConfig {
     interface Any extends WallConfig<any> {}
 
-    type FormData = Pick<
-      WallDocument["_source"],
-      "move" | "light" | "sight" | "sound" | "dir" | "door" | "ds" | "doorSound"
-    > & {
-      "threshold.light": WallDocument["_source"]["threshold"]["light"];
-      "threshold.sight": WallDocument["_source"]["threshold"]["sight"];
-      "threshold.sound": WallDocument["_source"]["threshold"]["sound"];
-      "threshold.attenuation": WallDocument["_source"]["threshold"]["attenuation"];
-    };
+    /** @internal */
+    type _FormData = Pick<WallDocument, "dir" | "door" | "doorSound" | "ds" | "light" | "move" | "sight" | "sound">;
+
+    interface FormData extends _FormData {
+      "threshold.light": WallDocument["threshold"]["light"];
+      "threshold.sight": WallDocument["threshold"]["sight"];
+      "threshold.sound": WallDocument["threshold"]["sound"];
+      "threshold.attenuation": WallDocument["threshold"]["attenuation"];
+    }
   }
 }
diff --git a/src/foundry/client/config.d.mts b/src/foundry/client/config.d.mts
index c82cbb9ed..cc9e7f65a 100644
--- a/src/foundry/client/config.d.mts
+++ b/src/foundry/client/config.d.mts
@@ -3198,24 +3198,40 @@ declare global {
       }
     }
 
+    /** @privateRemarks Foundry does not document the array options */
     interface WallDoorSound {
       /** A localization string label */
       label: string;
 
-      /** A sound path when the door is closed */
-      close: string;
+      /**
+       * A sound path when the door is closed
+       * @remarks If an array is provided, a random entry is chosen
+       */
+      close?: string | string[];
 
-      /** A sound path when the door becomes locked */
-      lock: string;
+      /**
+       * A sound path when the door becomes locked
+       * @remarks If an array is provided, a random entry is chosen
+       */
+      lock?: string | string[];
 
-      /** A sound path when opening the door */
-      open: string;
+      /**
+       * A sound path when opening the door
+       * @remarks If an array is provided, a random entry is chosen
+       */
+      open?: string | string[];
 
-      /** A sound path when attempting to open a locked door */
-      test: string;
+      /**
+       * A sound path when attempting to open a locked door
+       * @remarks If an array is provided, a random entry is chosen
+       */
+      test?: string | string[];
 
-      /** A sound path when the door becomes unlocked */
-      unlock: string;
+      /**
+       * A sound path when the door becomes unlocked
+       * @remarks If an array is provided, a random entry is chosen
+       */
+      unlock?: string | string[];
     }
 
     namespace Dice {
diff --git a/src/foundry/client/data/documents/ambient-light.d.mts b/src/foundry/client/data/documents/ambient-light.d.mts
index eec7e8e1e..38711ea43 100644
--- a/src/foundry/client/data/documents/ambient-light.d.mts
+++ b/src/foundry/client/data/documents/ambient-light.d.mts
@@ -101,31 +101,37 @@ declare global {
        * The x-coordinate position of the origin of the light
        * @defaultValue `0`
        */
-      x: fields.NumberField<{ required: true; integer: true; nullable: false; initial: 0; label: "XCoord" }>;
+      x: fields.NumberField<{ required: true; integer: true; nullable: false; initial: 0 }>;
 
       /**
        * The y-coordinate position of the origin of the light
        * @defaultValue `0`
        */
-      y: fields.NumberField<{ required: true; integer: true; nullable: false; initial: 0; label: "YCoord" }>;
+      y: fields.NumberField<{ required: true; integer: true; nullable: false; initial: 0 }>;
+
+      /**
+       * The elevation of the sound
+       * @defaultValue `0`
+       */
+      elevation: fields.NumberField<{ required: true; nullable: false; initial: 0 }>;
 
       /**
        * The angle of rotation for the tile between 0 and 360
        * @defaultValue `0`
        */
-      rotation: fields.AngleField<{ label: "LIGHT.Rotation" }>;
+      rotation: fields.AngleField;
 
       /**
        * Whether or not this light source is constrained by Walls
        * @defaultValue `true`
        */
-      walls: fields.BooleanField<{ initial: true; label: "LIGHT.Walls"; hint: "LIGHT.WallsHint" }>;
+      walls: fields.BooleanField<{ initial: true }>;
 
       /**
        * Whether or not this light source provides a source of vision
        * @defaultValue `false`
        */
-      vision: fields.BooleanField<{ label: "LIGHT.Vision"; hint: "LIGHT.VisionHint" }>;
+      vision: fields.BooleanField;
 
       /**
        * Light configuration data
@@ -137,7 +143,7 @@ declare global {
        * Is the light source currently hidden?
        * @defaultValue `false`
        */
-      hidden: fields.BooleanField<{ label: "Hidden" }>;
+      hidden: fields.BooleanField;
 
       /**
        * An object of optional key/value flags
@@ -198,6 +204,7 @@ declare global {
 
     interface CoreFlags {
       core?: {
+        /** @remarks If provided, will be used for any light animations emanating from this token */
         animationSeed?: number;
       };
     }
diff --git a/src/foundry/client/data/documents/ambient-sound.d.mts b/src/foundry/client/data/documents/ambient-sound.d.mts
index e9475c0ea..a61afc2d0 100644
--- a/src/foundry/client/data/documents/ambient-sound.d.mts
+++ b/src/foundry/client/data/documents/ambient-sound.d.mts
@@ -100,13 +100,19 @@ declare global {
        * The x-coordinate position of the origin of the sound.
        * @defaultValue `0`
        */
-      x: fields.NumberField<{ required: true; integer: true; nullable: false; initial: 0; label: "XCoord" }>;
+      x: fields.NumberField<{ required: true; integer: true; nullable: false; initial: 0 }>;
 
       /**
        * The y-coordinate position of the origin of the sound.
        * @defaultValue `0`
        */
-      y: fields.NumberField<{ required: true; integer: true; nullable: false; initial: 0; label: "YCoord" }>;
+      y: fields.NumberField<{ required: true; integer: true; nullable: false; initial: 0 }>;
+
+      /**
+       * The elevation of the sound.
+       * @defaultValue `0`
+       */
+      elevation: fields.NumberField<{ required: true; nullable: false; initial: 0 }>;
 
       /**
        * The radius of the emitted sound.
@@ -118,14 +124,13 @@ declare global {
         initial: 0;
         min: 0;
         step: 0.01;
-        label: "SOUND.Radius";
       }>;
 
       /**
        * The audio file path that is played by this sound
        * @defaultValue `null`
        */
-      path: fields.FilePathField<{ categories: ["AUDIO"]; label: "SOUND.SourcePath" }>;
+      path: fields.FilePathField<{ categories: ["AUDIO"] }>;
 
       /**
        * Does this sound loop?
@@ -137,41 +142,56 @@ declare global {
        * The audio volume of the sound, from 0 to 1
        * @defaultValue `0.5`
        */
-      volume: fields.AlphaField<{ initial: 0.5; step: 0.01; label: "SOUND.MaxVol"; hint: "SOUND.MaxVolHint" }>;
+      volume: fields.AlphaField<{ initial: 0.5; step: 0.01 }>;
 
       /**
        * Whether or not this sound source is constrained by Walls.
        * @defaultValue `true`
        */
-      walls: fields.BooleanField<{ initial: true; label: "SOUND.Walls"; hint: "SOUND.WallsHint" }>;
+      walls: fields.BooleanField<{ initial: true }>;
 
       /**
        * Whether to adjust the volume of the sound heard by the listener based on how
        * close the listener is to the center of the sound source.
        * @defaultValue `true`
        */
-      easing: fields.BooleanField<{ initial: true; label: "SOUND.Easing"; hint: "SOUND.EasingHint" }>;
+      easing: fields.BooleanField<{ initial: true }>;
 
       /**
        * Is the sound source currently hidden?
        * @defaultValue `false`
        */
-      hidden: fields.BooleanField<{ label: "Hidden" }>;
+      hidden: fields.BooleanField;
 
       /**
        * A darkness range (min and max) for which the source should be active
        * @defaultValue see properties
        */
-      darkness: fields.SchemaField<
-        {
-          /** @defaultValue `0` */
-          min: fields.AlphaField<{ initial: 0 }>;
+      darkness: fields.SchemaField<{
+        /** @defaultValue `0` */
+        min: fields.AlphaField<{ initial: 0 }>;
 
-          /** @defaultValue `1` */
-          max: fields.AlphaField<{ initial: 1 }>;
-        },
-        { label: "SOUND.DarknessRange"; hint: "SOUND.DarknessRangeHint" }
-      >;
+        /** @defaultValue `1` */
+        max: fields.AlphaField<{ initial: 1 }>;
+      }>;
+
+      /**
+       * Special effects to apply to the sound
+       * @defaultValue see properties
+       */
+      effects: fields.SchemaField<{
+        /**
+         * An effect configuration to apply to the sound when not muffled by walls (either clear of, or fully constrained by, walls)
+         * @defaultValue see properties of {@link EffectsConfigSchema | `AmbientSoundDocument.EffectsConfigSchema`}
+         */
+        base: fields.SchemaField<EffectsConfigSchema>;
+
+        /**
+         * An effect configuration to apply to the sound when muffled by walls
+         * @defaultValue see properties of {@link EffectsConfigSchema | `AmbientSoundDocument.EffectsConfigSchema`}
+         */
+        muffled: fields.SchemaField<EffectsConfigSchema>;
+      }>;
 
       /**
        * An object of optional key/value flags
@@ -180,6 +200,17 @@ declare global {
       flags: fields.ObjectField.FlagsField<"AmbientSound">;
     }
 
+    interface EffectsConfigSchema extends DataSchema {
+      /**
+       * @defaultValue `undefined`
+       * @remarks This isn't enforced by the model, but in practice should only have values in `keyof CONFIG["soundEffects"]`
+       */
+      type: fields.StringField;
+
+      /** @defaultValue `5` */
+      intensity: fields.NumberField<{ required: true; integer: true; initial: 5; min: 1; max: 10 }>;
+    }
+
     namespace DatabaseOperation {
       /** Options passed along in Get operations for AmbientSoundDocuments */
       interface Get extends foundry.abstract.types.DatabaseGetOperation<AmbientSoundDocument.Parent> {}
diff --git a/src/foundry/client/data/documents/drawing.d.mts b/src/foundry/client/data/documents/drawing.d.mts
index 455891ad5..5723c9ca0 100644
--- a/src/foundry/client/data/documents/drawing.d.mts
+++ b/src/foundry/client/data/documents/drawing.d.mts
@@ -101,7 +101,10 @@ declare global {
        * The _id of the user who created the drawing
        * @defaultValue `game.user?.id`
        */
-      author: fields.ForeignDocumentField<typeof documents.BaseUser, { nullable: false; initial: () => string }>;
+      author: fields.ForeignDocumentField<
+        typeof documents.BaseUser,
+        { nullable: false; initial: () => string | undefined }
+      >;
 
       /**
        * The geometric shape of the drawing
@@ -121,11 +124,17 @@ declare global {
        */
       y: fields.NumberField<{ required: true; nullable: false; initial: 0; label: "YCoord" }>;
 
+      /**
+       * The elevation of the drawing
+       * @defaultValue `0`
+       */
+      elevation: fields.NumberField<{ required: true; nullable: false; initial: 0 }>;
+
       /**
        * The z-index of this drawing relative to other siblings
        * @defaultValue `0`
        */
-      z: fields.NumberField<{ required: true; integer: true; nullable: false; initial: 0; label: "DRAWING.ZIndex" }>;
+      sort: fields.NumberField<{ required: true; integer: true; nullable: false; initial: 0 }>;
 
       /**
        * The angle of rotation for the drawing figure
@@ -148,19 +157,26 @@ declare global {
        * The fill type of the drawing shape, a value from CONST.DRAWING_FILL_TYPES
        * @defaultValue `CONST.DRAWING_FILL_TYPES.NONE`
        */
-      fillType: fields.NumberField<{
-        required: true;
-        initial: typeof CONST.DRAWING_FILL_TYPES.NONE;
-        choices: CONST.DRAWING_FILL_TYPES[];
-        label: "DRAWING.FillTypes";
-        validationError: "must be a value in CONST.DRAWING_FILL_TYPES";
-      }>;
+      fillType: fields.NumberField<
+        {
+          required: true;
+          nullable: false;
+          initial: typeof CONST.DRAWING_FILL_TYPES.NONE;
+          choices: CONST.DRAWING_FILL_TYPES[];
+          label: "DRAWING.FillTypes";
+          validationError: "must be a value in CONST.DRAWING_FILL_TYPES";
+        },
+        //FIXME: Without these overrides, the branded type from `choices` is not respected, and the field types as `number`
+        CONST.DRAWING_FILL_TYPES | null | undefined,
+        CONST.DRAWING_FILL_TYPES,
+        CONST.DRAWING_FILL_TYPES
+      >;
 
       /**
        * An optional color string with which to fill the drawing geometry
-       * @defaultValue `game.user?.color`
+       * @defaultValue `game.user?.color.css || "#ffffff"`
        */
-      fillColor: fields.ColorField<{ initial: () => string; label: "DRAWING.FillColor" }>;
+      fillColor: fields.ColorField<{ nullable: false; initial: () => string; label: "DRAWING.FillColor" }>;
 
       /**
        * The opacity of the fill applied to the drawing geometry
@@ -172,13 +188,19 @@ declare global {
        * The width in pixels of the boundary lines of the drawing geometry
        * @defaultValue `8`
        */
-      strokeWidth: fields.NumberField<{ integer: true; initial: 8; min: 0; label: "DRAWING.LineWidth" }>;
+      strokeWidth: fields.NumberField<{
+        nullable: false;
+        integer: true;
+        initial: 8;
+        min: 0;
+        label: "DRAWING.LineWidth";
+      }>;
 
       /**
        * The color of the boundary lines of the drawing geometry
-       * @defaultValue `game.user?.color`
+       * @defaultValue `game.user?.color.css || "#ffffff"`
        */
-      strokeColor: fields.ColorField<{ initial: () => string; label: "DRAWING.StrokeColor" }>;
+      strokeColor: fields.ColorField<{ nullable: false; initial: () => string; label: "DRAWING.StrokeColor" }>;
 
       /**
        * The opacity of the boundary lines of the drawing geometry
@@ -194,7 +216,7 @@ declare global {
 
       /**
        * Optional text which is displayed overtop of the drawing
-       * @defaultValue `""`
+       * @defaultValue `undefined`
        */
       text: fields.StringField<{ label: "DRAWING.TextLabel" }>;
 
@@ -209,6 +231,7 @@ declare global {
        * @defaultValue `48`
        */
       fontSize: fields.NumberField<{
+        nullable: false;
         integer: true;
         min: 8;
         max: 256;
@@ -221,7 +244,7 @@ declare global {
        * The color of text displayed within this drawing
        * @defaultValue `#FFFFFF`
        */
-      textColor: fields.ColorField<{ initial: "#FFFFFF"; label: "DRAWING.TextColor" }>;
+      textColor: fields.ColorField<{ nullable: false; initial: "#FFFFFF"; label: "DRAWING.TextColor" }>;
 
       /**
        * The opacity of text displayed within this drawing
diff --git a/src/foundry/client/data/documents/measured-template.d.mts b/src/foundry/client/data/documents/measured-template.d.mts
index 308da4da2..78211c4c0 100644
--- a/src/foundry/client/data/documents/measured-template.d.mts
+++ b/src/foundry/client/data/documents/measured-template.d.mts
@@ -101,19 +101,25 @@ declare global {
        * The _id of the user who created this measured template
        * @defaultValue `game?.user?.id`
        */
-      user: fields.ForeignDocumentField<typeof documents.BaseUser, { initial: () => string }>;
+      author: fields.ForeignDocumentField<typeof documents.BaseUser, { initial: () => string | undefined }>;
 
       /**
        * The value in CONST.MEASURED_TEMPLATE_TYPES which defines the geometry type of this template
-       * @defaultValue `CONST.MEASURED_TEMPLATE_TYPES.CIRCLE`
+       * @defaultValue `CONST.MEASURED_TEMPLATE_TYPES.CIRCLE` (`"circle"`)
        */
-      t: fields.StringField<{
-        required: true;
-        choices: foundry.CONST.MEASURED_TEMPLATE_TYPES[];
-        label: "Type";
-        initial: typeof CONST.MEASURED_TEMPLATE_TYPES.CIRCLE;
-        validationError: "must be a value in CONST.MEASURED_TEMPLATE_TYPES";
-      }>;
+      t: fields.StringField<
+        {
+          required: true;
+          choices: CONST.MEASURED_TEMPLATE_TYPES[];
+          label: "Type";
+          initial: typeof CONST.MEASURED_TEMPLATE_TYPES.CIRCLE;
+          validationError: "must be a value in CONST.MEASURED_TEMPLATE_TYPES";
+        },
+        //FIXME: Without these overrides, the branded type from `choices` is not respected, and the field types as `number`
+        CONST.MEASURED_TEMPLATE_TYPES | null | undefined,
+        CONST.MEASURED_TEMPLATE_TYPES,
+        CONST.MEASURED_TEMPLATE_TYPES
+      >;
 
       /**
        * The x-coordinate position of the origin of the template effect
@@ -127,11 +133,29 @@ declare global {
        */
       y: fields.NumberField<{ required: true; integer: true; nullable: false; initial: 0; label: "YCoord" }>;
 
+      /**
+       * The elevation of the template
+       * @defaultValue `0`
+       */
+      elevation: fields.NumberField<{ required: true; nullable: false; initial: 0 }>;
+
+      /**
+       * The z-index of this template relative to other siblings
+       * @defaultValue `0`
+       */
+      sort: fields.NumberField<{ required: true; integer: true; nullable: false; initial: 0 }>;
+
       /**
        * The distance of the template effect
-       * @defaultValue `1`
+       * @defaultValue `0`
        */
-      distance: fields.NumberField<{ required: true; positive: true; initial: 1; label: "Distance" }>;
+      distance: fields.NumberField<{
+        required: true;
+        nullable: false;
+        initial: 0;
+        min: 0;
+        label: "Distance";
+      }>;
 
       /**
        * The angle of rotation for the measured template
@@ -143,25 +167,25 @@ declare global {
        * The angle of effect of the measured template, applies to cone types
        * @defaultValue `0`
        */
-      angle: fields.AngleField<{ label: "Angle" }>;
+      angle: fields.AngleField<{ normalize: false; label: "Angle" }>;
 
       /**
        * The width of the measured template, applies to ray types
-       * @defaultValue `null`
+       * @defaultValue `0`
        */
-      width: fields.NumberField<{ integer: true; positive: true; label: "Width" }>;
+      width: fields.NumberField<{ required: true; nullable: false; initial: 0; min: 0; step: 0.01; label: "Width" }>;
 
       /**
        * A color string used to tint the border of the template shape
        * @defaultValue `#000000`
        */
-      borderColor: fields.ColorField<{ initial: "#000000" }>;
+      borderColor: fields.ColorField<{ nullable: false; initial: "#000000" }>;
 
       /**
        * A color string used to tint the fill of the template shape
-       * @defaultValue `#FF0000`
+       * @defaultValue `game.user?.color.css || "#ffffff"`
        */
-      fillColor: fields.ColorField<{ initial: "#FF0000" }>;
+      fillColor: fields.ColorField<{ nullable: false; initial: () => string }>;
 
       /**
        * A repeatable tiling texture used to add a texture fill to the template shape
@@ -181,6 +205,7 @@ declare global {
        */
       flags: fields.ObjectField.FlagsField<"MeasuredTemplate">;
     }
+
     namespace DatabaseOperation {
       /** Options passed along in Get operations for MeasuredTemplateDocuments */
       interface Get extends foundry.abstract.types.DatabaseGetOperation<MeasuredTemplateDocument.Parent> {}
diff --git a/src/foundry/client/data/documents/note.d.mts b/src/foundry/client/data/documents/note.d.mts
index 5c28eee76..1554decb1 100644
--- a/src/foundry/client/data/documents/note.d.mts
+++ b/src/foundry/client/data/documents/note.d.mts
@@ -122,13 +122,30 @@ declare global {
        */
       y: fields.NumberField<{ required: true; integer: true; nullable: false; initial: 0; label: "YCoord" }>;
 
+      /**
+       * The elevation of the note
+       * @defaultValue `0`
+       */
+      elevation: fields.NumberField<{ required: true; nullable: false; initial: 0 }>;
+
+      /**
+       * The z-index of this note relative to other siblings
+       * @defaultValue `0`
+       */
+      sort: fields.NumberField<{ required: true; integer: true; nullable: false; initial: 0 }>;
+
       /**
        * An image icon used to represent this note
        * @defaultValue `BaseNote.DEFAULT_ICON`
        */
       texture: TextureData<{
         categories: ["IMAGE"];
-        initial: () => typeof BaseNote.DEFAULT_ICON;
+        initial: {
+          src: () => typeof BaseNote.DEFAULT_ICON;
+          anchorX: 0.5;
+          anchorY: 0.5;
+          fit: "contain";
+        };
         label: "NOTE.EntryIcon";
       }>;
 
@@ -138,6 +155,7 @@ declare global {
        */
       iconSize: fields.NumberField<{
         required: true;
+        nullable: false;
         integer: true;
         min: 32;
         initial: 40;
@@ -175,19 +193,24 @@ declare global {
        * A value in CONST.TEXT_ANCHOR_POINTS which defines where the text label anchors to the note icon.
        * @defaultValue `CONST.TEXT_ANCHOR_POINTS.BOTTOM`
        */
-      textAnchor: fields.NumberField<{
-        required: true;
-        choices: foundry.CONST.TEXT_ANCHOR_POINTS[];
-        initial: typeof CONST.TEXT_ANCHOR_POINTS.BOTTOM;
-        label: "NOTE.AnchorPoint";
-        validationError: "must be a value in CONST.TEXT_ANCHOR_POINTS";
-      }>;
+      textAnchor: fields.NumberField<
+        {
+          required: true;
+          choices: CONST.TEXT_ANCHOR_POINTS[];
+          initial: typeof CONST.TEXT_ANCHOR_POINTS.BOTTOM;
+          label: "NOTE.AnchorPoint";
+          validationError: "must be a value in CONST.TEXT_ANCHOR_POINTS";
+        },
+        CONST.TEXT_ANCHOR_POINTS | null | undefined,
+        CONST.TEXT_ANCHOR_POINTS | null,
+        CONST.TEXT_ANCHOR_POINTS | null
+      >;
 
       /**
        * The string that defines the color with which the note text is rendered
        * @defaultValue `#FFFFFF`
        */
-      textColor: fields.ColorField<{ initial: "#FFFFFF"; label: "NOTE.TextColor" }>;
+      textColor: fields.ColorField<{ required: true; nullable: false; initial: "#FFFFFF"; label: "NOTE.TextColor" }>;
 
       /**
        * Whether this map pin is globally visible or requires LoS to see.
@@ -201,6 +224,7 @@ declare global {
        */
       flags: fields.ObjectField.FlagsField<"Note">;
     }
+
     namespace DatabaseOperation {
       /** Options passed along in Get operations for NoteDocuments */
       interface Get extends foundry.abstract.types.DatabaseGetOperation<NoteDocument.Parent> {}
diff --git a/src/foundry/client/data/documents/region-behavior.d.mts b/src/foundry/client/data/documents/region-behavior.d.mts
index a539859f7..17771ffe7 100644
--- a/src/foundry/client/data/documents/region-behavior.d.mts
+++ b/src/foundry/client/data/documents/region-behavior.d.mts
@@ -125,7 +125,7 @@ declare global {
        * Is the RegionBehavior currently disabled?
        * @defaultValue `false`
        */
-      disabled: fields.BooleanField<{ label: string; hint: string }>;
+      disabled: fields.BooleanField<{ label: "BEHAVIOR.FIELDS.disabled.label"; hint: "BEHAVIOR.FIELDS.disabled.hint" }>;
 
       /**
        * An object of optional key/value flags
diff --git a/src/foundry/client/data/documents/region.d.mts b/src/foundry/client/data/documents/region.d.mts
index 69e91de1c..12f2acba2 100644
--- a/src/foundry/client/data/documents/region.d.mts
+++ b/src/foundry/client/data/documents/region.d.mts
@@ -81,10 +81,10 @@ declare global {
     interface UpdateData extends fields.SchemaField.UpdateData<Schema> {}
 
     /**
-     * The schema for {@link Region | `Region`}. This is the source of truth for how an Region document
+     * The schema for {@link RegionDocument | `RegionDocument`}. This is the source of truth for how an Region document
      * must be structured.
      *
-     * Foundry uses this schema to validate the structure of the {@link Region | `Region`}. For example
+     * Foundry uses this schema to validate the structure of the {@link RegionDocument | `RegionDocument`}. For example
      * a {@link fields.StringField | `StringField`} will enforce that the value is a string. More
      * complex fields like {@link fields.SetField | `SetField`} goes through various conversions
      * starting as an array in the database, initialized as a set, and allows updates with any
@@ -97,21 +97,31 @@ declare global {
        */
       _id: fields.DocumentIdField;
 
-      // TODO(Eon): Should label here be string or "Name"?
       /**
        * The name used to describe the Region
        */
-      name: fields.StringField<{ required: true; blank: false; label: string; textSearch: true }>;
+      //FIXME: This field is `required` with no `initial`, so actually required for construction; Currently an AssignmentType override is required to enforce this
+      name: fields.StringField<{ required: true; blank: false; label: "Name"; textSearch: true }, string>;
 
       /**
        * The color used to highlight the Region
+       * @defaultValue `Color.fromHSV([Math.random(), 0.8, 0.8]).css`
        */
-      color: fields.ColorField<{ required: true; nullable: false; initial: () => string; label: string; hint: string }>;
+      color: fields.ColorField<{
+        required: true;
+        nullable: false;
+        initial: () => string;
+        label: "REGION.FIELDS.color.label";
+        hint: "REGION.FIELDS.color.hint";
+      }>;
 
       /**
        * The shapes that make up the Region
        */
-      shapes: fields.ArrayField<fields.TypedSchemaField<BaseShapeData.Types>>;
+      shapes: fields.ArrayField<
+        fields.TypedSchemaField<BaseShapeData.Types>,
+        { label: "REGION.FIELDS.shapes.label"; hint: "REGION.FIELDS.shapes.hint" }
+      >;
 
       /**
        * A RegionElevation object which defines the elevation levels where the Region takes effect
@@ -124,15 +134,29 @@ declare global {
            * @remarks if bottom is `null`, it is treated as `-Infinity`
            * @defaultValue `null`
            */
-          bottom: fields.NumberField<{ required: true; label: string; hint: string }>;
+          bottom: fields.NumberField<{
+            required: true;
+            label: "REGION.FIELDS.elevation.FIELDS.bottom.label";
+            hint: "REGION.FIELDS.elevation.FIELDS.bottom.hint";
+          }>;
+
           /**
            * The top elevation level where the Region's effect ends
            * @remarks if top is `null`, it is treated as `Infinity`
            * @defaultValue `null`
            */
-          top: fields.NumberField<{ required: true; label: string; hint: string }>;
+          top: fields.NumberField<{
+            required: true;
+            label: "REGION.FIELDS.elevation.FIELDS.top.label";
+            hint: "REGION.FIELDS.elevation.FIELDS.top.hint";
+          }>;
         },
-        { label: string; hint: string; validate: (d: any) => boolean; validationError: string }
+        {
+          label: "REGION.FIELDS.elevation.label";
+          hint: "REGION.FIELDS.elevation.hint";
+          validate: (d: unknown) => boolean;
+          validationError: "elevation.top may not be less than elevation.bottom";
+        }
       >;
 
       /**
@@ -141,17 +165,24 @@ declare global {
       behaviors: fields.EmbeddedCollectionField<
         typeof foundry.documents.BaseRegionBehavior,
         RegionDocument.Implementation,
-        { label: string; hint: string }
+        { label: "REGION.FIELDS.behaviors.label"; hint: "REGION.FIELDS.behaviors.hint" }
       >;
 
-      visibility: fields.NumberField<{
-        required: true;
-        initial: typeof CONST.REGION_VISIBILITY.LAYER;
-        choices: CONST.REGION_VISIBILITY[];
-        label: string;
-        hint: string;
-      }>;
+      /** @defaultValue `CONST.REGION_VISIBILITY.LAYER` (`0`) */
+      visibility: fields.NumberField<
+        {
+          required: true;
+          initial: typeof CONST.REGION_VISIBILITY.LAYER;
+          choices: CONST.REGION_VISIBILITY[];
+          label: "REGION.FIELDS.visibility.label";
+          hint: "REGION.FIELDS.visibility.hint";
+        },
+        CONST.REGION_VISIBILITY | null | undefined,
+        CONST.REGION_VISIBILITY | null,
+        CONST.REGION_VISIBILITY | null
+      >;
 
+      /** @defaultValue `false` */
       locked: fields.BooleanField;
 
       /**
diff --git a/src/foundry/client/data/documents/scene.d.mts b/src/foundry/client/data/documents/scene.d.mts
index 50198c73c..d239cdfd8 100644
--- a/src/foundry/client/data/documents/scene.d.mts
+++ b/src/foundry/client/data/documents/scene.d.mts
@@ -132,7 +132,7 @@ declare global {
        * An image or video file that provides the background texture for the scene.
        * @defaultValue see {@link TextureData | `TextureData`}
        */
-      background: TextureData<{ categories: ["IMAGE", "VIDEO"]; initial: null; wildcard: false }>;
+      background: TextureData;
 
       /**
        * An image or video file path providing foreground media for the scene
diff --git a/src/foundry/client/data/documents/tile.d.mts b/src/foundry/client/data/documents/tile.d.mts
index 3e30c5689..2db553e6c 100644
--- a/src/foundry/client/data/documents/tile.d.mts
+++ b/src/foundry/client/data/documents/tile.d.mts
@@ -123,6 +123,7 @@ declare global {
      * with the right values. This means you can pass a `Set` instance, an array of values,
      * a generator, or any other iterable.
      */
+    //TODO: ensure `width` and `height` are required for creation
     interface CreateData extends fields.SchemaField.CreateData<Schema> {}
 
     /**
@@ -161,24 +162,20 @@ declare global {
 
       /**
        * An image or video texture which this tile displays.
-       * @defaultValue `null`
        */
-      texture: TextureData<{ categories: ("IMAGE" | "VIDEO")[]; initial: null; wildcard: false }>;
+      texture: TextureData<{ initial: { anchorX: 0.5; anchorY: 0.5; alphaThreshold: 0.75 } }>;
 
       /**
        * The pixel width of the tile
        */
-      width: fields.NumberField<{
-        required: true;
-        min: 0;
-        nullable: false;
-        step: 0.1;
-      }>;
+      //FIXME: This field is `required` with no `initial`, so actually required for construction; Currently an AssignmentType override is required to enforce this
+      width: fields.NumberField<{ required: true; min: 0; nullable: false; step: 0.1 }, number>;
 
       /**
        * The pixel height of the tile
        */
-      height: fields.NumberField<{ required: true; min: 0; nullable: false; step: 0.1 }>;
+      //FIXME: This field is `required` with no `initial`, so actually required for construction; Currently an AssignmentType override is required to enforce this
+      height: fields.NumberField<{ required: true; min: 0; nullable: false; step: 0.1 }, number>;
 
       /**
        * The x-coordinate position of the top-left corner of the tile
@@ -199,7 +196,7 @@ declare global {
       elevation: fields.NumberField<{ required: true; nullable: false; initial: 0 }>;
 
       /**
-       * How to sort this tile within its elevation
+       * The z-index of this tile relative to other siblings
        * @defaultValue `0`
        */
       sort: fields.NumberField<{ required: true; integer: true; nullable: false; initial: 0 }>;
@@ -228,17 +225,14 @@ declare global {
        */
       locked: fields.BooleanField;
 
-      /**
-       * Is the tile an overhead tile?
-       * @defaultValue `false`
-       */
-      overhead: fields.BooleanField;
+      /** @defaultValue see properties */
+      restrictions: fields.SchemaField<{
+        /** @defaultValue `false` */
+        light: fields.BooleanField;
 
-      /**
-       * Is the tile a roof?
-       * @defaultValue `false`
-       */
-      roof: fields.BooleanField;
+        /** @defaultValue `false` */
+        weather: fields.BooleanField;
+      }>;
 
       /**
        * The tile's occlusion settings
@@ -249,23 +243,23 @@ declare global {
          * The occlusion mode from CONST.TILE_OCCLUSION_MODES
          * @defaultValue `1`
          */
-        mode: fields.NumberField<{
-          choices: CONST.OCCLUSION_MODES[];
-          initial: typeof CONST.OCCLUSION_MODES.FADE;
-          validationError: "must be a value in CONST.TILE_OCCLUSION_MODES";
-        }>;
+        mode: fields.NumberField<
+          {
+            choices: CONST.OCCLUSION_MODES[];
+            initial: typeof CONST.OCCLUSION_MODES.NONE;
+            validationError: "must be a value in CONST.TILE_OCCLUSION_MODES";
+          },
+          //FIXME: Without these overrides, the branded type from `choices` is not respected, and the field types as `number`
+          CONST.OCCLUSION_MODES | null | undefined,
+          CONST.OCCLUSION_MODES | null,
+          CONST.OCCLUSION_MODES | null
+        >;
 
         /**
          * The occlusion alpha between 0 and 1
          * @defaultValue `0`
          */
         alpha: fields.AlphaField<{ initial: 0 }>;
-
-        /**
-         * An optional radius of occlusion used for RADIAL mode
-         * @defaultValue `null`
-         */
-        radius: fields.NumberField<{ positive: true }>;
       }>;
 
       /**
@@ -408,6 +402,13 @@ declare global {
 
     interface CoreFlags {
       core?: {
+        /**
+         * @deprecated since v12, until 14
+         * @remarks "Tiling Sprites are deprecated without replacement."
+         */
+        isTilingSprite?: boolean;
+
+        /** @remarks If true, and texture.src is a video, it will jump to a random timestamp every time the tile is drawn */
         randomizeVideo?: boolean;
       };
     }
diff --git a/src/foundry/client/data/documents/token.d.mts b/src/foundry/client/data/documents/token.d.mts
index 83dfb3e5c..91352475e 100644
--- a/src/foundry/client/data/documents/token.d.mts
+++ b/src/foundry/client/data/documents/token.d.mts
@@ -151,18 +151,15 @@ declare global {
 
     /**
      * Schema definition shared by {@link foundry.data.PrototypeToken | `PrototypeToken`}.
-     * Foundry technically implements this through deletion, but it's easier for us to do by extension.
+     * Foundry technically implements this through deletion, but it's easier for us to do by extension as there are field
+     * option overrides (e.g `textSearch` on `name`) that cause type issues otherwise.
      */
     interface SharedProtoSchema extends DataSchema {
-      /**
-       * The name used to describe the Token
-       * @defaultValue `""`
-       */
-      name: fields.StringField<{ required: true; blank: true }>;
+      // `name` omitted here because, while it is not in the list of omitted fields for `PrototypeToken`, it's `textSearch: true` in the base schema, but overridden to `false` in `PrototypeToken`
 
       /**
        * The display mode of the Token nameplate, from CONST.TOKEN_DISPLAY_MODES
-       * @defaultValue `CONST.TOKEN_DISPLAY_MODES.NONE`
+       * @defaultValue `CONST.TOKEN_DISPLAY_MODES.NONE` (`0`)
        */
       displayName: fields.NumberField<
         {
@@ -171,6 +168,7 @@ declare global {
           choices: CONST.TOKEN_DISPLAY_MODES[];
           validationError: "must be a value in CONST.TOKEN_DISPLAY_MODES";
         },
+        //FIXME: Without these overrides, the branded type from `choices` is not respected, and the field types as `number`
         CONST.TOKEN_DISPLAY_MODES | null | undefined,
         CONST.TOKEN_DISPLAY_MODES,
         CONST.TOKEN_DISPLAY_MODES
@@ -190,27 +188,41 @@ declare global {
        * The width of the Token in grid units
        * @defaultValue `1`
        */
-      width: fields.NumberField<{ positive: true; initial: 1; label: "Width" }>;
+      width: fields.NumberField<{ nullable: false; positive: true; initial: 1; step: 0.5; label: "Width" }>;
 
       /**
        * The height of the Token in grid units
        * @defaultValue `1`
        */
-      height: fields.NumberField<{ positive: true; initial: 1; label: "Height" }>;
+      height: fields.NumberField<{ nullable: false; positive: true; initial: 1; step: 0.5; label: "Height" }>;
 
       /**
        * The token's texture on the canvas.
-       * @defaultValue `BaseToken.DEFAULT_ICON`
        */
-      texture: TextureData<{ initial: () => typeof BaseToken.DEFAULT_ICON; wildcard: true }>;
+      texture: TextureData<{
+        initial: {
+          src: () => typeof BaseToken.DEFAULT_ICON;
+          anchorX: 0.5;
+          anchorY: 0.5;
+          fit: "contain";
+          alphaThreshold: 0.75;
+        };
+        wildcard: true;
+      }>;
 
       /**
-       * @defaultValue `CONST.TOKEN_HEXAGONAL_SHAPES.ELLIPSE_1`
+       * @defaultValue `CONST.TOKEN_HEXAGONAL_SHAPES.ELLIPSE_1` (`0`)
        */
-      hexagonalShape: fields.NumberField<{
-        initial: typeof CONST.TOKEN_HEXAGONAL_SHAPES.ELLIPSE_1;
-        choices: CONST.TOKEN_HEXAGONAL_SHAPES[];
-      }>;
+      hexagonalShape: fields.NumberField<
+        {
+          initial: typeof CONST.TOKEN_HEXAGONAL_SHAPES.ELLIPSE_1;
+          choices: CONST.TOKEN_HEXAGONAL_SHAPES[];
+        },
+        //FIXME: Without these overrides, the branded type from `choices` is not respected, and the field types as `number`
+        CONST.TOKEN_HEXAGONAL_SHAPES | null | undefined,
+        CONST.TOKEN_HEXAGONAL_SHAPES,
+        CONST.TOKEN_HEXAGONAL_SHAPES
+      >;
 
       /**
        * Prevent the Token image from visually rotating?
@@ -232,7 +244,7 @@ declare global {
 
       /**
        * A displayed Token disposition from CONST.TOKEN_DISPOSITIONS
-       * @defaultValue `CONST.TOKEN_DISPOSITIONS.HOSTILE`
+       * @defaultValue `CONST.TOKEN_DISPOSITIONS.HOSTILE` (`-1`)
        */
       disposition: fields.NumberField<
         {
@@ -241,6 +253,7 @@ declare global {
           initial: typeof CONST.TOKEN_DISPOSITIONS.HOSTILE;
           validationError: "must be a value in CONST.TOKEN_DISPOSITIONS";
         },
+        //FIXME: Without these overrides, the branded type from `choices` is not respected, and the field types as `number`
         CONST.TOKEN_DISPOSITIONS | null | undefined,
         CONST.TOKEN_DISPOSITIONS,
         CONST.TOKEN_DISPOSITIONS
@@ -248,7 +261,7 @@ declare global {
 
       /**
        * The display mode of Token resource bars, from CONST.TOKEN_DISPLAY_MODES
-       * @defaultValue `CONST.TOKEN_DISPLAY_MODES.NONE`
+       * @defaultValue `CONST.TOKEN_DISPLAY_MODES.NONE` (`0`)
        */
       displayBars: fields.NumberField<
         {
@@ -257,6 +270,7 @@ declare global {
           initial: typeof CONST.TOKEN_DISPLAY_MODES.NONE;
           validationError: "must be a value in CONST.TOKEN_DISPLAY_MODES";
         },
+        //FIXME: Without these overrides, the branded type from `choices` is not respected, and the field types as `number`
         CONST.TOKEN_DISPLAY_MODES | null | undefined,
         CONST.TOKEN_DISPLAY_MODES,
         CONST.TOKEN_DISPLAY_MODES
@@ -264,32 +278,36 @@ declare global {
 
       /**
        * The configuration of the Token's primary resource bar
-       * @defaultValue
-       * ```typescript
-       * { attribute: null }
-       * ```
+       * @defaultValue see property
        */
       bar1: fields.SchemaField<{
         /**
          * The attribute path within the Token's Actor data which should be displayed
          * @defaultValue `game?.system.primaryTokenAttribute || null`
          */
-        attribute: fields.StringField<{ required: true; nullable: true; blank: false; initial: () => string | null }>;
+        attribute: fields.StringField<{
+          required: true;
+          nullable: true;
+          blank: false;
+          initial: () => string | null;
+        }>;
       }>;
 
       /**
        * The configuration of the Token's secondary resource bar
-       * @defaultValue
-       * ```typescript
-       * { attribute: null }
-       * ```
+       * @defaultValue see property
        */
       bar2: fields.SchemaField<{
         /**
          * The attribute path within the Token's Actor data which should be displayed
-         * @defaultValue `game?.system.secondaryTokenAttribute`
+         * @defaultValue `game?.system.secondaryTokenAttribute || null`
          */
-        attribute: fields.StringField<{ required: true; nullable: true; blank: false; initial: () => string | null }>;
+        attribute: fields.StringField<{
+          required: true;
+          nullable: true;
+          blank: false;
+          initial: () => string | null;
+        }>;
       }>;
 
       /**
@@ -301,25 +319,27 @@ declare global {
       /**
        * Configuration of sight and vision properties for the Token
        * @defaultValue see properties
+       * @privateRemarks Foundry has this split out into its own `@typedef TokenSightData`, but it's never
+       * referenced outside `@typedef TokenData`, so no need for a separate interface
        */
       sight: fields.SchemaField<{
         /**
          * Should vision computation and rendering be active for this Token?
-         * @defaultValue true, when the token's sight range is greater than 0
+         * @defaultValue `true`, when the token's sight range is greater than 0
          */
-        enabled: fields.BooleanField<{ initial: () => boolean }>;
+        enabled: fields.BooleanField<{ initial: (data: unknown) => boolean }>;
 
         /**
          * How far in distance units the Token can see without the aid of a light source
-         * @defaultValue `null`
+         * @defaultValue `0`
          */
-        range: fields.NumberField<{ required: true; nullable: false; min: 0; step: 0.01; initial: 0 }>;
+        range: fields.NumberField<{ required: true; nullable: true; min: 0; step: 0.01; initial: 0 }>;
 
         /**
          * An angle at which the Token can see relative to their direction of facing
          * @defaultValue `360`
          */
-        angle: fields.AngleField<{ initial: 360; base: 360 }>;
+        angle: fields.AngleField<{ initial: 360; normalize: false }>;
 
         /**
          * The vision mode which is used to render the appearance of the visible area
@@ -395,6 +415,7 @@ declare global {
       /**
        * An array of detection modes which are available to this Token
        * @defaultValue `[]`
+       * @remarks The validation function is a `BaseToken.#validateDetectionModes` reference, which throws if there's a duplicate mode ID
        */
       detectionModes: fields.ArrayField<
         fields.SchemaField<{
@@ -412,9 +433,9 @@ declare global {
 
           /**
            * The maximum range in distance units at which this mode can detect targets
-           * @defaultValue `0`
+           * @defaultValue `null`
            */
-          range: fields.NumberField<{ required: true; nullable: false; min: 0; step: 0.01; initial: 0 }>;
+          range: fields.NumberField<{ required: true; min: 0; step: 0.01 }>;
         }>,
         {
           validate: () => void;
@@ -458,7 +479,7 @@ declare global {
         /**
          * @defaultValue `1`
          */
-        effects: fields.NumberField<{ initial: 1; min: 0; max: 8388607; integer: true }>;
+        effects: fields.NumberField<{ initial: 1; min: 0; max: 0x7fffff; integer: true }>;
 
         /**
          * @defaultValue see properties
@@ -477,7 +498,7 @@ declare global {
       }>;
 
       /**
-       * @internal
+       * @remarks Foundry marked `@internal`
        */
       _regions: fields.ArrayField<fields.ForeignDocumentField<typeof documents.BaseRegion, { idOnly: true }>>;
 
@@ -505,6 +526,12 @@ declare global {
        */
       _id: fields.DocumentIdField;
 
+      /**
+       * The name used to describe the Token
+       * @defaultValue `""`
+       */
+      name: fields.StringField<{ required: true; blank: true; textSearch: true }>;
+
       /**
        * The _id of an Actor document which this Token represents
        * @defaultValue `null`
@@ -536,16 +563,17 @@ declare global {
       elevation: fields.NumberField<{ required: true; nullable: false; initial: 0 }>;
 
       /**
-       * An array of effect icon paths which are displayed on the Token
-       * @defaultValue `[]`
+       * Is the Token currently locked? A locked token cannot be moved or rotated via
+       * standard keyboard or mouse interaction.
+       * @defaultValue `false`
        */
-      effects: fields.ArrayField<fields.StringField>;
+      locked: fields.BooleanField;
 
       /**
-       * A single icon path which is displayed as an overlay on the Token
-       * @defaultValue `""`
+       * The z-index of this token relative to other siblings
+       * @defaultValue `0`
        */
-      overlayEffect: fields.StringField;
+      sort: fields.NumberField<{ required: true; integer: true; nullable: false; initial: 0 }>;
 
       /**
        * Is the Token currently hidden from player view?
@@ -669,7 +697,10 @@ declare global {
 
     interface CoreFlags {
       core?: {
+        /** @remarks If provided, will be used for any light animations emanating from this token */
         animationSeed?: number;
+
+        /** @remarks If true, and texture.src is a video, it will jump to a random timestamp every time the token is drawn */
         randomizeVideo?: boolean;
       };
     }
diff --git a/src/foundry/client/data/documents/wall.d.mts b/src/foundry/client/data/documents/wall.d.mts
index 94e10ee99..84f03ae9c 100644
--- a/src/foundry/client/data/documents/wall.d.mts
+++ b/src/foundry/client/data/documents/wall.d.mts
@@ -122,6 +122,7 @@ declare global {
      * with the right values. This means you can pass a `Set` instance, an array of values,
      * a generator, or any other iterable.
      */
+    //TODO: ensure `c` is required for creation
     interface CreateData extends fields.SchemaField.CreateData<Schema> {}
 
     /**
@@ -186,7 +187,7 @@ declare global {
       c: fields.ArrayField<
         fields.NumberField<{ required: true; integer: true; nullable: false }>,
         {
-          validate: (c: [x0: number, y0: number, x1: number, y1: number]) => boolean;
+          validate: (c: unknown) => c is [x0: number, y0: number, x1: number, y1: number];
           validationError: "must be a length-4 array of integer coordinates";
         },
         // TODO(LukeAbby): Make the array shape easier to override.
@@ -194,6 +195,7 @@ declare global {
         fields.ArrayField.InitializedElementType<
           fields.NumberField<{ required: true; integer: true; nullable: false }>
         >,
+        //FIXME: This field is `required` with no `initial`, so actually required for construction; Currently an AssignmentType override is required to enforce this
         [x0: number, y0: number, x1: number, y1: number],
         [x0: number, y0: number, x1: number, y1: number],
         fields.ArrayField.PersistedElementType<fields.NumberField<{ required: true; integer: true; nullable: false }>>,
@@ -202,85 +204,132 @@ declare global {
 
       /**
        * The illumination restriction type of this wall
-       * @defaultValue `CONST.WALL_SENSE_TYPES.NORMAL`
+       * @defaultValue `CONST.WALL_SENSE_TYPES.NORMAL` (`20`)
        */
-      light: fields.NumberField<{
-        required: true;
-        choices: CONST.WALL_SENSE_TYPES[];
-        initial: typeof CONST.WALL_SENSE_TYPES.NORMAL;
-        validationError: "must be a value in CONST.WALL_SENSE_TYPES";
-      }>;
+      light: fields.NumberField<
+        {
+          required: true;
+          choices: CONST.WALL_SENSE_TYPES[];
+          initial: typeof CONST.WALL_SENSE_TYPES.NORMAL;
+          validationError: "must be a value in CONST.WALL_SENSE_TYPES";
+        },
+        //FIXME: Without these overrides, the branded type from `choices` is not respected, and the field types as `number`
+        CONST.WALL_SENSE_TYPES | null | undefined,
+        CONST.WALL_SENSE_TYPES | null,
+        CONST.WALL_SENSE_TYPES | null
+      >;
 
       /**
        * The movement restriction type of this wall
-       * @defaultValue `CONST.WALL_MOVEMENT_TYPES.NORMAL`
+       * @defaultValue `CONST.WALL_MOVEMENT_TYPES.NORMAL` (`20`)
        */
-      move: fields.NumberField<{
-        required: true;
-        choices: CONST.WALL_MOVEMENT_TYPES[];
-        initial: typeof CONST.WALL_MOVEMENT_TYPES.NORMAL;
-        validationError: "must be a value in CONST.WALL_MOVEMENT_TYPES";
-      }>;
+      move: fields.NumberField<
+        {
+          required: true;
+          choices: CONST.WALL_MOVEMENT_TYPES[];
+          initial: typeof CONST.WALL_MOVEMENT_TYPES.NORMAL;
+          validationError: "must be a value in CONST.WALL_MOVEMENT_TYPES";
+        },
+        //FIXME: Without these overrides, the branded type from `choices` is not respected, and the field types as `number`
+        CONST.WALL_MOVEMENT_TYPES | null | undefined,
+        CONST.WALL_MOVEMENT_TYPES | null,
+        CONST.WALL_MOVEMENT_TYPES | null
+      >;
 
       /**
        * The visual restriction type of this wall
-       * @defaultValue `CONST.WALL_SENSE_TYPES.NORMAL`
+       * @defaultValue `CONST.WALL_SENSE_TYPES.NORMAL` (`20`)
        */
-      sight: fields.NumberField<{
-        required: true;
-        choices: CONST.WALL_SENSE_TYPES[];
-        initial: typeof CONST.WALL_SENSE_TYPES.NORMAL;
-        validationError: "must be a value in CONST.WALL_SENSE_TYPES";
-      }>;
+      sight: fields.NumberField<
+        {
+          required: true;
+          choices: CONST.WALL_SENSE_TYPES[];
+          initial: typeof CONST.WALL_SENSE_TYPES.NORMAL;
+          validationError: "must be a value in CONST.WALL_SENSE_TYPES";
+        },
+        //FIXME: Without these overrides, the branded type from `choices` is not respected, and the field types as `number`
+        CONST.WALL_SENSE_TYPES | null | undefined,
+        CONST.WALL_SENSE_TYPES | null,
+        CONST.WALL_SENSE_TYPES | null
+      >;
 
       /**
        * The auditory restriction type of this wall
-       * @defaultValue `CONST.WALL_SENSE_TYPES.NORMAL`
+       * @defaultValue `CONST.WALL_SENSE_TYPES.NORMAL` (`20`)
        */
-      sound: fields.NumberField<{
-        required: true;
-        choices: CONST.WALL_SENSE_TYPES[];
-        initial: typeof CONST.WALL_SENSE_TYPES.NORMAL;
-        validationError: "must be a value in CONST.WALL_SENSE_TYPES";
-      }>;
+      sound: fields.NumberField<
+        {
+          required: true;
+          choices: CONST.WALL_SENSE_TYPES[];
+          initial: typeof CONST.WALL_SENSE_TYPES.NORMAL;
+          validationError: "must be a value in CONST.WALL_SENSE_TYPES";
+        },
+        //FIXME: Without these overrides, the branded type from `choices` is not respected, and the field types as `number`
+        CONST.WALL_SENSE_TYPES | null | undefined,
+        CONST.WALL_SENSE_TYPES | null,
+        CONST.WALL_SENSE_TYPES | null
+      >;
 
       /**
        * The direction of effect imposed by this wall
-       * @defaultValue `CONST.WALL_DIRECTIONS.BOTH`
+       * @defaultValue `CONST.WALL_DIRECTIONS.BOTH` (`0`)
        */
-      dir: fields.NumberField<{
-        required: true;
-        choices: CONST.WALL_DIRECTIONS[];
-        initial: typeof CONST.WALL_DIRECTIONS.BOTH;
-        validationError: "must be a value in CONST.WALL_DIRECTIONS";
-      }>;
+      dir: fields.NumberField<
+        {
+          required: true;
+          choices: CONST.WALL_DIRECTIONS[];
+          initial: typeof CONST.WALL_DIRECTIONS.BOTH;
+          validationError: "must be a value in CONST.WALL_DIRECTIONS";
+        },
+        //FIXME: Without these overrides, the branded type from `choices` is not respected, and the field types as `number`
+        CONST.WALL_DIRECTIONS | null | undefined,
+        CONST.WALL_DIRECTIONS | null,
+        CONST.WALL_DIRECTIONS | null
+      >;
 
       /**
        * The type of door which this wall contains, if any
-       * @defaultValue `CONST.WALL_DOOR_TYPES.NONE`
+       * @defaultValue `CONST.WALL_DOOR_TYPES.NONE` (`0`)
        */
-      door: fields.NumberField<{
-        required: true;
-        choices: CONST.WALL_DOOR_TYPES[];
-        initial: typeof CONST.WALL_DOOR_TYPES.NONE;
-        validationError: "must be a value in CONST.WALL_DOOR_TYPES";
-      }>;
+      door: fields.NumberField<
+        {
+          required: true;
+          choices: CONST.WALL_DOOR_TYPES[];
+          initial: typeof CONST.WALL_DOOR_TYPES.NONE;
+          validationError: "must be a value in CONST.WALL_DOOR_TYPES";
+        },
+        //FIXME: Without these overrides, the branded type from `choices` is not respected, and the field types as `number`
+        CONST.WALL_DOOR_TYPES | null | undefined,
+        CONST.WALL_DOOR_TYPES | null,
+        CONST.WALL_DOOR_TYPES | null
+      >;
 
       /**
        * The state of the door this wall contains, if any
-       * @defaultValue `CONST.WALL_DOOR_STATES.CLOSED`
+       * @defaultValue `CONST.WALL_DOOR_STATES.CLOSED` (`0`)
        */
-      ds: fields.NumberField<{
-        required: true;
-        choices: CONST.WALL_DOOR_STATES[];
-        initial: typeof CONST.WALL_DOOR_STATES.CLOSED;
-        validationError: "must be a value in CONST.WALL_DOOR_STATES";
-      }>;
+      ds: fields.NumberField<
+        {
+          required: true;
+          choices: CONST.WALL_DOOR_STATES[];
+          initial: typeof CONST.WALL_DOOR_STATES.CLOSED;
+          validationError: "must be a value in CONST.WALL_DOOR_STATES";
+        },
+        //FIXME: Without these overrides, the branded type from `choices` is not respected, and the field types as `number`
+        CONST.WALL_DOOR_STATES | null | undefined,
+        CONST.WALL_DOOR_STATES | null,
+        CONST.WALL_DOOR_STATES | null
+      >;
 
+      /**
+       * @remarks TThis isn't enforced by the field, but should be in `keyof CONFIG.Wall.doorSounds`
+       * @defaultValue `undefined`
+       */
       doorSound: fields.StringField<{ required: false; blank: true; initial: undefined }>;
 
       /**
        * Configuration of threshold data for this wall
+       * @defaultValue see properties
        */
       threshold: fields.SchemaField<ThresholdSchema>;
 
diff --git a/src/foundry/common/abstract/data.d.mts b/src/foundry/common/abstract/data.d.mts
index 60ed472ff..d79da1e16 100644
--- a/src/foundry/common/abstract/data.d.mts
+++ b/src/foundry/common/abstract/data.d.mts
@@ -271,6 +271,7 @@ declare abstract class DataModel<
    * @param options - Additional shimming options
    * @returns Data with added backwards-compatible properties
    */
+  // options: not null (destructured)
   static shimData(data: AnyMutableObject, options?: DataModel.ShimDataOptions): AnyMutableObject;
 }
 
diff --git a/src/foundry/common/abstract/document.d.mts b/src/foundry/common/abstract/document.d.mts
index e984759a8..3dd790c81 100644
--- a/src/foundry/common/abstract/document.d.mts
+++ b/src/foundry/common/abstract/document.d.mts
@@ -227,16 +227,11 @@ declare abstract class Document<
    * @param options    - Additional options involved in the permission test
    * @returns Does the user have this permission level over the Document?
    */
+  // options: not null (destructured)
   testUserPermission(
     user: User.Internal.Implementation,
-    permission: keyof typeof CONST.DOCUMENT_OWNERSHIP_LEVELS | CONST.DOCUMENT_OWNERSHIP_LEVELS,
-    options?: InexactPartial<{
-      /**
-       * Require the exact permission level requested?
-       * @defaultValue `false`
-       */
-      exact: boolean;
-    }>,
+    permission: Document.TestableOwnershipLevel,
+    options?: Document.TestUserPermissionOptions,
   ): boolean;
 
   /**
@@ -1278,7 +1273,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<
@@ -1713,13 +1708,18 @@ declare namespace Document {
     extends ConstructionContext<Parent>,
       DataModel.DataValidationOptions<Parent> {}
 
-  interface TestUserPermissionOptions {
+  type TestableOwnershipLevel = keyof typeof CONST.DOCUMENT_OWNERSHIP_LEVELS | CONST.DOCUMENT_OWNERSHIP_LEVELS;
+
+  /** @internal */
+  type _TestUserPermissionsOptions = NullishProps<{
     /**
      * Require the exact permission level requested?
      * @defaultValue `false`
      */
-    exact?: boolean | undefined;
-  }
+    exact: boolean;
+  }>;
+
+  interface TestUserPermissionOptions extends _TestUserPermissionsOptions {}
 
   /**
    * @deprecated {@link ImplementationFor | `ImplementationInstanceFor`}
diff --git a/src/foundry/common/data/data.d.mts b/src/foundry/common/data/data.d.mts
index 2e153e13b..13ccdb2f3 100644
--- a/src/foundry/common/data/data.d.mts
+++ b/src/foundry/common/data/data.d.mts
@@ -1,18 +1,18 @@
-import type { DatabaseBackend } from "../abstract/module.d.mts";
 import type { DataModel } from "../abstract/data.d.mts";
-import type { fields } from "./module.d.mts";
-import type * as documents from "../documents/_module.d.mts";
-import type { AnyMutableObject, EmptyObject, RemoveIndexSignatures, ToMethod, ValueOf } from "fvtt-types/utils";
-import type { FilePathField } from "./fields.d.mts";
+import type {
+  AnyMutableObject,
+  EmptyObject,
+  GetKey,
+  NullishCoalesce,
+  RemoveIndexSignatures,
+  ToMethod,
+  ValueOf,
+} from "fvtt-types/utils";
+import fields = foundry.data.fields;
+import documents = foundry.documents;
 
 type DataSchema = foundry.data.fields.DataSchema;
 
-// TODO: Implement all of the necessary options
-
-declare global {
-  type LightAnimationData = fields.SchemaField.InitializedData<LightData.LightAnimationDataSchema>;
-}
-
 declare namespace LightData {
   type Parent = TokenDocument | AmbientLightDocument;
 
@@ -20,6 +20,8 @@ declare namespace LightData {
     /**
      * The animation type which is applied
      * @defaultValue `null`
+     * @remarks While not enforced by the data model, this should be in `keyof CONFIG.Canvas.lightAnimations`
+     * (or `.darknessAnimations` as appropriate) or the animation will be ignored
      */
     type: fields.StringField<{ nullable: true; blank: false; initial: null }>;
 
@@ -62,12 +64,12 @@ declare namespace LightData {
     /**
      * @defaultValue `0`
      */
-    min: fields.NumberField<{ initial: 0 }>;
+    min: fields.AlphaField<{ initial: 0 }>;
 
     /**
      * @defaultValue `1`
      */
-    max: fields.NumberField<{ initial: 1 }>;
+    max: fields.AlphaField<{ initial: 1 }>;
   }
 
   interface Schema extends DataSchema {
@@ -109,6 +111,7 @@ declare namespace LightData {
     /**
      * The coloration technique applied in the shader
      * @defaultValue `1`
+     * @remarks This should match the `id` of the desired property of {@link AdaptiveLightingShader.SHADER_TECHNIQUES | `AdaptiveLightingShader.SHADER_TECHNIQUES`}
      */
     coloration: fields.NumberField<{ required: true; integer: true; initial: 1 }>;
 
@@ -161,7 +164,7 @@ declare namespace LightData {
     darkness: fields.SchemaField<
       DarknessSchema,
       {
-        validate: (d: fields.SchemaField.AssignmentData<DarknessSchema>) => boolean;
+        validate: (d: unknown) => boolean;
         validationError: "darkness.max may not be less than darkness.min";
       }
     >;
@@ -175,12 +178,10 @@ declare namespace LightData {
 declare class LightData extends DataModel<LightData.Schema, LightData.Parent> {
   static override defineSchema(): LightData.Schema;
 
-  /**
-   * @defaultValue `["LIGHT"]`
-   */
+  /** @defaultValue `["LIGHT"]` */
   static override LOCALIZATION_PREFIXES: string[];
 
-  static migrateData(source: AnyMutableObject): AnyMutableObject;
+  static override migrateData(source: AnyMutableObject): AnyMutableObject;
 }
 
 declare namespace ShapeData {
@@ -433,79 +434,157 @@ declare class PolygonShapeData extends BaseShapeData<PolygonShapeData.Schema> {
 }
 
 declare namespace TextureData {
+  /** The parameter defaults for `srcOptions` in the {@link TextureData} constructor */
   interface DefaultOptions {
     categories: ["IMAGE", "VIDEO"];
-    // initial: {};
+    initial: EmptyObject;
     wildcard: false;
     label: "";
   }
 
-  interface Schema<SrcOptions extends FilePathField.Options> extends DataSchema {
+  /**
+   * @internal
+   * The `initial` property of the `srcOptions` parameter of the {@link TextureData | `TextureData`} constructor
+   * is not the `initial` for any one field, but instead is an object that gets parcelled out by key to the
+   * fields of the schema
+   */
+  type _SrcOptionsInitial<T> = {
+    [K in keyof T]: fields.DataField.Options.InitialType<T[K]>;
+  };
+
+  /** @remarks The keys picked directly are passed on to the `src: FilePathField` field, but `initial` is an object of initial values for potentially every field in the schema */
+  interface SrcOptions extends Pick<fields.FilePathField.Options, "categories" | "wildcard" | "label"> {
+    initial: _SrcOptionsInitial<fields.SchemaField.AssignmentData<Schema<DefaultOptions>>>;
+  }
+
+  interface Schema<Options extends SrcOptions = DefaultOptions> extends DataSchema {
     /**
      * The URL of the texture source.
      * @defaultValue `initial.src ?? null`
-     */
-    src: fields.FilePathField<SrcOptions>;
+     * @remarks The `initial` in the above default value is the property from the `srcOptions`
+     * parameter of the {@link TextureData | `TextureData`} constructor
+     */
+    src: fields.FilePathField<{
+      categories: NullishCoalesce<Options["categories"], DefaultOptions["categories"]>;
+      initial: NullishCoalesce<GetKey<Options["initial"], "src", null>, null>;
+      wildcard: NullishCoalesce<Options["wildcard"], DefaultOptions["wildcard"]>;
+      label: NullishCoalesce<Options["label"], DefaultOptions["label"]>;
+    }>;
 
     /**
      * The X coordinate of the texture anchor.
      * @defaultValue `initial.anchorX ?? 0`
+     * @remarks The `initial` in the above default value is the property from the `srcOptions`
+     * parameter of the {@link TextureData | `TextureData`} constructor
      */
-    anchorX: fields.NumberField<{ nullable: false; initial: number }>;
+    anchorX: fields.NumberField<{
+      nullable: false;
+      initial: NullishCoalesce<GetKey<Options["initial"], "anchorX", 0>, 0>;
+    }>;
 
     /**
      * The Y coordinate of the texture anchor.
      * @defaultValue `initial.anchorY ?? 0`
+     * @remarks The `initial` in the above default value is the property from the `srcOptions`
+     * parameter of the {@link TextureData | `TextureData`} constructor
      */
-    anchorY: fields.NumberField<{ nullable: false; initial: number }>;
+    anchorY: fields.NumberField<{
+      nullable: false;
+      initial: NullishCoalesce<GetKey<Options["initial"], "anchorY", 0>, 0>;
+    }>;
 
     /**
      * The X offset of the texture with (0,0) in the top left.
      * @defaultValue `initial.offsetX ?? 0`
+     * @remarks The `initial` in the above default value is the property from the `srcOptions`
+     * parameter of the {@link TextureData | `TextureData`} constructor
      */
-    offsetX: fields.NumberField<{ nullable: false; integer: true; initial: number }>;
+    offsetX: fields.NumberField<{
+      nullable: false;
+      integer: true;
+      initial: NullishCoalesce<GetKey<Options["initial"], "offsetX", 0>, 0>;
+    }>;
 
     /**
      * The Y offset of the texture with (0,0) in the top left.
      * @defaultValue `initial.offsetY ?? 0`
+     * @remarks The `initial` in the above default value is the property from the `srcOptions`
+     * parameter of the {@link TextureData | `TextureData`} constructor
      */
-    offsetY: fields.NumberField<{ nullable: false; integer: true; initial: number }>;
+    offsetY: fields.NumberField<{
+      nullable: false;
+      integer: true;
+      initial: NullishCoalesce<GetKey<Options["initial"], "offsetY", 0>, 0>;
+    }>;
 
     /**
      * @defaultValue `initial.fit ?? "fill"`
+     * @remarks The `initial` in the above default value is the property from the `srcOptions`
+     * parameter of the {@link TextureData | `TextureData`} constructor
      */
-    fit: fields.StringField<{ initial: string; choices: typeof CONST.TEXTURE_DATA_FIT_MODES }>;
+    fit: fields.StringField<
+      {
+        initial: NullishCoalesce<GetKey<Options["initial"], "fit", "fill">, "fill">;
+        choices: typeof CONST.TEXTURE_DATA_FIT_MODES;
+      },
+      ValueOf<typeof CONST.TEXTURE_DATA_FIT_MODES> | null | undefined,
+      ValueOf<typeof CONST.TEXTURE_DATA_FIT_MODES>,
+      ValueOf<typeof CONST.TEXTURE_DATA_FIT_MODES>
+    >;
 
     /**
      * The scale of the texture in the X dimension.
      * @defaultValue `initial.scaleX ?? 1`
+     * @remarks The `initial` in the above default value is the property from the `srcOptions`
+     * parameter of the {@link TextureData | `TextureData`} constructor
      */
-    scaleX: fields.NumberField<{ nullable: false; initial: number }>;
+    scaleX: fields.NumberField<{
+      nullable: false;
+      initial: NullishCoalesce<GetKey<Options["initial"], "scaleX", 1>, 1>;
+    }>;
 
     /**
      * The scale of the texture in the Y dimension.
      * @defaultValue `initial.scaleY ?? 1`
+     * @remarks The `initial` in the above default value is the property from the `srcOptions`
+     * parameter of the {@link TextureData | `TextureData`} constructor
      */
-    scaleY: fields.NumberField<{ nullable: false; initial: number }>;
+    scaleY: fields.NumberField<{
+      nullable: false;
+      initial: NullishCoalesce<GetKey<Options["initial"], "scaleY", 1>, 1>;
+    }>;
 
     /**
      * An angle of rotation by which this texture is rotated around its center.
      * @defaultValue `initial.rotation ?? 0`
+     * @remarks The `initial` in the above default value is the property from the `srcOptions`
+     * parameter of the {@link TextureData | `TextureData`} constructor
      */
-    rotation: fields.AngleField<{ initial: number }>;
+    rotation: fields.AngleField<{
+      initial: NullishCoalesce<GetKey<Options["initial"], "rotation", 0>, 0>;
+    }>;
 
     /**
      * The tint applied to the texture.
      * @defaultValue `initial.tint ?? "#ffffff"`
+     * @remarks The `initial` in the above default value is the property from the `srcOptions`
+     * parameter of the {@link TextureData | `TextureData`} constructor
      */
-    tint: fields.ColorField<{ nullable: false; initial: string }>;
-
+    tint: fields.ColorField<{
+      nullable: false;
+      initial: NullishCoalesce<GetKey<Options["initial"], "tint", "#ffffff">, "#ffffff">;
+    }>;
     /**
      * Only pixels with an alpha value at or above this value are consider solid
      * w.r.t. to occlusion testing and light/weather blocking.
      * @defaultValue `initial.alphaThreshold ?? 0`
+     * @remarks The `initial` in the above default value is the property from the `srcOptions`
+     * parameter of the {@link TextureData | `TextureData`} constructor
      */
-    alphaThreshold: fields.AlphaField<{ nullable: false; initial: number }>;
+    alphaThreshold: fields.AlphaField<{
+      nullable: false;
+      initial: NullishCoalesce<GetKey<Options["initial"], "alphaThreshold", 0>, 0>;
+    }>;
   }
 }
 
@@ -513,7 +592,7 @@ declare namespace TextureData {
  * A {@link fields.SchemaField | `fields.SchemaField`} subclass used to represent texture data.
  */
 declare class TextureData<
-  SrcOptions extends FilePathField.Options = TextureData.DefaultOptions,
+  SrcOptions extends TextureData.SrcOptions = TextureData.DefaultOptions,
   SchemaOptions extends fields.SchemaField.Options<TextureData.Schema<SrcOptions>> = EmptyObject,
 > extends fields.SchemaField<TextureData.Schema<SrcOptions>, SchemaOptions> {
   /**
@@ -526,7 +605,10 @@ declare class TextureData<
 declare namespace PrototypeToken {
   type Parent = documents.BaseActor;
 
-  // Not otherwise used
+  /**
+   * @internal
+   * The fields foundry omits from the BaseToken schema. Not used, left as reference
+   */
   type ExcludedProperties =
     | "_id"
     | "actorId"
@@ -539,12 +621,24 @@ declare namespace PrototypeToken {
     | "locked"
     | "_regions";
 
+  /**
+   * @remarks This has `PrototypeToken.#applyDefaultTokenSettings` run on it before actually being returned, so `initial`
+   * values may not be exactly accurate as typed
+   * @privateRemarks Since the {@link TokenDocument.Schema | `TokenDocument` schema} also extends `SharedProtoSchema`,
+   * overrides & extensions specific to {@link PrototypeToken | `PrototypeToken`} must go here
+   */
   interface Schema extends TokenDocument.SharedProtoSchema {
-    name: fields.StringField<{ required: true; blank: true; textSearch: boolean }>;
+    /**
+     * The name used to describe the Token
+     * @defaultValue `""`
+     * @privateRemarks Only change from parent schema is `textSearch: false`
+     */
+    name: fields.StringField<{ required: true; blank: true; textSearch: false }>;
 
     /**
      * Does the prototype token use a random wildcard image?
      * @defaultValue `false`
+     * @privateRemarks New field, not in parent schema
      */
     randomImg: fields.BooleanField;
   }
@@ -560,13 +654,18 @@ declare namespace PrototypeToken {
 /**
  * Extend the base TokenData to define a PrototypeToken which exists within a parent Actor.
  */
-declare class PrototypeToken extends DataModel<PrototypeToken.Schema, any> {
-  constructor(data?: PrototypeToken.ConstructorData, options?: DataModel.DataValidationOptions<PrototypeToken.Parent>);
-
-  declare parent: PrototypeToken.Parent;
+declare class PrototypeToken extends DataModel<PrototypeToken.Schema, PrototypeToken.Parent> {
+  // options: not null (destructured when passed to super)
+  constructor(
+    data?: PrototypeToken.ConstructorData | null,
+    options?: DataModel.DataValidationOptions<PrototypeToken.Parent>,
+  );
 
-  /** @defaultValue `{}` */
-  apps: Record<string, Application.Any>;
+  /**
+   * @defaultValue `{}`
+   * @remarks Created via `defineProperty` in constructor
+   */
+  apps: Record<string, Application.Any | foundry.applications.api.ApplicationV2.Any>;
 
   static override defineSchema(): PrototypeToken.Schema;
 
@@ -581,9 +680,9 @@ declare class PrototypeToken extends DataModel<PrototypeToken.Schema, any> {
   get actor(): this["parent"];
 
   override toObject(source: true): this["_source"] & { actorId: string | undefined };
-  override toObject(source?: boolean): ReturnType<this["schema"]["toObject"]>;
+  override toObject(source?: boolean): ReturnType<this["schema"]["toObject"]> & { actorId: string | undefined };
 
-  static get database(): DatabaseBackend;
+  static get database(): CONFIG["DatabaseBackend"];
 
   /**
    * Apply configured default token settings to the schema.
@@ -647,7 +746,7 @@ declare namespace TombstoneData {
      */
     _tombstone: fields.BooleanField<{
       initial: true;
-      validate: (v: boolean) => boolean;
+      validate: (v: unknown) => boolean;
       validationError: "must be true";
     }>;
   }
diff --git a/src/foundry/common/data/fields.d.mts b/src/foundry/common/data/fields.d.mts
index eb9916a9b..b333c8388 100644
--- a/src/foundry/common/data/fields.d.mts
+++ b/src/foundry/common/data/fields.d.mts
@@ -815,7 +815,7 @@ declare class SchemaField<
 }
 
 // FIXME(LukeAbby): This is a quick patch that avoids issues with the fact that the `initial` in `SchemaField` is not actually assignable to its assignment type etc.
-// This will be superceded once proper field treatment is applied.
+// This will be superseded once proper field treatment is applied.
 declare const __SchemaFieldInitialSymbol: unique symbol;
 
 type __SchemaFieldInitial = typeof __SchemaFieldInitialSymbol;
diff --git a/src/foundry/common/documents/ambient-light.d.mts b/src/foundry/common/documents/ambient-light.d.mts
index c4a8ccf04..05af79059 100644
--- a/src/foundry/common/documents/ambient-light.d.mts
+++ b/src/foundry/common/documents/ambient-light.d.mts
@@ -1,4 +1,3 @@
-import type { AnyMutableObject } from "fvtt-types/utils";
 import type DataModel from "../abstract/data.d.mts";
 import type Document from "../abstract/document.mts";
 import type { SchemaField } from "../data/fields.d.mts";
@@ -24,16 +23,29 @@ declare abstract class BaseAmbientLight extends Document<"AmbientLight", BaseAmb
    */
   constructor(...args: Document.ConstructorParameters<BaseAmbientLight.CreateData, BaseAmbientLight.Parent>);
 
+  /**
+   * @defaultValue
+   * ```js
+   * mergeObject(super.metadata, {
+   *   name: "AmbientLight",
+   *   collection: "lights",
+   *   label: "DOCUMENT.AmbientLight",
+   *   labelPlural: "DOCUMENT.AmbientLights",
+   *   schemaVersion: "12.324",
+   * })
+   * ```
+   */
   static override metadata: BaseAmbientLight.Metadata;
 
   static override defineSchema(): BaseAmbientLight.Schema;
 
-  static override migrateData(source: AnyMutableObject): AnyMutableObject;
+  /** @defaultValue `["AMBIENT_SOUND"]` */
+  static override LOCALIZATION_PREFIXES: string[];
 
   /*
    * After this point these are not really overridden methods.
    * They are here because they're static properties but depend on the instance and so can't be
-   * defined DRY-ly while also being easily overrideable.
+   * defined DRY-ly while also being easily overridable.
    */
 
   static " fvtt_types_internal_document_name_static": "AmbientLight";
diff --git a/src/foundry/common/documents/ambient-sound.d.mts b/src/foundry/common/documents/ambient-sound.d.mts
index 200b99e42..e9d50ef8d 100644
--- a/src/foundry/common/documents/ambient-sound.d.mts
+++ b/src/foundry/common/documents/ambient-sound.d.mts
@@ -1,4 +1,3 @@
-import type { AnyMutableObject } from "fvtt-types/utils";
 import type DataModel from "../abstract/data.d.mts";
 import type Document from "../abstract/document.mts";
 import type { SchemaField } from "../data/fields.d.mts";
@@ -24,16 +23,30 @@ declare abstract class BaseAmbientSound extends Document<"AmbientSound", BaseAmb
    */
   constructor(...args: Document.ConstructorParameters<BaseAmbientSound.CreateData, BaseAmbientSound.Parent>);
 
+  /**
+   * @defaultValue
+   * ```js
+   * mergeObject(super.metadata, {
+   *   name: "AmbientSound",
+   *   collection: "sounds",
+   *   label: "DOCUMENT.AmbientSound",
+   *   labelPlural: "DOCUMENT.AmbientSounds",
+   *   isEmbedded: true,
+   *   schemaVersion: "12.324"
+   * })
+   * ```
+   */
   static override metadata: AmbientSoundDocument.Metadata;
 
   static override defineSchema(): BaseAmbientSound.Schema;
 
-  static override migrateData(source: AnyMutableObject): AnyMutableObject;
+  /** @defaultValue `["AMBIENT_SOUND"]` */
+  static override LOCALIZATION_PREFIXES: string[];
 
   /*
    * After this point these are not really overridden methods.
    * They are here because they're static properties but depend on the instance and so can't be
-   * defined DRY-ly while also being easily overrideable.
+   * defined DRY-ly while also being easily overridable.
    */
 
   static " fvtt_types_internal_document_name_static": "AmbientLight";
diff --git a/src/foundry/common/documents/drawing.d.mts b/src/foundry/common/documents/drawing.d.mts
index 84dbde477..8ef6c71e0 100644
--- a/src/foundry/common/documents/drawing.d.mts
+++ b/src/foundry/common/documents/drawing.d.mts
@@ -1,7 +1,6 @@
-import type { AnyObject, AnyMutableObject, InexactPartial } from "fvtt-types/utils";
+import type { AnyMutableObject } from "fvtt-types/utils";
 import type DataModel from "../abstract/data.d.mts";
 import type Document from "../abstract/document.mts";
-import type * as CONST from "../constants.mts";
 import type { SchemaField } from "../data/fields.d.mts";
 
 /**
@@ -25,47 +24,54 @@ declare abstract class BaseDrawing extends Document<"Drawing", BaseDrawing.Schem
    */
   constructor(...args: Document.ConstructorParameters<BaseDrawing.CreateData, BaseDrawing.Parent>);
 
+  /**
+   * @defaultValue
+   * ```js
+   * mergeObject(super.metadata, {
+   *   name: "Drawing",
+   *   collection: "drawings",
+   *   label: "DOCUMENT.Drawing",
+   *   labelPlural: "DOCUMENT.Drawings",
+   *   isEmbedded: true,
+   *   permissions: {
+   *     create: this.#canCreate,
+   *     update: this.#canUpdate
+   *   },
+   *   schemaVersion: "12.324"
+   * })
+   * ```
+   */
   static override metadata: BaseDrawing.Metadata;
 
   static override defineSchema(): BaseDrawing.Schema;
 
-  /**
-   * Validate whether the drawing has some visible content (as required by validation).
-   */
-  static #validateVisibleContent(data: BaseDrawing.UpdateData): boolean;
-
-  /**
-   * Is a user able to update or delete an existing Drawing document??
-   * @internal
-   */
-  static #canModify(user: User.Implementation, doc: BaseDrawing, data: BaseDrawing.UpdateData): boolean;
+  static override canUserCreate(user: User.Internal.Implementation): boolean;
 
+  // options: not null (destructured)
   override testUserPermission(
-    user: User.Implementation,
-    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.TestableOwnershipLevel,
+    options?: Document.TestUserPermissionOptions,
   ): boolean;
 
-  static override cleanData(source?: AnyObject, options?: foundry.data.fields.DataField.CleanOptions): AnyObject;
-
+  /**
+   * @remarks Migrates:
+   * - `z` to `elevation`
+   */
   static override migrateData(source: AnyMutableObject): AnyMutableObject;
 
-  static override shimData(
-    data: AnyObject,
-    options?: {
-      /**
-       * Apply shims to embedded models?
-       * @defaultValue `true`
-       */
-      embedded?: boolean;
-    },
-  ): AnyObject;
+  /**
+   * @remarks Shims:
+   * - `z` to `elevation` since v12, until v14
+   */
+  // options: not null (destructured)
+  static override shimData(data: AnyMutableObject, options?: DataModel.ShimDataOptions): AnyMutableObject;
+
+  /**
+   * @deprecated since v12, until v14
+   * @remarks "You are accessing `z` which has been migrated to `elevation`"
+   */
+  get z(): this["elevation"];
 
   /*
    * After this point these are not really overridden methods.
diff --git a/src/foundry/common/documents/measured-template.d.mts b/src/foundry/common/documents/measured-template.d.mts
index 6baca9a56..ac4cf9ea4 100644
--- a/src/foundry/common/documents/measured-template.d.mts
+++ b/src/foundry/common/documents/measured-template.d.mts
@@ -1,4 +1,4 @@
-import type { InexactPartial } from "fvtt-types/utils";
+import type { AnyMutableObject } from "fvtt-types/utils";
 import type DataModel from "../abstract/data.d.mts";
 import type Document from "../abstract/document.mts";
 import type { SchemaField } from "../data/fields.d.mts";
@@ -24,43 +24,52 @@ declare abstract class BaseMeasuredTemplate extends Document<"MeasuredTemplate",
    */
   constructor(...args: Document.ConstructorParameters<BaseMeasuredTemplate.CreateData, BaseMeasuredTemplate.Parent>);
 
+  /**
+   * @defaultValue
+   * ```js
+   * mergeObject(super.metadata, {
+   *   name: "MeasuredTemplate",
+   *   collection: "templates",
+   *   label: "DOCUMENT.MeasuredTemplate",
+   *   labelPlural: "DOCUMENT.MeasuredTemplates",
+   *   isEmbedded: true,
+   *   permissions: {
+   *     create: this.#canCreate,
+   *     update: this.#canUpdate
+   *   },
+   *   schemaVersion: "12.324"
+   * })
+   * ```
+   */
   static override metadata: BaseMeasuredTemplate.Metadata;
 
   static override defineSchema(): BaseMeasuredTemplate.Schema;
 
+  // options: not null (destructured)
+  override testUserPermission(
+    user: User.Internal.Implementation,
+    permission: Document.TestableOwnershipLevel,
+    options?: Document.TestUserPermissionOptions,
+  ): boolean;
+
   /**
-   * Is a user able to create a new MeasuredTemplate?
-   * @param user - The user attempting the creation operation.
-   * @param doc  - The MeasuredTemplate being created.
-   * @internal
+   * @remarks Migrates:
+   * - `user` to `author`
    */
-  static #canCreate(user: User.Implementation, doc: BaseMeasuredTemplate): boolean;
+  static override migrateData(source: AnyMutableObject): AnyMutableObject;
 
   /**
-   * Is a user able to modify an existing MeasuredTemplate?
-   * @param user - The user attempting the modification.
-   * @param doc  - The MeasuredTemplate being modified.
-   * @param data - Data being changed.
-   * @internal
+   * @remarks Shims:
+   * - `user` to `author` since v12, until v14
    */
-  static #canModify(
-    user: User.Implementation,
-    doc: BaseMeasuredTemplate,
-    data?: BaseMeasuredTemplate.UpdateData,
-  ): boolean;
-
-  override testUserPermission(
-    user: User.Implementation,
-    permission: keyof typeof CONST.DOCUMENT_OWNERSHIP_LEVELS | foundry.CONST.DOCUMENT_OWNERSHIP_LEVELS,
-    options?: InexactPartial<{
-      /**
-       * Require the exact permission level requested?
-       * @defaultValue `false`
-       */
-      exact: boolean;
-    }>,
-  ): boolean;
+  // options: not null (destructured)
+  static override shimData(data: AnyMutableObject, options?: DataModel.ShimDataOptions): AnyMutableObject;
 
+  /**
+   * @deprecated since v12, until 14
+   * @remarks "You are accessing `user` which has been migrated to `author`"
+   */
+  get user(): this["author"];
   /*
    * After this point these are not really overridden methods.
    * They are here because they're static properties but depend on the instance and so can't be
diff --git a/src/foundry/common/documents/note.d.mts b/src/foundry/common/documents/note.d.mts
index 00995340a..eeaaac80d 100644
--- a/src/foundry/common/documents/note.d.mts
+++ b/src/foundry/common/documents/note.d.mts
@@ -1,4 +1,3 @@
-import type { AnyObject, AnyMutableObject, InexactPartial } from "fvtt-types/utils";
 import type DataModel from "../abstract/data.d.mts";
 import type Document from "../abstract/document.mts";
 import type { SchemaField } from "../data/fields.d.mts";
@@ -24,6 +23,21 @@ declare abstract class BaseNote extends Document<"Note", BaseNote.Schema, any> {
    */
   constructor(...args: Document.ConstructorParameters<BaseNote.CreateData, BaseNote.Parent>);
 
+  /**
+   * @defaultValue
+   * ```js
+   * mergeObject(super.metadata, {
+   *   name: "Note",
+   *   collection: "notes",
+   *   label: "DOCUMENT.Note",
+   *   labelPlural: "DOCUMENT.Notes",
+   *   permissions: {
+   *     create: "NOTE_CREATE"
+   *   },
+   *   schemaVersion: "12.324"
+   * })
+   * ```
+   */
   static override metadata: BaseNote.Metadata;
 
   static override defineSchema(): BaseNote.Schema;
@@ -35,30 +49,11 @@ declare abstract class BaseNote extends Document<"Note", BaseNote.Schema, any> {
   static DEFAULT_ICON: string;
 
   override testUserPermission(
-    user: User.Implementation,
-    permission: keyof typeof CONST.DOCUMENT_OWNERSHIP_LEVELS | foundry.CONST.DOCUMENT_OWNERSHIP_LEVELS,
-    options?: InexactPartial<{
-      /**
-       * Require the exact permission level requested?
-       * @defaultValue `false`
-       */
-      exact: boolean;
-    }>,
+    user: User.Internal.Implementation,
+    permission: Document.TestableOwnershipLevel,
+    options?: Document.TestUserPermissionOptions,
   ): boolean;
 
-  static override migrateData(source: AnyMutableObject): AnyMutableObject;
-
-  static override shimData(
-    data: AnyObject,
-    options?: {
-      /**
-       * Apply shims to embedded models?
-       * @defaultValue `true`
-       */
-      embedded?: boolean;
-    },
-  ): AnyObject;
-
   /*
    * After this point these are not really overridden methods.
    * They are here because they're static properties but depend on the instance and so can't be
diff --git a/src/foundry/common/documents/region-behavior.d.mts b/src/foundry/common/documents/region-behavior.d.mts
index 1b2c219df..42b240d33 100644
--- a/src/foundry/common/documents/region-behavior.d.mts
+++ b/src/foundry/common/documents/region-behavior.d.mts
@@ -24,11 +24,39 @@ declare abstract class BaseRegionBehavior<
    */
   constructor(...args: Document.ConstructorParameters<BaseRegionBehavior.CreateData, BaseRegionBehavior.Parent>);
 
+  /**
+   * @defaultValue
+   * ```js
+   * mergeObject(super.metadata, {
+   *   name: "RegionBehavior",
+   *   collection: "behaviors",
+   *   label: "DOCUMENT.RegionBehavior",
+   *   labelPlural: "DOCUMENT.RegionBehaviors",
+   *   coreTypes: [
+   *     "adjustDarknessLevel",
+   *     "displayScrollingText",
+   *     "executeMacro",
+   *     "executeScript",
+   *     "pauseGame",
+   *     "suppressWeather",
+   *     "teleportToken",
+   *     "toggleBehavior"
+   *   ],
+   *   hasTypeData: true,
+   *   isEmbedded: true,
+   *   permissions: {
+   *     create: this.#canCreate,
+   *     update: this.#canUpdate
+   *   },
+   *   schemaVersion: "12.324"
+   * })
+   * ```
+   */
   static override metadata: BaseRegionBehavior.Metadata;
 
   static override defineSchema(): BaseRegionBehavior.Schema;
 
-  static override canUserCreate(user: User.Implementation): boolean;
+  static override canUserCreate(user: User.Internal.Implementation): boolean;
 
   /*
    * After this point these are not really overridden methods.
diff --git a/src/foundry/common/documents/region.d.mts b/src/foundry/common/documents/region.d.mts
index 5b60e2947..9f91caf7d 100644
--- a/src/foundry/common/documents/region.d.mts
+++ b/src/foundry/common/documents/region.d.mts
@@ -20,6 +20,22 @@ declare abstract class BaseRegion extends Document<"Region", BaseRegion.Schema,
    */
   constructor(...args: Document.ConstructorParameters<BaseRegion.CreateData, BaseRegion.Parent>);
 
+  /**
+   * @defaultValue
+   * ```js
+   * mergeObject(super.metadata, {
+   *   name: "Region",
+   *   collection: "regions",
+   *   label: "DOCUMENT.Region",
+   *   labelPlural: "DOCUMENT.Regions",
+   *   isEmbedded: true,
+   *   embedded: {
+   *     RegionBehavior: "behaviors"
+   *   },
+   *   schemaVersion: "12.324"
+   * }
+   * ```
+   */
   static override metadata: BaseRegion.Metadata;
 
   static override defineSchema(): BaseRegion.Schema;
diff --git a/src/foundry/common/documents/tile.d.mts b/src/foundry/common/documents/tile.d.mts
index 8f475e64e..1112cab3b 100644
--- a/src/foundry/common/documents/tile.d.mts
+++ b/src/foundry/common/documents/tile.d.mts
@@ -1,4 +1,4 @@
-import type { AnyObject, AnyMutableObject } from "fvtt-types/utils";
+import type { AnyMutableObject, AnyObject } from "fvtt-types/utils";
 import type DataModel from "../abstract/data.d.mts";
 import type Document from "../abstract/document.mts";
 import type { DataField, SchemaField } from "../data/fields.d.mts";
@@ -23,24 +23,60 @@ declare abstract class BaseTile extends Document<"Tile", BaseTile.Schema, any> {
    * You should use {@link TileDocument.implementation | `new TileDocument.implementation(...)`} instead which will give you
    * a system specific implementation of `TileDocument`.
    */
-  constructor(...args: WallDocument.ConstructorArgs);
+  constructor(...args: TileDocument.ConstructorArgs);
 
+  /**
+   * @defaultValue
+   * ```js
+   * mergeObject(super.metadata, {
+   *   name: "Tile",
+   *   collection: "tiles",
+   *   label: "DOCUMENT.Tile",
+   *   labelPlural: "DOCUMENT.Tiles",
+   *   schemaVersion: "12.324"
+   * })
+   * ```
+   */
   static override metadata: BaseTile.Metadata;
 
   static override defineSchema(): BaseTile.Schema;
 
+  /**
+   * @remarks Migrates:
+   * - `z` to `sort`
+   * - `roof` to `restrictions.light` and `restrictions.weather`
+   */
   static override migrateData(source: AnyMutableObject): AnyMutableObject;
 
-  static override shimData(
-    data: AnyObject,
-    options?: {
-      /**
-       * Apply shims to embedded models?
-       * @defaultValue `true`
-       */
-      embedded?: boolean;
-    },
-  ): AnyObject;
+  /**
+   * @remarks Shims:
+   * - `z` to `sort` since v12, until v14
+   */
+  static override shimData(data: AnyMutableObject, options?: DataModel.ShimDataOptions): AnyMutableObject;
+
+  /**
+   * @deprecated since v12, until v14
+   * @remarks "You are accessing `roof` which has been migrated to `restrictions.{light|weather}`"
+   *
+   * Getter returns `this.restrictions.light && this.restrictions.weather`, setter sets both
+   */
+  set roof(value: boolean);
+
+  get roof();
+
+  /**
+   * @deprecated since v12, until v14
+   * @remarks "You are accessing `z` which has been migrated to `sort`"
+   */
+  get z(): this["sort"];
+
+  /**
+   * @deprecated since v12, until v14
+   * @remarks "`BaseTile#overhead` is deprecated."
+   *
+   * Returns `this.elevation >= this.parent?.foregroundElevation`
+   */
+  get overhead(): boolean;
 
   /*
    * After this point these are not really overridden methods.
diff --git a/src/foundry/common/documents/token.d.mts b/src/foundry/common/documents/token.d.mts
index 5bf97ca93..3955830c2 100644
--- a/src/foundry/common/documents/token.d.mts
+++ b/src/foundry/common/documents/token.d.mts
@@ -1,10 +1,9 @@
-import type { AnyObject, AnyMutableObject, InexactPartial } from "fvtt-types/utils";
+import type { AnyMutableObject, AnyObject, InexactPartial } from "fvtt-types/utils";
 import type { DataModel } from "../abstract/data.d.mts";
 import type Document from "../abstract/document.mts";
 import type * as CONST from "../constants.mts";
 import type { DataField, SchemaField } from "../data/fields.d.mts";
 import type { fields } from "../data/module.d.mts";
-import type { TokenDetectionMode } from "./_types.d.mts";
 import type { LogCompatibilityWarningOptions } from "../utils/logging.d.mts";
 
 /**
@@ -27,63 +26,79 @@ declare abstract class BaseToken extends Document<"Token", BaseToken.Schema, any
    */
   constructor(...args: TokenDocument.ConstructorArgs);
 
+  /**
+   * @defaultValue
+   * ```js
+   * mergeObject(super.metadata, {
+   *   name: "Token",
+   *   collection: "tokens",
+   *   label: "DOCUMENT.Token",
+   *   labelPlural: "DOCUMENT.Tokens",
+   *   isEmbedded: true,
+   *   embedded: {
+   *     ActorDelta: "delta"
+   *   },
+   *   permissions: {
+   *     create: "TOKEN_CREATE",
+   *     update: this.#canUpdate,
+   *     delete: "TOKEN_DELETE"
+   *   },
+   *   schemaVersion: "12.324"
+   * })
+   * ```
+   */
   static override metadata: BaseToken.Metadata;
 
   static override defineSchema(): BaseToken.Schema;
 
-  /**
-   * Validate the structure of the detection modes array
-   * @param modes - Configured detection modes
-   * @throws An error if the array is invalid
-   */
-  static #validateDetectionModes(modes: TokenDetectionMode[]): void;
-
   /**
    * The default icon used for newly created Token documents
-   * @defaultValue `CONST.DEFAULT_TOKEN`
+   * @defaultValue `CONST.DEFAULT_TOKEN` (`"icons/svg/mystery-man.svg"`)
    */
   static DEFAULT_ICON: string;
 
-  /**
-   * Is a user able to update an existing Token?
-   * @internal
-   */
-  static #canUpdate(user: User.Implementation, doc: BaseToken, data: BaseToken.UpdateData): boolean;
-
+  // options: not null (destructured)
   override testUserPermission(
     user: User.Implementation,
-    permission: keyof typeof CONST.DOCUMENT_OWNERSHIP_LEVELS | CONST.DOCUMENT_OWNERSHIP_LEVELS,
-    options?: InexactPartial<{
-      /**
-       * Require the exact permission level requested?
-       * @defaultValue `false`
-       */
-      exact: boolean;
-    }>,
+    permission: Document.TestableOwnershipLevel,
+    options?: Document.TestUserPermissionOptions,
   ): boolean;
 
   updateSource(
-    changes?: TokenDocument.CreateData,
+    changes?: TokenDocument.UpdateData,
     options?: { dryRun?: boolean; fallback?: boolean; recursive?: boolean },
-  ): AnyObject;
-
-  static override migrateData(source: AnyMutableObject): AnyMutableObject;
-
-  static override shimData(
-    data: AnyObject,
-    options?: {
-      /**
-       * Apply shims to embedded models?
-       * @defaultValue `true`
-       */
-      embedded?: boolean;
-    },
-  ): AnyObject;
+  ): TokenDocument.UpdateData;
 
   //TODO: Update with the Delta conditionality
   toObject(source: true): this["_source"];
   toObject(source?: boolean): ReturnType<this["schema"]["toObject"]>;
 
+  /**
+   * @remarks Migrates:
+   * - `actorData` to `delta`
+   */
+  static override migrateData(source: AnyMutableObject): AnyMutableObject;
+
+  /**
+   * @remarks Shims:
+   * - `actorData` to `delta` since v11, until v13
+   * - `effects` to nothing since v12, until v14 ("TokenDocument#effects is deprecated in favor of using ActiveEffect documents on the associated Actor")
+   * - `overlayEffect` to nothing since v12, until v14 ("TokenDocument#overlayEffect is deprecated in favor of using ActiveEffect documents on the associated Actor")
+   */
+  static override shimData(data: AnyMutableObject, options?: DataModel.ShimDataOptions): AnyMutableObject;
+
+  /**
+   * @deprecated since v12, until v14
+   * @remarks "TokenDocument#overlayEffect is deprecated in favor of using ActiveEffect documents on the associated Actor"
+   */
+  get effects(): [];
+
+  /**
+   * @deprecated since v12, until v14
+   * @remarks "TokenDocument# is deprecated in favor of using ActiveEffect documents on the associated Actor"
+   */
+  get overlayEffect(): "";
+
   /*
    * After this point these are not really overridden methods.
    * They are here because Foundry's documents are complex and have lots of edge cases.
diff --git a/src/foundry/common/documents/wall.d.mts b/src/foundry/common/documents/wall.d.mts
index a7239e2a6..0899fb1ad 100644
--- a/src/foundry/common/documents/wall.d.mts
+++ b/src/foundry/common/documents/wall.d.mts
@@ -1,4 +1,4 @@
-import type { AnyMutableObject, AnyObject } from "../../../utils/index.d.mts";
+import type { AnyObject } from "../../../utils/index.d.mts";
 import type DataModel from "../abstract/data.d.mts";
 import type Document from "../abstract/document.mts";
 import type { DataField, SchemaField } from "../data/fields.d.mts";
@@ -25,12 +25,25 @@ declare class BaseWall extends Document<WallDocument.Name, BaseWall.Schema, any>
    */
   constructor(...args: WallDocument.ConstructorArgs);
 
+  /**
+   * @defaultValue
+   * ```js
+   * mergeObject(super.metadata, {
+   *   name: "Wall",
+   *   collection: "walls",
+   *   label: "DOCUMENT.Wall",
+   *   labelPlural: "DOCUMENT.Walls",
+   *   permissions: {
+   *     update: this.#canUpdate
+   *   },
+   *   schemaVersion: "12.324"
+   * })
+   * ```
+   */
   static override metadata: BaseWall.Metadata;
 
   static override defineSchema(): BaseWall.Schema;
 
-  static override migrateData(source: AnyMutableObject): AnyMutableObject;
-
   /*
    * After this point these are not really overridden methods.
    * They are here because Foundry's documents are complex and have lots of edge cases.


Test patch:
diff --git a/tests/foundry/common/data/data.mjs.test-d.ts b/tests/foundry/common/data/data.mjs.test-d.ts
deleted file mode 100644
index 5e44964f6..000000000
--- a/tests/foundry/common/data/data.mjs.test-d.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-import { expectTypeOf } from "vitest";
-
-const myLight = new foundry.data.LightData();
-
-expectTypeOf(myLight.alpha).toEqualTypeOf<number>();
-
-const myShape = new foundry.data.ShapeData();
-
-expectTypeOf(myShape.type).toEqualTypeOf<"c" | "r" | "e" | "p">();
-
-// Using token here for comparison
-declare const baseToken: foundry.documents.BaseToken;
-expectTypeOf(baseToken.displayName).toEqualTypeOf<foundry.CONST.TOKEN_DISPLAY_MODES>();
-expectTypeOf(baseToken.light.alpha).toEqualTypeOf<number>();
-
-const myProtoToken = new foundry.data.PrototypeToken();
-expectTypeOf(myProtoToken.name).toEqualTypeOf<string>();
-expectTypeOf(myProtoToken.displayName).toEqualTypeOf<foundry.CONST.TOKEN_DISPLAY_MODES>();
-expectTypeOf(myProtoToken.light.alpha).toEqualTypeOf<number>();
-expectTypeOf(myProtoToken.isOwner).toEqualTypeOf<boolean>();
-expectTypeOf(myProtoToken.getBarAttribute("foo")?.attribute).toEqualTypeOf<string | undefined>();
-
-const myTexture = new foundry.data.TextureData();
-
-expectTypeOf(myTexture.src).toEqualTypeOf<string | undefined | null>();
-
-const myTombstone = new foundry.data.TombstoneData();
-
-expectTypeOf(myTombstone._tombstone).toEqualTypeOf<boolean>();
diff --git a/tests/foundry/common/data/data.test-d.ts b/tests/foundry/common/data/data.test-d.ts
new file mode 100644
index 000000000..c2341c93f
--- /dev/null
+++ b/tests/foundry/common/data/data.test-d.ts
@@ -0,0 +1,92 @@
+import { expectTypeOf } from "vitest";
+import DataModel = foundry.abstract.DataModel;
+import type { ValueOf } from "fvtt-types/utils";
+import type { ObjectAttributeBar, SingleAttributeBar } from "../../../../src/foundry/client/data/documents/token.d.mts";
+
+const myLight = new foundry.data.LightData();
+
+expectTypeOf(myLight.negative).toBeBoolean();
+expectTypeOf(myLight.priority).toBeNumber();
+expectTypeOf(myLight.alpha).toBeNumber();
+expectTypeOf(myLight.angle).toBeNumber();
+expectTypeOf(myLight.bright).toBeNumber();
+expectTypeOf(myLight.color).toEqualTypeOf<Color | null | undefined>();
+expectTypeOf(myLight.coloration).toEqualTypeOf<number | null>();
+expectTypeOf(myLight.dim).toBeNumber();
+expectTypeOf(myLight.attenuation).toBeNumber();
+expectTypeOf(myLight.luminosity).toBeNumber();
+expectTypeOf(myLight.saturation).toBeNumber();
+expectTypeOf(myLight.contrast).toBeNumber();
+expectTypeOf(myLight.shadows).toBeNumber();
+expectTypeOf(myLight.animation.intensity).toBeNumber();
+expectTypeOf(myLight.animation.reverse).toBeBoolean();
+expectTypeOf(myLight.animation.speed).toBeNumber();
+expectTypeOf(myLight.animation.type).toEqualTypeOf<string | null | undefined>();
+expectTypeOf(myLight.darkness.min).toBeNumber();
+expectTypeOf(myLight.darkness.max).toBeNumber();
+
+/******************************************************************/
+
+const myShape = new foundry.data.ShapeData();
+
+expectTypeOf(myShape.type).toEqualTypeOf<"c" | "r" | "e" | "p">();
+expectTypeOf(myShape.width).toEqualTypeOf<number | null | undefined>();
+expectTypeOf(myShape.height).toEqualTypeOf<number | null | undefined>();
+expectTypeOf(myShape.radius).toEqualTypeOf<number | null | undefined>();
+expectTypeOf(myShape.points).toEqualTypeOf<Array<number | undefined>>();
+
+/******************************************************************/
+
+// BaseShapeData, RectangleShapeData, CircleShapeData, EllipseShapeData, and PolygonShapeData
+// are tested in `tests/foundry/client-esm/canvas/regions/shape.test-d.ts`
+
+/******************************************************************/
+
+const textureDataTestSchema = {
+  textureData: new foundry.data.TextureData(
+    {},
+    { categories: ["IMAGE", "AUDIO"], initial: { src: "path/to/thing.png" } },
+  ),
+};
+type TextureTestSchema = typeof textureDataTestSchema;
+
+class TextureDataTestModel extends DataModel<TextureTestSchema> {
+  static override defineSchema(): TextureTestSchema {
+    return textureDataTestSchema;
+  }
+}
+const testModel = new TextureDataTestModel();
+expectTypeOf(testModel.textureData.src).toEqualTypeOf<string | undefined | null>();
+expectTypeOf(testModel.textureData.anchorX).toEqualTypeOf<number | undefined>();
+expectTypeOf(testModel.textureData.anchorY).toEqualTypeOf<number | undefined>();
+expectTypeOf(testModel.textureData.offsetX).toEqualTypeOf<number | undefined>();
+expectTypeOf(testModel.textureData.offsetY).toEqualTypeOf<number | undefined>();
+expectTypeOf(testModel.textureData.fit).toEqualTypeOf<ValueOf<typeof CONST.TEXTURE_DATA_FIT_MODES>>();
+expectTypeOf(testModel.textureData.scaleX).toEqualTypeOf<number | undefined>();
+expectTypeOf(testModel.textureData.scaleY).toEqualTypeOf<number | undefined>();
+expectTypeOf(testModel.textureData.rotation).toEqualTypeOf<number>();
+expectTypeOf(testModel.textureData.tint).toEqualTypeOf<Color | undefined>();
+expectTypeOf(testModel.textureData.alphaThreshold).toEqualTypeOf<number>();
+
+/******************************************************************/
+
+expectTypeOf(foundry.data.PrototypeToken.database).toEqualTypeOf<CONFIG["DatabaseBackend"]>();
+
+const myProtoToken = new foundry.data.PrototypeToken();
+
+// only the fields specific to the prototype token are tested here, the rest of the
+// schema is tested in `tests/foundry/common/documents/token.test-d.ts`
+expectTypeOf(myProtoToken.name).toEqualTypeOf<string>();
+expectTypeOf(myProtoToken.randomImg).toBeBoolean();
+
+expectTypeOf(myProtoToken.actor).toEqualTypeOf<foundry.documents.BaseActor>();
+expectTypeOf(myProtoToken.toObject().actorId).toEqualTypeOf<string | undefined>();
+expectTypeOf(myProtoToken.getBarAttribute("foo")).toEqualTypeOf<SingleAttributeBar | ObjectAttributeBar | null>();
+expectTypeOf(myProtoToken.getBarAttribute("foo")?.attribute).toEqualTypeOf<string | undefined>();
+
+/******************************************************************/
+
+const myTombstone = new foundry.data.TombstoneData();
+
+expectTypeOf(myTombstone._id).toEqualTypeOf<string | null>();
+expectTypeOf(myTombstone._tombstone).toEqualTypeOf<boolean>();
diff --git a/tests/foundry/common/documents/ambient-light.test-d.ts b/tests/foundry/common/documents/ambient-light.test-d.ts
index 7e0c9743f..8d23b577a 100644
--- a/tests/foundry/common/documents/ambient-light.test-d.ts
+++ b/tests/foundry/common/documents/ambient-light.test-d.ts
@@ -1,10 +1,154 @@
 import { expectTypeOf } from "vitest";
+import type { InterfaceToObject } from "fvtt-types/utils";
+import BaseAmbientLight = foundry.documents.BaseAmbientLight;
+import Document = foundry.abstract.Document;
 
-class TestBaseAmbientLight extends foundry.documents.BaseAmbientLight {}
+class TestBaseAmbientLight extends BaseAmbientLight {}
 
-expectTypeOf(new TestBaseAmbientLight()).toEqualTypeOf<foundry.documents.BaseAmbientLight>();
-expectTypeOf(new TestBaseAmbientLight({})).toEqualTypeOf<foundry.documents.BaseAmbientLight>();
+let myLight;
+// AmbientLight has no hard required fields for construction
+myLight = new TestBaseAmbientLight();
+myLight = new TestBaseAmbientLight({});
+myLight = new TestBaseAmbientLight({
+  _id: "XXXXXSomeIDXXXXX",
+  x: 10,
+  y: 10,
+  elevation: 20,
+  rotation: 180,
+  walls: false,
+  vision: true,
+  config: {
+    negative: true,
+    priority: 42,
+    alpha: 0.1,
+    angle: 90,
+    bright: 20,
+    color: "#ABCFED",
+    coloration: 9, // INVERT_ABSORPTION
+    dim: 40,
+    attenuation: 0.34,
+    luminosity: 0.8,
+    saturation: -0.8,
+    contrast: -0.23,
+    shadows: 0.41,
+    animation: {
+      intensity: 3,
+      reverse: true,
+      speed: 7,
+      type: "fairy",
+    },
+    darkness: { min: 0.77, max: 0.99 },
+  },
+  hidden: true,
+  flags: {
+    core: {
+      animationSeed: 17,
+    },
+  },
+});
+myLight = new TestBaseAmbientLight({
+  _id: null,
+  x: null,
+  y: null,
+  elevation: null,
+  rotation: null,
+  walls: null,
+  vision: null,
+  config: {
+    negative: null,
+    priority: null,
+    alpha: null,
+    angle: null,
+    bright: null,
+    color: null,
+    coloration: null,
+    dim: null,
+    attenuation: null,
+    luminosity: null,
+    saturation: null,
+    contrast: null,
+    shadows: null,
+    animation: {
+      intensity: null,
+      reverse: null,
+      speed: null,
+      type: null,
+    },
+    darkness: { min: null, max: null },
+  },
+  hidden: null,
+  flags: null,
+});
+myLight = new TestBaseAmbientLight({
+  config: {
+    animation: null,
+    darkness: null,
+  },
+});
+myLight = new TestBaseAmbientLight({
+  config: null,
+});
 
-declare const myLight: foundry.documents.BaseAmbientLight;
+myLight = new TestBaseAmbientLight({
+  _id: undefined,
+  x: undefined,
+  y: undefined,
+  elevation: undefined,
+  rotation: undefined,
+  walls: undefined,
+  vision: undefined,
+  config: {
+    negative: undefined,
+    priority: undefined,
+    alpha: undefined,
+    angle: undefined,
+    bright: undefined,
+    color: undefined,
+    coloration: undefined,
+    dim: undefined,
+    attenuation: undefined,
+    luminosity: undefined,
+    saturation: undefined,
+    contrast: undefined,
+    shadows: undefined,
+    animation: {
+      intensity: undefined,
+      reverse: undefined,
+      speed: undefined,
+      type: undefined,
+    },
+    darkness: { min: undefined, max: undefined },
+  },
+  hidden: undefined,
+  flags: undefined,
+});
+myLight = new TestBaseAmbientLight({
+  config: {
+    animation: undefined,
+    darkness: undefined,
+  },
+});
+myLight = new TestBaseAmbientLight({
+  config: undefined,
+});
+
+expectTypeOf(myLight).toEqualTypeOf<BaseAmbientLight>();
+
+expectTypeOf(myLight._id).toEqualTypeOf<string | null>();
+expectTypeOf(myLight.x).toBeNumber();
+expectTypeOf(myLight.y).toBeNumber();
+expectTypeOf(myLight.elevation).toBeNumber();
+expectTypeOf(myLight.rotation).toBeNumber();
+expectTypeOf(myLight.walls).toBeBoolean();
+expectTypeOf(myLight.vision).toBeBoolean();
+
+// LightData schema tests are in `tests/foundry/common/data/data.test-d.ts`
 expectTypeOf(myLight.config).toEqualTypeOf<foundry.data.LightData>();
-expectTypeOf(myLight.config.angle).toEqualTypeOf<number>();
+
+expectTypeOf(myLight.hidden).toBeBoolean();
+expectTypeOf(myLight.flags).toEqualTypeOf<
+  InterfaceToObject<BaseAmbientLight.CoreFlags> & InterfaceToObject<Document.CoreFlags>
+>();
+
+// document-specific flag(s)
+expectTypeOf(myLight.flags?.core?.animationSeed).toEqualTypeOf<number | undefined>();
diff --git a/tests/foundry/common/documents/ambient-sound.test-d.ts b/tests/foundry/common/documents/ambient-sound.test-d.ts
index f7d93b722..c799e781f 100644
--- a/tests/foundry/common/documents/ambient-sound.test-d.ts
+++ b/tests/foundry/common/documents/ambient-sound.test-d.ts
@@ -1,48 +1,131 @@
 import { expectTypeOf } from "vitest";
+import type { InterfaceToObject } from "fvtt-types/utils";
 
-class TestBaseAmbientSound extends foundry.documents.BaseAmbientSound {}
-
-expectTypeOf(new TestBaseAmbientSound()).toEqualTypeOf<foundry.documents.BaseAmbientSound>();
-expectTypeOf(new TestBaseAmbientSound({})).toEqualTypeOf<foundry.documents.BaseAmbientSound>();
-expectTypeOf(
-  new TestBaseAmbientSound({
-    _id: null,
-    x: 10,
-    y: 10,
-    hidden: true,
-    radius: 100,
-    darkness: { min: 10, max: 90 },
-    easing: true,
-    path: "path/to/file",
-    repeat: true,
-    volume: 100,
-  }),
-).toEqualTypeOf<foundry.documents.BaseAmbientSound>();
-expectTypeOf(
-  new TestBaseAmbientSound({
-    _id: null,
-    x: null,
-    y: null,
-    hidden: null,
-    radius: null,
-    darkness: null,
-    easing: null,
-    path: null,
-    repeat: null,
-    volume: null,
-  }),
-).toEqualTypeOf<foundry.documents.BaseAmbientSound>();
-expectTypeOf(
-  new TestBaseAmbientSound({
-    _id: undefined,
-    x: undefined,
-    y: undefined,
-    hidden: undefined,
-    radius: undefined,
-    darkness: undefined,
-    easing: undefined,
-    path: undefined,
-    repeat: undefined,
-    volume: undefined,
-  }),
-).toEqualTypeOf<foundry.documents.BaseAmbientSound>();
+import BaseAmbientSound = foundry.documents.BaseAmbientSound;
+import Document = foundry.abstract.Document;
+
+class TestBaseAmbientSound extends BaseAmbientSound {}
+
+let mySound;
+// AmbientSound has no hard required fields for construction
+mySound = new TestBaseAmbientSound();
+mySound = new TestBaseAmbientSound({});
+
+mySound = new TestBaseAmbientSound({
+  _id: "XXXXXSomeIDXXXXX",
+  x: 10,
+  y: 10,
+  elevation: 20,
+  radius: 100,
+  path: "path/to/file",
+  repeat: true,
+  volume: 100,
+  walls: false,
+  easing: true,
+  hidden: true,
+  darkness: { min: 10, max: 90 },
+  effects: {
+    base: {
+      type: "highpass",
+      intensity: 7,
+    },
+    muffled: {
+      type: "reverb",
+      intensity: 2,
+    },
+  },
+  flags: {
+    core: {
+      sheetLock: false,
+    },
+  },
+});
+
+mySound = new TestBaseAmbientSound({
+  _id: null,
+  x: null,
+  y: null,
+  elevation: null,
+  radius: null,
+  path: null,
+  repeat: null,
+  volume: null,
+  walls: null,
+  easing: null,
+  hidden: null,
+  darkness: { min: null, max: null },
+  effects: {
+    base: {
+      type: null,
+      intensity: null,
+    },
+    muffled: {
+      type: null,
+      intensity: null,
+    },
+  },
+  flags: null,
+});
+mySound = new TestBaseAmbientSound({
+  darkness: null,
+  effects: {
+    base: null,
+    muffled: null,
+  },
+});
+mySound = new TestBaseAmbientSound({ effects: null });
+
+mySound = new TestBaseAmbientSound({
+  _id: undefined,
+  x: undefined,
+  y: undefined,
+  elevation: undefined,
+  radius: undefined,
+  path: undefined,
+  repeat: undefined,
+  volume: undefined,
+  walls: undefined,
+  easing: undefined,
+  hidden: undefined,
+  darkness: { min: undefined, max: undefined },
+  effects: {
+    base: {
+      type: undefined,
+      intensity: undefined,
+    },
+    muffled: {
+      type: undefined,
+      intensity: undefined,
+    },
+  },
+  flags: undefined,
+});
+mySound = new TestBaseAmbientSound({
+  darkness: undefined,
+  effects: {
+    base: undefined,
+    muffled: undefined,
+  },
+});
+mySound = new TestBaseAmbientSound({ effects: undefined });
+
+expectTypeOf(mySound).toEqualTypeOf<BaseAmbientSound>();
+
+expectTypeOf(mySound._id).toEqualTypeOf<string | null>();
+expectTypeOf(mySound.x).toBeNumber();
+expectTypeOf(mySound.y).toBeNumber();
+expectTypeOf(mySound.elevation).toBeNumber();
+expectTypeOf(mySound.radius).toBeNumber();
+expectTypeOf(mySound.path).toEqualTypeOf<string | null | undefined>();
+expectTypeOf(mySound.repeat).toBeBoolean();
+expectTypeOf(mySound.volume).toBeNumber();
+expectTypeOf(mySound.walls).toBeBoolean();
+expectTypeOf(mySound.easing).toBeBoolean();
+expectTypeOf(mySound.hidden).toBeBoolean();
+expectTypeOf(mySound.darkness.min).toBeNumber();
+expectTypeOf(mySound.darkness.max).toBeNumber();
+expectTypeOf(mySound.effects.base.type).toEqualTypeOf<string | undefined>();
+expectTypeOf(mySound.effects.base.intensity).toEqualTypeOf<number | null>();
+expectTypeOf(mySound.effects.muffled.type).toEqualTypeOf<string | undefined>();
+expectTypeOf(mySound.effects.muffled.intensity).toEqualTypeOf<number | null>();
+expectTypeOf(mySound.flags).toEqualTypeOf<InterfaceToObject<Document.CoreFlags>>();
diff --git a/tests/foundry/common/documents/drawing.test-d.ts b/tests/foundry/common/documents/drawing.test-d.ts
index c1b278b83..8e16a5328 100644
--- a/tests/foundry/common/documents/drawing.test-d.ts
+++ b/tests/foundry/common/documents/drawing.test-d.ts
@@ -1,102 +1,151 @@
 import { expectTypeOf } from "vitest";
+import type { InterfaceToObject } from "fvtt-types/utils";
+import BaseDrawing = foundry.documents.BaseDrawing;
+import Document = foundry.abstract.Document;
 
-expectTypeOf(foundry.documents.BaseDrawing.create({})).toEqualTypeOf<Promise<DrawingDocument.Stored | undefined>>();
-expectTypeOf(foundry.documents.BaseDrawing.createDocuments([])).toEqualTypeOf<Promise<DrawingDocument.Stored[]>>();
-expectTypeOf(foundry.documents.BaseDrawing.updateDocuments([])).toEqualTypeOf<Promise<DrawingDocument[]>>();
-expectTypeOf(foundry.documents.BaseDrawing.deleteDocuments([])).toEqualTypeOf<Promise<DrawingDocument[]>>();
+class TestBaseDrawing extends foundry.documents.BaseDrawing {}
 
-const drawing = await foundry.documents.BaseDrawing.create({}, { temporary: true });
-if (drawing) {
-  expectTypeOf(drawing).toEqualTypeOf<DrawingDocument>();
-  // @ts-expect-error Drawing is distinct from the DrawingDocument
-  expectTypeOf(drawing).toEqualTypeOf<Drawing>();
-}
+let myDrawing;
+// Drawing has no hard required fields for construction
+myDrawing = new TestBaseDrawing();
+myDrawing = new TestBaseDrawing({});
+myDrawing = new TestBaseDrawing({
+  _id: "XXXXXSomeIDXXXXX",
+  author: "YYYYYSomeIDYYYYY",
+  shape: {
+    // you would never actually have all of these at the same time
+    type: "p",
+    height: 20,
+    width: 30,
+    radius: 400,
+    points: [500, 500, 37, 28],
+  },
+  x: 740,
+  y: 230,
+  elevation: 20,
+  sort: 42,
+  rotation: 0,
+  bezierFactor: 0.216,
+  fillType: CONST.DRAWING_FILL_TYPES.PATTERN,
+  fillColor: "#FEFFAF",
+  fillAlpha: 0.5,
+  strokeWidth: 2,
+  strokeColor: "#F9889F",
+  strokeAlpha: 0.9,
+  texture: "path/to/a/texture.png",
+  text: "Hello World",
+  fontFamily: "Amiri",
+  fontSize: 96,
+  textColor: "#123456",
+  textAlpha: 0.7,
+  hidden: false,
+  locked: false,
+  flags: {
+    core: {
+      sheetLock: false,
+    },
+  },
+});
 
-class TestBaseDrawing extends foundry.documents.BaseDrawing {}
+myDrawing = new TestBaseDrawing({
+  _id: null,
+  author: null,
+  shape: {
+    type: null,
+    height: null,
+    width: null,
+    radius: null,
+    points: null,
+  },
+  x: null,
+  y: null,
+  elevation: null,
+  sort: null,
+  rotation: null,
+  bezierFactor: null,
+  fillType: null,
+  fillColor: null,
+  fillAlpha: null,
+  strokeWidth: null,
+  strokeColor: null,
+  strokeAlpha: null,
+  texture: null,
+  text: null,
+  fontFamily: null,
+  fontSize: null,
+  textColor: null,
+  textAlpha: null,
+  hidden: null,
+  locked: null,
+  flags: null,
+});
+myDrawing = new TestBaseDrawing({ shape: null });
 
-expectTypeOf(new TestBaseDrawing()).toEqualTypeOf<foundry.documents.BaseDrawing>();
-expectTypeOf(new TestBaseDrawing({})).toEqualTypeOf<foundry.documents.BaseDrawing>();
-expectTypeOf(
-  new TestBaseDrawing({
-    author: null,
-    bezierFactor: null,
-    fillAlpha: null,
-    fillColor: null,
-    fillType: null,
-    flags: null,
-    fontFamily: null,
-    fontSize: null,
-    hidden: null,
-    locked: null,
-    rotation: null,
-    shape: null,
-    strokeAlpha: null,
-    strokeColor: null,
-    strokeWidth: null,
-    text: null,
-    textColor: null,
-    texture: null,
-    x: null,
-    y: null,
-    z: null,
-    _id: null,
-  }),
-).toEqualTypeOf<foundry.documents.BaseDrawing>();
-expectTypeOf(
-  new TestBaseDrawing({
-    author: undefined,
-    bezierFactor: undefined,
-    fillAlpha: undefined,
-    fillColor: undefined,
-    fillType: undefined,
-    flags: undefined,
-    fontFamily: undefined,
-    fontSize: undefined,
-    hidden: undefined,
-    locked: undefined,
-    rotation: undefined,
-    shape: undefined,
-    strokeAlpha: undefined,
-    strokeColor: undefined,
-    strokeWidth: undefined,
-    text: undefined,
-    textColor: undefined,
-    texture: undefined,
-    x: undefined,
-    y: undefined,
-    z: undefined,
-    _id: undefined,
-  }),
-).toEqualTypeOf<foundry.documents.BaseDrawing>();
+myDrawing = new TestBaseDrawing({
+  _id: undefined,
+  author: undefined,
+  shape: {
+    type: undefined,
+    height: undefined,
+    width: undefined,
+    radius: undefined,
+    points: undefined,
+  },
+  x: undefined,
+  y: undefined,
+  elevation: undefined,
+  sort: undefined,
+  rotation: undefined,
+  bezierFactor: undefined,
+  fillType: undefined,
+  fillColor: undefined,
+  fillAlpha: undefined,
+  strokeWidth: undefined,
+  strokeColor: undefined,
+  strokeAlpha: undefined,
+  texture: undefined,
+  text: undefined,
+  fontFamily: undefined,
+  fontSize: undefined,
+  textColor: undefined,
+  textAlpha: undefined,
+  hidden: undefined,
+  locked: undefined,
+  flags: undefined,
+});
+myDrawing = new TestBaseDrawing({ shape: undefined });
 
-expectTypeOf(
-  new TestBaseDrawing({
-    author: new User.implementation({ name: "foo" }),
-    bezierFactor: 0,
-    fillAlpha: 0.5,
-    fillColor: "#FFFFFF",
-    fillType: 0,
-    flags: {},
-    fontFamily: "Signika",
-    fontSize: 48,
-    hidden: false,
-    locked: false,
-    rotation: 0,
-    shape: {
-      type: "p",
-      height: 0,
-      width: 0,
-      points: [],
-    },
-    strokeAlpha: 1,
-    strokeColor: "#FFFFFF",
-    strokeWidth: 0,
-    text: "Hello World",
-    textColor: "#FFFFFF",
-    texture: "path/to/a/texture.png",
-    x: 0,
-    y: 0,
-    z: 0,
-    _id: "NlBhrPq62QrMErNh",
-  }),
-).toEqualTypeOf<foundry.documents.BaseDrawing>();
+expectTypeOf(myDrawing).toEqualTypeOf<BaseDrawing>();
+
+expectTypeOf(myDrawing._id).toEqualTypeOf<string | null>();
+expectTypeOf(myDrawing.author).toEqualTypeOf<User.Implementation>();
+
+// ShapeData schema tests are in `tests/foundry/common/data/data.test-d.ts`
+expectTypeOf(myDrawing.shape).toEqualTypeOf<foundry.data.ShapeData>();
+
+expectTypeOf(myDrawing.x).toBeNumber();
+expectTypeOf(myDrawing.y).toBeNumber();
+expectTypeOf(myDrawing.elevation).toBeNumber();
+expectTypeOf(myDrawing.sort).toBeNumber();
+expectTypeOf(myDrawing.rotation).toBeNumber();
+expectTypeOf(myDrawing.bezierFactor).toBeNumber();
+expectTypeOf(myDrawing.fillType).toEqualTypeOf<CONST.DRAWING_FILL_TYPES>();
+expectTypeOf(myDrawing.fillAlpha).toBeNumber();
+expectTypeOf(myDrawing.strokeAlpha).toBeNumber();
+expectTypeOf(myDrawing.texture).toEqualTypeOf<string | null | undefined>();
+expectTypeOf(myDrawing.text).toEqualTypeOf<string | undefined>();
+expectTypeOf(myDrawing.textAlpha).toBeNumber();
+expectTypeOf(myDrawing.hidden).toBeBoolean();
+expectTypeOf(myDrawing.locked).toBeBoolean();
+expectTypeOf(myDrawing.flags).toEqualTypeOf<InterfaceToObject<Document.CoreFlags>>();
+
+// The following fields can't really be `undefined` because they have `initial`s, see https://github.com/League-of-Foundry-Developers/foundry-vtt-types/issues/3055
+expectTypeOf(myDrawing.fillColor).toEqualTypeOf<Color | undefined>();
+expectTypeOf(myDrawing.strokeWidth).toEqualTypeOf<number | undefined>();
+expectTypeOf(myDrawing.strokeColor).toEqualTypeOf<Color | undefined>();
+expectTypeOf(myDrawing.fontFamily).toEqualTypeOf<string | undefined>();
+expectTypeOf(myDrawing.fontSize).toEqualTypeOf<number | undefined>();
+expectTypeOf(myDrawing.textColor).toEqualTypeOf<Color | undefined>();
+
+// non-schema:
+expectTypeOf(myDrawing.z).toBeNumber();
diff --git a/tests/foundry/common/documents/measured-template.test-d.ts b/tests/foundry/common/documents/measured-template.test-d.ts
index dce0e7311..54cc4276f 100644
--- a/tests/foundry/common/documents/measured-template.test-d.ts
+++ b/tests/foundry/common/documents/measured-template.test-d.ts
@@ -1,78 +1,89 @@
 import { expectTypeOf } from "vitest";
+import type { InterfaceToObject } from "fvtt-types/utils";
+import BaseMeasuredTemplate = foundry.documents.BaseMeasuredTemplate;
+import Document = foundry.abstract.Document;
 
-declare const template: foundry.documents.BaseMeasuredTemplate;
-expectTypeOf(template._id).toEqualTypeOf<string | null>();
-expectTypeOf(template.t).toEqualTypeOf<foundry.CONST.MEASURED_TEMPLATE_TYPES>();
-expectTypeOf(template.parent).toEqualTypeOf<Scene | null>();
+class TestBaseMeasuredTemplate extends BaseMeasuredTemplate {}
 
-const scene = new Scene({ name: "My scene" });
+let myTemplate;
+// MeasuredTemplate has no hard required fields for construction
+myTemplate = new TestBaseMeasuredTemplate();
+myTemplate = new TestBaseMeasuredTemplate({});
+myTemplate = new TestBaseMeasuredTemplate({
+  _id: "XXXXXSomeIDXXXXX",
+  author: "YYYYYSomeIDYYYYY",
+  t: CONST.MEASURED_TEMPLATE_TYPES.RAY,
+  x: 1230,
+  y: 340,
+  elevation: 20,
+  sort: 2,
+  distance: 100,
+  angle: 360,
+  width: 60,
+  borderColor: "#321123",
+  fillColor: "#987789",
+  texture: "path/to/a/texture.webp",
+  hidden: true,
+  flags: {
+    core: {
+      sheetLock: false,
+    },
+  },
+});
+myTemplate = new TestBaseMeasuredTemplate({
+  _id: null,
+  author: null,
+  t: null,
+  x: null,
+  y: null,
+  elevation: null,
+  sort: null,
+  distance: null,
+  angle: null,
+  width: null,
+  borderColor: null,
+  fillColor: null,
+  texture: null,
+  hidden: null,
+  flags: null,
+});
+myTemplate = new TestBaseMeasuredTemplate({
+  _id: undefined,
+  author: undefined,
+  t: undefined,
+  x: undefined,
+  y: undefined,
+  elevation: undefined,
+  sort: undefined,
+  distance: undefined,
+  angle: undefined,
+  width: undefined,
+  borderColor: undefined,
+  fillColor: undefined,
+  texture: undefined,
+  hidden: undefined,
+  flags: undefined,
+});
 
-class TestBaseMeasuredTemplate extends foundry.documents.BaseMeasuredTemplate {}
+expectTypeOf(myTemplate).toEqualTypeOf<TestBaseMeasuredTemplate>();
 
-new TestBaseMeasuredTemplate();
+expectTypeOf(myTemplate._id).toEqualTypeOf<string | null>();
+expectTypeOf(myTemplate.author).toEqualTypeOf<User.Implementation | null>();
+expectTypeOf(myTemplate.t).toEqualTypeOf<CONST.MEASURED_TEMPLATE_TYPES>();
+expectTypeOf(myTemplate.x).toBeNumber();
+expectTypeOf(myTemplate.y).toBeNumber();
+expectTypeOf(myTemplate.elevation).toBeNumber();
+expectTypeOf(myTemplate.sort).toBeNumber();
+expectTypeOf(myTemplate.distance).toBeNumber();
+expectTypeOf(myTemplate.direction).toBeNumber();
+expectTypeOf(myTemplate.width).toBeNumber();
+expectTypeOf(myTemplate.texture).toEqualTypeOf<string | null | undefined>();
+expectTypeOf(myTemplate.hidden).toBeBoolean();
+expectTypeOf(myTemplate.flags).toEqualTypeOf<InterfaceToObject<Document.CoreFlags>>();
 
-new TestBaseMeasuredTemplate({ x: 100, y: 100 });
+// The following fields can't really be `undefined` because they have `initial`s, see https://github.com/League-of-Foundry-Developers/foundry-vtt-types/issues/3055
+expectTypeOf(myTemplate.borderColor).toEqualTypeOf<Color | undefined>();
+expectTypeOf(myTemplate.fillColor).toEqualTypeOf<Color | undefined>();
 
-expectTypeOf(
-  new TestBaseMeasuredTemplate({ x: 100, y: 100 }, scene),
-).toEqualTypeOf<foundry.documents.BaseMeasuredTemplate>();
-expectTypeOf(new TestBaseMeasuredTemplate({}, scene)).toEqualTypeOf<foundry.documents.BaseMeasuredTemplate>();
-expectTypeOf(new TestBaseMeasuredTemplate(undefined, scene)).toEqualTypeOf<foundry.documents.BaseMeasuredTemplate>();
-expectTypeOf(
-  new TestBaseMeasuredTemplate(
-    {
-      _id: null,
-      user: null,
-      t: null,
-      x: null,
-      y: null,
-      distance: null,
-      angle: null,
-      width: null,
-      borderColor: null,
-      fillColor: null,
-      texture: null,
-      flags: null,
-    },
-    scene,
-  ),
-).toEqualTypeOf<foundry.documents.BaseMeasuredTemplate>();
-expectTypeOf(
-  new TestBaseMeasuredTemplate(
-    {
-      _id: undefined,
-      user: undefined,
-      t: undefined,
-      x: undefined,
-      y: undefined,
-      distance: undefined,
-      angle: undefined,
-      width: undefined,
-      borderColor: undefined,
-      fillColor: undefined,
-      texture: undefined,
-      flags: undefined,
-    },
-    scene,
-  ),
-).toEqualTypeOf<foundry.documents.BaseMeasuredTemplate>();
-
-expectTypeOf(
-  new TestBaseMeasuredTemplate(
-    {
-      _id: "10",
-      user: "11",
-      t: "ray",
-      x: 0,
-      y: 0,
-      distance: 10,
-      angle: 360,
-      width: 10,
-      borderColor: "#000000",
-      fillColor: "#ffffff",
-      texture: "path/to/a/texture",
-      flags: {},
-    },
-    scene,
-  ),
-).toEqualTypeOf<foundry.documents.BaseMeasuredTemplate>();
+// non-schema
+expectTypeOf(myTemplate.user).toEqualTypeOf<User.Implementation | null>();
diff --git a/tests/foundry/common/documents/note.test-d.ts b/tests/foundry/common/documents/note.test-d.ts
index ba1496282..25d67d4f9 100644
--- a/tests/foundry/common/documents/note.test-d.ts
+++ b/tests/foundry/common/documents/note.test-d.ts
@@ -1,64 +1,132 @@
 import { expectTypeOf } from "vitest";
+import type { InterfaceToObject } from "fvtt-types/utils";
+import BaseNote = foundry.documents.BaseNote;
+import Document = foundry.abstract.Document;
 
-class TestBaseNote extends foundry.documents.BaseNote {}
+class TestBaseNote extends BaseNote {}
 
-expectTypeOf(new TestBaseNote()).toEqualTypeOf<foundry.documents.BaseNote>();
+let myNote;
+// Note has no hard required fields for creation
+myNote = new TestBaseNote();
+myNote = new TestBaseNote({});
+myNote = new TestBaseNote({
+  _id: "XXXXXSomeIDXXXXX",
+  entryId: "YYYYYSomeIDYYYYY",
+  pageId: "ZZZZZSomeIDZZZZZ",
+  x: 100,
+  y: 300,
+  elevation: 20,
+  sort: 11,
+  texture: {
+    alphaThreshold: 1,
+    anchorX: 10,
+    anchorY: 20,
+    fit: "height",
+    offsetX: -20,
+    offsetY: -10,
+    rotation: 90,
+    scaleX: 1.2,
+    scaleY: 1.3,
+    src: "path/to/some/icon.svg",
+    tint: "#FFFFFF",
+  },
+  iconSize: 100,
+  text: "Some text",
+  fontFamily: "Comic Sans",
+  fontSize: 50,
+  textAnchor: CONST.TEXT_ANCHOR_POINTS.TOP,
+  textColor: "#FF0000",
+  global: true,
+  flags: {
+    core: {
+      sheetLock: false,
+    },
+  },
+});
+myNote = new TestBaseNote({
+  _id: null,
+  entryId: null,
+  pageId: null,
+  x: null,
+  y: null,
+  elevation: null,
+  sort: null,
+  texture: {
+    alphaThreshold: null,
+    anchorX: null,
+    anchorY: null,
+    fit: null,
+    offsetX: null,
+    offsetY: null,
+    rotation: null,
+    scaleX: null,
+    scaleY: null,
+    src: null,
+    tint: null,
+  },
+  iconSize: null,
+  text: null,
+  fontFamily: null,
+  fontSize: null,
+  textAnchor: null,
+  textColor: null,
+  global: null,
+  flags: null,
+});
+myNote = new TestBaseNote({ texture: null });
 
-expectTypeOf(new TestBaseNote({})).toEqualTypeOf<foundry.documents.BaseNote>();
+myNote = new TestBaseNote({
+  _id: undefined,
+  entryId: undefined,
+  pageId: undefined,
+  x: undefined,
+  y: undefined,
+  elevation: undefined,
+  sort: undefined,
+  texture: {
+    alphaThreshold: undefined,
+    anchorX: undefined,
+    anchorY: undefined,
+    fit: undefined,
+    offsetX: undefined,
+    offsetY: undefined,
+    rotation: undefined,
+    scaleX: undefined,
+    scaleY: undefined,
+    src: undefined,
+    tint: undefined,
+  },
+  iconSize: undefined,
+  text: undefined,
+  fontFamily: undefined,
+  fontSize: undefined,
+  textAnchor: undefined,
+  textColor: undefined,
+  global: undefined,
+  flags: undefined,
+});
+myNote = new TestBaseNote({ texture: undefined });
 
-expectTypeOf(
-  new TestBaseNote({
-    _id: undefined,
-    entryId: undefined,
-    x: undefined,
-    y: undefined,
-    texture: undefined,
-    iconSize: undefined,
-    text: undefined,
-    fontFamily: undefined,
-    fontSize: undefined,
-    textAnchor: undefined,
-    textColor: undefined,
-    flags: undefined,
-  }),
-).toEqualTypeOf<foundry.documents.BaseNote>();
+expectTypeOf(myNote).toEqualTypeOf<BaseNote>();
 
-expectTypeOf(
-  new TestBaseNote({
-    _id: null,
-    entryId: null,
-    x: null,
-    y: null,
-    texture: null,
-    iconSize: null,
-    text: null,
-    fontFamily: null,
-    fontSize: null,
-    textAnchor: null,
-    textColor: null,
-    flags: null,
-  }),
-).toEqualTypeOf<foundry.documents.BaseNote>();
+expectTypeOf(myNote._id).toEqualTypeOf<string | null>();
+expectTypeOf(myNote.entryId).toEqualTypeOf<string | null>();
+expectTypeOf(myNote.pageId).toEqualTypeOf<string | null>();
+expectTypeOf(myNote.x).toBeNumber();
+expectTypeOf(myNote.y).toBeNumber();
+expectTypeOf(myNote.elevation).toBeNumber();
+expectTypeOf(myNote.sort).toBeNumber();
 
-expectTypeOf(
-  new TestBaseNote({
-    _id: "bfeabfiea",
-    entryId: "bebfegibefaei",
-    x: 100,
-    y: 300,
-    texture: {
-      src: "path/to/some/icon.svg",
-      tint: "#FFFFFF",
-    },
-    iconSize: 100,
-    text: "Some text",
-    fontFamily: "Comic Sans",
-    fontSize: 50,
-    textAnchor: foundry.CONST.TEXT_ANCHOR_POINTS.TOP,
-    textColor: "#FF0000",
-    flags: {},
-  }),
-).toEqualTypeOf<foundry.documents.BaseNote>();
+// TextureData schema tests are in `tests/foundry/common/data/data.test-d.ts`
+expectTypeOf(myNote.texture).toEqualTypeOf<
+  foundry.data.fields.SchemaField.InitializedData<foundry.data.TextureData.Schema>
+>();
 
-// @ts-expect-error - A textAnchor cannot be an arbitrary number.
-new TestBaseNote({ textAnchor: 999 });
+expectTypeOf(myNote.iconSize).toBeNumber();
+expectTypeOf(myNote.text).toEqualTypeOf<string | undefined>();
+expectTypeOf(myNote.fontFamily).toBeString();
+expectTypeOf(myNote.fontSize).toEqualTypeOf<number | null>();
+expectTypeOf(myNote.textAnchor).toEqualTypeOf<CONST.TEXT_ANCHOR_POINTS | null>();
+expectTypeOf(myNote.textColor).toEqualTypeOf<Color>();
+expectTypeOf(myNote.global).toBeBoolean();
+expectTypeOf(myNote.flags).toEqualTypeOf<InterfaceToObject<Document.CoreFlags>>();
diff --git a/tests/foundry/common/documents/region-behavior.test-d.ts b/tests/foundry/common/documents/region-behavior.test-d.ts
new file mode 100644
index 000000000..34a244624
--- /dev/null
+++ b/tests/foundry/common/documents/region-behavior.test-d.ts
@@ -0,0 +1,99 @@
+import { expectTypeOf } from "vitest";
+import type { InterfaceToObject } from "fvtt-types/utils";
+import BaseRegionBehavior = foundry.documents.BaseRegionBehavior;
+import Document = foundry.abstract.Document;
+
+class TestRegionBehavior extends BaseRegionBehavior {}
+
+let myRB;
+// @ts-expect-error RegionBehavior requires a `type` for creation
+myRB = new TestRegionBehavior();
+// @ts-expect-error RegionBehavior requires a `type` for creation
+myRB = new TestRegionBehavior({});
+myRB = new TestRegionBehavior({
+  _id: "XXXXXSomeIDXXXXX",
+  name: "Some Behaviour",
+  type: "executeScript", // required for creation
+  system: {},
+  disabled: true,
+  flags: {
+    core: {
+      sheetLock: false,
+    },
+  },
+  _stats: {
+    compendiumSource: "Compendium.mysystem.pack-id.RegionBehavior.YYYYYSomeIDYYYYY",
+    coreVersion: "12",
+    createdTime: 123456789,
+    duplicateSource: "Scene.ZZZZZSomeIDZZZZZ.Region.WWWWWSomeIDWWWWW.RegionBehavior.VVVVVSomeIDVVVVV",
+    lastModifiedBy: "User.UUUUUSomeIDUUUUU",
+    modifiedTime: 987654321,
+    systemId: "pf2e",
+    systemVersion: "6.10.2",
+  },
+});
+
+myRB = new TestRegionBehavior({
+  _id: null,
+  name: null,
+  type: "executeScript", // required for creation
+  system: null,
+  disabled: null,
+  flags: null,
+  _stats: {
+    compendiumSource: null,
+    coreVersion: null,
+    createdTime: null,
+    duplicateSource: null,
+    lastModifiedBy: null,
+    modifiedTime: null,
+    systemId: null,
+    systemVersion: null,
+  },
+});
+myRB = new TestRegionBehavior({
+  type: "executeScript", // required for creation
+  _stats: null,
+});
+
+myRB = new TestRegionBehavior({
+  _id: undefined,
+  name: undefined,
+  type: "executeScript", // required for creation
+  system: undefined,
+  disabled: undefined,
+  flags: undefined,
+  _stats: {
+    compendiumSource: undefined,
+    coreVersion: undefined,
+    createdTime: undefined,
+    duplicateSource: undefined,
+    lastModifiedBy: undefined,
+    modifiedTime: undefined,
+    systemId: undefined,
+    systemVersion: undefined,
+  },
+});
+myRB = new TestRegionBehavior({
+  type: "executeScript", // required for creation
+  _stats: undefined,
+});
+
+expectTypeOf(myRB).toEqualTypeOf<BaseRegionBehavior>();
+
+expectTypeOf(myRB._id).toEqualTypeOf<string | null>();
+expectTypeOf(myRB.name).toBeString();
+//TODO: fix somehow
+// excessively deep error
+// expectTypeOf(myRB.type).toEqualTypeOf<
+//   foundry.data.fields.DocumentTypeField.InitializedType<
+//     typeof BaseRegionBehavior,
+//     foundry.data.fields.DocumentTypeField.DefaultOptions
+//   >
+// >();
+// expectTypeOf(myRB.system).toEqualTypeOf</* ???? */>()
+expectTypeOf(myRB.disabled).toBeBoolean();
+expectTypeOf(myRB.flags).toEqualTypeOf<InterfaceToObject<Document.CoreFlags>>();
+expectTypeOf(myRB._stats).toEqualTypeOf<
+  foundry.data.fields.SchemaField.InitializedData<foundry.data.fields.DocumentStatsField.Schema>
+>();
diff --git a/tests/foundry/common/documents/region.test-d.ts b/tests/foundry/common/documents/region.test-d.ts
new file mode 100644
index 000000000..edf635304
--- /dev/null
+++ b/tests/foundry/common/documents/region.test-d.ts
@@ -0,0 +1,106 @@
+import { expectTypeOf } from "vitest";
+import type { FixedInstanceType, InterfaceToObject, RemoveIndexSignatures, ValueOf } from "fvtt-types/utils";
+import type EmbeddedCollection from "../../../../src/foundry/common/abstract/embedded-collection.d.mts";
+import BaseRegion = foundry.documents.BaseRegion;
+import Document = foundry.abstract.Document;
+import type { BaseShapeData } from "../../../../src/foundry/common/data/data.d.mts";
+
+class TestRegion extends BaseRegion {}
+
+// Not sure know how to make this a specific type of behaviour *and* `.Implementation`
+declare const someScriptBehavior: RegionBehavior<"executeScript">;
+let myRegion;
+// @ts-expect-error Region construction requires a `name`
+myRegion = new TestRegion();
+// @ts-expect-error Region construction requires a `name`
+myRegion = new TestRegion({});
+
+myRegion = new TestRegion({
+  _id: "XXXXXSomeIDXXXXX",
+  name: "Some Region",
+  color: "#ABEFCD",
+  //TODO: fix TypedSchemaField typing?
+  shapes: [
+    {
+      type: "rectangle",
+      x: 1500,
+      y: 500,
+      width: 200,
+      height: 200,
+      hole: false,
+      rotation: 72,
+    },
+  ],
+  elevation: {
+    bottom: 0,
+    top: 50,
+  },
+  //TODO: this errors intermittently. circularities?
+  behaviors: [someScriptBehavior],
+  visibility: CONST.REGION_VISIBILITY.GAMEMASTER,
+  locked: true,
+  flags: {
+    core: {
+      sheetLock: false,
+    },
+  },
+});
+
+myRegion = new TestRegion({
+  _id: null,
+  name: "Some Region",
+  color: null,
+  shapes: null,
+  elevation: {
+    bottom: null,
+    top: null,
+  },
+  behaviors: null,
+  visibility: null,
+  locked: null,
+  flags: null,
+});
+myRegion = new TestRegion({
+  name: "Some Region",
+  elevation: null,
+});
+
+myRegion = new TestRegion({
+  _id: undefined,
+  name: "Some Region",
+  color: undefined,
+  shapes: undefined,
+  elevation: {
+    bottom: undefined,
+    top: undefined,
+  },
+  behaviors: undefined,
+  visibility: undefined,
+  locked: undefined,
+  flags: undefined,
+});
+myRegion = new TestRegion({
+  name: "Some Region",
+  elevation: undefined,
+});
+
+expectTypeOf(myRegion).toEqualTypeOf<BaseRegion>();
+
+expectTypeOf(myRegion._id).toEqualTypeOf<string | null>();
+expectTypeOf(myRegion.name).toBeString();
+expectTypeOf(myRegion.color).toEqualTypeOf<Color>();
+
+//TODO: why is this wrong
+expectTypeOf(myRegion.shapes).toEqualTypeOf<FixedInstanceType<ValueOf<RemoveIndexSignatures<BaseShapeData.Types>>>>();
+
+expectTypeOf(myRegion.elevation.bottom).toEqualTypeOf<number | null>();
+expectTypeOf(myRegion.elevation.top).toEqualTypeOf<number | null>();
+
+expectTypeOf(myRegion.behaviors).toEqualTypeOf<
+  //TODO: why is this is resolving as EmbeddedCollection<any, ...
+  EmbeddedCollection<typeof foundry.documents.BaseRegionBehavior, Region.Implementation>
+>();
+
+expectTypeOf(myRegion.visibility).toEqualTypeOf<CONST.REGION_VISIBILITY | null>();
+expectTypeOf(myRegion.locked).toBeBoolean();
+expectTypeOf(myRegion.flags).toEqualTypeOf<InterfaceToObject<Document.CoreFlags>>();
diff --git a/tests/foundry/common/documents/tile.test-d.ts b/tests/foundry/common/documents/tile.test-d.ts
index 1577f6202..3beab1bbe 100644
--- a/tests/foundry/common/documents/tile.test-d.ts
+++ b/tests/foundry/common/documents/tile.test-d.ts
@@ -1,104 +1,194 @@
 import { expectTypeOf } from "vitest";
+import type { InterfaceToObject } from "fvtt-types/utils";
+import BaseTile = foundry.documents.BaseTile;
+import Document = foundry.abstract.Document;
 
-// @ts-expect-error Width and height must be provided
-expectTypeOf(new foundry.documents.BaseTile()).toEqualTypeOf<foundry.documents.BaseTile>();
+class TestTile extends BaseTile {}
 
-// @ts-expect-error Width and height must be provided
-expectTypeOf(new foundry.documents.BaseTile({})).toEqualTypeOf<foundry.documents.BaseTile>();
+let myTile;
+// @ts-expect-error Tiles require a provided width and height
+myTile = new TestTile();
+// @ts-expect-error Tiles require a provided width and height
+myTile = new TestTile({});
 
-expectTypeOf(
-  new foundry.documents.BaseTile({
-    _id: undefined,
-    texture: undefined,
-    width: 100,
-    height: 100,
-    x: undefined,
-    y: undefined,
-    elevation: undefined,
-    sort: undefined,
-    rotation: undefined,
-    alpha: undefined,
-    hidden: undefined,
-    locked: undefined,
-    overhead: undefined,
-    occlusion: undefined,
-    video: undefined,
-    flags: undefined,
-  }),
-).toEqualTypeOf<foundry.documents.BaseTile>();
+myTile = new TestTile({
+  _id: "XXXXXSomeIDXXXXX",
+  texture: {
+    src: "path/to/some/image.png",
+    tint: "#FF0000",
+    alphaThreshold: 0.2,
+    anchorX: 0.2,
+    anchorY: 0.2,
+    fit: "contain",
+    offsetX: 10,
+    offsetY: 10,
+    rotation: 74,
+    scaleX: 0.8,
+    scaleY: 1.2,
+  },
+  width: 200, // actually required for construction
+  height: 200, // actually required for construction
+  x: 300,
+  y: 500,
+  elevation: 20,
+  sort: 23,
+  rotation: 170,
+  alpha: 0.67,
+  hidden: true,
+  locked: false,
+  restrictions: {
+    light: true,
+    weather: false,
+  },
+  occlusion: {
+    mode: CONST.OCCLUSION_MODES.FADE,
+    alpha: 0.78,
+  },
+  video: {
+    loop: true,
+    autoplay: true,
+    volume: 0.5,
+  },
+  flags: {
+    core: {
+      randomizeVideo: true,
+    },
+  },
+});
 
-expectTypeOf(
-  new foundry.documents.BaseTile({
-    _id: null,
-    texture: null,
-    width: 100,
-    height: 100,
-    x: null,
-    y: null,
-    elevation: 0.0,
-    sort: 0,
+myTile = new TestTile({
+  _id: null,
+  texture: {
+    src: null,
+    tint: null,
+    alphaThreshold: null,
+    anchorX: null,
+    anchorY: null,
+    fit: null,
+    offsetX: null,
+    offsetY: null,
     rotation: null,
+    scaleX: null,
+    scaleY: null,
+  },
+  width: 200, // actually required for construction
+  height: 200, // actually required for construction
+  x: null,
+  y: null,
+  elevation: null,
+  sort: null,
+  rotation: null,
+  alpha: null,
+  hidden: null,
+  locked: null,
+  restrictions: {
+    light: null,
+    weather: null,
+  },
+  occlusion: {
+    mode: null,
     alpha: null,
-    hidden: null,
-    locked: null,
-    overhead: null,
-    occlusion: null,
-    video: null,
-    flags: null,
-  }),
-).toEqualTypeOf<foundry.documents.BaseTile>();
-
-expectTypeOf(
-  new foundry.documents.BaseTile({
-    _id: "BGBEITBTEIGE",
-    texture: {
-      src: "path/to/some/image.png",
-      tint: "#FF0000",
-    },
-    width: 100,
-    height: 200,
-    x: 300,
-    y: 500,
-    elevation: 200.2,
-    sort: 1,
-    rotation: 0,
-    alpha: 0,
-    hidden: true,
-    locked: false,
-    overhead: true,
-    occlusion: {
-      mode: foundry.CONST.TILE_OCCLUSION_MODES.FADE,
-      alpha: 1,
-    },
-    video: {
-      loop: true,
-      autoplay: true,
-      volume: 0.5,
-    },
-    flags: {},
-  }),
-).toEqualTypeOf<foundry.documents.BaseTile>();
-
-// @ts-expect-error width and height may not be null
-new foundry.documents.BaseTile({
-  occlusion: {},
+  },
+  video: {
+    loop: null,
+    autoplay: null,
+    volume: null,
+  },
+  flags: null,
+});
+myTile = new TestTile({
+  width: 200, // actually required for construction
+  height: 200, // actually required for construction
+  texture: null,
+  restrictions: null,
+  occlusion: null,
+  video: null,
 });
 
-// @ts-expect-error mode cannot be an arbitrary number.
-new foundry.documents.BaseTile({
-  width: 300,
-  height: 300,
-  occlusion: { mode: 999 },
+myTile = new TestTile({
+  _id: undefined,
+  texture: {
+    src: undefined,
+    tint: undefined,
+    alphaThreshold: undefined,
+    anchorX: undefined,
+    anchorY: undefined,
+    fit: undefined,
+    offsetX: undefined,
+    offsetY: undefined,
+    rotation: undefined,
+    scaleX: undefined,
+    scaleY: undefined,
+  },
+  width: 200, // actually required for construction
+  height: 200, // actually required for construction
+  x: undefined,
+  y: undefined,
+  elevation: undefined,
+  sort: undefined,
+  rotation: undefined,
+  alpha: undefined,
+  hidden: undefined,
+  locked: undefined,
+  restrictions: {
+    light: undefined,
+    weather: undefined,
+  },
+  occlusion: {
+    mode: undefined,
+    alpha: undefined,
+  },
+  video: {
+    loop: undefined,
+    autoplay: undefined,
+    volume: undefined,
+  },
+  flags: undefined,
 });
+myTile = new TestTile({
+  width: 200, // actually required for construction
+  height: 200, // actually required for construction
+  texture: undefined,
+  restrictions: undefined,
+  occlusion: undefined,
+  video: undefined,
+});
+
+expectTypeOf(myTile).toEqualTypeOf<BaseTile>();
+
+expectTypeOf(myTile._id).toEqualTypeOf<string | null>();
+
+// TextureData schema tests are in `tests/foundry/common/data/data.test-d.ts`
+expectTypeOf(myTile.texture).toEqualTypeOf<
+  foundry.data.fields.SchemaField.InitializedData<foundry.data.TextureData.Schema>
+>();
 
-expectTypeOf(
-  new foundry.documents.BaseTile({
-    video: {},
-    width: 300,
-    height: 300,
-  }),
-).toEqualTypeOf<foundry.documents.BaseTile>();
+expectTypeOf(myTile.width).toBeNumber();
+expectTypeOf(myTile.height).toBeNumber();
+expectTypeOf(myTile.x).toBeNumber();
+expectTypeOf(myTile.y).toBeNumber();
+expectTypeOf(myTile.elevation).toBeNumber();
+expectTypeOf(myTile.sort).toBeNumber();
+expectTypeOf(myTile.rotation).toBeNumber();
+expectTypeOf(myTile.alpha).toBeNumber();
+expectTypeOf(myTile.hidden).toBeBoolean();
+expectTypeOf(myTile.locked).toBeBoolean();
+expectTypeOf(myTile.restrictions.light).toBeBoolean();
+expectTypeOf(myTile.restrictions.weather).toBeBoolean();
+expectTypeOf(myTile.occlusion.mode).toEqualTypeOf<CONST.OCCLUSION_MODES | null>();
+expectTypeOf(myTile.occlusion.alpha).toBeNumber();
+expectTypeOf(myTile.video.loop).toBeBoolean();
+expectTypeOf(myTile.video.autoplay).toBeBoolean();
+expectTypeOf(myTile.video.volume).toBeNumber();
+expectTypeOf(myTile.flags).toEqualTypeOf<
+  InterfaceToObject<TileDocument.CoreFlags> & InterfaceToObject<Document.CoreFlags>
+>();
 
-declare const myTile: foundry.documents.BaseTile;
+// document-specific flag(s)
+expectTypeOf(myTile.flags.core?.randomizeVideo).toEqualTypeOf<boolean | undefined>();
 
-expectTypeOf(myTile.overhead).toEqualTypeOf<boolean>();
+// non-schema:
+expectTypeOf((myTile.roof = true)).toBeBoolean();
+expectTypeOf(myTile.roof).toBeBoolean();
+expectTypeOf(myTile.z).toBeNumber();
+expectTypeOf(myTile.overhead).toBeBoolean();
diff --git a/tests/foundry/common/documents/token.test-d.ts b/tests/foundry/common/documents/token.test-d.ts
index c3af1a4d7..08c0681bf 100644
--- a/tests/foundry/common/documents/token.test-d.ts
+++ b/tests/foundry/common/documents/token.test-d.ts
@@ -1,10 +1,180 @@
 import { expectTypeOf } from "vitest";
+import type { InterfaceToObject } from "fvtt-types/utils";
+import BaseToken = foundry.documents.BaseToken;
+import Document = foundry.abstract.Document;
 
 class TestBaseToken extends foundry.documents.BaseToken {}
 
-new TestBaseToken();
+// Token has no hard required fields for construction
+let myToken = new TestBaseToken();
+myToken = new TestBaseToken({});
+myToken = new TestBaseToken({
+  _id: "XXXXXSomeIDXXXXX",
+  name: "Foo the Barbazian",
+  displayName: CONST.TOKEN_DISPLAY_MODES.OWNER,
+  actorId: "YYYYYSomeIDYYYYY",
+  actorLink: false,
+  delta: {
+    // not going to include the entire Actor schema here
+    name: "Foo the Barbazian",
+  },
+  appendNumber: true,
+  prependAdjective: true,
+  width: 2,
+  height: 3,
+  texture: {
+    alphaThreshold: 0.9,
+    anchorX: 0.7,
+    anchorY: 0.8,
+    fit: "cover",
+    offsetX: -5,
+    offsetY: -3,
+    rotation: 35,
+    scaleX: 3.12,
+    scaleY: 2.65,
+    src: "path/to/file.jpg",
+    tint: "#7EBF62",
+  },
+  hexagonalShape: CONST.TOKEN_HEXAGONAL_SHAPES.TRAPEZOID_1,
+  x: 500,
+  y: 737,
+  elevation: -50,
+  sort: 0x42,
+  locked: true,
+  rotation: 99,
+  alpha: 0.87,
+  hidden: false,
+  disposition: CONST.TOKEN_DISPOSITIONS.SECRET,
+  displayBars: CONST.TOKEN_DISPLAY_MODES.ALWAYS,
+  bar1: { attribute: "fizzbuzz" },
+  bar2: { attribute: "buzzfizz" },
+  light: {
+    negative: true,
+    priority: 42,
+    alpha: 0.1,
+    angle: 90,
+    bright: 20,
+    color: "#ABCFED",
+    coloration: 9, // INVERT_ABSORPTION
+    dim: 40,
+    attenuation: 0.34,
+    luminosity: 0.8,
+    saturation: -0.8,
+    contrast: -0.23,
+    shadows: 0.41,
+    animation: {
+      intensity: 3,
+      reverse: true,
+      speed: 7,
+      type: "fairy",
+    },
+    darkness: { min: 0.77, max: 0.99 },
+  },
+  sight: {
+    enabled: true,
+    range: 600,
+    angle: 127,
+    visionMode: "darkvision",
+    color: "#FA12BD",
+    attenuation: 0.3,
+    brightness: -0.1,
+    saturation: 0.6,
+    contrast: -0.21,
+  },
+  detectionModes: [
+    {
+      enabled: true,
+      id: "lightPerception",
+      range: 500,
+    },
+  ],
+  occludable: {
+    radius: 10,
+  },
+  ring: {
+    enabled: true,
+    colors: {
+      ring: "#FAAAAF",
+      background: "#AFFFFA",
+    },
+    effects: foundry.canvas.tokens.TokenRing.effects.BKG_WAVE + foundry.canvas.tokens.TokenRing.effects.RING_GRADIENT,
+    subject: {
+      scale: 2.78,
+      texture: "path/to/subject.webp",
+    },
+  },
+  _regions: ["ZZZZZSomeIDZZZZZ"],
+  flags: {
+    core: {
+      animationSeed: 0o42,
+      randomizeVideo: true,
+    },
+  },
+});
 
-const myToken = new TestBaseToken({ name: "foo" });
+// omitting the null and undefined construction cases due to size and coverage on other documents
 
+expectTypeOf(myToken).toEqualTypeOf<BaseToken>();
+
+expectTypeOf(myToken._id).toEqualTypeOf<string | null>();
+expectTypeOf(myToken.name).toBeString();
+expectTypeOf(myToken.displayName).toEqualTypeOf<CONST.TOKEN_DISPLAY_MODES>();
+expectTypeOf(myToken.actorId).toEqualTypeOf<string | null>();
+expectTypeOf(myToken.actorLink).toBeBoolean();
+expectTypeOf(myToken.delta).toEqualTypeOf<foundry.documents.BaseActor>();
+expectTypeOf(myToken.appendNumber).toBeBoolean();
+expectTypeOf(myToken.prependAdjective).toBeBoolean();
+
+// TextureData schema tests are in `tests/foundry/common/data/data.test-d.ts`
+expectTypeOf(myToken.texture).toEqualTypeOf<
+  foundry.data.fields.SchemaField.InitializedData<foundry.data.TextureData.Schema>
+>();
+
+expectTypeOf(myToken.hexagonalShape).toEqualTypeOf<CONST.TOKEN_HEXAGONAL_SHAPES>();
+expectTypeOf(myToken.x).toBeNumber();
+expectTypeOf(myToken.y).toBeNumber();
+expectTypeOf(myToken.elevation).toBeNumber();
+expectTypeOf(myToken.sort).toBeNumber();
+expectTypeOf(myToken.locked).toBeBoolean();
+expectTypeOf(myToken.lockRotation).toBeBoolean();
+expectTypeOf(myToken.rotation).toBeNumber();
+expectTypeOf(myToken.alpha).toBeNumber();
+expectTypeOf(myToken.hidden).toBeBoolean();
+expectTypeOf(myToken.disposition).toEqualTypeOf<CONST.TOKEN_DISPOSITIONS>();
+expectTypeOf(myToken.displayBars).toEqualTypeOf<CONST.TOKEN_DISPLAY_MODES>();
 expectTypeOf(myToken.bar1.attribute).toEqualTypeOf<string | null>();
-expectTypeOf(myToken.parent!.active).toEqualTypeOf<boolean>();
+expectTypeOf(myToken.bar2.attribute).toEqualTypeOf<string | null>();
+
+// LightData schema tests are in `tests/foundry/common/data/data.test-d.ts`
+expectTypeOf(myToken.light).toEqualTypeOf<foundry.data.LightData>();
+
+expectTypeOf(myToken.sight.enabled).toBeBoolean();
+expectTypeOf(myToken.sight.range).toEqualTypeOf<number | null>();
+expectTypeOf(myToken.sight.angle).toBeNumber();
+expectTypeOf(myToken.sight.visionMode).toBeString();
+expectTypeOf(myToken.sight.color).toEqualTypeOf<Color | null | undefined>;
+expectTypeOf(myToken.sight.attenuation).toBeNumber();
+expectTypeOf(myToken.sight.brightness).toBeNumber();
+expectTypeOf(myToken.sight.saturation).toBeNumber();
+expectTypeOf(myToken.sight.contrast).toBeNumber();
+if (myToken.detectionModes[0]) {
+  expectTypeOf(myToken.detectionModes[0].id).toEqualTypeOf<string | undefined>();
+  expectTypeOf(myToken.detectionModes[0].enabled).toBeBoolean();
+  expectTypeOf(myToken.detectionModes[0].range).toEqualTypeOf<number | null>();
+}
+expectTypeOf(myToken.ring.enabled).toBeBoolean();
+expectTypeOf(myToken.ring.subject.texture).toEqualTypeOf<string | null | undefined>();
+// TODO: ArrayField<ForeignDocumentField> is returning `never[]`
+expectTypeOf(myToken._regions).toEqualTypeOf<Array<string | null>>();
+expectTypeOf(myToken.flags).toEqualTypeOf<
+  InterfaceToObject<TokenDocument.CoreFlags> & InterfaceToObject<Document.CoreFlags>
+>();
+
+// The following fields can't really be `undefined` because they have `initial`s, see https://github.com/League-of-Foundry-Developers/foundry-vtt-types/issues/3055
+expectTypeOf(myToken.width).toEqualTypeOf<number | undefined>();
+expectTypeOf(myToken.height).toEqualTypeOf<number | undefined>();
+expectTypeOf(myToken.occludable.radius).toEqualTypeOf<number | undefined>();
+expectTypeOf(myToken.ring.colors.ring).toEqualTypeOf<Color | null | undefined>();
+expectTypeOf(myToken.ring.colors.background).toEqualTypeOf<Color | null | undefined>();
+expectTypeOf(myToken.ring.effects).toEqualTypeOf<number | null | undefined>();
+expectTypeOf(myToken.ring.subject.scale).toEqualTypeOf<number | null | undefined>();
diff --git a/tests/foundry/common/documents/wall.test-d.ts b/tests/foundry/common/documents/wall.test-d.ts
index d2f11fb9a..4b8e3c3a1 100644
--- a/tests/foundry/common/documents/wall.test-d.ts
+++ b/tests/foundry/common/documents/wall.test-d.ts
@@ -1,65 +1,21 @@
 import { expectTypeOf } from "vitest";
+import type { InterfaceToObject } from "fvtt-types/utils";
+import BaseWall = foundry.documents.BaseWall;
+import Document = foundry.abstract.Document;
 
-declare const myScene: Scene;
+class TestBaseWall extends BaseWall {}
 
-class TestBaseWall extends foundry.documents.BaseWall {}
-
-// @ts-expect-error - A BaseWall requires data.
-new TestBaseWall();
-
-// @ts-expect-error - A BaseWall requires c (coordinates).
-new TestBaseWall({});
-
-new TestBaseWall({ c: [0, 0, 0, 0] });
-new TestBaseWall({ c: [0, 0, 0, 0] }, { parent: myScene });
+//TODO: ensure `c` required for creation
+// @ts-expect-error Wall requires `c` for creation
+let myWall = new TestBaseWall();
+// @ts-expect-error Wall requires `c` for creation
+myWall = new TestBaseWall({});
 
 // @ts-expect-error - c must be a length-4 array of integer coordinates
-new TestBaseWall({ c: [10, 20] });
-// @ts-expect-error - c must be a length-4 array of integer coordinates
-new TestBaseWall({ c: [10, 20, 30, 40, 50] });
+myWall = new TestBaseWall({ c: [10, 20] });
 
-expectTypeOf(new TestBaseWall({ c: [10, 20, 30, 40] })).toEqualTypeOf<foundry.documents.BaseWall>();
-expectTypeOf(
-  new TestBaseWall({
-    _id: null,
-    c: [10, 20, 30, 40],
-    light: null,
-    move: null,
-    sight: null,
-    sound: null,
-    dir: null,
-    door: null,
-    ds: null,
-    flags: null,
-  }),
-).toEqualTypeOf<foundry.documents.BaseWall>();
-expectTypeOf(
-  new TestBaseWall({
-    _id: undefined,
-    c: [10, 20, 30, 40],
-    light: undefined,
-    move: undefined,
-    sight: undefined,
-    sound: undefined,
-    dir: undefined,
-    door: undefined,
-    ds: undefined,
-    flags: undefined,
-  }),
-).toEqualTypeOf<foundry.documents.BaseWall>();
-expectTypeOf(
-  new TestBaseWall({
-    c: [10, 20, 30, 40],
-    light: foundry.CONST.WALL_SENSE_TYPES.NORMAL,
-    move: foundry.CONST.WALL_MOVEMENT_TYPES.NORMAL,
-    sight: foundry.CONST.WALL_SENSE_TYPES.NORMAL,
-    sound: foundry.CONST.WALL_SENSE_TYPES.NORMAL,
-    dir: foundry.CONST.WALL_DIRECTIONS.BOTH,
-    door: foundry.CONST.WALL_DOOR_TYPES.NONE,
-    ds: foundry.CONST.WALL_DOOR_STATES.CLOSED,
-    flags: {},
-  }),
-).toEqualTypeOf<foundry.documents.BaseWall>();
+// @ts-expect-error - c must be a length-4 array of integer coordinates
+myWall = new TestBaseWall({ c: [10, 20, 30, 40, 50] });
 
 new TestBaseWall({
   c: [10, 20, 30, 40],
@@ -102,3 +58,86 @@ new TestBaseWall({
   // @ts-expect-error - ds can't be an arbitrary number
   ds: 9999,
 });
+
+myWall = new TestBaseWall({
+  _id: "XXXXXSomeIDXXXXX",
+  c: [20, 30, 240, 340],
+  light: CONST.WALL_SENSE_TYPES.DISTANCE,
+  move: CONST.WALL_MOVEMENT_TYPES.NORMAL,
+  sight: CONST.WALL_SENSE_TYPES.LIMITED,
+  sound: CONST.WALL_SENSE_TYPES.PROXIMITY,
+  dir: CONST.WALL_DIRECTIONS.LEFT,
+  door: CONST.WALL_DOOR_TYPES.SECRET,
+  ds: CONST.WALL_DOOR_STATES.LOCKED,
+  doorSound: "futuristicForcefield",
+  threshold: {
+    light: 20,
+    sight: 20,
+    sound: 50,
+    attenuation: true,
+  },
+  flags: {
+    core: {
+      sheetLock: false,
+    },
+  },
+});
+myWall = new TestBaseWall({
+  _id: null,
+  c: [20, 30, 240, 340],
+  light: null,
+  move: null,
+  sight: null,
+  sound: null,
+  dir: null,
+  door: null,
+  ds: null,
+  doorSound: null,
+  threshold: {
+    light: null,
+    sight: null,
+    sound: null,
+    attenuation: null,
+  },
+  flags: null,
+});
+myWall = new TestBaseWall({ threshold: null });
+
+myWall = new TestBaseWall({
+  _id: undefined,
+  c: [20, 30, 240, 340],
+  light: undefined,
+  move: undefined,
+  sight: undefined,
+  sound: undefined,
+  dir: undefined,
+  door: undefined,
+  ds: undefined,
+  doorSound: undefined,
+  threshold: {
+    light: undefined,
+    sight: undefined,
+    sound: undefined,
+    attenuation: undefined,
+  },
+  flags: undefined,
+});
+myWall = new TestBaseWall({ threshold: undefined });
+
+expectTypeOf(myWall).toEqualTypeOf<foundry.documents.BaseWall>();
+
+expectTypeOf(myWall._id).toEqualTypeOf<string | null>();
+expectTypeOf(myWall.c).toEqualTypeOf<[number, number, number, number]>();
+expectTypeOf(myWall.light).toEqualTypeOf<CONST.WALL_SENSE_TYPES | null>();
+expectTypeOf(myWall.move).toEqualTypeOf<CONST.WALL_MOVEMENT_TYPES | null>();
+expectTypeOf(myWall.sight).toEqualTypeOf<CONST.WALL_SENSE_TYPES | null>();
+expectTypeOf(myWall.sound).toEqualTypeOf<CONST.WALL_SENSE_TYPES | null>();
+expectTypeOf(myWall.dir).toEqualTypeOf<CONST.WALL_DIRECTIONS | null>();
+expectTypeOf(myWall.door).toEqualTypeOf<CONST.WALL_DOOR_TYPES | null>();
+expectTypeOf(myWall.ds).toEqualTypeOf<CONST.WALL_DOOR_STATES | null>();
+expectTypeOf(myWall.doorSound).toEqualTypeOf<string | undefined>();
+expectTypeOf(myWall.threshold.light).toEqualTypeOf<number | null>();
+expectTypeOf(myWall.threshold.sight).toEqualTypeOf<number | null>();
+expectTypeOf(myWall.threshold.sound).toEqualTypeOf<number | null>();
+expectTypeOf(myWall.threshold.attenuation).toBeBoolean();
+expectTypeOf(myWall.flags).toEqualTypeOf<InterfaceToObject<Document.CoreFlags>>();