@league-of-foundry-developers/foundry-vtt-types 9.238.0 → 9.249.0

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

@@ -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, PropertiesToSource } from '../../../types/helperTypes';
+import type { DocumentModificationOptions } from '../../common/abstract/document.mjs';
+import type { ChatMessageDataConstructorData } from '../../common/data/data.mjs/chatMessageData.js';
+import type { CombatantDataProperties } 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: PropertiesToSource<CombatantDataProperties>[],
       options: DocumentModificationOptions,
       userId: string
     ): void;
 
+    /** @override */
     protected _onUpdateEmbeddedDocuments(
       embeddedName: string,
-      documents: Combatant[],
-      result: DeepPartial<PropertiesToSource<CombatantDataProperties>>[],
+      documents: InstanceType<ConfiguredDocumentClass<typeof Combatant>>[],
+      result: PropertiesToSource<CombatantDataProperties>[],
       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/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 {

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

@@ -240,11 +240,21 @@ declare class ClientKeybindings {
   protected _onPan(context: KeyboardEventContext, movementDirections: ClientKeybindings.MovementDirection[]): boolean;
 
   /**
-   * Handle number key presses
+   * Handle Macro executions
    * @param context - The context data of the event
    * @internal
    */
-  protected static _onMacro(context: KeyboardEventContext): true;
+  protected static _onMacroExecute(
+    context: KeyboardEventContext,
+    number: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 0
+  ): boolean;
+
+  /**
+   * Handle Macro page swaps
+   * @param context - The context data of the event
+   * @internal
+   */
+  protected static _onMacroPageSwap(context: KeyboardEventContext, page: number): true;
 
   /**
    * Handle action to copy data to clipboard

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

@@ -211,7 +211,7 @@ declare namespace ClientSettings {
     label?: string;
     name?: string;
     restricted: boolean;
-    type: ConstructorOf<FormApplication<FormApplication.Options, object>>;
+    type: ConstructorOf<FormApplication<FormApplicationOptions, object>>;
   }
 
   interface RegisteredMenuSettings {
@@ -239,7 +239,7 @@ declare namespace ClientSettings {
     'core.nue.shownTips': boolean;
     'core.noCanvas': boolean;
     'core.permissions': Game.Permissions;
-    'core.rollMode': foundry.CONST.DICE_ROLL_MODES;
+    'core.rollMode': keyof CONFIG.Dice.RollModes;
     'core.softShadows': boolean;
     'core.time': number;
     'core.tokenDragPreview': boolean;

package/src/foundry/foundry.js/collections/documentCollection.d.ts

@@ -39,7 +39,7 @@ declare global {
     /**
      * Render any Applications associated with this DocumentCollection.
      */
-    render(force?: boolean, options?: Application.Options): void;
+    render(force?: boolean, options?: ApplicationOptions): void;
 
     /**
      * Update all objects in this DocumentCollection with a provided transformation.

package/src/foundry/foundry.js/collections/documentCollections/worldCollections/folders.d.ts

@@ -19,7 +19,7 @@ declare global {
     static documentName: 'Folder';
 
     /** @override */
-    render(force?: boolean, context?: Application.Options): void;
+    render(force?: boolean, context?: ApplicationOptions): void;
 
     /**
      * Refresh the display of any active JournalSheet instances where the folder list will change.

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

@@ -0,0 +1,60 @@
+/**
+ * An object containing the result of a collision test.
+ * @internal
+ */
+declare class CollisionResult {
+  constructor(values?: {
+    target?: PolygonVertex | null;
+    collisions?: PolygonVertex[];
+    cwEdges?: EdgeSet;
+    ccwEdges?: EdgeSet;
+    isBehind?: boolean;
+    isLimited?: boolean;
+    isRequired?: boolean;
+    wasLimited?: boolean;
+  });
+
+  /**
+   * The vertex that was the target of this result
+   * @defaultValue `null`
+   */
+  target: PolygonVertex | null;
+
+  /**
+   * The array of collision points which apply to this result
+   * @defaultValue `[]`
+   */
+  collisions: PolygonVertex[];
+
+  /**
+   * The set of edges connected to the target vertex that continue clockwise
+   * @defaultValue `new Set()`
+   */
+  cwEdges: EdgeSet;
+
+  /**
+   * The set of edges connected to the target vertex that continue counter-clockwise
+   * @defaultValue `new Set()`
+   */
+  ccwEdges: EdgeSet;
+
+  /**
+   * Is the target vertex for this result behind some closer active edge?
+   */
+  isBehind: boolean | undefined;
+
+  /**
+   * Does the target vertex for this result impose a limited collision?
+   */
+  isLimited: boolean | undefined;
+
+  /**
+   * Is this result required due to a limited angle?
+   */
+  isRequired: boolean | undefined;
+
+  /**
+   * Has the set of collisions for this result encountered a limited edge?
+   */
+  wasLimited: boolean | undefined;
+}