@league-of-foundry-developers/foundry-vtt-types 9.280.0 → 12.331.1-beta

package/src/foundry/client/data/collections/macros.d.mts

@@ -0,0 +1,32 @@
+import type { InexactPartial } from "../../../../types/utils.d.mts";
+
+declare global {
+  /**
+   * The singleton collection of Macro documents which exist within the active World.
+   * This Collection is accessible within the Game object as game.macros.
+   *
+   * @see {@link Macro} The Macro document
+   * @see {@link MacroDirectory} The MacroDirectory sidebar directory
+   */
+  class Macros extends WorldCollection<typeof foundry.documents.BaseMacro, "Macros"> {
+    static documentName: "Macro";
+
+    override get directory(): typeof ui.macros;
+
+    override fromCompendium<
+      FolderOpt extends boolean = false,
+      SortOpt extends boolean = true,
+      OwnershipOpt extends boolean = false,
+      IdOpt extends boolean = false,
+    >(
+      document: Macro.ConfiguredInstance | foundry.documents.BaseMacro.ConstructorData,
+      options?: InexactPartial<WorldCollection.FromCompendiumOptions<FolderOpt, SortOpt, OwnershipOpt, IdOpt>>,
+    ): Omit<
+      Macro["_source"],
+      | ClientDocument.OmitProperty<FolderOpt, "folder">
+      | ClientDocument.OmitProperty<SortOpt, "sort" | "navigation" | "navOrder">
+      | ClientDocument.OmitProperty<OwnershipOpt, "ownership">
+      | (IdOpt extends false ? "_id" : never)
+    >;
+  }
+}

package/src/foundry/client/data/collections/messages.d.mts

@@ -0,0 +1,35 @@
+import type Document from "../../../common/abstract/document.d.mts";
+
+declare global {
+  /**
+   * The singleton collection of ChatMessage documents which exist within the active World.
+   * This Collection is accessible within the Game object as game.messages.
+   *
+   * @see {@link ChatMessage} The ChatMessage document
+   * @see {@link ChatLog} The ChatLog sidebar directory
+   */
+  class Messages extends WorldCollection<typeof foundry.documents.BaseChatMessage, "Messages"> {
+    static documentName: "ChatMessage";
+
+    override get directory(): typeof ui.chat;
+
+    render(force?: boolean): void;
+
+    /**
+     * If requested, dispatch a Chat Bubble UI for the newly created message
+     * @param message - The ChatMessage document to say
+     */
+    sayBubble(message: ChatMessage.ConfiguredInstance): void;
+
+    /**
+     * Handle export of the chat log to a text file
+     */
+    export(): void;
+
+    /**
+     * Allow for bulk deletion of all chat messages, confirm first with a yes/no dialog.
+     * @see {@link Dialog.confirm}
+     */
+    flush(): Promise<Promise<Document.Stored<ChatMessage.ConfiguredInstance>[]> | false | null>;
+  }
+}

package/src/foundry/client/data/collections/playlists.d.mts

@@ -0,0 +1,34 @@
+import type { DeepPartial } from "../../../../types/utils.d.mts";
+import type Document from "../../../common/abstract/document.d.mts";
+
+declare global {
+  /**
+   * The singleton collection of Playlist documents which exist within the active World.
+   * This Collection is accessible within the Game object as game.playlists.
+   *
+   * @see {@link Playlist} The Playlist document
+   * @see {@link PlaylistDirectory} The PlaylistDirectory sidebar directory
+   */
+  class Playlists extends WorldCollection<typeof foundry.documents.BasePlaylist, "Playlists"> {
+    constructor(data?: Document.Stored<Playlist.ConfiguredInstance>["_source"][]);
+
+    static documentName: "Playlist";
+
+    /**
+     * Return the subset of Playlist documents which are currently playing
+     */
+    get playing(): ReturnType<this["filter"]>;
+
+    /**
+     * Perform one-time initialization to begin playback of audio
+     */
+    initialize(): void;
+
+    /**
+     * Handle changes to a Scene to determine whether to trigger changes to Playlist documents.
+     * @param scene - The Scene document being updated
+     * @param data  - The incremental update data
+     */
+    protected _onChangeScene(scene: Document.Stored<Scene>, data: DeepPartial<Scene["_source"]>): Promise<void>;
+  }
+}

package/src/foundry/client/data/collections/scenes.d.mts

@@ -0,0 +1,68 @@
+import type { InexactPartial } from "../../../../types/utils.d.mts";
+import type Document from "../../../common/abstract/document.d.mts";
+
+declare global {
+  /**
+   * The singleton collection of Scene documents which exist within the active World.
+   * This Collection is accessible within the Game object as game.scenes.
+   *
+   * @see {@link Scene} The Scene document
+   * @see {@link SceneDirectory} The SceneDirectory sidebar directory
+   */
+  class Scenes extends WorldCollection<typeof foundry.documents.BaseScene, "Scenes"> {
+    static documentName: "Scene";
+
+    /**
+     * Return a reference to the Scene which is currently active
+     */
+    get active(): Document.Stored<Scene.ConfiguredInstance> | undefined;
+
+    /**
+     * Return the current Scene target.
+     * This is the viewed scene if the canvas is active, otherwise it is the currently active scene.
+     */
+    get current(): Document.Stored<Scene.ConfiguredInstance> | undefined;
+
+    /**
+     * Return a reference to the Scene which is currently viewed
+     */
+    get viewed(): Document.Stored<Scene.ConfiguredInstance> | undefined;
+
+    /**
+     * Handle pre-loading the art assets for a Scene
+     *
+     * @param sceneId - The Scene id to begin loading
+     * @param push    - Trigger other connected clients to also pre-load Scene resources
+     *                  (default: `false`)
+     */
+    preload(sceneId: string, push?: boolean): io.Socket | Promise<unknown[]>;
+
+    /** @remarks This is not marked as protected because it is used in {@link Game#activateSocketListeners} */
+    static _activateSocketListeners(socket: io.Socket): void;
+
+    /**
+     * Handle requests pulling the current User to a specific Scene
+     */
+    protected static _pullToScene(sceneId: string): void;
+
+    override fromCompendium<
+      FolderOpt extends boolean = false,
+      SortOpt extends boolean = true,
+      OwnershipOpt extends boolean = false,
+      IdOpt extends boolean = false,
+      StateOpt extends boolean = false,
+    >(
+      document: Scene.ConfiguredInstance | foundry.documents.BaseScene.ConstructorData,
+      options?: InexactPartial<
+        WorldCollection.FromCompendiumOptions<FolderOpt, SortOpt, OwnershipOpt, IdOpt, StateOpt>
+      >,
+    ): Omit<
+      Scene["_source"],
+      | ClientDocument.OmitProperty<FolderOpt, "folder">
+      | ClientDocument.OmitProperty<SortOpt, "sort" | "navigation" | "navOrder">
+      | ClientDocument.OmitProperty<OwnershipOpt, "ownership">
+      | (IdOpt extends false ? "_id" : never)
+      | ClientDocument.OmitProperty<StateOpt, "active">
+    >;
+  }
+}

package/src/foundry/client/data/collections/settings.d.mts

@@ -0,0 +1,29 @@
+export {};
+
+declare global {
+  /**
+   * The Collection of Setting documents which exist within the active World.
+   * This collection is accessible as game.settings.storage.get("world")
+   *
+   * @see {@link Setting} The Setting document
+   */
+  class WorldSettings extends WorldCollection<typeof foundry.documents.BaseSetting, "WorldSettings"> {
+    static documentName: "Setting";
+
+    override get directory(): null;
+
+    /**
+     * Return the Setting or Keybind document with the given key.
+     * @param key - The setting key
+     * @returns The Setting.
+     */
+    getSetting(key: string): ReturnType<this["find"]>;
+
+    /**
+     * Return the serialized value of the world setting as a string
+     * @param key - The setting key
+     * @returns The serialized setting string
+     */
+    getItem(key: string): string | null;
+  }
+}

package/src/foundry/client/data/collections/tables.d.mts

@@ -0,0 +1,21 @@
+export {};
+
+declare global {
+  /**
+   * The singleton collection of RollTable documents which exist within the active World.
+   * This Collection is accessible within the Game object as game.tables.
+   *
+   * @see {@link RollTable} The RollTable document
+   * @see {@link RollTableDirectory} The RollTableDirectory sidebar directory
+   */
+  class RollTables extends WorldCollection<typeof foundry.documents.BaseRollTable, "RollTables"> {
+    static documentName: "RollTable";
+
+    override get directory(): (typeof ui)["tables"];
+
+    /**
+     * Register world settings related to RollTable documents
+     */
+    static registerSettings(): void;
+  }
+}

package/src/foundry/client/data/collections/users.d.mts

@@ -0,0 +1,50 @@
+import type { InexactPartial } from "../../../../types/utils.d.mts";
+import type Document from "../../../common/abstract/document.d.mts";
+
+declare global {
+  /**
+   * The singleton collection of User documents which exist within the active World.
+   * This Collection is accessible within the Game object as game.users.
+   *
+   * @see {@link User} The User document
+   */
+  class Users extends WorldCollection<typeof foundry.documents.BaseUser, "Users"> {
+    constructor(data?: User["_source"][]);
+
+    /**
+     * The User document of the currently connected user
+     * @defaultValue `null`
+     */
+    current: Document.Stored<User.ConfiguredInstance> | null;
+
+    /**
+     * Initialize the Map object and all its contained documents
+     * @internal
+     */
+    protected _initialize(): void;
+
+    static documentName: "User";
+
+    /**
+     * Get the users with player roles
+     */
+    get players(): ReturnType<this["filter"]>;
+
+    /**
+     * Get one User who is an active Gamemaster, or null if no active GM is available.
+     * This can be useful for workflows which occur on all clients, but where only one user should take action.
+     */
+    get activeGM(): User.ConfiguredInstance | null;
+
+    /** @remarks This is not marked as protected because it is used in {@link Game#activateSocketListeners} */
+    static _activateSocketListeners(socket: io.Socket): void;
+
+    /**
+     * Handle receipt of activity data from another User connected to the Game session
+     * @param userId       - The User id who generated the activity data
+     * @param activityData - The object of activity data
+     *                       (default: `{}`)
+     */
+    protected static _handleUserActivity(userId: string, activityData?: InexactPartial<User.ActivityData>): void;
+  }
+}

package/src/foundry/client/data/documents/active-effect.d.mts

@@ -0,0 +1,348 @@
+import type { AnyObject } from "../../../../types/utils.d.mts";
+import type { DataModel } from "../../../common/abstract/data.d.mts";
+import type Document from "../../../common/abstract/document.d.mts";
+import type { DocumentDatabaseOperations } from "../../../common/abstract/document.d.mts";
+import type { DataField } from "../../../common/data/fields.d.mts";
+import type { ActiveEffectData, EffectChangeData, EffectDurationData } from "../../../common/documents/_types.d.mts";
+
+declare global {
+  namespace ActiveEffect {
+    type ConfiguredClass = Document.ConfiguredClassForName<"ActiveEffect">;
+    type ConfiguredInstance = Document.ConfiguredInstanceForName<"ActiveEffect">;
+
+    interface DatabaseOperations
+      extends DocumentDatabaseOperations<
+        ActiveEffect,
+        { animate: boolean },
+        { animate: boolean },
+        { animate: boolean }
+      > {}
+  }
+
+  /**
+   * The client-side ActiveEffect document which extends the common BaseActiveEffect model.
+   * Each ActiveEffect belongs to the effects collection of its parent Document.
+   * Each ActiveEffect contains a ActiveEffectData object which provides its source data.
+   *
+   * @see {@link ActiveEffectData}          The ActiveEffect data schema
+   * @see {@link Actor}                     The Actor document which contains ActiveEffect embedded documents
+   * @see {@link Item}                      The Item document which contains ActiveEffect embedded documents
+   */
+  class ActiveEffect extends ClientDocumentMixin(foundry.documents.BaseActiveEffect) {
+    /**
+     * Create an ActiveEffect instance from some status effect ID.
+     * Delegates to {@link ActiveEffect._fromStatusEffect} to create the ActiveEffect instance
+     * after creating the ActiveEffect data from the status effect data if `CONFIG.statusEffects`.
+     * @param statusId - The status effect ID.
+     * @param options  - Additional options to pass to the ActiveEffect constructor.
+     * @returns The created ActiveEffect instance.
+     *
+     * @throws An error if there is no status effect in `CONFIG.statusEffects` with the given status ID and if
+     * the status has implicit statuses but doesn't have a static _id.
+     */
+    static fromStatusEffect(
+      statusId: string,
+      options?: Document.ConstructionContext<Document.Any | null>,
+    ): Promise<ActiveEffect.ConfiguredInstance>;
+
+    /**
+     * Create an ActiveEffect instance from status effect data.
+     * Called by {@link ActiveEffect.fromStatusEffect}.
+     * @param statusId   - The status effect ID.
+     * @param effectData - The status effect data.
+     * @param options    - Additional options to pass to the ActiveEffect constructor.
+     * @returns The created ActiveEffect instance.
+     */
+    protected static _fromStatusEffect(
+      statusId: string,
+      effectData: ActiveEffectData,
+      options?: Document.ConstructionContext<Document.Any | null>,
+    ): Promise<ActiveEffect.ConfiguredInstance>;
+
+    /**
+     * Is there some system logic that makes this active effect ineligible for application?
+     * @defaultValue `false`
+     */
+    get isSuppressed(): boolean;
+
+    /**
+     * Retrieve the Document that this ActiveEffect targets for modification.
+     */
+    get target(): Document.Any | null;
+
+    /**
+     * Whether the Active Effect currently applying its changes to the target.
+     */
+    get active(): boolean;
+
+    /**
+     *  Does this Active Effect currently modify an Actor?
+     */
+    get modifiesActor(): boolean;
+
+    prepareBaseData(): void;
+
+    prepareDerivedData(): void;
+
+    /**
+     * Update derived Active Effect duration data.
+     * Configure the remaining and label properties to be getters which lazily recompute only when necessary.
+     */
+    updateDuration(): ActiveEffectDuration;
+
+    /**
+     * Determine whether the ActiveEffect requires a duration update.
+     * True if the worldTime has changed for an effect whose duration is tracked in seconds.
+     * True if the combat turn has changed for an effect tracked in turns where the effect target is a combatant.
+     */
+    protected _requiresDurationUpdate(): boolean;
+
+    protected _prepareDuration(): Omit<ActiveEffectDuration, keyof EffectDurationData>;
+
+    /**
+     * Format a round+turn combination as a decimal
+     * @param round  - The round number
+     * @param turn   - The turn number
+     * @param nTurns - The maximum number of turns in the encounter
+     * @returns The decimal representation
+     */
+    protected _getCombatTime(round: number, turn: number, nTurns?: number): number;
+
+    /**
+     * Format a number of rounds and turns into a human-readable duration label
+     * @param rounds - The number of rounds
+     * @param turns  - The number of turns
+     * @returns The formatted label
+     */
+    protected _getDurationLabel(rounds: number, turns: number): string;
+
+    /**
+     * Describe whether the ActiveEffect has a temporary duration based on combat turns or rounds.
+     */
+    get isTemporary(): boolean;
+
+    /**
+     * The source name of the Active Effect. The source is retrieved synchronously.
+     * Therefore "Unknown" (localized) is returned if the origin points to a document inside a compendium.
+     * Returns "None" (localized) if it has no origin, and "Unknown" (localized) if the origin cannot be resolved.
+     */
+    get sourceName(): string;
+
+    /**
+     * Apply EffectChangeData to a field within a DataModel.
+     * @param model  - The model instance.
+     * @param change - The change to apply.
+     * @param field  - The field. If not supplied, it will be retrieved from the supplied model.
+     * @returns The updated value.
+     */
+    static applyField(model: DataModel.Any, change: EffectChangeData, field?: DataField.Any): unknown;
+
+    /**
+     * Apply this ActiveEffect to a provided Actor.
+     * TODO: This method is poorly conceived. Its functionality is static, applying a provided change to an Actor
+     * TODO: When we revisit this in Active Effects V2 this should become an Actor method, or a static method
+     * @param actor  - The Actor to whom this effect should be applied
+     * @param change - The change data being applied
+     * @returns The resulting applied value
+     */
+    apply(actor: Actor.ConfiguredInstance, change: EffectChangeData): unknown;
+
+    /**
+     * Apply this ActiveEffect to a provided Actor using a heuristic to infer the value types based on the current value
+     * and/or the default value in the template.json.
+     * @param actor   - The Actor to whom this effect should be applied.
+     * @param change  - The change data being applied.
+     * @param changes - The aggregate update paths and their updated values.
+     */
+    protected _applyLegacy(actor: Actor.ConfiguredInstance, change: EffectDurationData, changes: AnyObject): void;
+
+    /**
+     * Cast a raw EffectChangeData change string to the desired data type.
+     * @param raw - The raw string value
+     * @param type - The target data type that the raw value should be cast to match
+     * @returns The parsed delta cast to the target data type
+     */
+    protected _castDelta(raw: string, type: string): boolean | number | string | object;
+
+    /**
+     * Cast a raw EffectChangeData change string to an Array of an inner type.
+     * @param raw  - The raw string value
+     * @param type - The target data type of inner array elements
+     * @returns The parsed delta cast as a typed array
+     */
+    protected _castArray(raw: string, type: string): Array<boolean | string | number | object>;
+
+    /**
+     * Parse serialized JSON, or retain the raw string.
+     * @param raw - A raw serialized string
+     * @returns The parsed value, or the original value if parsing failed
+     */
+    protected _parseOrString(raw: string): string | object;
+
+    /**
+     * Apply an ActiveEffect that uses an ADD application mode.
+     * The way that effects are added depends on the data type of the current value.
+     *
+     * If the current value is null, the change value is assigned directly.
+     * If the current type is a string, the change value is concatenated.
+     * If the current type is a number, the change value is cast to numeric and added.
+     * If the current type is an array, the change value is appended to the existing array if it matches in type.
+     *
+     * @param actor   - The Actor to whom this effect should be applied
+     * @param change  - The change data being applied
+     * @param current - The current value being modified
+     * @param delta   - The parsed value of the change object
+     * @param changes - An object which accumulates changes to be applied
+     * @returns The resulting applied value
+     */
+    protected _applyAdd(
+      actor: Actor.ConfiguredInstance,
+      change: EffectChangeData,
+      current: any,
+      delta: any,
+      changes: AnyObject,
+    ): void;
+
+    /**
+     * Apply an ActiveEffect that uses a MULTIPLY application mode.
+     * Changes which MULTIPLY must be numeric to allow for multiplication.
+     * @param actor   - The Actor to whom this effect should be applied
+     * @param change  - The change data being applied
+     * @param current - The current value being modified
+     * @param delta   - The parsed value of the change object
+     * @param changes - An object which accumulates changes to be applied
+     * @returns The resulting applied value
+     */
+    protected _applyMultiply(
+      actor: Actor.ConfiguredInstance,
+      change: EffectChangeData,
+      current: any,
+      delta: any,
+      changes: AnyObject,
+    ): void;
+
+    /**
+     * Apply an ActiveEffect that uses an OVERRIDE application mode.
+     * Numeric data is overridden by numbers, while other data types are overridden by any value
+     * @param actor   - The Actor to whom this effect should be applied
+     * @param change  - The change data being applied
+     * @param current - The current value being modified
+     * @param delta   - The parsed value of the change object
+     * @param changes - An object which accumulates changes to be applied
+     * @returns The resulting applied value
+     */
+    protected _applyOverride(
+      actor: Actor.ConfiguredInstance,
+      change: EffectChangeData,
+      current: any,
+      delta: any,
+      changes: AnyObject,
+    ): void;
+
+    /**
+     * Apply an ActiveEffect that uses an UPGRADE, or DOWNGRADE application mode.
+     * Changes which UPGRADE or DOWNGRADE must be numeric to allow for comparison.
+     * @param actor   - The Actor to whom this effect should be applied
+     * @param change  - The change data being applied
+     * @param current - The current value being modified
+     * @param delta   - The parsed value of the change object
+     * @param changes - An object which accumulates changes to be applied
+     * @returns The resulting applied value
+     */
+    protected _applyUpgrade(
+      actor: Actor.ConfiguredInstance,
+      change: EffectChangeData,
+      current: any,
+      delta: any,
+      changes: AnyObject,
+    ): void;
+
+    /**
+     * Apply an ActiveEffect that uses a CUSTOM application mode.
+     * @param actor   - The Actor to whom this effect should be applied
+     * @param change  - The change data being applied
+     * @param current - The current value being modified
+     * @param delta   - The parsed value of the change object
+     * @param changes - An object which accumulates changes to be applied
+     * @returns The resulting applied value
+     */
+    protected _applyCustom(
+      actor: Actor.ConfiguredInstance,
+      change: EffectChangeData,
+      current: any,
+      delta: any,
+      changes: AnyObject,
+    ): void;
+
+    /**
+     * Retrieve the initial duration configuration.
+     */
+    static getInitialDuration(): {
+      duration: {
+        startTime: number;
+        startRound?: number | undefined;
+        startTurn?: number | undefined;
+      };
+    };
+
+    // TODO: This is a minor override and doing the extension is complicated
+    // getFlag(scope: string, key: string): unknown;
+
+    /**
+     * @privateRemarks _preCreate, _onCreate, _onUpdate, _preUpdate, and _onDelete are all overridden but with no signature changes.
+     * For type simplicity they are left off. These methods historically have been the source of a large amount of computation from tsc.
+     */
+
+    /**
+     * Display changes to active effects as scrolling Token status text.
+     * @param enabled - Is the active effect currently enabled?
+     */
+    protected _displayScrollingStatus(enabled: boolean): void;
+
+    /* -------------------------------------------- */
+    /*  Deprecations and Compatibility              */
+    /* -------------------------------------------- */
+
+    /**
+     * Get the name of the source of the Active Effect
+     * @deprecated since v11, will be removed in v13
+     * @remarks `"You are accessing ActiveEffect._getSourceName which is deprecated."`
+     */
+    _getSourceName(): Promise<string>;
+  }
+
+  interface ActiveEffect {
+    duration: ActiveEffectDuration;
+  }
+
+  interface ActiveEffectDuration extends EffectDurationData {
+    /**
+     * The duration type, either "seconds", "turns", or "none"
+     */
+    type: "seconds" | "turns" | "none";
+
+    /**
+     * The total effect duration, in seconds of world time or as a decimal
+     * number with the format `{rounds}.{turns}`
+     */
+    duration: number | null;
+
+    /**
+     * The remaining effect duration, in seconds of world time or as a decimal
+     * number with the format `{rounds}.{turns}`
+     */
+    remaining: number | null;
+
+    label: string;
+
+    /**
+     * An internal flag used determine when to recompute seconds-based duration
+     */
+    _worldTime: number;
+
+    /**
+     * An internal flag used determine when to recompute turns-based duration
+     */
+    _combatTime: number;
+  }
+}