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

package/src/foundry/common/documents/measured-template.d.mts

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -87,7 +87,7 @@ declare abstract class BaseSetting extends Document<"Setting", BaseSetting.Schem
   static override createDocuments<Temporary extends boolean | undefined = undefined>(
     data: Array<Setting.Implementation | Setting.CreateData> | undefined,
     operation?: Document.Database.CreateOperation<Setting.Database.Create<Temporary>>,
-  ): Promise<Array<Document.TemporaryIf<Setting.Implementation, Temporary>>>;
+  ): Promise<Array<Setting.TemporaryIf<Temporary>>>;
 
   static override updateDocuments(
     updates: Setting.UpdateData[] | undefined,
@@ -102,7 +102,7 @@ declare abstract class BaseSetting extends Document<"Setting", BaseSetting.Schem
   static override create<Temporary extends boolean | undefined = undefined>(
     data: Setting.CreateData | Setting.CreateData[],
     operation?: Setting.Database.CreateOperation<Temporary>,
-  ): Promise<Document.TemporaryIf<Setting.Implementation, Temporary> | undefined>;
+  ): Promise<Setting.TemporaryIf<Temporary> | undefined>;
 
   override update(
     data: Setting.UpdateData | undefined,
@@ -285,7 +285,8 @@ declare namespace BaseSetting {
   export import InitializedData = Setting.InitializedData;
   export import UpdateData = Setting.UpdateData;
   export import Schema = Setting.Schema;
-  export import DatabaseOperation = Setting.Database;
+  export import Database = Setting.Database;
+  export import TemporaryIf = Setting.TemporaryIf;
 
   namespace Internal {
     // Note(LukeAbby): The point of this is to give the base class of `Setting` a name.

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

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

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

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

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

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

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

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

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

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