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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@league-of-foundry-developers/foundry-vtt-types",
-  "version": "9.238.1",
+  "version": "9.242.0",
   "description": "TypeScript type definitions for Foundry VTT",
   "exports": {
     ".": {

package/src/foundry/common/constants.mjs.d.ts

@@ -721,6 +721,7 @@ export type WALL_DOOR_STATES = ValueOf<typeof WALL_DOOR_STATES>;
  * The wall properties which restrict the way interaction occurs with a specific wall
  */
 export const WALL_RESTRICTION_TYPES: readonly ['light', 'sight', 'sound', 'move'];
+export type WALL_RESTRICTION_TYPES = ValueOf<typeof WALL_RESTRICTION_TYPES>;
 
 /**
  * The types of sensory collision which a Wall may impose

package/src/foundry/common/data/data.mjs/adventureData.d.ts

@@ -2,16 +2,16 @@ import type { PropertiesToSource } from '../../../../types/helperTypes.js';
 import type DocumentData from '../../abstract/data.mjs';
 import { AnyDocumentData } from '../../abstract/data.mjs';
 import * as fields from '../fields.mjs';
-import type { ActorData } from './actorData.js';
-import type { CardsData } from './cardsData.js';
-import type { CombatData } from './combatData.js';
-import type { FolderData } from './folderData.js';
-import type { ItemData } from './itemData.js';
-import type { JournalEntryData } from './journalEntryData.js';
-import type { MacroData } from './macroData.js';
-import type { PlaylistData } from './playlistData.js';
-import type { RollTableData } from './rollTableData.js';
-import type { SceneData } from './sceneData.js';
+import type { ActorData, ActorDataConstructorData } from './actorData.js';
+import type { CardsData, CardsDataConstructorData } from './cardsData.js';
+import type { CombatData, CombatDataConstructorData } from './combatData.js';
+import type { FolderData, FolderDataConstructorData } from './folderData.js';
+import type { ItemData, ItemDataConstructorData } from './itemData.js';
+import type { JournalEntryData, JournalEntryDataConstructorData } from './journalEntryData.js';
+import type { MacroData, MacroDataConstructorData } from './macroData.js';
+import type { PlaylistData, PlaylistDataConstructorData } from './playlistData.js';
+import type { RollTableData, RollTableDataConstructorData } from './rollTableData.js';
+import type { SceneData, SceneDataConstructorData } from './sceneData.js';
 
 interface AdventureDataSchema extends DocumentSchema {
   _id: fields.DocumentId;
@@ -92,34 +92,34 @@ interface AdventureDataConstructorData {
   description?: string | null | undefined;
 
   /** @defaultValue `[]` */
-  actors?: ActorData[] | null | undefined;
+  actors?: ActorDataConstructorData[] | null | undefined;
 
   /** @defaultValue `[]` */
-  combats?: CombatData[] | null | undefined;
+  combats?: CombatDataConstructorData[] | null | undefined;
 
   /** @defaultValue `[]` */
-  items?: ItemData[] | null | undefined;
+  items?: ItemDataConstructorData[] | null | undefined;
 
   /** @defaultValue `[]` */
-  scenes?: SceneData[] | null | undefined;
+  scenes?: SceneDataConstructorData[] | null | undefined;
 
   /** @defaultValue `[]` */
-  journal?: JournalEntryData[] | null | undefined;
+  journal?: JournalEntryDataConstructorData[] | null | undefined;
 
   /** @defaultValue `[]` */
-  tables?: RollTableData[] | null | undefined;
+  tables?: RollTableDataConstructorData[] | null | undefined;
 
   /** @defaultValue `[]` */
-  macros?: MacroData[] | null | undefined;
+  macros?: MacroDataConstructorData[] | null | undefined;
 
   /** @defaultValue `[]` */
-  cards?: CardsData[] | null | undefined;
+  cards?: CardsDataConstructorData[] | null | undefined;
 
   /** @defaultValue `[]` */
-  playlists?: PlaylistData[] | null | undefined;
+  playlists?: PlaylistDataConstructorData[] | null | undefined;
 
   /** @defaultValue `[]` */
-  folders?: FolderData[] | null | undefined;
+  folders?: FolderDataConstructorData[] | null | undefined;
 
   /** @defaultValue `0` */
   sort?: number | null | undefined;
@@ -155,7 +155,7 @@ export class AdventureData extends DocumentData<
 
 /**
  * Property type: `D[]`
- * Constructor type: `D[] | null | undefined`
+ * Constructor type: `ConstructorDataType<D>[] | null | undefined`
  * Default: `[]`
  */
 type AdventureDocumentsField<D extends ConstructorOf<AnyDocumentData>> = DocumentField<D> & {

package/src/foundry/common/data/data.mjs/journalEntryData.d.ts

@@ -62,7 +62,7 @@ interface JournalEntryDataProperties {
   flags: ConfiguredFlags<'JournalEntry'>;
 }
 
-interface JournalEntryConstructorData {
+interface JournalEntryDataConstructorData {
   /**
    * The _id which uniquely identifies this JournalEntry document
    * @defaultValue `null`
@@ -118,10 +118,10 @@ export class JournalEntryData extends DocumentData<
   JournalEntryDataSchema,
   JournalEntryDataProperties,
   PropertiesToSource<JournalEntryDataProperties>,
-  JournalEntryConstructorData,
+  JournalEntryDataConstructorData,
   documents.BaseJournalEntry
 > {
-  constructor(data: JournalEntryConstructorData, document?: documents.BaseJournalEntry | null);
+  constructor(data: JournalEntryDataConstructorData, document?: documents.BaseJournalEntry | null);
 
   /** @override */
   static defineSchema(): JournalEntryDataSchema;

package/src/foundry/common/data/data.mjs/userData.d.ts

@@ -63,9 +63,13 @@ interface UserDataProperties {
   /** The user's name. */
   name: string;
 
-  /** @defaultValue `""` */
+  /**
+   * The user's password. Available only on the Server side for security.
+   * @defaultValue `""`
+   */
   password: string;
 
+  /** The user's password salt. Available only on the Server side for security. */
   passwordSalt: string | undefined;
 
   /**
@@ -113,9 +117,12 @@ interface UserDataConstructorData {
   /** The user's name. */
   name: string;
 
-  /** @defaultValue `""` */
-  password?: string | null | undefined;
+  /**
+   * The user's password. Available only on the Server side for security.
+   * @defaultValue `""`
+   */ password?: string | null | undefined;
 
+  /** The user's password salt. Available only on the Server side for security. */
   passwordSalt?: string | null | undefined;
 
   /**

package/src/foundry/common/documents.mjs/baseCombatant.d.ts

@@ -26,7 +26,7 @@ export declare class BaseCombatant extends Document<
       isEmbedded: true;
       labelPlural: 'DOCUMENT.Combatants';
       permissions: {
-        create: 'PLAYER';
+        create: typeof BaseCombatant._canCreate;
         update: typeof BaseCombatant._canUpdate;
       };
     }
@@ -38,8 +38,6 @@ export declare class BaseCombatant extends Document<
    */
   protected static _canUpdate(user: BaseUser, doc: BaseCombatant, data?: CombatantDataConstructorData): boolean;
 
-  /**
-   * Is a user able to create this Combatant?
-   */
+  /** Is a user able to create this Combatant? */
   protected static _canCreate(user: BaseUser, doc: BaseCombatant, data?: CombatantDataConstructorData): boolean;
 }

package/src/foundry/common/utils/geometry.mjs.d.ts

@@ -0,0 +1,148 @@
+/**
+ * Determine the relative orientation of three points in two-dimensional space.
+ * The result is also an approximation of twice the signed area of the triangle defined by the three points.
+ * This method is fast - but not robust against issues of floating point precision. Best used with integer coordinates.
+ * Adapted from https://github.com/mourner/robust-predicates
+ *
+ * @param a - An endpoint of segment AB, relative to which point C is tested
+ * @param b - An endpoint of segment AB, relative to which point C is tested
+ * @param c - A point that is tested relative to segment AB
+ *
+ * @returns The relative orientation of points A, B, and C
+ *          A positive value if the points are in counter-clockwise order (C lies to the left of AB)
+ *          A negative value if the points are in clockwise order (C lies to the right of AB)
+ *          Zero if the points A, B, and C are collinear.
+ */
+export function orient2dFast(a: Point, b: Point, c: Point): number;
+
+/**
+ * Quickly test whether the line segment AB intersects with the line segment CD.
+ * This method does not determine the point of intersection, for that use lineLineIntersection
+ *
+ * @param a - The first endpoint of segment AB
+ * @param b - The second endpoint of segment AB
+ * @param c - The first endpoint of segment CD
+ * @param d - The second endpoint of segment CD
+ *
+ * @returns Do the line segments intersect?
+ */
+export function lineSegmentIntersects(a: Point, b: Point, c: Point, d: Point): boolean;
+
+interface LineIntersection {
+  /** The x-coordinate of intersection */
+  x: number;
+
+  /** The y-coordinate of intersection */
+  y: number;
+
+  /** The vector distance from A to B on segment AB */
+  t0: number;
+
+  /** The vector distance from C to D on segment CD */
+  t1?: number;
+}
+
+/**
+ * An internal helper method for computing the intersection between two infinite-length lines.
+ * Adapted from http://paulbourke.net/geometry/pointlineplane/
+ *
+ * @param a - The first endpoint of segment AB
+ * @param b - The second endpoint of segment AB
+ * @param c - The first endpoint of segment CD
+ * @param d - The second endpoint of segment CD
+ *
+ * @returns An intersection point, or null if no intersection occurred
+ */
+export function lineLineIntersection(a: Point, b: Point, c: Point, d: Point): LineIntersection | null;
+
+/**
+ * An internal helper method for computing the intersection between two finite line segments.
+ * Adapted from http://paulbourke.net/geometry/pointlineplane/
+ *
+ * @param a       - The first endpoint of segment AB
+ * @param b       - The second endpoint of segment AB
+ * @param c       - The first endpoint of segment CD
+ * @param d       - The second endpoint of segment CD
+ * @param epsilon - A small epsilon which defines a tolerance for near-equality
+ *                  (default: `1e-8`)
+ *
+ * @returns An intersection point, or null if no intersection occurred
+ */
+export function lineSegmentIntersection(
+  a: Point,
+  b: Point,
+  c: Point,
+  d: Point,
+  epsilon?: number
+): LineIntersection | null;
+
+interface LineCircleIntersection {
+  /** Is point A inside the circle? */
+  aInside: boolean;
+
+  /** Is point B inside the circle? */
+  bInside: boolean;
+
+  /** Is the segment AB contained within the circle? */
+  contained: boolean;
+
+  /** Is the segment AB fully outside the circle? */
+  outside: boolean;
+
+  /** Is the segment AB tangent to the circle? */
+  tangent: boolean;
+
+  /** Intersection points: zero, one, or two */
+  intersections: [number] | [number, number] | [number, number, number];
+}
+
+/**
+ * Determine the intersection between a candidate wall and the circular radius of the polygon.
+ *
+ * @param a       - The initial vertex of the candidate edge
+ * @param b       - The second vertex of the candidate edge
+ * @param center  - The center of the bounding circle
+ * @param radius  - The radius of the bounding circle
+ * @param epsilon - A small tolerance for floating point precision
+ *                  (default: `1e-8`)
+ *
+ * @returns The intersection of the segment AB with the circle
+ */
+export function lineCircleIntersection(
+  a: Point,
+  b: Point,
+  center: Point,
+  radius: number,
+  epsilon?: number
+): LineCircleIntersection;
+
+/**
+ * Identify the point closest to C on segment AB
+ *
+ * @param c - The reference point C
+ * @param a - Point A on segment AB
+ * @param b - Point B on segment AB
+ *
+ * @returns The closest point to C on segment AB
+ */
+export function closestPointToSegment(c: Point, a: Point, b: Point): Point;
+
+/**
+ * Determine the points of intersection between a line segment (p0,p1) and a circle.
+ * There will be zero, one, or two intersections
+ * See https://math.stackexchange.com/a/311956
+ *
+ * @param p0      - The initial point of the line segment
+ * @param p1      - The terminal point of the line segment
+ * @param center  - The center of the circle
+ * @param radius  - The radius of the circle
+ * @param epsilon - A small tolerance for floating point precision
+ *                  (default: `0`)
+ */
+export function quadraticIntersection(
+  p0: Point,
+  p1: Point,
+  center: Point,
+  radius: number,
+  epsilon?: number
+): { x: number; y: number }[];

package/src/foundry/common/utils/helpers.mjs.d.ts

@@ -258,43 +258,6 @@ export declare function isNewerVersion(v1: number | string, v0: number | string)
  */
 export declare function isObjectEmpty(obj: object): boolean;
 
-/**
- * Update a source object by replacing its keys and values with those from a target object.
- *
- * @param original - The initial object which should be updated with values from the target
- * @param other    - A new object whose values should replace those in the source
- *                   (default: `{}`)
- * @param options  - Additional options which configure the merge
- *                   (default: `{}`)
- * @param _d       - A privately used parameter to track recursion depth.
- *                   (default: `0`)
- * @returns The original source object including updated, inserted, or overwritten records.
- *
- * @example <caption>Control how new keys and values are added</caption>
- * ```typescript
- * mergeObject({k1: "v1"}, {k2: "v2"}, {insertKeys: false}); // {k1: "v1"}
- * mergeObject({k1: "v1"}, {k2: "v2"}, {insertKeys: true});  // {k1: "v1", k2: "v2"}
- * mergeObject({k1: {i1: "v1"}}, {k1: {i2: "v2"}}, {insertValues: false}); // {k1: {i1: "v1"}}
- * mergeObject({k1: {i1: "v1"}}, {k1: {i2: "v2"}}, {insertValues: true}); // {k1: {i1: "v1", i2: "v2"}}
- * ```
- *
- * @example <caption>Control how existing data is overwritten</caption>
- * ```typescript
- * mergeObject({k1: "v1"}, {k1: "v2"}, {overwrite: true}); // {k1: "v2"}
- * mergeObject({k1: "v1"}, {k1: "v2"}, {overwrite: false}); // {k1: "v1"}
- * ```
- *
- * @example <caption>Control whether merges are performed recursively</caption>
- * ```typescript
- * mergeObject({k1: {i1: "v1"}}, {k1: {i2: "v2"}}, {recursive: false}); // {k1: {i1: "v2"}}
- * mergeObject({k1: {i1: "v1"}}, {k1: {i2: "v2"}}, {recursive: true}); // {k1: {i1: "v1", i2: "v2"}}
- * ```
- *
- * @example <caption>Deleting an existing object key</caption>
- * ```typescript
- * mergeObject({k1: "v1", k2: "v2"}, {"-=k1": null});   // {k2: "v2"}
- * ```
- */
 type OmitByValue<T, ValueType> = { [Key in keyof T as T[Key] extends ValueType ? never : Key]: T[Key] };
 type RemoveNever<T> = OmitByValue<T, never>;
 type PropWithMinus<K> = K extends string ? `-=${K}` : never;
@@ -333,6 +296,43 @@ type WithWidenedArrayTypes<T> = T extends Array<any>
   ? { [K in keyof T]: WithWidenedArrayTypes<T[K]> }
   : T;
 
+/**
+ * Update a source object by replacing its keys and values with those from a target object.
+ *
+ * @param original - The initial object which should be updated with values from the target
+ * @param other    - A new object whose values should replace those in the source
+ *                   (default: `{}`)
+ * @param options  - Additional options which configure the merge
+ *                   (default: `{}`)
+ * @param _d       - A privately used parameter to track recursion depth.
+ *                   (default: `0`)
+ * @returns The original source object including updated, inserted, or overwritten records.
+ *
+ * @example <caption>Control how new keys and values are added</caption>
+ * ```typescript
+ * mergeObject({k1: "v1"}, {k2: "v2"}, {insertKeys: false}); // {k1: "v1"}
+ * mergeObject({k1: "v1"}, {k2: "v2"}, {insertKeys: true});  // {k1: "v1", k2: "v2"}
+ * mergeObject({k1: {i1: "v1"}}, {k1: {i2: "v2"}}, {insertValues: false}); // {k1: {i1: "v1"}}
+ * mergeObject({k1: {i1: "v1"}}, {k1: {i2: "v2"}}, {insertValues: true}); // {k1: {i1: "v1", i2: "v2"}}
+ * ```
+ *
+ * @example <caption>Control how existing data is overwritten</caption>
+ * ```typescript
+ * mergeObject({k1: "v1"}, {k1: "v2"}, {overwrite: true}); // {k1: "v2"}
+ * mergeObject({k1: "v1"}, {k1: "v2"}, {overwrite: false}); // {k1: "v1"}
+ * ```
+ *
+ * @example <caption>Control whether merges are performed recursively</caption>
+ * ```typescript
+ * mergeObject({k1: {i1: "v1"}}, {k1: {i2: "v2"}}, {recursive: false}); // {k1: {i1: "v2"}}
+ * mergeObject({k1: {i1: "v1"}}, {k1: {i2: "v2"}}, {recursive: true}); // {k1: {i1: "v1", i2: "v2"}}
+ * ```
+ *
+ * @example <caption>Deleting an existing object key</caption>
+ * ```typescript
+ * mergeObject({k1: "v1", k2: "v2"}, {"-=k1": null});   // {k2: "v2"}
+ * ```
+ */
 export declare function mergeObject<
   T extends object,
   U extends DeepPartial<WithWidenedArrayTypes<T>>,

package/src/foundry/common/utils/module.mjs.d.ts

@@ -1,3 +1,4 @@
+export * from './geometry.mjs';
 export * from './helpers.mjs';
 export { default as Collection } from './collection.mjs';
 export { default as Semaphore } from './semaphore.mjs';

package/src/foundry/foundry.js/applications/formApplications/documentSheets/ambientLightConfig.d.ts

@@ -74,7 +74,7 @@ declare global {
     interface Data<Options extends DocumentSheet.Options>
       extends DocumentSheet.Data<InstanceType<ConfiguredDocumentClassForName<'AmbientLight'>>, Options> {
       isAdvanced: boolean;
-      colorationTechniques: unknown; // FIXME: typeof AdaptiveLightingShader.COLORATION_TECHNIQUES
+      colorationTechniques: typeof AdaptiveLightingShader.COLORATION_TECHNIQUES;
       lightAnimations: Record<string, string> & {
         '': 'None';
       };

package/src/foundry/foundry.js/applications/sidebarTabs/chatLog.d.ts

@@ -276,7 +276,7 @@ declare global {
      * @param mode - The new roll mode setting
      * @internal
      */
-    protected static _setRollMode(mode: foundry.CONST.DICE_ROLL_MODES): void;
+    protected static _setRollMode(mode: keyof CONFIG.Dice.RollModes): void;
   }
 
   namespace ChatLog {
@@ -297,7 +297,7 @@ declare global {
 
     interface Data {
       user: InstanceType<ConfiguredDocumentClass<typeof User>>;
-      rollMode: foundry.CONST.DICE_ROLL_MODES;
+      rollMode: keyof CONFIG.Dice.RollModes;
       rollModes: typeof CONFIG['Dice']['rollModes'];
       isStream: boolean;
     }

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

@@ -2,7 +2,6 @@
  * An AudioSourceNode container which handles the strategy of node type to use for playback.
  * Used by the Sound interface which controls playback.
  * This class is for internal use only and should not be used by external callers.
- * @internal
  */
 declare class AudioContainer {
   constructor(src: string);
@@ -31,16 +30,11 @@ declare class AudioContainer {
   isBuffer: boolean;
 
   /**
-   * Has the source for this audio container been loaded to a point that playback can begin?
-   * @defaultValue `false`
-   */
-  loaded: boolean;
-
-  /**
-   * Did the audio source fail to load (a 404 or some other reason).
-   * @defaultValue `false`
+   * Whether we have attempted to load the audio node or not, and whether it failed.
+   * @see {@link LOAD_STATES}
+   * @defaultValue `AudioContainer.LOAD_STATES.NONE`
    */
-  failed: boolean;
+  loadState: AudioContainer.LOAD_STATES;
 
   /**
    * Is the audio source currently playing?
@@ -65,6 +59,26 @@ declare class AudioContainer {
    */
   static MAX_BUFFER_DURATION: number;
 
+  /**
+   * The sequence of container loading states.
+   */
+  static LOAD_STATES: {
+    FAILED: -1;
+    NONE: 0;
+    LOADING: 1;
+    LOADED: 2;
+  };
+
+  /**
+   * Has the audio file been loaded either fully or for streaming.
+   */
+  get loaded(): boolean;
+
+  /**
+   * Did the audio file fail to load.
+   */
+  get failed(): boolean;
+
   /**
    * A reference to the AudioBuffer if the sourceNode is a AudioBufferSourceNode.
    */
@@ -155,3 +169,7 @@ declare class AudioContainer {
    */
   protected _unloadMediaNode(): void;
 }
+
+declare namespace AudioContainer {
+  type LOAD_STATES = ValueOf<typeof AudioContainer['LOAD_STATES']>;
+}

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/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,7 +211,7 @@ 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.
+     * @remarks returns documentation is incorrect (see https://gitlab.com/foundrynet/foundryvtt/-/issues/6367)
      */
     playDialog(
       card: InstanceType<ConfiguredDocumentClassForName<'Card'>>

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