@league-of-foundry-developers/foundry-vtt-types 13.340.0 → 13.340.1

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

@@ -5,16 +5,18 @@ import type {
   EmptyObject,
   NullishProps,
   InexactPartial,
-  ToMethod,
   FixedInstanceType,
-} from "../../../utils/index.d.mts";
+  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 { 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,
@@ -22,7 +24,7 @@ import type {
   MultiSelectInputConfig,
   SelectInputConfig,
   TextAreaInputConfig,
-} from "../../client-esm/applications/forms/fields.d.mts";
+} from "#client-esm/applications/forms/fields.d.mts";
 
 export type DataSchema = Record<string, DataField.Any>;
 
@@ -41,6 +43,7 @@ export type DataSchema = Record<string, DataField.Any>;
  */
 declare abstract class DataField<
   const Options extends DataField.Options.Any = DataField.DefaultOptions,
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   const AssignmentType = DataField.AssignmentType<Options>,
   const InitializedType = DataField.InitializedType<Options>,
   const PersistedType = InitializedType,
@@ -53,6 +56,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;
 
@@ -415,13 +427,16 @@ declare abstract class DataField<
 
 declare namespace DataField {
   /** Any DataField. */
-  type Any = DataField<DataField.Options.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>;
 
+  /**
+   * @deprecated - AssignmentType is being deprecated. See {@link SchemaField.AssignmentData | `SchemaField.AssignmentData`}
+   * for more details.
+   */
   type AssignmentTypeFor<ConcreteDataField extends Any> =
     ConcreteDataField extends DataField<any, infer AssignmentType, any, any> ? AssignmentType : never;
 
@@ -431,7 +446,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;
@@ -465,12 +480,14 @@ declare namespace DataField {
     /** 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"]>
+          // 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<BaseAssignmentType> | undefined;
+    validate?: DataField.Validator<DataField.Any, BaseAssignmentType> | undefined;
 
     /** A localizable label displayed on forms which render this field. */
     label?: string | undefined;
@@ -490,19 +507,19 @@ declare namespace DataField {
   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.
+    // 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 interfa
-    type Any = DataField.Options<any> & object;
+    // `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} option.
+     * 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} option.
+     * 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
@@ -541,6 +558,9 @@ declare namespace DataField {
    * 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
+   *
+   * @deprecated - This type is being phased out alongside the entirety of the concept of the
+   * `Assignment` type.
    */
   type DerivedAssignmentType<BaseAssignmentType, Options extends DataField.Options.Any> =
     | Exclude<BaseAssignmentType, null | undefined> // Always include the base type
@@ -580,7 +600,11 @@ declare namespace DataField {
   /**
    * A shorthand for the assignment type of a DataField class.
    * @typeParam Options - the options overriding the defaults
+   *
+   * @deprecated - AssignmentData is being phased out. See {@link SchemaField.AssignmentData | `SchemaField.AssignmentData`}
+   * for more details.
    */
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   type AssignmentType<Options extends DataField.Options.Any> = DerivedAssignmentType<any, MergedOptions<Options>>;
 
   /**
@@ -589,7 +613,7 @@ declare namespace DataField {
    */
   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;
@@ -611,22 +635,37 @@ 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>>;
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
+    validate?: Validator<CurrentField, DataField.AssignmentTypeFor<CurrentField>>;
   }
 
   interface Context {
@@ -658,11 +697,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
@@ -677,9 +716,10 @@ 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<
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
+  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>
   >,
@@ -799,7 +839,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;
@@ -809,66 +849,112 @@ 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> = DataField.Options<InnerAssignmentType<Fields> | __SchemaFieldInitial>;
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
+  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 instead of always being
+  // optional. This does mean the deprecation of `AssignmentData` is a "lie"
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
+  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;
-  }>;
+   *
+   * @deprecated This type is a relic of the early days of data models. It was meant to represent
+   * the types that would be valid for the expression `this.schemaProperty = ...`. Modern users will
+   * recognize that the only sane thing to do here is to use `InitializedData` but when data models
+   * were first being introduced there was an attempt to support a sort of strange compromise between
+   * `InitializedData`, `SourceData`, and even `CreateData` for backwards compatability with existing patterns.
+   *
+   * You should instead use those types as appropriate.
+   */
+  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
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
+            EmptyObject extends AssignmentData<SubSchema>
+            ? // eslint-disable-next-line @typescript-eslint/no-deprecated
+              AssignmentData<SubSchema> | undefined | null
+            : // eslint-disable-next-line @typescript-eslint/no-deprecated
+              AssignmentData<SubSchema>
+          : Fields[Key] extends DataField<any, infer AssignType, any, any>
+            ? AssignType
+            : never;
+    }>
+  >;
 
-  type InnerUpdateData<Fields extends DataSchema> = InnerAssignmentType<Fields>;
+  /**
+   * The required type of data used when updating a document.
+   * @typeParam Fields - the DataSchema fields of the SchemaField
+   */
+  // Note(LukeAbby): Currently this is identical to `AssignmentData` but the intent is to make it
+  // more accurate in the future.
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
+  type UpdateData<Fields extends DataSchema> = AssignmentData<Fields>;
 
   /**
-   * Get the inner initialized type for the given DataSchema.
+   * Gets the initialized version of a schema. This means a
    * @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>
-      ? 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;
-  }>;
+  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;
+    }>
+  >;
 
   /**
-   * Get the inner persisted type for the given DataSchema.
+   * @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 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 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,
     {
@@ -885,40 +971,114 @@ 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
+     *
+     * @deprecated This type is a relic of the early days of data models. It was meant to represent
+     * the types that would be valid for the expression `this.schemaProperty = ...`. Modern users will
+     * recognize that the only sane thing to do here is to use `InitializedType` but when data models
+     * were first being introduced there was an attempt to support a sort of strange compromise between
+     * `InitializedType`, `SourceType`, and even `CreateType` to an extent.
+     *
+     * You should instead use those types as appropriate.
+     */
+    type AssignmentType<
+      Fields extends DataSchema,
+      Opts extends Options<Fields> = DefaultOptions,
+      // eslint-disable-next-line @typescript-eslint/no-deprecated
+    > = 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>>;
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
+  > = 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 This type is a relic of the early days of data models. It was meant to represent
+   * the types that would be valid for the expression `this.schemaProperty = ...`. Modern users will
+   * recognize that the only sane thing to do here is to use `InitializedData` but when data models
+   * were first being introduced there was an attempt to support a sort of strange compromise between
+   * `InitializedData`, `SourceData`, and even `CreateData` to an extent.
+   *
+   * You should instead use those types as appropriate.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
+  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
@@ -932,6 +1092,7 @@ declare namespace SchemaField {
  */
 declare class BooleanField<
   const Options extends BooleanField.Options = BooleanField.DefaultOptions,
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   const AssignmentType = BooleanField.AssignmentType<SimpleMerge<Options, BooleanField.DefaultOptions>>,
   const InitializedType = BooleanField.InitializedType<SimpleMerge<Options, BooleanField.DefaultOptions>>,
   const PersistedType extends boolean | null | undefined = BooleanField.InitializedType<
@@ -963,7 +1124,7 @@ declare namespace BooleanField {
   /** A shorthand for the options of a BooleanField class. */
   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,
     {
@@ -982,7 +1143,11 @@ declare namespace BooleanField {
   /**
    * A shorthand for the assignment type of a BooleanField class.
    * @typeParam Opts - the options that override the default options
+   *
+   * @deprecated - AssignmentData is being phased out. See {@link SchemaField.AssignmentData | `SchemaField.AssignmentData`}
+   * for more details.
    */
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   type AssignmentType<Opts extends Options> = DataField.DerivedAssignmentType<boolean, MergedOptions<Opts>>;
 
   /**
@@ -993,7 +1158,7 @@ declare namespace BooleanField {
 }
 
 /**
- * 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
@@ -1007,6 +1172,7 @@ declare namespace BooleanField {
  */
 declare class NumberField<
   const Options extends NumberField.Options = NumberField.DefaultOptions,
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   const AssignmentType = NumberField.AssignmentType<Options>,
   const InitializedType = NumberField.InitializedType<Options>,
   const PersistedType extends number | null | undefined = NumberField.InitializedType<Options>,
@@ -1111,7 +1277,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,
     {
@@ -1166,7 +1332,7 @@ declare namespace NumberField {
     choices?: NumberField.Choices | undefined;
   }
 
-  /** The type of the default options for the {@link NumberField} class when choices are provided. */
+  /** The type of the default options for the {@link NumberField | `NumberField`} class when choices are provided. */
   type DefaultOptionsWhenChoicesProvided = SimpleMerge<DefaultOptions, { nullable: false }>;
 
   /**
@@ -1181,7 +1347,11 @@ declare namespace NumberField {
   /**
    * A shorthand for the assignment type of a NumberField class.
    * @typeParam Options - the options that override the default options
+   *
+   * @deprecated - AssignmentData is being phased out. See {@link SchemaField.AssignmentData | `SchemaField.AssignmentData`}
+   * for more details.
    */
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   type AssignmentType<Options extends NumberField.Options> = DataField.DerivedAssignmentType<
     number,
     MergedOptions<Options>
@@ -1228,7 +1398,7 @@ declare namespace NumberField {
 }
 
 /**
- * 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
@@ -1241,7 +1411,8 @@ declare namespace NumberField {
  * InitialValue: `""`
  */
 declare class StringField<
-  const Options extends StringField.Options = StringField.DefaultOptions,
+  const Options extends StringField.Options<unknown> = StringField.DefaultOptions,
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   const AssignmentType = StringField.AssignmentType<Options>,
   const InitializedType = StringField.InitializedType<Options>,
   const PersistedType extends string | null | undefined = StringField.InitializedType<Options>,
@@ -1280,7 +1451,7 @@ declare class StringField<
   /** @defaultValue `false` */
   textSearch: boolean;
 
-  protected static override get _defaults(): StringField.Options;
+  protected static override get _defaults(): StringField.Options<unknown>;
 
   override clean(value: AssignmentType, options?: DataField.CleanOptions): InitializedType;
 
@@ -1331,7 +1502,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,
     {
@@ -1343,7 +1514,7 @@ declare namespace StringField {
     }
   >;
 
-  interface Options extends DataField.Options<string> {
+  interface Options<Type = string> extends DataField.Options<Type> {
     /**
      * Is the string allowed to be blank (empty)?
      * @defaultValue `true`
@@ -1370,14 +1541,14 @@ declare namespace StringField {
     textSearch?: boolean | undefined;
   }
 
-  /** The type of the default options for the {@link StringField} class when choices are provided. */
+  /** 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 StringField.Options> = SimpleMerge<
+  type MergedOptions<Options extends StringField.Options<unknown>> = SimpleMerge<
     _OptionsForInitial<_OptionsForChoices<Options["choices"]>>,
     Options
   >;
@@ -1387,11 +1558,11 @@ declare namespace StringField {
     : DefaultOptionsWhenChoicesProvided;
 
   // FIXME: `"initial" extends keyof Options` does not work for modeling `"initial" in options`.
-  type _OptionsForInitial<Options extends StringField.Options> = "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 StringField.Options> = Options["required"] extends false | undefined
+  type _InitialForOptions<Options extends StringField.Options<unknown>> = Options["required"] extends false | undefined
     ? undefined
     : Options["blank"] extends true
       ? string
@@ -1401,7 +1572,7 @@ declare namespace StringField {
 
   // choices?: string[] | Record<string, string> | (() => string[] | Record<string, string>) | undefined;
 
-  type ValidChoice<Options extends StringField.Options> = Options["choices"] extends undefined
+  type ValidChoice<Options extends StringField.Options<unknown>> = Options["choices"] extends undefined
     ? string
     : Options["choices"] extends (...args: infer _1) => infer Choices
       ? FixedChoice<Choices>
@@ -1417,8 +1588,12 @@ declare namespace StringField {
   /**
    * A shorthand for the assignment type of a StringField class.
    * @typeParam Options - the options that override the default options
+   *
+   * @deprecated - AssignmentData is being phased out. See {@link SchemaField.AssignmentData | `SchemaField.AssignmentData`}
+   * for more details.
    */
-  type AssignmentType<Options extends StringField.Options> = DataField.DerivedAssignmentType<
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
+  type AssignmentType<Options extends StringField.Options<unknown>> = DataField.DerivedAssignmentType<
     ValidChoice<Options>,
     MergedOptions<Options>
   >;
@@ -1427,7 +1602,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 StringField.Options> = 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>
@@ -1469,7 +1644,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,6 +1658,7 @@ declare namespace StringField {
  */
 declare class ObjectField<
   const Options extends DataField.Options<AnyObject> = ObjectField.DefaultOptions,
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   const AssignmentType = ObjectField.AssignmentType<Options>,
   const InitializedType = ObjectField.InitializedType<Options>,
   const PersistedType extends AnyObject | null | undefined = ObjectField.InitializedType<Options>,
@@ -1515,7 +1691,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,
     {
@@ -1533,7 +1709,11 @@ declare namespace ObjectField {
   /**
    * A shorthand for the assignment type of a ObjectField class.
    * @typeParam Options - the options that override the default options
+   *
+   * @deprecated - AssignmentData is being phased out. See {@link SchemaField.AssignmentData | `SchemaField.AssignmentData`}
+   * for more details.
    */
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   type AssignmentType<Options extends DataField.Options<AnyObject>> = DataField.DerivedAssignmentType<
     AnyObject,
     MergedOptions<Options>
@@ -1549,7 +1729,7 @@ declare namespace ObjectField {
   >;
 
   /**
-   * 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
@@ -1562,14 +1742,24 @@ declare namespace ObjectField {
     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>>
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
+    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
@@ -1588,10 +1778,13 @@ declare namespace ObjectField {
 declare class ArrayField<
   const ElementFieldType extends DataField.Any | Document.AnyConstructor,
   const Options extends ArrayField.AnyOptions = ArrayField.DefaultOptions<
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
     ArrayField.AssignmentElementType<ElementFieldType>
   >,
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   const AssignmentElementType = ArrayField.AssignmentElementType<ElementFieldType>,
   const InitializedElementType = ArrayField.InitializedElementType<ElementFieldType>,
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   const AssignmentType = ArrayField.AssignmentType<AssignmentElementType, Options>,
   const InitializedType = ArrayField.InitializedType<AssignmentElementType, InitializedElementType, Options>,
   const PersistedElementType = ArrayField.PersistedElementType<ElementFieldType>,
@@ -1622,6 +1815,7 @@ declare class ArrayField<
   element: ElementFieldType;
 
   protected static override get _defaults(): ArrayField.Options<
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
     ArrayField.AssignmentElementType<DataField.Any | Document.AnyConstructor>
   >;
 
@@ -1654,7 +1848,7 @@ declare class ArrayField<
    * @returns An array of element-specific errors
    */
   protected _validateElements(
-    value: any[],
+    value: AnyArray,
     options?: DataField.ValidationOptions<DataField.Any>,
   ): DataModelValidationFailure | void;
 
@@ -1665,7 +1859,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;
 
@@ -1704,7 +1898,7 @@ declare namespace ArrayField {
   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> =
@@ -1714,7 +1908,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<
@@ -1739,41 +1933,48 @@ declare namespace ArrayField {
   /**
    * A type to infer the assignment element type of an ArrayField from its ElementFieldType.
    * @typeParam ElementFieldType - the DataField type of the elements in the ArrayField
+   *
+   * @deprecated - AssignmentData is being phased out. See {@link SchemaField.AssignmentData | `SchemaField.AssignmentData`}
+   * for more details.
    */
   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.
    * @typeParam AssignmentElementType - the assignment type of the elements of the ArrayField
    * @typeParam Opts                  - the options that override the default options
+   *
+   * @deprecated - AssignmentData is being phased out. See {@link SchemaField.AssignmentData | `SchemaField.AssignmentData`}
+   * for more details.
    */
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   type AssignmentType<AssignmentElementType, Opts extends AnyOptions> = DataField.DerivedAssignmentType<
     BaseAssignmentType<AssignmentElementType>,
     MergedOptions<AssignmentElementType, Opts>
@@ -1794,7 +1995,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<
@@ -1805,7 +2006,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
@@ -1824,9 +2025,12 @@ declare namespace ArrayField {
  */
 declare class SetField<
   ElementFieldType extends DataField.Any,
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   Options extends SetField.AnyOptions = SetField.DefaultOptions<ArrayField.AssignmentElementType<ElementFieldType>>,
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   AssignmentElementType = ArrayField.AssignmentElementType<ElementFieldType>,
   InitializedElementType = ArrayField.InitializedElementType<ElementFieldType>,
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   AssignmentType = SetField.AssignmentType<AssignmentElementType, Options>,
   InitializedType = SetField.InitializedType<AssignmentElementType, InitializedElementType, Options>,
   PersistedElementType = ArrayField.PersistedElementType<ElementFieldType>,
@@ -1872,24 +2076,27 @@ 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
    */
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   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
+   *
+   * @deprecated - Assignment type is being deprecated.
    */
   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>;
@@ -1908,8 +2115,13 @@ declare namespace SetField {
    * A shorthand for the assignment type of a SetField class.
    * @typeParam AssignmentElementType - the assignment type of the elements of the SetField
    * @typeParam Opts                  - the options that override the default options
+   *
+   * @deprecated - AssignmentData is being phased out. See {@link SchemaField.AssignmentData | `SchemaField.AssignmentData`}
+   * for more details.
    */
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   type AssignmentType<AssignmentElementType, Opts extends AnyOptions> = DataField.DerivedAssignmentType<
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
     BaseAssignmentType<AssignmentElementType>,
     MergedOptions<AssignmentElementType, Opts>
   >;
@@ -1929,7 +2141,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<
@@ -1948,7 +2160,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
@@ -1964,6 +2176,7 @@ declare namespace SetField {
 declare class EmbeddedDataField<
   const ModelType extends DataModel.AnyConstructor,
   const Options extends EmbeddedDataField.Options<ModelType> = EmbeddedDataField.DefaultOptions,
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   const AssignmentType = EmbeddedDataField.AssignmentType<ModelType, Options>,
   const InitializedType = EmbeddedDataField.InitializedType<ModelType, Options>,
   const PersistedType extends AnyObject | null | undefined = EmbeddedDataField.PersistedType<ModelType, Options>,
@@ -2005,10 +2218,11 @@ declare namespace EmbeddedDataField {
    * @typeParam ModelType - the DataModel for the embedded data
    */
   type Options<ModelType extends DataModel.AnyConstructor> = DataField.Options<
-    SchemaField.InnerAssignmentType<DataModel.SchemaOfClass<ModelType>> | __SchemaFieldInitial
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
+    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;
 
   /**
@@ -2025,12 +2239,17 @@ declare namespace EmbeddedDataField {
    * A shorthand for the assignment type of an EmbeddedDataField class.
    * @typeParam ModelType - the DataModel for the embedded data
    * @typeParam Opts      - the options that override the default options
+   *
+   * @deprecated - AssignmentType is being deprecated. See {@link SchemaField.AssignmentData | `SchemaField.AssignmentData`}
+   * for more details.
    */
   type AssignmentType<
     ModelType extends DataModel.AnyConstructor,
     Opts extends Options<ModelType>,
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
   > = DataField.DerivedAssignmentType<
-    SchemaField.InnerAssignmentType<DataModel.SchemaOfClass<ModelType>>,
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
+    SchemaField.AssignmentData<DataModel.SchemaOfClass<ModelType>>,
     MergedOptions<ModelType, Opts>
   >;
 
@@ -2054,13 +2273,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
@@ -2082,10 +2301,13 @@ declare class EmbeddedCollectionField<
   // TODO(LukeAbby): See if `ParentDataModel` can be made redundant by automatically inferring.
   ParentDataModel extends Document.Any,
   Options extends EmbeddedCollectionField.Options<any> = EmbeddedCollectionField.DefaultOptions<
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
     EmbeddedCollectionField.AssignmentElementType<ElementFieldType>
   >,
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   AssignmentElementType = EmbeddedCollectionField.AssignmentElementType<ElementFieldType>,
   InitializedElementType extends Document.Any = EmbeddedCollectionField.InitializedElementType<ElementFieldType>,
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   AssignmentType = EmbeddedCollectionField.AssignmentType<AssignmentElementType, Options>,
   InitializedType = EmbeddedCollectionField.InitializedType<
     AssignmentElementType,
@@ -2174,7 +2396,7 @@ 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.
@@ -2183,7 +2405,7 @@ declare namespace EmbeddedCollectionField {
   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>;
@@ -2201,11 +2423,15 @@ 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>
+   *
+   * @deprecated - AssignmentType is being deprecated. See {@link SchemaField.AssignmentData | `SchemaField.AssignmentData`}
+   * for more details.
+   */
+  // 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;
 
   /**
@@ -2219,20 +2445,25 @@ 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;
 
   /**
    * A shorthand for the assignment type of an ArrayField class.
    * @typeParam AssignmentElementType - the assignment type of the elements of the EmbeddedCollectionField
    * @typeParam Opts                  - the options that override the default options
+   *
+   * @deprecated - AssignmentType is being deprecated. See {@link SchemaField.AssignmentData | `SchemaField.AssignmentData`}
+   * for more details.
    */
   type AssignmentType<
     AssignmentElementType,
     Opts extends Options<AssignmentElementType>,
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
   > = DataField.DerivedAssignmentType<
     ArrayField.BaseAssignmentType<AssignmentElementType>,
     MergedOptions<AssignmentElementType, Opts>
@@ -2257,7 +2488,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<
@@ -2268,7 +2499,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
@@ -2289,10 +2520,13 @@ declare class EmbeddedCollectionDeltaField<
   ElementFieldType extends Document.AnyConstructor,
   ParentDataModel extends Document.Any,
   Options extends EmbeddedCollectionDeltaField.Options<any> = EmbeddedCollectionDeltaField.DefaultOptions<
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
     EmbeddedCollectionDeltaField.AssignmentElementType<ElementFieldType>
   >,
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   AssignmentElementType = EmbeddedCollectionDeltaField.AssignmentElementType<ElementFieldType>,
   InitializedElementType extends Document.Any = EmbeddedCollectionDeltaField.InitializedElementType<ElementFieldType>,
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   AssignmentType = EmbeddedCollectionDeltaField.AssignmentType<AssignmentElementType, Options>,
   InitializedType = EmbeddedCollectionDeltaField.InitializedType<
     AssignmentElementType,
@@ -2335,7 +2569,7 @@ declare namespace EmbeddedCollectionDeltaField {
   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>;
@@ -2353,11 +2587,14 @@ 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
+   *
+   * @deprecated - AssignmentType is being deprecated. See {@link SchemaField.AssignmentData | `SchemaField.AssignmentData`}
+   * for more details.
    */
-  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;
 
   /**
@@ -2371,20 +2608,25 @@ 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;
 
   /**
    * A shorthand for the assignment type of an ArrayField class.
    * @typeParam AssignmentElementType - the assignment type of the elements of the EmbeddedCollectionDeltaField
    * @typeParam Opts                  - the options that override the default options
+   *
+   * @deprecated - AssignmentType is being deprecated. See {@link SchemaField.AssignmentData | `SchemaField.AssignmentData`}
+   * for more details.
    */
   type AssignmentType<
     AssignmentElementType,
     Opts extends Options<AssignmentElementType>,
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
   > = DataField.DerivedAssignmentType<
     ArrayField.BaseAssignmentType<AssignmentElementType>,
     MergedOptions<AssignmentElementType, Opts>
@@ -2409,7 +2651,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<
@@ -2420,7 +2662,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
@@ -2436,6 +2678,7 @@ declare namespace EmbeddedCollectionDeltaField {
 declare class EmbeddedDocumentField<
   const DocumentType extends Document.AnyConstructor,
   const Options extends EmbeddedDocumentField.Options<DocumentType> = EmbeddedDocumentField.DefaultOptions,
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   const AssignmentType = EmbeddedDocumentField.AssignmentType<DocumentType, Options>,
   const InitializedType = EmbeddedDocumentField.InitializedType<DocumentType, Options>,
   const PersistedType extends AnyObject | null | undefined = EmbeddedDocumentField.PersistedType<DocumentType, Options>,
@@ -2468,15 +2711,18 @@ 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> = DataField.Options<
-    SchemaField.InnerAssignmentType<DataModel.SchemaOfClass<DocumentType>> | __SchemaFieldInitial
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
+    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,
     {
@@ -2498,12 +2744,17 @@ declare namespace EmbeddedDocumentField {
    * A shorthand for the assignment type of an EmbeddedDocumentField class.
    * @typeParam DocumentType - the type of the embedded Document
    * @typeParam Opts         - the options that override the default options
+   *
+   * @deprecated - AssignmentType is being deprecated. See {@link SchemaField.AssignmentData | `SchemaField.AssignmentData`}
+   * for more details.
    */
   type AssignmentType<
     DocumentType extends Document.AnyConstructor,
     Opts extends Options<DocumentType>,
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
   > = DataField.DerivedAssignmentType<
-    SchemaField.InnerAssignmentType<DataModel.SchemaOfClass<DocumentType>>,
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
+    SchemaField.AssignmentData<DataModel.SchemaOfClass<DocumentType>>,
     MergedOptions<DocumentType, Opts>
   >;
 
@@ -2516,7 +2767,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>
   >;
 
@@ -2529,13 +2780,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
@@ -2549,7 +2800,8 @@ declare namespace EmbeddedDocumentField {
  * InitialValue: `null`
  */
 declare class DocumentIdField<
-  Options extends StringField.Options = DocumentIdField.DefaultOptions,
+  Options extends DocumentIdField.Options = DocumentIdField.DefaultOptions,
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   AssignmentType = DocumentIdField.AssignmentType<Options>,
   InitializedType = DocumentIdField.InitializedType<Options>,
   PersistedType extends string | null | undefined = DocumentIdField.InitializedType<Options>,
@@ -2572,7 +2824,7 @@ declare class DocumentIdField<
   /** @defaultValue `"is not a valid Document ID string"` */
   override validationError: string;
 
-  protected static override get _defaults(): StringField.Options;
+  protected static override get _defaults(): StringField.Options<unknown>;
 
   protected override _cast(value: AssignmentType): InitializedType;
 
@@ -2583,7 +2835,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,
     {
@@ -2600,13 +2856,17 @@ 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 StringField.Options> = 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
+   *
+   * @deprecated - AssignmentType is being deprecated. See {@link SchemaField.AssignmentData | `SchemaField.AssignmentData`}
+   * for more details.
    */
-  type AssignmentType<Options extends StringField.Options> = DataField.DerivedAssignmentType<
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
+  type AssignmentType<Options extends StringField.Options<unknown>> = DataField.DerivedAssignmentType<
     string | Document.Any,
     MergedOptions<Options>
   >;
@@ -2615,18 +2875,19 @@ 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 StringField.Options> = 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<
   const Options extends DocumentUUIDField.Options = DocumentUUIDField.DefaultOptions,
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   const AssignmentType = StringField.AssignmentType<Options>,
   const InitializedType = StringField.InitializedType<Options>,
   const PersistedType extends string | null | undefined = StringField.InitializedType<Options>,
@@ -2720,7 +2981,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
@@ -2737,6 +2998,7 @@ declare namespace DocumentUUIDField {
 declare class ForeignDocumentField<
   DocumentType extends Document.AnyConstructor,
   Options extends ForeignDocumentField.Options = ForeignDocumentField.DefaultOptions,
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   AssignmentType = ForeignDocumentField.AssignmentType<DocumentType, Options>,
   InitializedType = ForeignDocumentField.InitializedType<DocumentType, Options>,
   PersistedType extends string | null | undefined = ForeignDocumentField.PersistedType<Options>,
@@ -2776,13 +3038,13 @@ declare class ForeignDocumentField<
 
 declare namespace ForeignDocumentField {
   /** The options for the ForeignDocumentField class. */
-  type Options = StringField.Options &
-    DataField.Options<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,
     {
@@ -2801,10 +3063,14 @@ declare namespace ForeignDocumentField {
   /**
    * A shorthand for the assignment type of a ForeignDocumentField class.
    * @typeParam Opts - the options that override the default options
+   *
+   * @deprecated - AssignmentType is being deprecated. See {@link SchemaField.AssignmentData | `SchemaField.AssignmentData`}
+   * for more details.
    */
   type AssignmentType<
     ConcreteDocument extends Document.AnyConstructor,
     Opts extends Options,
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
   > = DataField.DerivedAssignmentType<string | Document.ToConfiguredInstance<ConcreteDocument>, MergedOptions<Opts>>;
 
   /**
@@ -2827,7 +3093,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
@@ -2841,6 +3107,7 @@ declare namespace ForeignDocumentField {
  */
 declare class ColorField<
   Options extends StringField.Options = ColorField.DefaultOptions,
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   AssignmentType = ColorField.AssignmentType<Options>,
   InitializedType = ColorField.InitializedType<Options>,
   PersistedType extends string | null | undefined = ColorField.PersistedType<Options>,
@@ -2868,7 +3135,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,
     {
@@ -2888,7 +3155,11 @@ declare namespace ColorField {
   /**
    * A shorthand for the assignment type of a ColorField class.
    * @typeParam Options - the options that override the default options
+   *
+   * @deprecated - AssignmentType is being deprecated. See {@link SchemaField.AssignmentData | `SchemaField.AssignmentData`}
+   * for more details.
    */
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   type AssignmentType<Options extends StringField.Options> = DataField.DerivedAssignmentType<
     string,
     MergedOptions<Options>
@@ -2914,7 +3185,7 @@ declare namespace ColorField {
 }
 
 /**
- * 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
@@ -2928,6 +3199,7 @@ declare namespace ColorField {
  */
 declare class FilePathField<
   Options extends FilePathField.Options = FilePathField.DefaultOptions,
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   AssignmentType = FilePathField.AssignmentType<Options>,
   InitializedType = FilePathField.InitializedType<Options>,
   PersistedType extends string | null | undefined = FilePathField.InitializedType<Options>,
@@ -2975,7 +3247,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,
     {
@@ -3017,7 +3289,11 @@ declare namespace FilePathField {
   /**
    * A shorthand for the assignment type of a FilePathField class.
    * @typeParam Options - the options that override the default options
+   *
+   * @deprecated - AssignmentType is being deprecated. See {@link SchemaField.AssignmentData | `SchemaField.AssignmentData`}
+   * for more details.
    */
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   type AssignmentType<Options extends StringField.Options> = DataField.DerivedAssignmentType<
     string,
     MergedOptions<Options>
@@ -3034,7 +3310,7 @@ declare namespace FilePathField {
 }
 
 /**
- * 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
@@ -3048,6 +3324,7 @@ declare namespace FilePathField {
  */
 declare class AngleField<
   Options extends NumberField.Options = AngleField.DefaultOptions,
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   AssignmentType = AngleField.AssignmentType<Options>,
   InitializedType = AngleField.InitializedType<Options>,
   PersistedType extends number | null | undefined = AngleField.InitializedType<Options>,
@@ -3079,7 +3356,7 @@ declare class AngleField<
 }
 
 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,
     {
@@ -3102,7 +3379,11 @@ declare namespace AngleField {
   /**
    * A shorthand for the assignment type of a AngleField class.
    * @typeParam Options - the options that override the default options
+   *
+   * @deprecated - AssignmentType is being deprecated. See {@link SchemaField.AssignmentData | `SchemaField.AssignmentData`}
+   * for more details.
    */
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   type AssignmentType<Options extends NumberField.Options> = DataField.DerivedAssignmentType<
     number,
     MergedOptions<Options>
@@ -3119,7 +3400,7 @@ declare namespace AngleField {
 }
 
 /**
- * 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
@@ -3133,6 +3414,7 @@ declare namespace AngleField {
  */
 declare class AlphaField<
   Options extends NumberField.Options = AlphaField.DefaultOptions,
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   AssignmentType = AlphaField.AssignmentType<Options>,
   InitializedType = AlphaField.InitializedType<Options>,
   PersistedType extends number | null | undefined = AlphaField.InitializedType<Options>,
@@ -3159,7 +3441,7 @@ declare class AlphaField<
 }
 
 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,
     {
@@ -3181,7 +3463,11 @@ declare namespace AlphaField {
   /**
    * A shorthand for the assignment type of a AlphaField class.
    * @typeParam Options - the options that override the default options
+   *
+   * @deprecated - AssignmentType is being deprecated. See {@link SchemaField.AssignmentData | `SchemaField.AssignmentData`}
+   * for more details.
    */
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   type AssignmentType<Options extends NumberField.Options> = DataField.DerivedAssignmentType<
     number,
     MergedOptions<Options>
@@ -3198,11 +3484,12 @@ declare namespace AlphaField {
 }
 
 /**
- * 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 NumberField.Options = NumberField.DefaultOptions,
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   const AssignmentType = NumberField.AssignmentType<Options>,
   const InitializedType = NumberField.InitializedType<Options>,
   const PersistedType extends number | null | undefined = NumberField.InitializedType<Options>,
@@ -3229,7 +3516,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
@@ -3243,6 +3530,7 @@ declare namespace HueField {
  */
 declare class DocumentOwnershipField<
   Options extends DocumentOwnershipField.Options = DocumentOwnershipField.DefaultOptions,
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   AssignmentType = DocumentOwnershipField.AssignmentType<Options>,
   InitializedType = DocumentOwnershipField.InitializedType<Options>,
   PersistedType extends
@@ -3268,7 +3556,7 @@ declare namespace DocumentOwnershipField {
   /** A shorthand for the options of a DocumentOwnershipField class. */
   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,
     {
@@ -3286,7 +3574,11 @@ declare namespace DocumentOwnershipField {
   /**
    * A shorthand for the assignment type of a ObjectField class.
    * @typeParam Opts - the options that override the default options
+   *
+   * @deprecated - AssignmentType is being deprecated. See {@link SchemaField.AssignmentData | `SchemaField.AssignmentData`}
+   * for more details.
    */
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   type AssignmentType<Opts extends Options> = DataField.DerivedAssignmentType<
     Record<string, DOCUMENT_OWNERSHIP_LEVELS>,
     MergedOptions<Opts>
@@ -3303,7 +3595,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
@@ -3318,6 +3610,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 StringField.Options = JSONField.DefaultOptions,
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   AssignmentType = JSONField.AssignmentType<Options>,
   InitializedType = JSONField.InitializedType<Options>,
   PersistedType extends string | null | undefined = JSONField.PersistedType<Options>,
@@ -3376,7 +3669,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,
     {
@@ -3395,7 +3688,11 @@ declare namespace JSONField {
   /**
    * A shorthand for the assignment type of a JSONField class.
    * @typeParam Options - the options that override the default options
+   *
+   * @deprecated - AssignmentType is being deprecated. See {@link SchemaField.AssignmentData | `SchemaField.AssignmentData`}
+   * for more details.
    */
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   type AssignmentType<Options extends StringField.Options> = DataField.DerivedAssignmentType<
     string,
     MergedOptions<Options>
@@ -3421,7 +3718,7 @@ declare namespace JSONField {
 }
 
 /**
- * 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.
  */
@@ -3436,7 +3733,7 @@ declare class AnyField extends DataField<DataField.Options.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
@@ -3452,6 +3749,7 @@ declare class AnyField extends DataField<DataField.Options.Any, unknown, unknown
  */
 declare class HTMLField<
   Options extends StringField.Options = HTMLField.DefaultOptions,
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   AssignmentType = HTMLField.AssignmentType<Options>,
   InitializedType = HTMLField.InitializedType<Options>,
   PersistedType extends string | null | undefined = HTMLField.InitializedType<Options>,
@@ -3490,7 +3788,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,
     {
@@ -3508,7 +3806,11 @@ declare namespace HTMLField {
   /**
    * A shorthand for the assignment type of a HTMLField class.
    * @typeParam Options - the options that override the default options
+   *
+   * @deprecated - AssignmentType is being deprecated. See {@link SchemaField.AssignmentData | `SchemaField.AssignmentData`}
+   * for more details.
    */
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   type AssignmentType<Options extends StringField.Options> = DataField.DerivedAssignmentType<
     string,
     MergedOptions<Options>
@@ -3528,7 +3830,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
@@ -3542,6 +3844,7 @@ declare namespace HTMLField {
  */
 declare class IntegerSortField<
   Options extends NumberField.Options = IntegerSortField.DefaultOptions,
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   AssignmentType = IntegerSortField.AssignmentType<Options>,
   InitializedType = IntegerSortField.InitializedType<Options>,
   PersistedType extends number | null | undefined = IntegerSortField.InitializedType<Options>,
@@ -3566,7 +3869,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,
     {
@@ -3588,7 +3891,11 @@ declare namespace IntegerSortField {
   /**
    * A shorthand for the assignment type of a IntegerSortField class.
    * @typeParam Options - the options that override the default options
+   *
+   * @deprecated - AssignmentType is being deprecated. See {@link SchemaField.AssignmentData | `SchemaField.AssignmentData`}
+   * for more details.
    */
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   type AssignmentType<Options extends NumberField.Options> = DataField.DerivedAssignmentType<
     number,
     MergedOptions<Options>
@@ -3605,7 +3912,7 @@ declare namespace IntegerSortField {
 }
 
 /**
- * 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
@@ -3629,6 +3936,7 @@ declare namespace IntegerSortField {
  */
 declare class DocumentStatsField<
   Options extends DocumentStatsField.Options = DocumentStatsField.DefaultOptions,
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   AssignmentType = DocumentStatsField.AssignmentType<Options>,
   InitializedType = DocumentStatsField.InitializedType<Options>,
   PersistedType extends AnyObject | null | undefined = DocumentStatsField.PersistedType<Options>,
@@ -3638,13 +3946,15 @@ declare class DocumentStatsField<
 
 declare namespace DocumentStatsField {
   /** A shorthand for the options of a DocumentStatsField class. */
-  type Options = DataField.Options<SchemaField.InnerAssignmentType<Schema>>;
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
+  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. */
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
+  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>;
@@ -3652,9 +3962,14 @@ declare namespace DocumentStatsField {
   /**
    * A shorthand for the assignment type of a DocumentStatsField class.
    * @typeParam Opts - the options that override the default options
+   *
+   * @deprecated - AssignmentType is being deprecated. See {@link SchemaField.AssignmentData | `SchemaField.AssignmentData`}
+   * for more details.
    */
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   type AssignmentType<Opts extends Options = DefaultOptions> = DataField.DerivedAssignmentType<
-    SchemaField.InnerAssignmentType<Schema>,
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
+    SchemaField.AssignmentData<Schema>,
     MergedOptions<Opts>
   >;
 
@@ -3663,7 +3978,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>
   >;
 
@@ -3672,13 +3987,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 {
     /**
@@ -3723,11 +4049,12 @@ 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,
   const Options extends DocumentTypeField.Options = DocumentTypeField.DefaultOptions,
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   const AssignmentType = DocumentTypeField.AssignmentType<ConcreteDocumentClass, Options>,
   const InitializedType = DocumentTypeField.InitializedType<ConcreteDocumentClass, Options>,
   const PersistedType extends string | null | undefined = DocumentTypeField.InitializedType<
@@ -3756,7 +4083,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,
     {
@@ -3780,14 +4107,21 @@ declare namespace DocumentTypeField {
     }
   >;
 
+  /**
+   * @deprecated - AssignmentType is being deprecated. See {@link SchemaField.AssignmentData | `SchemaField.AssignmentData`}
+   * for more details.
+   */
   type AssignmentType<
     ConcreteDocumentClass extends Document.AnyConstructor,
     Options extends StringField.Options,
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
   > = StringField.AssignmentType<MergedOptions<ConcreteDocumentClass, Options>>;
+
   type InitializedType<
     ConcreteDocumentClass extends Document.AnyConstructor,
     Options extends StringField.Options,
   > = StringField.InitializedType<MergedOptions<ConcreteDocumentClass, Options>>;
+
   type PersistedType<
     ConcreteDocumentClass extends Document.AnyConstructor,
     Options extends StringField.Options,
@@ -3795,7 +4129,7 @@ declare namespace DocumentTypeField {
 }
 
 /**
- * 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
@@ -3811,6 +4145,7 @@ declare namespace DocumentTypeField {
 declare class TypeDataField<
   const SystemDocument extends Document.SystemConstructor,
   const Options extends TypeDataField.Options<SystemDocument> = TypeDataField.DefaultOptions,
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   const AssignmentType = TypeDataField.AssignmentType<SystemDocument, Options>,
   const InitializedType = TypeDataField.InitializedType<SystemDocument, Options>,
   const PersistedType extends AnyObject | null | undefined = TypeDataField.PersistedType<SystemDocument, Options>,
@@ -3885,10 +4220,11 @@ declare namespace TypeDataField {
    * @typeParam DocumentType - the type of the embedded Document
    */
   type Options<DocumentType extends Document.SystemConstructor> = DataField.Options<
-    SchemaField.InnerAssignmentType<DataModel.SchemaOfClass<DocumentType>>
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
+    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,
     {
@@ -3914,10 +4250,14 @@ declare namespace TypeDataField {
    * A shorthand for the assignment type of a TypeDataField class.
    * @typeParam DocumentType - the type of the embedded Document
    * @typeParam Options - the options that override the default options
+   *
+   * @deprecated - AssignmentType is being deprecated. See {@link SchemaField.AssignmentData | `SchemaField.AssignmentData`}
+   * for more details.
    */
   type AssignmentType<
     SystemDocumentConstructor extends Document.SystemConstructor,
     Opts extends Options<SystemDocumentConstructor>,
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
   > = DataField.DerivedAssignmentType<AnyObject, MergedOptions<SystemDocumentConstructor, Opts>>;
 
   /**
@@ -3929,27 +4269,14 @@ declare namespace TypeDataField {
     SystemDocumentConstructor extends Document.SystemConstructor,
     Opts extends Options<SystemDocumentConstructor>,
   > = DataField.DerivedInitializedType<
-    _Instances<DataModelsFor<SystemDocumentConstructor["metadata"]["name"]>> | UnknownSystem,
+    _Instances<DataModelsFor<SystemDocumentConstructor["metadata"]["name"]>> | Document.UnknownSystem,
     MergedOptions<SystemDocumentConstructor, Opts>
   >;
 
+  /** @internal */
   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}`;
-  }
+    [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.
@@ -3961,21 +4288,6 @@ 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
@@ -3988,11 +4300,12 @@ declare namespace TypeDataField {
 }
 
 /**
- * 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.Options<Types> = TypedSchemaField.DefaultOptions,
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   const AssignmentType = TypedSchemaField.AssignmentType<Types, Options>,
   const InitializedType = TypedSchemaField.InitializedType<Types, Options>,
   const PersistedType = TypedSchemaField.PersistedType<Types, Options>,
@@ -4088,12 +4401,18 @@ declare namespace TypedSchemaField {
    * @internal
    */
   type _AssignmentType<Types extends ConfiguredTypes> = {
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
     [K in keyof Types]: DataField.AssignmentTypeFor<Types[K]> & { type: K };
   }[keyof Types];
 
+  /**
+   * @deprecated - AssignmentType is being deprecated. See {@link SchemaField.AssignmentData | `SchemaField.AssignmentData`}
+   * for more details.
+   */
   type AssignmentType<
     Types extends TypedSchemaField.Types,
     Options extends TypedSchemaField.Options<Types>,
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
   > = DataField.DerivedAssignmentType<_AssignmentType<ToConfiguredTypes<Types>>, Options>;
 
   /**
@@ -4159,6 +4478,7 @@ declare namespace ModelValidationError {
 // directives that could mask other errors.
 declare class _InternalJavaScriptField<
   const Options extends JavaScriptField.Options = JavaScriptField.DefaultOptions,
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   const AssignmentType = StringField.AssignmentType<Options>,
   const InitializedType = StringField.InitializedType<Options>,
   const PersistedType extends string | null | undefined = StringField.InitializedType<Options>,
@@ -4169,10 +4489,11 @@ 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,
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   const AssignmentType = StringField.AssignmentType<Options>,
   const InitializedType = StringField.InitializedType<Options>,
   const PersistedType extends string | null | undefined = StringField.InitializedType<Options>,