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

package/src/foundry/client/apps/placeables/note-config.d.mts

@@ -0,0 +1,65 @@
+import type { MaybePromise } from "../../../../types/utils.d.mts";
+
+declare global {
+  /**
+   * The Application responsible for configuring a single Note document within a parent Scene.
+   * @typeParam Options - the type of the options object
+   */
+  class NoteConfig<
+    Options extends
+      DocumentSheetOptions<NoteDocument.ConfiguredInstance> = DocumentSheetOptions<NoteDocument.ConfiguredInstance>,
+  > extends DocumentSheet<Options, NoteDocument.ConfiguredInstance> {
+    /**
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   title: game.i18n.localize("NOTE.ConfigTitle"),
+     *   template: "templates/scene/note-config.html",
+     *   width: 400,
+     * })
+     * ```
+     */
+    static override get defaultOptions(): DocumentSheetOptions<NoteDocument>;
+
+    override getData(options?: Partial<Options>): MaybePromise<object>; // TODO: Implement GetDataReturnType
+
+    activateListeners(html: JQuery<HTMLElement>): void;
+
+    protected _onChangeInput(event: JQuery.ChangeEvent): Promise<void>;
+
+    /**
+     * Update disabled state of the custom icon field.
+     */
+    protected _updateCustomIcon(): void;
+
+    /**
+     * Update the list of pages.
+     */
+    protected _updatePageList(): void;
+
+    protected _getSubmitData(updateData?: object | null): Record<string, unknown>;
+
+    protected override _updateObject(event: Event, formData: NoteConfig.FormData): Promise<unknown>;
+
+    override close(options?: Application.CloseOptions): Promise<void>;
+  }
+
+  namespace NoteConfig {
+    type Any = NoteConfig<any>;
+
+    interface FormData {
+      entryId: NoteDocument["entryId"];
+      fontFamily: NoteDocument["fontFamily"];
+      fontSize: NoteDocument["fontSize"];
+      "icon.selected": NoteDocument["texture"]["src"];
+      "icon.custom": NoteDocument["texture"]["src"] | "";
+      iconSize: NoteDocument["iconSize"];
+      iconTint: NoteDocument["texture"]["tint"];
+      text: NoteDocument["text"];
+      textAnchor: NoteDocument["textAnchor"];
+      textColor: NoteDocument["textColor"];
+      x: NoteDocument["x"];
+      y: NoteDocument["y"];
+    }
+  }
+}

package/src/foundry/client/apps/placeables/sound-config.d.mts

@@ -0,0 +1,43 @@
+import type { MaybePromise } from "../../../../types/utils.d.mts";
+
+declare global {
+  /**
+   * The Application responsible for configuring a single AmbientSound document within a parent Scene.
+   * @typeParam Options - the type of the options object
+   */
+  class AmbientSoundConfig<
+    Options extends DocumentSheetOptions<AmbientSoundDocument> = DocumentSheetOptions<AmbientSoundDocument>,
+  > extends DocumentSheet<Options, AmbientSoundDocument.ConfiguredInstance> {
+    /**
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   title: "SOUND.ConfigTitle",
+     *   template: "templates/scene/sound-config.html",
+     *   width: 480
+     * });
+     * ```
+     */
+    static get defaultOptions(): DocumentSheetOptions<AmbientSoundDocument>;
+
+    override get title(): string;
+
+    override getData(options?: Partial<Options>): MaybePromise<object>; // TODO: Implement GetDataReturnType
+
+    protected override _updateObject(event: Event, formData: AmbientSoundConfig.FormData): Promise<unknown>;
+
+    override close(options?: Application.CloseOptions): Promise<void>;
+  }
+
+  namespace AmbientSoundConfig {
+    type Any = AmbientSoundConfig<any>;
+
+    type FormData = Pick<
+      foundry.documents.BaseAmbientSound,
+      "easing" | "path" | "volume" | "x" | "y" | "radius" | "walls"
+    > & {
+      "darkness.min": AmbientSoundDocument["darkness"]["min"];
+      "darkness.max": AmbientSoundDocument["darkness"]["max"];
+    };
+  }
+}

package/src/foundry/client/apps/placeables/tile-config.d.mts

@@ -0,0 +1,54 @@
+import type { MaybePromise } from "../../../../types/utils.d.mts";
+
+declare global {
+  /**
+   * The Application responsible for configuring a single Tile document within a parent Scene.
+   * @typeParam Options - the type of the options object
+   */
+  class TileConfig<Options extends TileConfig.Options = TileConfig.Options> extends DocumentSheet<
+    Options,
+    TileDocument.ConfiguredInstance
+  > {
+    /**
+     * @defaultValue
+     * ```typescript
+     * mergeObject(super.defaultOptions, {
+     *   id: "tile-config",
+     *   title: game.i18n.localize("TILE.ConfigTitle"),
+     *   template: "templates/scene/tile-config.html",
+     *   width: 420,
+     *   height: "auto",
+     *   submitOnChange: true,
+     *   tabs: [{navSelector: ".tabs", contentSelector: "form", initial: "basic"}]
+     * });
+     * ```
+     */
+    static override get defaultOptions(): TileConfig.Options;
+
+    override close(options?: Application.CloseOptions): Promise<void>;
+
+    override getData(options?: Partial<Options>): MaybePromise<object>; // TODO: Implement GetDataReturnType
+
+    protected override _onChangeInput(event: JQuery.ChangeEvent): Promise<void>;
+
+    protected override _updateObject(event: Event, formData: TileConfig.FormData): Promise<unknown>;
+  }
+
+  namespace TileConfig {
+    type Any = TileConfig<any>;
+
+    type FormData = Pick<TileDocument, "alpha" | "height" | "rotation" | "width" | "x" | "y" | "overhead" | "roof"> & {
+      "texture.src": string | null;
+      "texture.scaleX": number | null;
+      "texture.scaleY": number | null;
+      "texture.tint": string;
+    };
+
+    interface Options extends DocumentSheetOptions<TileDocument> {
+      /**
+       * Configure a preview version of a tile which is not yet saved
+       */
+      preview?: boolean;
+    }
+  }
+}

package/src/foundry/client/apps/placeables/tile-hud.d.mts

@@ -0,0 +1,37 @@
+import type { MaybePromise } from "../../../../types/utils.d.mts";
+
+declare global {
+  /**
+   * An implementation of the PlaceableHUD base class which renders a heads-up-display interface for Tile objects.
+   * @typeParam Options - the type of the options object
+   */
+  class TileHUD<Options extends ApplicationOptions = ApplicationOptions> extends BasePlaceableHUD<
+    Tile.ConfiguredInstance,
+    Options
+  > {
+    /**
+     * @defaultValue
+     * ```
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   id: "tile-hud",
+     *   template: "templates/hud/tile-hud.html"
+     * })
+     * ```
+     */
+    static override get defaultOptions(): ApplicationOptions;
+
+    override getData(options?: Partial<Options>): MaybePromise<object>; // TODO: Implement GetDataReturnType
+
+    override setPosition(options?: Partial<Application.Position>): void;
+
+    protected override _onClickControl(event: JQuery.ClickEvent): void | this;
+
+    protected _onToggleOverhead(event: PointerEvent, overhead: boolean): Promise<ReturnType<this["render"]>>;
+
+    protected _onControlVideo(event: PointerEvent): this;
+  }
+
+  namespace TileHUD {
+    type Any = TileHUD<any>;
+  }
+}

package/src/foundry/client/apps/placeables/token-config.d.mts

@@ -0,0 +1,244 @@
+import type { InterfaceToObject } from "../../../../types/helperTypes.d.mts";
+import type { AnyObject } from "../../../../types/utils.d.mts";
+import type StringTerm from "../../../client-esm/dice/terms/string.d.mts";
+
+declare global {
+  /**
+   * The Application responsible for configuring a single Token document within a parent Scene.
+   */
+  class TokenConfig<
+    Options extends
+      DocumentSheetOptions<TokenDocument.ConfiguredInstance> = DocumentSheetOptions<TokenDocument.ConfiguredInstance>,
+  > extends DocumentSheet<Options, TokenDocument.ConfiguredInstance | Actor.ConfiguredInstance> {
+    constructor(object: TokenDocument.ConfiguredInstance | Actor.ConfiguredInstance, options?: Partial<Options>);
+
+    /**
+     * The placed Token object in the Scene
+     */
+    token: TokenDocument.ConfiguredInstance | foundry.data.PrototypeToken;
+
+    /**
+     * A reference to the Actor which the token depicts
+     */
+    actor: Actor.ConfiguredInstance;
+
+    /**
+     * Maintain a copy of the original to show a real-time preview of changes.
+     */
+    preview: TokenDocument.ConfiguredInstance | foundry.data.PrototypeToken;
+
+    /**
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   classes: ["sheet", "token-sheet"],
+     *   template: "templates/scene/token-config.html",
+     *   width: 480,
+     *   height: "auto",
+     *   tabs: [
+     *     {navSelector: '.tabs[data-group="main"]', contentSelector: "form", initial: "character"},
+     *     {navSelector: '.tabs[data-group="light"]', contentSelector: '.tab[data-tab="light"]', initial: "basic"}
+     *     {navSelector: '.tabs[data-group="vision"]', contentSelector: '.tab[data-tab="vision"]', initial: "basic"}
+     *   ],
+     *   viewPermission: CONST.DOCUMENT_OWNERSHIP_LEVELS.OWNER,
+     *   sheetConfig: true
+     * })
+     * ```
+     */
+    static override get defaultOptions(): DocumentSheetOptions<TokenDocument.ConfiguredInstance>;
+
+    /**
+     * A convenience accessor to test whether we are configuring the prototype Token for an Actor.
+     */
+    get isPrototype(): boolean;
+
+    override get id(): string;
+
+    override get title(): string;
+
+    override render(force?: boolean, options?: Application.RenderOptions<Options>): this;
+
+    protected override _render(force?: boolean, options?: Application.RenderOptions<Options>): Promise<void>;
+
+    /**
+     * Handle preview with a token.
+     */
+    protected _handleTokenPreview(force: boolean, options?: Options): Promise<void>;
+
+    protected override _canUserView(user: User): boolean;
+
+    override getData(options?: Partial<Options>): Promise<object>; // TODO: Implement GetDataReturnType
+
+    protected _renderInner(data: ReturnType<this["getData"]>): Promise<JQuery<HTMLElement>>;
+
+    /**
+     * Get an Object of image paths and filenames to display in the Token sheet
+     * @internal
+     */
+    protected _getAlternateTokenImages(): Promise<Record<string, string>>;
+
+    override activateListeners(html: JQuery): void;
+
+    override close(options?: FormApplication.CloseOptions): Promise<void>;
+
+    protected override _getSubmitData(updateData?: AnyObject | null): InterfaceToObject<TokenConfig.FormData>;
+
+    protected override _onChangeInput(event: JQuery.ChangeEvent): Promise<void>;
+
+    /**
+     * Mimic changes to the Token document as if they were true document updates.
+     * @param change - The change to preview.
+     */
+    protected _previewChanges(change?: AnyObject): void;
+
+    /**
+     * Reset the temporary preview of the Token when the form is submitted or closed.
+     */
+    protected _resetPreview(): void;
+
+    protected override _updateObject(event: Event, formData: TokenConfig.FormData): Promise<unknown>;
+
+    /**
+     * Handle Token assignment requests to update the default prototype Token
+     * @param event - The left-click event on the assign token button
+     * @internal
+     */
+    protected _onAssignToken(event: JQuery.ClickEvent): void;
+
+    /**
+     * Handle changing the attribute bar in the drop-down selector to update the default current and max value
+     * @internal
+     */
+    protected _onBarChange(ev: JQuery.ChangeEvent): void;
+
+    /**
+     * Handle click events on a token configuration sheet action button
+     * @param event - The originating click event
+     */
+    protected _onClickActionButton(event: PointerEvent): void;
+
+    /**
+     * Handle adding a detection mode.
+     * @param modes - The existing detection modes
+     */
+    protected _onAddDetectionMode(modes: TokenDocument["detectionModes"]): void;
+
+    /**
+     * Handle removing a detection mode.
+     * @param index - The index of the detection mode to remove.
+     * @param modes - The existing detection modes.
+     */
+    protected _onRemoveDetectionMode(index: number, modes: TokenDocument["detectionModes"]): void;
+
+    /**
+     * Disable the user's ability to edit the token image field if wildcard images are enabled and that user does not have
+     * file browser permissions.
+     * @internal
+     */
+    protected _disableEditImage(): void;
+  }
+
+  namespace TokenConfig {
+    type Any = TokenConfig<any>;
+
+    interface FormData {
+      // TODO: Update
+      actorId: string;
+      actorLink: boolean;
+      alternateImages?: string;
+      alpha: number;
+      "bar1.attribute": string;
+      "bar2.attribute": string;
+      brightLight: number | null;
+      brightSight: number | null;
+      dimLight: number | null;
+      dimSight: number | null;
+      displayBars: foundry.CONST.TOKEN_DISPLAY_MODES;
+      displayName: foundry.CONST.TOKEN_DISPLAY_MODES;
+      disposition: foundry.CONST.TOKEN_DISPOSITIONS;
+      elevation: number | null;
+      height: number | null;
+      img: string;
+      lightAlpha: number;
+      lightAngle: number | null;
+      "lightAnimation.intensity": number;
+      "lightAnimation.speed": number;
+      "lightAnimation.type": string;
+      lightColor: string;
+      lockRotation: boolean;
+      mirrorX: boolean;
+      mirrorY: boolean;
+      name: StringTerm;
+      rotation: number | null;
+      scale: number;
+      sightAngle: number | null;
+      tint: string;
+      vision: boolean;
+      width: number | null;
+      x: number | null;
+      y: number | null;
+    }
+  }
+
+  /**
+   * A sheet that alters the values of the default Token configuration used when new Token documents are created.
+   */
+  class DefaultTokenConfig<
+    Options extends
+      DocumentSheetOptions<TokenDocument.ConfiguredInstance> = DocumentSheetOptions<TokenDocument.ConfiguredInstance>,
+  > extends TokenConfig<Options> {
+    constructor(object?: unknown, options?: Partial<Options>);
+
+    object: TokenDocument.ConfiguredInstance;
+
+    /**
+     * The named world setting that stores the default Token configuration
+     * @defaultValue `"defaultToken"`
+     */
+    static SETTING: string;
+
+    /**
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   template: "templates/scene/default-token-config.html",
+     *   sheetConfig: false
+     * })
+     * ```
+     */
+    static override get defaultOptions(): DocumentSheetOptions<TokenDocument.ConfiguredInstance>;
+
+    override get id(): string;
+
+    override get title(): string;
+
+    override get isEditable(): boolean;
+
+    protected override _canUserView(user: User): boolean;
+
+    override getData(options: unknown): Promise<object>; // TODO: Implement GetDataReturnType
+
+    override _getSubmitData(
+      updateData?: Parameters<TokenConfig["_getSubmitData"]>[0],
+    ): ReturnType<TokenConfig["_getSubmitData"]>;
+
+    override _updateObject(event: Event, formData?: object): Promise<unknown>;
+
+    override activateListeners(html: JQuery): void;
+
+    /**
+     * Reset the form to default values
+     */
+    reset(): void;
+
+    protected override _onBarChange(): Promise<void>;
+
+    protected override _onAddDetectionMode(modes: TokenDocument["detectionModes"]): void;
+
+    protected override _onRemoveDetectionMode(index: number, modes: TokenDocument["detectionModes"]): void;
+  }
+
+  namespace DefaultTokenConfig {
+    type Any = DefaultTokenConfig<any>;
+  }
+}

package/src/foundry/client/apps/placeables/token-hud.d.mts

@@ -0,0 +1,134 @@
+import type { MaybePromise } from "../../../../types/utils.d.mts";
+
+declare global {
+  /**
+   * An implementation of the PlaceableHUD base class which renders a heads-up-display interface for Token objects.
+   * This interface provides controls for visibility, attribute bars, elevation, status effects, and more.
+   * @typeParam Options - the type of the options object
+   */
+  class TokenHUD<Options extends ApplicationOptions = ApplicationOptions> extends BasePlaceableHUD<
+    Token.ConfiguredInstance,
+    Options
+  > {
+    /**
+     * Track whether the status effects control palette is currently expanded or hidden
+     * @defaultValue `false`
+     * @internal
+     */
+    protected _statusEffects: boolean;
+
+    /**
+     * @defaultValue
+     * ```
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   id: "token-hud",
+     *   template: "templates/hud/token-hud.html"
+     * })
+     * ```
+     */
+    static override get defaultOptions(): ApplicationOptions;
+
+    override bind(object: Token.ConfiguredInstance): void;
+
+    /**
+     * Refresh the currently active state of all status effect icons in the Token HUD selector.
+     */
+    refreshStatusIcons(): void;
+
+    override setPosition(_position?: Partial<Application.Position>): void;
+
+    override getData(options?: Partial<ApplicationOptions>): MaybePromise<object>; // TODO: Implement GetDataReturnType
+
+    /**
+     * Get an array of icon paths which represent valid status effect choices
+     * @internal
+     */
+    protected _getStatusEffectChoices(): Record<
+      string,
+      {
+        id: string;
+        title: string | null;
+        src: string;
+        isActive: boolean;
+        isOverlay: boolean;
+        cssClass: string;
+      }
+    >;
+
+    override activateListeners(html: JQuery): void;
+
+    protected override _onClickControl(event: JQuery.ClickEvent): unknown;
+
+    /**
+     * Handle initial click to focus an attribute update field
+     * @internal
+     */
+    protected _onAttributeClick(event: JQuery.ClickEvent): void;
+
+    /**
+     * Force field handling on an Enter keypress even if the value of the field did not change.
+     * This is important to suppose use cases with negative number values.
+     * @param event - The originating keydown event
+     * @internal
+     */
+    protected _onAttributeKeydown(event: JQuery.KeyDownEvent): void;
+
+    /**
+     * Handle attribute bar update
+     * @internal
+     */
+    protected _onAttributeUpdate(event: JQuery.FocusOutEvent): void;
+
+    /**
+     * Toggle Token combat state
+     * @internal
+     */
+    protected _onToggleCombat(event: JQuery.ClickEvent): Promise<void>;
+
+    /**
+     * Handle Token configuration button click
+     * @internal
+     */
+    protected _onTokenConfig(event: JQuery.ClickEvent): void;
+
+    /**
+     * Handle left-click events to toggle the displayed state of the status effect selection palette
+     * @internal
+     */
+    protected _onToggleStatusEffects(event: JQuery.ClickEvent): void;
+
+    /**
+     * Assign css selectors for the active state of the status effects selection palette
+     * @internal
+     */
+    protected _toggleStatusEffects(active: boolean): void;
+
+    /**
+     * Handle toggling a token status effect icon
+     * @param event  - The click event to toggle the effect
+     * @param options - Options which modify the toggle
+     * @internal
+     */
+    protected _onToggleEffect(
+      event: JQuery.ClickEvent | JQuery.ContextMenuEvent,
+      options?: {
+        /**
+         * Toggle the overlay effect?
+         * @defaultValue `false`
+         */
+        overlay?: boolean;
+      },
+    ): Promise<boolean>;
+
+    /**
+     * Handle toggling the target state for this Token
+     * @param event - The click event to toggle the target
+     * @internal
+     */
+    protected _onToggleTarget(event: JQuery.ClickEvent): void;
+  }
+
+  namespace TokenHUD {
+    type Any = TokenHUD<any>;
+  }
+}

package/src/foundry/client/apps/placeables/wall-config.d.mts

@@ -0,0 +1,63 @@
+import type { MaybePromise } from "../../../../types/utils.d.mts";
+
+declare global {
+  /**
+   * The Application responsible for configuring a single Wall document within a parent Scene.
+   * @typeParam Options - The type of the options object
+   */
+  class WallConfig<
+    Options extends DocumentSheetOptions<WallDocument> = DocumentSheetOptions<WallDocument>,
+  > extends DocumentSheet<Options, WallDocument.ConfiguredInstance> {
+    /**
+     * @defaultValue
+     * ```typescript
+     * const options = super.defaultOptions;
+     * options.classes.push("wall-config");
+     * options.template = "templates/scene/wall-config.html";
+     * options.width = 400;
+     * options.height = "auto";
+     * return options;
+     * ```
+     */
+    static get defaultOptions(): DocumentSheetOptions<WallDocument>;
+
+    /**
+     * An array of Wall ids that should all be edited when changes to this config form are submitted
+     * @defaultValue `[]`
+     */
+    editTargets: string[];
+
+    override get title(): string;
+
+    override render(
+      force?: boolean,
+      options?: Application.RenderOptions<Options> & {
+        walls?: Wall.ConfiguredInstance[] | undefined;
+      },
+    ): this;
+
+    override getData(): MaybePromise<object>; // TODO: Implement GetDataReturnType
+
+    override activateListeners(html: JQuery<HTMLElement>): void;
+
+    protected _onChangeInput(event: JQuery.ChangeEvent<any, any, any, any>): Promise<void | object>;
+
+    protected _getSubmitData(updateData?: object | null): WallConfig.FormData;
+
+    protected override _updateObject(event: Event, formData: WallConfig.FormData): Promise<unknown>;
+  }
+
+  namespace WallConfig {
+    type Any = WallConfig<any>;
+
+    type FormData = Pick<
+      WallDocument["_source"],
+      "move" | "light" | "sight" | "sound" | "dir" | "door" | "ds" | "doorSound"
+    > & {
+      "threshold.light": WallDocument["_source"]["threshold"]["light"];
+      "threshold.sight": WallDocument["_source"]["threshold"]["sight"];
+      "threshold.sound": WallDocument["_source"]["threshold"]["sound"];
+      "threshold.attenuation": WallDocument["_source"]["threshold"]["attenuation"];
+    };
+  }
+}

package/src/foundry/client/apps/sidebar/apps/chat-popout.d.mts

@@ -0,0 +1,39 @@
+export {};
+
+declare global {
+  /**
+   * A simple application which supports popping a ChatMessage out to a separate UI window.
+   * @typeParam Options - the type of the options object
+   */
+  class ChatPopout<Options extends ApplicationOptions = ApplicationOptions> extends Application<Options> {
+    constructor(message: ChatMessage.ConfiguredInstance, options?: Partial<Options>);
+
+    /**
+     * The displayed Chat Message document
+     */
+    message: ChatMessage.ConfiguredInstance;
+
+    /**
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   width: 300,
+     *   height: "auto",
+     *   classes: ["chat-popout"]
+     * })
+     * ```
+     */
+    static override get defaultOptions(): ApplicationOptions;
+
+    override get id(): string;
+
+    override get title(): string;
+
+    /** @remarks Foundry references an options object as a second argument, but this is never used nor provided in the invocation */
+    protected override _renderInner(data: ReturnType<this["getData"]>): Promise<JQuery>;
+  }
+
+  namespace ChatPopout {
+    type Any = ChatPopout<any>;
+  }
+}