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

package/src/foundry/client/data/documents/combat.d.ts

@@ -1,227 +0,0 @@
-import type { ConfiguredDocumentClass } from '../../../../types/helperTypes';
-import type { DocumentModificationOptions } from '../../../common/abstract/document.mjs';
-import type { ChatMessageDataConstructorData } from '../../../common/data/data.mjs/chatMessageData';
-import type { CombatantDataSource } from '../../../common/data/data.mjs/combatantData';
-
-declare global {
-  /**
-   * The Combat model definition which defines common behavior of an Combat document between both client and server.
-   * Each Combat document contains CombatData which defines its data schema.
-   *
-   * @see {@link data.CombatData}               The Combat data schema
-   * @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
-   */
-  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]
-    );
-
-    /** Track the sorted turn order of this combat encounter */
-    turns: InstanceType<ConfiguredDocumentClass<typeof Combatant>>[];
-
-    /** Record the current round, turn, and tokenId to understand changes in the encounter state */
-    current: RoundData;
-
-    /** Track the previous round, turn, and tokenId to understand changes in the encounter state */
-    previous: RoundData;
-
-    /**
-     * Track whether a sound notification is currently being played to avoid double-dipping
-     * @defaultValue `false`
-     * @internal
-     */
-    protected _soundPlaying: boolean;
-
-    /** The configuration setting used to record Combat preferences */
-    static CONFIG_SETTING: 'combatTrackerConfig';
-
-    /** Get the Combatant who has the current turn. */
-    get combatant(): this['turns'][number] | undefined;
-
-    /** The numeric round of the Combat encounter */
-    get round(): number;
-
-    /**
-     * A reference to the Scene document within which this Combat encounter occurs.
-     * If a specific Scene is not set in the Combat Data, the currently viewed scene is assumed instead.
-     */
-    get scene(): InstanceType<ConfiguredDocumentClass<typeof Scene>> | undefined;
-
-    /** Return the object of settings which modify the Combat Tracker behavior */
-    get settings(): typeof CombatEncounters['settings'];
-
-    /** Has this combat encounter been started? */
-    get started(): boolean;
-
-    /** The numeric turn of the combat round in the Combat encounter */
-    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
-     * @param options - Additional context to customize the update workflow
-     */
-    activate(
-      options?: DocumentModificationContext & foundry.utils.MergeObjectOptions
-    ): Promise<InstanceType<ConfiguredDocumentClass<typeof Combat>>[]>;
-
-    /** Display a dialog querying the GM whether they wish to end the combat encounter and empty the tracker */
-    endCombat(): Promise<InstanceType<ConfiguredDocumentClass<typeof Combat>> | undefined>;
-
-    /**
-     * Get a Combatant using its Token id
-     * @param tokenId - The id of the Token for which to acquire the combatant
-     */
-    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>;
-
-    /** Advance the combat to the next turn */
-    nextTurn(): Promise<this | undefined>;
-
-    override prepareDerivedData(): void;
-
-    /** Rewind the combat to the previous round */
-    previousRound(): Promise<this | undefined>;
-
-    /** 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 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 document once updates are complete.
-     */
-    rollInitiative(ids: string | string[], options?: InitiativeOptions): Promise<this>;
-
-    /**
-     * Roll initiative for all combatants which have not already rolled
-     * @param options - Additional options forwarded to the Combat.rollInitiative method
-     *                  default `{}`
-     */
-    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): 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 value - A specific initiative value to set
-     */
-    setInitiative(id: string, value: number): Promise<void>;
-
-    /** Return the Array of combatants sorted into initiative order, breaking ties alphabetically by name. */
-    setupTurns(): this['turns'];
-
-    /** Begin the combat encounter, advancing to round 1 and turn 1 */
-    startCombat(): Promise<this | undefined>;
-
-    /**
-     * 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;
-
-    protected override _onCreate(
-      data: this['data']['_source'],
-      options: DocumentModificationOptions,
-      userId: string
-    ): void;
-
-    protected override _onUpdate(
-      changed: DeepPartial<this['data']['_source']>,
-      options: DocumentModificationOptions,
-      userId: string
-    ): void;
-
-    protected override _onDelete(options: DocumentModificationOptions, userId: string): void;
-
-    protected override _onCreateEmbeddedDocuments(
-      type: string,
-      documents: InstanceType<ConfiguredDocumentClass<typeof Combatant>>[],
-      result: CombatantDataSource[],
-      options: DocumentModificationOptions,
-      userId: string
-    ): void;
-
-    protected override _onUpdateEmbeddedDocuments(
-      embeddedName: string,
-      documents: InstanceType<ConfiguredDocumentClass<typeof Combatant>>[],
-      result: CombatantDataSource[],
-      options: DocumentModificationOptions,
-      userId: string
-    ): void;
-
-    protected override _onDeleteEmbeddedDocuments(
-      embeddedName: string,
-      documents: InstanceType<ConfiguredDocumentClass<typeof Combatant>>[],
-      result: string[],
-      options: DocumentModificationContext,
-      userId: string
-    ): void;
-  }
-}
-
-interface InitiativeOptions {
-  /**
-   * A non-default initiative formula to roll. Otherwise the system default is used.
-   * @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?: ChatMessageDataConstructorData;
-}
-
-interface RoundData {
-  round: number | null;
-  turn: number | null;
-  tokenId: string | null;
-  combatantId: string | null;
-}

package/src/foundry/client/data/documents/combatant.d.ts

@@ -1,104 +0,0 @@
-import { ConfiguredDocumentClass } from '../../../../types/helperTypes';
-
-declare global {
-  /**
-   * The client-side Combatant document which extends the common BaseCombatant model.
-   * Each Combatant belongs to the effects collection of its parent Document.
-   * Each Combatant contains a CombatantData object which provides its source data.
-   *
-   * @see {@link data.CombatantData}                  The Combatant data schema
-   * @see {@link documents.Combat}                    The Combat document which contains Combatant embedded documents
-   * @see {@link applications.CombatantConfig}        The Combatant configuration application
-   */
-  class Combatant extends ClientDocumentMixin(foundry.documents.BaseCombatant) {
-    /**
-     * @param data    - Initial data provided to construct the Combatant document
-     * @param context - The document context, see {@link foundry.abstract.Document}
-     */
-    constructor(
-      data: ConstructorParameters<typeof foundry.documents.BaseCombatant>[0],
-      context: ConstructorParameters<typeof foundry.documents.BaseCombatant>[1]
-    );
-
-    /** The current value of the special tracked resource which pertains to this Combatant */
-    resource: `${number}` | number | boolean | null;
-
-    /**
-     * A convenience alias of Combatant#parent which is more semantically intuitive
-     */
-    get combat(): InstanceType<ConfiguredDocumentClass<typeof Combat>> | null;
-
-    /** Determine the image icon path that should be used to portray this Combatant in the combat tracker or elsewhere */
-    get img(): string;
-
-    /**  A convenience reference to the current initiative score of this Combatant */
-    get initiative(): number | null;
-
-    /** This is treated as a non-player combatant if it has no associated actor and no player users who can control it */
-    get isNPC(): boolean;
-
-    override get isOwner(): 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;
-
-    /** The displayed name for the Combatant is based off its own configured data, or the data of its represented Token. */
-    get name(): string;
-
-    /** A reference to the Actor document which this Combatant represents, if any */
-    get actor(): InstanceType<ConfiguredDocumentClass<typeof foundry.documents.BaseActor>> | null;
-
-    /** A reference to the Token document which this Combatant represents, if any */
-    get token(): InstanceType<ConfiguredDocumentClass<typeof foundry.documents.BaseToken>> | null;
-
-    /** 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: foundry.documents.BaseUser,
-      permission: keyof typeof foundry.CONST.DOCUMENT_PERMISSION_LEVELS | foundry.CONST.DOCUMENT_PERMISSION_LEVELS,
-      { exact }?: { exact?: boolean }
-    ): boolean;
-
-    /**
-     * Get a Roll object which represents the initiative roll for this Combatant.
-     * @param formula -  An explicit Roll formula to use for the combatant.
-     * @returns The Roll instance to use for the combatant.
-     */
-    getInitiativeRoll(formula?: string): Roll;
-
-    /**
-     * Roll initiative for this particular combatant.
-     * @param formula - A dice formula which overrides the default for this Combatant.
-     * @returns The updated Combatant.
-     */
-    rollInitiative(formula: string): Promise<this | undefined>;
-
-    override prepareDerivedData(): void;
-
-    /**
-     * Update the value of the tracked resource for this Combatant.
-     */
-    updateResource(): this['resource'];
-
-    /**
-     * Acquire the default dice formula which should be used to roll initiative for this combatant.
-     * Modules or systems could choose to override or extend this to accommodate special situations.
-     * @returns  The initiative formula to use for this combatant.
-     */
-    protected _getInitiativeFormula(): string;
-
-    /**
-     * @deprecated since v9
-     */
-    get isVisible(): boolean;
-  }
-}
-export {};

package/src/foundry/client/data/documents/drawing.d.ts

@@ -1,19 +0,0 @@
-import { ConfiguredDocumentClass } from '../../../../types/helperTypes';
-
-declare global {
-  /**
-   * The client-side Drawing document which extends the common BaseDrawing model.
-   * Each Drawing document contains DrawingData which defines its data schema.
-   *
-   * @see {@link data.DrawingData}              The Drawing data schema
-   * @see {@link documents.Scene}               The Scene document type which contains Drawing embedded documents
-   * @see {@link applications.DrawingConfig}    The Drawing configuration application
-   */
-  class DrawingDocument extends CanvasDocumentMixin(foundry.documents.BaseDrawing) {
-    /**
-     * A reference to the User who created the Drawing document.
-     * @remarks Will return undefined if the user has been deleted
-     */
-    get author(): InstanceType<ConfiguredDocumentClass<typeof User>> | undefined;
-  }
-}

package/src/foundry/client/data/documents/fog-exploration.d.ts

@@ -1,64 +0,0 @@
-import { ConfiguredDocumentClass } from '../../../../types/helperTypes';
-import { RequestOptions } from '../../../common/abstract/backend.mjs';
-
-declare global {
-  /**
-   * The client-side FogExploration document which extends the common BaseFogExploration model.
-   * Each FogExploration document contains FogExplorationData which defines its data schema.
-   *
-   * @see {@link data.FogExplorationData} The FogExploration data schema
-   */
-  class FogExploration extends ClientDocumentMixin(foundry.documents.BaseFogExploration) {
-    /**
-     * @param data - Initial data provided to construct the FogExploration document
-     *               (default: `{}`)
-     */
-    constructor(
-      data?: ConstructorParameters<ConstructorOf<foundry.documents.BaseFogExploration>>[0],
-      context?: ConstructorParameters<ConstructorOf<foundry.documents.BaseFogExploration>>[1]
-    );
-
-    /**
-     * Explore fog of war for a new point source position.
-     * @param source - The candidate source of exploration
-     * @param force  - Force the position to be re-explored
-     *                 (default: `false`)
-     * @returns Is the source position newly explored?
-     */
-    explore(source: PointSource, force?: boolean): boolean;
-
-    /**
-     * Obtain the fog of war exploration progress for a specific Scene and User.
-     * @param options - (default: `{}`)
-     */
-    static get(
-      {
-        scene,
-        user
-      }?: {
-        scene?: InstanceType<ConfiguredDocumentClass<typeof Scene>>;
-        user?: InstanceType<ConfiguredDocumentClass<typeof User>>;
-      },
-      options?: RequestOptions
-    ): Promise<StoredDocument<InstanceType<ConfiguredDocumentClass<typeof FogExploration>>> | null>;
-
-    /**
-     * Transform the explored base64 data into a PIXI.Texture object
-     */
-    getTexture(): PIXI.Texture | null;
-
-    /**
-     * Open Socket listeners which transact JournalEntry data
-     * @internal
-     */
-    static _activateSocketListeners(socket: io.Socket): void;
-
-    /**
-     * Handle a request from the server to reset fog of war for a particular scene.
-     * @internal
-     */
-    protected static _onResetFog(sceneId: string): void | Promise<void>;
-  }
-}
-
-export {};

package/src/foundry/client/data/documents/folder.d.ts

@@ -1,115 +0,0 @@
-import { ConfiguredDocumentClass, ConstructorDataType, DocumentConstructor } from '../../../../types/helperTypes';
-import { DocumentModificationOptions } from '../../../common/abstract/document.mjs';
-
-declare global {
-  /**
-   * The client-side Folder document which extends the common BaseFolder model.
-   * Each Folder document contains FolderData which defines its data schema.
-   *
-   * @see {@link data.FolderData}              The Folder data schema
-   * @see {@link documents.Folders}            The world-level collection of Folder documents
-   * @see {@link embedded.FolderSound}         The FolderSound embedded document within a parent Folder
-   * @see {@link applications.FolderConfig}    The Folder configuration application
-   *
-   * @param data - Initial data provided to construct the Folder document
-   */
-  class Folder extends ClientDocumentMixin(foundry.documents.BaseFolder) {
-    /**
-     * The depth of this folder in its sidebar tree
-     *
-     * @remarks For folders that have been populated by the {@link SidebarDirectory}, this is always be defined
-     */
-    depth?: number;
-
-    /**
-     * Return an array of the Document instances which are contained within this Folder.
-     */
-    get contents(): InstanceType<typeof CONFIG[this['data']['type']]['documentClass']>[];
-
-    /**
-     * Return whether the folder is displayed in the sidebar to the current user
-     */
-    get displayed(): boolean;
-
-    /**
-     * Return a reference to the Document type which is contained within this Folder.
-     */
-    get documentClass(): typeof CONFIG[this['data']['type']]['documentClass'];
-
-    /**
-     * Return a reference to the WorldCollection instance which provides Documents to this Folder.
-     */
-    get documentCollection(): Collection<InstanceType<typeof CONFIG[this['data']['type']]['documentClass']>>; // TODO: WorldCollection or ReturnType<Game['collections]['get]>
-
-    /**
-     * Return whether the folder is currently expanded within the sidebar interface.
-     */
-    get expanded(): boolean;
-
-    /**
-     * A reference to the parent Folder if one is set, otherwise null.
-     */
-    get parentFolder(): Folder | null;
-
-    /**
-     * Present a Dialog form to create a new Folder.
-     * @see {@link ClientDocumentMixin.createDialog}
-     * @param data    - Initial data with which to populate the creation form
-     *                  (default: `{}`)
-     * @param context - Additional context options or dialog positioning options
-     *                  (default: `{}`)
-     * @returns A Promise which resolves to the created Folder, or null if the dialog was closed.
-     *
-     * @remarks For weird reasons, we need to make this generic.
-     */
-    static createDialog<T extends DocumentConstructor>(
-      this: T,
-      data?:
-        | DeepPartial<
-            | ConstructorDataType<InstanceType<T>['data']>
-            | (ConstructorDataType<InstanceType<T>['data']> & Record<string, unknown>)
-          >
-        | undefined,
-      context?: Partial<Omit<FolderConfig.Options, 'resolve'>>
-    ): Promise<InstanceType<ConfiguredDocumentClass<T>> | null | undefined>;
-
-    /**
-     * Export all Documents contained in this Folder to a given Compendium pack.
-     * Optionally update existing Documents within the Pack by name, otherwise append all new entries.
-     * @param pack    - A Compendium pack to which the documents will be exported
-     * @param options - Additional options which customize how content is exported. See {@link ClientDocumentMixin#toCompendium}
-     *                  (default: `{}`)
-     * @returns The updated Compendium Collection instance
-     */
-    exportToCompendium<Metadata extends CompendiumCollection.Metadata>(
-      pack: CompendiumCollection<Metadata>,
-      options?: Folder.ExportToCompendiumOptions | undefined
-    ): Promise<CompendiumCollection<Metadata>>;
-
-    /**
-     * Provide a dialog form that allows for exporting the contents of a Folder into an eligible Compendium pack.
-     * @param pack    - A pack ID to set as the default choice in the select input
-     * @param options - Additional options passed to the Dialog.prompt method
-     *                  (default: `{}`)
-     * @returns A Promise which resolves or rejects once the dialog has been submitted or closed
-     */
-    exportDialog(pack: string, options?: DialogOptions): Promise<void>;
-
-    /**
-     * Get the Folder documents which are sub-folders of the current folder, either direct children or recursively.
-     * @param recursive - Identify child folders recursively, if false only direct children are returned
-     *                    (default: `false`)
-     * @returns An array of Folder documents which are subfolders of this one
-     */
-    getSubfolders(recursive?: boolean): InstanceType<ConfiguredDocumentClass<typeof Folder>>[];
-
-    protected _onDelete(options: DocumentModificationOptions, userId: string): void;
-  }
-
-  namespace Folder {
-    interface ExportToCompendiumOptions {
-      /** Update existing entries in the Compendium pack, matching by name */
-      updateByName?: boolean | undefined;
-    }
-  }
-}

package/src/foundry/client/data/documents/index.d.ts

@@ -1,27 +0,0 @@
-import './active-effect';
-import './actor';
-import './ambient-light';
-import './ambient-sound';
-import './card';
-import './cards';
-import './chat-message';
-import './combat';
-import './combatant';
-import './drawing';
-import './fog-exploration';
-import './folder';
-import './item';
-import './journal-entry';
-import './macro';
-import './measured-template';
-import './note';
-import './playlist-sound';
-import './playlist';
-import './scene';
-import './setting';
-import './table-result';
-import './table';
-import './tile';
-import './token';
-import './user';
-import './wall';

package/src/foundry/client/data/documents/item.d.ts

@@ -1,59 +0,0 @@
-import { ConfiguredDocumentClass } from '../../../../types/helperTypes';
-
-declare global {
-  /**
-   * The client-side Item document which extends the common BaseItem abstraction.
-   * Each Item document contains ItemData which defines its data schema.
-   *
-   * @see {@link data.ItemData}              The Item data schema
-   * @see {@link documents.Items}            The world-level collection of Item documents
-   * @see {@link applications.ItemSheet}     The Item configuration application
-   *
-   * @param data    - Initial data provided to construct the Item document
-   * @param context - The document context, see {@link foundry.abstract.Document}
-   */
-  class Item extends ClientDocumentMixin(foundry.documents.BaseItem) {
-    /**
-     * A convenience alias of Item#parent which is more semantically intuitive
-     */
-    get actor(): this['parent'];
-
-    /**
-     * A convenience reference to the image path (data.img) used to represent this Item
-     */
-    get img(): this['data']['img'];
-
-    /**
-     * Provide a thumbnail image path used to represent this document.
-     */
-    get thumbnail(): this['data']['img'];
-
-    /**
-     * A convenience alias of Item#isEmbedded which is preserves legacy support
-     */
-    get isOwned(): this['isEmbedded'];
-
-    /**
-     * Return an array of the Active Effect instances which originated from this Item.
-     * The returned instances are the ActiveEffect instances which exist on the Item itself.
-     */
-    get transferredEffects(): ReturnType<this['effects']['filter']>;
-
-    /**
-     * Prepare a data object which defines the data schema used by dice roll commands against this Item
-     */
-    getRollData(): object;
-
-    // @ts-expect-error For some reason, proctected static methods from Document are lost, so ts complains that this isn't actually an override
-    protected static override _onCreateDocuments(
-      items: Array<InstanceType<ConfiguredDocumentClass<typeof Item>>>,
-      context: DocumentModificationContext
-    ): Promise<unknown>;
-
-    // @ts-expect-error For some reason, proctected static methods from Document are lost, so ts complains that this isn't actually an override
-    protected static override _onDeleteDocuments(
-      items: Array<InstanceType<ConfiguredDocumentClass<typeof Item>>>,
-      context: DocumentModificationContext
-    ): Promise<unknown>;
-  }
-}