@league-of-foundry-developers/foundry-vtt-types 0.8.9-7 → 9.238.1

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

@@ -8,7 +8,7 @@
  * const dragDrop = new DragDrop({
  *   dragSelector: ".item",
  *   dropSelector: ".items",
- *   permissions: { dragstart: this._canDragStart.bind(this), drop: this._canDragDrop.bind(this) }
+ *   permissions: { dragstart: this._canDragStart.bind(this), drop: this._canDragDrop.bind(this) },
  *   callbacks: { dragstart: this._onDragStart.bind(this), drop: this._onDragDrop.bind(this) }
  * });
  * dragDrop.bind(html);
@@ -17,9 +17,9 @@
 declare class DragDrop {
   /**
    * @param dragSelector - The CSS selector used to target draggable elements.
-   *                       (default: `null`)
+   *                       (default: `undefined`)
    * @param dropSelector - The CSS selector used to target viable drop targets.
-   *                       (default: `null`)
+   *                       (default: `undefined`)
    * @param permissions  - An object of permission test functions for each action
    *                       (default: `{}`)
    * @param callbacks    - An object of callback functions for each action
@@ -29,27 +29,27 @@ declare class DragDrop {
 
   /**
    * The HTML selector which identifies draggable elements
-   * @defaultValue `null`
+   * @defaultValue `undefined`
    */
-  dragSelector: string | null;
+  dragSelector: string | null | undefined;
 
   /**
    * The HTML selector which identifies drop targets
-   * @defaultValue `null`
+   * @defaultValue `undefined`
    */
-  dropSelector: string | null;
+  dropSelector: string | null | undefined;
 
   /**
    * A set of permission checking functions for each action of the Drag and Drop workflow
    * @defaultValue `{}`
    */
-  permissions: Partial<Record<string, (selector: string | null) => boolean>>;
+  permissions: Partial<Record<DragDrop.Action, (selector: string | undefined) => boolean>>;
 
   /**
    * A set of callback functions for each action of the Drag and Drop workflow
    * @defaultValue `{}`
    */
-  callbacks: Partial<Record<string, (event: DragEvent) => unknown>>;
+  callbacks: Partial<Record<DragDrop.Action, (event: DragEvent) => void>>;
 
   /**
    * Bind the DragDrop controller to an HTML application
@@ -62,7 +62,7 @@ declare class DragDrop {
    * @param event  - The drag event being handled
    * @param action - The action being attempted
    */
-  callback(event: DragEvent, action: string): unknown;
+  callback(event: DragEvent, action: DragDrop.Action): void;
 
   /**
    * Test whether the current user has permission to perform a step of the workflow
@@ -70,40 +70,41 @@ declare class DragDrop {
    * @param selector - The selector being targeted
    * @returns Can the action be performed?
    */
-  can(action: string, selector: string | null): boolean;
+  can(action: DragDrop.Action, selector: string | undefined): boolean;
 
   /**
    * Handle the start of a drag workflow
    * @param event - The drag event being handled
+   * @internal
    */
   protected _handleDragStart(event: DragEvent): void;
 
   /**
    * Handle a dragged element over a droppable target
    * @param event - The drag event being handled
+   * @internal
    */
   protected _handleDragOver(event: DragEvent): false;
 
   /**
    * Handle a dragged element dropped on a droppable target
    * @param event - The drag event being handled
+   * @internal
    */
   protected _handleDrop(event: DragEvent): unknown;
 
-  static createDragImage(img: HTMLImageElement, width: number, height: number): HTMLDivElement | HTMLElement;
+  static createDragImage(img: HTMLImageElement, width: number, height: number): HTMLDivElement;
 }
 
 declare namespace DragDrop {
   interface Options {
     /**
      * The CSS selector used to target draggable elements.
-     * @defaultValue `null`
      */
     dragSelector?: DragDrop['dragSelector'];
 
     /**
      * The CSS selector used to target viable drop targets.
-     * @defaultValue `null`
      */
     dropSelector?: DragDrop['dropSelector'];
 
@@ -119,4 +120,6 @@ declare namespace DragDrop {
      */
     callbacks?: DragDrop['callbacks'];
   }
+
+  type Action = 'dragstart' | 'dragover' | 'drop';
 }

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

@@ -1,3 +1,4 @@
+import type { Socket } from 'socket.io-client';
 import { ConfiguredDocumentClass, ConfiguredDocumentClassForName, DocumentConstructor } from '../../types/helperTypes';
 
 declare global {
@@ -25,6 +26,9 @@ declare global {
      */
     data: Game.Data;
 
+    /** The Release data for this version of Foundry */
+    release: foundry.config.ReleaseData;
+
     /**
      * The id of the active World user, if any
      */
@@ -70,6 +74,25 @@ declare global {
      */
     keyboard: KeyboardManager | null;
 
+    /**
+     * The Mouse Manager
+     * @remarks Initialized between the `'setup'` and `'ready'` hook events.
+     * @defaultValue `null`
+     */
+    mouse: MouseManager | null;
+
+    /**
+     * The Gamepad Manager
+     * @remarks Initialized between the `'setup'` and `'ready'` hook events.
+     * @defaultValue `null`
+     */
+    gamepad: GamepadManager | null;
+
+    /**
+     * The New User Experience manager.
+     */
+    nue: NewUserExperience;
+
     /**
      * The user role permissions setting
      * @remarks Initialized between the `'setup'` and `'ready'` hook events.
@@ -87,6 +110,11 @@ declare global {
      */
     settings: ClientSettings;
 
+    /**
+     * Client keybindings which are used to configure application behavior
+     */
+    keybindings: ClientKeybindings;
+
     /**
      * A reference to the open Socket.io connection
      */
@@ -130,6 +158,9 @@ declare global {
      */
     ready: boolean;
 
+    /** Returns the current version of the Release, usable for comparisons using isNewerVersion */
+    get version(): string;
+
     /**
      * Fetch World data and return a Game instance
      * @param view      - The named view being created
@@ -151,6 +182,13 @@ declare global {
      */
     static getCookies(): Record<string, string>;
 
+    /**
+     * Request World data from server and return it
+     * @param socket - The active socket connection
+     * @param view   - The view for which data is being requested
+     */
+    static getData(socket: Socket, view: string): Promise<unknown>;
+
     /**
      * Request World data from server and return it
      */
@@ -189,14 +227,14 @@ declare global {
     shutDown(): Promise<void>;
 
     /**
-     * Fully set up the game state, initializing Entities, UI applications, and the Canvas
+     * Fully set up the game state, initializing Documents, UI applications, and the Canvas
      */
     setupGame(): Promise<void>;
 
     /**
      * Initialize game state data by creating WorldCollection instances for every primary Document type
      */
-    initializeEntities(): void;
+    initializeDocuments(): void;
 
     /**
      * @remarks Initialized between the `'setup'` and `'ready'` hook events.
@@ -248,6 +286,11 @@ declare global {
      */
     tables?: ConfiguredCollectionClassForName<'RollTable'>;
 
+    /**
+     * @remarks Initialized between the `'setup'` and `'ready'` hook events.
+     */
+    cards?: ConfiguredCollectionClassForName<'Cards'>;
+
     /**
      * @remarks Initialized between the `'setup'` and `'ready'` hook events.
      */
@@ -288,10 +331,20 @@ declare global {
     protected _checkFontsReady(ms: number): Promise<void>;
 
     /**
-     * Initialize Keyboard and Mouse controls
+     * Initialize Keyboard controls
      */
     initializeKeyboard(): void;
 
+    /**
+     * Initialize Mouse controls
+     */
+    initializeMouse(): void;
+
+    /**
+     * Initialize Gamepad controls
+     */
+    initializeGamepads(): void;
+
     /**
      * Register core game settings
      */
@@ -331,11 +384,24 @@ declare global {
      */
     togglePause(pause: boolean, push?: boolean): void;
 
+    /**
+     * Open Character sheet for current token or controlled actor
+     * @returns The ActorSheet which was toggled, or null if the User has no character
+     */
+    toggleCharacterSheet(): ActorSheet | null;
+
     /**
      * Log out of the game session by returning to the Join screen
      */
     logOut(): void;
 
+    /**
+     * Scale the base font size according to the user's settings.
+     * @param index - Optionally supply a font size index to use, otherwise use the user's setting.
+     *                Available font sizes, starting at index 1, are: 8, 10, 12, 14, 16, 18, 20, 24, 28, and 32.
+     */
+    scaleFonts(index?: number): void;
+
     /**
      * Activate Socket event listeners which are used to transact game state data with the server
      */
@@ -389,8 +455,9 @@ declare global {
     protected _onPointerUp(event: PointerEvent): void;
 
     /**
-     * Handle resizing of the game window
-     * Reposition any active UI windows
+     * Handle resizing of the game window by adjusting the canvas and repositioning active interface applications.
+     * @param event - The window resize event which has occurred
+     * @internal
      */
     protected _onWindowResize(event: UIEvent): void;
 
@@ -425,6 +492,11 @@ declare global {
      * Initialization steps for the Stream helper view
      */
     protected _initializeStreamView(): Promise<void>;
+
+    /**
+     * @deprecated since v9 - Use initializeDocuments instead.
+     */
+    initializeEntities(): void;
   }
 
   namespace Game {
@@ -435,71 +507,98 @@ declare global {
     }
 
     interface PackageData<T> {
-      type: 'world' | 'system' | 'module';
+      availability: number;
       data: T;
-      id: string;
-      path: string;
-      scripts: string[];
       esmodules: string[];
-      styles: string[];
+      id: string;
       languages: Language[];
+      locked: boolean;
       packs: {
-        name: string;
+        absPath: string;
+        /** @deprecated since V9 */
+        entity: foundry.CONST.COMPENDIUM_DOCUMENT_TYPES;
         label: string;
+        name: string;
+        package: string;
         path: string;
         private: boolean;
-        entity: foundry.CONST.CompendiumEntityType;
         system?: string;
-        absPath: string;
-        package: string;
+        type: foundry.CONST.COMPENDIUM_DOCUMENT_TYPES;
       };
-      locked: boolean;
-      availability: number;
+      scripts: string[];
+      styles: string[];
+      type: 'world' | 'system' | 'module';
       unavailable: boolean;
-      _systemUpdateCheckTime: number;
     }
 
-    interface WorldData<T> extends PackageData<T> {
-      type: 'world';
+    interface ModuleData<T> extends PackageData<T> {
+      active: boolean;
+      path: string;
+      type: 'module';
     }
 
     interface SystemData<T> extends PackageData<T> {
-      type: 'system';
+      _systemUpdateCheckTime: number;
+      documentTypes: {
+        [Key in
+          | foundry.CONST.DOCUMENT_TYPES
+          | 'ActiveEffect'
+          | 'Adventure'
+          | 'AmbientLight'
+          | 'AmbientSound'
+          | 'Card'
+          | 'Combatant'
+          | 'Drawing'
+          | 'FogExploration'
+          | 'MeasuredTemplate'
+          | 'Note'
+          | 'PlaylistSound'
+          | 'Setting'
+          | 'TableResult'
+          | 'Tile'
+          | 'Token'
+          | 'Wall']: string[];
+      };
+      model: {
+        Actor: Record<string, Record<string, unknown>>;
+        Cards: Record<string, Record<string, unknown>>;
+        Item: Record<string, Record<string, unknown>>;
+      };
+      path: string;
       template: {
         Actor?: {
           types: string[];
-          templates?: Partial<Record<string, unknown>>;
-        } & Partial<Record<string, unknown>>;
+          templates?: Record<string, unknown>;
+        } & Record<string, unknown>;
         Item?: {
           types: string[];
-          templates?: Partial<Record<string, unknown>>;
-        } & Partial<Record<string, unknown>>;
-      };
-      entityTypes: { [Key in foundry.CONST.EntityType | 'Setting' | 'FogExploration']: string[] };
-      model: {
-        Actor: Partial<Record<string, Partial<Record<string, unknown>>>>;
-        Item: Partial<Record<string, Partial<Record<string, unknown>>>>;
+          templates?: Record<string, unknown>;
+        } & Record<string, unknown>;
       };
+      type: 'system';
     }
 
-    interface ModuleData<T> extends PackageData<T> {
-      type: 'module';
-      active: boolean;
+    interface WorldData<T> extends PackageData<T> {
+      _systemUpdateCheckTime: number;
+      type: 'world';
     }
 
     type Data = {
-      userId: string;
-      version: string;
-      world: WorldData<foundry.packages.WorldData>;
-      system: SystemData<foundry.packages.SystemData>;
-      modules: ModuleData<foundry.packages.ModuleData>[];
-      paused: boolean;
+      activeUsers: string[];
       addresses: {
         local: string;
         remote: string;
+        remoteIsAccessible: boolean;
+      };
+      coreUpdate: {
+        channel: unknown | null;
+        couldReachWebsite: boolean;
+        hasUpdate: boolean;
+        slowResponse: boolean;
+        version: unknown | null;
+        willDisableModules: boolean;
       };
       files: {
-        storages: ('public' | 'data' | 's3')[];
         s3?: {
           endpoint: {
             protocol: string;
@@ -511,31 +610,51 @@ declare global {
             href: string;
           };
           buckets: string[];
-        };
+        } | null;
+        storages: ('public' | 'data' | 's3')[];
       };
+      modules: ModuleData<foundry.packages.ModuleData>[];
       options: {
+        demo: boolean;
         language: string;
         port: number;
         routePrefix: string | null;
         updateChannel: string;
-        demo: boolean;
       };
-      activeUsers: string[];
       packs: {
-        name: string;
+        /** @deprecated since V9 */
+        entity: foundry.CONST.COMPENDIUM_DOCUMENT_TYPES;
+        index: {
+          _id: string;
+          name: string;
+          type: string;
+        }[];
         label: string;
+        name: string;
+        package: string;
         path: string;
         private: boolean;
-        entity: foundry.CONST.CompendiumEntityType;
         system?: string;
-        package: string;
-        index: { name: string; type: string; _id: string }[];
+        type: foundry.CONST.COMPENDIUM_DOCUMENT_TYPES;
+      }[];
+      paused: boolean;
+      release: {
+        build: number;
+        channel: 'Stable' | 'Testing' | 'Development' | 'Prototype';
+        download: string;
+        generation: string;
+        notes: string;
+        time: number;
       };
-      coreUpdate: string | null;
+      system: SystemData<foundry.packages.SystemData>;
       systemUpdate: string | null;
+      userId: string;
+      /** @deprecated since V9 */
+      version?: string;
+      world: WorldData<foundry.packages.WorldData>;
     } & {
       [DocumentType in
-        | foundry.CONST.EntityType
+        | foundry.CONST.DOCUMENT_TYPES
         | 'Setting' as ConfiguredDocumentClassForName<DocumentType>['metadata']['collection']]?: InstanceType<
         ConfiguredDocumentClassForName<DocumentType>
       >['data']['_source'][];
@@ -548,11 +667,13 @@ declare global {
     };
 
     type Permissions = {
-      [Key in keyof typeof foundry.CONST.USER_PERMISSIONS]: foundry.CONST.UserRole[];
+      [Key in keyof typeof foundry.CONST.USER_PERMISSIONS]: foundry.CONST.USER_ROLES[];
     };
 
     type View = ValueOf<typeof foundry.CONST.GAME_VIEWS>;
   }
 }
 
-type ConfiguredCollectionClassForName<Name extends foundry.CONST.EntityType> = InstanceType<CONFIG[Name]['collection']>;
+type ConfiguredCollectionClassForName<Name extends foundry.CONST.DOCUMENT_TYPES> = InstanceType<
+  CONFIG[Name]['collection']
+>;

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

@@ -0,0 +1,41 @@
+/** Management class for Gamepad events */
+declare class GamepadManager {
+  constructor();
+
+  /**
+   * How often Gamepad polling should check for button presses
+   * @defaultValue `100`
+   */
+  static GAMEPAD_POLLER_INTERVAL_MS: number;
+
+  /**
+   * Handles a Gamepad Connection event, adding its info to the poll list
+   * @param event - The originating Event
+   * @internal
+   */
+  protected _onGamepadConnect(event: GamepadEvent): void;
+
+  /**
+   * Handles a Gamepad Disconnect event, removing it from consideration for polling
+   * @param event - The originating Event
+   * @internal
+   */
+  protected _onGamepadDisconnect(event: GamepadEvent): void;
+
+  /**
+   * Polls all Connected Gamepads for updates. If they have been updated, checks status of Axis and Buttons,
+   * firing off Keybinding Contexts as appropriate
+   * @internal
+   */
+  protected _pollGamepads(): void;
+
+  /**
+   * Converts a Gamepad Input event into a KeyboardEvent, then fires it
+   * @param gamepadId - The string representation of the Gamepad Input
+   * @param up        - True if the Input is pressed or active
+   * @param repeat    - True if the Input is being held
+   *                    (default: `false`)
+   * @internal
+   */
+  protected _handleGamepadInput(gamepadId: string, up: boolean, repeat?: boolean): void;
+}

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

@@ -15,6 +15,7 @@ declare global {
    * The currently supported variables are:
    * - {@link game}
    * - {@link socket}
+   * - {@link ui}
    * - {@link canvas}
    *
    * @example
@@ -64,9 +65,7 @@ declare global {
      * @defaultValue `{}`
      */
     windows: Record<number, Application>;
-  } & {
-    [Key in keyof CONFIG['ui']]?: InstanceType<CONFIG['ui'][Key]>;
-  };
+  } & ('ui' extends keyof LenientGlobalVariableTypes ? UiApplications : Partial<UiApplications>);
 
   /** The client-side console is the default logger  */
   let logger: typeof console;
@@ -115,7 +114,7 @@ declare global {
   let _token: InstanceType<CONFIG['Token']['objectClass']> | null;
 
   /*
-   * Global Vairables
+   * Global Variables
    * The following variables are declared directly in foundry's HTML file (or more concretely, in `main.hbs`)
    */
 
@@ -128,4 +127,8 @@ declare global {
     | null;
 }
 
+type UiApplications = {
+  [Key in keyof CONFIG['ui']]: InstanceType<CONFIG['ui'][Key]>;
+};
+
 export {};

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

@@ -218,7 +218,7 @@ declare namespace HandlebarsHelpers {
 
       /**
        * The original HTML content as a string
-       * @defaultValue `''`
+       * @defaultValue `""`
        */
       content?: string;
     };
@@ -259,7 +259,7 @@ declare namespace HandlebarsHelpers {
   interface NumberInputOptions extends Handlebars.HelperOptions {
     hash: {
       /**
-       * @defaultValue `''`
+       * @defaultValue `""`
        */
       name?: string;
 
@@ -271,12 +271,12 @@ declare namespace HandlebarsHelpers {
       disabled?: boolean;
 
       /**
-       * @defaultValue `''`
+       * @defaultValue `""`
        */
       placeholder?: string;
 
       /**
-       * @defaultValue `''`
+       * @defaultValue `""`
        */
       class?: string;
 

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

@@ -1,5 +1,6 @@
 import {
   ConfiguredDocumentClass,
+  ConfiguredDocumentClassForName,
   ConfiguredObjectClassForName,
   DocumentConstructor,
   ToObjectFalseType
@@ -162,6 +163,22 @@ declare global {
         change: EffectChangeData
       ) => boolean | void;
 
+      /**
+       * A hook event that fires immediately prior to PIXI Application construction with the configuration parameters.
+       * @param canvasConfig - Canvas configuration parameters that will be used
+       */
+      canvasConfig: (canvasConfig: {
+        view: HTMLCanvasElement;
+        width: number;
+        height: number;
+        transparent: boolean;
+        resolution: number;
+        autoDensity: boolean;
+        backgroundColor: string | null;
+        antialias: boolean;
+        powerPreference: string;
+      }) => unknown;
+
       /**
        * A hook event that fires when the Canvas is initialized.
        * @param canvas - the Canvas
@@ -259,6 +276,20 @@ declare global {
        */
       collapseSidebar: (sidebar: Sidebar, collapsed: boolean) => unknown;
 
+      /**
+       * A hook event that fires when Cards are dealt from a deck to other hands
+       * @param origin             - The origin Cards document
+       * @param destinations       - An array of destination Cards documents
+       * @param context            - Additional context which describes the operation
+       * @remarks This is called by {@link Hooks.call}.
+       * @remarks An explicit return value of `false` prevents the operation.
+       */
+      dealCards: (
+        origin: InstanceType<ConfiguredDocumentClassForName<'Cards'>>,
+        destinations: InstanceType<ConfiguredDocumentClassForName<'Cards'>>[],
+        context: Cards.DealContext
+      ) => boolean | void;
+
       /**
        * A hook event that fires when some useful data is dropped onto an ActorSheet.
        * @param actor - The Actor
@@ -395,6 +426,20 @@ declare global {
         updates: Record<string, number>
       ) => boolean;
 
+      /**
+       * A hook event that fires when Cards are passed from one stack to another
+       * @param origin      - The origin Cards document
+       * @param destination - The destination Cards document
+       * @param context     - Additional context which describes the operation
+       * @remarks This is called by {@link Hooks.call}.
+       * @remarks An explicit return value of `false` prevents the operation.
+       */
+      passCards: (
+        origin: InstanceType<ConfiguredDocumentClassForName<'Cards'>>,
+        destination: InstanceType<ConfiguredDocumentClassForName<'Cards'>>,
+        context: Cards.DealContext
+      ) => boolean | void;
+
       /**
        * A hook event that fires when the game is paused or un-paused.
        * @param paused - Is the game now paused (true) or un-paused (false)
@@ -434,6 +479,18 @@ declare global {
         }
       ) => boolean | void;
 
+      /**
+       * A hook event that fires when a stack of Cards are returned to the decks they originally came from.
+       * @param origin   - The origin Cards document.
+       * @param returned - The cards being returned.
+       * @param context  - Additional context which describes the operation.
+       */
+      returnCards: (
+        origin: InstanceType<ConfiguredDocumentClassForName<'Cards'>>,
+        returned: InstanceType<ConfiguredDocumentClassForName<'Card'>>[],
+        context: Cards.ReturnContext
+      ) => boolean | void;
+
       /**
        * A hook event that fires when the AV settings are changed.
        * @param settings - The AVSettings manager