@league-of-foundry-developers/foundry-vtt-types 13.346.0-beta.20250709002914 → 13.346.0-beta.20250709090128

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@league-of-foundry-developers/foundry-vtt-types",
-  "version": "13.346.0-beta.20250709002914",
+  "version": "13.346.0-beta.20250709090128",
   "description": "TypeScript type definitions for Foundry VTT",
   "type": "module",
   "types": "./src/index.d.mts",

package/src/configuration/configuration.d.mts

@@ -348,3 +348,41 @@ export interface SettingConfig {
  */
 // eslint-disable-next-line @typescript-eslint/no-empty-object-type
 export interface SystemNameConfig {}
+
+/**
+ * Controls various behaviors of `system`. By default fvtt-types forces you to account for all
+ * possible subtypes of a document. This helps make your code more robust for things like the
+ * arbitrary module subtypes that may exist. This is why if you try writing `item.system.someProp`
+ * you are going to get an error like:
+ * ```text
+ * Property 'someProp' does not exist on type 'SystemOfType<...>'.
+ *   Property 'someProp' does not exist on type 'UnknownTypeDataModel'.
+ * ```
+ *
+ * While inconvenient this is necessary for soundness. As a module subtype is designed to be
+ * completely arbitrary they could have a conflicting property with any shape. Therefore it's
+ * recommended to work around this with helpers that make it easier to actually account for module
+ * subtypes like an `isKnown` helper etc. but if you want to tweak the behavior for certain classes
+ * you can add `discriminate: "all"` which will make `item.system.someProp` be typed as
+ * `T | undefined`.
+ *
+ * Even more unsoundly, you can entirely ignore the existence of module subtypes and `"base"`
+ * entirely with `moduleSubtype: "ignore"` and `base: "ignore"`.
+ *
+ * @example
+ * ```typescript
+ * declare module "fvtt-types/configuration" {
+ *   interface SystemConfig {
+ *     Item: {
+ *       discriminate: "all";
+ *     };
+ *     Actor: {
+ *        moduleSubtype: "ignore";
+ *        base: "ignore";
+ *     };
+ *   }
+ * }
+ * ```
+ */
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+export interface SystemConfig {}

package/src/foundry/client/documents/active-effect.d.mts

@@ -101,7 +101,7 @@ declare namespace ActiveEffect {
    * builtin `ActiveEffect` class or a custom subclass if that is set up in
    * {@link ConfiguredActiveEffect | `fvtt-types/configuration/ConfiguredActiveEffect`}.
    */
-  type OfType<Type extends SubType> = _OfType[Type];
+  type OfType<Type extends SubType> = Document.Internal.DiscriminateSystem<Name, _OfType, Type, ConfiguredSubTypes>;
 
   /** @internal */
   interface _OfType
@@ -117,7 +117,7 @@ declare namespace ActiveEffect {
   /**
    * `SystemOfType` returns the system property for a specific `ActiveEffect` subtype.
    */
-  type SystemOfType<Type extends SubType> = Document.Internal.SystemOfType<_SystemMap, Type>;
+  type SystemOfType<Type extends SubType> = Document.Internal.SystemOfType<Name, _SystemMap, Type, ConfiguredSubTypes>;
 
   /**
    * @internal

package/src/foundry/client/documents/actor-delta.d.mts

@@ -98,7 +98,7 @@ declare namespace ActorDelta {
    * builtin `ActorDelta` class or a custom subclass if that is set up in
    * {@link ConfiguredActorDelta | `fvtt-types/configuration/ConfiguredActorDelta`}.
    */
-  type OfType<Type extends SubType> = _OfType[Type];
+  type OfType<Type extends SubType> = Document.Internal.DiscriminateSystem<Name, _OfType, Type, ConfiguredSubTypes>;
 
   /** @internal */
   interface _OfType
@@ -114,7 +114,7 @@ declare namespace ActorDelta {
   /**
    * `SystemOfType` returns the system property for a specific `ActorDelta` subtype.
    */
-  type SystemOfType<Type extends SubType> = Document.Internal.SystemOfType<_SystemMap, Type>;
+  type SystemOfType<Type extends SubType> = Document.Internal.SystemOfType<Name, _SystemMap, Type, ConfiguredSubTypes>;
 
   /**
    * @internal

package/src/foundry/client/documents/actor.d.mts

@@ -109,7 +109,7 @@ declare namespace Actor {
    * builtin `Actor` class or a custom subclass if that is set up in
    * {@link ConfiguredActor | `fvtt-types/configuration/ConfiguredActor`}.
    */
-  type OfType<Type extends SubType> = _OfType[Type];
+  type OfType<Type extends SubType> = Document.Internal.DiscriminateSystem<Name, _OfType, Type, ConfiguredSubTypes>;
 
   /** @internal */
   interface _OfType
@@ -125,7 +125,7 @@ declare namespace Actor {
   /**
    * `SystemOfType` returns the system property for a specific `Actor` subtype.
    */
-  type SystemOfType<Type extends SubType> = Document.Internal.SystemOfType<_SystemMap, Type>;
+  type SystemOfType<Type extends SubType> = Document.Internal.SystemOfType<Name, _SystemMap, Type, ConfiguredSubTypes>;
 
   /**
    * @internal

package/src/foundry/client/documents/card.d.mts

@@ -99,7 +99,7 @@ declare namespace Card {
    * builtin `Card` class or a custom subclass if that is set up in
    * {@link ConfiguredCard | `fvtt-types/configuration/ConfiguredCard`}.
    */
-  type OfType<Type extends SubType> = _OfType[Type];
+  type OfType<Type extends SubType> = Document.Internal.DiscriminateSystem<Name, _OfType, Type, ConfiguredSubTypes>;
 
   /** @internal */
   interface _OfType
@@ -115,7 +115,7 @@ declare namespace Card {
   /**
    * `SystemOfType` returns the system property for a specific `Card` subtype.
    */
-  type SystemOfType<Type extends SubType> = Document.Internal.SystemOfType<_SystemMap, Type>;
+  type SystemOfType<Type extends SubType> = Document.Internal.SystemOfType<Name, _SystemMap, Type, ConfiguredSubTypes>;
 
   /**
    * @internal

package/src/foundry/client/documents/cards.d.mts

@@ -104,7 +104,7 @@ declare namespace Cards {
    * builtin `Cards` class or a custom subclass if that is set up in
    * {@link ConfiguredCards | `fvtt-types/configuration/ConfiguredCards`}.
    */
-  type OfType<Type extends SubType> = _OfType[Type];
+  type OfType<Type extends SubType> = Document.Internal.DiscriminateSystem<Name, _OfType, Type, ConfiguredSubTypes>;
 
   /** @internal */
   interface _OfType
@@ -120,7 +120,7 @@ declare namespace Cards {
   /**
    * `SystemOfType` returns the system property for a specific `Cards` subtype.
    */
-  type SystemOfType<Type extends SubType> = Document.Internal.SystemOfType<_SystemMap, Type>;
+  type SystemOfType<Type extends SubType> = Document.Internal.SystemOfType<Name, _SystemMap, Type, ConfiguredSubTypes>;
 
   /**
    * @internal

package/src/foundry/client/documents/chat-message.d.mts

@@ -98,7 +98,7 @@ declare namespace ChatMessage {
    * builtin `ChatMessage` class or a custom subclass if that is set up in
    * {@link ConfiguredChatMessage | `fvtt-types/configuration/ConfiguredChatMessage`}.
    */
-  type OfType<Type extends SubType> = _OfType[Type];
+  type OfType<Type extends SubType> = Document.Internal.DiscriminateSystem<Name, _OfType, Type, ConfiguredSubTypes>;
 
   /** @internal */
   interface _OfType
@@ -114,7 +114,7 @@ declare namespace ChatMessage {
   /**
    * `SystemOfType` returns the system property for a specific `ChatMessage` subtype.
    */
-  type SystemOfType<Type extends SubType> = Document.Internal.SystemOfType<_SystemMap, Type>;
+  type SystemOfType<Type extends SubType> = Document.Internal.SystemOfType<Name, _SystemMap, Type, ConfiguredSubTypes>;
 
   /**
    * @internal

package/src/foundry/client/documents/combat.d.mts

@@ -105,7 +105,7 @@ declare namespace Combat {
    * builtin `Combat` class or a custom subclass if that is set up in
    * {@link ConfiguredCombat | `fvtt-types/configuration/ConfiguredCombat`}.
    */
-  type OfType<Type extends SubType> = _OfType[Type];
+  type OfType<Type extends SubType> = Document.Internal.DiscriminateSystem<Name, _OfType, Type, ConfiguredSubTypes>;
 
   /** @internal */
   interface _OfType
@@ -121,7 +121,7 @@ declare namespace Combat {
   /**
    * `SystemOfType` returns the system property for a specific `Combat` subtype.
    */
-  type SystemOfType<Type extends SubType> = Document.Internal.SystemOfType<_SystemMap, Type>;
+  type SystemOfType<Type extends SubType> = Document.Internal.SystemOfType<Name, _SystemMap, Type, ConfiguredSubTypes>;
 
   /**
    * @internal

package/src/foundry/client/documents/combatant-group.d.mts

@@ -81,7 +81,7 @@ declare namespace CombatantGroup {
    * builtin `CombatantGroup` class or a custom subclass if that is set up in
    * {@link ConfiguredCombatantGroup | `fvtt-types/configuration/ConfiguredCombatantGroup`}.
    */
-  type OfType<Type extends SubType> = _OfType[Type];
+  type OfType<Type extends SubType> = Document.Internal.DiscriminateSystem<Name, _OfType, Type, ConfiguredSubTypes>;
 
   /** @internal */
   interface _OfType
@@ -97,7 +97,7 @@ declare namespace CombatantGroup {
   /**
    * `SystemOfType` returns the system property for a specific `CombatantGroup` subtype.
    */
-  type SystemOfType<Type extends SubType> = Document.Internal.SystemOfType<_SystemMap, Type>;
+  type SystemOfType<Type extends SubType> = Document.Internal.SystemOfType<Name, _SystemMap, Type, ConfiguredSubTypes>;
 
   /**
    * @internal

package/src/foundry/client/documents/combatant.d.mts

@@ -99,7 +99,7 @@ declare namespace Combatant {
    * builtin `Combatant` class or a custom subclass if that is set up in
    * {@link ConfiguredCombatant | `fvtt-types/configuration/ConfiguredCombatant`}.
    */
-  type OfType<Type extends SubType> = _OfType[Type];
+  type OfType<Type extends SubType> = Document.Internal.DiscriminateSystem<Name, _OfType, Type, ConfiguredSubTypes>;
 
   /** @internal */
   interface _OfType
@@ -115,7 +115,7 @@ declare namespace Combatant {
   /**
    * `SystemOfType` returns the system property for a specific `Combatant` subtype.
    */
-  type SystemOfType<Type extends SubType> = Document.Internal.SystemOfType<_SystemMap, Type>;
+  type SystemOfType<Type extends SubType> = Document.Internal.SystemOfType<Name, _SystemMap, Type, ConfiguredSubTypes>;
 
   /**
    * @internal

package/src/foundry/client/documents/folder.d.mts

@@ -91,6 +91,7 @@ declare namespace Folder {
    * Note that `Folder` does not have a `system` property and therefore there is no way for a user
    * to configure custom subtypes. See {@linkcode Folder.SubType} for more information.
    */
+  // Note(LukeAbby): The lack of a `system` is why `Document.Internal.DiscriminateSystem` isn't applied.
   type OfType<Type extends SubType> = _OfType[Type];
 
   /** @internal */

package/src/foundry/client/documents/item.d.mts

@@ -106,7 +106,7 @@ declare namespace Item {
    * builtin `Item` class or a custom subclass if that is set up in
    * {@link ConfiguredItem | `fvtt-types/configuration/ConfiguredItem`}.
    */
-  type OfType<Type extends SubType> = _OfType[Type];
+  type OfType<Type extends SubType> = Document.Internal.DiscriminateSystem<Name, _OfType, Type, ConfiguredSubTypes>;
 
   /** @internal */
   interface _OfType
@@ -122,7 +122,7 @@ declare namespace Item {
   /**
    * `SystemOfType` returns the system property for a specific `Item` subtype.
    */
-  type SystemOfType<Type extends SubType> = Document.Internal.SystemOfType<_SystemMap, Type>;
+  type SystemOfType<Type extends SubType> = Document.Internal.SystemOfType<Name, _SystemMap, Type, ConfiguredSubTypes>;
 
   /**
    * @internal

package/src/foundry/client/documents/journal-entry-page.d.mts

@@ -98,7 +98,7 @@ declare namespace JournalEntryPage {
    * {@link ConfiguredJournalEntryPage | `fvtt-types/configuration/ConfiguredJournalEntryPage`}.
    * up.
    */
-  type OfType<Type extends SubType> = _OfType[Type];
+  type OfType<Type extends SubType> = Document.Internal.DiscriminateSystem<Name, _OfType, Type, ConfiguredSubTypes>;
 
   /** @internal */
   interface _OfType
@@ -114,7 +114,7 @@ declare namespace JournalEntryPage {
   /**
    * `SystemOfType` returns the system property for a specific `JournalEntryPage` subtype.
    */
-  type SystemOfType<Type extends SubType> = Document.Internal.SystemOfType<_SystemMap, Type>;
+  type SystemOfType<Type extends SubType> = Document.Internal.SystemOfType<Name, _SystemMap, Type, ConfiguredSubTypes>;
 
   /**
    * @internal

package/src/foundry/client/documents/macro.d.mts

@@ -101,6 +101,7 @@ declare namespace Macro {
    * Note that `Macro` does not have a `system` property and therefore there is no way for a user
    * to configure custom subtypes. See {@linkcode Macro.SubType} for more information.
    */
+  // Note(LukeAbby): The lack of a `system` is why `Document.Internal.DiscriminateSystem` isn't applied.
   type OfType<Type extends SubType> = _OfType[Type];
 
   /** @internal */

package/src/foundry/client/documents/region-behavior.d.mts

@@ -107,7 +107,7 @@ declare namespace RegionBehavior {
    * builtin `RegionBehavior` class or a custom subclass if that is set up in
    * {@link ConfiguredRegionBehavior | `fvtt-types/configuration/ConfiguredRegionBehavior`}.
    */
-  type OfType<Type extends SubType> = _OfType[Type];
+  type OfType<Type extends SubType> = Document.Internal.DiscriminateSystem<Name, _OfType, Type, ConfiguredSubTypes>;
 
   /** @internal */
   interface _OfType
@@ -123,7 +123,7 @@ declare namespace RegionBehavior {
   /**
    * `SystemOfType` returns the system property for a specific `RegionBehavior` subtype.
    */
-  type SystemOfType<Type extends SubType> = Document.Internal.SystemOfType<_SystemMap, Type>;
+  type SystemOfType<Type extends SubType> = Document.Internal.SystemOfType<Name, _SystemMap, Type, ConfiguredSubTypes>;
 
   /**
    * @internal

package/src/foundry/client/documents/table-result.d.mts

@@ -95,6 +95,7 @@ declare namespace TableResult {
    * Note that `TableResult` does not have a `system` property and therefore there is no way for a user
    * to configure custom subtypes. See {@linkcode TableResult.SubType} for more information.
    */
+  // Note(LukeAbby): The lack of a `system` is why `Document.Internal.DiscriminateSystem` isn't applied.
   type OfType<Type extends SubType> = _OfType[Type];
 
   /** @internal */

package/src/foundry/common/abstract/document.d.mts

@@ -21,9 +21,10 @@ import type {
   Brand,
   AnyMutableObject,
   MaybePromise,
-  Override,
   SimpleMerge,
   PrettifyType,
+  AllKeysOf,
+  Override,
 } from "#utils";
 import type * as CONST from "../constants.mts";
 import type {
@@ -47,6 +48,7 @@ import type {
 import type DataModel from "./data.mts";
 import type DocumentSocketResponse from "./socket.d.mts";
 import type EmbeddedCollection from "./embedded-collection.d.mts";
+import type { SystemConfig } from "#configuration";
 
 export default Document;
 
@@ -966,8 +968,15 @@ declare namespace Document {
     | "JournalEntryPage"
     | "RegionBehavior";
 
-  type CoreTypesForName<Name extends Type> = string &
-    GetKey<Document.MetadataFor<Name>, "coreTypes", [CONST.BASE_DOCUMENT_TYPE]>[number];
+  type CoreTypesForName<Name extends Type> = _CoreTypes<
+    Name,
+    string & GetKey<Document.MetadataFor<Name>, "coreTypes", [CONST.BASE_DOCUMENT_TYPE]>[number]
+  >;
+
+  /** @internal */
+  type _CoreTypes<Name extends Type, Types> = SystemConfig extends { [_ in Name]: { readonly base: "ignore" } }
+    ? Exclude<Types, "base">
+    : Types;
 
   type ConfiguredSubTypesOf<Name extends Type> = Name extends "ActorDelta"
     ? ConfiguredSubTypesOf<"Actor">
@@ -976,12 +985,18 @@ declare namespace Document {
       // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents, @typescript-eslint/no-duplicate-type-constituents
       string & (keyof GetKey<DataModelConfig, Name, unknown> | keyof GetKey<SourceConfig, Name, unknown>);
 
-  type SubTypesOf<Name extends Type> = Name extends "ActorDelta"
+  type SubTypesOf<Name extends Document.Type> = Name extends "ActorDelta"
     ? SubTypesOf<"Actor">
-    :
-        | Document.CoreTypesForName<Name>
-        | ConfiguredSubTypesOf<Name>
-        | (Document.MetadataFor<Name> extends { readonly hasTypeData: true } ? Document.ModuleSubType : never);
+    : Document.CoreTypesForName<Name> | ConfiguredSubTypesOf<Name> | _ModuleSubType<Name>;
+
+  /** @internal */
+  type _ModuleSubType<Name extends Type> = SystemConfig extends {
+    [_ in Name]: { readonly moduleSubType: "ignore" };
+  }
+    ? never
+    : Document.MetadataFor<Name> extends { readonly hasTypeData: true }
+      ? Document.ModuleSubType
+      : never;
 
   type ModuleSubType = Brand<`${string}.${string}`, "Document.ModuleSubtype">;
 
@@ -1135,19 +1150,31 @@ declare namespace Document {
       GetKey<SourceConfig, Name, {}>
     > &
       // `Document.ModuleSubType` has to be accounted for specially because of its perculiar nature.
-      Record<Document.ModuleSubType, UnknownSystem>;
+      Record<Document.ModuleSubType, _ModuleSubTypeFor<Name>>;
+
+    type _ModuleSubTypeFor<Name extends Document.WithSubTypes> = SystemConfig extends {
+      readonly [_ in Name]: { readonly moduleSubtype: "ignore" };
+    }
+      ? never
+      : // The `Extract<..., object>` serves a dual purpose:
+        // 1) Get rid of `| undefined` for optional subtypes.
+        // 2) Make sure it's obvious to TypeScript `system` is always an object.
+        Extract<GetKey<GetKey<DataModelConfig, Name, object>, Document.ModuleSubType, Document.UnknownSystem>, object>;
 
     // Note(LukeAbby): This is written this way to preserve any optional modifiers.
     type _ModelMap<Name extends Document.WithSubTypes, DataModel, Config> = PrettifyType<
       SimpleMerge<
         {
-          [SubType in keyof DataModel]: EmptyObject;
-        } & {
           [SubType in Document.CoreTypesForName<Name>]: EmptyObject;
         },
-        {
-          [SubType in keyof Config]: EmptyObject;
-        }
+        SimpleMerge<
+          {
+            [SubType in keyof DataModel]: EmptyObject;
+          },
+          {
+            [SubType in keyof Config]: EmptyObject;
+          }
+        >
       >
     >;
 
@@ -1160,31 +1187,47 @@ declare namespace Document {
       GetKey<DataConfig, Name, {}>
     > &
       // `Document.ModuleSubType` has to be accounted for specially because of its perculiar nature.
-      Record<Document.ModuleSubType, UnknownSystem>;
+      Record<Document.ModuleSubType, _ModuleSubTypeFor<Name>>;
 
     // Note(LukeAbby): This is written this way to preserve any optional modifiers.
-    type _SystemMap<Name extends Document.WithSubTypes, DataModel, Config> = PrettifyType<
+    type _SystemMap<Name extends Document.WithSubTypes, DataModel, DataConfig> = PrettifyType<
       SimpleMerge<
         {
-          [SubType in keyof DataModel]: DataModel[SubType] extends
-            | (abstract new (...args: never) => infer Model extends DataModel.Any)
-            | undefined
-            ? Model
-            : never;
-        } & {
           [SubType in Document.CoreTypesForName<Name>]: EmptyObject;
         },
-        {
-          [SubType in keyof Config]: Config[SubType];
-        }
+        SimpleMerge<
+          {
+            [SubType in keyof DataModel]: DataModel[SubType] extends
+              | (abstract new (...args: never) => infer Model extends DataModel.Any)
+              | undefined
+              ? Model
+              : never;
+          },
+          {
+            [SubType in keyof DataConfig]: DataConfig[SubType];
+          }
+        >
       >
     >;
 
-    type SystemOfType<SystemMap extends Record<SubType, object | undefined>, SubType extends string> = SubType extends
-      | ModuleSubType
-      | "base"
-      ? UnknownSystem
-      : DiscriminatedUnion<NonNullable<SystemMap[SubType]>>;
+    type SystemOfType<
+      Name extends Document.WithSystem,
+      SystemMap extends Record<SubType, object | undefined>,
+      SubType extends string,
+      ConfiguredSubTypes extends string,
+    > =
+      GetKey<SystemConfig, Name, "none"> extends "discriminateAll"
+        ? _DiscriminateUndefined<SystemMap[SubType]>
+        :
+            | ([Extract<SubType, ConfiguredSubTypes>] extends [never]
+                ? never
+                : _DiscriminateUndefined<SystemMap[Extract<SubType, ConfiguredSubTypes>]>)
+            | ([Exclude<SubType, ConfiguredSubTypes>] extends [never]
+                ? never
+                : SystemMap[Exclude<SubType, ConfiguredSubTypes>]);
+
+    /** @internal */
+    type _DiscriminateUndefined<T extends object | undefined> = DiscriminatedUnion<Exclude<T, undefined>>;
 
     // TODO(LukeAbby): Improve the type display with a helper here.
     // TODO(LukeAbby): Add `StoredSource` for a better type display there.
@@ -1208,6 +1251,52 @@ declare namespace Document {
       get invalid(): true;
     }
 
+    type DiscriminateSystem<
+      Name extends Document.WithSystem,
+      TypeMap extends Record<SubType, { system: object | undefined }>,
+      SubType extends string,
+      ConfiguredSubTypes extends string,
+    > = SystemConfig extends { readonly [_ in Name]: { readonly discriminate: "all" } }
+      ? _DiscriminateSystem<SubType, TypeMap>
+      :
+          | _DiscriminateSystem<Extract<SubType, ConfiguredSubTypes>, TypeMap>
+          | ([Exclude<SubType, ConfiguredSubTypes>] extends [never]
+              ? never
+              : TypeMap[Exclude<SubType, ConfiguredSubTypes>]);
+
+    type _DiscriminateSystem<
+      SubType extends AllSubType,
+      TypeMap extends Record<AllSubType, { system: object | undefined }>,
+      AllSubType extends string = SubType,
+    > = SubType extends unknown ? OfType<SubType, TypeMap, AllSubType> : never;
+
+    // Note(LukeAbby): This is named `OfType` to display as `Document.Internal.OfType` in quick info.
+    interface OfType<
+      OneSubType extends AllSubType,
+      TypeMap extends Record<AllSubType, { system: object | undefined }>,
+      AllSubType extends string,
+    > extends _Override<
+        TypeMap[OneSubType],
+        {
+          system: DiscriminatedSystem<
+            Exclude<TypeMap[OneSubType]["system"], undefined>,
+            Exclude<TypeMap[AllSubType]["system"], undefined>
+          >;
+        }
+      > {}
+
+    // @ts-expect-error This pattern is intrinsically an error.
+    interface _Override<Base extends object, OverrideWith extends object> extends OverrideWith, Base {}
+
+    /** @internal */
+    interface DiscriminatedSystem<System extends object, AllSystem extends object>
+      extends _Override<
+        {
+          [K in AllKeysOf<AllSystem>]?: never;
+        },
+        System
+      > {}
+
     interface DropData<DocumentType extends Document.Type> {
       /**
        * The data used to create a new document.

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

@@ -5181,7 +5181,8 @@ declare namespace TypeDataField {
     SystemDocumentConstructor extends Document.SystemConstructor,
     Opts extends Options<SystemDocumentConstructor>,
   > = DataField.DerivedInitializedType<
-    _Instances<DataModelsFor<SystemDocumentConstructor["metadata"]["name"]>> | Document.UnknownSystem,
+    | _Instances<DataModelsFor<SystemDocumentConstructor["metadata"]["name"]>>
+    | Document.Internal._ModuleSubTypeFor<SystemDocumentConstructor["metadata"]["name"]>,
     MergedOptions<SystemDocumentConstructor, Opts>
   >;
 

package/src/foundry/common/documents/item.d.mts

@@ -95,6 +95,8 @@ declare abstract class BaseItem<out SubType extends Item.SubType = Item.SubType>
 
   type: SubType;
 
+  aaaaa: SubType;
+
   /* Document overrides */
 
   // Same as Document for now