@league-of-foundry-developers/foundry-vtt-types 9.238.1 → 9.249.1

package/src/foundry/foundry.js/canvasAnimation.d.ts

@@ -1,3 +1,17 @@
+interface CanvasAnimationData {
+  /** The animation function being executed each frame */
+  fn: (dt: number) => void;
+
+  /** The object context within which animation occurs */
+  context: PIXI.DisplayObject;
+
+  /** A Promise which resolves once the animation is complete */
+  promise: Promise<boolean>;
+
+  /** The resolution function, allowing animation to be ended early */
+  resolve: (value: boolean) => void;
+}
+
 /**
  * A helper class providing utility methods for PIXI Canvas animation
  */
@@ -8,9 +22,7 @@ declare class CanvasAnimation {
    * Track an object of active animations by name, context, and function
    * This allows a currently playing animation to be referenced and terminated
    */
-  static animations: Partial<
-    Record<string, { fn: (dt: number) => void; context: PIXI.Container; resolve: (value: boolean) => void }>
-  >;
+  static animations: Record<string, CanvasAnimationData>;
 
   /**
    * Apply a linear animation from the current value of some attribute to a new value
@@ -42,6 +54,13 @@ declare class CanvasAnimation {
     options?: InexactPartial<LinearAnimationOptions>
   ): Promise<boolean>;
 
+  /**
+   * Retrieve an animation currently in progress by its name
+   * @param name - The animation name to retrieve
+   * @returns The animation data, or undefined
+   */
+  static getAnimation(name: string): CanvasAnimationData | undefined;
+
   /**
    * If an animation using a certain name already exists, terminate it
    * @param name - The animation name to terminate
@@ -75,7 +94,7 @@ declare class CanvasAnimation {
    */
   protected static _animateFrame(
     deltaTime: number,
-    resolve: (value: boolean) => void,
+    resolve: CanvasAnimationData['resolve'],
     reject: (reason?: any) => void,
     attributes: CanvasAnimation.Attribute[],
     duration: number,
@@ -85,8 +104,12 @@ declare class CanvasAnimation {
 
 declare namespace CanvasAnimation {
   interface Attribute {
-    parent: any;
     attribute: string;
+    d?: number;
+    delta?: number;
+    done?: number;
+    parent: any;
+    remaining?: number;
     to: number;
   }
 }
@@ -95,7 +118,7 @@ interface LinearAnimationOptions {
   /**
    * An animation context to use which defines scope
    */
-  context: PIXI.Container;
+  context: PIXI.DisplayObject;
 
   /**
    * Provide a unique animation name which may be referenced later
@@ -117,7 +140,7 @@ interface LinearAnimationOptions {
 type TickFunction = (dt: number, attributes: CanvasAnimation.Attribute[]) => void;
 type TransitionFunction = (
   dt: number,
-  resolve: (value: boolean) => void,
+  resolve: CanvasAnimationData['resolve'],
   reject: (reason?: any) => void,
   attributes: CanvasAnimation.Attribute[],
   duration: number,

package/src/foundry/foundry.js/clientDocumentMixin.d.ts

@@ -11,6 +11,40 @@ declare global {
   const ClientDocumentMixin: <T extends ConstructorOf<foundry.abstract.Document<any, any>>>(
     Base: T
   ) => ClientDocumentConstructor<T>;
+
+  namespace ClientDocumentMixin {
+    interface CompendiumExportOptions {
+      /**
+       * Clear the flags object
+       * @defaultValue `false`
+       */
+      clearFlags?: boolean | undefined;
+
+      /**
+       * Clear the currently assigned folder and sort order
+       * @defaultValue `true`
+       */
+      clearSort?: boolean | undefined;
+
+      /**
+       * Clear document permissions
+       * @defaultValue `true`
+       */
+      clearPermissions?: boolean | undefined;
+
+      /**
+       * Clear fields which store document state
+       * @defaultValue `true`
+       */
+      clearState?: boolean | undefined;
+
+      /**
+       * Retain the current Document id
+       * @defaultValue `false`
+       */
+      keepId?: boolean | undefined;
+    }
+  }
 }
 
 type ClientDocumentConstructor<T extends ConstructorOf<foundry.abstract.Document<any, any>>> = Pick<T, keyof T> &
@@ -275,7 +309,8 @@ export declare class ClientDocumentMixin<T extends foundry.abstract.Document<any
    *                  (default: `{}`)
    * @param context - Additional context options or dialog positioning options
    *                  (default: `{}`)
-   * @returns A Promise which resolves to the created Document
+   * @returns A Promise which resolves to the created Document, or null if the dialog was
+   *          closed.
    */
   static createDialog<T extends DocumentConstructor>(
     this: T,
@@ -300,7 +335,7 @@ export declare class ClientDocumentMixin<T extends foundry.abstract.Document<any
    * Export document data to a JSON file which can be saved by the client and later imported into a different session.
    * @param options - Additional options passed to the {@link ClientDocumentMixin#toCompendium} method
    */
-  exportToJSON(options?: CompendiumExportOptions): void;
+  exportToJSON(options?: ClientDocumentMixin.CompendiumExportOptions): void;
 
   /**
    * A helper function to handle obtaining the relevant Document from dropped data provided via a DataTransfer event.
@@ -343,7 +378,7 @@ export declare class ClientDocumentMixin<T extends foundry.abstract.Document<any
    */
   toCompendium(
     pack?: CompendiumCollection<CompendiumCollection.Metadata> | null,
-    options?: CompendiumExportOptions
+    options?: ClientDocumentMixin.CompendiumExportOptions
   ): Omit<T['data']['_source'], '_id' | 'folder' | 'permission'> & {
     permission?: T['data']['_source']['permission'];
   };
@@ -354,38 +389,6 @@ export declare class ClientDocumentMixin<T extends foundry.abstract.Document<any
   prepareEmbeddedEntities(): void;
 }
 
-interface CompendiumExportOptions {
-  /**
-   * Clear the flags object
-   * @defaultValue `false`
-   */
-  clearFlags: boolean;
-
-  /**
-   * Clear the currently assigned folder and sort order
-   * @defaultValue `true`
-   */
-  clearSort: boolean;
-
-  /**
-   * Clear document permissions
-   * @defaultValue `true`
-   */
-  clearPermissions: boolean;
-
-  /**
-   * Clear fields which store document state
-   * @defaultValue `true`
-   */
-  clearState: boolean;
-
-  /**
-   * Retain the current Document id
-   * @defaultValue `false`
-   */
-  keepId: boolean;
-}
-
 interface SortOptions<T> {
   /**
    * @defaultValue `[]`

package/src/foundry/foundry.js/clientDocuments/activeEffect.d.ts

@@ -1,6 +1,6 @@
 import { ConfiguredDocumentClass } from '../../../types/helperTypes';
 import { DocumentModificationOptions } from '../../common/abstract/document.mjs';
-import type { ActiveEffectDataConstructorData } from '../../common/data/data.mjs/activeEffectData.js';
+import type { ActiveEffectDataConstructorData } from '../../common/data/data.mjs/activeEffectData';
 import { EffectChangeData } from '../../common/data/data.mjs/effectChangeData';
 
 declare global {

package/src/foundry/foundry.js/clientDocuments/actor.d.ts

@@ -120,7 +120,7 @@ declare global {
     /**
      * Prepare a data object which defines the data schema used by dice roll commands against this Actor
      */
-    getRollData(): this['data']['data'];
+    getRollData(): object;
 
     /** @override */
     protected _getSheetClass(): ConstructorOf<FormApplication> | null;

package/src/foundry/foundry.js/clientDocuments/card.d.ts

@@ -47,7 +47,8 @@ declare global {
     get source(): InstanceType<ConfiguredDocumentClassForName<'Cards'>> | undefined | null;
 
     /**
-     * A convenience property for whether or not the Card is within its source Cards stack.
+     * A convenience property for whether or not the Card is within its source Cards stack. Cards in decks are always
+     * considered home.
      */
     get isHome(): boolean;
 

package/src/foundry/foundry.js/clientDocuments/cards.d.ts

@@ -99,11 +99,8 @@ declare global {
      * Shuffle this Cards stack, randomizing the sort order of all the cards it contains.
      * @param options - (default: `{}`)
      * @returns The Cards document after the shuffle operation has completed
-     * @remarks The returns documentaion is incorrect (https://gitlab.com/foundrynet/foundryvtt/-/issues/6367).
      */
-    shuffle(
-      options?: Cards.ShuffleOptions | undefined
-    ): Promise<InstanceType<ConfiguredDocumentClassForName<'Card'>>[]>;
+    shuffle(options?: Cards.ShuffleOptions | undefined): Promise<InstanceType<ConfiguredDocumentClassForName<'Cards'>>>;
 
     /**
      * Reset the Cards stack, retrieving all original cards from other stacks where they may have been drawn if this is a
@@ -111,13 +108,8 @@ declare global {
      * @param options - Options which modify the reset operation
      *                  (default: `{}`)
      * @returns The Cards document after the reset operation has completed
-     * @remarks The returns documentaion is incorrect (https://gitlab.com/foundrynet/foundryvtt/-/issues/6367).
      */
-    reset(
-      options?: Cards.ResetOptions | undefined
-    ): Promise<
-      InstanceType<ConfiguredDocumentClassForName<'Card'>>[] | InstanceType<ConfiguredDocumentClassForName<'Cards'>>
-    >;
+    reset(options?: Cards.ResetOptions | undefined): Promise<InstanceType<ConfiguredDocumentClassForName<'Cards'>>>;
 
     /**
      * Perform a reset operation for a deck, retrieving all original cards from other stacks where they may have been
@@ -126,11 +118,10 @@ declare global {
      *                  (default: `{}`)
      * @returns The Cards document after the reset operation has completed.
      * @internal
-     * @remarks The returns documentaion is incorrect (https://gitlab.com/foundrynet/foundryvtt/-/issues/6367).
      */
     protected _resetDeck(
       options?: Cards.ResetOptions | undefined
-    ): Promise<InstanceType<ConfiguredDocumentClassForName<'Card'>>[]>;
+    ): Promise<InstanceType<ConfiguredDocumentClassForName<'Cards'>>>;
 
     /**
      * Return all cards in this stack to their original decks.
@@ -220,15 +211,10 @@ declare global {
      * Display a dialog which prompts the user to play a specific Card to some other Cards document
      * @see {@link Cards#pass}
      * @param card - The specific card being played as part of this dialog
-     * @remarks returns documentation is incorrect.
      */
     playDialog(
       card: InstanceType<ConfiguredDocumentClassForName<'Card'>>
-    ): Promise<
-      | InstanceType<ConfiguredDocumentClassForName<'Card'>>[]
-      | InstanceType<ConfiguredDocumentClassForName<'Cards'>>
-      | null
-    >;
+    ): Promise<InstanceType<ConfiguredDocumentClassForName<'Card'>>[] | void | null>;
 
     /**
      * Display a confirmation dialog for whether or not the user wishes to reset a Cards stack

package/src/foundry/foundry.js/clientDocuments/chatMessage.d.ts

@@ -1,6 +1,6 @@
 import { ConfiguredDocumentClass } from '../../../types/helperTypes';
 import { DocumentModificationOptions } from '../../common/abstract/document.mjs';
-import type { ChatMessageDataConstructorData } from '../../common/data/data.mjs/chatMessageData.js';
+import type { ChatMessageDataConstructorData } from '../../common/data/data.mjs/chatMessageData';
 
 declare global {
   /**
@@ -74,14 +74,14 @@ declare global {
      */
     static applyRollMode(
       chatData: ChatMessageDataConstructorData,
-      rollMode: foundry.CONST.DICE_ROLL_MODES
+      rollMode: keyof typeof CONFIG.Dice.rollModes | 'roll'
     ): ChatMessageDataConstructorData;
 
     /**
      * Update the data of a ChatMessage instance to apply a requested rollMode
      * @param rollMode - The rollMode preference to apply to this message data
      */
-    applyRollMode(rollMode: foundry.CONST.DICE_ROLL_MODES): void;
+    applyRollMode(rollMode: keyof typeof CONFIG.Dice.rollModes | 'roll'): void;
 
     /**
      * Attempt to determine who is the speaking character (and token) for a certain Chat Message

package/src/foundry/foundry.js/clientDocuments/combat.d.ts

@@ -1,7 +1,7 @@
-import { ConfiguredDocumentClass, PropertiesToSource } from '../../../types/helperTypes';
-import { DocumentModificationOptions } from '../../common/abstract/document.mjs';
-import { CombatantDataProperties } from '../../common/data/data.mjs/combatantData';
-import type { CombatDataConstructorData } from '../../common/data/data.mjs/combatData.js';
+import type { ConfiguredDocumentClass } from '../../../types/helperTypes';
+import type { DocumentModificationOptions } from '../../common/abstract/document.mjs';
+import type { ChatMessageDataConstructorData } from '../../common/data/data.mjs/chatMessageData';
+import type { CombatantDataSource } from '../../common/data/data.mjs/combatantData';
 
 declare global {
   /**
@@ -12,10 +12,11 @@ declare global {
    * @see {@link documents.Combats}             The world-level collection of Combat documents
    * @see {@link embedded.Combatant}            The Combatant embedded document which exists within a Combat document
    * @see {@link applications.CombatConfig}     The Combat configuration application
-   *
-   * @param data - Initial data provided to construct the Combat document
    */
   class Combat extends ClientDocumentMixin(foundry.documents.BaseCombat) {
+    /**
+     * @param data - Initial data provided to construct the Combat document
+     */
     constructor(
       data?: ConstructorParameters<ConstructorOf<foundry.documents.BaseCombat>>[0],
       context?: ConstructorParameters<ConstructorOf<foundry.documents.BaseCombat>>[1]
@@ -33,6 +34,7 @@ declare global {
     /**
      * Track whether a sound notification is currently being played to avoid double-dipping
      * @defaultValue `false`
+     * @internal
      */
     protected _soundPlaying: boolean;
 
@@ -40,7 +42,7 @@ declare global {
     static CONFIG_SETTING: 'combatTrackerConfig';
 
     /** Get the Combatant who has the current turn. */
-    get combatant(): this['turns'][number];
+    get combatant(): this['turns'][number] | undefined;
 
     /** The numeric round of the Combat encounter */
     get round(): number;
@@ -58,10 +60,13 @@ declare global {
     get started(): boolean;
 
     /** The numeric turn of the combat round in the Combat encounter */
-    get turn(): number;
+    get turn(): number | null;
 
     get visible(): true;
 
+    /** Is this combat active in the current scene? */
+    get isActive(): boolean;
+
     /**
      * Set the current Combat encounter as active within the Scene.
      * Deactivate all other Combat encounters within the viewed Scene and set this one as active
@@ -78,7 +83,13 @@ declare global {
      * Get a Combatant using its Token id
      * @param tokenId - The id of the Token for which to acquire the combatant
      */
-    getCombatantByToken(tokenId: string): ReturnType<this['combatants']['find']>;
+    getCombatantByToken(tokenId: string): InstanceType<ConfiguredDocumentClass<typeof Combatant>> | undefined;
+
+    /**
+     * Get a Combatant using its Actor id
+     * @param actorId - The id of the Actor for which to acquire the combatant
+     */
+    getCombatantByActor(actorId: string): InstanceType<ConfiguredDocumentClass<typeof Combatant>> | undefined;
 
     /** Advance the combat to the next round */
     nextRound(): Promise<this | undefined>;
@@ -95,15 +106,18 @@ declare global {
     /** Rewind the combat to the previous turn */
     previousTurn(): Promise<this | undefined>;
 
+    /** Toggle whether this combat is linked to the scene or globally available. */
+    toggleSceneLink(): Promise<this | undefined>;
+
     /** Reset all combatant initiative scores, setting the turn back to zero */
     resetAll(): Promise<this | undefined>;
 
     /**
-     * Roll initiative for one or multiple Combatants within the Combat entity
-     * @param ids - A Combatant id or Array of ids for which to roll
+     * Roll initiative for one or multiple Combatants within the Combat document
+     * @param ids     - A Combatant id or Array of ids for which to roll
      * @param options - Additional options which modify how initiative rolls are created or presented.
      *                  default `{}`
-     * @returns  A promise which resolves to the updated Combat entity once updates are complete.
+     * @returns A promise which resolves to the updated Combat document once updates are complete.
      */
     rollInitiative(ids: string | string[], options?: InitiativeOptions): Promise<this>;
 
@@ -112,19 +126,19 @@ declare global {
      * @param options - Additional options forwarded to the Combat.rollInitiative method
      *                  default `{}`
      */
-    rollAll(options?: InitiativeOptions): this['rollInitiative'];
+    rollAll(options?: InitiativeOptions): Promise<this>;
 
     /**
      * Roll initiative for all non-player actors who have not already rolled
      * @param options - Additional options forwarded to the Combat.rollInitiative method
      *                  default `{}`
      */
-    rollNPC(options?: InitiativeOptions): this['rollInitiative'];
+    rollNPC(options?: InitiativeOptions): Promise<this>;
 
     /**
      * Assign initiative for a single Combatant within the Combat encounter.
      * Update the Combat turn order to maintain the same combatant as the current turn.
-     * @param id - The combatant ID for which to set initiative
+     * @param id    - The combatant ID for which to set initiative
      * @param value - A specific initiative value to set
      */
     setInitiative(id: string, value: number): Promise<void>;
@@ -139,66 +153,52 @@ declare global {
      * Define how the array of Combatants is sorted in the displayed list of the tracker.
      * This method can be overridden by a system or module which needs to display combatants in an alternative order.
      * By default sort by initiative, next falling back to name, lastly tie-breaking by combatant id.
+     * @internal
      */
     protected _sortCombatants(
       a: InstanceType<ConfiguredDocumentClass<typeof Combatant>>,
       b: InstanceType<ConfiguredDocumentClass<typeof Combatant>>
     ): number;
 
+    /** @override */
     protected _onCreate(data: this['data']['_source'], options: DocumentModificationOptions, userId: string): void;
 
+    /** @override */
     protected _onUpdate(
       changed: DeepPartial<this['data']['_source']>,
       options: DocumentModificationOptions,
       userId: string
-    ): void; //TODO Returntype could also be CombatTracker.scrollToTurn
+    ): void;
 
+    /** @override */
     protected _onDelete(options: DocumentModificationOptions, userId: string): void;
 
+    /** @override */
     protected _onCreateEmbeddedDocuments(
-      embeddedName: string,
-      documents: Combatant[],
-      result: DeepPartial<PropertiesToSource<CombatantDataProperties>>[],
+      type: string,
+      documents: InstanceType<ConfiguredDocumentClass<typeof Combatant>>[],
+      result: CombatantDataSource[],
       options: DocumentModificationOptions,
       userId: string
     ): void;
 
+    /** @override */
     protected _onUpdateEmbeddedDocuments(
       embeddedName: string,
-      documents: Combatant[],
-      result: DeepPartial<PropertiesToSource<CombatantDataProperties>>[],
+      documents: InstanceType<ConfiguredDocumentClass<typeof Combatant>>[],
+      result: CombatantDataSource[],
       options: DocumentModificationOptions,
       userId: string
     ): void;
 
+    /** @override */
     protected _onDeleteEmbeddedDocuments(
       embeddedName: string,
-      documents: Combatant[],
+      documents: InstanceType<ConfiguredDocumentClass<typeof Combatant>>[],
       result: string[],
       options: DocumentModificationContext,
       userId: string
     ): void;
-
-    /** @deprecated since 0.8.0 */
-    getCombatant(id: string): this['combatants']['get'];
-
-    /** @deprecated since 0.8.0 */
-    createCombatant(
-      data: CombatDataConstructorData | (CombatDataConstructorData & Record<string, unknown>),
-      options?: DocumentModificationContext
-    ): this['createEmbeddedDocuments'];
-
-    /** @deprecated since 0.8.0 */
-    updateCombatant(
-      data: DeepPartial<CombatDataConstructorData | (CombatDataConstructorData & Record<string, unknown>)>,
-      options?: DocumentModificationContext
-    ): NonNullable<ReturnType<this['combatants']['get']>>['update'];
-
-    /** @deprecated since 0.8.0 */
-    deleteCombatant(
-      id: string,
-      options?: DocumentModificationContext
-    ): NonNullable<ReturnType<this['combatants']['get']>>['delete'];
   }
 }
 
@@ -208,16 +208,18 @@ interface InitiativeOptions {
    * @defaultValue `null`
    */
   formula?: string | null;
+
   /**
    * Update the Combat turn after adding new initiative scores to keep the turn on the same Combatant.
    * @defaultValue `true`
    */
   updateTurn?: boolean;
+
   /**
    * Additional options with which to customize created Chat Messages
    * @defaultValue `{}`
    */
-  messageOptions?: object; //TODO Type properly once ChatMessage is typed
+  messageOptions?: ChatMessageDataConstructorData;
 }
 
 interface RoundData {

package/src/foundry/foundry.js/clientDocuments/combatant.d.ts

@@ -1,5 +1,4 @@
 import { ConfiguredDocumentClass } from '../../../types/helperTypes';
-import { BaseUser } from '../../common/documents.mjs';
 
 declare global {
   /**
@@ -22,18 +21,6 @@ declare global {
       context: ConstructorParameters<typeof foundry.documents.BaseCombatant>[1]
     );
 
-    /**
-     * A cached reference to the Token which this Combatant represents, if any
-     * @defaultValue `undefined`
-     * */
-    protected _token: InstanceType<ConfiguredDocumentClass<typeof foundry.documents.BaseToken>> | null | undefined;
-
-    /**
-     * A cached reference to the Actor which this Combatant represents, if any
-     * @defaultValue `undefined`
-     * */
-    protected _actor: InstanceType<ConfiguredDocumentClass<typeof foundry.documents.BaseActor>> | null | undefined;
-
     /** The current value of the special tracked resource which pertains to this Combatant */
     resource: `${number}` | number | boolean | null;
 
@@ -54,8 +41,8 @@ declare global {
     /** @override */
     get isOwner(): boolean;
 
-    /** Is this Combatant entry currently visible in the Combat Tracker? */
-    get isVisible(): boolean;
+    /** @override */
+    get visible(): boolean;
 
     /** Is this Combatant "hidden", either because they are explicitly marked as hidden or because their token is hidden */
     get hidden(): boolean;
@@ -72,9 +59,14 @@ declare global {
     /** An array of User documents who have ownership of this Document */
     get players(): InstanceType<ConfiguredDocumentClass<typeof foundry.documents.BaseUser>>[];
 
+    /**
+     * Has this combatant been marked as defeated?
+     */
+    get isDefeated(): boolean;
+
     /** @override */
     testUserPermission(
-      user: BaseUser,
+      user: foundry.documents.BaseUser,
       permission: keyof typeof foundry.CONST.DOCUMENT_PERMISSION_LEVELS | foundry.CONST.DOCUMENT_PERMISSION_LEVELS,
       { exact }?: { exact?: boolean }
     ): boolean;
@@ -89,7 +81,7 @@ declare global {
     /**
      * Roll initiative for this particular combatant.
      * @param formula - A dice formula which overrides the default for this Combatant.
-     * @returns The Roll instance to use for the combatant.
+     * @returns The updated Combatant.
      */
     rollInitiative(formula: string): Promise<this | undefined>;
 
@@ -107,6 +99,11 @@ declare global {
      * @returns  The initiative formula to use for this combatant.
      */
     protected _getInitiativeFormula(): string;
+
+    /**
+     * @deprecated since v9
+     */
+    get isVisible(): boolean;
   }
 }
 export {};

package/src/foundry/foundry.js/clientDocuments/folder.d.ts

@@ -1,6 +1,5 @@
-import { ConfiguredDocumentClass } from '../../../types/helperTypes';
+import { ConfiguredDocumentClass, ConstructorDataType, DocumentConstructor } from '../../../types/helperTypes';
 import { DocumentModificationOptions } from '../../common/abstract/document.mjs';
-import type { FolderDataConstructorData } from '../../common/data/data.mjs/folderData.js';
 
 declare global {
   /**
@@ -65,14 +64,21 @@ declare global {
      * @returns An active FolderConfig instance for creating the new Folder entity
      *
      * @remarks
-     * This actually returns a FolderConfig but that is incorrectly overriding
-     * ClientDocumentMixin.createDialog, for which a Promise of the created
-     * Document is returned.
+     * The documented return type is incorrect. It now returns a promise that resolves to the
+     * created folder as intended. See https://gitlab.com/foundrynet/foundryvtt/-/issues/6619
+     *
+     * For weird reasons, we need to make this generic.
      */
-    static createDialog(
-      data?: DeepPartial<FolderDataConstructorData | (FolderDataConstructorData & Record<string, unknown>)> | undefined,
-      options?: Dialog.Options | undefined
-    ): any;
+    static createDialog<T extends DocumentConstructor>(
+      this: T,
+      data?:
+        | DeepPartial<
+            | ConstructorDataType<InstanceType<T>['data']>
+            | (ConstructorDataType<InstanceType<T>['data']> & Record<string, unknown>)
+          >
+        | undefined,
+      options?: Partial<DocumentSheetOptions> | undefined
+    ): Promise<InstanceType<ConfiguredDocumentClass<T>> | null | undefined>;
 
     /**
      * Export all Documents contained in this Folder to a given Compendium pack.

package/src/foundry/foundry.js/clientDocuments/item.d.ts

@@ -1,5 +1,5 @@
 import { ConfiguredDocumentClass } from '../../../types/helperTypes';
-import type { ItemDataConstructorData } from '../../common/data/data.mjs/itemData.js';
+import type { ItemDataConstructorData } from '../../common/data/data.mjs/itemData';
 
 declare global {
   /**
@@ -43,7 +43,7 @@ declare global {
     /**
      * Prepare a data object which defines the data schema used by dice roll commands against this Item
      */
-    getRollData(): this['data']['data'];
+    getRollData(): object;
 
     /** @override */
     protected _getSheetClass(): typeof ItemSheet | null;

package/src/foundry/foundry.js/clientDocuments/playlist.d.ts

@@ -1,6 +1,6 @@
 import type { ConfiguredDocumentClass } from '../../../types/helperTypes';
 import type { DocumentModificationOptions } from '../../common/abstract/document.mjs';
-import type { PlaylistDataConstructorData } from '../../common/data/data.mjs/playlistData.js';
+import type { PlaylistDataConstructorData } from '../../common/data/data.mjs/playlistData';
 
 declare global {
   /**

package/src/foundry/foundry.js/clientDocuments/rollTable.d.ts

@@ -158,7 +158,7 @@ declare global {
       /**
        * The chat roll mode to use when displaying the result
        */
-      rollMode: foundry.CONST.DICE_ROLL_MODES;
+      rollMode: keyof CONFIG.Dice.RollModes | 'roll';
     }
 
     /**
@@ -180,7 +180,7 @@ declare global {
        * Additional options which customize the created messages
        * @defaultValue `{}`
        */
-      messageOptions: ConstructorParameters<typeof foundry.documents.BaseChatMessage>[1];
+      messageOptions: DocumentModificationContext & { rollMode: keyof CONFIG.Dice.RollModes | 'roll' };
     }
 
     interface RollOptions {