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

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

@@ -0,0 +1,88 @@
+import type { SchemaField } from "../../../common/data/fields.d.mts";
+import type { BaseActor } from "../../../common/documents/_module.d.mts";
+import type { DocumentDatabaseOperations } from "../../../common/abstract/document.d.mts";
+import type Document from "../../../common/abstract/document.d.mts";
+
+declare global {
+  namespace ActorDelta {
+    type ConfiguredClass = Document.ConfiguredClassForName<"ActorDelta">;
+    type ConfiguredInstance = Document.ConfiguredInstanceForName<"ActorDelta">;
+
+    interface DatabaseOperations extends DocumentDatabaseOperations<ActorDelta> {}
+  }
+
+  /**
+   * The client-side ActorDelta embedded document which extends the common BaseActorDelta document model.
+   * @see {@link TokenDocument}  The TokenDocument document type which contains ActorDelta embedded documents.
+   */
+  class ActorDelta extends ClientDocumentMixin(foundry.documents.BaseActorDelta) {
+    protected override _configure(options?: { pack?: string | null }): void;
+
+    protected override _initialize(options?: any): void;
+    protected override _initialize(): void;
+
+    /** Pass-through the type from the synthetic Actor, if it exists. */
+    _type: string;
+
+    get type(): string;
+
+    set type(type: string);
+
+    /**
+     * Apply this ActorDelta to the base Actor and return a synthetic Actor.
+     * @param context - Context to supply to synthetic Actor instantiation.
+     */
+    apply(context: unknown): Actor.ConfiguredInstance;
+
+    /** @remarks `"The synthetic actor prepares its items in the appropriate context of an actor. The actor delta does not need to prepare its items, and would do so in the incorrect context."` */
+    override prepareEmbeddedDocuments(): void;
+
+    override updateSource(
+      changes?: SchemaField.InnerAssignmentType<BaseActor.Schema>,
+      options?: { dryRun?: boolean; fallback?: boolean; recursive?: boolean },
+    ): object;
+
+    override reset(): void;
+
+    /**
+     * Generate a synthetic Actor instance when constructed, or when the represented Actor, or actorLink status changes.
+     */
+    protected _createSyntheticActor(options?: {
+      /**
+       * Whether to fully re-initialize this ActorDelta's collections in
+       * order to re-retrieve embedded Documents from the synthetic
+       * Actor.
+       */
+      reinitializeCollections: boolean;
+    }): void;
+
+    /**
+     * Update the synthetic Actor instance with changes from the delta or the base Actor.
+     */
+    updateSyntheticActor(): void;
+
+    /**
+     * Restore this delta to empty, inheriting all its properties from the base actor.
+     * @returns The restored synthetic Actor.
+     */
+    restore(): Promise<Actor.ConfiguredInstance>;
+
+    /**
+     * Ensure that the embedded collection delta is managing any entries that have had their descendants updated.
+     * @param doc - The parent whose immediate children have been modified.
+     */
+    _handleDeltaCollectionUpdates(doc: Document.Any): void;
+
+    /**
+     * @privateRemarks _onUpdate 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.
+     */
+
+    protected override _dispatchDescendantDocumentEvents(
+      event: ClientDocument.LifeCycleEventName,
+      collection: string,
+      args: unknown[],
+      _parent: ClientDocument,
+    ): void;
+  }
+}

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

@@ -0,0 +1,301 @@
+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 { SchemaField } from "../../../common/data/fields.d.mts";
+import type { BaseActor } from "../../../common/documents/_module.d.mts";
+
+declare global {
+  namespace Actor {
+    type ConfiguredClass = Document.ConfiguredClassForName<"Actor">;
+    type ConfiguredInstance = Document.ConfiguredInstanceForName<"Actor">;
+
+    interface DatabaseOperations extends DocumentDatabaseOperations<Actor> {}
+
+    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) {
+    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 | SchemaField.InnerAssignmentType<BaseActor.Schema>,
+      options?: unknown,
+    ): SchemaField.InnerPersistedType<BaseActor.Schema>;
+
+    /**
+     * 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(): {
+      [K in foundry.documents.BaseItem["type"]]: Array<
+        Item.ConfiguredInstance & {
+          type: K;
+          // TODO: It's the "extends cannot be used to replicate in problem" again
+          // system: "Item" extends keyof DataModelConfig ? DataModelConfig["Item"][K] : never;
+        }
+      >;
+    };
+    /**
+     * 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,94 @@
+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";
+
+declare global {
+  namespace Adventure {
+    type ConfiguredClass = Document.ConfiguredClassForName<"Adventure">;
+    type ConfiguredInstance = Document.ConfiguredInstanceForName<"Adventure">;
+
+    interface DatabaseOperations extends DocumentDatabaseOperations<Adventure> {}
+
+    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 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,32 @@
+import type Document from "../../../common/abstract/document.d.mts";
+import type { DocumentDatabaseOperations } from "../../../common/abstract/document.d.mts";
+
+declare global {
+  namespace 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 */
+  }
+
+  /**
+   * 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) {
+    /**
+     * @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,19 @@
+import type Document from "../../../common/abstract/document.d.mts";
+import type { DocumentDatabaseOperations } from "../../../common/abstract/document.d.mts";
+
+declare global {
+  namespace AmbientSoundDocument {
+    type ConfiguredClass = Document.ConfiguredClassForName<"AmbientSound">;
+    type ConfiguredInstance = Document.ConfiguredInstanceForName<"AmbientSound">;
+
+    interface DatabaseOperations extends DocumentDatabaseOperations<AmbientSoundDocument> {}
+  }
+
+  /**
+   * 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) {}
+}

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

@@ -0,0 +1,115 @@
+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";
+
+declare global {
+  namespace Card {
+    type ConfiguredClass = Document.ConfiguredClassForName<"Card">;
+    type ConfiguredInstance = Document.ConfiguredInstanceForName<"Card">;
+
+    interface DatabaseOperations extends DocumentDatabaseOperations<Card> {}
+  }
+
+  /**
+   * 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) {
+    /**
+     * 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>;
+  }
+}