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

package/src/foundry/client/applications/api/document-sheet.d.mts

@@ -0,0 +1,207 @@
+import type { DeepPartial, Identity } from "#utils";
+import type ApplicationV2 from "./application.d.mts";
+import type FormDataExtended from "../ux/form-data-extended.d.mts";
+
+import Document = foundry.abstract.Document;
+
+declare module "#configuration" {
+  namespace Hooks {
+    interface ApplicationV2Config {
+      DocumentSheetV2: DocumentSheetV2.Any;
+    }
+  }
+}
+
+declare namespace DocumentSheetV2 {
+  interface Any extends AnyDocumentSheetV2 {}
+  interface AnyConstructor extends Identity<typeof AnyDocumentSheetV2> {}
+
+  interface RenderContext<ConcreteDocument extends Document.Any> extends ApplicationV2.RenderContext {
+    document: ConcreteDocument;
+    source: ConcreteDocument["_source"];
+    fields: ConcreteDocument["schema"]["fields"];
+    editable: boolean;
+    rootId: string;
+  }
+
+  interface Configuration<ConcreteDocument extends Document.Any> extends _Configuration {
+    /**
+     * The Document instance associated with this sheet
+     */
+    document: ConcreteDocument;
+  }
+
+  /** @internal */
+  interface _Configuration extends ApplicationV2.Configuration {
+    /**
+     * A permission level in CONST.DOCUMENT_OWNERSHIP_LEVELS
+     */
+    viewPermission: typeof foundry.CONST.DOCUMENT_OWNERSHIP_LEVELS;
+
+    /**
+     * A permission level in CONST.DOCUMENT_OWNERSHIP_LEVELS
+     */
+    editPermission: typeof foundry.CONST.DOCUMENT_OWNERSHIP_LEVELS;
+
+    /**
+     * Can this sheet class be used to create a new Document?
+     */
+    canCreate: boolean;
+
+    /**
+     * Allow sheet configuration as a header button
+     */
+    sheetConfig: boolean;
+  }
+
+  // Note(LukeAbby): This `& object` is so that the `DEFAULT_OPTIONS` can be overridden more easily
+  // Without it then `static override DEFAULT_OPTIONS = { unrelatedProp: 123 }` would error.
+  interface DefaultOptions extends DeepPartial<_Configuration>, Identity<object> {
+    /**
+     * @deprecated Setting `document` in `DocumentSheetV2.DEFAULT_OPTIONS` is not supported. If you
+     * have a need for this, please file an issue.
+     */
+    document?: never;
+  }
+
+  interface RenderOptions extends ApplicationV2.RenderOptions {
+    /** A string with the format "\{operation\}\{documentName\}" providing context */
+    renderContext: string;
+
+    /** Data describing the document modification that occurred */
+    renderData: object;
+  }
+
+  interface SubmitOptions {
+    /** Additional data passed in if this form is submitted manually which should be merged with prepared formData. */
+    updateData: object;
+  }
+}
+
+/**
+ * The Application class is responsible for rendering an HTMLElement into the Foundry Virtual Tabletop user interface.
+ */
+declare class DocumentSheetV2<
+  Document extends Document.Any,
+  RenderContext extends object = DocumentSheetV2.RenderContext<Document>,
+  Configuration extends DocumentSheetV2.Configuration<Document> = DocumentSheetV2.Configuration<Document>,
+  RenderOptions extends DocumentSheetV2.RenderOptions = DocumentSheetV2.RenderOptions,
+> extends ApplicationV2<RenderContext, Configuration, RenderOptions> {
+  constructor(options?: DeepPartial<Configuration>);
+
+  static DEFAULT_OPTIONS: DocumentSheetV2.DefaultOptions;
+
+  get document(): Document;
+
+  override get title(): string;
+
+  /**
+   * Is this Document sheet visible to the current User?
+   * This is governed by the viewPermission threshold configured for the class.
+   */
+  get isVisible(): boolean;
+
+  /**
+   * Is this Document sheet editable by the current User?
+   * This is governed by the editPermission threshold configured for the class.
+   */
+  get isEditable(): boolean;
+
+  protected _initializeApplicationOptions(options: DeepPartial<Configuration>): Configuration;
+
+  protected override _headerControlsButtons(): Generator<ApplicationV2.HeaderControlsEntry, void, undefined>;
+
+  protected override _configureRenderOptions(options: DeepPartial<RenderOptions>): void;
+
+  protected override _prepareContext(
+    options: DeepPartial<RenderOptions> & { isFirstRender: boolean },
+  ): Promise<RenderContext>;
+
+  protected override _renderFrame(options: DeepPartial<RenderOptions>): Promise<HTMLElement>;
+
+  /**
+   * Disable or reenable all form fields in this application
+   * @param disabled - Should the fields be disabled?
+   */
+  protected _toggleDisabled(disabled: boolean): void;
+
+  protected override _canRender(options: DeepPartial<RenderOptions>): false | void;
+
+  protected override _onFirstRender(
+    context: DeepPartial<RenderContext>,
+    options: DeepPartial<RenderOptions>,
+  ): Promise<void>;
+
+  protected override _onRender(context: DeepPartial<RenderContext>, options: DeepPartial<RenderOptions>): Promise<void>;
+
+  protected override _onClose(options: DeepPartial<RenderOptions>): void;
+
+  protected override _onChangeForm(formConfig: ApplicationV2.FormConfiguration, event: Event): void;
+
+  /**
+   * Handle toggling the revealed state of a secret embedded in some content.
+   */
+  protected _onRevealSecret(event: Event): void;
+
+  /**
+   * Prepare data used to update the Item upon form submission.
+   * This data is cleaned and validated before being returned for further processing.
+   * @param event      - The originating form submission event
+   * @param form       - The form element that was submitted
+   * @param formData   - Processed data for the submitted form
+   * @param updateData - Additional data passed in if this form is submitted manually which should be merged with prepared formData
+   * @returns Prepared submission data as an object
+   * @throws Subclasses may throw validation errors here to prevent form submission
+   * @privateRemarks TODO: Improve typing for updateData & return
+   */
+  protected _prepareSubmitData(
+    event: SubmitEvent,
+    form: HTMLFormElement,
+    formData: FormDataExtended,
+    updateData?: unknown,
+  ): object;
+
+  /**
+   * Customize how form data is extracted into an expanded object.
+   * @param event    - The originating form submission event
+   * @param form     - The form element that was submitted
+   * @param formData - Processed data for the submitted form
+   * @returns An expanded object of processed form data
+   * @throws Subclasses may throw validation errors here to prevent form submission
+   */
+  protected _processFormData(event: SubmitEvent | null, form: HTMLFormElement, formData: FormDataExtended): object;
+
+  /**
+   * Submit a document update or creation request based on the processed form data.
+   * @param event    - The originating form submission event
+   * @param form     - The form element that was submitted
+   * @param formData - Processed and validated form data to be used for a document update
+   * @param options  - Additional options altering the request
+   * @privateRemarks TODO: Improve options to capture the Create and/or Update options available to the Document
+   */
+  protected _processSubmitData(
+    event: SubmitEvent,
+    form: HTMLFormElement,
+    formData: FormDataExtended,
+    options?: unknown,
+  ): Promise<void>;
+
+  /**
+   * Provide a deprecation path for converted V1 document sheets.
+   * @param first - The first parameter received by this class's constructor
+   * @param rest  - Any additional parameters received
+   * @privateRemarks - This *is* possible to type more precisely but the reward/benefit is pretty minor
+   */
+  static _migrateConstructorParams(first: unknown, rest: unknown[]): DocumentSheetV2.Configuration<Document.Any>;
+}
+
+export default DocumentSheetV2;
+
+declare abstract class AnyDocumentSheetV2 extends DocumentSheetV2<
+  Document.Any,
+  object,
+  DocumentSheetV2.Configuration<Document.Any>,
+  DocumentSheetV2.RenderOptions
+> {
+  constructor(...args: never);
+}

package/src/foundry/client/applications/api/handlebars-application.d.mts

@@ -0,0 +1,240 @@
+import type { DeepPartial, FixedInstanceType, Mixin } from "#utils";
+import type ApplicationV2 from "./application.d.mts";
+import type DocumentSheetV2 from "./document-sheet.d.mts";
+
+/**
+ * The mixed application class augmented with [Handlebars](https://handlebarsjs.com) template rendering behavior.
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+declare class HandlebarsApplication {
+  /** @privateRemarks All mixin classses should accept anything for its constructor. */
+  constructor(...args: any[]);
+
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+  readonly [ApplicationV2.Internal.__RenderContext]: {};
+
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+  readonly [ApplicationV2.Internal.__Configuration]: {};
+
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+  readonly [ApplicationV2.Internal.__RenderOptions]: {};
+
+  /**
+   * Configure a registry of template parts which are supported for this application for partial rendering.
+   * @defaultValue `{}`
+   */
+  static PARTS: Record<string, HandlebarsApplicationMixin.HandlebarsTemplatePart>;
+
+  /**
+   * A record of all rendered template parts.
+   * @defaultValue `{}`
+   */
+  get parts(): Record<string, HTMLElement>;
+
+  protected _configureRenderOptions(options: DeepPartial<HandlebarsApplicationMixin.RenderOptions>): void;
+
+  /**
+   * Allow subclasses to dynamically configure render parts.
+   */
+  protected _configureRenderParts(
+    options: HandlebarsApplicationMixin.RenderOptions,
+  ): Record<string, HandlebarsApplicationMixin.HandlebarsTemplatePart>;
+
+  protected _preRender(
+    context: DeepPartial<ApplicationV2.RenderContextOf<this>>,
+    options: DeepPartial<ApplicationV2.RenderOptionsOf<this>>,
+  ): Promise<void>;
+
+  /**
+   * Render each configured application part using Handlebars templates.
+   * @param context - Context data for the render operation
+   * @param options - Options which configure application rendering behavior
+   * @returns A single rendered HTMLElement for each requested part
+   */
+  protected _renderHTML(
+    context: ApplicationV2.RenderContextOf<this>,
+    options: DeepPartial<ApplicationV2.RenderOptionsOf<this>>,
+  ): Promise<Record<string, HTMLElement>>;
+
+  /**
+   * Prepare context that is specific to only a single rendered part.
+   *
+   * It is recommended to augment or mutate the shared context so that downstream methods like _onRender have
+   * visibility into the data that was used for rendering. It is acceptable to return a different context object
+   * rather than mutating the shared context at the expense of this transparency.
+   *
+   * @param partId  - The part being rendered
+   * @param context - Shared context provided by _prepareContext
+   * @param options - Options which configure application rendering behavior
+   * @returns Context data for a specific part
+   */
+  protected _preparePartContext(
+    partId: string,
+    context: ApplicationV2.RenderContextOf<this>,
+    options: DeepPartial<HandlebarsApplicationMixin.RenderOptions>,
+  ): Promise<ApplicationV2.RenderContextOf<this>>;
+
+  /**
+   * Replace the HTML of the application with the result provided by Handlebars rendering.
+   * @param result  - The result from Handlebars template rendering
+   * @param content - The content element into which the rendered result must be inserted
+   * @param options - Options which configure application rendering behavior
+   */
+  protected _replaceHTML(
+    result: Record<string, HTMLElement>,
+    content: HTMLElement,
+    options: DeepPartial<ApplicationV2.RenderOptionsOf<this>>,
+  ): void;
+
+  /**
+   * Prepare data used to synchronize the state of a template part.
+   * @param partId       - The id of the part being rendered
+   * @param newElement   - The new rendered HTML element for the part
+   * @param priorElement - The prior rendered HTML element for the part
+   * @param state        - A state object which is used to synchronize after replacement
+   */
+  protected _preSyncPartState(
+    partId: string,
+    newElement: HTMLElement,
+    priorElement: HTMLElement,
+    state: HandlebarsApplicationMixin.PartState,
+  ): void;
+
+  /**
+   * Synchronize the state of a template part after it has been rendered and replaced in the DOM.
+   * @param partId       - The id of the part being rendered
+   * @param newElement   - The new rendered HTML element for the part
+   * @param priorElement - The prior rendered HTML element for the part
+   * @param state        - A state object which is used to synchronize after replacement
+   */
+  protected _syncPartState(
+    partId: string,
+    newElement: HTMLElement,
+    priorElement: HTMLElement,
+    state: HandlebarsApplicationMixin.PartState,
+  ): void;
+
+  protected _tearDown(options: DeepPartial<ApplicationV2.ClosingOptions>): void;
+
+  /**
+   * Attach event listeners to rendered template parts.
+   * @param partId      - The id of the part being rendered
+   * @param htmlElement - The rendered HTML element for the part
+   * @param options     - Rendering options passed to the render method
+   */
+  protected _attachPartListeners(
+    partId: string,
+    htmlElement: HTMLElement,
+    options: DeepPartial<HandlebarsApplicationMixin.RenderOptions>,
+  ): void;
+}
+
+/**
+ * Augment an Application class with [Handlebars](https://handlebarsjs.com) template rendering behavior.
+ */
+declare function HandlebarsApplicationMixin<BaseClass extends HandlebarsApplicationMixin.BaseClass>(
+  BaseApplication: BaseClass,
+): Mixin<typeof HandlebarsApplication, BaseClass>;
+
+declare namespace HandlebarsApplicationMixin {
+  interface AnyMixedConstructor extends ReturnType<typeof HandlebarsApplicationMixin<BaseClass>> {}
+  interface AnyMixed extends FixedInstanceType<AnyMixedConstructor> {}
+
+  type BaseClass = ApplicationV2.Internal.Constructor;
+
+  interface PartState {
+    scrollPositions: Array<[el1: HTMLElement, scrollTop: number, scrollLeft: number]>;
+    focus?: string | undefined;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+  interface RenderContext {}
+
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+  interface Configuration {}
+
+  interface RenderOptions {
+    parts: string[];
+  }
+
+  /**
+   * @deprecated - Merge {@linkcode ApplicationV2.RenderOptions} and {@linkcode HandlebarsApplicationMixin.RenderOptions} individually.
+   */
+  interface ApplicationV2RenderOptions extends RenderOptions, ApplicationV2.RenderOptions {}
+
+  /**
+   * @deprecated - Merge {@linkcode DocumentSheetV2.RenderOptions} and {@linkcode HandlebarsApplicationMixin.RenderOptions} individually.
+   */
+  interface DocumentSheetV2RenderOptions extends RenderOptions, DocumentSheetV2.RenderOptions {}
+
+  interface HandlebarsTemplatePart {
+    /**
+     * The template entry-point for the part
+     */
+    template: string;
+
+    /**
+     * A CSS id to assign to the top-level element of the rendered part.
+     * This id string is automatically prefixed by the application id.
+     */
+    id?: string | null | undefined;
+
+    /**
+     * Does this rendered contents of this template part replace the children of the root element?
+     */
+    root?: boolean | null | undefined;
+
+    /**
+     * An array of CSS classes to apply to the top-level element of the
+     * rendered part.
+     */
+    classes?: string[] | null | undefined;
+
+    /**
+     * An array of additional templates that are required to render the part.
+     * If omitted, only the entry-point is inferred as required.
+     */
+    templates?: string[] | null | undefined;
+
+    /**
+     * An array of selectors within this part whose scroll positions should
+     * be persisted during a re-render operation. A blank string is used
+     * to denote that the root level of the part is scrollable.
+     */
+    scrollable?: string[] | null | undefined;
+
+    /**
+     * A registry of forms selectors and submission handlers.
+     */
+    forms?: Record<string, ApplicationV2.FormConfiguration> | null | undefined;
+  }
+
+  namespace HandlebarsApplication {
+    /**
+     * @deprecated Use {@linkcode ApplicationV2.RenderContextOf} instead.
+     */
+    // Note(LukeAbby): `object` is returned in the false case instead of `never` because otherwise errors will crop up at usage sites like "any cannot be assigned to `never`".
+    type RenderContextFor<Instance extends HandlebarsApplication> =
+      Instance extends ApplicationV2.Internal.Instance<infer RenderContext, infer _1, infer _2>
+        ? RenderContext
+        : object;
+
+    /**
+     * @deprecated Use {@linkcode ApplicationV2.ConfigurationOf} instead.
+     */
+    type ConfigurationFor<Instance extends HandlebarsApplication> =
+      Instance extends ApplicationV2.Internal.Instance<infer _1, infer Configuration, infer _2>
+        ? Configuration
+        : unknown;
+
+    /**
+     * @deprecated Use {@linkcode ApplicationV2.RenderOptionsOf} instead.
+     */
+    type RenderOptionsFor<Instance extends HandlebarsApplication> =
+      Instance extends ApplicationV2.Internal.Instance<infer _1, infer _2, infer RenderOptions>
+        ? RenderOptions
+        : object;
+  }
+}
+
+export default HandlebarsApplicationMixin;

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

@@ -0,0 +1,44 @@
+import type { 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 {
+      CameraPopout: CameraPopout.Any;
+    }
+  }
+}
+
+/**
+ * An application for a single popped-out camera.
+ * @remarks TODO: Stub
+ */
+declare class CameraPopout<
+  RenderContext extends CameraPopout.RenderContext = CameraPopout.RenderContext,
+  Configuration extends CameraPopout.Configuration = CameraPopout.Configuration,
+  RenderOptions extends CameraPopout.RenderOptions = CameraPopout.RenderOptions,
+> extends HandlebarsApplicationMixin(ApplicationV2)<RenderContext, Configuration, RenderOptions> {}
+
+declare namespace CameraPopout {
+  interface Any extends AnyCameraPopout {}
+  interface AnyConstructor extends Identity<typeof AnyCameraPopout> {}
+
+  interface RenderContext extends HandlebarsApplicationMixin.RenderContext, ApplicationV2.RenderContext {
+    rootId: string;
+  }
+
+  interface Configuration extends HandlebarsApplicationMixin.Configuration, ApplicationV2.Configuration {
+    user: User.Implementation;
+  }
+
+  interface RenderOptions extends HandlebarsApplicationMixin.RenderOptions, ApplicationV2.RenderOptions {}
+}
+
+declare abstract class AnyCameraPopout extends CameraPopout<
+  CameraPopout.RenderContext,
+  CameraPopout.Configuration,
+  CameraPopout.RenderOptions
+> {}
+
+export default CameraPopout;

package/src/foundry/client/applications/apps/av/cameras.d.mts

@@ -0,0 +1,118 @@
+import type ApplicationV2 from "../../api/application.d.mts";
+import type HandlebarsApplicationMixin from "../../api/handlebars-application.d.mts";
+import type { Identity } from "#utils";
+
+import AVSettings = foundry.av.AVSettings;
+
+declare module "#configuration" {
+  namespace Hooks {
+    interface ApplicationV2Config {
+      CameraViews: CameraViews.Any;
+    }
+  }
+}
+
+/**
+ * An application that shows docked camera views.
+ * @remarks TODO: Stub
+ */
+declare class CameraViews<
+  RenderContext extends CameraViews.RenderContext = CameraViews.RenderContext,
+  Configuration extends CameraViews.Configuration = CameraViews.Configuration,
+  RenderOptions extends CameraViews.RenderOptions = CameraViews.RenderOptions,
+> extends HandlebarsApplicationMixin(ApplicationV2)<RenderContext, Configuration, RenderOptions> {}
+
+declare namespace CameraViews {
+  interface Any extends AnyCameraViews {}
+  interface AnyConstructor extends Identity<typeof AnyCameraViews> {}
+
+  interface RenderContext extends HandlebarsApplicationMixin.RenderContext, ApplicationV2.RenderContext {}
+  interface Configuration extends HandlebarsApplicationMixin.Configuration, ApplicationV2.Configuration {}
+  interface RenderOptions extends HandlebarsApplicationMixin.RenderOptions, ApplicationV2.RenderOptions {}
+
+  interface ControlContext {
+    icon: string;
+    label: string;
+    display: boolean;
+  }
+
+  interface UserContext {
+    /** The User instance. */
+    user: User.Implementation;
+
+    /** The user's AV settings. */
+    settings: AVSettings.Data;
+
+    /** Whether the user's AV stream is local. */
+    local: boolean;
+
+    /** The user's character name. */
+    charname: string;
+
+    /** The CSS class of the user's camera dock. */
+    css: string;
+
+    /** Whether the user is broadcasting video. */
+    hasVideo: boolean;
+
+    /** Whether the user is broadcasting audio. */
+    hasAudio: boolean;
+
+    /** Whether the main camera dock is hidden. */
+    hidden: boolean;
+
+    nameplates: Nameplates;
+
+    video: Video;
+
+    volume: Volume;
+
+    controls: Record<string, ControlContext>;
+  }
+
+  interface Nameplates {
+    /** Whether camera nameplates are entirely hidden. */
+    hidden: boolean;
+
+    /** Nameplate CSS classes. */
+    css: string;
+
+    /** Whether to show player names on nameplates. */
+    playerName: string;
+
+    /** Whether to show character names on nameplates. */
+    charname: string;
+  }
+
+  interface Video {
+    /** The video stream's volume. */
+    volume: number;
+
+    /** Whether to mute the video stream's audio. */
+    muted: boolean;
+
+    /** Whether to show this user's camera. */
+    show: boolean;
+  }
+
+  interface Volume {
+    /** The user's configured volume level. */
+    value: number;
+
+    /** The volume range field. */
+    field: foundry.data.fields.DataField.Any;
+
+    /** Whether to show a volume bar for this user. */
+    show: boolean;
+  }
+}
+
+declare abstract class AnyCameraViews extends CameraViews<
+  CameraViews.RenderContext,
+  CameraViews.Configuration,
+  CameraViews.RenderOptions
+> {
+  constructor(...args: never);
+}
+
+export default CameraViews;

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

@@ -0,0 +1,45 @@
+import type ApplicationV2 from "../api/application.d.mts";
+import type HandlebarsApplicationMixin from "../api/handlebars-application.d.mts";
+import type { Identity } from "#utils";
+
+declare module "#configuration" {
+  namespace Hooks {
+    interface ApplicationV2Config {
+      CombatTrackerConfig: CombatTrackerConfig.Any;
+    }
+  }
+}
+
+/**
+ * The Application responsible for configuring the CombatTracker and its contents.
+ * @remarks TODO: Stub
+ */
+declare class CombatTrackerConfig<
+  RenderContext extends CombatTrackerConfig.RenderContext = CombatTrackerConfig.RenderContext,
+  Configuration extends CombatTrackerConfig.Configuration = CombatTrackerConfig.Configuration,
+  RenderOptions extends CombatTrackerConfig.RenderOptions = CombatTrackerConfig.RenderOptions,
+> extends HandlebarsApplicationMixin(ApplicationV2)<RenderContext, Configuration, RenderOptions> {}
+
+declare namespace CombatTrackerConfig {
+  interface Any extends AnyCombatTrackerConfig {}
+  interface AnyConstructor extends Identity<typeof AnyCombatTrackerConfig> {}
+
+  /**
+   * @remarks Foundry's override of `_prepareContext` does not call `super`. Therefore it does not
+   * inherit context from its parent class.
+   */
+  interface RenderContext {
+    rootId: string;
+  }
+
+  interface Configuration extends HandlebarsApplicationMixin.Configuration, ApplicationV2.Configuration {}
+  interface RenderOptions extends HandlebarsApplicationMixin.RenderOptions, ApplicationV2.RenderOptions {}
+}
+
+declare abstract class AnyCombatTrackerConfig extends CombatTrackerConfig<
+  CombatTrackerConfig.RenderContext,
+  CombatTrackerConfig.Configuration,
+  CombatTrackerConfig.RenderOptions
+> {}
+
+export default CombatTrackerConfig;