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

package/src/foundry/client/data/documents/actor.d.mts

@@ -0,0 +1,315 @@
+import type { DeepPartial, InexactPartial } from "../../../../types/utils.d.mts";
+import type Document from "../../../common/abstract/document.d.mts";
+import type { DocumentDatabaseOperations } from "../../../common/abstract/document.d.mts";
+import type BaseActor from "../../../common/documents/actor.d.mts";
+
+declare global {
+  namespace Actor {
+    type Metadata = Document.MetadataFor<Actor>;
+
+    type ConfiguredClass = Document.ConfiguredClassForName<"Actor">;
+    type ConfiguredInstance = Document.ConfiguredInstanceForName<"Actor">;
+
+    interface DatabaseOperations extends DocumentDatabaseOperations<Actor> {}
+
+    type ItemTypes = {
+      [K in Game.Model.TypeNames<"Item">]: Array<
+        // TODO(LukeAbby): Looks like a `Item.OfType` helper would be useful.
+        Item.ConfiguredInstance & {
+          type: K;
+        } & (DataModelConfig extends { Item: { readonly [_ in K]?: infer SystemData } }
+            ? { system: SystemData }
+            : // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+              {})
+      >;
+    };
+
+    // Helpful aliases
+    type TypeNames = BaseActor.TypeNames;
+    type ConstructorData = BaseActor.ConstructorData;
+    type UpdateData = BaseActor.UpdateData;
+    type Schema = BaseActor.Schema;
+    type Source = BaseActor.Source;
+
+    interface RollInitiativeOptions {
+      /**
+       * Create new Combatant entries for Tokens associated with this actor.
+       * @defaultValue `false`
+       */
+      createCombatants?: boolean;
+
+      /**
+       * Re-roll the initiative for this Actor if it has already been rolled.
+       * @defaultValue `false`
+       */
+      rerollInitiative?: boolean;
+
+      /**
+       * Additional options passed to the Combat#rollInitiative method.
+       * @defaultValue `{}`
+       */
+      initiativeOptions?: Combat.InitiativeOptions;
+    }
+  }
+
+  /**
+   * The client-side Actor document which extends the common BaseActor model.
+   *
+   *  ### Hook Events
+   * {@link hookEvents.applyCompendiumArt}
+   *
+   * @see {@link Actors}            The world-level collection of Actor documents
+   * @see {@link ActorSheet}     The Actor configuration application
+   *
+   * @example <caption>Create a new Actor</caption>
+   * ```typescript
+   * let actor = await Actor.create({
+   *   name: "New Test Actor",
+   *   type: "character",
+   *   img: "artwork/character-profile.jpg"
+   * });
+   * ```
+   *
+   * @example <caption>Retrieve an existing Actor</caption>
+   * ```typescript
+   * let actor = game.actors.get(actorId);
+   * ```
+   */
+  class Actor extends ClientDocumentMixin(foundry.documents.BaseActor) {
+    static override metadata: Actor.Metadata;
+
+    protected override _configure(options?: { pack?: string | null }): void;
+
+    /**
+     * Maintain a list of Token Documents that represent this Actor, stored by Scene.
+     */
+    protected _dependentTokens: foundry.utils.IterableWeakMap<
+      Scene.ConfiguredInstance,
+      TokenDocument.ConfiguredInstance
+    >;
+
+    protected override _initializeSource(
+      data: this | Actor.ConstructorData,
+      options?: Omit<foundry.abstract.DataModel.DataValidationOptions, "parent">,
+    ): Actor.Source;
+
+    /**
+     * An object that tracks which tracks the changes to the data model which were applied by active effects
+     * @defaultValue `{}`
+     */
+    overrides: Record<string, unknown>;
+
+    /**
+     * The statuses that are applied to this actor by active effects
+     */
+    statuses: Set<string>;
+
+    /**
+     * A cached array of image paths which can be used for this Actor's token.
+     * Null if the list has not yet been populated.
+     * @defaultValue `null`
+     */
+    protected _tokenImages: string[] | null;
+
+    /**
+     * Cache the last drawn wildcard token to avoid repeat draws
+     * @defaultValue `null`
+     */
+    protected _lastWildcard: string | null;
+
+    /**
+     * Provide a thumbnail image path used to represent this document.
+     */
+    get thumbnail(): this["img"];
+
+    /**
+     * Provide an object which organizes all embedded Item instances by their type
+     */
+    get itemTypes(): Actor.ItemTypes;
+    /**
+     * Test whether an Actor document is a synthetic representation of a Token (if true) or a full Document (if false)
+     */
+    get isToken(): boolean;
+
+    /**
+     * Retrieve the list of ActiveEffects that are currently applied to this Actor.
+     */
+    get appliedEffects(): ActiveEffect.ConfiguredInstance[];
+
+    /**
+     * An array of ActiveEffect instances which are present on the Actor which have a limited duration.
+     */
+    get temporaryEffects(): ReturnType<this["effects"]["filter"]>;
+
+    /**
+     * Return a reference to the TokenDocument which owns this Actor as a synthetic override
+     */
+    get token(): TokenDocument.ConfiguredInstance | null;
+
+    /**
+     * Whether the Actor has at least one Combatant in the active Combat that represents it.
+     */
+    get inCombat(): boolean;
+
+    /**
+     * Apply any transformations to the Actor data which are caused by ActiveEffects.
+     */
+    applyActiveEffects(): void;
+
+    /**
+     * Retrieve an Array of active tokens which represent this Actor in the current canvas Scene.
+     * If the canvas is not currently active, or there are no linked actors, the returned Array will be empty.
+     * If the Actor is a synthetic token actor, only the exact Token which it represents will be returned.
+     *
+     * @param linked   - Limit results to Tokens which are linked to the Actor. Otherwise return all
+     *                   Tokens even those which are not linked. (default: `false`)
+     * @param document - Return the Document instance rather than the PlaceableObject (default: `false`)
+     * @returns An array of Token instances in the current Scene which reference this Actor.
+     */
+    getActiveTokens<ReturnDocument extends boolean = false>(
+      linked?: boolean,
+      document?: ReturnDocument,
+    ): ReturnDocument extends true ? TokenDocument.ConfiguredInstance[] : Token.ConfiguredInstance[];
+
+    /**
+     * Get all ActiveEffects that may apply to this Actor.
+     * If CONFIG.ActiveEffect.legacyTransferral is true, this is equivalent to actor.effects.contents.
+     * If CONFIG.ActiveEffect.legacyTransferral is false, this will also return all the transferred ActiveEffects on any
+     * of the Actor's owned Items.
+     */
+    allApplicableEffects(): Generator<ActiveEffect.ConfiguredInstance>;
+
+    /**
+     * Prepare a data object which defines the data schema used by dice roll commands against this Actor
+     * @remarks defaults to this.system, but provided as object for flexible overrides
+     */
+    getRollData(): object;
+
+    /**
+     * Create a new TokenData object which can be used to create a Token representation of the Actor.
+     * @param data - Additional data, such as x, y, rotation, etc. for the created token data (default: `{}`)
+     * @returns The created TokenData instance
+     */
+    getTokenDocument(data?: foundry.documents.BaseToken.ConstructorData): Promise<TokenDocument.ConfiguredInstance>;
+
+    /**
+     * Get an Array of Token images which could represent this Actor
+     */
+    getTokenImages(): Promise<string[]>;
+
+    /**
+     * Handle how changes to a Token attribute bar are applied to the Actor.
+     * This allows for game systems to override this behavior and deploy special logic.
+     * @param attribute - The attribute path
+     * @param value     - The target attribute value
+     * @param isDelta   - Whether the number represents a relative change (true) or an absolute change (false) (default: `false`)
+     * @param isBar     - Whether the new value is part of an attribute bar, or just a direct value (default: `true`)
+     * @returns The updated Actor document
+     */
+    modifyTokenAttribute(attribute: string, value: number, isDelta: boolean, isBar: boolean): Promise<this | undefined>;
+
+    override prepareData(): void;
+
+    override prepareEmbeddedDocuments(): void;
+
+    /**
+     * Roll initiative for all Combatants in the currently active Combat encounter which are associated with this Actor.
+     * If viewing a full Actor document, all Tokens which map to that actor will be targeted for initiative rolls.
+     * If viewing a synthetic Token actor, only that particular Token will be targeted for an initiative roll.
+     *
+     * @param options - Configuration for how initiative for this Actor is rolled.
+     * @returns A promise which resolves to the Combat document once rolls are complete.
+     */
+    rollInitiative(options?: Actor.RollInitiativeOptions): Promise<void>;
+
+    /**
+     * Toggle a configured status effect for the Actor.
+     * @param statusId  - A status effect ID defined in CONFIG.statusEffects
+     * @param options   - Additional options which modify how the effect is created
+     * @returns A promise which resolves to one of the following values:
+     *            - ActiveEffect if a new effect need to be created
+     *            - true if was already an existing effect
+     *            - false if an existing effect needed to be removed
+     *            - undefined if no changes need to be made
+     */
+    toggleStatusEffect(
+      statusId: string,
+      options?: InexactPartial<{
+        /** Force the effect to be active or inactive regardless of its current state. */
+        active: boolean;
+        /** Display the toggled effect as an overlay. Default `false`. */
+        overlay: boolean;
+      }>,
+    ): Promise<ActiveEffect.ConfiguredInstance | boolean | undefined>;
+
+    /**
+     * Request wildcard token images from the server and return them.
+     * @param actorId - The actor whose prototype token contains the wildcard image path.
+     * @internal
+     */
+    protected static _requestTokenImages(
+      actorId: string,
+      options?: {
+        /** The name of the compendium the actor is in. */
+        pack: string;
+      },
+    ): Promise<string[]>;
+
+    /**
+     * Get this actor's dependent tokens.
+     * If the actor is a synthetic token actor, only the exact Token which it represents will be returned.
+     */
+    getDependentTokens(
+      options?: InexactPartial<{
+        /**
+         * A single Scene, or list of Scenes to filter by.
+         */
+        scenes: Scene | Scene[];
+        /**
+         * Limit the results to tokens that are linked to the actor.
+         * @defaultValue `false`
+         */
+        linked: boolean;
+      }>,
+    ): TokenDocument.ConfiguredInstance[];
+
+    /**
+     * Register a token as a dependent of this actor.
+     * @param token - The Token
+     */
+    protected _registerDependantToken(token: TokenDocument): void;
+
+    /**
+     * Remove a token from this actor's dependents.
+     * @param token - The Token
+     */
+    protected _unregisterDependentToken(token: TokenDocument): void;
+
+    /**
+     * Prune a whole scene from this actor's dependent tokens.
+     * @param scene - The scene
+     */
+    protected _unregisterDependentScene(scene: Scene): void;
+
+    /**
+     * @privateRemarks _preCreate, _onUpdate, onCreateDescendantDocuments, onUpdateDescendantDocuments, and _onDeleteDescendentDocuments 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.
+     */
+
+    /**
+     * Additional workflows to perform when any descendant document within this Actor changes.
+     * @internal
+     */
+    protected _onEmbeddedDocumentChange(): void;
+
+    /**
+     * Update the active TokenDocument instances which represent this Actor.
+     * @param update  - The update delta.
+     * @param options - The update context.
+     */
+    protected _updateDependentTokens(
+      update: DeepPartial<TokenDocument["_source"]>,
+      options: Document.OnUpdateOptions<"Token">,
+    ): void;
+  }
+}

package/src/foundry/client/data/documents/adventure.d.mts

@@ -0,0 +1,105 @@
+import type { FolderDocumentTypes } from "../../../../types/helperTypes.d.mts";
+import type { InexactPartial } from "../../../../types/utils.d.mts";
+// eslint-disable-next-line import/no-named-as-default
+import type DataModel from "../../../common/abstract/data.d.mts";
+import type { fields } from "../../../common/data/module.d.mts";
+import type { DocumentDatabaseOperations } from "../../../common/abstract/document.d.mts";
+import type Document from "../../../common/abstract/document.d.mts";
+import type BaseAdventure from "../../../common/documents/adventure.d.mts";
+
+declare global {
+  namespace Adventure {
+    type Metadata = Document.MetadataFor<Adventure>;
+
+    type ConfiguredClass = Document.ConfiguredClassForName<"Adventure">;
+    type ConfiguredInstance = Document.ConfiguredInstanceForName<"Adventure">;
+
+    interface DatabaseOperations extends DocumentDatabaseOperations<Adventure> {}
+
+    // Helpful aliases
+    type ConstructorData = BaseAdventure.ConstructorData;
+    type UpdateData = BaseAdventure.UpdateData;
+    type Schema = BaseAdventure.Schema;
+    type Source = BaseAdventure.Source;
+
+    interface PrepareImportOptions {
+      /**
+       * A subset of adventure fields to import.
+       */
+      // TODO: This isn't *quite* right as the keyof is including all the nevers.
+      importFields: Array<keyof typeof foundry.documents.BaseAdventure.contentFields | "all">;
+    }
+
+    interface ImportOptions extends PrepareImportOptions {
+      /**
+       * Display a warning dialog if existing documents would be overwritten
+       * @defaultValue `true`
+       */
+      dialog: boolean;
+    }
+  }
+
+  /**
+   * The client-side Adventure document which extends the common {@link foundry.documents.BaseAdventure} model.
+   */
+  class Adventure extends ClientDocumentMixin(foundry.documents.BaseAdventure) {
+    static override metadata: Adventure.Metadata;
+
+    static fromSource<Schema extends DataSchema>(
+      source: fields.SchemaField.InnerAssignmentType<Schema>,
+      {
+        strict,
+        ...context
+      }?: DataModel.ConstructorOptions & {
+        /**
+         * Models created from trusted source data are validated non-strictly
+         * @defaultValue `false`
+         */
+        strict?: boolean;
+      },
+    ): DataModel<Schema, DataModel.Any | null>;
+
+    /**
+     * Perform a full import workflow of this Adventure.
+     * Create new and update existing documents within the World.
+     * @param options - Options which configure and customize the import process
+     * @returns The import result
+     */
+    import(options?: InexactPartial<Adventure.ImportOptions>): Promise<AdventureImportResult>;
+
+    /**
+     * Prepare Adventure data for import into the World.
+     * @param options - Options passed in from the import dialog to configure the import behavior
+     * @returns A subset of adventure fields to import.
+     */
+    prepareImport(options?: InexactPartial<Adventure.PrepareImportOptions>): Promise<AdventureImportData>;
+
+    /**
+     * Execute an Adventure import workflow, creating and updating documents in the World.
+     */
+    importContent(data?: InexactPartial<AdventureImportData>): Promise<AdventureImportResult>;
+  }
+
+  interface AdventureImportData {
+    toCreate?: DocumentDataRecord;
+    toUpdate?: DocumentDataRecord;
+    documentCount: number;
+  }
+
+  interface AdventureImportResult {
+    created: DocumentResult;
+    updated: DocumentResult;
+  }
+}
+
+type DocumentDataRecord = {
+  [K in AdventureDocumentTypes]?: foundry.data.fields.SchemaField.InnerAssignmentType<
+    ReturnType<Document.ConfiguredClassForName<K>["defineSchema"]>
+  >[];
+};
+
+type DocumentResult = {
+  [K in AdventureDocumentTypes]?: InstanceType<Document.ConfiguredClassForName<K>>[];
+};
+
+type AdventureDocumentTypes = Exclude<FolderDocumentTypes, "Adventure"> | "Folder";

package/src/foundry/client/data/documents/ambient-light.d.mts

@@ -0,0 +1,43 @@
+import type Document from "../../../common/abstract/document.d.mts";
+import type { DocumentDatabaseOperations } from "../../../common/abstract/document.d.mts";
+import type BaseAmbientLight from "../../../common/documents/ambient-light.d.mts";
+
+declare global {
+  namespace AmbientLightDocument {
+    type Metadata = Document.MetadataFor<AmbientLightDocument>;
+
+    type ConfiguredClass = Document.ConfiguredClassForName<"AmbientLight">;
+    type ConfiguredInstance = Document.ConfiguredInstanceForName<"AmbientLight">;
+
+    /* eslint-disable @typescript-eslint/no-empty-object-type */
+    interface DatabaseOperations
+      extends DocumentDatabaseOperations<AmbientLightDocument, {}, { animate: boolean }, {}> {}
+    /* eslint-enable @typescript-eslint/no-empty-object-type */
+
+    // Helpful aliases
+    type ConstructorData = BaseAmbientLight.ConstructorData;
+    type UpdateData = BaseAmbientLight.UpdateData;
+    type Schema = BaseAmbientLight.Schema;
+    type Source = BaseAmbientLight.Source;
+  }
+
+  /**
+   * The client-side AmbientLight document which extends the common BaseAmbientLight model.
+   *
+   * @see {@link Scene}                     The Scene document type which contains AmbientLight documents
+   * @see {@link AmbientLightConfig}        The AmbientLight configuration application
+   */
+  class AmbientLightDocument extends CanvasDocumentMixin(foundry.documents.BaseAmbientLight) {
+    static override metadata: AmbientLightDocument.Metadata;
+
+    /**
+     * @privateRemarks _onUpdate is overridden but with no signature changes.
+     * For type simplicity it is left off. These methods historically have been the source of a large amount of computation from tsc.
+     */
+
+    /**
+     * Is this ambient light source global in nature?
+     */
+    get isGlobal(): boolean;
+  }
+}

package/src/foundry/client/data/documents/ambient-sound.d.mts

@@ -0,0 +1,30 @@
+import type Document from "../../../common/abstract/document.d.mts";
+import type { DocumentDatabaseOperations } from "../../../common/abstract/document.d.mts";
+import type BaseAmbientSound from "../../../common/documents/ambient-sound.d.mts";
+
+declare global {
+  namespace AmbientSoundDocument {
+    type Metadata = Document.MetadataFor<AmbientSoundDocument>;
+
+    type ConfiguredClass = Document.ConfiguredClassForName<"AmbientSound">;
+    type ConfiguredInstance = Document.ConfiguredInstanceForName<"AmbientSound">;
+
+    interface DatabaseOperations extends DocumentDatabaseOperations<AmbientSoundDocument> {}
+
+    // Helpful aliases
+    type ConstructorData = BaseAmbientSound.ConstructorData;
+    type UpdateData = BaseAmbientSound.UpdateData;
+    type Schema = BaseAmbientSound.Schema;
+    type Source = BaseAmbientSound.Source;
+  }
+
+  /**
+   * The client-side AmbientSound document which extends the common BaseAmbientSound document model.
+   *
+   * @see {@link Scene}                   The Scene document type which contains AmbientSound documents
+   * @see {@link AmbientSoundConfig}      The AmbientSound configuration application
+   */
+  class AmbientSoundDocument extends CanvasDocumentMixin(foundry.documents.BaseAmbientSound) {
+    static override metadata: AmbientSoundDocument.Metadata;
+  }
+}

package/src/foundry/client/data/documents/card.d.mts

@@ -0,0 +1,127 @@
+import type { DeepPartial, InexactPartial } from "../../../../types/utils.d.mts";
+import type Document from "../../../common/abstract/document.d.mts";
+import type { DocumentDatabaseOperations } from "../../../common/abstract/document.d.mts";
+import type { CardFaceData } from "../../../common/documents/_types.d.mts";
+import type BaseCard from "../../../common/documents/card.d.mts";
+
+declare global {
+  namespace Card {
+    type Metadata = Document.MetadataFor<Card>;
+
+    type ConfiguredClass = Document.ConfiguredClassForName<"Card">;
+    type ConfiguredInstance = Document.ConfiguredInstanceForName<"Card">;
+
+    interface DatabaseOperations extends DocumentDatabaseOperations<Card> {}
+
+    // Helpful aliases
+    type TypeNames = BaseCard.TypeNames;
+    type ConstructorData = BaseCard.ConstructorData;
+    type UpdateData = BaseCard.UpdateData;
+    type Schema = BaseCard.Schema;
+    type Source = BaseCard.Source;
+  }
+
+  /**
+   * The client-side Card document which extends the common BaseCard document model.
+   *
+   * @see {@link Cards}                    The Cards document type which contains Card embedded documents
+   */
+  class Card extends ClientDocumentMixin(foundry.documents.BaseCard) {
+    static override metadata: Card.Metadata;
+
+    /**
+     * The current card face
+     */
+    get currentFace(): CardFaceData | null;
+
+    /**
+     * The image of the currently displayed card face or back
+     */
+    get img(): string;
+
+    /**
+     * The name of the current card face, or the name of the card itself
+     */
+    get name(): string;
+
+    /**
+     * A reference to the source Cards document which defines this Card.
+     */
+    get source(): Cards.ConfiguredInstance | undefined | null;
+
+    /**
+     * A convenience property for whether or not the Card is within its source Cards stack. Cards in decks are always
+     * considered home.
+     */
+    get isHome(): boolean;
+
+    /**
+     * Whether or not to display the face of this card?
+     */
+    get showFace(): boolean;
+
+    /**
+     * Does this Card have a next face available to flip to?
+     */
+    get hasNextFace(): boolean;
+
+    /**
+     * Does this Card have a previous face available to flip to?
+     */
+    get hasPreviousFace(): boolean;
+
+    override prepareDerivedData(): void;
+
+    /**
+     * Flip this card to some other face. A specific face may be requested, otherwise:
+     * If the card currently displays a face the card is flipped to the back.
+     * If the card currently displays the back it is flipped to the first face.
+     * @param face - A specific face to flip the card to
+     * @returns A reference to this card after the flip operation is complete
+     */
+    flip(face?: number | null): Promise<Card.ConfiguredInstance | undefined>;
+
+    /**
+     * Pass this Card to some other Cards document.
+     * @param to      - A new Cards document this card should be passed to
+     * @param options - (default: `{}`)
+     * @returns A reference to this card after the it has been passed to another parent document
+     */
+    pass(to: Cards.ConfiguredInstance, options?: Cards.PassOptions): Promise<Card.ConfiguredInstance | undefined>;
+
+    /**
+     * Play a specific card to some other Cards document.
+     * This method is currently a more semantic alias for Card#pass.
+     * @see Card#pass
+     */
+    play(to: Cards.ConfiguredInstance, options?: Cards.PassOptions): Promise<Card.ConfiguredInstance | undefined>;
+
+    /**
+     * Discard a specific card to some other Cards document.
+     * This method is currently a more semantic alias for Card#pass.
+     * @see Card#pass
+     */
+    discard(to: Cards.ConfiguredInstance, options?: Cards.PassOptions): Promise<Card.ConfiguredInstance | undefined>;
+
+    /**
+     * Recall this Card to its original Cards parent.
+     * @param options - Options which modify the recall operation
+     *                  (default: `{}`)
+     * @returns A reference to the recallled card belonging to its original parent
+     */
+    recall(options?: Cards.ResetOptions): Promise<Card.ConfiguredInstance>;
+
+    /**
+     * Create a chat message which displays this Card.
+     * @param messageData - Additional data which becomes part of the created ChatMessageData
+     *                      (default: `{}`)
+     * @param options     - Options which modify the message creation operation
+     *                      (default: `{}`)
+     * @returns The created chat message
+     */
+    toMessage(
+      messageData?: DeepPartial<foundry.documents.BaseChatMessage.ConstructorData>,
+      options?: InexactPartial<Document.OnCreateOptions<"ChatMessage">>,
+    ): Promise<ChatMessage.ConfiguredInstance | undefined>;
+  }
+}