@league-of-foundry-developers/foundry-vtt-types 13.340.1 → 13.345.1-beta.20250704.94554

package/src/foundry/common/data/validation-failure.d.mts

@@ -1,3 +1,5 @@
+import type { InexactPartial } from "#utils";
+
 /**
  * A class responsible for recording information about a validation failure.
  */
@@ -33,6 +35,7 @@ declare class DataModelValidationFailure {
 
   /**
    * If this field contains a list of elements that are validated as part of its validation, their results are recorded here.
+   * @defaultValue `{}`
    */
   elements: DataModelValidationFailure.ElementValidationFailure[];
 
@@ -57,12 +60,14 @@ declare class DataModelValidationFailure {
   /**
    * Return the base properties of this failure, omitting any nested failures.
    */
-  toObject(): DataModelValidationFailure.ToObject;
+  toObject(): DataModelValidationFailure.ToObjectReturn;
 
   /**
    * Represent the DataModelValidationFailure as a string.
    */
   toString(): string;
+
+  static #DataModelValidationFailure: true;
 }
 
 /**
@@ -73,7 +78,7 @@ declare class DataModelValidationError extends Error {
    * @param failure - The failure that triggered this error or an error message
    * @param params  - Additional Error constructor parameters
    */
-  constructor(failure: DataModelValidationFailure | string, options?: { cause?: Error | string });
+  constructor(failure: DataModelValidationFailure | string, options?: ErrorOptions);
 
   /**
    * Retrieve the root failure that caused this error, or a specific sub-failure via a path.
@@ -126,52 +131,57 @@ declare class DataModelValidationError extends Error {
    * Generate a nested tree view of the error as an HTML string.
    */
   asHTML(): string;
+
+  #DataModelValidationError: true;
 }
 
 declare namespace DataModelValidationFailure {
-  /** @deprecated {@link ConstructorOptions | `ConstructorOptions`} */
-  type ConstructorArgs = ConstructorOptions;
-
-  interface ConstructorOptions {
+  /** @internal */
+  type _ConstructorOptions = InexactPartial<{
     /** The value that failed validation for this field. */
-    invalidValue?: unknown;
+    invalidValue: unknown;
 
     /**  The value it was replaced by, if any. */
-    fallback?: unknown;
+    fallback: unknown;
 
     /**
      * Whether the value was dropped from some parent collection.
      * @defaultValue `false`
      */
-    dropped?: boolean | undefined;
+    dropped: boolean;
 
     /** The validation error message. */
-    message?: string | undefined;
+    message: string;
 
     /**
      * Whether this failure was unresolved
      * @defaultValue `false`
      */
-    unresolved?: boolean | undefined;
-  }
+    unresolved: boolean;
+  }>;
 
-  interface ElementValidationFailure {
-    /** Either the element's index or some other identifier for it. */
-    id: string | number;
+  interface ConstructorOptions extends _ConstructorOptions {}
 
+  /** @internal */
+  type _ElementValidationFailure = InexactPartial<{
     /** Optionally a user-friendly name for the element. */
     name?: string;
+  }>;
+
+  interface ElementValidationFailure extends _ElementValidationFailure {
+    /** Either the element's index or some other identifier for it. */
+    id: string | number;
 
     /** The element's validation failure. */
     failure: DataModelValidationFailure;
   }
 
-  interface ToObject {
-    invalidValue?: unknown;
-    fallback?: unknown;
-    dropped?: boolean | undefined;
-    message?: string | undefined;
-  }
+  /**
+   * @remarks {@linkcode DataModelValidationFailure.toObject | DataModelValidationFailure#toObject} returns
+   * its instance's properties of the same names
+   */
+  interface ToObjectReturn
+    extends Pick<DataModelValidationFailure, "invalidValue" | "fallback" | "dropped" | "message"> {}
 }
 
 export { DataModelValidationFailure, DataModelValidationError };

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

@@ -1,12 +1,12 @@
 /**
  * Test whether a string is a valid 16 character UID
  */
-export declare function isValidId(id: string | null): boolean;
+export declare function isValidId(id: string): boolean;
 
 /**
  * Test whether a file path has an extension in a list of provided extensions
  */
-export declare function hasFileExtension(path: string | null, extensions: string[]): boolean;
+export declare function hasFileExtension(path: string, extensions: string[]): boolean;
 
 /**
  * Test whether a string data blob contains base64 data, optionally of a specific type or types

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

@@ -14,11 +14,13 @@ export { default as BaseCards } from "./cards.mjs";
 export { default as BaseChatMessage } from "./chat-message.mjs";
 export { default as BaseCombat } from "./combat.mjs";
 export { default as BaseCombatant } from "./combatant.mjs";
+export { default as BaseCombatantGroup } from "./combatant-group.mjs";
 export { default as BaseDrawing } from "./drawing.mjs";
 export { default as BaseFogExploration } from "./fog-exploration.mjs";
 export { default as BaseFolder } from "./folder.mjs";
 export { default as BaseItem } from "./item.mjs";
 export { default as BaseJournalEntry } from "./journal-entry.mjs";
+export { default as BaseJournalEntryCategory } from "./journal-entry-category.mjs";
 export { default as BaseJournalEntryPage } from "./journal-entry-page.mjs";
 export { default as BaseMacro } from "./macro.mjs";
 export { default as BaseMeasuredTemplate } from "./measured-template.mjs";

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

@@ -1,147 +1,139 @@
-import type BaseActiveEffect from "./active-effect.d.mts";
-import type BaseCard from "./card.d.mts";
-import type BaseCards from "./cards.d.mts";
-import type BaseChatMessage from "./chat-message.d.mts";
-import type BaseCombat from "./combat.d.mts";
-import type BaseCombatant from "./combatant.d.mts";
-import type BaseDrawing from "./drawing.d.mts";
-import type BaseFogExploration from "./fog-exploration.d.mts";
-import type BaseFolder from "./folder.d.mts";
-import type BaseItem from "./item.d.mts";
-import type BaseJournalEntryPage from "./journal-entry-page.d.mts";
-import type BaseJournalEntry from "./journal-entry.d.mts";
-import type BaseMacro from "./macro.d.mts";
-import type BaseMeasuredTemplate from "./measured-template.d.mts";
-import type BaseNote from "./note.d.mts";
-import type BasePlaylistSound from "./playlist-sound.d.mts";
-import type BasePlaylist from "./playlist.d.mts";
-import type BaseRegionBehavior from "./region-behavior.d.mts";
-import type BaseRegion from "./region.d.mts";
-import type BaseRollTable from "./roll-table.d.mts";
-import type BaseScene from "./scene.d.mts";
-import type BaseSetting from "./setting.d.mts";
-import type BaseTableResult from "./table-result.d.mts";
-import type BaseTile from "./tile.d.mts";
-import type BaseToken from "./token.d.mts";
-import type BaseUser from "./user.d.mts";
-import type BaseWall from "./wall.d.mts";
+/* eslint-disable @typescript-eslint/no-unused-vars */
 
-/**
- * @deprecated This does not specify whether this is for source, initialized, or update data and
- * is used interchangeably with all of those.
- */
-export type ActiveEffectData = BaseActiveEffect.Properties;
+// After seeing that none of these types add anything or are even exported a
+// very reasonable question may be: Why on earth does this file exist?
+//
+// Well this is the file in which Foundry defines these types. We don't house
+// them here because it has poor discoverability. The names Foundry has chosen
+// also overlaps with other existing names, such as SettingConfig vs. ClientSetting.SettingConfig
 
-/**
- * @deprecated {@link ActiveEffect.DurationData | `ActiveEffect.DurationData`}
- */
-export type EffectDurationData = ActiveEffect.DurationData;
+export {};
 
-/**
- * @deprecated {@link ActiveEffect.EffectChangeData | `ActiveEffect.EffectChangeData`}
- */
-export type EffectChangeData = ActiveEffect.EffectChangeData;
-export interface AmbientSoundEffect {
-  type: keyof CONFIG["soundEffects"];
+type ActiveEffectData = ActiveEffect.InitializedData;
 
-  /**
-   * @defaultValue `5`
-   * @remarks Can't be `null` as {@link BiquadFilterNode} and {@link ConvolverNode} constructors both only have parameter defaults
-   */
-  intensity?: number | undefined;
-} // TODO: Maybe move when BaseAmbientSound's schema is updated.
+type EffectDurationData = ActiveEffect.DurationData;
 
-export type CardData = BaseCard.Properties;
+type EffectChangeData = ActiveEffect.ChangeData;
 
-export type CardFaceData = BaseCard.Properties["faces"][number];
+type ActorData = Actor.InitializedData;
 
-export type CardsData = BaseCards.Properties;
+type ActorDeltaData = ActorDelta.InitializedData;
 
-export type ChatMessageData = BaseChatMessage.Properties;
+type AdventureData = Adventure.InitializedData;
 
-export type ChatSpeakerData = BaseChatMessage.Properties["speaker"];
+type AmbientLightData = AmbientLightDocument.InitializedData;
 
-export type CombatData = BaseCombat.Properties;
+type AmbientSoundData = AmbientSoundDocument.InitializedData;
 
-export type CombatantData = BaseCombatant.Properties;
+type AmbientSoundEffect = AmbientSoundDocument.Effect;
 
-export type DrawingData = BaseDrawing.Properties;
+type CardData = Card.InitializedData;
 
-export type FogExplorationData = BaseFogExploration.Properties;
+type CardFaceData = Card.FaceData;
 
-export type FolderData = BaseFolder.Properties;
+type CardsData = Cards.InitializedData;
 
-export type ItemData = BaseItem.Properties;
+type ChatMessageData = ChatMessage.InitializedData;
 
-export type JournalEntryData = BaseJournalEntry.Properties;
+type ChatSpeakerData = ChatMessage.SpeakerData;
 
-export type JournalEntryPageImageData = BaseJournalEntryPage.Properties["image"];
+type CombatData = Combat.InitializedData;
 
-export type JournalEntryPageTextData = BaseJournalEntryPage.Properties["text"];
+type CombatantData = Combatant.InitializedData;
 
-export type JournalEntryPageVideoData = BaseJournalEntryPage.Properties["video"];
+type CombatantGroupData = CombatantGroup.InitializedData;
 
-export type JournalEntryPageTitleData = BaseJournalEntryPage.Properties["title"];
+type DrawingData = DrawingDocument.InitializedData;
 
-export type JournalEntryPageData = BaseJournalEntryPage.Properties;
+type FogExplorationData = FogExploration.InitializedData;
 
-export type MacroData = BaseMacro.Properties;
+type FolderData = Folder.InitializedData;
 
-export type MeasuredTemplateData = BaseMeasuredTemplate.Properties;
+type ItemData = Item.InitializedData;
 
-export type NoteData = BaseNote.Properties;
+type JournalEntryData = JournalEntry.InitializedData;
 
-export type PlaylistData = BasePlaylist.Properties;
+type JournalEntryCategoryData = JournalEntryCategory.InitializedData;
 
-export type PlaylistSoundData = BasePlaylistSound.Properties;
+type JournalEntryPageImageData = JournalEntryPage.InitializedData["image"];
 
-export type RollTableData = BaseRollTable.Properties;
+type JournalEntryPageTextData = JournalEntryPage.InitializedData["text"];
 
-export type SceneData = BaseScene.Properties;
+type JournalEntryPageVideoData = JournalEntryPage.InitializedData["video"];
 
-export type GridData = BaseScene.Properties["grid"];
+type JournalEntryPageTitleData = JournalEntryPage.InitializedData["title"];
 
-// TODO: Remove when BaseScene's schema is updated.
-// @ts-expect-error This still has to be typed
-export type EnvironmentData = BaseScene.Properties["environment"]["base"];
+type JournalEntryPageData = JournalEntryPage.InitializedData;
 
-export interface _GlobalLightData {
+type MacroData = Macro.InitializedData;
+
+type MeasuredTemplateData = MeasuredTemplateDocument.InitializedData;
+
+type NoteData = NoteDocument.InitializedData;
+
+type PlaylistData = Playlist.InitializedData;
+
+type PlaylistSoundData = PlaylistSound.InitializedData;
+
+type RollTableData = RollTable.InitializedData;
+
+type SceneData = Scene.InitializedData;
+
+type GridData = Scene.InitializedData["grid"];
+
+type EnvironmentData = Scene.InitializedData["environment"]["base"];
+
+interface _GlobalLightData {
   enabled: number; // TODO: Report as a likely error.
   bright: boolean;
 }
 
-// TODO: Remove when BaseScene's schema is updated.
-// @ts-expect-error This still has to be typed
-export type GlobalLightData = BaseScene.Properties["environment"]["globalLight"];
+type GlobalLightData = Scene.InitializedData["environment"]["globalLight"];
+
+type SceneEnvironmentData = Scene.InitializedData["environment"];
+
+type RegionData = RegionDocument.InitializedData;
+
+type RegionBehaviorData = RegionBehavior.InitializedData;
+
+type RegionSocketEvent = RegionDocument.SocketRegionEvent;
+
+type SettingData = Setting.InitializedData;
+
+type TableResultData = TableResult.InitializedData;
+
+type TileRestrictionsData = TileDocument.InitializedData["restrictions"];
+
+type TileOcclusionData = TileDocument.InitializedData["occlusion"];
+
+type TileVideoData = TileDocument.InitializedData["video"];
 
-// TODO: Remove when BaseScene's schema is updated.
-// @ts-expect-error This still has to be typed
-export type SceneEnvironmentData = BaseScene.Properties["environment"];
+type TileData = TileDocument.InitializedData;
 
-export type RegionData = BaseRegion.Properties;
+type TokenOcclusionData = TokenDocument.InitializedData["occludable"];
 
-export type RegionBehaviorData = BaseRegionBehavior.Properties;
+type TokenRingData = TokenDocument.InitializedData["ring"];
 
-export type SettingData = BaseSetting.Properties;
+type TokenData = TokenDocument.InitializedData;
 
-export type TableResultData = BaseTableResult.Properties;
+type PrototypeTokenData = unknown;
 
-export type TileOcclusionData = BaseTile.Properties["occlusion"];
+type TokenSightData = TokenDocument.InitializedData["sight"];
 
-export type TileVideoData = BaseTile.Properties["video"];
+type TokenDetectionMode = TokenDocument.DetectionModeData;
 
-export type TileData = BaseTile.Properties;
+type TokenBarData = TokenDocument.InitializedData["bar1"];
 
-export type TokenData = BaseToken.Properties;
+type TokenPosition = TokenDocument.Position;
 
-export type TokenSightData = BaseToken.Properties["sight"];
+type TokenDimensions = TokenDocument.Dimensions;
 
-export type TokenDetectionMode = BaseToken.Properties["detectionModes"][number];
+type TokenHexagonalOffsetsData = TokenDocument.HexagonalOffsetsData;
 
-export type TokenBarData = BaseToken.Properties["bar1"];
+type TokenHexagonalShapeData = unknown;
 
-export type UserData = BaseUser.Properties;
+type UserData = User.InitializedData;
 
-export type WallData = BaseWall.Properties;
+type WallData = WallDocument.InitializedData;
 
-export type WallThresholdData = BaseWall.Properties["threshold"];
+type WallThresholdData = WallDocument.ThresholdData;