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

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 "fvtt-types/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.
@@ -132,10 +42,10 @@ declare global {
  * 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;
@@ -145,6 +55,15 @@ declare abstract class DataField<
    */
   constructor(options?: Options, context?: DataField.Context);
 
+  /** @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 +89,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
@@ -234,7 +153,7 @@ 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.
@@ -301,7 +220,7 @@ declare abstract class DataField<
   validate(
     value: AssignmentType,
     options?: DataField.ValidationOptions<DataField.Any>,
-  ): DataModelValidationFailure | undefined;
+  ): DataModelValidationFailure | void;
 
   /**
    * Special validation rules which supersede regular field validation.
@@ -403,7 +322,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.
@@ -426,7 +345,7 @@ declare abstract class DataField<
     value: InitializedType,
     delta: InitializedType,
     model: DataModel.Any,
-    change: EffectChangeData,
+    change: ActiveEffect.EffectChangeData,
   ): InitializedType | undefined;
 
   /**
@@ -441,7 +360,7 @@ declare abstract class DataField<
     value: InitializedType,
     delta: InitializedType,
     model: DataModel.Any,
-    change: EffectChangeData,
+    change: ActiveEffect.EffectChangeData,
   ): InitializedType | undefined;
 
   /**
@@ -456,7 +375,7 @@ declare abstract class DataField<
     value: InitializedType,
     delta: InitializedType,
     model: DataModel.Any,
-    change: EffectChangeData,
+    change: ActiveEffect.EffectChangeData,
   ): InitializedType | undefined;
 
   /**
@@ -471,7 +390,7 @@ declare abstract class DataField<
     value: InitializedType,
     delta: InitializedType,
     model: DataModel.Any,
-    change: EffectChangeData,
+    change: ActiveEffect.EffectChangeData,
   ): InitializedType | undefined;
 
   /**
@@ -486,7 +405,7 @@ declare abstract class DataField<
     value: InitializedType,
     delta: InitializedType,
     model: DataModel.Any,
-    change: EffectChangeData,
+    change: ActiveEffect.EffectChangeData,
   ): InitializedType | undefined;
 
   /**
@@ -501,15 +420,14 @@ declare abstract class DataField<
     value: InitializedType,
     delta: InitializedType,
     model: DataModel.Any,
-    change: EffectChangeData,
+    change: ActiveEffect.EffectChangeData,
   ): InitializedType;
 }
 
 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 +441,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 +453,108 @@ 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);
+  }
+
+  interface DataValidationOptions {
+    /** 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;
+  }
+
   /**
    * 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 +584,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,15 +593,15 @@ 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. */
+  /** An interface for the options of the {@link DataField | `DataField`} clean functions. */
   interface CleanOptions {
     /** Whether to perform partial cleaning? */
     partial?: boolean;
@@ -615,22 +623,36 @@ 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: ValidationOptions<CurrentField>,
+        ): value is BaseAssignmentType;
+      }["validate"]
+    | {
+        validate(
+          this: CurrentField,
+          value: unknown,
+          options: ValidationOptions<CurrentField>,
+        ): asserts value is BaseAssignmentType;
+      }["validate"]
+    | {
+        validate(
+          this: CurrentField,
+          value: unknown,
+          options: ValidationOptions<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 {
+  interface ValidationOptions<CurrentField extends DataField.Any> extends DataValidationOptions {
     source?: AnyObject;
-    validate?: Validator<DataField.AssignmentTypeFor<DataField>>;
+    validate?: Validator<CurrentField, DataField.AssignmentTypeFor<CurrentField>>;
   }
 
   interface Context {
@@ -662,11 +684,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
@@ -681,9 +703,9 @@ declare abstract class AnyDataField extends DataField<any, any, any, any> {
 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>
   >,
@@ -702,7 +724,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>;
 
@@ -785,7 +807,7 @@ declare class SchemaField<
 
   override apply<Options, Return>(
     fn: keyof this | ((this: this, value: undefined | null, options: Options) => Return),
-    value?: undefined | null,
+    value?: null,
     options?: Options,
   ): Return;
   override apply<Value, Options, Return>(
@@ -803,7 +825,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 +835,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;
-  }>;
-
-  /**
-   * Get the inner initialized type for the given DataSchema.
+  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;
+    }>
+  >;
+
+  /**
+   * 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;
-  }>;
-
-  /** The type of the default options for the {@link SchemaField} class. */
+  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 | `SchemaField`} class. */
   type DefaultOptions = SimpleMerge<
     DataField.DefaultOptions,
     {
@@ -887,40 +942,97 @@ 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
@@ -947,7 +1059,7 @@ 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;
 
@@ -963,9 +1075,9 @@ declare class BooleanField<
 
 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,50 +1106,8 @@ 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
@@ -1050,7 +1120,7 @@ declare global {
  * 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>,
@@ -1061,7 +1131,7 @@ declare class NumberField<
   constructor(options?: Options, context?: DataField.Context);
 
   /** @defaultValue `null` */
-  override initial: DataFieldOptions.InitialType<InitializedType>;
+  override initial: DataField.Options.InitialType<InitializedType>;
 
   /** @defaultValue `true` */
   override nullable: boolean;
@@ -1104,7 +1174,7 @@ 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;
 
@@ -1155,7 +1225,7 @@ declare class NumberField<
 }
 
 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 +1240,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 +1296,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 +1305,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>
   >;
@@ -1231,37 +1341,8 @@ declare namespace NumberField {
     | 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;
-  }
-}
-
 /**
- * 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
@@ -1274,7 +1355,7 @@ declare global {
  * 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>,
@@ -1285,7 +1366,7 @@ declare class StringField<
   constructor(options?: Options, context?: DataField.Context);
 
   /** @defaultValue `undefined` */
-  override initial: DataFieldOptions.InitialType<InitializedType>;
+  override initial: DataField.Options.InitialType<InitializedType>;
 
   /**
    * Is the string allowed to be blank (empty)?
@@ -1313,7 +1394,7 @@ declare class StringField<
   /** @defaultValue `false` */
   textSearch: boolean;
 
-  protected static override get _defaults(): StringFieldOptions;
+  protected static override get _defaults(): StringField.Options<unknown>;
 
   override clean(value: AssignmentType, options?: DataField.CleanOptions): InitializedType;
 
@@ -1364,7 +1445,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 +1457,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 +1515,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 +1541,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>
@@ -1470,7 +1583,7 @@ 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
@@ -1483,7 +1596,7 @@ declare namespace StringField {
  * 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,9 +1608,9 @@ 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>;
 
   protected override _cast(value: AssignmentType): InitializedType;
 
@@ -1516,7 +1629,7 @@ declare class ObjectField<
 }
 
 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 +1642,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 +1657,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 +1673,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
@@ -1615,7 +1737,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
@@ -1655,7 +1777,7 @@ declare class ArrayField<
    * @returns An array of element-specific errors
    */
   protected _validateElements(
-    value: any[],
+    value: AnyArray,
     options?: DataField.ValidationOptions<DataField.Any>,
   ): DataModelValidationFailure | void;
 
@@ -1666,7 +1788,7 @@ declare class ArrayField<
    * @returns A validation failure if the element failed validation
    */
   protected _validateElement(
-    value: any,
+    value: unknown,
     options: DataField.ValidationOptions<DataField.Any>,
   ): DataModelValidationFailure | void;
 
@@ -1700,12 +1822,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 +1837,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 +1864,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 +1917,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 +1928,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
@@ -1873,24 +1995,24 @@ declare class SetField<
 
 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 +2052,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 +2071,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
@@ -2005,11 +2127,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 +2153,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 +2166,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 +2177,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
@@ -2175,16 +2297,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 +2325,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 +2343,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 +2382,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 +2393,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
@@ -2333,10 +2457,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 +2479,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 +2496,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 +2535,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 +2546,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
@@ -2469,15 +2594,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 +2631,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 +2644,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 +2657,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
@@ -2550,7 +2677,7 @@ declare namespace EmbeddedDocumentField {
  * 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 +2692,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,7 +2700,7 @@ 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;
 
@@ -2584,7 +2711,11 @@ declare class DocumentIdField<
 }
 
 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 +2732,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 +2747,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<
@@ -2681,14 +2812,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 +2852,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
@@ -2778,13 +2908,13 @@ declare class ForeignDocumentField<
 
 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 +2937,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,7 +2959,7 @@ 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
@@ -2842,7 +2972,7 @@ declare namespace ForeignDocumentField {
  * 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 +2981,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,7 +2989,7 @@ 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;
 
@@ -2870,7 +3000,7 @@ declare class ColorField<
 }
 
 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 +3015,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 +3030,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,39 +3039,14 @@ 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
@@ -2954,7 +3059,7 @@ declare global {
  * 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>,
@@ -2989,9 +3094,9 @@ 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;
 
@@ -3002,7 +3107,7 @@ declare class FilePathField<
 }
 
 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 +3120,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,14 +3159,14 @@ 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
@@ -3054,7 +3179,7 @@ declare namespace FilePathField {
  * 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>,
@@ -3066,7 +3191,7 @@ declare class AngleField<
   override nullable: boolean;
 
   /** @defaultValue `0` */
-  override initial: DataFieldOptions.InitialType<InitializedType>;
+  override initial: DataField.Options.InitialType<InitializedType>;
 
   /** @defaultValue `0` */
   base: number;
@@ -3080,13 +3205,13 @@ 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;
 }
 
 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,
     {
@@ -3104,13 +3229,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,14 +3244,14 @@ 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
@@ -3139,7 +3264,7 @@ declare namespace AngleField {
  * 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 +3276,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 +3287,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 +3308,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 +3323,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 +3345,7 @@ declare class HueField<
 }
 
 declare namespace HueField {
-  type Options = NumberFieldOptions;
+  type Options = NumberField.Options;
 
   type DefaultOptions = SimpleMerge<
     NumberField.DefaultOptions,
@@ -3236,7 +3361,7 @@ 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
@@ -3258,7 +3383,7 @@ 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;
@@ -3273,9 +3398,9 @@ declare class DocumentOwnershipField<
 
 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,7 +3435,7 @@ 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
@@ -3324,7 +3449,7 @@ declare namespace DocumentOwnershipField {
  */
 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>,
@@ -3335,12 +3460,12 @@ declare class JSONField<
   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;
 
@@ -3383,7 +3508,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 +3522,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 +3537,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,19 +3546,19 @@ 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> {
   override _cast(value: unknown): unknown;
 
   protected override _validateType(
@@ -3443,7 +3568,7 @@ declare class AnyField extends DataField<DataFieldOptions.Any, unknown, unknown,
 }
 
 /**
- * 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
@@ -3458,7 +3583,7 @@ declare class AnyField extends DataField<DataFieldOptions.Any, unknown, unknown,
  * 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,7 +3594,7 @@ 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.
   toFormGroup(
@@ -3497,7 +3622,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 +3635,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 +3650,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,7 +3660,7 @@ 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
@@ -3548,7 +3673,7 @@ declare namespace HTMLField {
  * 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,7 +3688,7 @@ 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;
@@ -3573,7 +3698,7 @@ declare class IntegerSortField<
 }
 
 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,
     {
@@ -3590,13 +3715,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,18 +3730,14 @@ 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
@@ -3649,13 +3770,13 @@ declare class DocumentStatsField<
 
 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 +3786,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 +3795,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 +3804,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 +3866,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,
@@ -3756,7 +3888,7 @@ declare class DocumentTypeField<
    * @param options - Options which configure the behavior of the field
    * @param context - Additional context which describes the field
    */
-  constructor(documentClass: ConcreteDocumentClass, options: DocumentTypeField.Options, context?: DataField.Context);
+  constructor(documentClass: ConcreteDocumentClass, options?: DocumentTypeField.Options, context?: DataField.Context);
 
   static override get _defaults(): DocumentTypeField.Options;
 
@@ -3767,7 +3899,7 @@ declare class DocumentTypeField<
 }
 
 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 +3909,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 +3925,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
@@ -3895,11 +4027,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 +4049,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]>
+  type DataModelsFor<DocumentType extends Document.Type> = DocumentType extends keyof DataModelConfig
+    ? 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]>
-    : 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 +4060,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 +4070,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,50 +4091,35 @@ 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);
+  constructor(types: Types, options?: Options, context?: DataField.Context);
 
-  static get _defaults(): DataFieldOptions.Any;
+  static get _defaults(): DataField.Options.Any;
 
   /**
    * The types of this field.
@@ -4106,6 +4153,8 @@ declare class TypedSchemaField<
 }
 
 declare namespace TypedSchemaField {
+  interface Options<T extends Types> extends DataField.Options<_AssignmentType<ToConfiguredTypes<T>>> {}
+
   type DefaultOptions = SimpleMerge<
     DataField.DefaultOptions,
     {
@@ -4113,31 +4162,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,37 +4203,37 @@ 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>;
 }
 
 /**
@@ -4187,6 +4241,7 @@ declare namespace TypedSchemaField {
  * @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,6 +4257,7 @@ 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;
 }
 
@@ -4228,7 +4284,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,
@@ -4255,7 +4311,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 +4320,7 @@ declare namespace JavaScriptField {
   };
 
   type DefaultOptions = SimpleMerge<
-    StringFieldOptions,
+    StringField.Options,
     {
       async: false;
     }