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

package/src/foundry/common/data/fields.d.mts

@@ -1,20 +1,22 @@
 import type {
   RemoveIndexSignatures,
   SimpleMerge,
-  ValueOf,
   AnyObject,
   EmptyObject,
   NullishProps,
   InexactPartial,
-  AnyConstructor,
-} from "../../../types/utils.d.mts";
+  FixedInstanceType,
+  Identity,
+  PrettifyType,
+  InterfaceToObject,
+  AnyArray,
+} from "#utils";
 import type { DataModel } from "../abstract/data.mts";
 import type Document from "../abstract/document.mts";
 import type { EmbeddedCollection, EmbeddedCollectionDelta, TypeDataModel } from "../abstract/module.d.mts";
 import type { DOCUMENT_OWNERSHIP_LEVELS } from "../constants.d.mts";
 import type { CONST } from "../../client-esm/client.d.mts";
 import type { DataModelValidationFailure } from "./validation-failure.mts";
-import type { EffectChangeData } from "../documents/_types.d.mts";
 import type {
   FormGroupConfig,
   FormInputConfig,
@@ -23,100 +25,8 @@ import type {
   SelectInputConfig,
   TextAreaInputConfig,
 } from "../../client-esm/applications/forms/fields.d.mts";
-import type { ToMethod } from "../../../types/helperTypes.d.mts";
 
-declare global {
-  /**
-   * @typeParam BaseAssignmentType - the base assignment type for a DataField, without null or undefined
-   */
-  interface DataFieldOptions<BaseAssignmentType> {
-    /**
-     * Is this field required to be populated?
-     * @defaultValue `false`
-     */
-    required?: boolean | undefined;
-
-    /**
-     * Can this field have null values?
-     * @defaultValue `false`
-     */
-    nullable?: boolean | undefined;
-
-    /**
-     * Can this field only be modified by a gamemaster or assistant gamemaster?
-     * @defaultValue `false`
-     */
-    gmOnly?: boolean | undefined;
-
-    /** The initial value of a field, or a function which assigns that initial value. */
-    initial?:
-      | DataFieldOptions.InitialType<
-          DataFieldOptions.InitialReturnType<BaseAssignmentType, this["nullable"], this["required"]>
-        >
-      | undefined;
-
-    /** A data validation function which accepts one argument with the current value. */
-    validate?: DataField.Validator<BaseAssignmentType> | undefined;
-
-    /** A localizable label displayed on forms which render this field. */
-    label?: string | undefined;
-
-    /** Localizable help text displayed on forms which render this field. */
-    hint?: string | undefined;
-
-    /**
-     * A custom validation error string. When displayed will be prepended with the
-     * document name, field name, and candidate value. This error string is only
-     * used when the return type of the validate function is a boolean. If an Error
-     * is thrown in the validate function, the string message of that Error is used.
-     */
-    validationError?: string | undefined;
-  }
-
-  namespace DataFieldOptions {
-    /** Any DataFieldOptions. */
-    // Note(LukeAbby): This `& object` is intentional. Its purpose is to allow options like `{ integer: true }` to be assigned.
-    // This is an issue because `{ integer: true }` does not extend `{ required?: boolean }` because they have properties in common.
-    // Even though `{ integer: true, required: undefined }` would extend `{ required?: boolean }` following the regular rules of surplus properties being allowed.
-    // `object` was chosen over `AnyObject` so that people may pass in interfa
-    type Any = DataFieldOptions<any> & object;
-
-    /**
-     * A helper type for the {@link DataFieldOptions.initial} option.
-     * @typeParam ReturnType - the return type of the option
-     */
-    type InitialType<ReturnType> = ReturnType | ((initialData: unknown) => ReturnType);
-
-    /**
-     * The decorated return type for the {@link DataFieldOptions.initial} option.
-     * @typeParam BaseAssignmentType - the base assignment type for a DataField
-     * @typeParam NullableOption     - the value of the nullable option
-     * @typeParam RequiredOption     - the value of the required option
-     */
-    type InitialReturnType<BaseAssignmentType, NullableOption, RequiredOption> =
-      | Exclude<BaseAssignmentType, null | undefined>
-      | (NullableOption extends true ? null : never)
-      | (RequiredOption extends true ? never : undefined);
-  }
-
-  interface DataFieldValidationOptions {
-    /** Whether this is a partial schema validation, or a complete one. */
-    partial?: boolean;
-
-    /** Whether to allow replacing invalid values with valid fallbacks. */
-    fallback?: boolean;
-
-    /** The full source object being evaluated. */
-    source?: AnyObject;
-
-    /**
-     * If true, invalid embedded documents will emit a warning and be placed in
-     * the invalidDocuments collection rather than causing the parent to be
-     * considered invalid.
-     */
-    dropInvalidEmbedded?: boolean;
-  }
-}
+export type DataSchema = Record<string, DataField.Any>;
 
 /**
  * An abstract class that defines the base pattern for a data field within a data schema.
@@ -126,24 +36,35 @@ declare global {
  * @typeParam PersistedType   - the type of the persisted values of the DataField
  * @remarks
  * Defaults:
- * AssignmentType: `unknown | null | undefined`
- * InitializedType: `unknown | undefined`
- * PersistedType: `unknown | undefined`
- * InitialValue: `undefined`
+ * - AssignmentType: `unknown | null | undefined`
+ * - InitializedType: `unknown | undefined`
+ * - PersistedType: `unknown | undefined`
+ * - InitialValue: `undefined`
  */
 declare abstract class DataField<
-  const Options extends DataFieldOptions.Any = DataField.DefaultOptions,
+  const Options extends DataField.Options.Any = DataField.DefaultOptions,
   const AssignmentType = DataField.AssignmentType<Options>,
   const InitializedType = DataField.InitializedType<Options>,
-  const PersistedType extends unknown | null | undefined = InitializedType,
+  const PersistedType = InitializedType,
 > {
   // Prevent from being bivariant.
   #assignmentType: AssignmentType;
 
   /**
    * @param options - Options which configure the behavior of the field
+   * @param context - Additional context which describes the field
    */
-  constructor(options?: Options, context?: DataField.Context);
+  // options: not null (unchecked `in` operation), context: not null (destructured)
+  constructor(options?: Options, context?: DataField.ConstructionContext);
+
+  /** @internal */
+  " __fvtt_types_internal_source_data": PersistedType;
+
+  /** @internal */
+  " __fvtt_types_internal_assignment_data": AssignmentType;
+
+  /** @internal */
+  " __fvtt_types_internal_initialized_data": InitializedType;
 
   /** The initially provided options which configure the data field */
   options: Options;
@@ -170,7 +91,7 @@ declare abstract class DataField<
    * The initial value of a field, or a function which assigns that initial value.
    * @defaultValue `undefined`
    */
-  initial: DataFieldOptions.InitialType<InitializedType>;
+  initial: DataField.Options.InitialType<InitializedType>;
 
   /**
    * Should the prepared value of the field be read-only, preventing it from being
@@ -205,14 +126,14 @@ declare abstract class DataField<
    *
    * The field name of this DataField instance.
    * This is assigned by SchemaField#initialize.
-   * @internal
+   * @remarks Foundry marked `@internal`
    */
   name: string | undefined;
 
   /**
    * A reference to the parent schema to which this DataField belongs.
    * This is assigned by SchemaField#initialize.
-   * @internal
+   * @remarks Foundry marked `@internal`
    */
   parent: DataField.Any | undefined;
 
@@ -234,10 +155,11 @@ declare abstract class DataField<
    * Default parameters for this field type
    * @remarks This is not entirely type-safe, overrides should specify a more concrete return type.
    */
-  protected static get _defaults(): DataFieldOptions.Any;
+  protected static get _defaults(): DataField.Options.Any;
 
   /**
    * A dot-separated string representation of the field path within the parent schema.
+   * @remarks Returns `""` if both `this.parent?.fieldPath` and `this.name` are falsey
    */
   get fieldPath(): string;
 
@@ -245,13 +167,14 @@ declare abstract class DataField<
    * Apply a function to this DataField which propagates through recursively to any contained data schema.
    * @param fn      - The function to apply
    * @param value   - The current value of this field
-   * @param options - Additional options passed to the applied function
-   *                  (default `{}`)
+   * @param options - Additional options passed to the applied function (default `{}`)
    * @returns The results object
    */
-  apply<Value, Options, Return>(
-    fn: keyof this | ((this: this, value: Value, options: Options) => Return),
-    value: Value,
+  // TODO: Determine `value` based upon the field metadata in fields-v2 (while allowing subclasses to narrow allowed values)
+  // options: not null (could be forwarded somewhere destructured, parameter default only)
+  apply<Options, Return>(
+    fn: keyof this | ((this: this, value: unknown, options: Options) => Return),
+    value?: unknown,
     options?: Options,
   ): Return;
 
@@ -263,6 +186,7 @@ declare abstract class DataField<
    * @param options - Additional options for how the field is cleaned
    * @returns The cast value
    */
+  // options: not null (parameter default only, property access)
   clean(value: AssignmentType, options?: DataField.CleanOptions): InitializedType;
 
   /**
@@ -270,8 +194,9 @@ declare abstract class DataField<
    * @param value   - The appropriately coerced value.
    * @param options - Additional options for how the field is cleaned.
    * @returns The cleaned value.
+   * @remarks Simply returns `value` in `DataField`. `options` is unused in `DataField`
    */
-  protected _cleanType(value: InitializedType, options?: DataField.CleanOptions): InitializedType;
+  protected _cleanType(value: InitializedType, options?: DataField.CleanOptions | null): InitializedType;
 
   /**
    * Cast a non-default value to ensure it is the correct type for the field
@@ -285,8 +210,12 @@ declare abstract class DataField<
    * @param data - The source data object for which an initial value is required
    * @returns A valid initial value
    * @throws An error if there is no valid initial value defined
+   * @remarks The `@throws` is Foundry's, and is wrong, as all fields will at a minimum inherit `initial: undefined` from DataField.
+   *
+   * `data` is unused if the field's `initial` is not a function.
    */
-  getInitialValue(data: DataField.CleanOptions["source"]): InitializedType;
+  // TODO: the @throws is omitted in v13, clean up remarks
+  getInitialValue(data?: unknown): InitializedType;
 
   /**
    * Validate a candidate input for this field, ensuring it meets the field requirements.
@@ -298,10 +227,8 @@ declare abstract class DataField<
    *                  (default: `{}`)
    * @returns Returns a ModelValidationError if a validation failure occurred
    */
-  validate(
-    value: AssignmentType,
-    options?: DataField.ValidationOptions<DataField.Any>,
-  ): DataModelValidationFailure | undefined;
+  // options: not null (parameter default only, property access)
+  validate(value: AssignmentType, options?: DataField.ValidateOptions<this>): DataModelValidationFailure | void;
 
   /**
    * Special validation rules which supersede regular field validation.
@@ -322,9 +249,10 @@ declare abstract class DataField<
    *          otherwise void.
    * @throws May throw a specific error if the value is not valid
    */
+  // options: not null (parameter default only, property access in subclasses)
   protected _validateType(
     value: InitializedType,
-    options?: DataField.ValidationOptions<DataField.Any>,
+    options?: DataField.ValidateOptions<this>,
   ): boolean | DataModelValidationFailure | void;
 
   /**
@@ -333,9 +261,17 @@ declare abstract class DataField<
    * @param data    - Candidate data for joint model validation
    * @param options - Options which modify joint model validation
    * @throws  An error if joint model validation fails
-   * @internal
+   * @remarks Foundry marked `@internal`
+   *
+   * The only place core checks the `options` for any property is in {@link TypeDataField._validateModel | `TypeDataField#_validateModel`},
+   * where it checks `options.source?.type`
+   *
+   * {@link SchemaField._validateModel | `SchemaField._validateModel`} enforces `source`'s existence for subsidiary calls
+   *
+   * The only place core *calls* this at a top level, it does not pass anything for `options`, relying on SchemaField above
+   * to make TypeDataField work
    */
-  protected _validateModel(data: AnyObject, options?: AnyObject): void; // TODO: Type further.
+  protected _validateModel(data: AnyObject, options?: DataField.ValidateModelOptions | null): void; // TODO: Type further.
 
   /**
    * Initialize the original source data into a mutable copy for the DataModel instance.
@@ -343,12 +279,18 @@ declare abstract class DataField<
    * @param model   - The DataModel instance that this field belongs to
    * @param options - Initialization options
    * @returns An initialized copy of the source data
+   * @remarks Core fields that return a function:
+   * - {@link ForeignDocumentField | `ForeignDocumentField`}
+   * - `ActorDeltaField` (exported in the BaseToken file but not re-exported by the relevant `_module`, so unlinkable)
    */
+  // TODO: investigate narrowing return to just `InitializedType` on inheritance lines that don't possibly return one
+  // TODO: (everything except SchemaField and ObjectField and their descendants)
+  // options: not null (parameter default only)
   initialize(
     value: PersistedType,
     model: DataModel.Any,
-    options?: AnyObject, // TODO: Type further.
-  ): (() => InitializedType | null) | InitializedType;
+    options?: DataField.InitializeOptions,
+  ): InitializedType | (() => InitializedType | null);
 
   /**
    * Export the current value of the field into a serializable object.
@@ -361,7 +303,7 @@ declare abstract class DataField<
    * Recursively traverse a schema and retrieve a field specification by a given path
    * @param path - The field path as an array of strings
    */
-  protected _getField(path: string[]): unknown; // TODO: Type further.
+  protected _getField(path: string[]): DataField.Any | undefined;
 
   /**
    * Does this form field class have defined form support?
@@ -403,7 +345,7 @@ declare abstract class DataField<
    * @param change - The change to apply.
    * @returns The updated value.
    */
-  applyChange(value: InitializedType, model: DataModel.Any, change: EffectChangeData): InitializedType;
+  applyChange(value: InitializedType, model: DataModel.Any, change: ActiveEffect.EffectChangeData): InitializedType;
 
   /**
    * Cast a change delta into an appropriate type to be applied to this field.
@@ -421,13 +363,15 @@ declare abstract class DataField<
    * @param model  - The model instance.
    * @param change - The original change data.
    * @returns - The updated value.
+   *
+   * @remarks Returns `value + delta`. `model` and `change` are unused in `DataField`
    */
   protected _applyChangeAdd(
     value: InitializedType,
     delta: InitializedType,
     model: DataModel.Any,
-    change: EffectChangeData,
-  ): InitializedType | undefined;
+    change: ActiveEffect.EffectChangeData,
+  ): InitializedType;
 
   /**
    * Apply a MULTIPLY change to this field.
@@ -436,12 +380,14 @@ declare abstract class DataField<
    * @param model  - The model instance.
    * @param change - The original change data.
    * @returns The updated value.
+   *
+   * @remarks No-op in `DataField`, returns `undefined` unless overridden
    */
   protected _applyChangeMultiply(
     value: InitializedType,
     delta: InitializedType,
     model: DataModel.Any,
-    change: EffectChangeData,
+    change: ActiveEffect.EffectChangeData,
   ): InitializedType | undefined;
 
   /**
@@ -451,13 +397,15 @@ declare abstract class DataField<
    * @param model  - The model instance.
    * @param change - The original change data.
    * @returns The updated value.
+   *
+   * @returns Simply returns `delta`. `value`, `model`, and `change` are unused in `DataField`
    */
   protected _applyChangeOverride(
     value: InitializedType,
     delta: InitializedType,
     model: DataModel.Any,
-    change: EffectChangeData,
-  ): InitializedType | undefined;
+    change: ActiveEffect.EffectChangeData,
+  ): InitializedType;
 
   /**
    * Apply an UPGRADE change to this field.
@@ -466,12 +414,14 @@ declare abstract class DataField<
    * @param model - The model instance.
    * @param change - The original change data.
    * @returns - The updated value.
+   *
+   * @remarks No-op in `DataField`, returns `undefined` unless overridden
    */
   protected _applyChangeUpgrade(
     value: InitializedType,
     delta: InitializedType,
     model: DataModel.Any,
-    change: EffectChangeData,
+    change: ActiveEffect.EffectChangeData,
   ): InitializedType | undefined;
 
   /**
@@ -481,12 +431,14 @@ declare abstract class DataField<
    * @param model  - The model instance.
    * @param change - The original change data.
    * @returns The updated value.
+   *
+   * @remarks No-op in `DataField`, returns `undefined` unless overridden
    */
   protected _applyChangeDowngrade(
     value: InitializedType,
     delta: InitializedType,
     model: DataModel.Any,
-    change: EffectChangeData,
+    change: ActiveEffect.EffectChangeData,
   ): InitializedType | undefined;
 
   /**
@@ -496,20 +448,20 @@ declare abstract class DataField<
    * @param model - The model instance.
    * @param change - The original change data.
    * @returns - The updated value.
+   * @remarks Only returns a value if the target value of the change actually changed
    */
   protected _applyChangeCustom(
     value: InitializedType,
     delta: InitializedType,
     model: DataModel.Any,
-    change: EffectChangeData,
-  ): InitializedType;
+    change: ActiveEffect.EffectChangeData,
+  ): InitializedType | undefined;
 }
 
 declare namespace DataField {
   /** Any DataField. */
-  type Any = DataField<DataFieldOptions.Any, unknown, unknown, unknown>;
-
-  type AnyConstructor = typeof AnyDataField;
+  interface Any extends AnyDataField {}
+  interface AnyConstructor extends Identity<typeof AnyDataField> {}
 
   /** A DataField with unknown inner types. */
   type Unknown = DataField<any, unknown, unknown, unknown>;
@@ -523,7 +475,7 @@ declare namespace DataField {
   type PersistedTypeFor<ConcreteDataField extends Any> =
     ConcreteDataField extends DataField<any, any, any, infer PersistedType> ? PersistedType : never;
 
-  /** The type of the default options for the {@link DataField} class. */
+  /** The type of the default options for the {@link DataField | `DataField`} class. */
   interface DefaultOptions {
     required: false;
     nullable: false;
@@ -535,18 +487,90 @@ declare namespace DataField {
     validationError: "is not a valid value";
   }
 
+  interface Options<BaseAssignmentType> {
+    /**
+     * Is this field required to be populated?
+     * @defaultValue `false`
+     */
+    required?: boolean | undefined;
+
+    /**
+     * Can this field have null values?
+     * @defaultValue `false`
+     */
+    nullable?: boolean | undefined;
+
+    /**
+     * Can this field only be modified by a gamemaster or assistant gamemaster?
+     * @defaultValue `false`
+     */
+    gmOnly?: boolean | undefined;
+
+    /** The initial value of a field, or a function which assigns that initial value. */
+    initial?:
+      | DataField.Options.InitialType<
+          // TODO(LukeAbby): Add a `ValidateOptions` type or something of that sort in order to
+          // catch incorrect initial types.
+          DataField.Options.InitialReturnType<BaseAssignmentType, boolean, boolean>
+        >
+      | undefined;
+
+    /** A data validation function which accepts one argument with the current value. */
+    validate?: DataField.Validator<DataField.Any, BaseAssignmentType> | undefined;
+
+    /** A localizable label displayed on forms which render this field. */
+    label?: string | undefined;
+
+    /** Localizable help text displayed on forms which render this field. */
+    hint?: string | undefined;
+
+    /**
+     * A custom validation error string. When displayed will be prepended with the
+     * document name, field name, and candidate value. This error string is only
+     * used when the return type of the validate function is a boolean. If an Error
+     * is thrown in the validate function, the string message of that Error is used.
+     */
+    validationError?: string | undefined;
+  }
+
+  namespace Options {
+    /** Any DataField.Options. */
+    // Note(LukeAbby): This `& object` is intentional. Its purpose is to allow options like `{ integer: true }` to be assigned.
+    // This is an issue because `{ integer: true }` does not extend `{ required?: boolean }` because they have no properties in common.
+    // Even though `{ integer: true, required: undefined }` would extend `{ required?: boolean }` following the regular rules of surplus properties being allowed.
+    // `object` was chosen over `AnyObject` so that people may pass in interfaces.
+    interface Any extends DataField.Options<any>, Identity<object> {}
+
+    /**
+     * A helper type for the {@link DataField.Options.initial | `DataField.Options.initial`} option.
+     * @typeParam ReturnType - the return type of the option
+     */
+    type InitialType<ReturnType> = ReturnType | ((initialData: unknown) => ReturnType);
+
+    /**
+     * The decorated return type for the {@link DataField.Options.initial | `DataField.Options.initial`} option.
+     * @typeParam BaseAssignmentType - the base assignment type for a DataField
+     * @typeParam NullableOption     - the value of the nullable option
+     * @typeParam RequiredOption     - the value of the required option
+     */
+    type InitialReturnType<BaseAssignmentType, NullableOption, RequiredOption> =
+      | Exclude<BaseAssignmentType, null | undefined>
+      | (NullableOption extends true ? null : never)
+      | (RequiredOption extends true ? never : undefined);
+  }
+
   /**
    * A helper type for the given options type merged into the default options of the DataField class.
    * @typeParam Options - the options that override the default options
    */
-  type MergedOptions<Options extends DataFieldOptions.Any> = SimpleMerge<DefaultOptions, Options>;
+  type MergedOptions<Options extends DataField.Options.Any> = SimpleMerge<DefaultOptions, Options>;
 
   /**
    * A type to decorate the base assignment type to a DataField, based on the options of the field.
    * @typeParam BaseAssignmentType - the base assignment type of the DataField, without null or undefined
    * @typeParam Options            - the options of the DataField
    */
-  type DerivedAssignmentType<BaseAssignmentType, Options extends DataFieldOptions.Any> =
+  type DerivedAssignmentType<BaseAssignmentType, Options extends DataField.Options.Any> =
     | Exclude<BaseAssignmentType, null | undefined> // Always include the base type
     | (Options["nullable"] extends true // determine whether null is in the union
         ? // when nullable, null is always allowed
@@ -576,7 +600,7 @@ declare namespace DataField {
    * @typeParam BaseInitializedType - the base initialized type of the DataField, without null or undefined
    * @typeParam Options             - the options of the DataField
    */
-  type DerivedInitializedType<BaseInitializedType, Options extends DataFieldOptions.Any> =
+  type DerivedInitializedType<BaseInitializedType, Options extends DataField.Options.Any> =
     | Exclude<BaseInitializedType, null | undefined>
     | (Options["nullable"] extends true ? null : never)
     | (Options["required"] extends true ? never : undefined);
@@ -585,24 +609,89 @@ declare namespace DataField {
    * A shorthand for the assignment type of a DataField class.
    * @typeParam Options - the options overriding the defaults
    */
-  type AssignmentType<Options extends DataFieldOptions.Any> = DerivedAssignmentType<any, MergedOptions<Options>>;
+  type AssignmentType<Options extends DataField.Options.Any> = DerivedAssignmentType<any, MergedOptions<Options>>;
 
   /**
    * A shorthand for the initialized type of a DataField class.
    * @typeParam Options - the options overriding the defaults
    */
-  type InitializedType<Options extends DataFieldOptions.Any> = DerivedInitializedType<any, MergedOptions<Options>>;
+  type InitializedType<Options extends DataField.Options.Any> = DerivedInitializedType<any, MergedOptions<Options>>;
 
-  /** An interface for the options of the {@link DataField} clean functions. */
-  interface CleanOptions {
+  /** @internal */
+  type _ConstructionContext = NullishProps<{
+    /** A field name to assign to the constructed field */
+    name?: string;
+  }> &
+    InexactPartial<{
+      /**
+       * Another data field which is a hierarchical parent of this one
+       * @remarks Can't be `null` as there's a `!== undefined` check in {@link SchemaField._initialize | `SchemaField#_initialize`}
+       */
+      parent?: DataField.Any;
+    }>;
+
+  interface ConstructionContext extends _ConstructionContext {}
+
+  /** @internal */
+  type _ValidationOptions = NullishProps<{
+    /** Whether this is a partial schema validation, or a complete one. */
+    partial: boolean;
+
+    /** Whether to allow replacing invalid values with valid fallbacks. */
+    fallback: boolean;
+
+    /**
+     * If true, invalid embedded documents will emit a warning and be placed in the invalidDocuments
+     * collection rather than causing the parent to be considered invalid.
+     */
+    dropInvalidEmbedded?: boolean;
+  }> &
+    InexactPartial<{
+      /**
+       * The full source object being evaluated.
+       * @privateRemarks Disallowing `null` as this value gets passed to provided `initial` functions,
+       * and users shouldn't have to expect `null`
+       */
+      source: AnyObject;
+    }>;
+
+  /**
+   * @remarks This is the type for the options for `#validate` and associate methods *without* the
+   * possible inclusion of a `validator` function.
+   *
+   * If you are looking for the type with a generic formerly under this name, see {@link ValidateOptions | `DataField.ValidateOptions`}
+   */
+  interface ValidationOptions extends _ValidationOptions {}
+
+  /**
+   * @deprecated Use {@link ValidateOptions | `DataField.ValidationOptions`} instead if you need a direct replacement,
+   * or {@link ValidateOptions | `DataField.ValidateOptions`} if you're typing the options of `#validate` or an associated
+   * method.
+   */
+  interface DataValidationOptions extends ValidationOptions {}
+
+  /** @internal */
+  type _CleanOptions = NullishProps<{
     /** Whether to perform partial cleaning? */
-    partial?: boolean;
+    partial: boolean;
 
     /** The root data model being cleaned */
-    source?: {
-      type?: string;
-    };
-  }
+    source: AnyObject;
+  }>;
+
+  /** An interface for the options of {@link DataField.clean | `DataField#clean`} and {@link DataField._cleanType | `DataField#_cleanType`}. */
+  interface CleanOptions extends _CleanOptions {}
+
+  /**
+   * @remarks The only place core checks the `options` for any property is in {@link TypeDataField._validateModel | `TypeDataField#_validateModel`},
+   * where it checks `options.source?.type`
+   *
+   * {@link SchemaField._validateModel | `SchemaField._validateModel`} enforces `source`'s existence for subsidiary calls
+   *
+   * The only place core *calls* this at a top level, it does not pass anything for `options`, relying on SchemaField above
+   * to make TypeDataField work
+   */
+  interface ValidateModelOptions extends Pick<ValidationOptions, "source"> {}
 
   /**
    * A Custom DataField validator function.
@@ -615,31 +704,55 @@ declare namespace DataField {
    *
    * An Error may be thrown which provides a custom error message explaining the reason the value is invalid.
    */
-  type Validator<BaseAssignmentType> = ToMethod<
-    (
-      this: DataField,
-      // TODO(LukeAbby): Always allowing `null | undefined` may be too lenient but it's probably the best type for the time being.
-      value: BaseAssignmentType | null | undefined,
-      options: ValidationOptions<DataField>,
-    ) => DataModelValidationFailure | boolean | void
-  >;
+  type Validator<CurrentField extends DataField.Any, BaseAssignmentType> =
+    | {
+        validate(
+          this: CurrentField,
+          value: unknown,
+          options: ValidateOptions<CurrentField>,
+        ): value is BaseAssignmentType;
+      }["validate"]
+    | {
+        validate(
+          this: CurrentField,
+          value: unknown,
+          options: ValidateOptions<CurrentField>,
+        ): asserts value is BaseAssignmentType;
+      }["validate"]
+    | {
+        validate(
+          this: CurrentField,
+          value: unknown,
+          options: ValidateOptions<CurrentField>,
+        ): DataModelValidationFailure | boolean | void;
+      }["validate"];
 
   /**
-   * An interface for the options of the {@link DataField} validation functions.
-   * @typeParam DataField - the type of the DataField, which is the receiver of the validate function
+   * An interface for the options of the {@link DataField | `DataField`} validation functions.
+   * @typeParam CurrentField - the type of the DataField, which is the receiver of the validate function
    */
-  interface ValidationOptions<DataField extends DataField.Any> extends DataValidationOptions {
-    source?: AnyObject;
-    validate?: Validator<DataField.AssignmentTypeFor<DataField>>;
+  interface ValidateOptions<CurrentField extends DataField.Any> extends ValidationOptions {
+    /**
+     * @remarks If {@link DataField.validate | `DataField#validate`} is called with a `validate: someFunc` in its `options`,
+     * it will then pass that `options` object on to that function when it calls it, without alteration.
+     * Nothing in core makes use of the fact that a reference to the function is available, this seems incidental.
+     */
+    validate?: Validator<CurrentField, DataField.AssignmentTypeFor<CurrentField>>;
   }
 
-  interface Context {
-    /** A field name to assign to the constructed field */
-    name: string;
-
-    /** Another data field which is a hierarchical parent of this one */
-    parent: DataField.Any;
-  }
+  /**
+   * @remarks The `options` passed to {@link DataField.initialize | `DataField#initialize`} exclusively (in core) come from
+   * {@link DataModel._initialize | `DataModel#_initialize`} or an override (meaning `parent` has been stripped from the
+   * interface), and eventually hits one of:
+   * 1. Document construction, in all cases with `parent` already provided
+   * 2. Gets fed back {@link DataModel._initialize | `DataModel#_initialize`} or an override
+   * 3. {@link Document.get | `Document.get`}, but the one place this happens, `pack` is already provided, and that's the only
+   * option that method cares about.
+   *
+   * This extends the `Document` interface because several core fields use the `pack` property, which isn't available on the
+   * `DataModel` interface
+   */
+  interface InitializeOptions extends Document.InitializeOptions {}
 
   interface ToInputConfig<InitializedType> extends FormInputConfig<InitializedType> {}
 
@@ -662,11 +775,11 @@ declare namespace DataField {
 }
 
 declare abstract class AnyDataField extends DataField<any, any, any, any> {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }
 
 /**
- * A special class of {@link DataField} which defines a data schema.
+ * A special class of {@link DataField | `DataField`} which defines a data schema.
  * @typeParam Fields          - the DataSchema fields of the SchemaField
  * @typeParam Options         - the options of the SchemaField instance
  * @typeParam AssignmentType  - the type of the allowed assignment values of the SchemaField
@@ -674,16 +787,16 @@ declare abstract class AnyDataField extends DataField<any, any, any, any> {
  * @typeParam PersistedType   - the type of the persisted values of the SchemaField
  * @remarks
  * Defaults:
- * AssignmentType: `SchemaField.AssignmentType<Fields> | null | undefined`
- * InitializedType: `SchemaField.InitializedType<Fields>`
- * PersistedType: `SchemaField.PersistedType<Fields>`
+ * - AssignmentType: `SchemaField.AssignmentType<Fields> | null | undefined`
+ * - InitializedType: `SchemaField.InitializedType<Fields>`
+ * - PersistedType: `SchemaField.PersistedType<Fields>`
  */
 declare class SchemaField<
   Fields extends DataSchema,
   Options extends SchemaField.Options<Fields> = SchemaField.DefaultOptions,
-  AssignmentType = SchemaField.AssignmentType<Fields, SimpleMerge<Options, SchemaField.DefaultOptions>>,
-  InitializedType = SchemaField.InitializedType<Fields, SimpleMerge<Options, SchemaField.DefaultOptions>>,
-  PersistedType extends AnyObject | null | undefined = SchemaField.PersistedType<
+  AssignmentType = SchemaField.Internal.AssignmentType<Fields, SimpleMerge<Options, SchemaField.DefaultOptions>>,
+  InitializedType = SchemaField.Internal.InitializedType<Fields, SimpleMerge<Options, SchemaField.DefaultOptions>>,
+  PersistedType extends AnyObject | null | undefined = SchemaField.Internal.PersistedType<
     Fields,
     SimpleMerge<Options, SchemaField.DefaultOptions>
   >,
@@ -691,9 +804,11 @@ declare class SchemaField<
   /**
    * @param fields  - The contained field definitions
    * @param options - Options which configure the behavior of the field
+   * @param context - Additional context which describes the field
    */
   // Saying `fields: Fields` here causes the inference for the fields to be unnecessarily widened. This might effectively be a no-op but it fixes the inference.
-  constructor(fields: { [K in keyof Fields]: Fields[K] }, options?: Options, context?: DataField.Context);
+  // options: not null (unchecked `in` operation in super), context: not null (destructured in super)
+  constructor(fields: { [K in keyof Fields]: Fields[K] }, options?: Options, context?: DataField.ConstructionContext);
 
   /** @defaultValue `true` */
   override required: boolean;
@@ -702,7 +817,7 @@ declare class SchemaField<
   override nullable: boolean;
 
   /** @defaultValue `() => this.clean({})` */
-  override initial: DataFieldOptions.InitialType<InitializedType>;
+  override initial: DataField.Options.InitialType<InitializedType>;
 
   protected static override get _defaults(): SchemaField.Options<DataSchema>;
 
@@ -726,6 +841,7 @@ declare class SchemaField<
    */
   [Symbol.iterator](): Generator<DataField.Unknown>;
 
+  // TODO: see if its viable to narrow keys, values, entries, has, and get's types via the schema
   /**
    * An array of field names which are present in the schema.
    */
@@ -762,35 +878,40 @@ declare class SchemaField<
    */
   getField(fieldName: string | string[]): DataField.Unknown | undefined;
 
-  protected override _getField(path: string[]): DataField.Unknown;
+  protected override _getField(path: string[]): DataField.Any;
 
   protected override _cast(value: AssignmentType): InitializedType;
 
+  /**
+   * @remarks Ensures `options.source` is set via effectively `||= data`, then forwards to each field's `#clean`
+   *
+   * Deletes any keys from `value` not in the schema
+   */
+  // options: not null (parameter default only, property access)
   protected override _cleanType(value: InitializedType, options?: DataField.CleanOptions): InitializedType;
 
+  // options: not null (parameter default only)
   override initialize(
     value: PersistedType,
     model: DataModel.Any,
-    options?: AnyObject,
+    options?: DataField.InitializeOptions,
   ): InitializedType | (() => InitializedType | null);
 
+  // options: not null (parameter default only, property access)
   protected override _validateType(
     value: InitializedType,
-    options?: DataField.ValidationOptions<DataField.Any>,
+    options?: DataField.ValidateOptions<this>,
   ): boolean | DataModelValidationFailure | void;
 
-  protected override _validateModel(data: AnyObject, options?: AnyObject): void;
+  // options: not null (parameter default only, property access)
+  protected override _validateModel(data: AnyObject, options?: DataField.ValidateModelOptions): void;
 
   override toObject(value: InitializedType): PersistedType;
 
+  // options: not null (could be forwarded somewhere destructured, parameter default only)
   override apply<Options, Return>(
-    fn: keyof this | ((this: this, value: undefined | null, options: Options) => Return),
-    value?: undefined | null,
-    options?: Options,
-  ): Return;
-  override apply<Value, Options, Return>(
-    fn: keyof this | ((this: this, value: Value, options: Options) => Return),
-    value: Value,
+    fn: keyof this | ((this: this, value: AnyObject, options: Options) => Return),
+    value?: AnyObject,
     options?: Options,
   ): Return;
 
@@ -803,7 +924,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;
@@ -813,64 +934,97 @@ declare namespace SchemaField {
    * A shorthand for the options of a SchemaField class.
    * @typeParam Fields - the DataSchema fields of the SchemaField
    */
-  type Options<Fields extends DataSchema> = DataFieldOptions<InnerAssignmentType<Fields> | __SchemaFieldInitial>;
+  type Options<Fields extends DataSchema> = DataField.Options<AssignmentData<Fields> | __SchemaFieldInitial>;
 
   /** Any SchemaField. */
-  type Any = SchemaField<any, any, any, any, any>;
+  interface Any extends SchemaField<any, any, any, any, any> {}
 
   /**
    * Get the constructor type for the given DataSchema.
    * @typeParam Fields - the DataSchema fields of the SchemaField
    */
-  type InnerConstructorType<Fields extends DataSchema> = InnerAssignmentType<Fields>;
+  // Note(LukeAbby): Currently this is identical to the assignment type. The intent is to make this
+  // More accurate in the future, e.g. requiring some requisite properties.
+  type CreateData<Fields extends DataSchema> = AssignmentData<Fields>;
 
   /**
    * Get the inner assignment type for the given DataSchema.
    * @typeParam Fields - the DataSchema fields of the SchemaField
    */
-  type InnerAssignmentType<Fields extends DataSchema> = RemoveIndexSignatures<{
-    [Key in keyof Fields]?: Fields[Key] extends EmbeddedDataField<any, any, infer AssignmentType, any, any>
-      ? AssignmentType
-      : Fields[Key] extends SchemaField<infer SubSchema, any, any, any, any>
-        ? // FIXME(LukeAbby): This is a quick hack into InnerAssignmentType that assumes that the `initial` of `SchemaField` is not changed from the default of `{}`
-          // This will be fixed with the refactoring of the types
-          EmptyObject extends InnerAssignmentType<SubSchema>
-          ? InnerAssignmentType<SubSchema> | undefined | null
-          : InnerAssignmentType<SubSchema>
-        : Fields[Key] extends DataField<any, infer AssignType, any, any>
-          ? AssignType
-          : never;
-  }>;
+  type AssignmentData<Fields extends DataSchema> = PrettifyType<
+    RemoveIndexSignatures<{
+      [Key in keyof Fields]?: Fields[Key] extends EmbeddedDataField<any, any, infer AssignmentType, any, any>
+        ? AssignmentType
+        : Fields[Key] extends SchemaField<infer SubSchema, any, any, any, any>
+          ? // FIXME(LukeAbby): This is a quick hack into AssignmentData that assumes that the `initial` of `SchemaField` is not changed from the default of `{}`
+            // This will be fixed with the refactoring of the types
+            EmptyObject extends AssignmentData<SubSchema>
+            ? AssignmentData<SubSchema> | undefined | null
+            : AssignmentData<SubSchema>
+          : Fields[Key] extends DataField<any, infer AssignType, any, any>
+            ? AssignType
+            : never;
+    }>
+  >;
 
   /**
-   * Get the inner initialized type for the given DataSchema.
+   * The required type of data used when updating a document.
    * @typeParam Fields - the DataSchema fields of the SchemaField
    */
-  type InnerInitializedType<Fields extends DataSchema> = RemoveIndexSignatures<{
-    [Key in keyof Fields]: Fields[Key] extends EmbeddedDataField<infer Model, any, any, any, any>
-      ? InstanceType<Model>
-      : Fields[Key] extends SchemaField<infer SubSchema, any, any, any, any>
-        ? InnerInitializedType<SubSchema>
-        : Fields[Key] extends DataField<any, any, infer InitType, any>
-          ? InitType
-          : never;
-  }>;
+  // Note(LukeAbby): Currently this is identical to `AssignmentData` but the intent is to make it
+  // more accurate in the future.
+  type UpdateData<Fields extends DataSchema> = AssignmentData<Fields>;
 
   /**
-   * Get the inner persisted type for the given DataSchema.
+   * Gets the initialized version of a schema. This means a
    * @typeParam Fields - the DataSchema fields of the SchemaField
    */
-  type InnerPersistedType<Fields extends DataSchema> = RemoveIndexSignatures<{
-    [Key in keyof Fields]: Fields[Key] extends EmbeddedDataField<any, any, any, any, infer PersistType>
-      ? PersistType
-      : Fields[Key] extends SchemaField<infer SubSchema, any, any, any, any>
-        ? InnerPersistedType<SubSchema>
-        : Fields[Key] extends DataField<any, any, any, infer PersistType>
-          ? PersistType
-          : never;
-  }>;
+  type InitializedData<Fields extends DataSchema> = PrettifyType<
+    RemoveIndexSignatures<{
+      [Key in keyof Fields]: Fields[Key] extends EmbeddedDataField<infer Model, any, any, any, any>
+        ? FixedInstanceType<Model>
+        : Fields[Key] extends SchemaField<infer SubSchema, any, any, any, any>
+          ? InitializedData<SubSchema>
+          : Fields[Key] extends DataField<any, any, infer InitType, any>
+            ? InitType
+            : never;
+    }>
+  >;
+
+  /**
+   * @deprecated {@link SourceData | `SourceData`}
+   */
+  type PersistedData<Fields extends DataSchema> = SourceData<Fields>;
+
+  /**
+   * Get the persisted type for the given DataSchema. This is the type used for source.
+   * @typeParam Fields - the DataSchema fields of the SchemaField
+   */
+  type SourceData<Fields extends DataSchema> = PrettifyType<
+    RemoveIndexSignatures<{
+      [Key in keyof Fields]: Fields[Key] extends EmbeddedDataField<any, any, any, any, infer PersistType>
+        ? PersistType
+        : Fields[Key] extends SchemaField<infer SubSchema, any, any, any, any>
+          ? SourceData<SubSchema>
+          : Fields[Key] extends DataField<any, any, any, infer PersistType>
+            ? PersistType
+            : never;
+    }>
+  >;
+
+  type UpdateSourceData<Fields extends DataSchema> = PrettifyType<
+    RemoveIndexSignatures<{
+      [Key in keyof Fields]: Fields[Key] extends EmbeddedDataField<any, any, any, any, infer PersistType>
+        ? PersistType
+        : Fields[Key] extends SchemaField<infer SubSchema, any, any, any, any>
+          ? SourceData<SubSchema>
+          : Fields[Key] extends DataField<any, any, any, infer PersistType>
+            ? PersistType
+            : never;
+    }>
+  >;
 
-  /** The type of the default options for the {@link SchemaField} class. */
+  /** The type of the default options for the {@link SchemaField | `SchemaField`} class. */
   type DefaultOptions = SimpleMerge<
     DataField.DefaultOptions,
     {
@@ -887,50 +1041,107 @@ declare namespace SchemaField {
    */
   type MergedOptions<Fields extends DataSchema, Opts extends Options<Fields>> = SimpleMerge<DefaultOptions, Opts>;
 
-  // FIXME: null or undefined should be permissible, cast as the initialized type
+  // These exist for calculating the type of schema field with options.
+  // This will be deleted once fields are refactored.
+  // The names are also confusing. Hence these it's put into `Internal.
+  namespace Internal {
+    // FIXME: null or undefined should be permissible, cast as the initialized type
+    /**
+     * A shorthand for the assignment type of a SchemaField class.
+     * @typeParam Fields - the DataSchema fields of the SchemaField
+     * @typeParam Opts   - the options that override the default options
+     */
+    type AssignmentType<
+      Fields extends DataSchema,
+      Opts extends Options<Fields> = DefaultOptions,
+    > = DataField.DerivedAssignmentType<AssignmentData<Fields>, MergedOptions<Fields, Opts>>;
+
+    /**
+     * A shorthand for the assignment type of a SchemaField class.
+     * @typeParam Fields - the DataSchema fields of the SchemaField
+     * @typeParam Opts   - the options that override the default options
+     */
+    type InitializedType<
+      Fields extends DataSchema,
+      Opts extends Options<Fields> = DefaultOptions,
+    > = DataField.DerivedInitializedType<InitializedData<Fields>, MergedOptions<Fields, Opts>>;
+
+    /**
+     * A shorthand for the assignment type of a SchemaField class.
+     * @typeParam Fields - the DataSchema fields of the SchemaField
+     * @typeParam Opts   - the options that override the default options
+     */
+    type PersistedType<
+      Fields extends DataSchema,
+      Opts extends Options<Fields> = DefaultOptions,
+    > = DataField.DerivedInitializedType<SourceData<Fields>, MergedOptions<Fields, Opts>>;
+  }
+
   /**
-   * A shorthand for the assignment type of a SchemaField class.
-   * @typeParam Fields - the DataSchema fields of the SchemaField
-   * @typeParam Opts   - the options that override the default options
+   * This is deprecated because of likely confusion between `SchemaField.AssignmentData` and `SchemaField.AssignmentType`.
+   * @deprecated {@link SchemaField.Internal.AssignmentType | `SchemaField.Internal.AssignmentType`}
    */
   type AssignmentType<
     Fields extends DataSchema,
     Opts extends Options<Fields> = DefaultOptions,
-  > = DataField.DerivedAssignmentType<InnerAssignmentType<Fields>, MergedOptions<Fields, Opts>>;
+  > = Internal.AssignmentType<Fields, Opts>;
 
   /**
-   * A shorthand for the assignment type of a SchemaField class.
-   * @typeParam Fields - the DataSchema fields of the SchemaField
-   * @typeParam Opts   - the options that override the default options
+   * This is deprecated because of likely confusion between `SchemaField.InitializedData` and `SchemaField.InitializedType`.
+   * @deprecated {@link SchemaField.Internal.InitializedType | `SchemaField.Internal.InitializedType`}
    */
   type InitializedType<
     Fields extends DataSchema,
     Opts extends Options<Fields> = DefaultOptions,
-  > = DataField.DerivedInitializedType<InnerInitializedType<Fields>, MergedOptions<Fields, Opts>>;
+  > = Internal.InitializedType<Fields, Opts>;
 
   /**
-   * A shorthand for the assignment type of a SchemaField class.
-   * @typeParam Fields - the DataSchema fields of the SchemaField
-   * @typeParam Opts   - the options that override the default options
+   * This is deprecated because of likely confusion between `SchemaField.PersistedData` and `SchemaField.PersistedType`.
+   * @deprecated {@link SchemaField.Internal.PersistedType | `SchemaField.Internal.PersistedType`}
    */
-  type PersistedType<
-    Fields extends DataSchema,
-    Opts extends Options<Fields> = DefaultOptions,
-  > = DataField.DerivedInitializedType<InnerPersistedType<Fields>, MergedOptions<Fields, Opts>>;
+  type PersistedType<Fields extends DataSchema, Opts extends Options<Fields> = DefaultOptions> = Internal.PersistedType<
+    Fields,
+    Opts
+  >;
+
+  /**
+   * @deprecated {@link SchemaField.CreateData | `SchemaField.CreateData`}
+   */
+  type InnerConstructorType<Fields extends DataSchema> = CreateData<Fields>;
+
+  /**
+   * @deprecated {@link SchemaField.AssignmentData | `SchemaField.AssignmentData`}
+   */
+  type InnerAssignmentType<Fields extends DataSchema> = AssignmentData<Fields>;
+
+  /**
+   * @deprecated {@link SchemaField.InitializedData | `SchemaField.InitializedData`}
+   */
+  type InnerInitializedType<Fields extends DataSchema> = InitializedData<Fields>;
+
+  /**
+   * @deprecated {@link SchemaField.UpdateData | `SchemaField.UpdateData`}
+   */
+  type InnerUpdateData<Fields extends DataSchema> = UpdateData<Fields>;
+
+  /**
+   * @deprecated {@link SchemaField.SourceData | `SchemaField.SourceData`}
+   */
+  type InnerPersistedType<Fields extends DataSchema> = SourceData<Fields>;
 }
 
 /**
- * A subclass of [DataField]{@link DataField} which deals with boolean-typed data.
+ * A subclass of {@link DataField | `DataField`} which deals with boolean-typed data.
  * @typeParam Options         - the options of the BooleanField instance
  * @typeParam AssignmentType  - the type of the allowed assignment values of the BooleanField
  * @typeParam InitializedType - the type of the initialized values of the BooleanField
  * @typeParam PersistedType   - the type of the persisted values of the BooleanField
  * @remarks
  * Defaults:
- * AssignmentType: `boolean | null | undefined`
- * InitializedType: `boolean`
- * PersistedType: `boolean`
- * InitialValue: `false`
+ * - AssignmentType: `boolean | null | undefined`
+ * - InitializedType: `boolean`
+ * - PersistedType: `boolean`
+ * - InitialValue: `false`
  */
 declare class BooleanField<
   const Options extends BooleanField.Options = BooleanField.DefaultOptions,
@@ -947,25 +1158,58 @@ declare class BooleanField<
   override nullable: boolean;
 
   /** @defaultValue `false` */
-  override initial: DataFieldOptions.InitialType<InitializedType>;
+  override initial: DataField.Options.InitialType<InitializedType>;
 
   protected static override get _defaults(): BooleanField.Options;
 
   protected override _cast(value: AssignmentType): InitializedType;
 
+  /** @remarks `options` is unused in `BooleanField` */
   protected override _validateType(
     value: InitializedType,
-    options?: DataField.ValidationOptions<DataField.Any>,
+    options?: DataField.ValidateOptions<this> | null,
   ): boolean | DataModelValidationFailure | void;
 
   protected override _toInput(config: DataField.ToInputConfig<InitializedType>): HTMLElement | HTMLCollection;
+
+  /** @remarks Returns `value || delta`. `model` and `change` are unused in `BooleanField` */
+  protected override _applyChangeAdd(
+    value: InitializedType,
+    delta: InitializedType,
+    model: DataModel.Any,
+    change: ActiveEffect.EffectChangeData,
+  ): InitializedType;
+
+  /** @remarks Returns `value && delta`. `model` and `change` are unused in `BooleanField` */
+  protected override _applyChangeMultiply(
+    value: InitializedType,
+    delta: InitializedType,
+    model: DataModel.Any,
+    change: ActiveEffect.EffectChangeData,
+  ): InitializedType;
+
+  /** @remarks Returns `delta > value ? delta : value`. `model` and `change` are unused in `BooleanField` */
+  protected override _applyChangeUpgrade(
+    value: InitializedType,
+    delta: InitializedType,
+    model: DataModel.Any,
+    change: ActiveEffect.EffectChangeData,
+  ): InitializedType;
+
+  /** @remarks Returns `delta < value ? delta : value`. `model` and `change` are unused in `BooleanField` */
+  protected override _applyChangeDowngrade(
+    value: InitializedType,
+    delta: InitializedType,
+    model: DataModel.Any,
+    change: ActiveEffect.EffectChangeData,
+  ): InitializedType;
 }
 
 declare namespace BooleanField {
   /** A shorthand for the options of a BooleanField class. */
-  type Options = DataFieldOptions<boolean>;
+  type Options = DataField.Options<boolean>;
 
-  /** The type of the default options for the {@link BooleanField} class. */
+  /** The type of the default options for the {@link BooleanField | `BooleanField`} class. */
   type DefaultOptions = SimpleMerge<
     DataField.DefaultOptions,
     {
@@ -994,76 +1238,40 @@ declare namespace BooleanField {
   type InitializedType<Opts extends Options> = DataField.DerivedInitializedType<boolean, MergedOptions<Opts>>;
 }
 
-declare global {
-  interface NumberFieldOptions extends DataFieldOptions<number> {
-    /**
-     * A minimum allowed value
-     * @defaultValue `undefined`
-     */
-    min?: number | undefined;
-
-    /**
-     * A maximum allowed value
-     * @defaultValue `undefined`
-     */
-    max?: number | undefined;
-
-    /**
-     * A permitted step size
-     * @defaultValue `undefined`
-     */
-    step?: number | undefined;
-
-    /**
-     * Must the number be an integer?
-     * @defaultValue `false`
-     */
-    integer?: boolean | undefined;
-
-    /**
-     * Must the number be positive?
-     * @defaultValue `false`
-     */
-    positive?: boolean | undefined;
-
-    /**
-     * An array of values or an object of values/labels which represent
-     * allowed choices for the field. A function may be provided which dynamically
-     * returns the array of choices.
-     * @defaultValue `undefined`
-     */
-    choices?: NumberField.Choices | undefined;
-  }
-}
-
 /**
- * A subclass of [DataField]{@link DataField} which deals with number-typed data.
+ * A subclass of {@link DataField | `DataField`} which deals with number-typed data.
  * @typeParam Options         - the options of the NumberField instance
  * @typeParam AssignmentType  - the type of the allowed assignment values of the NumberField
  * @typeParam InitializedType - the type of the initialized values of the NumberField
  * @typeParam PersistedType   - the type of the persisted values of the NumberField
  * @remarks
  * Defaults:
- * AssignmentType: `number | null | undefined`
- * InitializedType: `number | null`
- * PersistedType: `number | null`
- * InitialValue: `null`
+ * - AssignmentType: `number | null | undefined`
+ * - InitializedType: `number | null`
+ * - PersistedType: `number | null`
+ * - InitialValue: `null`
  */
 declare class NumberField<
-  const Options extends NumberFieldOptions = NumberField.DefaultOptions,
+  const Options extends NumberField.Options = NumberField.DefaultOptions,
   const AssignmentType = NumberField.AssignmentType<Options>,
   const InitializedType = NumberField.InitializedType<Options>,
   const PersistedType extends number | null | undefined = NumberField.InitializedType<Options>,
 > extends DataField<Options, AssignmentType, InitializedType, PersistedType> {
   /**
    * @param options - Options which configure the behavior of the field
+   * @param context - Additional context which describes the field
+   * @remarks Changes the default of `nullable` if passed `choices`
    */
-  constructor(options?: Options, context?: DataField.Context);
+  // options: not null (unchecked `in` operation in super), context: not null (destructured in super)
+  constructor(options?: Options, context?: DataField.ConstructionContext);
 
   /** @defaultValue `null` */
-  override initial: DataFieldOptions.InitialType<InitializedType>;
+  override initial: DataField.Options.InitialType<InitializedType>;
 
-  /** @defaultValue `true` */
+  /**
+   * @defaultValue `true`
+   * @remarks If this field is created with `choices`, the default becomes `false`
+   */
   override nullable: boolean;
 
   /**
@@ -1104,24 +1312,23 @@ declare class NumberField<
    */
   choices: number[] | Record<number, string> | (() => number[] | Record<number, string>) | undefined;
 
-  protected static override get _defaults(): NumberFieldOptions;
+  protected static override get _defaults(): NumberField.Options;
 
   protected override _cast(value: AssignmentType): InitializedType;
 
-  protected override _cleanType(value: InitializedType, options?: DataField.CleanOptions): InitializedType;
+  /**
+   * @remarks Applies `integer`, `min`, `max`, and `step`
+   *
+   * `options` is only passed to super, so effectively unused
+   * */
+  protected override _cleanType(value: InitializedType, options?: DataField.CleanOptions | null): InitializedType;
 
+  /** @remarks `options` is unused in `NumberField` */
   protected override _validateType(
     value: InitializedType,
-    options?: DataField.ValidationOptions<DataField.Any>,
+    options?: DataField.ValidateOptions<this> | null,
   ): boolean | DataModelValidationFailure | void;
 
-  /**
-   * Test whether a provided value is a valid choice from the allowed choice set
-   * @param value - The provided value
-   * @returns Is the choice valid?
-   */
-  #isValidChoice(value: AssignmentType): boolean;
-
   // These verbose overloads are because otherwise there would be a misleading errors about `choices` being required without mentioning `options` or vice versa.
   toFormGroup(
     groupConfig?: DataField.GroupConfig,
@@ -1152,10 +1359,34 @@ declare class NumberField<
   protected override _toInput(
     config: NumberField.ToInputConfigWithChoices<InitializedType, Options["choices"]>,
   ): HTMLElement | HTMLCollection;
+
+  /** @remarks Returns `value * delta`. `model` and `change` are unused in `NumberField` */
+  protected override _applyChangeMultiply(
+    value: InitializedType,
+    delta: InitializedType,
+    model: DataModel.Any,
+    change: ActiveEffect.EffectChangeData,
+  ): InitializedType;
+
+  /** @remarks Returns `delta > value ? delta : value`. `model` and `change` are unused in `NumberField` */
+  protected override _applyChangeUpgrade(
+    value: InitializedType,
+    delta: InitializedType,
+    model: DataModel.Any,
+    change: ActiveEffect.EffectChangeData,
+  ): InitializedType;
+
+  /** @remarks Returns `delta < value ? delta : value`. `model` and `change` are unused in `NumberField` */
+  protected override _applyChangeDowngrade(
+    value: InitializedType,
+    delta: InitializedType,
+    model: DataModel.Any,
+    change: ActiveEffect.EffectChangeData,
+  ): InitializedType;
 }
 
 declare namespace NumberField {
-  /** The type of the default options for the {@link NumberField} class. */
+  /** The type of the default options for the {@link NumberField | `NumberField`} class. */
   type DefaultOptions = SimpleMerge<
     DataField.DefaultOptions,
     {
@@ -1170,14 +1401,54 @@ declare namespace NumberField {
     }
   >;
 
-  /** The type of the default options for the {@link NumberField} class when choices are provided. */
+  interface Options extends DataField.Options<number> {
+    /**
+     * A minimum allowed value
+     * @defaultValue `undefined`
+     */
+    min?: number | undefined;
+
+    /**
+     * A maximum allowed value
+     * @defaultValue `undefined`
+     */
+    max?: number | undefined;
+
+    /**
+     * A permitted step size
+     * @defaultValue `undefined`
+     */
+    step?: number | undefined;
+
+    /**
+     * Must the number be an integer?
+     * @defaultValue `false`
+     */
+    integer?: boolean | undefined;
+
+    /**
+     * Must the number be positive?
+     * @defaultValue `false`
+     */
+    positive?: boolean | undefined;
+
+    /**
+     * An array of values or an object of values/labels which represent
+     * allowed choices for the field. A function may be provided which dynamically
+     * returns the array of choices.
+     * @defaultValue `undefined`
+     */
+    choices?: NumberField.Choices | undefined;
+  }
+
+  /** The type of the default options for the {@link NumberField | `NumberField`} class when choices are provided. */
   type DefaultOptionsWhenChoicesProvided = SimpleMerge<DefaultOptions, { nullable: false }>;
 
   /**
    * A helper type for the given options type merged into the default options of the NumberField class.
    * @typeParam Options - the options that override the default options
    */
-  type MergedOptions<Options extends NumberFieldOptions> = SimpleMerge<
+  type MergedOptions<Options extends NumberField.Options> = SimpleMerge<
     undefined extends Options["choices"] ? DefaultOptions : DefaultOptionsWhenChoicesProvided,
     Options
   >;
@@ -1186,7 +1457,7 @@ declare namespace NumberField {
    * A shorthand for the assignment type of a NumberField class.
    * @typeParam Options - the options that override the default options
    */
-  type AssignmentType<Options extends NumberFieldOptions> = DataField.DerivedAssignmentType<
+  type AssignmentType<Options extends NumberField.Options> = DataField.DerivedAssignmentType<
     number,
     MergedOptions<Options>
   >;
@@ -1195,7 +1466,7 @@ declare namespace NumberField {
    * A shorthand for the initialized type of a NumberField class.
    * @typeParam Options - the options that override the default options
    */
-  type InitializedType<Options extends NumberFieldOptions> = DataField.DerivedInitializedType<
+  type InitializedType<Options extends NumberField.Options> = DataField.DerivedInitializedType<
     number,
     MergedOptions<Options>
   >;
@@ -1219,77 +1490,52 @@ declare namespace NumberField {
   type ToInputConfigWithChoices<InitializedType, Choices extends NumberField.Choices | undefined> = SimpleMerge<
     DataField.ToInputConfigWithChoices<InitializedType, Choices>,
     _ToInputConfig<InitializedType>
-  >;
-
-  interface ToInputConfigWithOptions<InitializedType>
-    extends DataField.ToInputConfigWithOptions<InitializedType>,
-      _ToInputConfig<InitializedType> {}
-
-  type ToInputConfig<InitializedType, Choices extends NumberField.Choices | undefined> =
-    | _ToInputConfig<InitializedType>
-    | ToInputConfigWithChoices<InitializedType, Choices>
-    | ToInputConfigWithOptions<InitializedType>;
-}
-
-declare global {
-  interface StringFieldOptions extends DataFieldOptions<string> {
-    /**
-     * Is the string allowed to be blank (empty)?
-     * @defaultValue `true`
-     */
-    blank?: boolean | undefined;
-
-    /**
-     * Should any provided string be trimmed as part of cleaning?
-     * @defaultValue `true`
-     */
-    trim?: boolean | undefined;
-
-    /**
-     * An array of values or an object of values/labels which represent
-     * allowed choices for the field. A function may be provided which dynamically
-     * returns the array of choices.
-     * @defaultValue `undefined`
-     */
-    choices?: StringField.Choices | undefined;
+  >;
 
-    /**
-     * @defaultValue `false`
-     */
-    textSearch?: boolean | undefined;
-  }
+  interface ToInputConfigWithOptions<InitializedType>
+    extends DataField.ToInputConfigWithOptions<InitializedType>,
+      _ToInputConfig<InitializedType> {}
+
+  type ToInputConfig<InitializedType, Choices extends NumberField.Choices | undefined> =
+    | _ToInputConfig<InitializedType>
+    | ToInputConfigWithChoices<InitializedType, Choices>
+    | ToInputConfigWithOptions<InitializedType>;
 }
 
 /**
- * A subclass of [DataField]{@link DataField} which deals with string-typed data.
+ * A subclass of {@link DataField | `DataField`} which deals with string-typed data.
  * @typeParam Options         - the options of the StringField instance
  * @typeParam AssignmentType  - the type of the allowed assignment values of the StringField
  * @typeParam InitializedType - the type of the initialized values of the StringField
  * @typeParam PersistedType   - the type of the persisted values of the StringField
  * @remarks
  * Defaults:
- * AssignmentType: `string | null | undefined`
- * InitializedType: `string`
- * PersistedType: `string`
- * InitialValue: `""`
+ * - AssignmentType: `string | null | undefined`
+ * - InitializedType: `string`
+ * - PersistedType: `string`
+ * - InitialValue: `""`
  */
 declare class StringField<
-  const Options extends StringFieldOptions = StringField.DefaultOptions,
+  const Options extends StringField.Options<unknown> = StringField.DefaultOptions,
   const AssignmentType = StringField.AssignmentType<Options>,
   const InitializedType = StringField.InitializedType<Options>,
   const PersistedType extends string | null | undefined = StringField.InitializedType<Options>,
 > extends DataField<Options, AssignmentType, InitializedType, PersistedType> {
   /**
    * @param options - Options which configure the behavior of the field
+   * @param context - Additional context which describes the field
+   * @remarks If passed `choices`, changes the defaults of `nullable` and `blank`
    */
-  constructor(options?: Options, context?: DataField.Context);
+  // options: not null (unchecked `in` operation in super), context: not null (destructured in super)
+  constructor(options?: Options, context?: DataField.ConstructionContext);
 
   /** @defaultValue `undefined` */
-  override initial: DataFieldOptions.InitialType<InitializedType>;
+  override initial: DataField.Options.InitialType<InitializedType>;
 
   /**
    * Is the string allowed to be blank (empty)?
    * @defaultValue `true`
+   * @remarks If this field is created with `choices`, the default changes to `false`
    */
   blank: boolean;
 
@@ -1299,7 +1545,10 @@ declare class StringField<
    */
   trim: boolean;
 
-  /** @defaultValue `false` */
+  /**
+   * @defaultValue `false`
+   * @remarks If this field is created with `choices`, the default changes to `false`
+   */
   override nullable: boolean;
 
   /**
@@ -1313,28 +1562,33 @@ declare class StringField<
   /** @defaultValue `false` */
   textSearch: boolean;
 
-  protected static override get _defaults(): StringFieldOptions;
+  protected static override get _defaults(): StringField.Options<unknown>;
 
+  // options: not null (parameter default only, property access)
   override clean(value: AssignmentType, options?: DataField.CleanOptions): InitializedType;
 
   protected override _cast(value: AssignmentType): InitializedType;
 
   protected override _validateSpecial(value: AssignmentType): boolean | void;
 
+  /** @remarks `options` is unused in `StringField` */
   protected override _validateType(
     value: InitializedType,
-    options?: DataField.ValidationOptions<DataField.Any>,
+    options?: DataField.ValidateOptions<this>,
   ): boolean | DataModelValidationFailure | void;
 
   /**
    * Test whether a provided value is a valid choice from the allowed choice set
    * @param value - The provided value
    * @returns Is the choice valid?
+   *
+   * @privateRemarks `#_validateType` throws if `value` is not `string` before forwarding here
    */
-  protected _isValidChoice(value: AssignmentType): boolean;
+  protected _isValidChoice(value: string): boolean;
 
   /**
    * Get a record of eligible choices for the field.
+   * @remarks Foundry marked `@internal`
    */
   static _getChoices(options?: StringField.GetChoicesOptions): FormSelectOption[];
 
@@ -1364,7 +1618,7 @@ declare class StringField<
 }
 
 declare namespace StringField {
-  /** The type of the default options for the {@link StringField} class. */
+  /** The type of the default options for the {@link StringField | `StringField`} class. */
   type DefaultOptions = SimpleMerge<
     DataField.DefaultOptions,
     {
@@ -1376,28 +1630,55 @@ declare namespace StringField {
     }
   >;
 
-  /** The type of the default options for the {@link StringField} class when choices are provided. */
+  interface Options<Type = string> extends DataField.Options<Type> {
+    /**
+     * Is the string allowed to be blank (empty)?
+     * @defaultValue `true`
+     */
+    blank?: boolean | undefined;
+
+    /**
+     * Should any provided string be trimmed as part of cleaning?
+     * @defaultValue `true`
+     */
+    trim?: boolean | undefined;
+
+    /**
+     * An array of values or an object of values/labels which represent
+     * allowed choices for the field. A function may be provided which dynamically
+     * returns the array of choices.
+     * @defaultValue `undefined`
+     */
+    choices?: StringField.Choices | undefined;
+
+    /**
+     * @defaultValue `false`
+     */
+    textSearch?: boolean | undefined;
+  }
+
+  /** The type of the default options for the {@link StringField | `StringField`} class when choices are provided. */
   type DefaultOptionsWhenChoicesProvided = SimpleMerge<DefaultOptions, { nullable: false; blank: false }>;
 
   /**
    * A helper type for the given options type merged into the default options of the StringField class.
    * @typeParam Options - the options that override the default options
    */
-  type MergedOptions<Options extends StringFieldOptions> = SimpleMerge<
+  type MergedOptions<Options extends StringField.Options<unknown>> = SimpleMerge<
     _OptionsForInitial<_OptionsForChoices<Options["choices"]>>,
     Options
   >;
 
-  type _OptionsForChoices<Choices extends StringFieldOptions["choices"]> = undefined extends Choices
+  type _OptionsForChoices<Choices extends StringField.Options["choices"]> = undefined extends Choices
     ? DefaultOptions
     : DefaultOptionsWhenChoicesProvided;
 
   // FIXME: `"initial" extends keyof Options` does not work for modeling `"initial" in options`.
-  type _OptionsForInitial<Options extends StringFieldOptions> = "initial" extends keyof Options
+  type _OptionsForInitial<Options extends StringField.Options<unknown>> = "initial" extends keyof Options
     ? Options
     : SimpleMerge<Options, { initial: _InitialForOptions<Options> }>;
 
-  type _InitialForOptions<Options extends StringFieldOptions> = Options["required"] extends false | undefined
+  type _InitialForOptions<Options extends StringField.Options<unknown>> = Options["required"] extends false | undefined
     ? undefined
     : Options["blank"] extends true
       ? string
@@ -1407,19 +1688,24 @@ declare namespace StringField {
 
   // choices?: string[] | Record<string, string> | (() => string[] | Record<string, string>) | undefined;
 
-  type ValidChoice<Options extends StringFieldOptions> = Options["choices"] extends undefined
+  type ValidChoice<Options extends StringField.Options<unknown>> = Options["choices"] extends undefined
     ? string
-    : Options["choices"] extends (...args: any) => infer Choices
+    : Options["choices"] extends (...args: infer _1) => infer Choices
       ? FixedChoice<Choices>
       : FixedChoice<Options["choices"]>;
 
-  type FixedChoice<Choices> = Choices extends Array<infer U> ? U : Choices extends Record<infer K, any> ? K : string;
+  type FixedChoice<Choices> =
+    Choices extends ReadonlyArray<infer U>
+      ? U
+      : Choices extends { readonly [_ in infer K]: infer _1 }
+        ? K & string
+        : string;
 
   /**
    * A shorthand for the assignment type of a StringField class.
    * @typeParam Options - the options that override the default options
    */
-  type AssignmentType<Options extends StringFieldOptions> = DataField.DerivedAssignmentType<
+  type AssignmentType<Options extends StringField.Options<unknown>> = DataField.DerivedAssignmentType<
     ValidChoice<Options>,
     MergedOptions<Options>
   >;
@@ -1428,7 +1714,7 @@ declare namespace StringField {
    * A shorthand for the initialized type of a StringField class.
    * @typeParam Options - the options that override the default options
    */
-  type InitializedType<Options extends StringFieldOptions> = DataField.DerivedInitializedType<
+  type InitializedType<Options extends StringField.Options<unknown>> = DataField.DerivedInitializedType<
     // TODO(LukeAbby): This is a workaround for how `ValidChoice` is defined ignorant of the `StringField`/`NumberField` divide.
     ValidChoice<Options> & (string | null | undefined),
     MergedOptions<Options>
@@ -1440,11 +1726,10 @@ declare namespace StringField {
       }
     | readonly string[];
 
+  // TODO: consolidate with inline type in GetChoicesOptions if possible
   type Choices = BaseChoices | (() => BaseChoices);
 
-  /**
-   * @internal
-   */
+  /** @internal */
   interface _GetChoicesOptions {
     /**
      * The property in the choice object values to use as the option label.
@@ -1470,20 +1755,20 @@ declare namespace StringField {
 }
 
 /**
- * A subclass of [DataField]{@link DataField} which deals with object-typed data.
+ * A subclass of {@link DataField | `DataField`} which deals with object-typed data.
  * @typeParam Options         - the options of the ObjectField instance
  * @typeParam AssignmentType  - the type of the allowed assignment values of the ObjectField
  * @typeParam InitializedType - the type of the initialized values of the ObjectField
  * @typeParam PersistedType   - the type of the persisted values of the ObjectField
  * @remarks
  * Defaults:
- * AssignmentType: `object | null | undefined`
- * InitializedType: `object`
- * PersistedType: `object`
- * InitialValue: `{}`
+ * - AssignmentType: `object | null | undefined`
+ * - InitializedType: `object`
+ * - PersistedType: `object`
+ * - InitialValue: `{}`
  */
 declare class ObjectField<
-  const Options extends DataFieldOptions<AnyObject> = ObjectField.DefaultOptions,
+  const Options extends DataField.Options<AnyObject> = ObjectField.DefaultOptions,
   const AssignmentType = ObjectField.AssignmentType<Options>,
   const InitializedType = ObjectField.InitializedType<Options>,
   const PersistedType extends AnyObject | null | undefined = ObjectField.InitializedType<Options>,
@@ -1495,28 +1780,33 @@ declare class ObjectField<
   override nullable: boolean;
 
   /** @defaultValue `() => ({})` */
-  override initial: DataFieldOptions.InitialType<InitializedType>;
+  override initial: DataField.Options.InitialType<InitializedType>;
 
-  protected static override get _defaults(): DataFieldOptions<AnyObject>;
+  protected static override get _defaults(): DataField.Options<AnyObject>;
+
+  override getInitialValue(data?: unknown): InitializedType;
 
   protected override _cast(value: AssignmentType): InitializedType;
 
+  // options: not null (parameter default only)
   override initialize(
     value: PersistedType,
     model: DataModel.Any,
-    options?: AnyObject,
+    options?: DataField.InitializeOptions,
   ): InitializedType | (() => InitializedType | null);
 
   override toObject(value: InitializedType): PersistedType;
 
+  /** @remarks `options` is unused in `ObjectField` */
+  // options: not null (parameter default only, despite being unused)
   protected override _validateType(
     value: InitializedType,
-    options?: DataField.ValidationOptions<DataField.Any>,
+    options?: DataField.ValidateOptions<this>,
   ): boolean | DataModelValidationFailure | void;
 }
 
 declare namespace ObjectField {
-  /** The type of the default options for the {@link ObjectField} class. */
+  /** The type of the default options for the {@link ObjectField | `ObjectField`} class. */
   type DefaultOptions = SimpleMerge<
     DataField.DefaultOptions,
     {
@@ -1529,13 +1819,13 @@ declare namespace ObjectField {
    * A helper type for the given options type merged into the default options of the ObjectField class.
    * @typeParam Options - the options that override the default options
    */
-  type MergedOptions<Options extends DataFieldOptions<AnyObject>> = SimpleMerge<DefaultOptions, Options>;
+  type MergedOptions<Options extends DataField.Options<AnyObject>> = SimpleMerge<DefaultOptions, Options>;
 
   /**
    * A shorthand for the assignment type of a ObjectField class.
    * @typeParam Options - the options that override the default options
    */
-  type AssignmentType<Options extends DataFieldOptions<AnyObject>> = DataField.DerivedAssignmentType<
+  type AssignmentType<Options extends DataField.Options<AnyObject>> = DataField.DerivedAssignmentType<
     AnyObject,
     MergedOptions<Options>
   >;
@@ -1544,13 +1834,13 @@ declare namespace ObjectField {
    * A shorthand for the initialized type of a ObjectField class.
    * @typeParam Options - the options that override the default options
    */
-  type InitializedType<Options extends DataFieldOptions<AnyObject>> = DataField.DerivedInitializedType<
+  type InitializedType<Options extends DataField.Options<AnyObject>> = DataField.DerivedInitializedType<
     AnyObject,
     MergedOptions<Options>
   >;
 
   /**
-   * A helper to create a flags object field for the given key in the {@link FlagConfig}.
+   * A helper to create a flags object field for the given key in the {@link FlagConfig | `FlagConfig`}.
    * @typeParam Key            - the key to look for in the FlagConfig
    * @typeParam ExtensionFlags - additional flags besides the ones configured for the class
    * @typeParam Options        - the options of the field
@@ -1560,17 +1850,26 @@ declare namespace ObjectField {
     // The type `{}` is useful here because in an intersection it reduces down to nothing unlike `EmptyObject`.
     // eslint-disable-next-line @typescript-eslint/no-empty-object-type
     ExtensionFlags extends AnyObject = {},
-    Options extends DataFieldOptions.Any = ObjectField.DefaultOptions,
+    Options extends DataField.Options.Any = ObjectField.DefaultOptions,
   > = ObjectField<
     Options,
-    DataField.DerivedAssignmentType<Document.ConfiguredFlagsForName<Name> & ExtensionFlags, MergedOptions<Options>>,
-    DataField.DerivedInitializedType<Document.ConfiguredFlagsForName<Name> & ExtensionFlags, MergedOptions<Options>>,
-    DataField.DerivedInitializedType<Document.ConfiguredFlagsForName<Name> & ExtensionFlags, MergedOptions<Options>>
+    DataField.DerivedAssignmentType<
+      Document.ConfiguredFlagsForName<Name> & ExtensionFlags & InterfaceToObject<Document.CoreFlags>,
+      MergedOptions<Options>
+    >,
+    DataField.DerivedInitializedType<
+      Document.ConfiguredFlagsForName<Name> & ExtensionFlags & InterfaceToObject<Document.CoreFlags>,
+      MergedOptions<Options>
+    >,
+    DataField.DerivedInitializedType<
+      Document.ConfiguredFlagsForName<Name> & ExtensionFlags & InterfaceToObject<Document.CoreFlags>,
+      MergedOptions<Options>
+    >
   >;
 }
 
 /**
- * A subclass of [DataField]{@link DataField} which deals with array-typed data.
+ * A subclass of {@link DataField | `DataField`} which deals with array-typed data.
  * @typeParam ElementFieldType       - the field type for the elements in the ArrayField
  * @typeParam AssignmentElementType  - the assignment type for the elements in the array
  * @typeParam InitializedElementType - the initialized type for the elements in the array
@@ -1580,11 +1879,14 @@ declare namespace ObjectField {
  * @typeParam PersistedElementType   - the persisted type for the elements in the array
  * @typeParam PersistedType          - the type of the persisted values of the ArrayField
  * @remarks
+ * `ArrayField` itself will not accept Document class instances, that exists on `ElementFieldType` to support
+ * {@link EmbeddedCollectionField | `EmbeddedCollectionField` }
+ *
  * Defaults:
- * AssignmentType: `ArrayField.BaseAssignmentType<AssignmentElementType> | null | undefined`
- * InitializedType: `InitializedElementType[]`
- * PersistedType: `PersistedElementType[]`
- * InitialValue: `[]`
+ * - AssignmentType: `ArrayField.BaseAssignmentType<AssignmentElementType> | null | undefined`
+ * - InitializedType: `InitializedElementType[]`
+ * - PersistedType: `PersistedElementType[]`
+ * - InitialValue: `[]`
  */
 declare class ArrayField<
   const ElementFieldType extends DataField.Any | Document.AnyConstructor,
@@ -1605,8 +1907,11 @@ declare class ArrayField<
   /**
    * @param element - A DataField instance which defines the type of element contained in the Array.
    * @param options - Options which configure the behavior of the field
+   * @param context - Additional context which describes the field
+   * @throws If provided a `max` that is lower than `min` (default `0`)
    */
-  constructor(element: ElementFieldType, options?: Options, context?: DataField.Context);
+  // options: not null (unchecked `in` operation in super), context: not null (destructured in super)
+  constructor(element: ElementFieldType, options?: Options, context?: DataField.ConstructionContext);
 
   /** @defaultValue `true` */
   override required: boolean;
@@ -1615,7 +1920,7 @@ declare class ArrayField<
   override nullable: boolean;
 
   /** @defaultValue `() => []` */
-  override initial: DataFieldOptions.InitialType<InitializedType>;
+  override initial: DataField.Options.InitialType<InitializedType>;
 
   /**
    * The data type of each element in this array
@@ -1637,15 +1942,21 @@ declare class ArrayField<
    */
   protected static _validateElementType<T extends DataField.Any>(element: T): T;
 
-  protected override _validateModel(data: AnyObject, options?: AnyObject): void;
+  // options: not null (could be destructured in element#_validateModel)
+  protected override _validateModel(data: AnyObject, options?: DataField.ValidateModelOptions): void;
 
   protected override _cast(value: AssignmentType): InitializedType;
 
-  protected override _cleanType(value: InitializedType, options?: DataField.CleanOptions): InitializedType;
+  /**
+   * @remarks `options` gets its `partial` property forced `false`, then each element gets run through its field's `#clean`
+   * @privateRemarks `null` is allowed for `options` as it gets spread, and `...null` doesn't error
+   */
+  protected override _cleanType(value: InitializedType, options?: DataField.CleanOptions | null): InitializedType;
 
+  // options: not null (parameter default only)
   protected override _validateType(
     value: InitializedType,
-    options?: DataField.ValidationOptions<DataField.Any>,
+    options?: DataField.ValidateOptions<this>,
   ): boolean | DataModelValidationFailure | void;
 
   /**
@@ -1655,8 +1966,8 @@ declare class ArrayField<
    * @returns An array of element-specific errors
    */
   protected _validateElements(
-    value: any[],
-    options?: DataField.ValidationOptions<DataField.Any>,
+    value: AnyArray,
+    options?: DataField.ValidateOptions<this> | null,
   ): DataModelValidationFailure | void;
 
   /**
@@ -1666,26 +1977,28 @@ declare class ArrayField<
    * @returns A validation failure if the element failed validation
    */
   protected _validateElement(
-    value: any,
-    options: DataField.ValidationOptions<DataField.Any>,
+    value: unknown,
+    options: DataField.ValidateOptions<this>,
   ): DataModelValidationFailure | void;
 
+  // options: not null (parameter default only)
   override initialize(
     value: PersistedType,
     model: DataModel.Any,
-    options?: AnyObject,
+    options?: DataField.InitializeOptions,
   ): InitializedType | (() => InitializedType | null);
 
   override toObject(value: InitializedType): PersistedType;
 
   // TODO: Limit to the keys of `this` that are actually callable.
-  override apply<Value, Options, Return>(
-    fn: keyof this | ((this: this, value: Value, options: Options) => Return),
-    value: Value,
+  // options: not null (could be forwarded somewhere destructured, parameter default only)
+  override apply<Options, Return>(
+    fn: keyof this | ((this: this, value: AnyArray, options: Options) => Return),
+    value?: AnyArray,
     options?: Options,
   ): Return;
 
-  protected override _getField(path: string[]): unknown;
+  protected override _getField(path: string[]): DataField.Any;
 
   /**
    * Migrate this field's candidate source data.
@@ -1693,6 +2006,16 @@ declare class ArrayField<
    * @param fieldData  - The value of this field within the source data
    */
   migrateSource(sourceData: AnyObject, fieldData: unknown): unknown;
+
+  protected override _castChangeDelta(delta: string): InitializedType;
+
+  /** @remarks Returns `value` with `delta` `push`ed. `model` and `change` are unused in `ArrayField` */
+  protected override _applyChangeAdd(
+    value: InitializedType,
+    delta: InitializedType,
+    model: DataModel.Any,
+    change: ActiveEffect.EffectChangeData,
+  ): InitializedType;
 }
 
 declare namespace ArrayField {
@@ -1700,12 +2023,12 @@ declare namespace ArrayField {
    * A shorthand for the options of an ArrayField class.
    * @typeParam AssignmentElementType - the assignment type of the elements in the array
    */
-  type Options<AssignmentElementType> = DataFieldOptions<BaseAssignmentType<AssignmentElementType>>;
+  type Options<AssignmentElementType> = DataField.Options<BaseAssignmentType<AssignmentElementType>>;
 
   type AnyOptions = Options<unknown>;
 
   /**
-   * The base assignment type for the {@link ArrayField} class.
+   * The base assignment type for the {@link ArrayField | `ArrayField`} class.
    * @typeParam AssignmentElementType - the assignment type of the elements in the array
    */
   type BaseAssignmentType<AssignmentElementType> =
@@ -1715,7 +2038,7 @@ declare namespace ArrayField {
     | AssignmentElementType;
 
   /**
-   * The type of the default options for the {@link ArrayField} class.
+   * The type of the default options for the {@link ArrayField | `ArrayField`} class.
    * @typeParam AssignmentElementType - the assignment type of the elements in the array
    */
   type DefaultOptions<AssignmentElementType> = SimpleMerge<
@@ -1742,33 +2065,33 @@ declare namespace ArrayField {
    * @typeParam ElementFieldType - the DataField type of the elements in the ArrayField
    */
   type AssignmentElementType<ElementFieldType extends DataField.Any | Document.AnyConstructor> =
-    ElementFieldType extends DataField<any, infer Assign, any, any>
-      ? Assign
-      : ElementFieldType extends new (...args: any[]) => Document<any, infer Schema extends DataSchema, any>
-        ? SchemaField.InnerAssignmentType<Schema>
-        : never;
+    ElementFieldType extends
+      | (abstract new (...args: infer _1) => { " __fvtt_types_internal_assignment_data": infer AssignmentData })
+      | { " __fvtt_types_internal_assignment_data": infer AssignmentData }
+      ? AssignmentData
+      : never;
 
   /**
    * A type to infer the initialized element type of an ArrayField from its ElementFieldType.
    * @typeParam ElementFieldType - the DataField type of the elements in the ArrayField
    */
   type InitializedElementType<ElementFieldType extends DataField.Any | Document.AnyConstructor> =
-    ElementFieldType extends DataField<any, any, infer Init, any>
-      ? Init
-      : ElementFieldType extends new (...args: any[]) => Document<any, infer Schema extends DataSchema, any>
-        ? SchemaField.InnerInitializedType<Schema>
-        : never;
+    ElementFieldType extends
+      | (abstract new (...args: infer _1) => { " __fvtt_types_internal_initialized_data": infer InitializedData })
+      | { " __fvtt_types_internal_initialized_data": infer InitializedData }
+      ? InitializedData
+      : never;
 
   /**
    * A type to infer the initialized element type of an ArrayField from its ElementFieldType.
    * @typeParam ElementFieldType - the DataField type of the elements in the ArrayField
    */
   type PersistedElementType<ElementFieldType extends DataField.Any | Document.AnyConstructor> =
-    ElementFieldType extends DataField<any, any, any, infer Persist>
-      ? Persist
-      : ElementFieldType extends new (...args: any[]) => Document<any, infer Schema extends DataSchema, any>
-        ? SchemaField.InnerPersistedType<Schema>
-        : never;
+    ElementFieldType extends
+      | (abstract new (...args: infer _1) => { " __fvtt_types_internal_source_data": infer PersistedData })
+      | { " __fvtt_types_internal_source_data": infer PersistedData }
+      ? PersistedData
+      : never;
 
   /**
    * A shorthand for the assignment type of an ArrayField class.
@@ -1795,7 +2118,7 @@ declare namespace ArrayField {
   /**
    * A shorthand for the persisted type of an ArrayField class.
    * @typeParam AssignmentElementType - the assignment type of the elements of the ArrayField
-   * @typeParam PersistedElementType  - the perssited type of the elements of the ArrayField
+   * @typeParam PersistedElementType  - the persisted type of the elements of the ArrayField
    * @typeParam Opts                  - the options that override the default options
    */
   type PersistedType<
@@ -1806,7 +2129,7 @@ declare namespace ArrayField {
 }
 
 /**
- * A subclass of [ArrayField]{@link ArrayField} which supports a set of contained elements.
+ * A subclass of {@link ArrayField | `ArrayField`} which supports a set of contained elements.
  * Elements in this set are treated as fungible and may be represented in any order or discarded if invalid.
  * @typeParam ElementFieldType       - the field type for the elements in the SetField
  * @typeParam AssignmentElementType  - the assignment type for the elements in the set
@@ -1818,10 +2141,10 @@ declare namespace ArrayField {
  * @typeParam PersistedType          - the type of the persisted values of the SetField
  * @remarks
  * Defaults:
- * AssignmentType: `SetField.BaseAssignmentType<AssignmentElementType> | null | undefined`
- * InitializedType: `Set<InitializedElementType>`
- * PersistedType: `PersistedElementType[]`
- * InitialValue: `new Set()`
+ * - AssignmentType: `SetField.BaseAssignmentType<AssignmentElementType> | null | undefined`
+ * - InitializedType: `Set<InitializedElementType>`
+ * - PersistedType: `PersistedElementType[]`
+ * - InitialValue: `new Set()`
  */
 declare class SetField<
   ElementFieldType extends DataField.Any,
@@ -1846,15 +2169,17 @@ declare class SetField<
   PersistedElementType,
   PersistedType
 > {
+  // options: required (property access with no default)
   protected override _validateElements(
     value: any[],
-    options?: DataField.ValidationOptions<DataField.Any>,
+    options: DataField.ValidateOptions<this>,
   ): void | DataModelValidationFailure;
 
+  // options: not null (parameter default only)
   override initialize(
     value: PersistedType,
     model: DataModel.Any,
-    options?: AnyObject,
+    options?: DataField.InitializeOptions,
   ): InitializedType | (() => InitializedType | null);
 
   override toObject(value: InitializedType): PersistedType;
@@ -1869,28 +2194,41 @@ declare class SetField<
   protected override _toInput(
     config: SetField.ToInputConfig<ElementFieldType, InitializedType>,
   ): HTMLElement | HTMLCollection;
+
+  protected override _castChangeDelta(delta: string): InitializedType;
+
+  /**
+   * @remarks Returns `value` with each element of `delta` `add`ed in order.
+   * `model` and `change` are unused in `SetField`
+   */
+  protected override _applyChangeAdd(
+    value: InitializedType,
+    delta: InitializedType,
+    model: DataModel.Any,
+    change: ActiveEffect.EffectChangeData,
+  ): InitializedType;
 }
 
 declare namespace SetField {
   /** Any SetField */
-  type Any = SetField<DataField.Any, any, any, any, any, any, any, any>;
+  interface Any extends SetField<DataField.Any, any, any, any, any, any, any, any> {}
 
   /**
    * A shorthand for the options of a SetField class.
    * @typeParam AssignmentElementType - the assignment type of the elements in the array
    */
-  type Options<AssignmentElementType> = DataFieldOptions<SetField.BaseAssignmentType<AssignmentElementType>>;
+  type Options<AssignmentElementType> = DataField.Options<SetField.BaseAssignmentType<AssignmentElementType>>;
 
   type AnyOptions = Options<unknown>;
 
   /**
-   * The base assignment type for the {@link SetField} class.
+   * The base assignment type for the {@link SetField | `SetField`} class.
    * @typeParam AssignmentElementType - the assignment type of the elements in the array
    */
   type BaseAssignmentType<AssignmentElementType> = ArrayField.BaseAssignmentType<AssignmentElementType>;
 
   /**
-   * The type of the default options for the {@link SetField} class.
+   * The type of the default options for the {@link SetField | `SetField`} class.
    * @typeParam AssignmentElementType - the assignment type of the elements in the array
    */
   type DefaultOptions<AssignmentElementType> = ArrayField.DefaultOptions<AssignmentElementType>;
@@ -1930,7 +2268,7 @@ declare namespace SetField {
   /**
    * A shorthand for the persisted type of a SetField class.
    * @typeParam AssignmentElementType - the assignment type of the elements of the SetField
-   * @typeParam PersistedElementType  - the perssited type of the elements of the SetField
+   * @typeParam PersistedElementType  - the persisted type of the elements of the SetField
    * @typeParam Opts                  - the options that override the default options
    */
   type PersistedType<
@@ -1949,7 +2287,7 @@ declare namespace SetField {
 }
 
 /**
- * A subclass of [ObjectField]{@link ObjectField} which embeds some other DataModel definition as an inner object.
+ * A subclass of {@link ObjectField | `ObjectField`} which embeds some other DataModel definition as an inner object.
  * @typeParam ModelType       - the DataModel for the embedded data
  * @typeParam Options         - the options of the EmbeddedDataField instance
  * @typeParam AssignmentType  - the type of the allowed assignment values of the EmbeddedDataField
@@ -1957,10 +2295,10 @@ declare namespace SetField {
  * @typeParam PersistedType   - the type of the persisted values of the EmbeddedDataField
  * @remarks
  * Defaults:
- * AssignmentType: `SchemaField.AssignmentType<ModelType["schema"]["fields"]> | null | undefined`
- * InitializedType: `SchemaField.InitializedType<ModelType["schema"]["fields"]>`
- * PersistedType: `SchemaField.PersistedType<ModelType["schema"]["fields"]>`
- * InitialValue: `{}`
+ * - AssignmentType: `SchemaField.AssignmentType<ModelType["schema"]["fields"]> | null | undefined`
+ * - InitializedType: `SchemaField.InitializedType<ModelType["schema"]["fields"]>`
+ * - PersistedType: `SchemaField.PersistedType<ModelType["schema"]["fields"]>`
+ * - InitialValue: `{}`
  */
 declare class EmbeddedDataField<
   const ModelType extends DataModel.AnyConstructor,
@@ -1972,20 +2310,32 @@ declare class EmbeddedDataField<
   /**
    * @param model   - The class of DataModel which should be embedded in this field
    * @param options - Options which configure the behavior of the field
+   * @param context - Additional context which describes the field
    */
-  constructor(model: ModelType, options?: Options, context?: DataField.Context);
+  // options: not null (unchecked `in` operation in super), context: not null (destructured in super)
+  constructor(model: ModelType, options?: Options, context?: DataField.ConstructionContext);
 
   /**
    * The embedded DataModel definition which is contained in this field.
    */
   model: ModelType;
 
-  protected override _initialize(fields: DataModel.SchemaOfClass<ModelType>): DataModel.SchemaOfClass<ModelType>;
+  /** @remarks Passed `options.source` will be ignored, forwarded to super with `source: value` */
+  // options: not null (parameter default only, property access)
+  override clean(value: AssignmentType, options?: DataField.CleanOptions): InitializedType;
+
+  /** @remarks Forwards to super with `options.source: value` */
+  // options: not null (parameter default only, property access)
+  override validate(
+    value: AssignmentType,
+    options?: DataField.ValidateOptions<this>,
+  ): DataModelValidationFailure | void;
 
+  // options: not null (parameter default only)
   override initialize(
     value: PersistedType,
     model: DataModel.Any,
-    options?: AnyObject,
+    options?: DataField.InitializeOptions,
   ): InitializedType | (() => InitializedType | null);
 
   override toObject(value: InitializedType): PersistedType;
@@ -1997,7 +2347,7 @@ declare class EmbeddedDataField<
    */
   migrateSource(sourceData: AnyObject, fieldData: unknown): unknown;
 
-  protected override _validateModel(data: AnyObject, options?: AnyObject): void;
+  protected override _validateModel(data: AnyObject, options?: DataField.ValidateModelOptions | null): void;
 }
 
 declare namespace EmbeddedDataField {
@@ -2005,11 +2355,11 @@ declare namespace EmbeddedDataField {
    * A shorthand for the options of an EmbeddedDataField class.
    * @typeParam ModelType - the DataModel for the embedded data
    */
-  type Options<ModelType extends DataModel.AnyConstructor> = DataFieldOptions<
-    SchemaField.InnerAssignmentType<DataModel.SchemaOfClass<ModelType>> | __SchemaFieldInitial
+  type Options<ModelType extends DataModel.AnyConstructor> = DataField.Options<
+    SchemaField.AssignmentData<DataModel.SchemaOfClass<ModelType>> | __SchemaFieldInitial
   >;
 
-  /** The type of the default options for the {@link EmbeddedDataField} class. */
+  /** The type of the default options for the {@link EmbeddedDataField | `EmbeddedDataField`} class. */
   type DefaultOptions = SchemaField.DefaultOptions;
 
   /**
@@ -2031,7 +2381,7 @@ declare namespace EmbeddedDataField {
     ModelType extends DataModel.AnyConstructor,
     Opts extends Options<ModelType>,
   > = DataField.DerivedAssignmentType<
-    SchemaField.InnerAssignmentType<DataModel.SchemaOfClass<ModelType>>,
+    SchemaField.AssignmentData<DataModel.SchemaOfClass<ModelType>>,
     MergedOptions<ModelType, Opts>
   >;
 
@@ -2044,7 +2394,7 @@ declare namespace EmbeddedDataField {
   type InitializedType<
     ModelType extends DataModel.AnyConstructor,
     Opts extends Options<ModelType>,
-  > = DataField.DerivedInitializedType<InstanceType<ModelType>, MergedOptions<ModelType, Opts>>;
+  > = DataField.DerivedInitializedType<FixedInstanceType<ModelType>, MergedOptions<ModelType, Opts>>;
 
   /**
    * A shorthand for the persisted type of an EmbeddedDataField class.
@@ -2055,13 +2405,13 @@ declare namespace EmbeddedDataField {
     ModelType extends DataModel.AnyConstructor,
     Opts extends Options<ModelType>,
   > = DataField.DerivedInitializedType<
-    SchemaField.InnerPersistedType<DataModel.SchemaOfClass<ModelType>>,
+    SchemaField.SourceData<DataModel.SchemaOfClass<ModelType>>,
     MergedOptions<ModelType, Opts>
   >;
 }
 
 /**
- * A subclass of [ArrayField]{@link ArrayField} which supports an embedded Document collection.
+ * A subclass of {@link ArrayField | `ArrayField`} which supports an embedded Document collection.
  * Invalid elements will be dropped from the collection during validation rather than failing for the field entirely.
  * @typeParam ElementFieldType       - the field type for the elements in the EmbeddedCollectionField
  * @typeParam AssignmentElementType  - the assignment type for the elements in the collection
@@ -2073,10 +2423,10 @@ declare namespace EmbeddedDataField {
  * @typeParam PersistedType          - the type of the persisted values of the EmbeddedCollectionField
  * @remarks
  * Defaults:
- * AssignmentType: `ArrayField.BaseAssignmentType<AssignmentElementType> | null | undefined`
- * InitializedType: `Collection<InitializedElementType>`
- * PersistedType: `PersistedElementType[]`
- * InitialValue: `[]`
+ * - AssignmentType: `ArrayField.BaseAssignmentType<AssignmentElementType> | null | undefined`
+ * - InitializedType: `Collection<InitializedElementType>`
+ * - PersistedType: `PersistedElementType[]`
+ * - InitialValue: `[]`
  */
 declare class EmbeddedCollectionField<
   ElementFieldType extends Document.AnyConstructor,
@@ -2113,10 +2463,16 @@ declare class EmbeddedCollectionField<
   /**
    * @param element - The type of Document which belongs to this embedded collection
    * @param options - Options which configure the behavior of the field
+   * @param context - Additional context which describes the field
+   * @remarks Forces `readonly: true`, regardless of passed value
    */
-  constructor(element: ElementFieldType, options?: Options, context?: DataField.Context);
+  // options: not null (unchecked `in` operation in super), context: not null (destructured in super)
+  constructor(element: ElementFieldType, options?: Options, context?: DataField.ConstructionContext);
 
-  /** @defaultValue `true` */
+  /**
+   * @defaultValue `true`
+   * @remarks Enforced by the constructor
+   */
   override readonly: true;
 
   protected static override _validateElementType<T extends DataField.Any | Document.AnyConstructor>(element: T): T;
@@ -2139,24 +2495,35 @@ declare class EmbeddedCollectionField<
    */
   get schema(): this["model"]["schema"];
 
-  protected override _cleanType(value: InitializedType, options?: DataField.CleanOptions): InitializedType;
+  protected override _cast(value: AssignmentType): InitializedType;
+
+  /**
+   * @remarks Calls the Collection's Document's Implementation's `schema.clean` on every entry in `value`,
+   * with `options.source` set to that entry
+   * @privateRemarks `null` is allowed for `options` as it gets spread, and `...null` doesn't error
+   */
+  protected override _cleanType(value: InitializedType, options?: DataField.CleanOptions | null): InitializedType;
 
+  // options: required (property access with no default)
   protected override _validateElements(
     value: any[],
-    options?: DataField.ValidationOptions<DataField.Any>,
+    options: DataField.ValidateOptions<this>,
   ): DataModelValidationFailure | void;
 
+  // options: not null (parameter default only)
   override initialize(
     value: PersistedType,
     model: DataModel.Any,
-    options?: AnyObject,
+    options?: DataField.InitializeOptions,
   ): InitializedType | (() => InitializedType | null);
 
   override toObject(value: InitializedType): PersistedType;
 
+  // TODO: Find a way to limit `Value` to `AnyObject | undefined` here while allowing it to be `unknown` in DataField
+  // options: not null (could be forwarded somewhere destructured, parameter default only)
   override apply<Value, Options, Return>(
     fn: keyof this | ((this: this, value: Value, options: Options) => Return),
-    value: Value,
+    value?: Value,
     options?: Options,
   ): Return;
 
@@ -2175,16 +2542,16 @@ declare class EmbeddedCollectionField<
 }
 
 declare namespace EmbeddedCollectionField {
-  type Any = EmbeddedCollectionField<any, any, any, any, any, any, any, any, any>;
+  interface Any extends EmbeddedCollectionField<any, any, any, any, any, any, any, any, any> {}
 
   /**
    * A shorthand for the options of an EmbeddedCollectionField class.
    * @typeParam AssignmentElementType - the assignment type of the elements of the EmbeddedCollectionField
    */
-  type Options<AssignmentElementType> = DataFieldOptions<ArrayField.BaseAssignmentType<AssignmentElementType>>;
+  type Options<AssignmentElementType> = DataField.Options<ArrayField.BaseAssignmentType<AssignmentElementType>>;
 
   /**
-   * The type of the default options for the {@link EmbeddedCollectionField} class.
+   * The type of the default options for the {@link EmbeddedCollectionField | `EmbeddedCollectionField`} class.
    * @typeParam AssignmentElementType - the assignment type of the elements of the EmbeddedCollectionField
    */
   type DefaultOptions<AssignmentElementType> = ArrayField.DefaultOptions<AssignmentElementType>;
@@ -2203,10 +2570,11 @@ declare namespace EmbeddedCollectionField {
    * A type to infer the assignment element type of an EmbeddedCollectionField from its ElementFieldType.
    * @typeParam ElementFieldType - the DataField type of the elements in the EmbeddedCollectionField
    */
-  type AssignmentElementType<ElementFieldType extends Document.AnyConstructor> = ElementFieldType extends new (
-    ...args: any[]
-  ) => Document<any, infer Schema extends DataSchema, any>
-    ? SchemaField.InnerAssignmentType<Schema>
+  // Note(LukeAbby): For some reason checking `extends Document` causes issues where this doesn't.
+  type AssignmentElementType<ElementFieldType extends Document.AnyConstructor> = ElementFieldType extends abstract new (
+    ...args: infer _1
+  ) => { " __fvtt_types_internal_assignment_data": infer AssignmentData }
+    ? AssignmentData
     : never;
 
   /**
@@ -2220,10 +2588,11 @@ declare namespace EmbeddedCollectionField {
    * A type to infer the initialized element type of an EmbeddedCollectionField from its ElementFieldType.
    * @typeParam ElementFieldType - the DataField type of the elements in the EmbeddedCollectionField
    */
-  type PersistedElementType<ElementFieldType extends Document.AnyConstructor> = ElementFieldType extends new (
-    ...args: any[]
-  ) => Document<any, infer Schema extends DataSchema, any>
-    ? SchemaField.InnerPersistedType<Schema>
+  // Note(LukeAbby): For some reason checking `extends Document` causes issues where this doesn't.
+  type PersistedElementType<ElementFieldType extends Document.AnyConstructor> = ElementFieldType extends abstract new (
+    ...args: infer _1
+  ) => { " __fvtt_types_internal_source_data": infer AssignmentData }
+    ? AssignmentData
     : never;
 
   /**
@@ -2258,7 +2627,7 @@ declare namespace EmbeddedCollectionField {
   /**
    * A shorthand for the persisted type of an ArrayField class.
    * @typeParam AssignmentElementType - the assignment type of the elements of the EmbeddedCollectionField
-   * @typeParam PersistedElementType  - the perssited type of the elements of the EmbeddedCollectionField
+   * @typeParam PersistedElementType  - the persisted type of the elements of the EmbeddedCollectionField
    * @typeParam Opts                  - the options that override the default options
    */
   type PersistedType<
@@ -2269,7 +2638,7 @@ declare namespace EmbeddedCollectionField {
 }
 
 /**
- * A subclass of {@link EmbeddedCollectionField} which manages a collection of delta objects relative to another
+ * A subclass of {@link EmbeddedCollectionField | `EmbeddedCollectionField`} which manages a collection of delta objects relative to another
  * collection.
  * @typeParam ElementFieldType       - the field type for the elements in the EmbeddedCollectionDeltaField
  * @typeParam AssignmentElementType  - the assignment type for the elements in the collection
@@ -2281,10 +2650,10 @@ declare namespace EmbeddedCollectionField {
  * @typeParam PersistedType          - the type of the persisted values of the EmbeddedCollectionDeltaField
  * @remarks
  * Defaults:
- * AssignmentType: `ArrayField.BaseAssignmentType<AssignmentElementType> | null | undefined`
- * InitializedType: `Collection<InitializedElementType>`
- * PersistedType: `PersistedElementType[]`
- * InitialValue: `[]`
+ * - AssignmentType: `ArrayField.BaseAssignmentType<AssignmentElementType> | null | undefined`
+ * - InitializedType: `Collection<InitializedElementType>`
+ * - PersistedType: `PersistedElementType[]`
+ * - InitialValue: `[]`
  */
 declare class EmbeddedCollectionDeltaField<
   ElementFieldType extends Document.AnyConstructor,
@@ -2320,11 +2689,17 @@ declare class EmbeddedCollectionDeltaField<
 > {
   static override get implementation(): typeof EmbeddedCollectionDelta;
 
-  protected override _cleanType(value: InitializedType, options?: DataField.CleanOptions): InitializedType;
+  /**
+   * @remarks Calls the Collection's Document's Implementation's `schema.clean` on every entry in `value`,
+   * with `options.source` set to that entry, and some special handling for Tombstone data
+   * @privateRemarks `null` is allowed for `options` as it gets spread, and `...null` doesn't error
+   */
+  protected override _cleanType(value: InitializedType, options?: DataField.CleanOptions | null): InitializedType;
 
+  // options: required (property access with no default)
   protected override _validateElements(
     value: any[],
-    options?: DataField.ValidationOptions<DataField.Any>,
+    options: DataField.ValidateOptions<this>,
   ): void | DataModelValidationFailure;
 }
 
@@ -2333,10 +2708,10 @@ declare namespace EmbeddedCollectionDeltaField {
    * A shorthand for the options of an EmbeddedCollectionDeltaField class.
    * @typeParam AssignmentElementType - the assignment type of the elements of the EmbeddedCollectionDeltaField
    */
-  type Options<AssignmentElementType> = DataFieldOptions<ArrayField.BaseAssignmentType<AssignmentElementType>>;
+  type Options<AssignmentElementType> = DataField.Options<ArrayField.BaseAssignmentType<AssignmentElementType>>;
 
   /**
-   * The type of the default options for the {@link EmbeddedCollectionDeltaField} class.
+   * The type of the default options for the {@link EmbeddedCollectionDeltaField | `EmbeddedCollectionDeltaField`} class.
    * @typeParam AssignmentElementType - the assignment type of the elements of the EmbeddedCollectionDeltaField
    */
   type DefaultOptions<AssignmentElementType> = ArrayField.DefaultOptions<AssignmentElementType>;
@@ -2355,10 +2730,10 @@ declare namespace EmbeddedCollectionDeltaField {
    * A type to infer the assignment element type of an EmbeddedCollectionDeltaField from its ElementFieldType.
    * @typeParam ElementFieldType - the DataField type of the elements in the EmbeddedCollectionDeltaField
    */
-  type AssignmentElementType<ElementFieldType extends Document.AnyConstructor> = ElementFieldType extends new (
-    ...args: any[]
-  ) => Document<any, infer Schema extends DataSchema, any>
-    ? SchemaField.InnerAssignmentType<Schema>
+  type AssignmentElementType<ElementFieldType extends Document.AnyConstructor> = ElementFieldType extends abstract new (
+    ...args: infer _1
+  ) => { " __fvtt_types_internal_assignment_data": infer AssignmentData }
+    ? AssignmentData
     : never;
 
   /**
@@ -2372,10 +2747,11 @@ declare namespace EmbeddedCollectionDeltaField {
    * A type to infer the initialized element type of an EmbeddedCollectionDeltaField from its ElementFieldType.
    * @typeParam ElementFieldType - the DataField type of the elements in the EmbeddedCollectionDeltaField
    */
-  type PersistedElementType<ElementFieldType extends Document.AnyConstructor> = ElementFieldType extends new (
-    ...args: any[]
-  ) => Document<any, infer Schema extends DataSchema, any>
-    ? SchemaField.InnerPersistedType<Schema>
+  // Note(LukeAbby): For some reason checking `extends Document` causes issues where `extends DataModel` doesn't.
+  type PersistedElementType<ElementFieldType extends Document.AnyConstructor> = ElementFieldType extends abstract new (
+    ...args: infer _1
+  ) => { " __fvtt_types_internal_source_data": infer AssignmentData }
+    ? AssignmentData
     : never;
 
   /**
@@ -2410,7 +2786,7 @@ declare namespace EmbeddedCollectionDeltaField {
   /**
    * A shorthand for the persisted type of an ArrayField class.
    * @typeParam AssignmentElementType - the assignment type of the elements of the EmbeddedCollectionDeltaField
-   * @typeParam PersistedElementType  - the perssited type of the elements of the EmbeddedCollectionDeltaField
+   * @typeParam PersistedElementType  - the persisted type of the elements of the EmbeddedCollectionDeltaField
    * @typeParam Opts                  - the options that override the default options
    */
   type PersistedType<
@@ -2421,7 +2797,7 @@ declare namespace EmbeddedCollectionDeltaField {
 }
 
 /**
- * A subclass of {@link EmbeddedDataField} which supports a single embedded Document.
+ * A subclass of {@link EmbeddedDataField | `EmbeddedDataField`} which supports a single embedded Document.
  * @typeParam DocumentType    - the type of the embedded Document
  * @typeParam Options         - the options of the EmbeddedDocumentField instance
  * @typeParam AssignmentType  - the type of the allowed assignment values of the EmbeddedDocumentField
@@ -2429,10 +2805,10 @@ declare namespace EmbeddedCollectionDeltaField {
  * @typeParam PersistedType   - the type of the persisted values of the EmbeddedDocumentField
  * @remarks
  * Defaults:
- * AssignmentType: `SchemaField.AssignmentType<DocumentType["schema"]["fields"]> | null | undefined`
- * InitializedType: `SchemaField.InitializedType<DocumentType["schema"]["fields"]> | null`
- * PersistedType: `SchemaField.PersistedType<DocumentType["schema"]["fields"]> | null`
- * InitialValue: `{}`
+ * - AssignmentType: `SchemaField.AssignmentType<DocumentType["schema"]["fields"]> | null | undefined`
+ * - InitializedType: `SchemaField.InitializedType<DocumentType["schema"]["fields"]> | null`
+ * - PersistedType: `SchemaField.PersistedType<DocumentType["schema"]["fields"]> | null`
+ * - InitialValue: `{}`
  */
 declare class EmbeddedDocumentField<
   const DocumentType extends Document.AnyConstructor,
@@ -2444,8 +2820,10 @@ declare class EmbeddedDocumentField<
   /**
    * @param model   - The type of Document which is embedded.
    * @param options - Options which configure the behavior of the field.
+   * @param context - Additional context which describes the field
    */
-  constructor(model: DocumentType, options?: Options, context?: DataField.Context);
+  // options: not null (unchecked `in` operation in super), context: not null (destructured in super)
+  constructor(model: DocumentType, options?: Options, context?: DataField.ConstructionContext);
 
   /** @defaultValue `true` */
   override nullable: boolean;
@@ -2455,10 +2833,11 @@ declare class EmbeddedDocumentField<
   /** @defaultValue `true` */
   static override hierarchical: boolean;
 
+  // options: not null (parameter default only)
   override initialize(
     value: PersistedType,
     model: DataModel.Any,
-    options?: AnyObject,
+    options?: DataField.InitializeOptions,
   ): InitializedType | (() => InitializedType | null);
 
   /**
@@ -2469,15 +2848,17 @@ declare class EmbeddedDocumentField<
 }
 
 declare namespace EmbeddedDocumentField {
+  interface Any extends EmbeddedDocumentField<any, any, any, any, any> {}
+
   /**
    * A shorthand for the options of an EmbeddedDocumentField class.
    * @typeParam DocumentType - the type of the embedded Document
    */
-  type Options<DocumentType extends Document.AnyConstructor> = DataFieldOptions<
-    SchemaField.InnerAssignmentType<DataModel.SchemaOfClass<DocumentType>> | __SchemaFieldInitial
+  type Options<DocumentType extends Document.AnyConstructor> = DataField.Options<
+    SchemaField.AssignmentData<DataModel.SchemaOfClass<DocumentType>> | __SchemaFieldInitial
   >;
 
-  /** The type of the default options for the {@link EmbeddedDocumentField} class. */
+  /** The type of the default options for the {@link EmbeddedDocumentField | `EmbeddedDocumentField`} class. */
   type DefaultOptions = SimpleMerge<
     EmbeddedDataField.DefaultOptions,
     {
@@ -2504,7 +2885,7 @@ declare namespace EmbeddedDocumentField {
     DocumentType extends Document.AnyConstructor,
     Opts extends Options<DocumentType>,
   > = DataField.DerivedAssignmentType<
-    SchemaField.InnerAssignmentType<DataModel.SchemaOfClass<DocumentType>>,
+    SchemaField.AssignmentData<DataModel.SchemaOfClass<DocumentType>>,
     MergedOptions<DocumentType, Opts>
   >;
 
@@ -2517,7 +2898,7 @@ declare namespace EmbeddedDocumentField {
     DocumentType extends Document.AnyConstructor,
     Opts extends Options<DocumentType>,
   > = DataField.DerivedInitializedType<
-    SchemaField.InnerInitializedType<DataModel.SchemaOfClass<DocumentType>>,
+    SchemaField.InitializedData<DataModel.SchemaOfClass<DocumentType>>,
     MergedOptions<DocumentType, Opts>
   >;
 
@@ -2530,13 +2911,13 @@ declare namespace EmbeddedDocumentField {
     DocumentType extends Document.AnyConstructor,
     Opts extends Options<DocumentType>,
   > = DataField.DerivedInitializedType<
-    SchemaField.InnerPersistedType<DataModel.SchemaOfClass<DocumentType>>,
+    SchemaField.SourceData<DataModel.SchemaOfClass<DocumentType>>,
     MergedOptions<DocumentType, Opts>
   >;
 }
 
 /**
- * A subclass of [StringField]{@link StringField} which provides the primary _id for a Document.
+ * A subclass of {@link StringField | `StringField`} which provides the primary _id for a Document.
  * The field may be initially null, but it must be non-null when it is saved to the database.
  * @typeParam Options         - the options of the DocumentIdField instance
  * @typeParam AssignmentType  - the type of the allowed assignment values of the DocumentIdField
@@ -2544,13 +2925,13 @@ declare namespace EmbeddedDocumentField {
  * @typeParam PersistedType   - the type of the persisted values of the DocumentIdField
  * @remarks
  * Defaults:
- * AssignmentType: `string | Document.Any | null | undefined`
- * InitializedType: `string | null`
- * PersistedType: `string | null`
- * InitialValue: `null`
+ * - AssignmentType: `string | Document.Any | null | undefined`
+ * - InitializedType: `string | null`
+ * - PersistedType: `string | null`
+ * - InitialValue: `null`
  */
 declare class DocumentIdField<
-  Options extends StringFieldOptions = DocumentIdField.DefaultOptions,
+  Options extends DocumentIdField.Options = DocumentIdField.DefaultOptions,
   AssignmentType = DocumentIdField.AssignmentType<Options>,
   InitializedType = DocumentIdField.InitializedType<Options>,
   PersistedType extends string | null | undefined = DocumentIdField.InitializedType<Options>,
@@ -2565,7 +2946,7 @@ declare class DocumentIdField<
   override nullable: boolean;
 
   /** @defaultValue `null` */
-  override initial: DataFieldOptions.InitialType<InitializedType>;
+  override initial: DataField.Options.InitialType<InitializedType>;
 
   /** @defaultValue `true` */
   override readonly: boolean;
@@ -2573,18 +2954,23 @@ declare class DocumentIdField<
   /** @defaultValue `"is not a valid Document ID string"` */
   override validationError: string;
 
-  protected static override get _defaults(): StringFieldOptions;
+  protected static override get _defaults(): StringField.Options<unknown>;
 
   protected override _cast(value: AssignmentType): InitializedType;
 
+  /** @remarks `options` is unused in `DocumentIdField` */
   protected override _validateType(
     value: InitializedType,
-    options?: DataField.ValidationOptions<DataField.Any>,
+    options?: DataField.ValidateOptions<this> | null,
   ): boolean | DataModelValidationFailure | void;
 }
 
 declare namespace DocumentIdField {
-  /** The type of the default options for the {@link DocumentIdField} class. */
+  type Options = StringField.Options<unknown> & {
+    readonly?: boolean;
+  };
+
+  /** The type of the default options for the {@link DocumentIdField | `DocumentIdField`} class. */
   type DefaultOptions = SimpleMerge<
     StringField.DefaultOptions,
     {
@@ -2601,13 +2987,13 @@ declare namespace DocumentIdField {
    * A helper type for the given options type merged into the default options of the DocumentIdField class.
    * @typeParam Options - the options that override the default options
    */
-  type MergedOptions<Options extends StringFieldOptions> = SimpleMerge<DefaultOptions, Options>;
+  type MergedOptions<Options extends StringField.Options<unknown>> = SimpleMerge<DefaultOptions, Options>;
 
   /**
    * A shorthand for the assignment type of a StringField class.
    * @typeParam Options - the options that override the default options
    */
-  type AssignmentType<Options extends StringFieldOptions> = DataField.DerivedAssignmentType<
+  type AssignmentType<Options extends StringField.Options<unknown>> = DataField.DerivedAssignmentType<
     string | Document.Any,
     MergedOptions<Options>
   >;
@@ -2616,14 +3002,14 @@ declare namespace DocumentIdField {
    * A shorthand for the initialized type of a StringField class.
    * @typeParam Options - the options that override the default options
    */
-  type InitializedType<Options extends StringFieldOptions> = DataField.DerivedInitializedType<
+  type InitializedType<Options extends StringField.Options<unknown>> = DataField.DerivedInitializedType<
     string,
     MergedOptions<Options>
   >;
 }
 
 /**
- * A subclass of {@link StringField} which supports referencing some other Document by its UUID.
+ * A subclass of {@link StringField | `StringField`} which supports referencing some other Document by its UUID.
  * This field may not be blank, but may be null to indicate that no UUID is referenced.
  */
 declare class DocumentUUIDField<
@@ -2636,7 +3022,8 @@ declare class DocumentUUIDField<
    * @param options - Options which configure the behavior of the field
    * @param context - Additional context which describes the field
    */
-  constructor(options?: Options, context?: DataField.Context);
+  // options: not null (unchecked `in` operation in super), context: not null (destructured in super)
+  constructor(options?: Options, context?: DataField.ConstructionContext);
 
   /** A specific document type in CONST.ALL_DOCUMENT_TYPES required by this field */
   type: Document.Type | undefined;
@@ -2646,9 +3033,10 @@ declare class DocumentUUIDField<
 
   static get _defaults(): DocumentUUIDField.Options;
 
+  /** @remarks `options` is unused in `DocumentUUIDField` */
   protected override _validateType(
     value: InitializedType,
-    options?: DataField.ValidationOptions<DataField.Any>,
+    options?: DataField.ValidateOptions<this> | null,
   ): boolean | DataModelValidationFailure | void;
 
   // These verbose overloads are because otherwise there would be a misleading errors about `choices` being required without mentioning `options` or vice versa.
@@ -2681,14 +3069,13 @@ declare class DocumentUUIDField<
 }
 
 declare namespace DocumentUUIDField {
-  type Options = StringFieldOptions &
-    StringFieldOptions & {
-      /* A specific document type in CONST.ALL_DOCUMENT_TYPES required by this field */
-      type?: Document.Type | undefined;
+  type Options = StringField.Options & {
+    /* A specific document type in CONST.ALL_DOCUMENT_TYPES required by this field */
+    type?: Document.Type | undefined;
 
-      /* Does this field require (or prohibit) embedded documents? */
-      embedded?: boolean | undefined;
-    };
+    /* Does this field require (or prohibit) embedded documents? */
+    embedded?: boolean | undefined;
+  };
 
   type DefaultOptions = SimpleMerge<
     StringField.DefaultOptions,
@@ -2722,7 +3109,7 @@ declare namespace DocumentUUIDField {
 }
 
 /**
- * A special class of [StringField]{@link StringField} field which references another DataModel by its id.
+ * A special class of {@link StringField | `StringField`} field which references another DataModel by its id.
  * This field may also be null to indicate that no foreign model is linked.
  * @typeParam DocumentType    - the type of the foreign document constructor
  * @typeParam Options         - the options for the ForeignDocumentField
@@ -2731,10 +3118,10 @@ declare namespace DocumentUUIDField {
  * @typeParam PersistedType   - the type of the persisted values of the ForeignDocumentField
  * @remarks
  * Defaults:
- * AssignmentType: `string | InstanceType<DocumentType> | null | undefined`
- * InitializedType: `InstanceType<DocumentType> | null`
- * PersistedType: `string | null`
- * InitialValue: `null`
+ * - AssignmentType: `string | InstanceType<DocumentType> | null | undefined`
+ * - InitializedType: `InstanceType<DocumentType> | null`
+ * - PersistedType: `string | null`
+ * - InitialValue: `null`
  */
 declare class ForeignDocumentField<
   DocumentType extends Document.AnyConstructor,
@@ -2746,8 +3133,12 @@ declare class ForeignDocumentField<
   /**
    * @param model   - The foreign DataModel class definition which this field should link to.
    * @param options - Options which configure the behavior of the field
+   * @param context - Additional context which describes the field
+   *
+   * @privateRemarks Technically the runtime check allows any DataModel, but that seems unintended
    */
-  constructor(model: DocumentType, options?: Options, context?: DataField.Context);
+  // options: not null (unchecked `in` operation in super), context: not null (destructured in super)
+  constructor(model: DocumentType, options?: Options, context?: DataField.ConstructionContext);
 
   /** @defaultValue `true` */
   override nullable: boolean;
@@ -2767,24 +3158,27 @@ declare class ForeignDocumentField<
 
   protected override _cast(value: AssignmentType): InitializedType;
 
+  // options: not null (parameter default only)
   override initialize(
     value: PersistedType,
     model: DataModel.Any,
-    options?: AnyObject,
+    options?: DataField.InitializeOptions,
   ): InitializedType | (() => InitializedType | null);
 
   override toObject(value: InitializedType): PersistedType;
+
+  //TODO: _toInput
 }
 
 declare namespace ForeignDocumentField {
   /** The options for the ForeignDocumentField class. */
-  type Options = StringFieldOptions &
-    DataFieldOptions<string | Document.Any> & {
-      // Making this ---------^ more concrete leads to excessively deep instantiation
-      idOnly?: boolean;
-    };
+  // TODO(LukeAbby)
+  interface Options extends StringField.Options<string | Document.Any> {
+    //                                          ^ Making this more concrete leads to excessively deep instantiation
+    idOnly?: boolean;
+  }
 
-  /** The type of the default options for the {@link ForeignDocumentField} class. */
+  /** The type of the default options for the {@link ForeignDocumentField | `ForeignDocumentField`} class. */
   type DefaultOptions = SimpleMerge<
     DocumentIdField.DefaultOptions,
     {
@@ -2807,7 +3201,7 @@ declare namespace ForeignDocumentField {
   type AssignmentType<
     ConcreteDocument extends Document.AnyConstructor,
     Opts extends Options,
-  > = DataField.DerivedAssignmentType<string | Document.ToConfiguredClass<ConcreteDocument>, MergedOptions<Opts>>;
+  > = DataField.DerivedAssignmentType<string | Document.ToConfiguredInstance<ConcreteDocument>, MergedOptions<Opts>>;
 
   /**
    * A shorthand for the initialized type of a ForeignDocumentField class.
@@ -2829,20 +3223,20 @@ declare namespace ForeignDocumentField {
 }
 
 /**
- * A special [StringField]{@link StringField} which records a standardized CSS color string.
+ * A special {@link StringField | `StringField`} which records a standardized CSS color string.
  * @typeParam Options         - the options of the ColorField instance
  * @typeParam AssignmentType  - the type of the allowed assignment values of the ColorField
  * @typeParam InitializedType - the type of the initialized values of the ColorField
  * @typeParam PersistedType   - the type of the persisted values of the ColorField
  * @remarks
  * Defaults:
- * AssignmentType: `string | null | undefined`
- * InitializedType: `string | null`
- * PersistedType: `string | null`
- * InitialValue: `null`
+ * - AssignmentType: `string | null | undefined`
+ * - InitializedType: `string | null`
+ * - PersistedType: `string | null`
+ * - InitialValue: `null`
  */
 declare class ColorField<
-  Options extends StringFieldOptions = ColorField.DefaultOptions,
+  Options extends StringField.Options = ColorField.DefaultOptions,
   AssignmentType = ColorField.AssignmentType<Options>,
   InitializedType = ColorField.InitializedType<Options>,
   PersistedType extends string | null | undefined = ColorField.PersistedType<Options>,
@@ -2851,7 +3245,7 @@ declare class ColorField<
   override nullable: boolean;
 
   /** @defaultValue `null` */
-  override initial: DataFieldOptions.InitialType<InitializedType>;
+  override initial: DataField.Options.InitialType<InitializedType>;
 
   /** @defaultValue `false` */
   override blank: boolean;
@@ -2859,18 +3253,38 @@ declare class ColorField<
   /** @defaultValue `"is not a valid hexadecimal color string"` */
   override validationError: string;
 
-  protected static override get _defaults(): StringFieldOptions;
+  protected static override get _defaults(): StringField.Options;
 
-  override clean(value: AssignmentType, options?: DataField.CleanOptions): InitializedType;
+  // options: not null (parameter default only)
+  override initialize(
+    value: PersistedType,
+    model: DataModel.Any,
+    options?: DataField.InitializeOptions,
+  ): InitializedType | (() => InitializedType | null);
+
+  /** @throws If the value isn't a valid {@link foundry.utils.Color.Source | `Color.Source`} *after* going through `super` */
+  override getInitialValue(data?: unknown): InitializedType;
+
+  protected override _cast(value: AssignmentType): InitializedType;
+
+  /**
+   * @remarks Returns `value.css` if it's a `.valid` `Color`, otherwise `this.getInitialValue(options.source)`
+   *
+   * `options` is required as it lacks any default handling and has its `.source` property accessed
+   */
+  protected override _cleanType(value: InitializedType, options: DataField.CleanOptions): InitializedType;
 
+  /** @remarks `options` is only passed to super, where it is unused in `StringField` */
   protected override _validateType(
     value: InitializedType,
-    options?: DataField.ValidationOptions<DataField.Any>,
+    options?: DataField.ValidateOptions<this> | null,
   ): boolean | DataModelValidationFailure | void;
+
+  protected override _toInput(config: DataField.ToInputConfig<InitializedType>): HTMLElement | HTMLCollection;
 }
 
 declare namespace ColorField {
-  /** The type of the default options for the {@link ColorField} class. */
+  /** The type of the default options for the {@link ColorField | `ColorField`} class. */
   type DefaultOptions = SimpleMerge<
     StringField.DefaultOptions,
     {
@@ -2885,13 +3299,13 @@ declare namespace ColorField {
    * A helper type for the given options type merged into the default options of the ColorField class.
    * @typeParam Options - the options that override the default options
    */
-  type MergedOptions<Options extends StringFieldOptions> = SimpleMerge<DefaultOptions, Options>;
+  type MergedOptions<Options extends StringField.Options> = SimpleMerge<DefaultOptions, Options>;
 
   /**
    * A shorthand for the assignment type of a ColorField class.
    * @typeParam Options - the options that override the default options
    */
-  type AssignmentType<Options extends StringFieldOptions> = DataField.DerivedAssignmentType<
+  type AssignmentType<Options extends StringField.Options> = DataField.DerivedAssignmentType<
     string,
     MergedOptions<Options>
   >;
@@ -2900,7 +3314,7 @@ declare namespace ColorField {
    * A shorthand for the initialized type of a ColorField class.
    * @typeParam Options - the options that override the default options
    */
-  type InitializedType<Options extends StringFieldOptions> = DataField.DerivedInitializedType<
+  type InitializedType<Options extends StringField.Options> = DataField.DerivedInitializedType<
     Color,
     MergedOptions<Options>
   >;
@@ -2909,60 +3323,37 @@ declare namespace ColorField {
    * A shorthand for the persisted type of a ColorField class.
    * @typeParam Options - the options that override the default options
    */
-  type PersistedType<Options extends StringFieldOptions> = DataField.DerivedInitializedType<
+  type PersistedType<Options extends StringField.Options> = DataField.DerivedInitializedType<
     string,
     MergedOptions<Options>
   >;
 }
 
-declare global {
-  /**
-   * @typeParam Value  - the type of the value of the field
-   */
-  interface FilePathFieldOptions extends StringFieldOptions {
-    /**
-     * A set of categories in CONST.FILE_CATEGORIES which this field supports
-     * @defaultValue `[]`
-     */
-    categories?: (keyof typeof CONST.FILE_CATEGORIES)[];
-
-    /**
-     * Is embedded base64 data supported in lieu of a file path?
-     * @defaultValue `false`
-     */
-    base64?: boolean;
-
-    /**
-     * Does this file path field allow wildcard characters?
-     * @defaultValue `false`
-     */
-    wildcard?: boolean;
-  }
-}
-
 /**
- * A special [StringField]{@link StringField} which records a file path or inline base64 data.
+ * A special {@link StringField | `StringField`} which records a file path or inline base64 data.
  * @typeParam Options         - the options of the FilePathField instance
  * @typeParam AssignmentType  - the type of the allowed assignment values of the FilePathField
  * @typeParam InitializedType - the type of the initialized values of the FilePathField
  * @typeParam PersistedType   - the type of the persisted values of the FilePathField
  * @remarks
  * Defaults:
- * AssignmentType: `string | null | undefined`
- * InitializedType: `string | null`
- * PersistedType: `string | null`
- * InitialValue: `null`
+ * - AssignmentType: `string | null | undefined`
+ * - InitializedType: `string | null`
+ * - PersistedType: `string | null`
+ * - InitialValue: `null`
  */
 declare class FilePathField<
-  Options extends FilePathFieldOptions = FilePathField.DefaultOptions,
+  Options extends FilePathField.Options = FilePathField.DefaultOptions,
   AssignmentType = FilePathField.AssignmentType<Options>,
   InitializedType = FilePathField.InitializedType<Options>,
   PersistedType extends string | null | undefined = FilePathField.InitializedType<Options>,
 > extends StringField<Options, AssignmentType, InitializedType, PersistedType> {
   /**
    * @param options - Options which configure the behavior of the field
+   * @param context - Additional context which describes the field
    */
-  constructor(options?: Options, context?: DataField.Context);
+  // options: not null (unchecked `in` operation in super), context: not null (destructured in super)
+  constructor(options?: Options, context?: DataField.ConstructionContext);
 
   /**
    * A set of categories in CONST.FILE_CATEGORIES which this field supports
@@ -2989,20 +3380,23 @@ declare class FilePathField<
   override blank: boolean;
 
   /** @defaultValue `null` */
-  override initial: DataFieldOptions.InitialType<InitializedType>;
+  override initial: DataField.Options.InitialType<InitializedType>;
 
-  protected static override get _defaults(): FilePathFieldOptions;
+  protected static override get _defaults(): FilePathField.Options;
 
   override clean(value: AssignmentType, options?: DataField.CleanOptions): InitializedType;
 
+  /** @remarks `options` is unused in `FilePathField` */
   protected override _validateType(
     value: InitializedType,
-    options?: DataField.ValidationOptions<DataField.Any>,
+    options?: DataField.ValidateOptions<this>,
   ): boolean | DataModelValidationFailure | void;
+
+  // TODO: _toInput
 }
 
 declare namespace FilePathField {
-  /** The type of the default options for the {@link FilePathField} class. */
+  /** The type of the default options for the {@link FilePathField | `FilePathField`} class. */
   type DefaultOptions = SimpleMerge<
     StringField.DefaultOptions,
     {
@@ -3015,17 +3409,37 @@ declare namespace FilePathField {
     }
   >;
 
+  interface Options extends StringField.Options {
+    /**
+     * A set of categories in CONST.FILE_CATEGORIES which this field supports
+     * @defaultValue `[]`
+     */
+    categories?: (keyof typeof CONST.FILE_CATEGORIES)[];
+
+    /**
+     * Is embedded base64 data supported in lieu of a file path?
+     * @defaultValue `false`
+     */
+    base64?: boolean;
+
+    /**
+     * Does this file path field allow wildcard characters?
+     * @defaultValue `false`
+     */
+    wildcard?: boolean;
+  }
+
   /**
    * A helper type for the given options type merged into the default options of the FilePathField class.
    * @typeParam Options - the options that override the default options
    */
-  type MergedOptions<Options extends StringFieldOptions> = SimpleMerge<DefaultOptions, Options>;
+  type MergedOptions<Options extends StringField.Options> = SimpleMerge<DefaultOptions, Options>;
 
   /**
    * A shorthand for the assignment type of a FilePathField class.
    * @typeParam Options - the options that override the default options
    */
-  type AssignmentType<Options extends StringFieldOptions> = DataField.DerivedAssignmentType<
+  type AssignmentType<Options extends StringField.Options> = DataField.DerivedAssignmentType<
     string,
     MergedOptions<Options>
   >;
@@ -3034,31 +3448,38 @@ declare namespace FilePathField {
    * A shorthand for the initialized type of a FilePathField class.
    * @typeParam Options - the options that override the default options
    */
-  type InitializedType<Options extends StringFieldOptions> = DataField.DerivedInitializedType<
+  type InitializedType<Options extends StringField.Options> = DataField.DerivedInitializedType<
     string,
     MergedOptions<Options>
   >;
 }
 
 /**
- * A special [NumberField]{@link NumberField} which represents an angle of rotation in degrees between 0 and 360.
+ * A special {@link NumberField | `NumberField`} which represents an angle of rotation in degrees between 0 and 360.
  * @typeParam Options         - the options of the AngleField instance
  * @typeParam AssignmentType  - the type of the allowed assignment values of the AngleField
  * @typeParam InitializedType - the type of the initialized values of the AngleField
  * @typeParam PersistedType   - the type of the persisted values of the AngleField
  * @remarks
  * Defaults:
- * AssignmentType: `number | null | undefined`
- * InitializedType: `number`
- * PersistedType: `number`
- * InitialValue: `0`
+ * - AssignmentType: `number | null | undefined`
+ * - InitializedType: `number`
+ * - PersistedType: `number`
+ * - InitialValue: `0`
  */
 declare class AngleField<
-  Options extends NumberFieldOptions = AngleField.DefaultOptions,
+  Options extends NumberField.Options = AngleField.DefaultOptions,
   AssignmentType = AngleField.AssignmentType<Options>,
   InitializedType = AngleField.InitializedType<Options>,
   PersistedType extends number | null | undefined = AngleField.InitializedType<Options>,
 > extends NumberField<Options, AssignmentType, InitializedType, PersistedType> {
+  /**
+   * @param options - Options which configure the behavior of the field
+   * @param context - Additional context which describes the field
+   */
+  // options: not null (unchecked `in` operation in super), context: not null (destructured in super)
+  constructor(options?: Options, context?: DataField.ConstructionContext);
+
   /** @defaultValue `true` */
   override required: boolean;
 
@@ -3066,10 +3487,13 @@ declare class AngleField<
   override nullable: boolean;
 
   /** @defaultValue `0` */
-  override initial: DataFieldOptions.InitialType<InitializedType>;
+  override initial: DataField.Options.InitialType<InitializedType>;
 
-  /** @defaultValue `0` */
-  base: number;
+  /**
+   * Whether the angle should be normalized to [0,360) before being clamped to [0,360]. The default is true.
+   * @defaultValue `true`
+   */
+  normalize: boolean;
 
   /** @defaultValue `0` */
   override min: number | undefined;
@@ -3080,20 +3504,28 @@ declare class AngleField<
   /** @defaultValue `"is not a number between 0 and 360"` */
   override validationError: string;
 
-  protected static override get _defaults(): NumberFieldOptions;
+  protected static override get _defaults(): NumberField.Options;
 
   protected override _cast(value: AssignmentType): InitializedType;
+
+  /**
+   * @deprecated since v12, until v14
+   * @remarks "The `AngleField#base` is deprecated in favor of {@link AngleField.normalize | `AngleField#normalize`}."
+   */
+  get base(): number;
+
+  set base(value);
 }
 
 declare namespace AngleField {
-  /** The type of the default options for the {@link AngleField} class. */
+  /** The type of the default options for the {@link AngleField | `AngleField`} class. */
   type DefaultOptions = SimpleMerge<
     NumberField.DefaultOptions,
     {
       required: true;
       nullable: false;
       initial: 0;
-      base: 0;
+      normalize: true;
       min: 0;
       max: 360;
       validationError: "is not a number between 0 and 360";
@@ -3104,13 +3536,13 @@ declare namespace AngleField {
    * A helper type for the given options type merged into the default options of the AngleField class.
    * @typeParam Options - the options that override the default options
    */
-  type MergedOptions<Options extends NumberFieldOptions> = SimpleMerge<DefaultOptions, Options>;
+  type MergedOptions<Options extends NumberField.Options> = SimpleMerge<DefaultOptions, Options>;
 
   /**
    * A shorthand for the assignment type of a AngleField class.
    * @typeParam Options - the options that override the default options
    */
-  type AssignmentType<Options extends NumberFieldOptions> = DataField.DerivedAssignmentType<
+  type AssignmentType<Options extends NumberField.Options> = DataField.DerivedAssignmentType<
     number,
     MergedOptions<Options>
   >;
@@ -3119,27 +3551,27 @@ declare namespace AngleField {
    * A shorthand for the initialized type of a AngleField class.
    * @typeParam Options - the options that override the default options
    */
-  type InitializedType<Options extends NumberFieldOptions> = DataField.DerivedInitializedType<
+  type InitializedType<Options extends NumberField.Options> = DataField.DerivedInitializedType<
     number,
     MergedOptions<Options>
   >;
 }
 
 /**
- * A special [NumberField]{@link NumberField} represents a number between 0 and 1.
+ * A special {@link NumberField | `NumberField`} represents a number between 0 and 1.
  * @typeParam Options         - the options of the AlphaField instance
  * @typeParam AssignmentType  - the type of the allowed assignment values of the AlphaField
  * @typeParam InitializedType - the type of the initialized values of the AlphaField
  * @typeParam PersistedType   - the type of the persisted values of the AlphaField
  * @remarks
  * Defaults:
- * AssignmentType: `number | null | undefined`
- * InitializedType: `number`
- * PersistedType: `number`
- * InitialValue: `1`
+ * - AssignmentType: `number | null | undefined`
+ * - InitializedType: `number`
+ * - PersistedType: `number`
+ * - InitialValue: `1`
  */
 declare class AlphaField<
-  Options extends NumberFieldOptions = AlphaField.DefaultOptions,
+  Options extends NumberField.Options = AlphaField.DefaultOptions,
   AssignmentType = AlphaField.AssignmentType<Options>,
   InitializedType = AlphaField.InitializedType<Options>,
   PersistedType extends number | null | undefined = AlphaField.InitializedType<Options>,
@@ -3151,7 +3583,7 @@ declare class AlphaField<
   override nullable: boolean;
 
   /** @defaultValue `1` */
-  override initial: DataFieldOptions.InitialType<InitializedType>;
+  override initial: DataField.Options.InitialType<InitializedType>;
 
   /** @defaultValue `0` */
   override min: number | undefined;
@@ -3162,11 +3594,11 @@ declare class AlphaField<
   /** @defaultValue `"is not a number between 0 and 1"` */
   override validationError: string;
 
-  protected static override get _defaults(): NumberFieldOptions;
+  protected static override get _defaults(): NumberField.Options;
 }
 
 declare namespace AlphaField {
-  /** The type of the default options for the {@link AlphaField} class. */
+  /** The type of the default options for the {@link AlphaField | `AlphaField`} class. */
   type DefaultOptions = SimpleMerge<
     NumberField.DefaultOptions,
     {
@@ -3183,13 +3615,13 @@ declare namespace AlphaField {
    * A helper type for the given options type merged into the default options of the AlphaField class.
    * @typeParam Options - the options that override the default options
    */
-  type MergedOptions<Options extends NumberFieldOptions> = SimpleMerge<DefaultOptions, Options>;
+  type MergedOptions<Options extends NumberField.Options> = SimpleMerge<DefaultOptions, Options>;
 
   /**
    * A shorthand for the assignment type of a AlphaField class.
    * @typeParam Options - the options that override the default options
    */
-  type AssignmentType<Options extends NumberFieldOptions> = DataField.DerivedAssignmentType<
+  type AssignmentType<Options extends NumberField.Options> = DataField.DerivedAssignmentType<
     number,
     MergedOptions<Options>
   >;
@@ -3198,18 +3630,18 @@ declare namespace AlphaField {
    * A shorthand for the initialized type of a AlphaField class.
    * @typeParam Options - the options that override the default options
    */
-  type InitializedType<Options extends NumberFieldOptions> = DataField.DerivedInitializedType<
+  type InitializedType<Options extends NumberField.Options> = DataField.DerivedInitializedType<
     number,
     MergedOptions<Options>
   >;
 }
 
 /**
- * A special [NumberField]{@link NumberField} represents a number between 0 (inclusive) and 1 (exclusive).
+ * A special {@link NumberField | `NumberField`} represents a number between 0 (inclusive) and 1 (exclusive).
  * Its values are normalized (modulo 1) to the range [0, 1) instead of being clamped.
  */
 declare class HueField<
-  const Options extends NumberFieldOptions = NumberField.DefaultOptions,
+  const Options extends NumberField.Options = NumberField.DefaultOptions,
   const AssignmentType = NumberField.AssignmentType<Options>,
   const InitializedType = NumberField.InitializedType<Options>,
   const PersistedType extends number | null | undefined = NumberField.InitializedType<Options>,
@@ -3220,7 +3652,7 @@ declare class HueField<
 }
 
 declare namespace HueField {
-  type Options = NumberFieldOptions;
+  type Options = NumberField.Options;
 
   type DefaultOptions = SimpleMerge<
     NumberField.DefaultOptions,
@@ -3236,17 +3668,17 @@ declare namespace HueField {
 }
 
 /**
- * A special [ObjectField]{@link ObjectField} which captures a mapping of User IDs to Document permission levels.
+ * A special {@link ObjectField | `ObjectField`} which captures a mapping of User IDs to Document permission levels.
  * @typeParam Options         - the options of the DocumentOwnershipField instance
  * @typeParam AssignmentType  - the type of the allowed assignment values of the DocumentOwnershipField
  * @typeParam InitializedType - the type of the initialized values of the DocumentOwnershipField
  * @typeParam PersistedType   - the type of the persisted values of the DocumentOwnershipField
  * @remarks
  * Defaults:
- * AssignmentType: `Record<string, DOCUMENT_OWNERSHIP_LEVELS> | null | undefined`
- * InitializedType: `Record<string, DOCUMENT_OWNERSHIP_LEVELS>`
- * PersistedType: `Record<string, DOCUMENT_OWNERSHIP_LEVELS>`
- * InitialValue: `{ default: DOCUMENT_OWNERSHIP_LEVELS.NONE }`
+ * - AssignmentType: `Record<string, DOCUMENT_OWNERSHIP_LEVELS> | null | undefined`
+ * - InitializedType: `Record<string, DOCUMENT_OWNERSHIP_LEVELS>`
+ * - PersistedType: `Record<string, DOCUMENT_OWNERSHIP_LEVELS>`
+ * - InitialValue: `{ default: DOCUMENT_OWNERSHIP_LEVELS.NONE }`
  */
 declare class DocumentOwnershipField<
   Options extends DocumentOwnershipField.Options = DocumentOwnershipField.DefaultOptions,
@@ -3258,24 +3690,25 @@ declare class DocumentOwnershipField<
     | undefined = DocumentOwnershipField.InitializedType<Options>,
 > extends ObjectField<Options, AssignmentType, InitializedType, PersistedType> {
   /** @defaultValue `{"default": DOCUMENT_OWNERSHIP_LEVELS.NONE}` */
-  override initial: DataFieldOptions.InitialType<InitializedType>;
+  override initial: DataField.Options.InitialType<InitializedType>;
 
   /** @defaultValue `"is not a mapping of user IDs and document permission levels"` */
   override validationError: string;
 
   protected static override get _defaults(): DocumentOwnershipField.Options;
 
+  /** @remarks `options` is unused in `DocumentOwnershipField` */
   protected override _validateType(
     value: InitializedType,
-    options?: DataField.ValidationOptions<DataField.Any>,
+    options?: DataField.ValidateOptions<this> | null,
   ): boolean | DataModelValidationFailure | void;
 }
 
 declare namespace DocumentOwnershipField {
   /** A shorthand for the options of a DocumentOwnershipField class. */
-  type Options = DataFieldOptions<Record<string, DOCUMENT_OWNERSHIP_LEVELS>>;
+  type Options = DataField.Options<Record<string, DOCUMENT_OWNERSHIP_LEVELS>>;
 
-  /** The type of the default options for the {@link DocumentOwnershipField} class. */
+  /** The type of the default options for the {@link DocumentOwnershipField | `DocumentOwnershipField`} class. */
   type DefaultOptions = SimpleMerge<
     ObjectField.DefaultOptions,
     {
@@ -3310,49 +3743,52 @@ declare namespace DocumentOwnershipField {
 }
 
 /**
- * A special [StringField]{@link StringField} which contains serialized JSON data.
+ * A special {@link StringField | `StringField`} which contains serialized JSON data.
  * @typeParam Options         - the options of the JSONField instance
  * @typeParam AssignmentType  - the type of the allowed assignment values of the JSONField
  * @typeParam InitializedType - the type of the initialized values of the JSONField
  * @typeParam PersistedType   - the type of the persisted values of the JSONField
  * @remarks
  * Defaults:
- * AssignmentType: `string | null | undefined`
- * InitializedType: `object | undefined`
- * PersistedType: `string | undefined`
- * InitialValue: `undefined`
+ * - AssignmentType: `string | null | undefined`
+ * - InitializedType: `object | undefined`
+ * - PersistedType: `string | undefined`
+ * - InitialValue: `undefined`
  */
 declare class JSONField<
   // TODO(LukeAbby): Due to the unconditional setting of `blank`, `trim`, and `choices` setting them is meaningless which basically means they're removed from the options.
-  Options extends StringFieldOptions = JSONField.DefaultOptions,
+  Options extends StringField.Options = JSONField.DefaultOptions,
   AssignmentType = JSONField.AssignmentType<Options>,
   InitializedType = JSONField.InitializedType<Options>,
   PersistedType extends string | null | undefined = JSONField.PersistedType<Options>,
 > extends StringField<Options, AssignmentType, InitializedType, PersistedType> {
-  constructor(options?: Options, context?: DataField.Context);
+  // options: not null (unchecked `in` operation in super), context: not null (destructured in super)
+  constructor(options?: Options, context?: DataField.ConstructionContext);
 
   /** @defaultValue `false` */
   override blank: boolean;
 
   /** @defaultValue `undefined` */
-  override initial: DataFieldOptions.InitialType<InitializedType>;
+  override initial: DataField.Options.InitialType<InitializedType>;
 
   /** @defaultValue `"is not a valid JSON string"` */
   override validationError: string;
 
-  protected static override get _defaults(): StringFieldOptions;
+  protected static override get _defaults(): StringField.Options;
 
   override clean(value: AssignmentType, options?: DataField.CleanOptions): InitializedType;
 
+  /** @remarks `options` is unused in `JSONField` */
   protected override _validateType(
     value: InitializedType,
-    options?: DataField.ValidationOptions<DataField.Any>,
+    options?: DataField.ValidateOptions<this> | null,
   ): boolean | DataModelValidationFailure | void;
 
+  // options: not null (parameter default only)
   override initialize(
     value: PersistedType,
     model: DataModel.Any,
-    options?: AnyObject,
+    options?: DataField.InitializeOptions,
   ): InitializedType | (() => InitializedType | null);
 
   override toObject(value: InitializedType): PersistedType;
@@ -3383,7 +3819,7 @@ declare class JSONField<
 }
 
 declare namespace JSONField {
-  /** The type of the default options for the {@link JSONField} class. */
+  /** The type of the default options for the {@link JSONField | `JSONField`} class. */
   type DefaultOptions = SimpleMerge<
     StringField.DefaultOptions,
     {
@@ -3397,13 +3833,13 @@ declare namespace JSONField {
    * A helper type for the given options type merged into the default options of the JSONField class.
    * @typeParam Options - the options that override the default options
    */
-  type MergedOptions<Options extends StringFieldOptions> = SimpleMerge<DefaultOptions, Options>;
+  type MergedOptions<Options extends StringField.Options> = SimpleMerge<DefaultOptions, Options>;
 
   /**
    * A shorthand for the assignment type of a JSONField class.
    * @typeParam Options - the options that override the default options
    */
-  type AssignmentType<Options extends StringFieldOptions> = DataField.DerivedAssignmentType<
+  type AssignmentType<Options extends StringField.Options> = DataField.DerivedAssignmentType<
     string,
     MergedOptions<Options>
   >;
@@ -3412,7 +3848,7 @@ declare namespace JSONField {
    * A shorthand for the initialized type of a JSONField class.
    * @typeParam Options - the options that override the default options
    */
-  type InitializedType<Options extends StringFieldOptions> = DataField.DerivedInitializedType<
+  type InitializedType<Options extends StringField.Options> = DataField.DerivedInitializedType<
     AnyObject,
     MergedOptions<Options>
   >;
@@ -3421,29 +3857,35 @@ declare namespace JSONField {
    * A shorthand for the persisted type of a JSONField class.
    * @typeParam Options - the options that override the default options
    */
-  type PersistedType<Options extends StringFieldOptions> = DataField.DerivedInitializedType<
+  type PersistedType<Options extends StringField.Options> = DataField.DerivedInitializedType<
     string,
     MergedOptions<Options>
   >;
 }
 
 /**
- * A special subclass of {@link DataField} which can contain any value of any type.
+ * A special subclass of {@link DataField | `DataField`} which can contain any value of any type.
  * Any input is accepted and is treated as valid.
  * It is not recommended to use this class except for very specific circumstances.
  */
 // TODO(LukeAbby): This field effectively removes all options because there's no point asking for an options when none of them do anything.
-declare class AnyField extends DataField<DataFieldOptions.Any, unknown, unknown, unknown> {
+declare class AnyField extends DataField<DataField.Options.Any, unknown, unknown, unknown> {
+  /** @remarks Simply returns `value` */
   override _cast(value: unknown): unknown;
 
+  /**
+   * @remarks `options` is unused in `AnyField`
+   *
+   * Always returns `true`
+   */
   protected override _validateType(
     value: unknown,
-    options?: DataField.ValidationOptions<DataField.Any>,
+    options?: DataField.ValidateOptions<this> | null,
   ): boolean | DataModelValidationFailure | void;
 }
 
 /**
- * A subclass of [StringField]{@link StringField} which contains a sanitized HTML string.
+ * A subclass of {@link StringField | `StringField`} which contains a sanitized HTML string.
  * This class does not override any StringField behaviors, but is used by the server-side to identify fields which
  * require sanitization of user input.
  * @typeParam Options         - the options of the HTMLField instance
@@ -3452,13 +3894,13 @@ declare class AnyField extends DataField<DataFieldOptions.Any, unknown, unknown,
  * @typeParam PersistedType   - the type of the persisted values of the HTMLField
  * @remarks
  * Defaults:
- * AssignmentType: `string | null | undefined`
- * InitializedType: `string`
- * PersistedType: `string`
- * InitialValue: `""`
+ * - AssignmentType: `string | null | undefined`
+ * - InitializedType: `string`
+ * - PersistedType: `string`
+ * - InitialValue: `""`
  */
 declare class HTMLField<
-  Options extends StringFieldOptions = HTMLField.DefaultOptions,
+  Options extends StringField.Options = HTMLField.DefaultOptions,
   AssignmentType = HTMLField.AssignmentType<Options>,
   InitializedType = HTMLField.InitializedType<Options>,
   PersistedType extends string | null | undefined = HTMLField.InitializedType<Options>,
@@ -3469,9 +3911,10 @@ declare class HTMLField<
   /** @defaultValue `true` */
   override blank: boolean;
 
-  protected static override get _defaults(): StringFieldOptions;
+  protected static override get _defaults(): StringField.Options;
 
   // These verbose overloads are because otherwise there would be a misleading errors about `choices` being required without mentioning `options` or vice versa.
+  /** @remarks Sets `groupConfig.stacked ??= true` before calling super */
   toFormGroup(
     groupConfig?: HTMLField.GroupConfig,
     inputConfig?: DataField.ToInputConfig<InitializedType> | DataField.ToInputConfigWithOptions<InitializedType>,
@@ -3497,7 +3940,7 @@ declare class HTMLField<
 }
 
 declare namespace HTMLField {
-  /** The type of the default options for the {@link HTMLField} class. */
+  /** The type of the default options for the {@link HTMLField | `HTMLField`} class. */
   type DefaultOptions = SimpleMerge<
     StringField.DefaultOptions,
     {
@@ -3510,13 +3953,13 @@ declare namespace HTMLField {
    * A helper type for the given options type merged into the default options of the HTMLField class.
    * @typeParam Options - the options that override the default options
    */
-  type MergedOptions<Options extends StringFieldOptions> = SimpleMerge<DefaultOptions, Options>;
+  type MergedOptions<Options extends StringField.Options> = SimpleMerge<DefaultOptions, Options>;
 
   /**
    * A shorthand for the assignment type of a HTMLField class.
    * @typeParam Options - the options that override the default options
    */
-  type AssignmentType<Options extends StringFieldOptions> = DataField.DerivedAssignmentType<
+  type AssignmentType<Options extends StringField.Options> = DataField.DerivedAssignmentType<
     string,
     MergedOptions<Options>
   >;
@@ -3525,7 +3968,7 @@ declare namespace HTMLField {
    * A shorthand for the initialized type of a HTMLField class.
    * @typeParam Options - the options that override the default options
    */
-  type InitializedType<Options extends StringFieldOptions> = DataField.DerivedInitializedType<
+  type InitializedType<Options extends StringField.Options> = DataField.DerivedInitializedType<
     string,
     MergedOptions<Options>
   >;
@@ -3535,20 +3978,20 @@ declare namespace HTMLField {
 }
 
 /**
- * A subclass of {@link NumberField} which is used for storing integer sort keys.
+ * A subclass of {@link NumberField | `NumberField`} which is used for storing integer sort keys.
  * @typeParam Options         - the options of the IntegerSortField instance
  * @typeParam AssignmentType  - the type of the allowed assignment values of the IntegerSortField
  * @typeParam InitializedType - the type of the initialized values of the IntegerSortField
  * @typeParam PersistedType   - the type of the persisted values of the IntegerSortField
  * @remarks
  * Defaults:
- * AssignmentType: `number | null | undefined`
- * InitializedType: `number`
- * PersistedType: `number`
- * InitialValue: `0`
+ * - AssignmentType: `number | null | undefined`
+ * - InitializedType: `number`
+ * - PersistedType: `number`
+ * - InitialValue: `0`
  */
 declare class IntegerSortField<
-  Options extends NumberFieldOptions = IntegerSortField.DefaultOptions,
+  Options extends NumberField.Options = IntegerSortField.DefaultOptions,
   AssignmentType = IntegerSortField.AssignmentType<Options>,
   InitializedType = IntegerSortField.InitializedType<Options>,
   PersistedType extends number | null | undefined = IntegerSortField.InitializedType<Options>,
@@ -3563,19 +4006,21 @@ declare class IntegerSortField<
   override integer: boolean;
 
   /** @defaultValue `0` */
-  override initial: DataFieldOptions.InitialType<InitializedType>;
+  override initial: DataField.Options.InitialType<InitializedType>;
 
   /** @defaultValue `"FOLDER.DocumentSort"` */
   override label: string;
 
   /** @defaultValue `"FOLDER.DocumentSortHint"` */
   override hint: string;
+
+  static override get _defaults(): NumberField.Options;
 }
 
 declare namespace IntegerSortField {
-  /** The type of the default options for the {@link IntegerSortField} class. */
+  /** The type of the default options for the {@link IntegerSortField | `IntegerSortField`} class. */
   type DefaultOptions = SimpleMerge<
-    DataField.DefaultOptions,
+    NumberField.DefaultOptions,
     {
       required: true;
       nullable: false;
@@ -3590,13 +4035,13 @@ declare namespace IntegerSortField {
    * A helper type for the given options type merged into the default options of the IntegerSortField class.
    * @typeParam Options - the options that override the default options
    */
-  type MergedOptions<Options extends NumberFieldOptions> = SimpleMerge<DefaultOptions, Options>;
+  type MergedOptions<Options extends NumberField.Options> = SimpleMerge<DefaultOptions, Options>;
 
   /**
    * A shorthand for the assignment type of a IntegerSortField class.
    * @typeParam Options - the options that override the default options
    */
-  type AssignmentType<Options extends NumberFieldOptions> = DataField.DerivedAssignmentType<
+  type AssignmentType<Options extends NumberField.Options> = DataField.DerivedAssignmentType<
     number,
     MergedOptions<Options>
   >;
@@ -3605,28 +4050,24 @@ declare namespace IntegerSortField {
    * A shorthand for the initialized type of a IntegerSortField class.
    * @typeParam Options - the options that override the default options
    */
-  type InitializedType<Options extends NumberFieldOptions> = DataField.DerivedInitializedType<
+  type InitializedType<Options extends NumberField.Options> = DataField.DerivedInitializedType<
     number,
     MergedOptions<Options>
   >;
 }
 
-declare global {
-  type DocumentStats = DocumentStatsField.Properties;
-}
-
 /**
- * A subclass of {@link SchemaField} which stores document metadata in the _stats field.
+ * A subclass of {@link SchemaField | `SchemaField`} which stores document metadata in the _stats field.
  * @typeParam Options         - the options of the DocumentStatsField instance
  * @typeParam AssignmentType  - the type of the allowed assignment values of the DocumentStatsField
  * @typeParam InitializedType - the type of the initialized values of the DocumentStatsField
  * @typeParam PersistedType   - the type of the persisted values of the DocumentStatsField
  * @remarks
  * Defaults:
- * AssignmentType: `Partial<DocumentStats> | null | undefined`
- * InitializedType: `DocumentStats`
- * PersistedType: `object`
- * InitialValue:
+ * - AssignmentType: `Partial<DocumentStats> | null | undefined`
+ * - InitializedType: `DocumentStats`
+ * - PersistedType: `object`
+ * - InitialValue:
  * ```typescript
  * {
  *   systemId: null,
@@ -3644,18 +4085,58 @@ declare class DocumentStatsField<
   InitializedType = DocumentStatsField.InitializedType<Options>,
   PersistedType extends AnyObject | null | undefined = DocumentStatsField.PersistedType<Options>,
 > extends SchemaField<DocumentStatsField.Schema, Options, AssignmentType, InitializedType, PersistedType> {
-  constructor(options?: Options);
+  /**
+   * @param options - Options which configure the behavior of the field
+   * @param context - Additional context which describes the field
+   */
+  // options: not null (unchecked `in` operation in super), context: not null (destructured in super)
+  constructor(options?: Options, context?: DataField.ConstructionContext);
+
+  /**
+   * All Document stats.
+   * @defaultValue
+   * ```js
+   * [
+   *   "coreVersion",
+   *   "systemId",
+   *   "systemVersion",
+   *   "createdTime",
+   *   "modifiedTime",
+   *   "lastModifiedBy",
+   *   "compendiumSource",
+   *   "duplicateSource"
+   * ]
+   * ```
+   */
+  static fields: string[];
+
+  /**
+   * These fields are managed by the server and are ignored if they appear in creation or update data.
+   * @defaultValue
+   * ```js
+   * [
+   *   "coreVersion",
+   *   "systemId",
+   *   "systemVersion",
+   *   "createdTime",
+   *   "modifiedTime",
+   *   "lastModifiedBy",
+   * ]
+   * ```
+   * @remarks The only fields not managed are `compendiumSource` and `duplicateSource`
+   */
+  static managedFields: string[];
 }
 
 declare namespace DocumentStatsField {
   /** A shorthand for the options of a DocumentStatsField class. */
-  type Options = DataFieldOptions<SchemaField.InnerAssignmentType<Schema>>;
+  type Options = DataField.Options<SchemaField.AssignmentData<Schema>>;
 
-  /** The type of the default options for the {@link DocumentStatsField} class. */
-  type DefaultOptions = SimpleMerge<SchemaField.DefaultOptions, { initial: SchemaField.InnerAssignmentType<Schema> }>;
+  /** The type of the default options for the {@link DocumentStatsField | `DocumentStatsField`} class. */
+  type DefaultOptions = SimpleMerge<SchemaField.DefaultOptions, { initial: SchemaField.AssignmentData<Schema> }>;
 
   /**
-   * A helper type for the given options type merged into the default options of the {@link DocumentStatsField} class.
+   * A helper type for the given options type merged into the default options of the {@link DocumentStatsField | `DocumentStatsField`} class.
    * @typeParam Opts - the options that override the default options
    */
   type MergedOptions<Opts extends Options> = SimpleMerge<DefaultOptions, Opts>;
@@ -3665,7 +4146,7 @@ declare namespace DocumentStatsField {
    * @typeParam Opts - the options that override the default options
    */
   type AssignmentType<Opts extends Options = DefaultOptions> = DataField.DerivedAssignmentType<
-    SchemaField.InnerAssignmentType<Schema>,
+    SchemaField.AssignmentData<Schema>,
     MergedOptions<Opts>
   >;
 
@@ -3674,7 +4155,7 @@ declare namespace DocumentStatsField {
    * @typeParam Opts - the options that override the default options
    */
   type InitializedType<Opts extends Options = DefaultOptions> = DataField.DerivedInitializedType<
-    SchemaField.InnerInitializedType<Schema>,
+    SchemaField.InitializedData<Schema>,
     MergedOptions<Opts>
   >;
 
@@ -3683,13 +4164,24 @@ declare namespace DocumentStatsField {
    * @typeParam Opts - the options that override the default options
    */
   type PersistedType<Opts extends Options = DefaultOptions> = DataField.DerivedInitializedType<
-    SchemaField.InnerPersistedType<Schema>,
+    SchemaField.SourceData<Schema>,
     MergedOptions<Opts>
   >;
 
-  type ConstructorData = SchemaField.InnerConstructorType<Schema>;
-  type Properties = SchemaField.InnerInitializedType<Schema>;
-  type Source = SchemaField.InnerPersistedType<Schema>;
+  interface CreateData extends SchemaField.CreateData<Schema> {}
+
+  interface InitializedData extends SchemaField.InitializedData<Schema> {}
+
+  interface SourceData extends SchemaField.SourceData<Schema> {}
+
+  /** @deprecated {@link DocumentStatsField.CreateData | `DocumentStatsField.CreateData`} */
+  type ConstructorData = CreateData;
+
+  /** @deprecated {@link DocumentStatsField.InitializedData | `DocumentStatsField.InitializedData`} */
+  type Properties = SchemaField.InitializedData<Schema>;
+
+  /** @deprecated {@link DocumentStatsField.SourceData | `DocumentStatsField.SourceData`} */
+  type Source = SchemaField.SourceData<Schema>;
 
   interface Schema extends DataSchema {
     /**
@@ -3734,7 +4226,7 @@ declare namespace DocumentStatsField {
 }
 
 /**
- * A subclass of [StringField]{@link StringField} that is used specifically for the Document "type" field.
+ * A subclass of {@link StringField | `StringField`} that is used specifically for the Document "type" field.
  */
 declare class DocumentTypeField<
   const ConcreteDocumentClass extends Document.AnyConstructor,
@@ -3755,19 +4247,26 @@ declare class DocumentTypeField<
    * @param documentClass - The base document class which belongs in this field
    * @param options - Options which configure the behavior of the field
    * @param context - Additional context which describes the field
+   * @remarks Enforces `choices` being `documentClass.TYPES`
    */
-  constructor(documentClass: ConcreteDocumentClass, options: DocumentTypeField.Options, context?: DataField.Context);
+  // options: not null (unchecked `in` operation in super), context: not null (destructured in super)
+  constructor(
+    documentClass: ConcreteDocumentClass,
+    options?: DocumentTypeField.Options,
+    context?: DataField.ConstructionContext,
+  );
 
   static override get _defaults(): DocumentTypeField.Options;
 
+  /** @remarks `options` is required as it has no default handling and its `fallback` property is accessed */
   protected override _validateType(
     value: InitializedType,
-    options?: DataField.ValidationOptions<DataField.Any>,
+    options: DataField.ValidateOptions<this>,
   ): boolean | DataModelValidationFailure | void;
 }
 
 declare namespace DocumentTypeField {
-  /** The type of the default options for the {@link DocumentTypeField} class. */
+  /** The type of the default options for the {@link DocumentTypeField | `DocumentTypeField`} class. */
   type DefaultOptions = SimpleMerge<
     StringField.DefaultOptions,
     {
@@ -3777,12 +4276,12 @@ declare namespace DocumentTypeField {
     }
   >;
 
-  interface Options extends StringFieldOptions {}
+  interface Options extends StringField.Options {}
 
   // TODO(LukeAbby): This class has effectively removed `choices` and `validationError` since they're unconditionally set in the constructor.
   type MergedOptions<
     ConcreteDocumentClass extends Document.AnyConstructor,
-    Options extends StringFieldOptions,
+    Options extends StringField.Options,
   > = SimpleMerge<
     SimpleMerge<DefaultOptions, Options>,
     {
@@ -3793,20 +4292,20 @@ declare namespace DocumentTypeField {
 
   type AssignmentType<
     ConcreteDocumentClass extends Document.AnyConstructor,
-    Options extends StringFieldOptions,
+    Options extends StringField.Options,
   > = StringField.AssignmentType<MergedOptions<ConcreteDocumentClass, Options>>;
   type InitializedType<
     ConcreteDocumentClass extends Document.AnyConstructor,
-    Options extends StringFieldOptions,
+    Options extends StringField.Options,
   > = StringField.InitializedType<MergedOptions<ConcreteDocumentClass, Options>>;
   type PersistedType<
     ConcreteDocumentClass extends Document.AnyConstructor,
-    Options extends StringFieldOptions,
+    Options extends StringField.Options,
   > = StringField.InitializedType<MergedOptions<ConcreteDocumentClass, Options>>;
 }
 
 /**
- * A subclass of [ObjectField]{@link ObjectField} which supports a type-specific data object.
+ * A subclass of {@link ObjectField | `ObjectField`} which supports a type-specific data object.
  * @typeParam DocumentType    - the type of the embedded Document
  * @typeParam Options         - the options of the TypeDataField instance
  * @typeParam AssignmentType  - the type of the allowed assignment values of the TypeDataField
@@ -3814,10 +4313,10 @@ declare namespace DocumentTypeField {
  * @typeParam PersistedType   - the type of the persisted values of the TypeDataField
  * @remarks
  * Defaults:
- * AssignmentType: `SchemaField.AssignmentType<DocumentType["schema"]["fields"]> | null | undefined`
- * InitializedType: `SchemaField.InitializedType<DocumentType["schema"]["fields"]>`
- * PersistedType: `SchemaField.PersistedType<DocumentType["schema"]["fields"]>`
- * InitialValue: `{}`
+ * - AssignmentType: `SchemaField.AssignmentType<DocumentType["schema"]["fields"]> | null | undefined`
+ * - InitializedType: `SchemaField.InitializedType<DocumentType["schema"]["fields"]>`
+ * - PersistedType: `SchemaField.PersistedType<DocumentType["schema"]["fields"]>`
+ * - InitialValue: `{}`
  */
 declare class TypeDataField<
   const SystemDocument extends Document.SystemConstructor,
@@ -3829,8 +4328,10 @@ declare class TypeDataField<
   /**
    * @param document - The base document class which belongs in this field
    * @param options  - Options which configure the behavior of the field
+   * @param context - Additional context which describes the field
    */
-  constructor(document: SystemDocument, options?: Options);
+  // options: not null (unchecked `in` operation in super), context: not null (destructured in super)
+  constructor(document: SystemDocument, options?: Options, context?: DataField.ConstructionContext);
 
   /** @defaultValue `true` */
   override required: boolean;
@@ -3863,22 +4364,34 @@ declare class TypeDataField<
    */
   getModelForType(type: string): DataModel.AnyConstructor | null;
 
-  override getInitialValue(data: { type?: string }): InitializedType;
+  /** @remarks If an object with a valid `type` isn't passed, returns `{}` */
+  override getInitialValue(data?: { type?: string }): InitializedType;
 
-  protected override _cleanType(value: InitializedType, options?: DataField.CleanOptions): InitializedType;
+  /**
+   * @remarks Returns:
+   * - If a valid TypeDataModel, the `value` run through its `.cleanData` with `options.source: value`, else
+   * - If `options.partial`, simply `value`, else
+   * - A `mergeObject` of `this.getInitialValue(options.source)` and `value`
+   *
+   * `options` is required as it lacks any default handling and has its properties accessed
+   */
+  protected override _cleanType(value: InitializedType, options: DataField.CleanOptions): InitializedType;
 
+  // options: not null (parameter default only)
   override initialize(
     value: PersistedType,
     model: DataModel.Any,
-    options?: AnyObject,
+    options?: DataField.InitializeOptions,
   ): InitializedType | (() => InitializedType | null);
 
+  // options: not null (parameter default only, property access)
   protected override _validateType(
     value: InitializedType,
-    options?: DataField.ValidationOptions<DataField.Any>,
+    options?: DataField.ValidateOptions<this>,
   ): boolean | DataModelValidationFailure | void;
 
-  protected override _validateModel(data: AnyObject, options?: AnyObject): void;
+  // options: not ull (parameter default only, property access)
+  protected override _validateModel(data: AnyObject, options?: DataField.ValidateModelOptions): void;
 
   override toObject(value: InitializedType): PersistedType;
 
@@ -3895,11 +4408,11 @@ declare namespace TypeDataField {
    * A shorthand for the options of a TypeDataField class.
    * @typeParam DocumentType - the type of the embedded Document
    */
-  type Options<DocumentType extends Document.SystemConstructor> = DataFieldOptions<
-    SchemaField.InnerAssignmentType<DataModel.SchemaOfClass<DocumentType>>
+  type Options<DocumentType extends Document.SystemConstructor> = DataField.Options<
+    SchemaField.AssignmentData<DataModel.SchemaOfClass<DocumentType>>
   >;
 
-  /** The type of the default options for the {@link TypeDataField} class. */
+  /** The type of the default options for the {@link TypeDataField | `TypeDataField`} class. */
   type DefaultOptions = SimpleMerge<
     ObjectField.DefaultOptions,
     {
@@ -3917,73 +4430,10 @@ declare namespace TypeDataField {
     Opts
   >;
 
-  /**
-   * Get the system DataModel configuration for a specific document type.
-   * @typeParam DocumentType - the type of the Document this system data is for
-   *
-   * @deprecated - This helper is from a time where {@link DataModelConfig | `DataModelConfig`}
-   * was still recommended to use instances. This will always return instances but
-   * its name is now misleading. For a replacement see {@link DataModelInstances | `DataModelInstances`}.
-   * If you want to get the class see {@link DataModelClasses | `DataModelClasses`}.
-   */
-  type Config<DocumentType extends Document.SystemConstructor> = DataModelInstances<DocumentType["metadata"]["name"]>;
-
-  type DataModelInstances<DocumentType extends Document.Type> = DocumentType extends keyof DataModelConfig
-    ? _ToInstances<DataModelConfig[DocumentType]>
-    : EmptyObject;
-
-  /**
-   * @internal
-   */
-  type _ToInstances<T extends AnyObject> = {
-    [K in keyof T]: T[K] extends AnyConstructor ? InstanceType<T[K]> : T[K];
-  };
-
-  type DataModelClasses<DocumentType extends Document.Type> = DocumentType extends keyof DataModelConfig
-    ? _ToClasses<DataModelConfig[DocumentType]>
+  type DataModelsFor<DocumentType extends Document.Type> = DocumentType extends keyof DataModelConfig
+    ? DataModelConfig[DocumentType]
     : EmptyObject;
 
-  /**
-   * @internal
-   */
-  type _ToClasses<T extends AnyObject> = {
-    [K in keyof T]: _ToClass<T[K]>;
-  };
-
-  /**
-   * @internal
-   * This method must go from an instance to a static side we know nothing about.
-   * This means its inherently lossy and full of assumptions.
-   * This is to support old configuration styles relatively gracefully.
-   */
-  type _ToClass<T> = T extends AnyConstructor
-    ? T
-    : T extends TypeDataModel<infer Schema, infer Parent, infer BaseData, infer DerivedData>
-      ? TypeDataModel.ConfigurationFailureClass &
-          (abstract new (...args: any[]) => T) &
-          typeof TypeDataModel<Schema, Parent, BaseData, DerivedData>
-      : T extends DataModel<infer Schema, infer Parent, infer ExtraConstructorOptions>
-        ? TypeDataModel.ConfigurationFailureClass &
-            (abstract new (...args: any[]) => T) &
-            typeof DataModel<Schema, Parent, ExtraConstructorOptions>
-        : TypeDataModel.ConfigurationFailureClass;
-
-  /**
-   * Get the configured core and system type names for a specific document type.
-   * @typeParam ConcreteDocument - the type of the Document this data is for
-   * @deprecated Use the Game.Model namespace instead of TypeDataField
-   */
-  type TypeNames<ConcreteDocument extends Document.SystemConstructor> = Game.Model.TypeNames<
-    ConcreteDocument["metadata"]["name"]
-  >;
-
-  /**
-   * Get the core type names for a specific document type.
-   * @typeParam DocumentType - the type of the Document this data is for
-   * @deprecated Use `DocumentType["metadata"]["coreTypes"][number]`
-   */
-  type CoreTypeNames<DocumentType extends Document.SystemConstructor> = DocumentType["metadata"]["coreTypes"][number];
-
   /**
    * A shorthand for the assignment type of a TypeDataField class.
    * @typeParam DocumentType - the type of the embedded Document
@@ -3991,8 +4441,8 @@ declare namespace TypeDataField {
    */
   type AssignmentType<
     SystemDocumentConstructor extends Document.SystemConstructor,
-    Opts extends Options<InstanceType<SystemDocumentConstructor>>,
-  > = DataField.DerivedAssignmentType<AnyObject, MergedOptions<InstanceType<SystemDocumentConstructor>, Opts>>;
+    Opts extends Options<SystemDocumentConstructor>,
+  > = DataField.DerivedAssignmentType<AnyObject, MergedOptions<SystemDocumentConstructor, Opts>>;
 
   /**
    * A shorthand for the initialized type of a TypeDataField class.
@@ -4001,23 +4451,16 @@ declare namespace TypeDataField {
    */
   type InitializedType<
     SystemDocumentConstructor extends Document.SystemConstructor,
-    Opts extends Options<InstanceType<SystemDocumentConstructor>>,
+    Opts extends Options<SystemDocumentConstructor>,
   > = DataField.DerivedInitializedType<
-    ValueOf<DataModelInstances<SystemDocumentConstructor["metadata"]["name"]>> | UnknownSystem,
-    MergedOptions<InstanceType<SystemDocumentConstructor>, Opts>
+    _Instances<DataModelsFor<SystemDocumentConstructor["metadata"]["name"]>> | Document.UnknownSystem,
+    MergedOptions<SystemDocumentConstructor, Opts>
   >;
 
-  /**
-   * With the existence of custom module subtypes a system can no longer rely on their configured types being the only ones.
-   * A module can provide its own custom type though it is always of the form `${moduleName}.${subType}` so the `.` is a pretty
-   * strong indicator.
-   *
-   * `UnknownSourceData` covers the case where it's configured without a data model.
-   * See {@link UnknownSystem | `UnknownSystem`} for other possibilities.
-   */
-  interface UnknownSourceData extends AnyObject {
-    type: `${string}.${string}`;
-  }
+  /** @internal */
+  type _Instances<T> = {
+    [K in keyof T]: T[K] extends (abstract new (...args: never) => infer U extends DataModel.Any) ? U : never;
+  }[keyof T];
 
   /**
    * With the existence of custom module subtypes a system can no longer rely on their configured types being the only ones.
@@ -4029,83 +4472,85 @@ declare namespace TypeDataField {
    */
   interface UnknownTypeDataModel extends TypeDataModel<any, any, any, any> {}
 
-  /**
-   * With the existence of custom module subtypes a system can no longer rely on their configured types being the only ones.
-   *
-   * `UnknownDataModel` covers the case where it's configured with a {@link DataModel | `DataModel`}.
-   * Using a {@link TypeDataModel | `TypeDataModel`} is recommended by Foundry but a {@link DataModel | `DataModel`} is
-   * always possible.
-   * See {@link UnknownSystem | `UnknownSystem`} for other possibilities.
-   */
-  interface UnknownDataModel extends DataModel<any, any, any> {}
-
-  /**
-   * With the existence of custom module subtypes a system can no longer rely on their configured types being the only ones.
-   */
-  type UnknownSystem = UnknownSourceData | UnknownTypeDataModel | UnknownDataModel;
-
   /**
    * A shorthand for the persisted type of a TypeDataField class.
    * @typeParam DocumentType - the type of the embedded Document
    * @typeParam Opts         - the options that override the default options
    */
   type PersistedType<
-    SystemDocumentConstructor extends Document.SystemConstructor,
-    Opts extends Options<InstanceType<SystemDocumentConstructor>>,
-  > = DataField.DerivedInitializedType<AnyObject, MergedOptions<InstanceType<SystemDocumentConstructor>, Opts>>;
+    ConcreteDocument extends Document.SystemConstructor,
+    Opts extends Options<ConcreteDocument>,
+  > = DataField.DerivedInitializedType<AnyObject, MergedOptions<ConcreteDocument, Opts>>;
 }
 
 /**
- * A subclass of [DataField]{@link DataField} which allows to typed schemas.
+ * A subclass of {@link DataField | `DataField`} which allows to typed schemas.
  */
 declare class TypedSchemaField<
   const Types extends TypedSchemaField.Types,
-  const Options extends TypedSchemaField.DefaultOptions = TypedSchemaField.DefaultOptions,
+  const Options extends TypedSchemaField.Options<Types> = TypedSchemaField.DefaultOptions,
   const AssignmentType = TypedSchemaField.AssignmentType<Types, Options>,
   const InitializedType = TypedSchemaField.InitializedType<Types, Options>,
-  const PersistedType extends unknown | null | undefined = TypedSchemaField.PersistedType<Types, Options>,
+  const PersistedType = TypedSchemaField.PersistedType<Types, Options>,
 > extends DataField<Options, AssignmentType, InitializedType, PersistedType> {
   /**
    * @param types   - The different types this field can represent.
    * @param options - Options which configure the behavior of the field
    * @param context - Additional context which describes the field
    */
-  constructor(types: Types, options: Options, context?: DataField.Context);
+  // options: not null (unchecked `in` operation in super), context: not null (destructured in super)
+  constructor(types: Types, options?: Options, context?: DataField.ConstructionContext);
 
-  static get _defaults(): DataFieldOptions.Any;
+  static get _defaults(): DataField.Options.Any;
 
   /**
    * The types of this field.
    */
   types: TypedSchemaField.ToConfiguredTypes<Types>;
 
-  protected override _getField(path: string[]): unknown;
+  protected override _getField(path: string[]): DataField.Any;
 
+  /**
+   * @remarks Returns `value` if `value?.type` doesn't map to a valid type, otherwise it runs `value`
+   * through the matching type's `#clean`
+   */
+  // options: not null (parameter default only, property access in super)
   protected override _cleanType(value: InitializedType, options?: DataField.CleanOptions): InitializedType;
 
   protected override _cast(value: AssignmentType): InitializedType;
 
   protected override _validateSpecial(value: AssignmentType): boolean | void;
 
+  /** @remarks Forwards to the SchemaField designated by `value.type`'s `#validate` */
+  // options: not null (parameter default only, property access in super)
   protected override _validateType(
     value: InitializedType,
-    options?: DataField.ValidationOptions<DataField.Any>,
+    options?: DataField.ValidateOptions<this>,
   ): boolean | DataModelValidationFailure | void;
 
+  // options: not null (parameter default only)
   override initialize(
     value: PersistedType,
     model: DataModel.Any,
-    options?: AnyObject, // TODO: Type further.
-  ): (() => InitializedType | null) | InitializedType;
+    options?: DataField.InitializeOptions,
+  ): InitializedType | (() => InitializedType | null);
 
   override toObject(value: InitializedType): PersistedType;
 
   // TODO(LukeAbby): Type `TypedSchemaField#apply`.
+  // options: not null (could be forwarded somewhere destructured, parameter default only)
+  override apply<Options, Return>(
+    fn: keyof this | ((this: this, value: AnyObject, options: Options) => Return),
+    value?: AnyObject,
+    options?: Options,
+  ): Return;
 
   migrateSource(sourceData: AnyObject, fieldData: unknown): unknown;
 }
 
 declare namespace TypedSchemaField {
+  interface Options<T extends Types> extends DataField.Options<_AssignmentType<ToConfiguredTypes<T>>> {}
+
   type DefaultOptions = SimpleMerge<
     DataField.DefaultOptions,
     {
@@ -4113,31 +4558,36 @@ declare namespace TypedSchemaField {
     }
   >;
 
-  type ValidField = DataField<
-    {
-      required: true;
-      nullable: false;
-    },
-    any,
-    any,
-    any
-  >;
-
+  /**
+   * A `ValidDataSchema` must pass the checks in `#configureTypes`. Namely:
+   * - No `name` property.
+   * - No `parent`.
+   *
+   * Additionally the `type` property (if any):
+   * - Must be a `StringField`.
+   * - Must be `required`
+   * - Must not be `nullable`.
+   * - Must not be `blank`.
+   * - Must allow the corresponding type as a valid value.
+   */
   // eslint-disable-next-line @typescript-eslint/consistent-type-definitions
   type ValidDataSchema = {
-    readonly [field: string]: ValidField;
+    readonly [field: string]: DataField.Any;
   };
 
   // eslint-disable-next-line @typescript-eslint/consistent-type-definitions
   type Types = {
     [type: string]:
       | ValidDataSchema
-      | SchemaField<ValidDataSchema, any, any, any, any>
-      | typeof DataModel<ValidDataSchema, any>;
+      | SchemaField<DataSchema, { required: true; nullable: false }, any, any, any>
+      | typeof DataModel<DataSchema, null>;
   };
 
   type ToConfiguredTypes<Types extends TypedSchemaField.Types> = {
-    [K in keyof Types]: Types[K] extends DataModel.AnyConstructor ? EmbeddedDataField<Types[K]> : never;
+    [K in keyof Types]:
+      | (Types[K] extends ValidDataSchema ? SchemaField<Types[K]> : never)
+      | (Types[K] extends SchemaField.Any ? Types[K] : never)
+      | (Types[K] extends DataModel.AnyConstructor ? EmbeddedDataField<Types[K]> : never);
   };
 
   // eslint-disable-next-line @typescript-eslint/consistent-type-definitions
@@ -4149,44 +4599,45 @@ declare namespace TypedSchemaField {
    * @internal
    */
   type _AssignmentType<Types extends ConfiguredTypes> = {
-    [K in keyof Types]: DataField.AssignmentTypeFor<Types[K]>;
+    [K in keyof Types]: DataField.AssignmentTypeFor<Types[K]> & { type: K };
   }[keyof Types];
 
   type AssignmentType<
     Types extends TypedSchemaField.Types,
-    Options extends TypedSchemaField.DefaultOptions,
+    Options extends TypedSchemaField.Options<Types>,
   > = DataField.DerivedAssignmentType<_AssignmentType<ToConfiguredTypes<Types>>, Options>;
 
   /**
    * @internal
    */
   type _InitializedType<Types extends ConfiguredTypes> = {
-    [K in keyof Types]: DataField.InitializedTypeFor<Types[K]>;
+    [K in keyof Types]: DataField.InitializedTypeFor<Types[K]> & { type: K };
   }[keyof Types];
 
   type InitializedType<
     Types extends TypedSchemaField.Types,
-    Options extends TypedSchemaField.DefaultOptions,
+    Options extends TypedSchemaField.Options<Types>,
   > = DataField.DerivedInitializedType<_InitializedType<ToConfiguredTypes<Types>>, Options>;
 
   /**
    * @internal
    */
   type _PersistedType<Types extends ConfiguredTypes> = {
-    [K in keyof Types]: DataField.PersistedTypeFor<Types[K]>;
+    [K in keyof Types]: DataField.PersistedTypeFor<Types[K]> & { type: K };
   }[keyof Types];
 
   type PersistedType<
     Types extends TypedSchemaField.Types,
-    _Options extends TypedSchemaField.DefaultOptions,
-  > = DataField.DerivedInitializedType<_PersistedType<ToConfiguredTypes<Types>>, _Options>;
+    Options extends TypedSchemaField.Options<Types>,
+  > = DataField.DerivedInitializedType<_PersistedType<ToConfiguredTypes<Types>>, Options>;
 }
 
 /**
- * @deprecated since v11; ModelValidationError is deprecated. Please use DataModelValidationError instead.
+ * @deprecated since v11 until v13; ModelValidationError is deprecated. Please use DataModelValidationError instead.
  * @typeParam Errors - the type of the errors contained in this error
  */
 declare class ModelValidationError<
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   Errors extends ModelValidationError.Errors = ModelValidationError.Errors,
 > extends Error {
   /**
@@ -4202,12 +4653,13 @@ declare class ModelValidationError<
    * @param errors - The raw error structure
    * @returns A formatted error message
    */
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   static formatErrors(errors: ModelValidationError.Errors): string;
 }
 
 declare namespace ModelValidationError {
   /**
-   * @deprecated since v11; ModelValidationError is deprecated. Please use DataModelValidationError instead.
+   * @deprecated since v11 until v13; ModelValidationError is deprecated. Please use DataModelValidationError instead.
    */
   type Errors = Record<number | string | symbol, Error> | Error[] | string;
 }
@@ -4228,7 +4680,7 @@ declare class _InternalJavaScriptField<
 }
 
 /**
- * A subclass of {@link StringField} which contains JavaScript code.
+ * A subclass of {@link StringField | `StringField`} which contains JavaScript code.
  */
 declare class JavaScriptField<
   const Options extends JavaScriptField.Options = JavaScriptField.DefaultOptions,
@@ -4236,15 +4688,23 @@ declare class JavaScriptField<
   const InitializedType = StringField.InitializedType<Options>,
   const PersistedType extends string | null | undefined = StringField.InitializedType<Options>,
 > extends _InternalJavaScriptField<Options, AssignmentType, InitializedType, PersistedType> {
-  constructor(options?: Options, context?: DataField.Context);
+  /**
+   * @param options - Options which configure the behavior of the field
+   * @param context - Additional context which describes the field
+   * @remarks Enforces `choices = undefined`
+   */
+  // options: not null (unchecked `in` operation in super), context: not null (destructured in super)
+  constructor(options?: Options, context?: DataField.ConstructionContext);
 
   static get _defaults(): JavaScriptField.Options;
 
+  /** @remarks `options` is only passed to super, where it is unused in `StringField` */
   protected override _validateType(
     value: InitializedType,
-    options?: DataField.ValidationOptions<DataField.Any>,
+    options?: DataField.ValidateOptions<this> | null,
   ): boolean | DataModelValidationFailure | void;
 
+  /** @remarks Sets `groupConfig.stacked ??= true` then forwards to super */
   override toFormGroup(
     groupConfig?: JavaScriptField.GroupConfig,
     inputConfig?: JavaScriptField.ToInputConfig<InitializedType>,
@@ -4255,7 +4715,7 @@ declare class JavaScriptField<
 
 declare namespace JavaScriptField {
   // TODO(LukeAbby): `choices` is effectively deleted due to being unconditionally set to `undefined` in the constructor.
-  type Options = StringFieldOptions & {
+  type Options = StringField.Options & {
     /**
      * Does the field allow async code?
      * @defaultValue `false`
@@ -4264,7 +4724,7 @@ declare namespace JavaScriptField {
   };
 
   type DefaultOptions = SimpleMerge<
-    StringFieldOptions,
+    StringField.Options,
     {
       async: false;
     }