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

package/src/foundry/client/applications/apps/grid-config.d.mts

@@ -0,0 +1,51 @@
+import type HandlebarsApplicationMixin from "../api/handlebars-application.d.mts";
+import type DocumentSheetV2 from "../api/document-sheet.d.mts";
+import type { Identity } from "#utils";
+
+declare module "#configuration" {
+  namespace Hooks {
+    interface ApplicationV2Config {
+      GridConfig: GridConfig.Any;
+    }
+  }
+}
+
+/**
+ * A tool for fine-tuning the grid in a Scene
+ * @remarks TODO: Stub
+ */
+declare class GridConfig<
+  RenderContext extends GridConfig.RenderContext = GridConfig.RenderContext,
+  Configuration extends GridConfig.Configuration = GridConfig.Configuration,
+  RenderOptions extends GridConfig.RenderOptions = GridConfig.RenderOptions,
+> extends HandlebarsApplicationMixin(DocumentSheetV2)<
+  Scene.Implementation,
+  RenderContext,
+  Configuration,
+  RenderOptions
+> {}
+
+declare namespace GridConfig {
+  interface Any extends AnyGridConfig {}
+  interface AnyConstructor extends Identity<typeof AnyGridConfig> {}
+
+  interface RenderContext
+    extends HandlebarsApplicationMixin.RenderContext,
+      DocumentSheetV2.RenderContext<Scene.Implementation> {}
+
+  interface Configuration
+    extends HandlebarsApplicationMixin.Configuration,
+      DocumentSheetV2.Configuration<Scene.Implementation> {}
+
+  interface RenderOptions extends HandlebarsApplicationMixin.RenderOptions, DocumentSheetV2.RenderOptions {}
+}
+
+declare abstract class AnyGridConfig extends GridConfig<
+  GridConfig.RenderContext,
+  GridConfig.Configuration,
+  GridConfig.RenderOptions
+> {
+  constructor(...args: never);
+}
+
+export default GridConfig;

package/src/foundry/client/applications/apps/image-popout.d.mts

@@ -0,0 +1,111 @@
+import type { DeepPartial, Identity } from "#utils";
+import type ApplicationV2 from "../api/application.d.mts";
+import type HandlebarsApplicationMixin from "../api/handlebars-application.d.mts";
+
+declare module "#configuration" {
+  namespace Hooks {
+    interface ApplicationV2Config {
+      ImagePopout: ImagePopout.Any;
+    }
+  }
+}
+
+/**
+ * An Image Popout Application which features a single image in a lightbox style frame.
+ * Furthermore, this application allows for sharing the display of an image with other connected players.
+ *
+ * @example Creating an Image Popout
+ * ```js
+ * // Construct the Application instance
+ * const ip = new ImagePopout({
+ *   src: "path/to/image.jpg",
+ *   uuid: game.actors.getName("My Hero").uuid
+ *   window: {title: "My Featured Image"}
+ * });
+ *
+ * // Display the image popout
+ * ip.render(true);
+ *
+ * // Share the image with other connected players
+ * ip.shareImage();
+ * ```
+ * @remarks TODO: Stub
+ */
+declare class ImagePopout<
+  RenderContext extends ImagePopout.RenderContext = ImagePopout.RenderContext,
+  Configuration extends ImagePopout.Configuration = ImagePopout.Configuration,
+  RenderOptions extends ImagePopout.RenderOptions = ImagePopout.RenderOptions,
+> extends HandlebarsApplicationMixin(ApplicationV2)<RenderContext, Configuration, RenderOptions> {
+  constructor(options: DeepPartial<Configuration> & { src: string });
+}
+
+declare namespace ImagePopout {
+  interface Any extends AnyImagePopout {}
+  interface AnyConstructor extends Identity<typeof AnyImagePopout> {}
+
+  /**
+   * @remarks Foundry's override of `_prepareContext` does not call `super`. Therefore it does not
+   * inherit context from its parent class.
+   */
+  interface RenderContext {
+    caption: string | undefined;
+    image: string;
+    isVideo: boolean;
+    title: string;
+    altText: string;
+  }
+
+  interface Configuration extends HandlebarsApplicationMixin.Configuration, ApplicationV2.Configuration {
+    /** The URL to the image or video file */
+    src: string;
+
+    /** Caption text to display below the image. */
+    caption: string;
+
+    /**
+     * The UUID of some related {@link foundry.abstract.Document|`Document`}.
+     * @defaultValue `null`
+     */
+    uuid: string | null | undefined;
+
+    /** Force showing or hiding the title */
+    showTitle?: boolean | null | undefined;
+  }
+
+  interface RenderOptions extends HandlebarsApplicationMixin.RenderOptions, ApplicationV2.RenderOptions {}
+
+  interface ShareImageConfig {
+    /**
+     * The image URL to share.
+     */
+    image: string;
+
+    /**
+     * The image title.
+     */
+    title: string;
+
+    /**
+     * The UUID of a {@linkcode foundry.abstract.Document} related to the image, used to determine permission to see the image title.
+     */
+    uuid?: string | undefined;
+
+    /**
+     * If this is provided, the permissions of the related Document will be ignored and the title will be shown based on this parameter.
+     */
+    showTitle?: string | undefined;
+
+    /**
+     * A list of user IDs to show the image to.
+     */
+    users?: string[] | undefined;
+  }
+}
+
+declare abstract class AnyImagePopout extends ImagePopout<
+  ImagePopout.RenderContext,
+  ImagePopout.Configuration,
+  ImagePopout.RenderOptions
+> {}
+
+export default ImagePopout;

package/src/foundry/client/applications/apps/permission-config.d.mts

@@ -0,0 +1,79 @@
+import type { InterfaceToObject, MustConform, DeepPartial, Identity } from "#utils";
+import type { UserPermission } from "#common/constants.d.mts";
+import type { CONST } from "../../client.d.mts";
+import type ApplicationV2 from "../api/application.d.mts";
+import type HandlebarsApplicationMixin from "../api/handlebars-application.d.mts";
+
+declare module "#configuration" {
+  namespace Hooks {
+    interface ApplicationV2Config {
+      PermissionConfig: PermissionConfig.Any;
+    }
+  }
+}
+
+/**
+ * An application for configuring the permissions which are available to each User role.
+ */
+declare class PermissionConfig<
+  RenderContext extends PermissionConfig.RenderContext = PermissionConfig.RenderContext,
+  Configuration extends PermissionConfig.Configuration = PermissionConfig.Configuration,
+  RenderOptions extends PermissionConfig.RenderOptions = PermissionConfig.RenderOptions,
+> extends HandlebarsApplicationMixin(ApplicationV2)<RenderContext, Configuration, RenderOptions> {
+  // placeholder private member to help subclassing
+  #permissionConfig: true;
+
+  static override DEFAULT_OPTIONS: Partial<ApplicationV2.Configuration>;
+  static override PARTS: InterfaceToObject<PermissionConfig.Parts>;
+
+  /* -------------------------------------------- */
+  /*  Rendering                                   */
+  /* -------------------------------------------- */
+
+  override _prepareContext(options: DeepPartial<RenderOptions>): Promise<RenderContext>;
+}
+
+declare namespace PermissionConfig {
+  interface Any extends AnyPermissionConfig {}
+  interface AnyConstructor extends Identity<typeof AnyPermissionConfig> {}
+
+  interface PermissionWithRoles extends UserPermission {
+    id: string;
+    roles: {
+      name: string;
+      value: boolean;
+      readonly: string;
+    }[];
+  }
+
+  /**
+   * @remarks Foundry's override of `_prepareContext` does not call `super`. Therefore it does not
+   * inherit context from its parent class.
+   */
+  interface RenderContext {
+    roles: Record<CONST.USER_ROLES, string>;
+    permissions: PermissionWithRoles[];
+    buttons: ApplicationV2.FormFooterButton[];
+  }
+
+  interface Configuration extends HandlebarsApplicationMixin.Configuration, ApplicationV2.Configuration {}
+  interface RenderOptions extends HandlebarsApplicationMixin.RenderOptions, ApplicationV2.RenderOptions {}
+
+  interface Parts {
+    permissions: HandlebarsApplicationMixin.HandlebarsTemplatePart;
+    footer: HandlebarsApplicationMixin.HandlebarsTemplatePart;
+  }
+}
+
+declare abstract class AnyPermissionConfig extends PermissionConfig<
+  PermissionConfig.RenderContext,
+  PermissionConfig.Configuration,
+  PermissionConfig.RenderOptions
+> {}
+
+type _PartsMustBeValid = MustConform<
+  InterfaceToObject<PermissionConfig.Parts>,
+  Record<string, HandlebarsApplicationMixin.HandlebarsTemplatePart>
+>;
+
+export default PermissionConfig;

package/src/foundry/client/applications/dice/roll-resolver.d.mts

@@ -0,0 +1,125 @@
+import type { DeepPartial, EmptyObject, Identity, InexactPartial } from "#utils";
+import type ApplicationV2 from "../api/application.d.mts";
+import type HandlebarsApplicationMixin from "../api/handlebars-application.d.mts";
+
+declare module "#configuration" {
+  namespace Hooks {
+    interface ApplicationV2Config {
+      RollResolver: RollResolver.Any;
+    }
+  }
+}
+
+/**
+ * An application responsible for handling unfulfilled dice terms in a roll.
+ */
+declare class RollResolver<
+  RenderContext extends RollResolver.RenderContext = EmptyObject,
+  Configuration extends RollResolver.Configuration = RollResolver.Configuration,
+  RenderOptions extends RollResolver.RenderOptions = RollResolver.RenderOptions,
+> extends HandlebarsApplicationMixin(ApplicationV2)<RenderContext, Configuration, RenderOptions> {
+  constructor(roll: Roll, options?: DeepPartial<Configuration>);
+
+  // a placeholder private method to help subclassing
+  #rollResolver: true;
+
+  /**
+   * A collection of fulfillable dice terms.
+   */
+  get fulfillable(): Map<string, RollResolver.DiceTermFulfillmentDescriptor>;
+
+  /**
+   * The roll being resolved.
+   */
+  get roll(): Roll;
+  #roll: Roll;
+
+  /**
+   * Identify any terms in this Roll that should be fulfilled externally, and prompt the user to do so.
+   * @returns Returns a Promise that resolves when the first pass of fulfillment is complete.
+   */
+  awaitFulfillment(): Promise<void>;
+
+  /**
+   * Register a fulfilled die roll.
+   * @param method        - The method used for fulfillment.
+   * @param denomination  - The denomination of the fulfilled die.
+   * @param result        - The rolled number.
+   * @returns               Whether the result was consumed.
+   */
+  registerResult(method: string, denomination: string, result: number): boolean;
+
+  /**
+   * Handle prompting for a single extra result from a term.
+   * @param term                - The term.
+   * @param method              - The method used to obtain the result.
+   * @returns
+   */
+  resolveResult(
+    term: foundry.dice.terms.DiceTerm,
+    method: string,
+    options?: InexactPartial<{
+      /** @defaultValue `false` */
+      reroll: boolean;
+
+      /** @defaultValue `false` */
+      explode: boolean;
+    }>,
+  ): Promise<number | void>;
+
+  /**
+   * Update the Roll instance with the fulfilled results.
+   * @param event     - The originating form submission event.
+   * @param form      - The form element that was submitted.
+   * @param formData  - Processed data for the submitted form.
+   */
+  static _fulfillRoll(
+    event: SubmitEvent,
+    form: HTMLFormElement,
+    formData: foundry.applications.ux.FormDataExtended,
+  ): Promise<void>;
+
+  /**
+   * Add a new term to the resolver.
+   * @param term        - The term.
+   * @returns  A Promise that resolves when the term's results have been externally fulfilled.
+   */
+  addTerm(term: foundry.dice.terms.DiceTerm): Promise<void>;
+
+  /**
+   * Check if all rolls have been fulfilled.
+   */
+  _checkDone(): void;
+
+  /**
+   * Toggle the state of the submit button.
+   * @param enabled  - Whether the button is enabled.
+   */
+  _toggleSubmission(enabled: boolean): void;
+}
+
+declare namespace RollResolver {
+  interface Any extends AnyRollResolver {}
+  interface AnyConstructor extends Identity<typeof AnyRollResolver> {}
+
+  interface RenderContext extends HandlebarsApplicationMixin.RenderContext, ApplicationV2.RenderContext {}
+  interface Configuration extends HandlebarsApplicationMixin.Configuration, ApplicationV2.Configuration {}
+  interface RenderOptions extends HandlebarsApplicationMixin.RenderOptions, ApplicationV2.RenderOptions {}
+
+  interface DiceTermFulfillmentDescriptor {
+    id: string;
+    term: foundry.dice.terms.DiceTerm;
+    method: string;
+    isNew?: boolean | undefined;
+  }
+}
+
+declare abstract class AnyRollResolver extends RollResolver<
+  RollResolver.RenderContext,
+  RollResolver.Configuration,
+  RollResolver.RenderOptions
+> {
+  constructor(...args: never);
+}
+
+export default RollResolver;

package/src/foundry/client/applications/elements/document-tags.d.mts

@@ -0,0 +1,93 @@
+import type { FormInputConfig } from "../forms/fields.d.mts";
+import type AbstractFormInputElement from "./form-element.d.mts";
+
+/**
+ * A custom HTMLElement used to render a set of associated Documents referenced by UUID.
+ */
+declare class HTMLDocumentTagsElement extends AbstractFormInputElement<Record<string, string> | string | string[]> {
+  constructor();
+
+  static override tagName: "document-tags";
+
+  protected _value: Record<string, string>;
+
+  set type(value: string);
+
+  /**
+   * Restrict this element to documents of a particular type.
+   */
+  get type(): string | null;
+
+  /**
+   * Restrict to only allow referencing a single Document instead of an array of documents.
+   */
+  get single(): boolean;
+  set single(value: boolean);
+
+  set max(value: number);
+
+  /**
+   * Allow a maximum number of documents to be tagged to the element.
+   */
+  get max(): number;
+
+  /**
+   * Initialize innerText or an initial value attribute of the element as a serialized JSON array.
+   */
+  protected _initializeTags(): void;
+
+  protected override _buildElements(): (HTMLButtonElement | HTMLDivElement)[];
+
+  protected override _refresh(): void;
+
+  /**
+   * Create an HTML string fragment for a single document tag.
+   * @param uuid     - The document UUID
+   * @param name     - The document name
+   * @param editable - Is the tag editable?
+   *                   (default: `true`)
+   */
+  static renderTag(uuid: string, name: string, editable?: boolean): HTMLDivElement;
+
+  /**
+   * Validate that the tagged document is allowed to be added to this field.
+   * Subclasses may impose more strict validation as to which types of documents are allowed.
+   * @param document - A candidate document or compendium index entry to tag
+   * @throws An error if the candidate document is not allowed
+   */
+  // TODO: Fix once compendium index types are added.
+  _validateDocument(document: foundry.abstract.Document.Any | Record<string, unknown>): void;
+
+  protected override _getValue(): string | string[];
+
+  protected override _setValue(value: string | string[]): void;
+
+  protected override _toggleDisabled(disabled: boolean): void;
+
+  /**
+   * Create a HTMLDocumentTagsElement using provided configuration data.
+   */
+  static create(config: HTMLDocumentTagsElement.DocumentTagsInputConfig): HTMLDocumentTagsElement;
+}
+
+declare namespace HTMLDocumentTagsElement {
+  interface DocumentTagsInputConfig extends FormInputConfig<unknown> {
+    /**
+     * A specific document type in CONST.ALL_DOCUMENT_TYPES
+     */
+    type?: foundry.CONST.ALL_DOCUMENT_TYPES;
+
+    /**
+     * Only allow referencing a single document. In this case the submitted form value will
+     *    be a single UUID string rather than an array
+     */
+    single?: boolean;
+
+    /**
+     * Only allow attaching a maximum number of documents
+     */
+    max?: number;
+  }
+}
+
+export default HTMLDocumentTagsElement;

package/src/foundry/client/applications/elements/file-picker.d.mts

@@ -0,0 +1,63 @@
+import type { FormInputConfig } from "../forms/fields.d.mts";
+import type AbstractFormInputElement from "./form-element.d.mts";
+import type FilePicker from "../apps/file-picker.d.mts";
+
+/**
+ * A custom HTML element responsible for rendering a file input field and associated FilePicker button.
+ */
+declare class HTMLFilePickerElement extends AbstractFormInputElement<string> {
+  constructor();
+
+  static override tagName: "file-picker";
+
+  /**
+   * The file path selected.
+   */
+  input: HTMLInputElement;
+
+  /**
+   * A button to open the file picker interface.
+   */
+  button: HTMLButtonElement;
+
+  /**
+   * A reference to the FilePicker application instance originated by this element.
+   */
+  picker: FilePicker;
+
+  /**
+   * A type of file which can be selected in this field.
+   * @see {@linkcode FilePicker.FILE_TYPES}
+   */
+  get type(): FilePicker.Type;
+  set type(value: FilePicker.Type);
+
+  /**
+   * Prevent uploading new files as part of this element's FilePicker dialog.
+   */
+  get noupload(): boolean;
+  set noupload(value: boolean);
+
+  protected override _buildElements(): (HTMLInputElement | HTMLButtonElement)[];
+
+  protected override _toggleDisabled(disabled: boolean): void;
+
+  protected override _activateListeners(): void;
+
+  protected override _onClick(event: PointerEvent): void;
+
+  /**
+   * Create a HTMLFilePickerElement using provided configuration data.
+   */
+  static create(config: HTMLFilePickerElement.FilePickerInputConfig): HTMLElement;
+}
+
+declare namespace HTMLFilePickerElement {
+  interface FilePickerInputConfig extends FormInputConfig<string> {
+    type?: FilePicker.Type;
+    placeholder?: string;
+    noupload?: boolean;
+  }
+}
+
+export default HTMLFilePickerElement;

package/src/foundry/client/applications/elements/form-element.d.mts

@@ -0,0 +1,108 @@
+/**
+ * An abstract custom HTMLElement designed for use with form inputs.
+ * @remarks Fires input  - An "input" event when the value of the input changes
+ * @remarks Fires change - A "change" event when the value of the element changes
+ */
+export default abstract class AbstractFormInputElement<FormInputValueType> extends HTMLElement {
+  constructor();
+
+  /**
+   * The HTML tag name used by this element.
+   */
+  static tagName: string;
+
+  /**
+   * Declare that this custom element provides form element functionality.
+   */
+  static formAssociated: boolean;
+
+  /**
+   * Attached ElementInternals which provides form handling functionality.
+   */
+  protected _internals: ElementInternals;
+
+  /**
+   * The form this element belongs to.
+   */
+  get form(): HTMLFormElement;
+  set name(value: string);
+
+  /**
+   * The input element name.
+   */
+  get name(): string;
+  set value(value: FormInputValueType);
+
+  /**
+   * The value of the input element.
+   */
+  get value(): FormInputValueType;
+
+  /**
+   * The underlying value of the element.
+   */
+  protected _value: FormInputValueType;
+
+  /**
+   * Return the value of the input element which should be submitted to the form.
+   */
+  protected _getValue(): FormInputValueType;
+
+  /**
+   * Translate user-provided input value into the format that should be stored.
+   * @param value - A new value to assign to the element
+   * @throws An error if the provided value is invalid
+   */
+  protected _setValue(value: FormInputValueType): void;
+
+  set disabled(value: boolean);
+
+  /**
+   * Is this element disabled?
+   */
+  get disabled(): boolean;
+
+  /**
+   * Is this field editable? The field can be neither disabled nor readonly.
+   */
+  get editable(): boolean;
+
+  /**
+   * Special behaviors that the subclass should implement when toggling the disabled state of the input.
+   * @param disabled - The new disabled state
+   */
+  protected _toggleDisabled(disabled: boolean): void;
+
+  /**
+   * Initialize the custom element, constructing its HTML.
+   */
+  connectedCallback(): void;
+
+  /**
+   * Create the HTML elements that should be included in this custom element.
+   * Elements are returned as an array of ordered children.
+   */
+  protected _buildElements(): HTMLElement[];
+
+  /**
+   * Refresh the active state of the custom element.
+   */
+  protected _refresh(): void;
+
+  /**
+   * Apply key attributes on the containing custom HTML element to input elements contained within it.
+   * @internal
+   */
+  protected _applyInputAttributes(input: HTMLInputElement): void;
+
+  /**
+   * Activate event listeners which add dynamic behavior to the custom element.
+   */
+  protected _activateListeners(): void;
+
+  /**
+   * Special handling when the custom element is clicked. This should be implemented to transfer focus to an
+   * appropriate internal element.
+   */
+  protected _onClick(event: PointerEvent): void;
+}