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

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

@@ -1,15 +1,16 @@
 import type {
   RemoveIndexSignatures,
   SimpleMerge,
-  ValueOf,
   AnyObject,
   EmptyObject,
   NullishProps,
   InexactPartial,
-} from "../../../types/utils.d.mts";
+  ToMethod,
+  FixedInstanceType,
+} from "../../../utils/index.d.mts";
 import type { DataModel } from "../abstract/data.mts";
 import type Document from "../abstract/document.mts";
-import type { EmbeddedCollection, EmbeddedCollectionDelta } from "../abstract/module.d.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";
@@ -23,94 +24,7 @@ import type {
   TextAreaInputConfig,
 } from "../../client-esm/applications/forms/fields.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 | 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. */
-    type Any = DataFieldOptions<any>;
-
-    /**
-     * 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.
@@ -120,17 +34,20 @@ declare global {
  * @typeParam PersistedType   - the type of the persisted values of the DataField
  * @remarks
  * Defaults:
- * AssignmentType: `any | null | undefined`
+ * AssignmentType: `unknown | null | undefined`
  * InitializedType: `unknown | undefined`
  * PersistedType: `unknown | undefined`
  * InitialValue: `undefined`
  */
 declare abstract class DataField<
-  const Options extends DataFieldOptions.Any = DataField.DefaultOptions,
+  const Options extends DataField.Options.Any = DataField.DefaultOptions,
   const AssignmentType = DataField.AssignmentType<Options>,
   const InitializedType = DataField.InitializedType<Options>,
-  const PersistedType extends unknown | null | undefined = InitializedType,
+  const PersistedType = InitializedType,
 > {
+  // Prevent from being bivariant.
+  #assignmentType: AssignmentType;
+
   /**
    * @param options - Options which configure the behavior of the field
    */
@@ -161,7 +78,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
@@ -225,7 +142,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.
@@ -292,7 +209,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.
@@ -394,7 +311,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.
@@ -417,7 +334,7 @@ declare abstract class DataField<
     value: InitializedType,
     delta: InitializedType,
     model: DataModel.Any,
-    change: EffectChangeData,
+    change: ActiveEffect.EffectChangeData,
   ): InitializedType | undefined;
 
   /**
@@ -432,7 +349,7 @@ declare abstract class DataField<
     value: InitializedType,
     delta: InitializedType,
     model: DataModel.Any,
-    change: EffectChangeData,
+    change: ActiveEffect.EffectChangeData,
   ): InitializedType | undefined;
 
   /**
@@ -447,7 +364,7 @@ declare abstract class DataField<
     value: InitializedType,
     delta: InitializedType,
     model: DataModel.Any,
-    change: EffectChangeData,
+    change: ActiveEffect.EffectChangeData,
   ): InitializedType | undefined;
 
   /**
@@ -462,7 +379,7 @@ declare abstract class DataField<
     value: InitializedType,
     delta: InitializedType,
     model: DataModel.Any,
-    change: EffectChangeData,
+    change: ActiveEffect.EffectChangeData,
   ): InitializedType | undefined;
 
   /**
@@ -477,7 +394,7 @@ declare abstract class DataField<
     value: InitializedType,
     delta: InitializedType,
     model: DataModel.Any,
-    change: EffectChangeData,
+    change: ActiveEffect.EffectChangeData,
   ): InitializedType | undefined;
 
   /**
@@ -492,13 +409,13 @@ 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<any, any, any, any>;
+  type Any = DataField<DataField.Options.Any, unknown, unknown, unknown>;
 
   type AnyConstructor = typeof AnyDataField;
 
@@ -526,18 +443,106 @@ 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<
+          DataField.Options.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 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 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 = DataField.Options<any> & object;
+
+    /**
+     * A helper type for the {@link 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} 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
@@ -567,7 +572,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);
@@ -576,13 +581,13 @@ declare namespace DataField {
    * A shorthand for the assignment type of a DataField class.
    * @typeParam Options - the options overriding the defaults
    */
-  type AssignmentType<Options extends DataFieldOptions.Any> = DerivedAssignmentType<any, MergedOptions<Options>>;
+  type AssignmentType<Options extends DataField.Options.Any> = DerivedAssignmentType<any, MergedOptions<Options>>;
 
   /**
    * A shorthand for the initialized type of a DataField class.
    * @typeParam Options - the options overriding the defaults
    */
-  type InitializedType<Options extends DataFieldOptions.Any> = DerivedInitializedType<any, MergedOptions<Options>>;
+  type InitializedType<Options extends DataField.Options.Any> = DerivedInitializedType<any, MergedOptions<Options>>;
 
   /** An interface for the options of the {@link DataField} clean functions. */
   interface CleanOptions {
@@ -606,8 +611,14 @@ declare namespace DataField {
    *
    * An Error may be thrown which provides a custom error message explaining the reason the value is invalid.
    */
-  // TODO(LukeAbby): `value: never` is a stopgap because of emergent errors. Pass back in `BaseAssignmentType` instead of `value: never` which is too lenient.
-  type Validator = (this: DataField, value: never, options: ValidationOptions<DataField>) => boolean | void;
+  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
+  >;
 
   /**
    * An interface for the options of the {@link DataField} validation functions.
@@ -615,7 +626,7 @@ declare namespace DataField {
    */
   interface ValidationOptions<DataField extends DataField.Any> extends DataValidationOptions {
     source?: AnyObject;
-    validate?: Validator;
+    validate?: Validator<DataField.AssignmentTypeFor<DataField>>;
   }
 
   interface Context {
@@ -646,7 +657,9 @@ declare namespace DataField {
   interface GroupConfig extends NullishProps<FormGroupConfig, "label" | "hint" | "input"> {}
 }
 
-declare abstract class AnyDataField extends DataField<any, any, any, any> {}
+declare abstract class AnyDataField extends DataField<any, any, any, any> {
+  constructor(arg0: never, ...args: never[]);
+}
 
 /**
  * A special class of {@link DataField} which defines a data schema.
@@ -685,7 +698,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>;
 
@@ -766,6 +779,11 @@ declare class SchemaField<
 
   override toObject(value: InitializedType): PersistedType;
 
+  override apply<Options, Return>(
+    fn: keyof this | ((this: this, value: undefined | null, options: Options) => Return),
+    value?: null,
+    options?: Options,
+  ): Return;
   override apply<Value, Options, Return>(
     fn: keyof this | ((this: this, value: Value, options: Options) => Return),
     value: Value,
@@ -791,7 +809,7 @@ 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<InnerAssignmentType<Fields> | __SchemaFieldInitial>;
 
   /** Any SchemaField. */
   type Any = SchemaField<any, any, any, any, any>;
@@ -807,29 +825,33 @@ declare namespace SchemaField {
    * @typeParam Fields - the DataSchema fields of the SchemaField
    */
   type InnerAssignmentType<Fields extends DataSchema> = RemoveIndexSignatures<{
-    [Key in keyof Fields]?: Fields[Key] extends DataField<any, infer AssignType, any, any>
-      ? Fields[Key] extends SchemaField<infer SubSchema, any, any, any, any>
+    [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>
-        : AssignType
-      : never;
+        : Fields[Key] extends DataField<any, infer AssignType, any, any>
+          ? AssignType
+          : never;
   }>;
 
+  type InnerUpdateData<Fields extends DataSchema> = InnerAssignmentType<Fields>;
+
   /**
    * Get the inner initialized type for the given DataSchema.
    * @typeParam Fields - the DataSchema fields of the SchemaField
    */
   type InnerInitializedType<Fields extends DataSchema> = RemoveIndexSignatures<{
-    [Key in keyof Fields]: Fields[Key] extends DataField<any, any, infer InitType, any>
-      ? Fields[Key] extends EmbeddedDataField<infer Model, any, any, any, any>
-        ? InstanceType<Model>
-        : Fields[Key] extends SchemaField<infer SubSchema, any, any, any, any>
-          ? InnerInitializedType<SubSchema>
-          : InitType
-      : never;
+    [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>
+        ? InnerInitializedType<SubSchema>
+        : Fields[Key] extends DataField<any, any, infer InitType, any>
+          ? InitType
+          : never;
   }>;
 
   /**
@@ -837,11 +859,13 @@ declare namespace SchemaField {
    * @typeParam Fields - the DataSchema fields of the SchemaField
    */
   type InnerPersistedType<Fields extends DataSchema> = RemoveIndexSignatures<{
-    [Key in keyof Fields]: Fields[Key] extends DataField<any, any, any, infer PersistType>
-      ? Fields[Key] extends SchemaField<infer SubSchema, any, any, any, any>
+    [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>
-        : PersistType
-      : never;
+        : Fields[Key] extends DataField<any, any, any, infer PersistType>
+          ? PersistType
+          : never;
   }>;
 
   /** The type of the default options for the {@link SchemaField} class. */
@@ -921,7 +945,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;
 
@@ -937,7 +961,7 @@ 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. */
   type DefaultOptions = SimpleMerge<
@@ -968,48 +992,6 @@ 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.
  * @typeParam Options         - the options of the NumberField instance
@@ -1024,7 +1006,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>,
@@ -1035,7 +1017,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;
@@ -1078,7 +1060,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;
 
@@ -1144,6 +1126,46 @@ declare namespace NumberField {
     }
   >;
 
+  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} class when choices are provided. */
   type DefaultOptionsWhenChoicesProvided = SimpleMerge<DefaultOptions, { nullable: false }>;
 
@@ -1151,7 +1173,7 @@ declare namespace NumberField {
    * 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
   >;
@@ -1160,7 +1182,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>
   >;
@@ -1169,7 +1191,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>
   >;
@@ -1205,35 +1227,6 @@ 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.
  * @typeParam Options         - the options of the StringField instance
@@ -1248,7 +1241,7 @@ declare global {
  * InitialValue: `""`
  */
 declare class StringField<
-  const Options extends StringFieldOptions = StringField.DefaultOptions,
+  const Options extends StringField.Options = StringField.DefaultOptions,
   const AssignmentType = StringField.AssignmentType<Options>,
   const InitializedType = StringField.InitializedType<Options>,
   const PersistedType extends string | null | undefined = StringField.InitializedType<Options>,
@@ -1259,7 +1252,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)?
@@ -1287,7 +1280,7 @@ declare class StringField<
   /** @defaultValue `false` */
   textSearch: boolean;
 
-  protected static override get _defaults(): StringFieldOptions;
+  protected static override get _defaults(): StringField.Options;
 
   override clean(value: AssignmentType, options?: DataField.CleanOptions): InitializedType;
 
@@ -1350,6 +1343,33 @@ declare namespace StringField {
     }
   >;
 
+  interface Options extends DataField.Options<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;
+  }
+
   /** The type of the default options for the {@link StringField} class when choices are provided. */
   type DefaultOptionsWhenChoicesProvided = SimpleMerge<DefaultOptions, { nullable: false; blank: false }>;
 
@@ -1357,21 +1377,21 @@ declare namespace StringField {
    * 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> = 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> = "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> = Options["required"] extends false | undefined
     ? undefined
     : Options["blank"] extends true
       ? string
@@ -1381,19 +1401,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> = 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> = DataField.DerivedAssignmentType<
     ValidChoice<Options>,
     MergedOptions<Options>
   >;
@@ -1402,7 +1427,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> = 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>
@@ -1457,7 +1482,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>,
@@ -1469,9 +1494,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;
 
@@ -1503,13 +1528,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>
   >;
@@ -1518,7 +1543,7 @@ 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>
   >;
@@ -1534,7 +1559,7 @@ 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>>,
@@ -1562,9 +1587,11 @@ declare namespace ObjectField {
  */
 declare class ArrayField<
   const ElementFieldType extends DataField.Any | Document.AnyConstructor,
+  const Options extends ArrayField.AnyOptions = ArrayField.DefaultOptions<
+    ArrayField.AssignmentElementType<ElementFieldType>
+  >,
   const AssignmentElementType = ArrayField.AssignmentElementType<ElementFieldType>,
   const InitializedElementType = ArrayField.InitializedElementType<ElementFieldType>,
-  const Options extends ArrayField.Options<AssignmentElementType> = ArrayField.DefaultOptions<AssignmentElementType>,
   const AssignmentType = ArrayField.AssignmentType<AssignmentElementType, Options>,
   const InitializedType = ArrayField.InitializedType<AssignmentElementType, InitializedElementType, Options>,
   const PersistedElementType = ArrayField.PersistedElementType<ElementFieldType>,
@@ -1587,7 +1614,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
@@ -1672,7 +1699,9 @@ 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.
@@ -1702,7 +1731,7 @@ declare namespace ArrayField {
    * @typeParam AssignmentElementType - the assignment type of the elements of the ArrayField
    * @typeParam Opts                  - the options that override the default options
    */
-  type MergedOptions<AssignmentElementType, Opts extends Options<AssignmentElementType>> = SimpleMerge<
+  type MergedOptions<AssignmentElementType, Opts extends AnyOptions> = SimpleMerge<
     DefaultOptions<AssignmentElementType>,
     Opts
   >;
@@ -1745,10 +1774,7 @@ declare namespace ArrayField {
    * @typeParam AssignmentElementType - the assignment type of the elements of the ArrayField
    * @typeParam Opts                  - the options that override the default options
    */
-  type AssignmentType<
-    AssignmentElementType,
-    Opts extends Options<AssignmentElementType>,
-  > = DataField.DerivedAssignmentType<
+  type AssignmentType<AssignmentElementType, Opts extends AnyOptions> = DataField.DerivedAssignmentType<
     BaseAssignmentType<AssignmentElementType>,
     MergedOptions<AssignmentElementType, Opts>
   >;
@@ -1762,7 +1788,7 @@ declare namespace ArrayField {
   type InitializedType<
     AssignmentElementType,
     InitializedElementType,
-    Opts extends Options<AssignmentElementType>,
+    Opts extends AnyOptions,
   > = DataField.DerivedInitializedType<InitializedElementType[], MergedOptions<AssignmentElementType, Opts>>;
 
   /**
@@ -1774,7 +1800,7 @@ declare namespace ArrayField {
   type PersistedType<
     AssignmentElementType,
     PersistedElementType,
-    Opts extends Options<AssignmentElementType>,
+    Opts extends AnyOptions,
   > = DataField.DerivedInitializedType<PersistedElementType[], MergedOptions<AssignmentElementType, Opts>>;
 }
 
@@ -1798,9 +1824,9 @@ declare namespace ArrayField {
  */
 declare class SetField<
   ElementFieldType extends DataField.Any,
+  Options extends SetField.AnyOptions = SetField.DefaultOptions<ArrayField.AssignmentElementType<ElementFieldType>>,
   AssignmentElementType = ArrayField.AssignmentElementType<ElementFieldType>,
   InitializedElementType = ArrayField.InitializedElementType<ElementFieldType>,
-  Options extends SetField.Options<AssignmentElementType> = SetField.DefaultOptions<AssignmentElementType>,
   AssignmentType = SetField.AssignmentType<AssignmentElementType, Options>,
   InitializedType = SetField.InitializedType<AssignmentElementType, InitializedElementType, Options>,
   PersistedElementType = ArrayField.PersistedElementType<ElementFieldType>,
@@ -1811,9 +1837,9 @@ declare class SetField<
   >,
 > extends ArrayField<
   ElementFieldType,
+  Options,
   AssignmentElementType,
   InitializedElementType,
-  Options,
   AssignmentType,
   InitializedType,
   PersistedElementType,
@@ -1852,7 +1878,9 @@ declare namespace SetField {
    * 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.
@@ -1871,7 +1899,7 @@ declare namespace SetField {
    * @typeParam AssignmentElementType - the assignment type of the elements of the SetField
    * @typeParam Opts                  - the options that override the default options
    */
-  type MergedOptions<AssignmentElementType, Opts extends Options<AssignmentElementType>> = SimpleMerge<
+  type MergedOptions<AssignmentElementType, Opts extends AnyOptions> = SimpleMerge<
     DefaultOptions<AssignmentElementType>,
     Opts
   >;
@@ -1881,10 +1909,7 @@ declare namespace SetField {
    * @typeParam AssignmentElementType - the assignment type of the elements of the SetField
    * @typeParam Opts                  - the options that override the default options
    */
-  type AssignmentType<
-    AssignmentElementType,
-    Opts extends Options<AssignmentElementType>,
-  > = DataField.DerivedAssignmentType<
+  type AssignmentType<AssignmentElementType, Opts extends AnyOptions> = DataField.DerivedAssignmentType<
     BaseAssignmentType<AssignmentElementType>,
     MergedOptions<AssignmentElementType, Opts>
   >;
@@ -1898,7 +1923,7 @@ declare namespace SetField {
   type InitializedType<
     AssignmentElementType,
     InitializedElementType,
-    Opts extends Options<AssignmentElementType>,
+    Opts extends AnyOptions,
   > = DataField.DerivedInitializedType<Set<InitializedElementType>, MergedOptions<AssignmentElementType, Opts>>;
 
   /**
@@ -1910,7 +1935,7 @@ declare namespace SetField {
   type PersistedType<
     AssignmentElementType,
     PersistedElementType,
-    Opts extends Options<AssignmentElementType>,
+    Opts extends AnyOptions,
   > = DataField.DerivedInitializedType<PersistedElementType[], MergedOptions<AssignmentElementType, Opts>>;
 
   type ToInputConfig<ElementFieldType extends DataField.Any, InitializedType> = ElementFieldType extends {
@@ -1954,7 +1979,7 @@ declare class EmbeddedDataField<
    */
   model: ModelType;
 
-  protected override _initialize(fields: DataSchema): DataSchema;
+  protected override _initialize(fields: DataModel.SchemaOfClass<ModelType>): DataModel.SchemaOfClass<ModelType>;
 
   override initialize(
     value: PersistedType,
@@ -1979,7 +2004,7 @@ 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<
+  type Options<ModelType extends DataModel.AnyConstructor> = DataField.Options<
     SchemaField.InnerAssignmentType<DataModel.SchemaOfClass<ModelType>> | __SchemaFieldInitial
   >;
 
@@ -2018,10 +2043,7 @@ declare namespace EmbeddedDataField {
   type InitializedType<
     ModelType extends DataModel.AnyConstructor,
     Opts extends Options<ModelType>,
-  > = DataField.DerivedInitializedType<
-    SchemaField.InnerInitializedType<DataModel.SchemaOfClass<ModelType>>,
-    MergedOptions<ModelType, Opts>
-  >;
+  > = DataField.DerivedInitializedType<FixedInstanceType<ModelType>, MergedOptions<ModelType, Opts>>;
 
   /**
    * A shorthand for the persisted type of an EmbeddedDataField class.
@@ -2057,11 +2079,13 @@ declare namespace EmbeddedDataField {
  */
 declare class EmbeddedCollectionField<
   ElementFieldType extends Document.AnyConstructor,
+  // TODO(LukeAbby): See if `ParentDataModel` can be made redundant by automatically inferring.
   ParentDataModel extends Document.Any,
+  Options extends EmbeddedCollectionField.Options<any> = EmbeddedCollectionField.DefaultOptions<
+    EmbeddedCollectionField.AssignmentElementType<ElementFieldType>
+  >,
   AssignmentElementType = EmbeddedCollectionField.AssignmentElementType<ElementFieldType>,
   InitializedElementType extends Document.Any = EmbeddedCollectionField.InitializedElementType<ElementFieldType>,
-  Options extends
-    EmbeddedCollectionField.Options<AssignmentElementType> = EmbeddedCollectionField.DefaultOptions<AssignmentElementType>,
   AssignmentType = EmbeddedCollectionField.AssignmentType<AssignmentElementType, Options>,
   InitializedType = EmbeddedCollectionField.InitializedType<
     AssignmentElementType,
@@ -2077,9 +2101,9 @@ declare class EmbeddedCollectionField<
   >,
 > extends ArrayField<
   ElementFieldType,
+  Options,
   AssignmentElementType,
   InitializedElementType,
-  Options,
   AssignmentType,
   InitializedType,
   PersistedElementType,
@@ -2156,7 +2180,7 @@ declare namespace EmbeddedCollectionField {
    * 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.
@@ -2264,10 +2288,11 @@ declare namespace EmbeddedCollectionField {
 declare class EmbeddedCollectionDeltaField<
   ElementFieldType extends Document.AnyConstructor,
   ParentDataModel extends Document.Any,
+  Options extends EmbeddedCollectionDeltaField.Options<any> = EmbeddedCollectionDeltaField.DefaultOptions<
+    EmbeddedCollectionDeltaField.AssignmentElementType<ElementFieldType>
+  >,
   AssignmentElementType = EmbeddedCollectionDeltaField.AssignmentElementType<ElementFieldType>,
   InitializedElementType extends Document.Any = EmbeddedCollectionDeltaField.InitializedElementType<ElementFieldType>,
-  Options extends
-    EmbeddedCollectionDeltaField.Options<AssignmentElementType> = EmbeddedCollectionDeltaField.DefaultOptions<AssignmentElementType>,
   AssignmentType = EmbeddedCollectionDeltaField.AssignmentType<AssignmentElementType, Options>,
   InitializedType = EmbeddedCollectionDeltaField.InitializedType<
     AssignmentElementType,
@@ -2284,9 +2309,9 @@ declare class EmbeddedCollectionDeltaField<
 > extends EmbeddedCollectionField<
   ElementFieldType,
   ParentDataModel,
+  Options,
   AssignmentElementType,
   InitializedElementType,
-  Options,
   AssignmentType,
   InitializedType,
   PersistedElementType,
@@ -2307,7 +2332,7 @@ 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.
@@ -2447,7 +2472,7 @@ declare namespace EmbeddedDocumentField {
    * A shorthand for the options of an EmbeddedDocumentField class.
    * @typeParam DocumentType - the type of the embedded Document
    */
-  type Options<DocumentType extends Document.AnyConstructor> = DataFieldOptions<
+  type Options<DocumentType extends Document.AnyConstructor> = DataField.Options<
     SchemaField.InnerAssignmentType<DataModel.SchemaOfClass<DocumentType>> | __SchemaFieldInitial
   >;
 
@@ -2524,7 +2549,7 @@ declare namespace EmbeddedDocumentField {
  * InitialValue: `null`
  */
 declare class DocumentIdField<
-  Options extends StringFieldOptions = DocumentIdField.DefaultOptions,
+  Options extends StringField.Options = DocumentIdField.DefaultOptions,
   AssignmentType = DocumentIdField.AssignmentType<Options>,
   InitializedType = DocumentIdField.InitializedType<Options>,
   PersistedType extends string | null | undefined = DocumentIdField.InitializedType<Options>,
@@ -2539,7 +2564,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;
@@ -2547,7 +2572,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;
 
   protected override _cast(value: AssignmentType): InitializedType;
 
@@ -2575,13 +2600,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> = 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> = DataField.DerivedAssignmentType<
     string | Document.Any,
     MergedOptions<Options>
   >;
@@ -2590,7 +2615,7 @@ 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> = DataField.DerivedInitializedType<
     string,
     MergedOptions<Options>
   >;
@@ -2655,14 +2680,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,
@@ -2752,8 +2776,8 @@ declare class ForeignDocumentField<
 
 declare namespace ForeignDocumentField {
   /** The options for the ForeignDocumentField class. */
-  type Options = StringFieldOptions &
-    DataFieldOptions<string | Document.Any> & {
+  type Options = StringField.Options &
+    DataField.Options<string | Document.Any> & {
       // Making this ---------^ more concrete leads to excessively deep instantiation
       idOnly?: boolean;
     };
@@ -2781,7 +2805,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.
@@ -2816,7 +2840,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>,
@@ -2825,7 +2849,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;
@@ -2833,7 +2857,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;
 
@@ -2859,13 +2883,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>
   >;
@@ -2874,7 +2898,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>
   >;
@@ -2883,37 +2907,12 @@ 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.
  * @typeParam Options         - the options of the FilePathField instance
@@ -2928,7 +2927,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>,
@@ -2963,9 +2962,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;
 
@@ -2989,17 +2988,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>
   >;
@@ -3008,7 +3027,7 @@ 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>
   >;
@@ -3028,7 +3047,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>,
@@ -3040,7 +3059,7 @@ declare class AngleField<
   override nullable: boolean;
 
   /** @defaultValue `0` */
-  override initial: DataFieldOptions.InitialType<InitializedType>;
+  override initial: DataField.Options.InitialType<InitializedType>;
 
   /** @defaultValue `0` */
   base: number;
@@ -3054,7 +3073,7 @@ 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;
 }
@@ -3078,13 +3097,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>
   >;
@@ -3093,7 +3112,7 @@ 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>
   >;
@@ -3113,7 +3132,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>,
@@ -3125,7 +3144,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;
@@ -3136,7 +3155,7 @@ 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 {
@@ -3157,13 +3176,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>
   >;
@@ -3172,7 +3191,7 @@ 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>
   >;
@@ -3183,7 +3202,7 @@ declare namespace AlphaField {
  * 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>,
@@ -3194,7 +3213,7 @@ declare class HueField<
 }
 
 declare namespace HueField {
-  type Options = NumberFieldOptions;
+  type Options = NumberField.Options;
 
   type DefaultOptions = SimpleMerge<
     NumberField.DefaultOptions,
@@ -3232,7 +3251,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;
@@ -3247,7 +3266,7 @@ 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. */
   type DefaultOptions = SimpleMerge<
@@ -3298,7 +3317,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>,
@@ -3309,12 +3328,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;
 
@@ -3371,13 +3390,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>
   >;
@@ -3386,7 +3405,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>
   >;
@@ -3395,7 +3414,7 @@ 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>
   >;
@@ -3407,7 +3426,7 @@ declare namespace JSONField {
  * 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(
@@ -3432,7 +3451,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>,
@@ -3443,7 +3462,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(
@@ -3484,13 +3503,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>
   >;
@@ -3499,7 +3518,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>
   >;
@@ -3522,7 +3541,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>,
@@ -3537,7 +3556,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;
@@ -3564,13 +3583,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>
   >;
@@ -3579,16 +3598,12 @@ 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.
  * @typeParam Options         - the options of the DocumentStatsField instance
@@ -3623,7 +3638,7 @@ 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.InnerAssignmentType<Schema>>;
 
   /** The type of the default options for the {@link DocumentStatsField} class. */
   type DefaultOptions = SimpleMerge<SchemaField.DefaultOptions, { initial: SchemaField.InnerAssignmentType<Schema> }>;
@@ -3730,7 +3745,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;
 
@@ -3751,12 +3766,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>,
     {
@@ -3767,15 +3782,15 @@ 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>>;
 }
 
@@ -3869,7 +3884,7 @@ 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<
+  type Options<DocumentType extends Document.SystemConstructor> = DataField.Options<
     SchemaField.InnerAssignmentType<DataModel.SchemaOfClass<DocumentType>>
   >;
 
@@ -3891,30 +3906,9 @@ 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
-   */
-  type Config<DocumentType extends Document.SystemConstructor> =
-    DocumentType["metadata"]["name"] extends keyof DataModelConfig
-      ? DataModelConfig[DocumentType["metadata"]["name"]]
-      : EmptyObject;
-
-  /**
-   * 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];
+  type DataModelsFor<DocumentType extends Document.Type> = DocumentType extends keyof DataModelConfig
+    ? DataModelConfig[DocumentType]
+    : EmptyObject;
 
   /**
    * A shorthand for the assignment type of a TypeDataField class.
@@ -3923,8 +3917,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.
@@ -3933,21 +3927,64 @@ declare namespace TypeDataField {
    */
   type InitializedType<
     SystemDocumentConstructor extends Document.SystemConstructor,
-    Opts extends Options<InstanceType<SystemDocumentConstructor>>,
+    Opts extends Options<SystemDocumentConstructor>,
   > = DataField.DerivedInitializedType<
-    ValueOf<Config<SystemDocumentConstructor>> | AnyObject,
-    MergedOptions<InstanceType<SystemDocumentConstructor>, Opts>
+    _Instances<DataModelsFor<SystemDocumentConstructor["metadata"]["name"]>> | UnknownSystem,
+    MergedOptions<SystemDocumentConstructor, Opts>
   >;
 
+  type _Instances<T> = {
+    [K in keyof T]: T[K] extends (abstract new (arg0: never, ...args: never[]) => infer U extends DataModel.Any)
+      ? U
+      : never;
+  };
+
+  /**
+   * 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}`;
+  }
+
+  /**
+   * 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.
+   *
+   * `UnknownTypeDataModel` covers the case where it's configured with a {@link TypeDataModel | `TypeDataModel`}.
+   * See {@link UnknownSystem | `UnknownSystem`} for other possibilities.
+   */
+  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>>;
 }
 
 /**
@@ -3955,19 +3992,19 @@ declare namespace TypeDataField {
  */
 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.
@@ -4001,6 +4038,8 @@ declare class TypedSchemaField<
 }
 
 declare namespace TypedSchemaField {
+  interface Options<T extends Types> extends DataField.Options<_AssignmentType<ToConfiguredTypes<T>>> {}
+
   type DefaultOptions = SimpleMerge<
     DataField.DefaultOptions,
     {
@@ -4008,31 +4047,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
@@ -4044,37 +4088,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>;
 }
 
 /**
@@ -4082,6 +4126,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 {
   /**
@@ -4097,6 +4142,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;
 }
 
@@ -4150,7 +4196,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`
@@ -4159,7 +4205,7 @@ declare namespace JavaScriptField {
   };
 
   type DefaultOptions = SimpleMerge<
-    StringFieldOptions,
+    StringField.Options,
     {
       async: false;
     }