@league-of-foundry-developers/foundry-vtt-types 13.340.0 → 13.345.1-beta.20250704.94554

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

@@ -1,318 +0,0 @@
-import type { DeepPartial, InexactPartial } from "fvtt-types/utils";
-import type Document 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 Document.Database.Operations<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;
-
-    static get implementation(): Actor.ConfiguredClass;
-
-    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

@@ -1,106 +0,0 @@
-import type { FolderDocumentTypes, InexactPartial, FixedInstanceType } from "fvtt-types/utils";
-import type DataModel from "../../../common/abstract/data.d.mts";
-import type { fields } from "../../../common/data/_module.d.mts";
-import type Document from "../../../common/abstract/document.d.mts";
-import type BaseAdventure from "../../../common/documents/adventure.d.mts";
-
-type DataSchema = foundry.data.fields.DataSchema;
-
-declare global {
-  namespace Adventure {
-    type Metadata = Document.MetadataFor<Adventure>;
-
-    type ConfiguredClass = Document.ConfiguredClassForName<"Adventure">;
-    type ConfiguredInstance = Document.ConfiguredInstanceForName<"Adventure">;
-
-    interface DatabaseOperations extends Document.Database.Operations<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 get implementation(): Adventure.ConfiguredClass;
-
-    static fromSource<Schema extends DataSchema>(
-      source: fields.SchemaField.InnerAssignmentType<Schema>,
-      {
-        strict,
-        ...context
-      }?: DataModel.DataValidationOptions & {
-        /**
-         * 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]?: FixedInstanceType<Document.ConfiguredClassForName<K>>[];
-};
-
-type AdventureDocumentTypes = Exclude<FolderDocumentTypes, "Adventure"> | "Folder";

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

@@ -1,44 +0,0 @@
-import type Document 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 Document.Database.Operations<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;
-
-    static get implementation(): AmbientLightDocument.ConfiguredClass;
-
-    /**
-     * @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

@@ -1,31 +0,0 @@
-import type Document 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 Document.Database.Operations<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;
-
-    static get implementation(): AmbientSoundDocument.ConfiguredClass;
-  }
-}

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

@@ -1,128 +0,0 @@
-import type { DeepPartial, InexactPartial } from "fvtt-types/utils";
-import type Document 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 Document.Database.Operations<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;
-
-    static get implementation(): Card.ConfiguredClass;
-
-    /**
-     * 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>;
-  }
-}