@league-of-foundry-developers/foundry-vtt-types 13.346.0-beta.20250705112003 → 13.346.0-beta.20250705133313

package/src/foundry/common/documents/ambient-sound.d.mts

@@ -78,7 +78,7 @@ declare abstract class BaseAmbientSound extends Document<"AmbientSound", BaseAmb
   static override createDocuments<Temporary extends boolean | undefined = undefined>(
     data: Array<AmbientSoundDocument.Implementation | AmbientSoundDocument.CreateData> | undefined,
     operation?: Document.Database.CreateOperation<AmbientSoundDocument.Database.Create<Temporary>>,
-  ): Promise<Array<Document.TemporaryIf<AmbientSoundDocument.Implementation, Temporary>>>;
+  ): Promise<Array<AmbientSoundDocument.TemporaryIf<Temporary>>>;
 
   static override updateDocuments(
     updates: AmbientSoundDocument.UpdateData[] | undefined,
@@ -93,7 +93,7 @@ declare abstract class BaseAmbientSound extends Document<"AmbientSound", BaseAmb
   static override create<Temporary extends boolean | undefined = undefined>(
     data: AmbientSoundDocument.CreateData | AmbientSoundDocument.CreateData[],
     operation?: AmbientSoundDocument.Database.CreateOperation<Temporary>,
-  ): Promise<Document.TemporaryIf<AmbientSoundDocument.Implementation, Temporary> | undefined>;
+  ): Promise<AmbientSoundDocument.TemporaryIf<Temporary> | undefined>;
 
   override update(
     data: AmbientSoundDocument.UpdateData | undefined,
@@ -117,12 +117,12 @@ declare abstract class BaseAmbientSound extends Document<"AmbientSound", BaseAmb
   override getFlag<Scope extends AmbientSoundDocument.Flags.Scope, Key extends AmbientSoundDocument.Flags.Key<Scope>>(
     scope: Scope,
     key: Key,
-  ): Document.GetFlag<AmbientSoundDocument.Name, Scope, Key>;
+  ): AmbientSoundDocument.Flags.Get<Scope, Key>;
 
   override setFlag<
     Scope extends AmbientSoundDocument.Flags.Scope,
     Key extends AmbientSoundDocument.Flags.Key<Scope>,
-    Value extends Document.GetFlag<AmbientSoundDocument.Name, Scope, Key>,
+    Value extends AmbientSoundDocument.Flags.Get<Scope, Key>,
   >(scope: Scope, key: Key, value: Value): Promise<this>;
 
   override unsetFlag<Scope extends AmbientSoundDocument.Flags.Scope, Key extends AmbientSoundDocument.Flags.Key<Scope>>(
@@ -296,7 +296,8 @@ declare namespace BaseAmbientSound {
   export import InitializedData = AmbientSoundDocument.InitializedData;
   export import UpdateData = AmbientSoundDocument.UpdateData;
   export import Schema = AmbientSoundDocument.Schema;
-  export import DatabaseOperation = AmbientSoundDocument.Database;
+  export import Database = AmbientSoundDocument.Database;
+  export import TemporaryIf = AmbientSoundDocument.TemporaryIf;
   export import Flags = AmbientSoundDocument.Flags;
 
   namespace Internal {

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

@@ -104,7 +104,7 @@ declare abstract class BaseCard<out SubType extends BaseCard.SubType = BaseCard.
   static override createDocuments<Temporary extends boolean | undefined = undefined>(
     data: Array<Card.Implementation | Card.CreateData> | undefined,
     operation?: Document.Database.CreateOperation<Card.Database.Create<Temporary>>,
-  ): Promise<Array<Document.TemporaryIf<Card.Implementation, Temporary>>>;
+  ): Promise<Array<Card.TemporaryIf<Temporary>>>;
 
   static override updateDocuments(
     updates: Card.UpdateData[] | undefined,
@@ -119,7 +119,7 @@ declare abstract class BaseCard<out SubType extends BaseCard.SubType = BaseCard.
   static override create<Temporary extends boolean | undefined = undefined>(
     data: Card.CreateData | Card.CreateData[],
     operation?: Card.Database.CreateOperation<Temporary>,
-  ): Promise<Document.TemporaryIf<Card.Implementation, Temporary> | undefined>;
+  ): Promise<Card.TemporaryIf<Temporary> | undefined>;
 
   override update(
     data: Card.UpdateData | undefined,
@@ -140,12 +140,12 @@ declare abstract class BaseCard<out SubType extends BaseCard.SubType = BaseCard.
   override getFlag<Scope extends Card.Flags.Scope, Key extends Card.Flags.Key<Scope>>(
     scope: Scope,
     key: Key,
-  ): Document.GetFlag<Card.Name, Scope, Key>;
+  ): Card.Flags.Get<Scope, Key>;
 
   override setFlag<
     Scope extends Card.Flags.Scope,
     Key extends Card.Flags.Key<Scope>,
-    Value extends Document.GetFlag<Card.Name, Scope, Key>,
+    Value extends Card.Flags.Get<Scope, Key>,
   >(scope: Scope, key: Key, value: Value): Promise<this>;
 
   override unsetFlag<Scope extends Card.Flags.Scope, Key extends Card.Flags.Key<Scope>>(
@@ -319,7 +319,8 @@ declare namespace BaseCard {
   export import InitializedData = Card.InitializedData;
   export import UpdateData = Card.UpdateData;
   export import Schema = Card.Schema;
-  export import DatabaseOperation = Card.Database;
+  export import Database = Card.Database;
+  export import TemporaryIf = Card.TemporaryIf;
   export import Flags = Card.Flags;
 
   namespace Internal {

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

@@ -118,7 +118,7 @@ declare abstract class BaseCards<out SubType extends BaseCards.SubType = BaseCar
   static override createDocuments<Temporary extends boolean | undefined = undefined>(
     data: Array<Cards.Implementation | Cards.CreateData> | undefined,
     operation?: Document.Database.CreateOperation<Cards.Database.Create<Temporary>>,
-  ): Promise<Array<Document.TemporaryIf<Cards.Implementation, Temporary>>>;
+  ): Promise<Array<Cards.TemporaryIf<Temporary>>>;
 
   static override updateDocuments(
     updates: Cards.UpdateData[] | undefined,
@@ -133,7 +133,7 @@ declare abstract class BaseCards<out SubType extends BaseCards.SubType = BaseCar
   static override create<Temporary extends boolean | undefined = undefined>(
     data: Cards.CreateData | Cards.CreateData[],
     operation?: Cards.Database.CreateOperation<Temporary>,
-  ): Promise<Document.TemporaryIf<Cards.Implementation, Temporary> | undefined>;
+  ): Promise<Cards.TemporaryIf<Temporary> | undefined>;
 
   override update(
     data: Cards.UpdateData | undefined,
@@ -187,12 +187,12 @@ declare abstract class BaseCards<out SubType extends BaseCards.SubType = BaseCar
   override getFlag<Scope extends Cards.Flags.Scope, Key extends Cards.Flags.Key<Scope>>(
     scope: Scope,
     key: Key,
-  ): Document.GetFlag<Cards.Name, Scope, Key>;
+  ): Cards.Flags.Get<Scope, Key>;
 
   override setFlag<
     Scope extends Cards.Flags.Scope,
     Key extends Cards.Flags.Key<Scope>,
-    Value extends Document.GetFlag<Cards.Name, Scope, Key>,
+    Value extends Cards.Flags.Get<Scope, Key>,
   >(scope: Scope, key: Key, value: Value): Promise<this>;
 
   override unsetFlag<Scope extends Cards.Flags.Scope, Key extends Cards.Flags.Key<Scope>>(
@@ -364,7 +364,8 @@ declare namespace BaseCards {
   export import InitializedData = Cards.InitializedData;
   export import UpdateData = Cards.UpdateData;
   export import Schema = Cards.Schema;
-  export import DatabaseOperation = Cards.Database;
+  export import Database = Cards.Database;
+  export import TemporaryIf = Cards.TemporaryIf;
   export import Flags = Cards.Flags;
 
   namespace Internal {

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

@@ -113,7 +113,7 @@ declare abstract class BaseChatMessage<
   static override createDocuments<Temporary extends boolean | undefined = undefined>(
     data: Array<ChatMessage.Implementation | ChatMessage.CreateData> | undefined,
     operation?: Document.Database.CreateOperation<ChatMessage.Database.Create<Temporary>>,
-  ): Promise<Array<Document.TemporaryIf<ChatMessage.Implementation, Temporary>>>;
+  ): Promise<Array<ChatMessage.TemporaryIf<Temporary>>>;
 
   static override updateDocuments(
     updates: ChatMessage.UpdateData[] | undefined,
@@ -128,7 +128,7 @@ declare abstract class BaseChatMessage<
   static override create<Temporary extends boolean | undefined = undefined>(
     data: ChatMessage.CreateData | ChatMessage.CreateData[],
     operation?: ChatMessage.Database.CreateOperation<Temporary>,
-  ): Promise<Document.TemporaryIf<ChatMessage.Implementation, Temporary> | undefined>;
+  ): Promise<ChatMessage.TemporaryIf<Temporary> | undefined>;
 
   override update(
     data: ChatMessage.UpdateData | undefined,
@@ -149,12 +149,12 @@ declare abstract class BaseChatMessage<
   override getFlag<Scope extends ChatMessage.Flags.Scope, Key extends ChatMessage.Flags.Key<Scope>>(
     scope: Scope,
     key: Key,
-  ): Document.GetFlag<ChatMessage.Name, Scope, Key>;
+  ): ChatMessage.Flags.Get<Scope, Key>;
 
   override setFlag<
     Scope extends ChatMessage.Flags.Scope,
     Key extends ChatMessage.Flags.Key<Scope>,
-    Value extends Document.GetFlag<ChatMessage.Name, Scope, Key>,
+    Value extends ChatMessage.Flags.Get<Scope, Key>,
   >(scope: Scope, key: Key, value: Value): Promise<this>;
 
   override unsetFlag<Scope extends ChatMessage.Flags.Scope, Key extends ChatMessage.Flags.Key<Scope>>(
@@ -335,7 +335,8 @@ declare namespace BaseChatMessage {
   export import InitializedData = ChatMessage.InitializedData;
   export import UpdateData = ChatMessage.UpdateData;
   export import Schema = ChatMessage.Schema;
-  export import DatabaseOperation = ChatMessage.Database;
+  export import Database = ChatMessage.Database;
+  export import TemporaryIf = ChatMessage.TemporaryIf;
   export import Flags = ChatMessage.Flags;
   export import CoreFlags = ChatMessage.CoreFlags;
   export import GetSpeakerOptions = ChatMessage.GetSpeakerOptions;

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

@@ -121,7 +121,7 @@ declare abstract class BaseCombat<out SubType extends BaseCombat.SubType = BaseC
   static override createDocuments<Temporary extends boolean | undefined = undefined>(
     data: Array<Combat.Implementation | Combat.CreateData> | undefined,
     operation?: Document.Database.CreateOperation<Combat.Database.Create<Temporary>>,
-  ): Promise<Array<Document.TemporaryIf<Combat.Implementation, Temporary>>>;
+  ): Promise<Array<Combat.TemporaryIf<Temporary>>>;
 
   static override updateDocuments(
     updates: Combat.UpdateData[] | undefined,
@@ -136,7 +136,7 @@ declare abstract class BaseCombat<out SubType extends BaseCombat.SubType = BaseC
   static override create<Temporary extends boolean | undefined = undefined>(
     data: Combat.CreateData | Combat.CreateData[],
     operation?: Combat.Database.CreateOperation<Temporary>,
-  ): Promise<Document.TemporaryIf<Combat.Implementation, Temporary> | undefined>;
+  ): Promise<Combat.TemporaryIf<Temporary> | undefined>;
 
   override update(
     data: Combat.UpdateData | undefined,
@@ -190,12 +190,12 @@ declare abstract class BaseCombat<out SubType extends BaseCombat.SubType = BaseC
   override getFlag<Scope extends Combat.Flags.Scope, Key extends Combat.Flags.Key<Scope>>(
     scope: Scope,
     key: Key,
-  ): Document.GetFlag<Combat.Name, Scope, Key>;
+  ): Combat.Flags.Get<Scope, Key>;
 
   override setFlag<
     Scope extends Combat.Flags.Scope,
     Key extends Combat.Flags.Key<Scope>,
-    Value extends Document.GetFlag<Combat.Name, Scope, Key>,
+    Value extends Combat.Flags.Get<Scope, Key>,
   >(scope: Scope, key: Key, value: Value): Promise<this>;
 
   override unsetFlag<Scope extends Combat.Flags.Scope, Key extends Combat.Flags.Key<Scope>>(
@@ -367,7 +367,8 @@ declare namespace BaseCombat {
   export import InitializedData = Combat.InitializedData;
   export import UpdateData = Combat.UpdateData;
   export import Schema = Combat.Schema;
-  export import DatabaseOperation = Combat.Database;
+  export import Database = Combat.Database;
+  export import TemporaryIf = Combat.TemporaryIf;
   export import Flags = Combat.Flags;
 
   namespace Internal {

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

@@ -87,7 +87,7 @@ declare abstract class BaseCombatantGroup<
   static override createDocuments<Temporary extends boolean | undefined = undefined>(
     data: Array<CombatantGroup.Implementation | CombatantGroup.CreateData> | undefined,
     operation?: Document.Database.CreateOperation<CombatantGroup.Database.Create<Temporary>>,
-  ): Promise<Array<Document.TemporaryIf<CombatantGroup.Implementation, Temporary>>>;
+  ): Promise<Array<CombatantGroup.TemporaryIf<Temporary>>>;
 
   static override updateDocuments(
     updates: CombatantGroup.UpdateData[] | undefined,
@@ -102,7 +102,7 @@ declare abstract class BaseCombatantGroup<
   static override create<Temporary extends boolean | undefined = undefined>(
     data: CombatantGroup.CreateData | CombatantGroup.CreateData[],
     operation?: CombatantGroup.Database.CreateOperation<Temporary>,
-  ): Promise<Document.TemporaryIf<CombatantGroup.Implementation, Temporary> | undefined>;
+  ): Promise<CombatantGroup.TemporaryIf<Temporary> | undefined>;
 
   override update(
     data: CombatantGroup.UpdateData | undefined,
@@ -124,12 +124,12 @@ declare abstract class BaseCombatantGroup<
   override getFlag<Scope extends CombatantGroup.Flags.Scope, Key extends CombatantGroup.Flags.Key<Scope>>(
     scope: Scope,
     key: Key,
-  ): Document.GetFlag<CombatantGroup.Name, Scope, Key>;
+  ): CombatantGroup.Flags.Get<Scope, Key>;
 
   override setFlag<
     Scope extends CombatantGroup.Flags.Scope,
     Key extends CombatantGroup.Flags.Key<Scope>,
-    Value extends Document.GetFlag<CombatantGroup.Name, Scope, Key>,
+    Value extends CombatantGroup.Flags.Get<Scope, Key>,
   >(scope: Scope, key: Key, value: Value): Promise<this>;
 
   override unsetFlag<Scope extends CombatantGroup.Flags.Scope, Key extends CombatantGroup.Flags.Key<Scope>>(
@@ -306,7 +306,8 @@ declare namespace BaseCombatantGroup {
   export import InitializedData = CombatantGroup.InitializedData;
   export import UpdateData = CombatantGroup.UpdateData;
   export import Schema = CombatantGroup.Schema;
-  export import DatabaseOperation = CombatantGroup.Database;
+  export import Database = CombatantGroup.Database;
+  export import TemporaryIf = CombatantGroup.TemporaryIf;
   export import Flags = CombatantGroup.Flags;
 
   namespace Internal {

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

@@ -102,7 +102,7 @@ declare abstract class BaseCombatant<
   static override createDocuments<Temporary extends boolean | undefined = undefined>(
     data: Array<Combatant.Implementation | Combatant.CreateData> | undefined,
     operation?: Document.Database.CreateOperation<Combatant.Database.Create<Temporary>>,
-  ): Promise<Array<Document.TemporaryIf<Combatant.Implementation, Temporary>>>;
+  ): Promise<Array<Combatant.TemporaryIf<Temporary>>>;
 
   static override updateDocuments(
     updates: Combatant.UpdateData[] | undefined,
@@ -117,7 +117,7 @@ declare abstract class BaseCombatant<
   static override create<Temporary extends boolean | undefined = undefined>(
     data: Combatant.CreateData | Combatant.CreateData[],
     operation?: Combatant.Database.CreateOperation<Temporary>,
-  ): Promise<Document.TemporaryIf<Combatant.Implementation, Temporary> | undefined>;
+  ): Promise<Combatant.TemporaryIf<Temporary> | undefined>;
 
   override update(
     data: Combatant.UpdateData | undefined,
@@ -138,12 +138,12 @@ declare abstract class BaseCombatant<
   override getFlag<Scope extends Combatant.Flags.Scope, Key extends Combatant.Flags.Key<Scope>>(
     scope: Scope,
     key: Key,
-  ): Document.GetFlag<Combatant.Name, Scope, Key>;
+  ): Combatant.Flags.Get<Scope, Key>;
 
   override setFlag<
     Scope extends Combatant.Flags.Scope,
     Key extends Combatant.Flags.Key<Scope>,
-    Value extends Document.GetFlag<Combatant.Name, Scope, Key>,
+    Value extends Combatant.Flags.Get<Scope, Key>,
   >(scope: Scope, key: Key, value: Value): Promise<this>;
 
   override unsetFlag<Scope extends Combatant.Flags.Scope, Key extends Combatant.Flags.Key<Scope>>(
@@ -324,7 +324,8 @@ declare namespace BaseCombatant {
   export import InitializedData = Combatant.InitializedData;
   export import UpdateData = Combatant.UpdateData;
   export import Schema = Combatant.Schema;
-  export import DatabaseOperation = Combatant.Database;
+  export import Database = Combatant.Database;
+  export import TemporaryIf = Combatant.TemporaryIf;
   export import Flags = Combatant.Flags;
 
   namespace Internal {

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

@@ -121,7 +121,7 @@ declare abstract class BaseDrawing extends Document<"Drawing", BaseDrawing.Schem
   static override createDocuments<Temporary extends boolean | undefined = undefined>(
     data: Array<DrawingDocument.Implementation | DrawingDocument.CreateData> | undefined,
     operation?: Document.Database.CreateOperation<DrawingDocument.Database.Create<Temporary>>,
-  ): Promise<Array<Document.TemporaryIf<DrawingDocument.Implementation, Temporary>>>;
+  ): Promise<Array<DrawingDocument.TemporaryIf<Temporary>>>;
 
   static override updateDocuments(
     updates: DrawingDocument.UpdateData[] | undefined,
@@ -136,7 +136,7 @@ declare abstract class BaseDrawing extends Document<"Drawing", BaseDrawing.Schem
   static override create<Temporary extends boolean | undefined = undefined>(
     data: DrawingDocument.CreateData | DrawingDocument.CreateData[],
     operation?: DrawingDocument.Database.CreateOperation<Temporary>,
-  ): Promise<Document.TemporaryIf<DrawingDocument.Implementation, Temporary> | undefined>;
+  ): Promise<DrawingDocument.TemporaryIf<Temporary> | undefined>;
 
   override update(
     data: DrawingDocument.UpdateData | undefined,
@@ -160,12 +160,12 @@ declare abstract class BaseDrawing extends Document<"Drawing", BaseDrawing.Schem
   override getFlag<Scope extends DrawingDocument.Flags.Scope, Key extends DrawingDocument.Flags.Key<Scope>>(
     scope: Scope,
     key: Key,
-  ): Document.GetFlag<DrawingDocument.Name, Scope, Key>;
+  ): DrawingDocument.Flags.Get<Scope, Key>;
 
   override setFlag<
     Scope extends DrawingDocument.Flags.Scope,
     Key extends DrawingDocument.Flags.Key<Scope>,
-    Value extends Document.GetFlag<DrawingDocument.Name, Scope, Key>,
+    Value extends DrawingDocument.Flags.Get<Scope, Key>,
   >(scope: Scope, key: Key, value: Value): Promise<this>;
 
   override unsetFlag<Scope extends DrawingDocument.Flags.Scope, Key extends DrawingDocument.Flags.Key<Scope>>(
@@ -339,7 +339,8 @@ declare namespace BaseDrawing {
   export import InitializedData = DrawingDocument.InitializedData;
   export import UpdateData = DrawingDocument.UpdateData;
   export import Schema = DrawingDocument.Schema;
-  export import DatabaseOperation = DrawingDocument.Database;
+  export import Database = DrawingDocument.Database;
+  export import TemporaryIf = DrawingDocument.TemporaryIf;
   export import Flags = DrawingDocument.Flags;
 
   namespace Internal {

package/src/foundry/common/documents/fog-exploration.d.mts

@@ -91,7 +91,7 @@ declare abstract class BaseFogExploration extends Document<"FogExploration", Bas
   static override createDocuments<Temporary extends boolean | undefined = undefined>(
     data: Array<FogExploration.Implementation | FogExploration.CreateData> | undefined,
     operation?: Document.Database.CreateOperation<FogExploration.Database.Create<Temporary>>,
-  ): Promise<Array<Document.TemporaryIf<FogExploration.Implementation, Temporary>>>;
+  ): Promise<Array<FogExploration.TemporaryIf<Temporary>>>;
 
   static override updateDocuments(
     updates: FogExploration.UpdateData[] | undefined,
@@ -106,7 +106,7 @@ declare abstract class BaseFogExploration extends Document<"FogExploration", Bas
   static override create<Temporary extends boolean | undefined = undefined>(
     data: FogExploration.CreateData | FogExploration.CreateData[],
     operation?: FogExploration.Database.CreateOperation<Temporary>,
-  ): Promise<Document.TemporaryIf<FogExploration.Implementation, Temporary> | undefined>;
+  ): Promise<FogExploration.TemporaryIf<Temporary> | undefined>;
 
   override update(
     data: FogExploration.UpdateData | undefined,
@@ -130,12 +130,12 @@ declare abstract class BaseFogExploration extends Document<"FogExploration", Bas
   override getFlag<Scope extends FogExploration.Flags.Scope, Key extends FogExploration.Flags.Key<Scope>>(
     scope: Scope,
     key: Key,
-  ): Document.GetFlag<FogExploration.Name, Scope, Key>;
+  ): FogExploration.Flags.Get<Scope, Key>;
 
   override setFlag<
     Scope extends FogExploration.Flags.Scope,
     Key extends FogExploration.Flags.Key<Scope>,
-    Value extends Document.GetFlag<FogExploration.Name, Scope, Key>,
+    Value extends FogExploration.Flags.Get<Scope, Key>,
   >(scope: Scope, key: Key, value: Value): Promise<this>;
 
   override unsetFlag<Scope extends FogExploration.Flags.Scope, Key extends FogExploration.Flags.Key<Scope>>(
@@ -305,7 +305,8 @@ declare namespace BaseFogExploration {
   export import InitializedData = FogExploration.InitializedData;
   export import UpdateData = FogExploration.UpdateData;
   export import Schema = FogExploration.Schema;
-  export import DatabaseOperation = FogExploration.Database;
+  export import Database = FogExploration.Database;
+  export import TemporaryIf = FogExploration.TemporaryIf;
   export import Flags = FogExploration.Flags;
 
   namespace Internal {

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

@@ -106,7 +106,7 @@ declare abstract class BaseFolder<out SubType extends BaseFolder.SubType = BaseF
   static override createDocuments<Temporary extends boolean | undefined = undefined>(
     data: Array<Folder.Implementation | Folder.CreateData> | undefined,
     operation?: Document.Database.CreateOperation<Folder.Database.Create<Temporary>>,
-  ): Promise<Array<Document.TemporaryIf<Folder.Implementation, Temporary>>>;
+  ): Promise<Array<Folder.TemporaryIf<Temporary>>>;
 
   static override updateDocuments(
     updates: Folder.UpdateData[] | undefined,
@@ -121,7 +121,7 @@ declare abstract class BaseFolder<out SubType extends BaseFolder.SubType = BaseF
   static override create<Temporary extends boolean | undefined = undefined>(
     data: Folder.CreateData | Folder.CreateData[],
     operation?: Folder.Database.CreateOperation<Temporary>,
-  ): Promise<Document.TemporaryIf<Folder.Implementation, Temporary> | undefined>;
+  ): Promise<Folder.TemporaryIf<Temporary> | undefined>;
 
   override update(
     data: Folder.UpdateData | undefined,
@@ -140,12 +140,12 @@ declare abstract class BaseFolder<out SubType extends BaseFolder.SubType = BaseF
   override getFlag<Scope extends Folder.Flags.Scope, Key extends Folder.Flags.Key<Scope>>(
     scope: Scope,
     key: Key,
-  ): Document.GetFlag<Folder.Name, Scope, Key>;
+  ): Folder.Flags.Get<Scope, Key>;
 
   override setFlag<
     Scope extends Folder.Flags.Scope,
     Key extends Folder.Flags.Key<Scope>,
-    Value extends Document.GetFlag<Folder.Name, Scope, Key>,
+    Value extends Folder.Flags.Get<Scope, Key>,
   >(scope: Scope, key: Key, value: Value): Promise<this>;
 
   override unsetFlag<Scope extends Folder.Flags.Scope, Key extends Folder.Flags.Key<Scope>>(
@@ -315,7 +315,8 @@ declare namespace BaseFolder {
   export import InitializedData = Folder.InitializedData;
   export import UpdateData = Folder.UpdateData;
   export import Schema = Folder.Schema;
-  export import DatabaseOperation = Folder.Database;
+  export import Database = Folder.Database;
+  export import TemporaryIf = Folder.TemporaryIf;
   export import Flags = Folder.Flags;
 
   namespace Internal {

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

@@ -125,7 +125,7 @@ declare abstract class BaseItem<out SubType extends Item.SubType = Item.SubType>
   static override createDocuments<Temporary extends boolean | undefined = undefined>(
     data: Array<Item.Implementation | Item.CreateData> | undefined,
     operation?: Document.Database.CreateOperation<Item.Database.Create<Temporary>>,
-  ): Promise<Array<Document.TemporaryIf<Item.Implementation, Temporary>>>;
+  ): Promise<Array<Item.TemporaryIf<Temporary>>>;
 
   static override updateDocuments(
     updates: Item.UpdateData[] | undefined,
@@ -140,7 +140,7 @@ declare abstract class BaseItem<out SubType extends Item.SubType = Item.SubType>
   static override create<Temporary extends boolean | undefined = undefined>(
     data: Item.CreateData | Item.CreateData[],
     operation?: Item.Database.CreateOperation<Temporary>,
-  ): Promise<Document.TemporaryIf<Item.Implementation, Temporary> | undefined>;
+  ): Promise<Item.TemporaryIf<Temporary> | undefined>;
 
   override update(
     data: Item.UpdateData | undefined,
@@ -194,12 +194,12 @@ declare abstract class BaseItem<out SubType extends Item.SubType = Item.SubType>
   override getFlag<Scope extends Item.Flags.Scope, Key extends Item.Flags.Key<Scope>>(
     scope: Scope,
     key: Key,
-  ): Document.GetFlag<Item.Name, Scope, Key>;
+  ): Item.Flags.Get<Scope, Key>;
 
   override setFlag<
     Scope extends Item.Flags.Scope,
     Key extends Item.Flags.Key<Scope>,
-    Value extends Document.GetFlag<Item.Name, Scope, Key>,
+    Value extends Item.Flags.Get<Scope, Key>,
   >(scope: Scope, key: Key, value: Value): Promise<this>;
 
   override unsetFlag<Scope extends Item.Flags.Scope, Key extends Item.Flags.Key<Scope>>(
@@ -371,7 +371,8 @@ declare namespace BaseItem {
   export import InitializedData = Item.InitializedData;
   export import UpdateData = Item.UpdateData;
   export import Schema = Item.Schema;
-  export import DatabaseOperation = Item.Database;
+  export import Database = Item.Database;
+  export import TemporaryIf = Item.TemporaryIf;
   export import Flags = Item.Flags;
   export import GetDefaultArtworkReturn = Item.GetDefaultArtworkReturn;
 

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

@@ -85,7 +85,7 @@ declare abstract class BaseJournalEntryCategory extends Document<
   static override createDocuments<Temporary extends boolean | undefined = undefined>(
     data: Array<JournalEntryCategory.Implementation | JournalEntryCategory.CreateData> | undefined,
     operation?: Document.Database.CreateOperation<JournalEntryCategory.Database.Create<Temporary>>,
-  ): Promise<Array<Document.TemporaryIf<JournalEntryCategory.Implementation, Temporary>>>;
+  ): Promise<Array<JournalEntryCategory.TemporaryIf<Temporary>>>;
 
   static override updateDocuments(
     updates: JournalEntryCategory.UpdateData[] | undefined,
@@ -100,7 +100,7 @@ declare abstract class BaseJournalEntryCategory extends Document<
   static override create<Temporary extends boolean | undefined = undefined>(
     data: JournalEntryCategory.CreateData | JournalEntryCategory.CreateData[],
     operation?: JournalEntryCategory.Database.CreateOperation<Temporary>,
-  ): Promise<Document.TemporaryIf<JournalEntryCategory.Implementation, Temporary> | undefined>;
+  ): Promise<JournalEntryCategory.TemporaryIf<Temporary> | undefined>;
 
   override update(
     data: JournalEntryCategory.UpdateData | undefined,
@@ -122,12 +122,12 @@ declare abstract class BaseJournalEntryCategory extends Document<
   override getFlag<Scope extends JournalEntryCategory.Flags.Scope, Key extends JournalEntryCategory.Flags.Key<Scope>>(
     scope: Scope,
     key: Key,
-  ): Document.GetFlag<JournalEntryCategory.Name, Scope, Key>;
+  ): JournalEntryCategory.Flags.Get<Scope, Key>;
 
   override setFlag<
     Scope extends JournalEntryCategory.Flags.Scope,
     Key extends JournalEntryCategory.Flags.Key<Scope>,
-    Value extends Document.GetFlag<JournalEntryCategory.Name, Scope, Key>,
+    Value extends JournalEntryCategory.Flags.Get<Scope, Key>,
   >(scope: Scope, key: Key, value: Value): Promise<this>;
 
   override unsetFlag<Scope extends JournalEntryCategory.Flags.Scope, Key extends JournalEntryCategory.Flags.Key<Scope>>(
@@ -299,7 +299,8 @@ declare namespace BaseJournalEntryCategory {
   export import InitializedData = JournalEntry.InitializedData;
   export import UpdateData = JournalEntry.UpdateData;
   export import Schema = JournalEntry.Schema;
-  export import DatabaseOperation = JournalEntry.Database;
+  export import Database = JournalEntry.Database;
+  export import TemporaryIf = JournalEntry.TemporaryIf;
   export import Flags = JournalEntry.Flags;
 
   namespace Internal {

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

@@ -90,7 +90,7 @@ declare abstract class BaseJournalEntryPage<
   static override createDocuments<Temporary extends boolean | undefined = undefined>(
     data: Array<JournalEntryPage.Implementation | JournalEntryPage.CreateData> | undefined,
     operation?: Document.Database.CreateOperation<JournalEntryPage.Database.Create<Temporary>>,
-  ): Promise<Array<Document.TemporaryIf<JournalEntryPage.Implementation, Temporary>>>;
+  ): Promise<Array<JournalEntryPage.TemporaryIf<Temporary>>>;
 
   static override updateDocuments(
     updates: JournalEntryPage.UpdateData[] | undefined,
@@ -105,7 +105,7 @@ declare abstract class BaseJournalEntryPage<
   static override create<Temporary extends boolean | undefined = undefined>(
     data: JournalEntryPage.CreateData | JournalEntryPage.CreateData[],
     operation?: JournalEntryPage.Database.CreateOperation<Temporary>,
-  ): Promise<Document.TemporaryIf<JournalEntryPage.Implementation, Temporary> | undefined>;
+  ): Promise<JournalEntryPage.TemporaryIf<Temporary> | undefined>;
 
   override update(
     data: JournalEntryPage.UpdateData | undefined,
@@ -129,12 +129,12 @@ declare abstract class BaseJournalEntryPage<
   override getFlag<Scope extends JournalEntryPage.Flags.Scope, Key extends JournalEntryPage.Flags.Key<Scope>>(
     scope: Scope,
     key: Key,
-  ): Document.GetFlag<JournalEntryPage.Name, Scope, Key>;
+  ): JournalEntryPage.Flags.Get<Scope, Key>;
 
   override setFlag<
     Scope extends JournalEntryPage.Flags.Scope,
     Key extends JournalEntryPage.Flags.Key<Scope>,
-    Value extends Document.GetFlag<JournalEntryPage.Name, Scope, Key>,
+    Value extends JournalEntryPage.Flags.Get<Scope, Key>,
   >(scope: Scope, key: Key, value: Value): Promise<this>;
 
   override unsetFlag<Scope extends JournalEntryPage.Flags.Scope, Key extends JournalEntryPage.Flags.Key<Scope>>(
@@ -313,7 +313,8 @@ declare namespace BaseJournalEntryPage {
   export import InitializedData = JournalEntryPage.InitializedData;
   export import UpdateData = JournalEntryPage.UpdateData;
   export import Schema = JournalEntryPage.Schema;
-  export import DatabaseOperation = JournalEntryPage.Database;
+  export import Database = JournalEntryPage.Database;
+  export import TemporaryIf = JournalEntryPage.TemporaryIf;
   export import Flags = JournalEntryPage.Flags;
 
   namespace Internal {

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

@@ -101,7 +101,7 @@ declare abstract class BaseJournalEntry extends Document<"JournalEntry", BaseJou
   static override createDocuments<Temporary extends boolean | undefined = undefined>(
     data: Array<JournalEntry.Implementation | JournalEntry.CreateData> | undefined,
     operation?: Document.Database.CreateOperation<JournalEntry.Database.Create<Temporary>>,
-  ): Promise<Array<Document.TemporaryIf<JournalEntry.Implementation, Temporary>>>;
+  ): Promise<Array<JournalEntry.TemporaryIf<Temporary>>>;
 
   static override updateDocuments(
     updates: JournalEntry.UpdateData[] | undefined,
@@ -116,7 +116,7 @@ declare abstract class BaseJournalEntry extends Document<"JournalEntry", BaseJou
   static override create<Temporary extends boolean | undefined = undefined>(
     data: JournalEntry.CreateData | JournalEntry.CreateData[],
     operation?: JournalEntry.Database.CreateOperation<Temporary>,
-  ): Promise<Document.TemporaryIf<JournalEntry.Implementation, Temporary> | undefined>;
+  ): Promise<JournalEntry.TemporaryIf<Temporary> | undefined>;
 
   override update(
     data: JournalEntry.UpdateData | undefined,
@@ -173,12 +173,12 @@ declare abstract class BaseJournalEntry extends Document<"JournalEntry", BaseJou
   override getFlag<Scope extends JournalEntry.Flags.Scope, Key extends JournalEntry.Flags.Key<Scope>>(
     scope: Scope,
     key: Key,
-  ): Document.GetFlag<JournalEntry.Name, Scope, Key>;
+  ): JournalEntry.Flags.Get<Scope, Key>;
 
   override setFlag<
     Scope extends JournalEntry.Flags.Scope,
     Key extends JournalEntry.Flags.Key<Scope>,
-    Value extends Document.GetFlag<JournalEntry.Name, Scope, Key>,
+    Value extends JournalEntry.Flags.Get<Scope, Key>,
   >(scope: Scope, key: Key, value: Value): Promise<this>;
 
   override unsetFlag<Scope extends JournalEntry.Flags.Scope, Key extends JournalEntry.Flags.Key<Scope>>(
@@ -352,7 +352,8 @@ declare namespace BaseJournalEntry {
   export import InitializedData = JournalEntry.InitializedData;
   export import UpdateData = JournalEntry.UpdateData;
   export import Schema = JournalEntry.Schema;
-  export import DatabaseOperation = JournalEntry.Database;
+  export import Database = JournalEntry.Database;
+  export import TemporaryIf = JournalEntry.TemporaryIf;
   export import Flags = JournalEntry.Flags;
   export import CoreFlags = JournalEntry.CoreFlags;
 

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

@@ -128,7 +128,7 @@ declare abstract class BaseMacro<out SubType extends BaseMacro.SubType = BaseMac
   static override createDocuments<Temporary extends boolean | undefined = undefined>(
     data: Array<Macro.Implementation | Macro.CreateData> | undefined,
     operation?: Document.Database.CreateOperation<Macro.Database.Create<Temporary>>,
-  ): Promise<Array<Document.TemporaryIf<Macro.Implementation, Temporary>>>;
+  ): Promise<Array<Macro.TemporaryIf<Temporary>>>;
 
   static override updateDocuments(
     updates: Macro.UpdateData[] | undefined,
@@ -143,7 +143,7 @@ declare abstract class BaseMacro<out SubType extends BaseMacro.SubType = BaseMac
   static override create<Temporary extends boolean | undefined = undefined>(
     data: Macro.CreateData | Macro.CreateData[],
     operation?: Macro.Database.CreateOperation<Temporary>,
-  ): Promise<Document.TemporaryIf<Macro.Implementation, Temporary> | undefined>;
+  ): Promise<Macro.TemporaryIf<Temporary> | undefined>;
 
   override update(
     data: Macro.UpdateData | undefined,
@@ -164,12 +164,12 @@ declare abstract class BaseMacro<out SubType extends BaseMacro.SubType = BaseMac
   override getFlag<Scope extends Macro.Flags.Scope, Key extends Macro.Flags.Key<Scope>>(
     scope: Scope,
     key: Key,
-  ): Document.GetFlag<Macro.Name, Scope, Key>;
+  ): Macro.Flags.Get<Scope, Key>;
 
   override setFlag<
     Scope extends Macro.Flags.Scope,
     Key extends Macro.Flags.Key<Scope>,
-    Value extends Document.GetFlag<Macro.Name, Scope, Key>,
+    Value extends Macro.Flags.Get<Scope, Key>,
   >(scope: Scope, key: Key, value: Value): Promise<this>;
 
   override unsetFlag<Scope extends Macro.Flags.Scope, Key extends Macro.Flags.Key<Scope>>(
@@ -333,7 +333,8 @@ declare namespace BaseMacro {
   export import InitializedData = Macro.InitializedData;
   export import UpdateData = Macro.UpdateData;
   export import Schema = Macro.Schema;
-  export import DatabaseOperation = Macro.Database;
+  export import Database = Macro.Database;
+  export import TemporaryIf = Macro.TemporaryIf;
   export import Flags = Macro.Flags;
 
   namespace Internal {