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

package/src/foundry/client/apps/forms/actor.d.mts

@@ -0,0 +1,176 @@
+import type { GetDataReturnType, MaybePromise } from "../../../../types/utils.d.mts";
+import type { DropData as ClientDocumentMixinDropData } from "../../data/abstract/client-document.d.mts";
+
+declare global {
+  /**
+   * The Application responsible for displaying and editing a single Actor document.
+   * This Application is responsible for rendering an actor's attributes and allowing the actor to be edited.
+   * @param actor   - The Actor instance being displayed within the sheet.
+   * @param options - Additional application configuration options.
+   *
+   * @typeParam Options - the type of the options object
+   */
+  class ActorSheet<Options extends ActorSheet.Options = ActorSheet.Options> extends DocumentSheet<
+    Options,
+    Actor.ConfiguredInstance
+  > {
+    /**
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   height: 720,
+     *   width: 800,
+     *   template: "templates/sheets/actor-sheet.html",
+     *   closeOnSubmit: false,
+     *   submitOnClose: true,
+     *   submitOnChange: true,
+     *   resizable: true,
+     *   baseApplication: "ActorSheet",
+     *   dragDrop: [{ dragSelector: ".item-list .item", dropSelector: null }],
+     *   token: null,
+     * });
+     * ```
+     */
+    static get defaultOptions(): ActorSheet.Options;
+
+    override get title(): string;
+
+    /**
+     * A convenience reference to the Actor document
+     */
+    get actor(): this["object"];
+
+    /**
+     * If this Actor Sheet represents a synthetic Token actor, reference the active Token
+     */
+    get token(): Exclude<this["object"]["token"] | this["options"]["token"], undefined> | null;
+
+    override close(options?: FormApplication.CloseOptions): Promise<void>;
+
+    override getData(options?: Partial<Options>): MaybePromise<GetDataReturnType<ActorSheet.ActorSheetData>>;
+
+    protected override _getHeaderButtons(): Application.HeaderButton[];
+
+    protected override _getSubmitData(updateData?: object | null): Partial<Record<string, unknown>>;
+
+    /**
+     * Handle requests to configure the Token for the Actor
+     */
+    protected _onConfigureToken(event: JQuery.ClickEvent): void;
+
+    protected override _canDragStart(selector: string): boolean;
+
+    protected override _canDragDrop(selector: string): boolean;
+
+    protected override _onDragStart(event: DragEvent): void;
+
+    protected override _onDrop(event: DragEvent): void;
+
+    /**
+     * Handle the dropping of ActiveEffect data onto an Actor Sheet
+     * @param event - The concluding DragEvent which contains drop data
+     * @param data  - The data transfer extracted from the event
+     * @returns A data object which describes the result of the drop
+     * @remarks This is intentionally typed to return `Promise<unknown>` to
+     * allow overriding methods to return whatever they want. The return type is
+     * not meant to be used aside from being awaited.
+     */
+    protected _onDropActiveEffect(event: DragEvent, data: ActorSheet.DropData.ActiveEffect): Promise<unknown>;
+
+    /**
+     * Handle dropping of an item reference or item data onto an Actor Sheet
+     * @param event - The concluding DragEvent which contains drop data
+     * @param data  - The data transfer extracted from the event
+     * @returns A data object which describes the result of the drop
+     * @remarks This is intentionally typed to return `Promise<unknown>` to
+     * allow overriding methods to return whatever they want. The return type is
+     * not meant to be used aside from being awaited.
+     */
+    protected _onDropActor(event: DragEvent, data: ActorSheet.DropData.Actor): Promise<unknown>;
+
+    /**
+     * Handle dropping of an item reference or item data onto an Actor Sheet
+     * @param event - The concluding DragEvent which contains drop data
+     * @param data  - The data transfer extracted from the event
+     * @remarks This is intentionally typed to return `Promise<unknown>` to
+     * allow overriding methods to return whatever they want. The return type is
+     * not meant to be used aside from being awaited.
+     */
+    protected _onDropItem(event: DragEvent, data: ActorSheet.DropData.Item): Promise<unknown>;
+
+    /**
+     * Handle dropping of a Folder on an Actor Sheet.
+     * Currently supports dropping a Folder of Items to create all items as owned items.
+     * @param event - The concluding DragEvent which contains drop data
+     * @param data  - The data transfer extracted from the event
+     * @remarks This is intentionally typed to return `Promise<unknown>` to
+     * allow overriding methods to return whatever they want. The return type is
+     * not meant to be used aside from being awaited.
+     */
+    protected _onDropFolder(event: DragEvent, data: ActorSheet.DropData.Folder): Promise<unknown>;
+
+    /**
+     * Handle the final creation of dropped Item data on the Actor.
+     * This method is factored out to allow downstream classes the opportunity to override item creation behavior.
+     * @param itemData - The item data requested for creation
+     */
+    protected _onDropItemCreate(itemData: Item["_source"][] | Item["_source"]): Promise<Item.ConfiguredInstance[]>;
+
+    /**
+     * Handle a drop event for an existing embedded Item to sort that Item relative to its siblings
+     */
+    protected _onSortItem(event: DragEvent, itemData: Item["_source"]): undefined | Promise<Item.ConfiguredInstance[]>;
+
+    /**
+     * Is the drop data coming from the same actor?
+     * @param data - The drop data.
+     * @internal
+     */
+    protected _isFromSameActor(data: ActorSheet.DropData.Item): Promise<boolean>;
+  }
+
+  namespace ActorSheet {
+    type Any = ActorSheet<any>;
+
+    type DropData =
+      | DropData.ActiveEffect
+      | DropData.Actor
+      | DropData.Item
+      | DropData.Folder
+      | (Partial<Record<string, unknown>> & { type: string });
+
+    namespace DropData {
+      interface ActiveEffect {
+        type: "ActiveEffect";
+        tokenId?: string;
+        actorId?: string;
+        data: foundry.documents.BaseActiveEffect["_source"];
+      }
+
+      interface Actor {
+        type: "Actor";
+      }
+
+      type Item = ClientDocumentMixinDropData<Item.ConfiguredInstance> & {
+        type: "Item";
+      };
+
+      interface Folder {
+        type: "Folder";
+        documentName: foundry.CONST.FOLDER_DOCUMENT_TYPES;
+        id: string;
+      }
+    }
+
+    interface Options extends DocumentSheetOptions<Actor> {
+      token?: TokenDocument.ConfiguredInstance | null;
+    }
+
+    interface ActorSheetData<Options extends ActorSheet.Options = ActorSheet.Options>
+      extends DocumentSheet.DocumentSheetData<Options, Actor.ConfiguredInstance> {
+      actor: ActorSheet["actor"];
+      items: this["data"]["items"];
+      effects: this["data"]["effects"];
+    }
+  }
+}

package/src/foundry/client/apps/forms/adventure-exporter.d.mts

@@ -0,0 +1,132 @@
+import type { EditorView } from "prosemirror-view";
+import type { Editor } from "tinymce";
+import type { GetDataReturnType } from "../../../../types/utils.d.mts";
+
+declare global {
+  /**
+   * An interface for packaging Adventure content and loading it to a compendium pack.
+   */
+  class AdventureExporter<Options extends AdventureExporter.Options = AdventureExporter.Options> extends DocumentSheet<
+    Options,
+    Adventure.ConfiguredInstance
+  > {
+    constructor(object?: Adventure.ConfiguredInstance & { pack: string }, options?: Partial<Options>);
+
+    /**
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   template: "templates/adventure/exporter.html",
+     *   id: "adventure-exporter",
+     *   classes: ["sheet", "adventure", "adventure-exporter"],
+     *   width: 560,
+     *   height: "auto",
+     *   tabs: [{navSelector: ".tabs", contentSelector: "form", initial: "summary"}],
+     *   dragDrop: [{ dropSelector: "form" }],
+     *   scrollY: [".tab.contents"],
+     *   submitOnClose: false,
+     *   closeOnSubmit: true
+     * });
+     * ```
+     */
+    static override get defaultOptions(): AdventureExporter.Options;
+
+    /**
+     * An alias for the Adventure document
+     */
+    adventure: this["object"];
+
+    contentTree: Record<string, AdventureExporter.AdventureContentTreeRoot>;
+
+    override get isEditable(): boolean;
+
+    override getData(options?: Partial<Options>): Promise<GetDataReturnType<AdventureExporter.AdventureExporterData>>;
+
+    override activateEditor(
+      name: string,
+      options?: TextEditor.Options,
+      initialContent?: string,
+    ): Promise<Editor | EditorView>;
+
+    protected override _getHeaderButtons(): Application.HeaderButton[];
+
+    override close(options?: FormApplication.CloseOptions): Promise<void>;
+
+    override activateListeners(html: JQuery<HTMLElement>): void;
+
+    protected override _updateObject(event: Event, adventureData: object): Promise<unknown>;
+
+    protected override _onDrop(event: DragEvent): void;
+
+    /**
+     * Stage a document for addition to the Adventure.
+     * This adds the document locally, the change is not yet submitted to the database.
+     * @param document - Some document to be added to the Adventure.
+     */
+    addContent(document: ClientDocument): void;
+
+    /**
+     * Remove a single Document from the Adventure.
+     * @param document - The Document being removed from the Adventure.
+     */
+    removeContent(document: ClientDocument): void;
+  }
+
+  namespace AdventureExporter {
+    type Any = AdventureExporter<any>;
+
+    interface Options extends DocumentSheetOptions<Adventure.ConfiguredInstance> {}
+
+    interface AdventureContentTreeNode {
+      /** An alias for folder.id */
+      id: string | null;
+
+      /** An alias for folder.name */
+      name: string;
+
+      /** The Folder at this node level */
+      folder: Folder;
+
+      /** The modification state of the Folder */
+      state: string;
+
+      /** An array of child nodes */
+      children: AdventureContentTreeNode[];
+
+      /** An array of documents */
+      documents: { id: string; name: string; document: ClientDocument; state: string }[];
+    }
+
+    interface AdventureContentTreeRoot extends AdventureContentTreeNode {
+      /** The folder ID is null at the root level */
+      id: null;
+
+      /** The Document name contained in this tree */
+      documentName: string;
+
+      /** The Document collection name of this tree */
+      collection: string;
+
+      /** The name displayed at the root level of the tree */
+      name: string;
+
+      /** The icon displayed at the root level of the tree */
+      icon: string;
+
+      /** The icon which represents the current collapsed state of the tree */
+      collapseIcon: string;
+
+      /** CSS classes which describe the display of the tree */
+      cssClass: string;
+
+      /** The number of documents which are present in the tree */
+      documentCount: number;
+    }
+
+    interface AdventureExporterData {
+      adventure: Adventure.ConfiguredInstance;
+
+      contentTree: AdventureExporter["contentTree"];
+    }
+  }
+}

package/src/foundry/client/apps/forms/adventure-importer.d.mts

@@ -0,0 +1,85 @@
+import type { GetDataReturnType } from "../../../../types/utils.d.mts";
+
+declare global {
+  /**
+   * An interface for importing an adventure from a compendium pack.
+   */
+  class AdventureImporter<Options extends AdventureImporter.Options = AdventureImporter.Options> extends DocumentSheet<
+    Options,
+    Adventure.ConfiguredInstance
+  > {
+    /**
+     * An alias for the Adventure document
+     */
+    adventure: this["object"];
+
+    override get isEditable(): boolean;
+
+    /**
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   template: "templates/adventure/importer.html",
+     *   id: "adventure-importer",
+     *   classes: ["sheet", "adventure", "adventure-importer"],
+     *   width: 800,
+     *   height: "auto",
+     *   submitOnClose: false,
+     *   closeOnSubmit: true
+     * });
+     * ```
+     */
+    static override get defaultOptions(): AdventureImporter.Options;
+
+    override getData(options?: Partial<Options>): Promise<GetDataReturnType<AdventureImporter.AdventureImporterData>>;
+
+    override activateListeners(html: JQuery<HTMLElement>): void;
+
+    /**
+     * Handle toggling the import all checkbox.
+     * @param event - The change event
+     */
+    protected _onToggleImportAll(event: Event): void;
+
+    /**
+     * Prepare a list of content types provided by this adventure.
+     */
+    protected _getContentList(): { icon: string; label: string; count: number }[];
+
+    protected override _getHeaderButtons(): Application.HeaderButton[];
+
+    protected override _updateObject(event: Event, formData: object): Promise<void | ReturnType<Adventure["import"]>>;
+
+    /**
+     * Mirror Adventure#import but call AdventureImporter#_importContent and AdventureImport#_prepareImportData
+     * @deprecated since v11, will be removed in v13
+     */
+    _importLegacy(formData: object): Promise<void>;
+
+    /**
+     * @deprecated since v11, will be removed in v13
+     * @remarks `"AdventureImporter#_prepareImportData is deprecated. Please use Adventure#prepareImport instead."`
+     */
+    _prepareImportData(formData: object): Promise<void>;
+
+    /**
+     * @deprecated since v11, will be removed in v13
+     * @remarks `"AdventureImporter#_importContent is deprecated. Please use Adventure#importContent instead."`
+     */
+    _importContent(formData: object): Promise<void>;
+  }
+
+  namespace AdventureImporter {
+    type Any = AdventureImporter<any>;
+
+    interface Options extends DocumentSheetOptions<Adventure.ConfiguredInstance> {}
+
+    interface AdventureImporterData {
+      adventure: Adventure.ConfiguredInstance;
+
+      contents: ReturnType<AdventureImporter["_getContentList"]>;
+
+      imported: boolean;
+    }
+  }
+}

package/src/foundry/client/apps/forms/base-sheet.d.mts

@@ -0,0 +1,45 @@
+import type { EditorView } from "prosemirror-view";
+import type { Editor } from "tinymce";
+import type { GetDataReturnType } from "../../../../types/utils.d.mts";
+
+declare global {
+  class BaseSheet<Options extends BaseSheet.Options = BaseSheet.Options> extends DocumentSheet<
+    Options,
+    foundry.abstract.Document.Any
+  > {
+    /**
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   template: "templates/sheets/base-sheet.html",
+     *   classes: ["sheet", "base-sheet"],
+     *   width: 450,
+     *   height: "auto",
+     *   resizable: true,
+     *   submitOnChange: true,
+     *   closeOnSubmit: false
+     * });
+     * ```
+     */
+    static override get defaultOptions(): BaseSheet.Options;
+
+    override getData(): Promise<GetDataReturnType<BaseSheet.BaseSheetData>>;
+
+    protected _render(force?: boolean, options?: Application.RenderOptions<Options>): Promise<void>;
+
+    activateEditor(name: string, options?: TextEditor.Options, initialContent?: string): Promise<Editor | EditorView>;
+  }
+
+  namespace BaseSheet {
+    type Any = BaseSheet<any>;
+
+    interface Options extends DocumentSheetOptions<Adventure.ConfiguredInstance> {}
+
+    interface BaseSheetData extends DocumentSheet.DocumentSheetData<Options, foundry.abstract.Document.Any> {
+      hasName: boolean;
+      hasImage: boolean;
+      hasDescription: boolean;
+      desriptionHTML?: string;
+    }
+  }
+}

package/src/foundry/client/apps/forms/card-config.d.mts

@@ -0,0 +1,48 @@
+import type { GetDataReturnType, MaybePromise } from "../../../../types/utils.d.mts";
+
+declare global {
+  /**
+   * A DocumentSheet application responsible for displaying and editing a single embedded Card document.
+   *
+   * @typeParam Options - The type of the options object
+   */
+  class CardConfig<Options extends DocumentSheetOptions<Card> = DocumentSheetOptions<Card>> extends DocumentSheet<
+    Options,
+    Card.ConfiguredInstance
+  > {
+    /**
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   classes: ["sheet", "card-config"],
+     *   template: "templates/cards/card-config.html",
+     *   width: 480,
+     *   height: "auto",
+     *   tabs: [{navSelector: ".tabs", contentSelector: "form", initial: "details"}]
+     * })
+     * ```
+     */
+    static override get defaultOptions(): DocumentSheetOptions<Card>;
+
+    override getData(options?: Partial<Options>): MaybePromise<GetDataReturnType<CardConfig.CardConfigData>>;
+
+    override activateListeners(html: JQuery): void;
+
+    /**
+     * Handle card face control actions which modify single cards on the sheet.
+     * @param event - The originating click event
+     * @returns A Promise which resolves once the handler has completed
+     */
+    protected _onFaceControl(event: JQuery.ClickEvent): Promise<unknown>;
+  }
+
+  namespace CardConfig {
+    type Any = CardConfig<any>;
+
+    interface CardConfigData<Options extends DocumentSheetOptions<Card> = DocumentSheetOptions<Card>>
+      extends DocumentSheet.DocumentSheetData<Options, Card.ConfiguredInstance> {
+      //TODO: Find if we can better type this
+      types: Record<string, string>;
+    }
+  }
+}

package/src/foundry/client/apps/forms/cards-config.d.mts

@@ -0,0 +1,141 @@
+import type { ConfiguredDocumentClassForName } from "../../../../types/helperTypes.d.mts";
+import type { GetDataReturnType, MaybePromise } from "../../../../types/utils.d.mts";
+
+declare global {
+  /**
+   * A DocumentSheet application responsible for displaying and editing a single Cards stack.
+   *
+   * @typeParam Options - The type of the options object
+   */
+  class CardsConfig<Options extends CardsConfig.Options = CardsConfig.Options> extends DocumentSheet<
+    Options,
+    Cards.ConfiguredInstance
+  > {
+    constructor(object: ConfiguredDocumentClassForName<"Cards">, options: Options);
+
+    /**
+     * The allowed sorting methods which can be used for this sheet
+     */
+    static SORT_TYPES: {
+      STANDARD: "standard";
+      SHUFFLED: "shuffled";
+    };
+
+    /**
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   classes: ["sheet", "cards-config"],
+     *   template: "templates/cards/cards-deck.html",
+     *   width: 620,
+     *   height: "auto",
+     *   closeOnSubmit: false,
+     *   viewPermission: CONST.DOCUMENT_OWNERSHIP_LEVELS.OBSERVER,
+     *   dragDrop: [{dragSelector: "ol.cards li.card", dropSelector: "ol.cards"}],
+     *   tabs: [{navSelector: ".tabs", contentSelector: "form", initial: "cards"}],
+     *   scrollY: ["ol.cards"],
+     *   sort: this.SORT_TYPES.SHUFFLED
+     * })
+     * ```
+     */
+    static override get defaultOptions(): CardsConfig.Options;
+
+    override getData(options?: Partial<Options>): MaybePromise<GetDataReturnType<CardsConfig.CardsConfigData>>;
+
+    override activateListeners(html: JQuery): void;
+
+    /**
+     * Handle card control actions which modify single cards on the sheet.
+     * @param event - The originating click event
+     * @returns A Promise which resolves once the handler has completed
+     */
+    protected _onCardControl(event: JQuery.ClickEvent): Promise<void>;
+
+    /**
+     * Handle lazy-loading card face images.
+     * See {@link SidebarTab#_onLazyLoadImage}
+     * @param entries  - The entries which are now in the observer frame
+     * @param observer - The intersection observer instance
+     */
+    protected _onLazyLoadImage(entries: IntersectionObserverEntry[], observer: IntersectionObserver): void;
+
+    protected override _canDragStart(selector: string): boolean;
+
+    protected override _onDragStart(event: DragEvent): void;
+
+    protected override _canDragDrop(selector: string): boolean;
+
+    protected override _onDrop(event: DragEvent): Promise<void>;
+
+    /**
+     * Handle sorting a Card relative to other siblings within this document
+     * @param event - The drag drop event
+     * @param card  - The card being dragged
+     * @internal
+     */
+    protected _onSortCard(
+      event: DragEvent,
+      card: Card.ConfiguredInstance,
+    ): ReturnType<Cards.ConfiguredInstance["updateEmbeddedDocuments"]>;
+  }
+
+  namespace CardsConfig {
+    type Any = CardsConfig<any>;
+  }
+
+  /**
+   * A subclass of CardsConfig which provides a sheet representation for Cards documents with the "hand" type.
+   *
+   * @typeParam Options - The type of the options object
+   */
+  class CardsHand<Options extends CardsConfig.Options = CardsConfig.Options> extends CardsConfig<Options> {
+    /**
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   template: "templates/cards/cards-hand.html"
+     * })
+     * ```
+     */
+    static override get defaultOptions(): CardsConfig.Options;
+  }
+
+  namespace CardsHand {
+    type Any = CardsHand<any>;
+  }
+
+  /**
+   * A subclass of CardsConfig which provides a sheet representation for Cards documents with the "pile" type.
+   *
+   * @typeParam Options - The type of the options object
+   */
+  class CardsPile<Options extends CardsConfig.Options = CardsConfig.Options> extends CardsConfig<Options> {
+    /**
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   template: "templates/cards/cards-pile.html"
+     * })
+     * ```
+     */
+    static override get defaultOptions(): CardsConfig.Options;
+  }
+
+  namespace CardsPile {
+    type Any = CardsPile<any>;
+  }
+
+  namespace CardsConfig {
+    interface Options extends DocumentSheetOptions<Cards> {
+      sort: string;
+    }
+
+    interface CardsConfigData<Options extends CardsConfig.Options = CardsConfig.Options>
+      extends DocumentSheet.DocumentSheetData<Options, Cards.ConfiguredInstance> {
+      cards: Card.ConfiguredInstance[];
+      //TODO: Find if we can better type this
+      types: Record<string, string>;
+      inCompendium: boolean;
+    }
+  }
+}

package/src/foundry/client/apps/forms/combat-config.d.mts

@@ -0,0 +1,51 @@
+import type { GetDataReturnType, MaybePromise } from "../../../../types/utils.d.mts";
+
+declare global {
+  /**
+   * The Application responsible for configuring the CombatTracker and its contents.
+   * @typeParam Options - The type of the options object
+   */
+  class CombatTrackerConfig<Options extends FormApplicationOptions = FormApplicationOptions> extends FormApplication<
+    Options,
+    undefined
+  > {
+    /**
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   id: "combat-config",
+     *   title: game.i18n.localize("COMBAT.Settings"),
+     *   classes: ["sheet", "combat-sheet"],
+     *   template: "templates/sheets/combat-config.html",
+     *   width: 420,
+     * })
+     * ```
+     */
+    static override get defaultOptions(): FormApplicationOptions;
+
+    override getData(
+      options?: Partial<Options>,
+    ): MaybePromise<GetDataReturnType<CombatTrackerConfig.CombatTrackerConfigData>>;
+
+    protected override _updateObject(
+      event: Event,
+      formData: SettingConfig["core.combatTrackerConfig"],
+    ): Promise<unknown>;
+
+    override activateListeners(html: JQuery<HTMLElement>): void;
+
+    protected override _onChangeInput(event: JQuery.ChangeEvent<any, any, any, any>): Promise<void | object>;
+  }
+
+  namespace CombatTrackerConfig {
+    type Any = CombatTrackerConfig<any>;
+
+    interface CombatTrackerConfigData extends FormApplication.FormApplicationData {
+      settings: SettingConfig["core.combatTrackerConfig"];
+      attributeChoices: ReturnType<(typeof TokenDocument)["getTrackedAttributeChoices"]>;
+      combatTheme: SettingOptions<string>;
+      selectedTheme: SettingConfig["core.combatTheme"];
+      user: User;
+    }
+  }
+}