@league-of-foundry-developers/foundry-vtt-types 13.346.0-beta.20250715051532 → 13.346.0-beta.20250715141329

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.20250715051532",
+  "version": "13.346.0-beta.20250715141329",
   "description": "TypeScript type definitions for Foundry VTT",
   "type": "module",
   "types": "./src/index.d.mts",

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

@@ -81,27 +81,27 @@ declare namespace ActiveEffect {
   type SubType = foundry.Game.Model.TypeNames<"ActiveEffect">;
 
   /**
-   * `ConfiguredSubTypes` represents the subtypes a user explicitly registered. This excludes
+   * `ConfiguredSubType` represents the subtypes a user explicitly registered. This excludes
    * subtypes like the Foundry builtin subtype `"base"` and the catch-all subtype for arbitrary
    * module subtypes `${string}.${string}`.
    *
    * @see {@link SubType} for more information.
    */
-  type ConfiguredSubTypes = Document.ConfiguredSubTypesOf<"ActiveEffect">;
+  type ConfiguredSubType = Document.ConfiguredSubTypeOf<"ActiveEffect">;
 
   /**
    * `Known` represents the types of `ActiveEffect` that a user explicitly registered.
    *
-   * @see {@link ConfiguredSubTypes} for more information.
+   * @see {@link ConfiguredSubType} for more information.
    */
-  type Known = ActiveEffect.OfType<ActiveEffect.ConfiguredSubTypes>;
+  type Known = ActiveEffect.OfType<ActiveEffect.ConfiguredSubType>;
 
   /**
    * `OfType` returns an instance of `ActiveEffect` with the corresponding type. This works with both the
    * builtin `ActiveEffect` class or a custom subclass if that is set up in
    * {@link ConfiguredActiveEffect | `fvtt-types/configuration/ConfiguredActiveEffect`}.
    */
-  type OfType<Type extends SubType> = Document.Internal.DiscriminateSystem<Name, _OfType, Type, ConfiguredSubTypes>;
+  type OfType<Type extends SubType> = Document.Internal.DiscriminateSystem<Name, _OfType, Type, ConfiguredSubType>;
 
   /** @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<Name, _SystemMap, Type, ConfiguredSubTypes>;
+  type SystemOfType<Type extends SubType> = Document.Internal.SystemOfType<Name, _SystemMap, Type, ConfiguredSubType>;
 
   /**
    * @internal
@@ -665,6 +665,11 @@ declare namespace ActiveEffect {
    */
   // eslint-disable-next-line @typescript-eslint/no-deprecated
   type ConstructorArgs = Document.ConstructorParameters<CreateData, Parent>;
+
+  /**
+   * @deprecated Replaced with {@linkcode ActiveEffect.ConfiguredSubType} (will be removed in v14).
+   */
+  type ConfiguredSubTypes = ConfiguredSubType;
 }
 
 /**

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

@@ -78,27 +78,27 @@ declare namespace ActorDelta {
   type SubType = Actor.SubType;
 
   /**
-   * `ConfiguredSubTypes` represents the subtypes a user explicitly registered. This excludes
+   * `ConfiguredSubType` represents the subtypes a user explicitly registered. This excludes
    * subtypes like the Foundry builtin subtype `"base"` and the catch-all subtype for arbitrary
    * module subtypes `${string}.${string}`.
    *
    * @see {@linkcode ActorDelta.SubType} for more information.
    */
-  type ConfiguredSubTypes = Actor.SubType;
+  type ConfiguredSubType = Actor.SubType;
 
   /**
    * `Known` represents the types of `ActorDelta` that a user explicitly registered.
    *
-   * @see {@link ConfiguredSubTypes} for more information.
+   * @see {@link ConfiguredSubType} for more information.
    */
-  type Known = ActorDelta.OfType<ActorDelta.ConfiguredSubTypes>;
+  type Known = ActorDelta.OfType<ActorDelta.ConfiguredSubType>;
 
   /**
    * `OfType` returns an instance of `ActorDelta` with the corresponding type. This works with both the
    * builtin `ActorDelta` class or a custom subclass if that is set up in
    * {@link ConfiguredActorDelta | `fvtt-types/configuration/ConfiguredActorDelta`}.
    */
-  type OfType<Type extends SubType> = Document.Internal.DiscriminateSystem<Name, _OfType, Type, ConfiguredSubTypes>;
+  type OfType<Type extends SubType> = Document.Internal.DiscriminateSystem<Name, _OfType, Type, ConfiguredSubType>;
 
   /** @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<Name, _SystemMap, Type, ConfiguredSubTypes>;
+  type SystemOfType<Type extends SubType> = Document.Internal.SystemOfType<Name, _SystemMap, Type, ConfiguredSubType>;
 
   /**
    * @internal
@@ -553,6 +553,11 @@ declare namespace ActorDelta {
    * parent in the construction context for any construction, not just `.create`ion
    */
   interface ConstructorArgs extends Identity<[data: CreateData | undefined, context: ConstructionContext]> {}
+
+  /**
+   * @deprecated Replaced with {@linkcode ActorDelta.ConfiguredSubType} (will be removed in v14).
+   */
+  type ConfiguredSubTypes = ConfiguredSubType;
 }
 
 /**

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

@@ -89,27 +89,27 @@ declare namespace Actor {
   type SubType = foundry.Game.Model.TypeNames<"Actor">;
 
   /**
-   * `ConfiguredSubTypes` represents the subtypes a user explicitly registered. This excludes
+   * `ConfiguredSubType` represents the subtypes a user explicitly registered. This excludes
    * subtypes like the Foundry builtin subtype `"base"` and the catch-all subtype for arbitrary
    * module subtypes `${string}.${string}`.
    *
    * @see {@link SubType} for more information.
    */
-  type ConfiguredSubTypes = Document.ConfiguredSubTypesOf<"Actor">;
+  type ConfiguredSubType = Document.ConfiguredSubTypeOf<"Actor">;
 
   /**
    * `Known` represents the types of `Actor` that a user explicitly registered.
    *
-   * @see {@link ConfiguredSubTypes} for more information.
+   * @see {@link ConfiguredSubType} for more information.
    */
-  type Known = Actor.OfType<Actor.ConfiguredSubTypes>;
+  type Known = Actor.OfType<Actor.ConfiguredSubType>;
 
   /**
    * `OfType` returns an instance of `Actor` with the corresponding type. This works with both the
    * builtin `Actor` class or a custom subclass if that is set up in
    * {@link ConfiguredActor | `fvtt-types/configuration/ConfiguredActor`}.
    */
-  type OfType<Type extends SubType> = Document.Internal.DiscriminateSystem<Name, _OfType, Type, ConfiguredSubTypes>;
+  type OfType<Type extends SubType> = Document.Internal.DiscriminateSystem<Name, _OfType, Type, ConfiguredSubType>;
 
   /** @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<Name, _SystemMap, Type, ConfiguredSubTypes>;
+  type SystemOfType<Type extends SubType> = Document.Internal.SystemOfType<Name, _SystemMap, Type, ConfiguredSubType>;
 
   /**
    * @internal
@@ -655,6 +655,11 @@ declare namespace Actor {
    */
   // eslint-disable-next-line @typescript-eslint/no-deprecated
   type ConstructorArgs = Document.ConstructorParameters<CreateData, Parent>;
+
+  /**
+   * @deprecated Replaced with {@linkcode Actor.ConfiguredSubType} (will be removed in v14).
+   */
+  type ConfiguredSubTypes = ConfiguredSubType;
 }
 
 /**

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

@@ -79,27 +79,27 @@ declare namespace Card {
   type SubType = foundry.Game.Model.TypeNames<"Card">;
 
   /**
-   * `ConfiguredSubTypes` represents the subtypes a user explicitly registered. This excludes
+   * `ConfiguredSubType` represents the subtypes a user explicitly registered. This excludes
    * subtypes like the Foundry builtin subtype `"base"` and the catch-all subtype for arbitrary
    * module subtypes `${string}.${string}`.
    *
    * @see {@link SubType} for more information.
    */
-  type ConfiguredSubTypes = Document.ConfiguredSubTypesOf<"Card">;
+  type ConfiguredSubType = Document.ConfiguredSubTypeOf<"Card">;
 
   /**
    * `Known` represents the types of `Card` that a user explicitly registered.
    *
-   * @see {@link ConfiguredSubTypes} for more information.
+   * @see {@link ConfiguredSubType} for more information.
    */
-  type Known = Card.OfType<Card.ConfiguredSubTypes>;
+  type Known = Card.OfType<Card.ConfiguredSubType>;
 
   /**
    * `OfType` returns an instance of `Card` with the corresponding type. This works with both the
    * builtin `Card` class or a custom subclass if that is set up in
    * {@link ConfiguredCard | `fvtt-types/configuration/ConfiguredCard`}.
    */
-  type OfType<Type extends SubType> = Document.Internal.DiscriminateSystem<Name, _OfType, Type, ConfiguredSubTypes>;
+  type OfType<Type extends SubType> = Document.Internal.DiscriminateSystem<Name, _OfType, Type, ConfiguredSubType>;
 
   /** @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<Name, _SystemMap, Type, ConfiguredSubTypes>;
+  type SystemOfType<Type extends SubType> = Document.Internal.SystemOfType<Name, _SystemMap, Type, ConfiguredSubType>;
 
   /**
    * @internal
@@ -562,6 +562,11 @@ declare namespace Card {
    */
   // eslint-disable-next-line @typescript-eslint/no-deprecated
   type ConstructorArgs = Document.ConstructorParameters<CreateData, Parent>;
+
+  /**
+   * @deprecated Replaced with {@linkcode Card.ConfiguredSubType} (will be removed in v14).
+   */
+  type ConfiguredSubTypes = ConfiguredSubType;
 }
 
 /**

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

@@ -84,27 +84,27 @@ declare namespace Cards {
   type SubType = foundry.Game.Model.TypeNames<"Cards">;
 
   /**
-   * `ConfiguredSubTypes` represents the subtypes a user explicitly registered. This excludes
+   * `ConfiguredSubType` represents the subtypes a user explicitly registered. This excludes
    * subtypes like the Foundry builtin subtype `"base"` and the catch-all subtype for arbitrary
    * module subtypes `${string}.${string}`.
    *
    * @see {@link SubType} for more information.
    */
-  type ConfiguredSubTypes = Document.ConfiguredSubTypesOf<"Cards">;
+  type ConfiguredSubType = Document.ConfiguredSubTypeOf<"Cards">;
 
   /**
    * `Known` represents the types of `Cards` that a user explicitly registered.
    *
-   * @see {@link ConfiguredSubTypes} for more information.
+   * @see {@link ConfiguredSubType} for more information.
    */
-  type Known = Cards.OfType<Cards.ConfiguredSubTypes>;
+  type Known = Cards.OfType<Cards.ConfiguredSubType>;
 
   /**
    * `OfType` returns an instance of `Cards` with the corresponding type. This works with both the
    * builtin `Cards` class or a custom subclass if that is set up in
    * {@link ConfiguredCards | `fvtt-types/configuration/ConfiguredCards`}.
    */
-  type OfType<Type extends SubType> = Document.Internal.DiscriminateSystem<Name, _OfType, Type, ConfiguredSubTypes>;
+  type OfType<Type extends SubType> = Document.Internal.DiscriminateSystem<Name, _OfType, Type, ConfiguredSubType>;
 
   /** @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<Name, _SystemMap, Type, ConfiguredSubTypes>;
+  type SystemOfType<Type extends SubType> = Document.Internal.SystemOfType<Name, _SystemMap, Type, ConfiguredSubType>;
 
   /**
    * @internal
@@ -739,6 +739,11 @@ declare namespace Cards {
    */
   // eslint-disable-next-line @typescript-eslint/no-deprecated
   type ConstructorArgs = Document.ConstructorParameters<CreateData, Parent>;
+
+  /**
+   * @deprecated Replaced with {@linkcode Cards.ConfiguredSubType} (will be removed in v14).
+   */
+  type ConfiguredSubTypes = ConfiguredSubType;
 }
 
 /**

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

@@ -78,27 +78,27 @@ declare namespace ChatMessage {
   type SubType = foundry.Game.Model.TypeNames<"ChatMessage">;
 
   /**
-   * `ConfiguredSubTypes` represents the subtypes a user explicitly registered. This excludes
+   * `ConfiguredSubType` represents the subtypes a user explicitly registered. This excludes
    * subtypes like the Foundry builtin subtype `"base"` and the catch-all subtype for arbitrary
    * module subtypes `${string}.${string}`.
    *
    * @see {@link SubType} for more information.
    */
-  type ConfiguredSubTypes = Document.ConfiguredSubTypesOf<"ChatMessage">;
+  type ConfiguredSubType = Document.ConfiguredSubTypeOf<"ChatMessage">;
 
   /**
    * `Known` represents the types of `ChatMessage` that a user explicitly registered.
    *
-   * @see {@link ConfiguredSubTypes} for more information.
+   * @see {@link ConfiguredSubType} for more information.
    */
-  type Known = ChatMessage.OfType<ChatMessage.ConfiguredSubTypes>;
+  type Known = ChatMessage.OfType<ChatMessage.ConfiguredSubType>;
 
   /**
    * `OfType` returns an instance of `ChatMessage` with the corresponding type. This works with both the
    * builtin `ChatMessage` class or a custom subclass if that is set up in
    * {@link ConfiguredChatMessage | `fvtt-types/configuration/ConfiguredChatMessage`}.
    */
-  type OfType<Type extends SubType> = Document.Internal.DiscriminateSystem<Name, _OfType, Type, ConfiguredSubTypes>;
+  type OfType<Type extends SubType> = Document.Internal.DiscriminateSystem<Name, _OfType, Type, ConfiguredSubType>;
 
   /** @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<Name, _SystemMap, Type, ConfiguredSubTypes>;
+  type SystemOfType<Type extends SubType> = Document.Internal.SystemOfType<Name, _SystemMap, Type, ConfiguredSubType>;
 
   /**
    * @internal
@@ -657,6 +657,11 @@ declare namespace ChatMessage {
    */
   // eslint-disable-next-line @typescript-eslint/no-deprecated
   type ConstructorArgs = Document.ConstructorParameters<CreateData, Parent>;
+
+  /**
+   * @deprecated Replaced with {@linkcode ChatMessage.ConfiguredSubType} (will be removed in v14).
+   */
+  type ConfiguredSubTypes = ConfiguredSubType;
 }
 
 /**

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

@@ -85,27 +85,27 @@ declare namespace Combat {
   type SubType = foundry.Game.Model.TypeNames<"Combat">;
 
   /**
-   * `ConfiguredSubTypes` represents the subtypes a user explicitly registered. This excludes
+   * `ConfiguredSubType` represents the subtypes a user explicitly registered. This excludes
    * subtypes like the Foundry builtin subtype `"base"` and the catch-all subtype for arbitrary
    * module subtypes `${string}.${string}`.
    *
    * @see {@link SubType} for more information.
    */
-  type ConfiguredSubTypes = Document.ConfiguredSubTypesOf<"Combat">;
+  type ConfiguredSubType = Document.ConfiguredSubTypeOf<"Combat">;
 
   /**
    * `Known` represents the types of `Combat` that a user explicitly registered.
    *
-   * @see {@link ConfiguredSubTypes} for more information.
+   * @see {@link ConfiguredSubType} for more information.
    */
-  type Known = Combat.OfType<Combat.ConfiguredSubTypes>;
+  type Known = Combat.OfType<Combat.ConfiguredSubType>;
 
   /**
    * `OfType` returns an instance of `Combat` with the corresponding type. This works with both the
    * builtin `Combat` class or a custom subclass if that is set up in
    * {@link ConfiguredCombat | `fvtt-types/configuration/ConfiguredCombat`}.
    */
-  type OfType<Type extends SubType> = Document.Internal.DiscriminateSystem<Name, _OfType, Type, ConfiguredSubTypes>;
+  type OfType<Type extends SubType> = Document.Internal.DiscriminateSystem<Name, _OfType, Type, ConfiguredSubType>;
 
   /** @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<Name, _SystemMap, Type, ConfiguredSubTypes>;
+  type SystemOfType<Type extends SubType> = Document.Internal.SystemOfType<Name, _SystemMap, Type, ConfiguredSubType>;
 
   /**
    * @internal
@@ -607,6 +607,11 @@ declare namespace Combat {
    */
   // eslint-disable-next-line @typescript-eslint/no-deprecated
   type ConstructorArgs = Document.ConstructorParameters<CreateData, Parent>;
+
+  /**
+   * @deprecated Replaced with {@linkcode Combat.ConfiguredSubType} (will be removed in v14).
+   */
+  type ConfiguredSubTypes = ConfiguredSubType;
 }
 
 /**

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

@@ -61,27 +61,27 @@ declare namespace CombatantGroup {
   type SubType = foundry.Game.Model.TypeNames<"CombatantGroup">;
 
   /**
-   * `ConfiguredSubTypes` represents the subtypes a user explicitly registered. This excludes
+   * `ConfiguredSubType` represents the subtypes a user explicitly registered. This excludes
    * subtypes like the Foundry builtin subtype `"base"` and the catch-all subtype for arbitrary
    * module subtypes `${string}.${string}`.
    *
    * @see {@link SubType} for more information.
    */
-  type ConfiguredSubTypes = Document.ConfiguredSubTypesOf<"CombatantGroup">;
+  type ConfiguredSubType = Document.ConfiguredSubTypeOf<"CombatantGroup">;
 
   /**
    * `Known` represents the types of `CombatantGroup` that a user explicitly registered.
    *
-   * @see {@link ConfiguredSubTypes} for more information.
+   * @see {@link ConfiguredSubType} for more information.
    */
-  type Known = CombatantGroup.OfType<CombatantGroup.ConfiguredSubTypes>;
+  type Known = CombatantGroup.OfType<CombatantGroup.ConfiguredSubType>;
 
   /**
    * `OfType` returns an instance of `CombatantGroup` with the corresponding type. This works with both the
    * builtin `CombatantGroup` class or a custom subclass if that is set up in
    * {@link ConfiguredCombatantGroup | `fvtt-types/configuration/ConfiguredCombatantGroup`}.
    */
-  type OfType<Type extends SubType> = Document.Internal.DiscriminateSystem<Name, _OfType, Type, ConfiguredSubTypes>;
+  type OfType<Type extends SubType> = Document.Internal.DiscriminateSystem<Name, _OfType, Type, ConfiguredSubType>;
 
   /** @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<Name, _SystemMap, Type, ConfiguredSubTypes>;
+  type SystemOfType<Type extends SubType> = Document.Internal.SystemOfType<Name, _SystemMap, Type, ConfiguredSubType>;
 
   /**
    * @internal
@@ -447,6 +447,11 @@ declare namespace CombatantGroup {
    */
   // eslint-disable-next-line @typescript-eslint/no-deprecated
   type ConstructorArgs = Document.ConstructorParameters<CreateData, Parent>;
+
+  /**
+   * @deprecated Replaced with {@linkcode CombatantGroup.ConfiguredSubType} (will be removed in v14).
+   */
+  type ConfiguredSubTypes = ConfiguredSubType;
 }
 
 /**

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

@@ -79,27 +79,27 @@ declare namespace Combatant {
   type SubType = foundry.Game.Model.TypeNames<"Combatant">;
 
   /**
-   * `ConfiguredSubTypes` represents the subtypes a user explicitly registered. This excludes
+   * `ConfiguredSubType` represents the subtypes a user explicitly registered. This excludes
    * subtypes like the Foundry builtin subtype `"base"` and the catch-all subtype for arbitrary
    * module subtypes `${string}.${string}`.
    *
    * @see {@link SubType} for more information.
    */
-  type ConfiguredSubTypes = Document.ConfiguredSubTypesOf<"Combatant">;
+  type ConfiguredSubType = Document.ConfiguredSubTypeOf<"Combatant">;
 
   /**
    * `Known` represents the types of `Combatant` that a user explicitly registered.
    *
-   * @see {@link ConfiguredSubTypes} for more information.
+   * @see {@link ConfiguredSubType} for more information.
    */
-  type Known = Combatant.OfType<Combatant.ConfiguredSubTypes>;
+  type Known = Combatant.OfType<Combatant.ConfiguredSubType>;
 
   /**
    * `OfType` returns an instance of `Combatant` with the corresponding type. This works with both the
    * builtin `Combatant` class or a custom subclass if that is set up in
    * {@link ConfiguredCombatant | `fvtt-types/configuration/ConfiguredCombatant`}.
    */
-  type OfType<Type extends SubType> = Document.Internal.DiscriminateSystem<Name, _OfType, Type, ConfiguredSubTypes>;
+  type OfType<Type extends SubType> = Document.Internal.DiscriminateSystem<Name, _OfType, Type, ConfiguredSubType>;
 
   /** @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<Name, _SystemMap, Type, ConfiguredSubTypes>;
+  type SystemOfType<Type extends SubType> = Document.Internal.SystemOfType<Name, _SystemMap, Type, ConfiguredSubType>;
 
   /**
    * @internal
@@ -486,6 +486,11 @@ declare namespace Combatant {
    */
   // eslint-disable-next-line @typescript-eslint/no-deprecated
   type ConstructorArgs = Document.ConstructorParameters<CreateData, Parent>;
+
+  /**
+   * @deprecated Replaced with {@linkcode Combatant.ConfiguredSubType} (will be removed in v14).
+   */
+  type ConfiguredSubTypes = ConfiguredSubType;
 }
 
 /**

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

@@ -73,7 +73,7 @@ declare namespace Folder {
    *
    * This type exists only to be informative.
    */
-  type ConfiguredSubTypes = never;
+  type ConfiguredSubType = never;
 
   /**
    * @deprecated `Folder` does not have `system` and therefore there is no way for a user to
@@ -512,6 +512,12 @@ declare namespace Folder {
    */
   // eslint-disable-next-line @typescript-eslint/no-deprecated
   type ConstructorArgs = Document.ConstructorParameters<CreateData, Parent>;
+
+  /**
+   * @deprecated Replaced with {@linkcode Folder.ConfiguredSubType} (will be removed in v14).
+   */
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
+  type ConfiguredSubTypes = ConfiguredSubType;
 }
 
 /**

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

@@ -86,27 +86,27 @@ declare namespace Item {
   type SubType = foundry.Game.Model.TypeNames<"Item">;
 
   /**
-   * `ConfiguredSubTypes` represents the subtypes a user explicitly registered. This excludes
+   * `ConfiguredSubType` represents the subtypes a user explicitly registered. This excludes
    * subtypes like the Foundry builtin subtype `"base"` and the catch-all subtype for arbitrary
    * module subtypes `${string}.${string}`.
    *
    * @see {@link SubType} for more information.
    */
-  type ConfiguredSubTypes = Document.ConfiguredSubTypesOf<"Item">;
+  type ConfiguredSubType = Document.ConfiguredSubTypeOf<"Item">;
 
   /**
    * `Known` represents the types of `Item` that a user explicitly registered.
    *
-   * @see {@link ConfiguredSubTypes} for more information.
+   * @see {@link ConfiguredSubType} for more information.
    */
-  type Known = Item.OfType<Item.ConfiguredSubTypes>;
+  type Known = Item.OfType<Item.ConfiguredSubType>;
 
   /**
    * `OfType` returns an instance of `Item` with the corresponding type. This works with both the
    * builtin `Item` class or a custom subclass if that is set up in
    * {@link ConfiguredItem | `fvtt-types/configuration/ConfiguredItem`}.
    */
-  type OfType<Type extends SubType> = Document.Internal.DiscriminateSystem<Name, _OfType, Type, ConfiguredSubTypes>;
+  type OfType<Type extends SubType> = Document.Internal.DiscriminateSystem<Name, _OfType, Type, ConfiguredSubType>;
 
   /** @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<Name, _SystemMap, Type, ConfiguredSubTypes>;
+  type SystemOfType<Type extends SubType> = Document.Internal.SystemOfType<Name, _SystemMap, Type, ConfiguredSubType>;
 
   /**
    * @internal
@@ -553,6 +553,11 @@ declare namespace Item {
    */
   // eslint-disable-next-line @typescript-eslint/no-deprecated
   type ConstructorArgs = Document.ConstructorParameters<CreateData, Parent>;
+
+  /**
+   * @deprecated Replaced with {@linkcode Item.ConfiguredSubType} (will be removed in v14).
+   */
+  type ConfiguredSubTypes = ConfiguredSubType;
 }
 
 /**

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

@@ -77,20 +77,20 @@ declare namespace JournalEntryPage {
   type SubType = foundry.Game.Model.TypeNames<"JournalEntryPage">;
 
   /**
-   * `ConfiguredSubTypes` represents the subtypes a user explicitly registered. This excludes
+   * `ConfiguredSubType` represents the subtypes a user explicitly registered. This excludes
    * subtypes like the Foundry builtin subtype `"base"` and the catch-all subtype for arbitrary
    * module subtypes `${string}.${string}`.
    *
    * @see {@link SubType} for more information.
    */
-  type ConfiguredSubTypes = Document.ConfiguredSubTypesOf<"JournalEntryPage">;
+  type ConfiguredSubType = Document.ConfiguredSubTypeOf<"JournalEntryPage">;
 
   /**
    * `Known` represents the types of `JournalEntryPage` that a user explicitly registered.
    *
-   * @see {@link ConfiguredSubTypes} for more information.
+   * @see {@link ConfiguredSubType} for more information.
    */
-  type Known = JournalEntryPage.OfType<JournalEntryPage.ConfiguredSubTypes>;
+  type Known = JournalEntryPage.OfType<JournalEntryPage.ConfiguredSubType>;
 
   /**
    * `OfType` returns an instance of `JournalEntryPage` with the corresponding type. This works with both the
@@ -98,7 +98,7 @@ declare namespace JournalEntryPage {
    * {@link ConfiguredJournalEntryPage | `fvtt-types/configuration/ConfiguredJournalEntryPage`}.
    * up.
    */
-  type OfType<Type extends SubType> = Document.Internal.DiscriminateSystem<Name, _OfType, Type, ConfiguredSubTypes>;
+  type OfType<Type extends SubType> = Document.Internal.DiscriminateSystem<Name, _OfType, Type, ConfiguredSubType>;
 
   /** @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<Name, _SystemMap, Type, ConfiguredSubTypes>;
+  type SystemOfType<Type extends SubType> = Document.Internal.SystemOfType<Name, _SystemMap, Type, ConfiguredSubType>;
 
   /**
    * @internal
@@ -633,6 +633,11 @@ declare namespace JournalEntryPage {
    */
   // eslint-disable-next-line @typescript-eslint/no-deprecated
   type ConstructorArgs = Document.ConstructorParameters<CreateData, Parent>;
+
+  /**
+   * @deprecated Replaced with {@linkcode JournalEntryPage.ConfiguredSubType} (will be removed in v14).
+   */
+  type ConfiguredSubTypes = ConfiguredSubType;
 }
 
 /**

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

@@ -83,7 +83,7 @@ declare namespace Macro {
    *
    * This type exists only to be informative.
    */
-  type ConfiguredSubTypes = never;
+  type ConfiguredSubType = never;
 
   /**
    * @deprecated `Macro` does not have `system` and therefore there is no way for a user to
@@ -525,6 +525,12 @@ declare namespace Macro {
    */
   // eslint-disable-next-line @typescript-eslint/no-deprecated
   type ConstructorArgs = Document.ConstructorParameters<CreateData, Parent>;
+
+  /**
+   * @deprecated Replaced with {@linkcode Macro.ConfiguredSubType} (will be removed in v14).
+   */
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
+  type ConfiguredSubTypes = ConfiguredSubType;
 }
 
 /**

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

@@ -87,27 +87,27 @@ declare namespace RegionBehavior {
   type SubType = foundry.Game.Model.TypeNames<"RegionBehavior">;
 
   /**
-   * `ConfiguredSubTypes` represents the subtypes a user explicitly registered. This excludes
+   * `ConfiguredSubType` represents the subtypes a user explicitly registered. This excludes
    * subtypes like the Foundry builtin subtype `"base"` and the catch-all subtype for arbitrary
    * module subtypes `${string}.${string}`.
    *
    * @see {@link SubType} for more information.
    */
-  type ConfiguredSubTypes = Document.ConfiguredSubTypesOf<"RegionBehavior">;
+  type ConfiguredSubType = Document.ConfiguredSubTypeOf<"RegionBehavior">;
 
   /**
    * `Known` represents the types of `RegionBehavior` that a user explicitly registered.
    *
-   * @see {@link ConfiguredSubTypes} for more information.
+   * @see {@link ConfiguredSubType} for more information.
    */
-  type Known = RegionBehavior.OfType<RegionBehavior.ConfiguredSubTypes>;
+  type Known = RegionBehavior.OfType<RegionBehavior.ConfiguredSubType>;
 
   /**
    * `OfType` returns an instance of `RegionBehavior` with the corresponding type. This works with both the
    * builtin `RegionBehavior` class or a custom subclass if that is set up in
    * {@link ConfiguredRegionBehavior | `fvtt-types/configuration/ConfiguredRegionBehavior`}.
    */
-  type OfType<Type extends SubType> = Document.Internal.DiscriminateSystem<Name, _OfType, Type, ConfiguredSubTypes>;
+  type OfType<Type extends SubType> = Document.Internal.DiscriminateSystem<Name, _OfType, Type, ConfiguredSubType>;
 
   /** @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<Name, _SystemMap, Type, ConfiguredSubTypes>;
+  type SystemOfType<Type extends SubType> = Document.Internal.SystemOfType<Name, _SystemMap, Type, ConfiguredSubType>;
 
   /**
    * @internal
@@ -445,6 +445,11 @@ declare namespace RegionBehavior {
    */
   // eslint-disable-next-line @typescript-eslint/no-deprecated
   type ConstructorArgs = Document.ConstructorParameters<CreateData, Parent>;
+
+  /**
+   * @deprecated Replaced with {@linkcode RegionBehavior.ConfiguredSubType} (will be removed in v14).
+   */
+  type ConfiguredSubTypes = ConfiguredSubType;
 }
 
 /**

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

@@ -77,7 +77,7 @@ declare namespace TableResult {
    *
    * This type exists only to be informative.
    */
-  type ConfiguredSubTypes = never;
+  type ConfiguredSubType = never;
 
   /**
    * @deprecated `TableResult` does not have `system` and therefore there is no way for a user to
@@ -453,6 +453,12 @@ declare namespace TableResult {
    */
   // eslint-disable-next-line @typescript-eslint/no-deprecated
   type ConstructorArgs = Document.ConstructorParameters<CreateData, Parent>;
+
+  /**
+   * @deprecated Replaced with {@linkcode TableResult.ConfiguredSubType} (will be removed in v14).
+   */
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
+  type ConfiguredSubTypes = ConfiguredSubType;
 }
 
 /**

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

@@ -978,8 +978,8 @@ declare namespace Document {
     ? Exclude<Types, "base">
     : Types;
 
-  type ConfiguredSubTypesOf<Name extends Type> = Name extends "ActorDelta"
-    ? ConfiguredSubTypesOf<"Actor">
+  type ConfiguredSubTypeOf<Name extends Type> = Name extends "ActorDelta"
+    ? ConfiguredSubTypeOf<"Actor">
     : // ESLint doesn't know that `DataModelConfig` and `SourceConfig` are meant to be declaration merged into.
       // Therefore it hastily thinks the results are always `never`.
       // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents, @typescript-eslint/no-duplicate-type-constituents
@@ -987,7 +987,7 @@ declare namespace Document {
 
   type SubTypesOf<Name extends Document.Type> = Name extends "ActorDelta"
     ? SubTypesOf<"Actor">
-    : Document.CoreTypesForName<Name> | ConfiguredSubTypesOf<Name> | _ModuleSubType<Name>;
+    : Document.CoreTypesForName<Name> | ConfiguredSubTypeOf<Name> | _ModuleSubType<Name>;
 
   /** @internal */
   type _ModuleSubType<Name extends Type> = SystemConfig extends {
@@ -1214,17 +1214,17 @@ declare namespace Document {
       Name extends Document.WithSystem,
       SystemMap extends Record<SubType, object | undefined>,
       SubType extends string,
-      ConfiguredSubTypes extends string,
+      ConfiguredSubType extends string,
     > =
       GetKey<SystemConfig, Name, "none"> extends "discriminateAll"
         ? _DiscriminateUndefined<SystemMap[SubType]>
         :
-            | ([Extract<SubType, ConfiguredSubTypes>] extends [never]
+            | ([Extract<SubType, ConfiguredSubType>] extends [never]
                 ? never
-                : _DiscriminateUndefined<SystemMap[Extract<SubType, ConfiguredSubTypes>]>)
-            | ([Exclude<SubType, ConfiguredSubTypes>] extends [never]
+                : _DiscriminateUndefined<SystemMap[Extract<SubType, ConfiguredSubType>]>)
+            | ([Exclude<SubType, ConfiguredSubType>] extends [never]
                 ? never
-                : SystemMap[Exclude<SubType, ConfiguredSubTypes>]);
+                : SystemMap[Exclude<SubType, ConfiguredSubType>]);
 
     /** @internal */
     type _DiscriminateUndefined<T extends object | undefined> = DiscriminatedUnion<Exclude<T, undefined>>;
@@ -1255,14 +1255,14 @@ declare namespace Document {
       Name extends Document.WithSystem,
       TypeMap extends Record<SubType, { system: object | undefined }>,
       SubType extends string,
-      ConfiguredSubTypes extends string,
+      ConfiguredSubType extends string,
     > = SystemConfig extends { readonly [_ in Name]: { readonly discriminate: "all" } }
       ? DiscriminateSubType<SubType, TypeMap>
       :
-          | DiscriminateSubType<Extract<SubType, ConfiguredSubTypes>, TypeMap>
-          | ([Exclude<SubType, ConfiguredSubTypes>] extends [never]
+          | DiscriminateSubType<Extract<SubType, ConfiguredSubType>, TypeMap>
+          | ([Exclude<SubType, ConfiguredSubType>] extends [never]
               ? never
-              : TypeMap[Exclude<SubType, ConfiguredSubTypes>]);
+              : TypeMap[Exclude<SubType, ConfiguredSubType>]);
 
     type DiscriminateSubType<
       SubType extends AllSubType,

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

@@ -319,7 +319,7 @@ declare namespace BaseActiveEffect {
   export import Hierarchy = ActiveEffect.Hierarchy;
   export import Metadata = ActiveEffect.Metadata;
   export import SubType = ActiveEffect.SubType;
-  export import ConfiguredSubTypes = ActiveEffect.ConfiguredSubTypes;
+  export import ConfiguredSubType = ActiveEffect.ConfiguredSubType;
   export import Known = ActiveEffect.Known;
   export import OfType = ActiveEffect.OfType;
   export import SystemOfType = ActiveEffect.SystemOfType;

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

@@ -384,7 +384,7 @@ declare namespace BaseActorDelta {
   export import Hierarchy = ActorDelta.Hierarchy;
   export import Metadata = ActorDelta.Metadata;
   export import SubType = ActorDelta.SubType;
-  export import ConfiguredSubTypes = ActorDelta.ConfiguredSubTypes;
+  export import ConfiguredSubType = ActorDelta.ConfiguredSubType;
   export import Known = ActorDelta.Known;
   export import OfType = ActorDelta.OfType;
   export import SystemOfType = ActorDelta.SystemOfType;

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

@@ -354,7 +354,7 @@ declare namespace BaseActor {
   export import Hierarchy = Actor.Hierarchy;
   export import Metadata = Actor.Metadata;
   export import SubType = Actor.SubType;
-  export import ConfiguredSubTypes = Actor.ConfiguredSubTypes;
+  export import ConfiguredSubType = Actor.ConfiguredSubType;
   export import Known = Actor.Known;
   export import OfType = Actor.OfType;
   export import SystemOfType = Actor.SystemOfType;

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

@@ -300,7 +300,7 @@ declare namespace BaseCard {
   export import Hierarchy = Card.Hierarchy;
   export import Metadata = Card.Metadata;
   export import SubType = Card.SubType;
-  export import ConfiguredSubTypes = Card.ConfiguredSubTypes;
+  export import ConfiguredSubType = Card.ConfiguredSubType;
   export import Known = Card.Known;
   export import OfType = Card.OfType;
   export import SystemOfType = Card.SystemOfType;

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

@@ -342,7 +342,7 @@ declare namespace BaseCards {
   export import Hierarchy = Cards.Hierarchy;
   export import Metadata = Cards.Metadata;
   export import SubType = Cards.SubType;
-  export import ConfiguredSubTypes = Cards.ConfiguredSubTypes;
+  export import ConfiguredSubType = Cards.ConfiguredSubType;
   export import Known = Cards.Known;
   export import OfType = Cards.OfType;
   export import SystemOfType = Cards.SystemOfType;

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

@@ -316,7 +316,7 @@ declare namespace BaseChatMessage {
   export import Hierarchy = ChatMessage.Hierarchy;
   export import Metadata = ChatMessage.Metadata;
   export import SubType = ChatMessage.SubType;
-  export import ConfiguredSubTypes = ChatMessage.ConfiguredSubTypes;
+  export import ConfiguredSubType = ChatMessage.ConfiguredSubType;
   export import Known = ChatMessage.Known;
   export import OfType = ChatMessage.OfType;
   export import SystemOfType = ChatMessage.SystemOfType;

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

@@ -345,7 +345,7 @@ declare namespace BaseCombat {
   export import Hierarchy = Combat.Hierarchy;
   export import Metadata = Combat.Metadata;
   export import SubType = Combat.SubType;
-  export import ConfiguredSubTypes = Combat.ConfiguredSubTypes;
+  export import ConfiguredSubType = Combat.ConfiguredSubType;
   export import Known = Combat.Known;
   export import OfType = Combat.OfType;
   export import SystemOfType = Combat.SystemOfType;

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

@@ -287,7 +287,7 @@ declare namespace BaseCombatantGroup {
   export import Hierarchy = CombatantGroup.Hierarchy;
   export import Metadata = CombatantGroup.Metadata;
   export import SubType = CombatantGroup.SubType;
-  export import ConfiguredSubTypes = CombatantGroup.ConfiguredSubTypes;
+  export import ConfiguredSubType = CombatantGroup.ConfiguredSubType;
   export import Known = CombatantGroup.Known;
   export import OfType = CombatantGroup.OfType;
   export import SystemOfType = CombatantGroup.SystemOfType;

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

@@ -305,7 +305,7 @@ declare namespace BaseCombatant {
   export import Hierarchy = Combatant.Hierarchy;
   export import Metadata = Combatant.Metadata;
   export import SubType = Combatant.SubType;
-  export import ConfiguredSubTypes = Combatant.ConfiguredSubTypes;
+  export import ConfiguredSubType = Combatant.ConfiguredSubType;
   export import Known = Combatant.Known;
   export import OfType = Combatant.OfType;
   export import SystemOfType = Combatant.SystemOfType;

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

@@ -351,7 +351,7 @@ declare namespace BaseItem {
   export import Hierarchy = Item.Hierarchy;
   export import Metadata = Item.Metadata;
   export import SubType = Item.SubType;
-  export import ConfiguredSubTypes = Item.ConfiguredSubTypes;
+  export import ConfiguredSubType = Item.ConfiguredSubType;
   export import Known = Item.Known;
   export import OfType = Item.OfType;
   export import SystemOfType = Item.SystemOfType;

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

@@ -294,7 +294,7 @@ declare namespace BaseJournalEntryPage {
   export import Hierarchy = JournalEntryPage.Hierarchy;
   export import Metadata = JournalEntryPage.Metadata;
   export import SubType = JournalEntryPage.SubType;
-  export import ConfiguredSubTypes = JournalEntryPage.ConfiguredSubTypes;
+  export import ConfiguredSubType = JournalEntryPage.ConfiguredSubType;
   export import Known = JournalEntryPage.Known;
   export import OfType = JournalEntryPage.OfType;
   export import SystemOfType = JournalEntryPage.SystemOfType;

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

@@ -315,7 +315,7 @@ declare namespace BaseMacro {
   export import Hierarchy = Macro.Hierarchy;
   export import Metadata = Macro.Metadata;
   export import SubType = Macro.SubType;
-  export import ConfiguredSubTypes = Macro.ConfiguredSubTypes;
+  export import ConfiguredSubType = Macro.ConfiguredSubType;
   export import Known = Macro.Known;
   export import OfType = Macro.OfType;
   export import Parent = Macro.Parent;

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

@@ -311,7 +311,7 @@ declare namespace BaseRegionBehavior {
   export import Hierarchy = RegionBehavior.Hierarchy;
   export import Metadata = RegionBehavior.Metadata;
   export import SubType = RegionBehavior.SubType;
-  export import ConfiguredSubTypes = RegionBehavior.ConfiguredSubTypes;
+  export import ConfiguredSubType = RegionBehavior.ConfiguredSubType;
   export import Known = RegionBehavior.Known;
   export import OfType = RegionBehavior.OfType;
   export import SystemOfType = RegionBehavior.SystemOfType;

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

@@ -320,7 +320,7 @@ declare namespace BaseTableResult {
   export import Hierarchy = TableResult.Hierarchy;
   export import Metadata = TableResult.Metadata;
   export import SubType = TableResult.SubType;
-  export import ConfiguredSubTypes = TableResult.ConfiguredSubTypes;
+  export import ConfiguredSubType = TableResult.ConfiguredSubType;
   export import Known = TableResult.Known;
   export import OfType = TableResult.OfType;
   export import Parent = TableResult.Parent;