@league-of-foundry-developers/foundry-vtt-types 12.331.3-beta → 13.340.0

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

@@ -1,143 +1,30 @@
-import type { DeepPartial, Mixin } from "../../../../types/utils.d.mts";
+import type { DeepPartial, FixedInstanceType, Mixin } from "fvtt-types/utils";
 import type ApplicationV2 from "./application.d.mts";
-
-declare namespace HandlebarsApplication {
-  // Note(LukeAbby): `unknown` 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 ConfigurationFor<Instance extends HandlebarsApplication> =
-    Instance extends ApplicationV2.Internal.Instance<infer Configuration, any, any> ? Configuration : unknown;
-
-  type RenderOptionsFor<Instance extends HandlebarsApplication> =
-    Instance extends ApplicationV2.Internal.Instance<any, infer RenderOptions, any> ? RenderOptions : unknown;
-
-  type RenderContextFor<Instance extends HandlebarsApplication> =
-    Instance extends ApplicationV2.Internal.Instance<any, any, infer RenderContext> ? RenderContext : unknown;
-}
-
-/**
- * The mixed application class augmented with [Handlebars](https://handlebarsjs.com) template rendering behavior.
- */
-declare class HandlebarsApplication {
-  /** @privateRemarks All mixin classses should accept anything for its constructor. */
-  constructor(...args: any[]);
-
-  /**
-   * 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.HandlebarsRenderOptions>): void;
-
-  protected _preFirstRender(
-    context: DeepPartial<HandlebarsApplication.RenderContextFor<this>>,
-    options: DeepPartial<HandlebarsApplication.RenderOptionsFor<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: HandlebarsApplication.RenderContextFor<this>,
-    options: DeepPartial<HandlebarsApplication.RenderOptionsFor<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: HandlebarsApplication.RenderContextFor<this>,
-    options: DeepPartial<HandlebarsApplicationMixin.HandlebarsRenderOptions>,
-  ): Promise<HandlebarsApplication.RenderContextFor<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<HandlebarsApplication.RenderOptionsFor<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;
-
-  /**
-   * 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.HandlebarsRenderOptions>,
-  ): void;
-}
+import type DocumentSheetV2 from "./document-sheet.d.mts";
 
 /**
  * Augment an Application class with [Handlebars](https://handlebarsjs.com) template rendering behavior.
  */
-declare function HandlebarsApplicationMixin<BaseClass extends ApplicationV2.Internal.Constructor>(
+declare function HandlebarsApplicationMixin<BaseClass extends HandlebarsApplicationMixin.BaseClass>(
   BaseApplication: BaseClass,
-): Mixin<typeof HandlebarsApplication, BaseClass>;
+): Mixin<typeof HandlebarsApplicationMixin.HandlebarsApplication, BaseClass>;
 
 declare namespace HandlebarsApplicationMixin {
+  type AnyMixedConstructor = 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;
   }
 
-  // TODO: How does this merge with DocumentSheetRenderOptions?
-  interface HandlebarsRenderOptions extends ApplicationV2.RenderOptions {
+  interface RenderOptions {
     parts: string[];
   }
+  interface ApplicationV2RenderOptions extends RenderOptions, ApplicationV2.RenderOptions {}
+  interface DocumentSheetV2RenderOptions extends RenderOptions, DocumentSheetV2.RenderOptions {}
 
   interface HandlebarsTemplatePart {
     /**
@@ -149,31 +36,174 @@ declare namespace HandlebarsApplicationMixin {
      * 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;
+    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[];
+    classes?: string[] | null | undefined;
 
     /**
-     * An array of templates that are required to render the part.
+     * An array of additional templates that are required to render the part.
      * If omitted, only the entry-point is inferred as required.
      */
-    templates?: string[];
+    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.
      */
-    scrollabe?: string[];
+    scrollable?: string[] | null | undefined;
 
     /**
      * A registry of forms selectors and submission handlers.
      */
-    forms?: Record<string, ApplicationV2.FormConfiguration>;
+    forms?: Record<string, ApplicationV2.FormConfiguration> | null | undefined;
+  }
+
+  namespace HandlebarsApplication {
+    // Note(LukeAbby): `unknown` 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 ConfigurationFor<Instance extends HandlebarsApplication> =
+      Instance extends ApplicationV2.Internal.Instance<infer Configuration, infer _1, infer _2>
+        ? Configuration
+        : unknown;
+
+    type RenderOptionsFor<Instance extends HandlebarsApplication> =
+      Instance extends ApplicationV2.Internal.Instance<infer _1, infer RenderOptions, infer _2>
+        ? RenderOptions
+        : object;
+
+    type RenderContextFor<Instance extends HandlebarsApplication> =
+      Instance extends ApplicationV2.Internal.Instance<infer _1, infer _2, infer RenderContext>
+        ? RenderContext
+        : object;
+  }
+
+  /**
+   * The mixed application class augmented with [Handlebars](https://handlebarsjs.com) template rendering behavior.
+   *
+   * @remarks This does NOT exist at runtime. This is only here to be used as a type when relevant as well as to avoid
+   * issues with anonymous mixin classes.
+   */
+  class HandlebarsApplication {
+    /** @privateRemarks All mixin classses should accept anything for its constructor. */
+    constructor(...args: any[]);
+
+    /**
+     * 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 _preFirstRender(
+      context: DeepPartial<HandlebarsApplication.RenderContextFor<this>>,
+      options: DeepPartial<HandlebarsApplication.RenderOptionsFor<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: HandlebarsApplication.RenderContextFor<this>,
+      options: DeepPartial<HandlebarsApplication.RenderOptionsFor<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: HandlebarsApplication.RenderContextFor<this>,
+      options: DeepPartial<HandlebarsApplicationMixin.RenderOptions>,
+    ): Promise<HandlebarsApplication.RenderContextFor<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<HandlebarsApplication.RenderOptionsFor<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;
   }
 }
 

package/src/foundry/client-esm/applications/apps/_module.d.mts

@@ -1,7 +1,14 @@
 // In Foundry itself this file contains re-exports of these other modules.
 // Therefore it has a runtime effect and uses `.mjs` instead of `.d.mts`.
-// While `.mts` could work, to avoid `import/no-unresolved` from erroring `.mjs` is used.
-/* eslint-disable import/extensions */
+// While `.mts` could work, to avoid `import-x/no-unresolved` from erroring `.mjs` is used.
+/* eslint-disable import-x/extensions */
 
+export * as av from "./av/_module.mjs";
+export { default as CombatTrackerConfig } from "./combat-tracker-config.mjs";
 export { default as CompendiumArtConfig } from "./compendium-art-config.mjs";
+export { default as DocumentOwnershipConfig } from "./document-ownership.mjs";
+export { default as DocumentSheetConfig } from "./document-sheet-config.mjs";
+export { default as FilePicker } from "./file-picker.mjs";
+export { default as GridConfig } from "./grid-config.mjs";
+export { default as ImagePopout } from "./image-popout.mjs";
 export { default as PermissionConfig } from "./permission-config.mjs";

package/src/foundry/client-esm/applications/apps/av/_module.d.mts

@@ -0,0 +1,7 @@
+// In Foundry itself this file contains re-exports of these other modules.
+// Therefore it has a runtime effect and uses `.mjs` instead of `.d.mts`.
+// While `.mts` could work, to avoid `import-x/no-unresolved` from erroring `.mjs` is used.
+/* eslint-disable import-x/extensions */
+
+export { default as CameraPopout } from "./camera-popout.mjs";
+export { default as CameraViews } from "./cameras.mjs";

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

@@ -0,0 +1,23 @@
+import type ApplicationV2 from "../../api/application.d.mts";
+import type HandlebarsApplicationMixin from "../../api/handlebars-application.d.mts";
+
+/**
+ * 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
+    HandlebarsApplicationMixin.ApplicationV2RenderOptions = HandlebarsApplicationMixin.ApplicationV2RenderOptions,
+> extends HandlebarsApplicationMixin(ApplicationV2)<RenderContext, Configuration, RenderOptions> {}
+
+declare namespace CameraPopout {
+  interface Configuration extends ApplicationV2.Configuration {
+    user: User.ConfiguredInstance;
+  }
+
+  interface RenderContext extends ApplicationV2.RenderContext {}
+}
+
+export default CameraPopout;

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

@@ -0,0 +1,95 @@
+import type ApplicationV2 from "../../api/application.d.mts";
+import type HandlebarsApplicationMixin from "../../api/handlebars-application.d.mts";
+
+/**
+ * An application that shows docked camera views.
+ * @remarks TODO: Stub
+ */
+declare class CameraViews<
+  RenderContext extends CameraViews.RenderContext = CameraViews.RenderContext,
+  Configuration extends ApplicationV2.Configuration = ApplicationV2.Configuration,
+  RenderOptions extends
+    HandlebarsApplicationMixin.ApplicationV2RenderOptions = HandlebarsApplicationMixin.ApplicationV2RenderOptions,
+> extends HandlebarsApplicationMixin(ApplicationV2)<RenderContext, Configuration, RenderOptions> {}
+
+declare namespace CameraViews {
+  interface RenderContext extends ApplicationV2.RenderContext {}
+
+  interface ControlContext {
+    icon: string;
+    label: string;
+    display: boolean;
+  }
+
+  interface UserContext {
+    /** The User instance. */
+    user: User;
+
+    /** The user's AV settings. */
+    settings: AVSettingsData;
+
+    /** 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;
+  }
+}
+
+export default CameraViews;

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

@@ -0,0 +1,21 @@
+import type ApplicationV2 from "../api/application.d.mts";
+import type HandlebarsApplicationMixin from "../api/handlebars-application.d.mts";
+
+/**
+ * The Application responsible for configuring the CombatTracker and its contents.
+ * @remarks TODO: Stub
+ */
+declare class CombatTrackerConfig<
+  RenderContext extends CombatTrackerConfig.RenderContext = CombatTrackerConfig.RenderContext,
+  Configuration extends ApplicationV2.Configuration = ApplicationV2.Configuration,
+  RenderOptions extends
+    HandlebarsApplicationMixin.ApplicationV2RenderOptions = HandlebarsApplicationMixin.ApplicationV2RenderOptions,
+> extends HandlebarsApplicationMixin(ApplicationV2)<RenderContext, Configuration, RenderOptions> {}
+
+declare namespace CombatTrackerConfig {
+  interface RenderContext {
+    rootId: string;
+  }
+}
+
+export default CombatTrackerConfig;

package/src/foundry/client-esm/applications/apps/compendium-art-config.d.mts

@@ -1,5 +1,4 @@
-import type { ConformRecord, InterfaceToObject, MustConform } from "../../../../types/helperTypes.d.mts";
-import type { DeepPartial } from "../../../../types/utils.d.mts";
+import type { ConformRecord, InterfaceToObject, MustConform, DeepPartial } from "fvtt-types/utils";
 import type { CompendiumArtDescriptor } from "../../helpers/_types.d.mts";
 import type ApplicationV2 from "../api/application.d.mts";
 import type HandlebarsApplicationMixin from "../api/handlebars-application.d.mts";
@@ -17,7 +16,8 @@ type CompendiumArtConfigParts = ConformRecord<
 declare class CompendiumArtConfig<
   RenderContext extends CompendiumArtConfigRenderContext = CompendiumArtConfigRenderContext,
   Configuration extends ApplicationV2.Configuration = ApplicationV2.Configuration,
-  RenderOptions extends ApplicationV2.RenderOptions = ApplicationV2.RenderOptions,
+  RenderOptions extends
+    HandlebarsApplicationMixin.ApplicationV2RenderOptions = HandlebarsApplicationMixin.ApplicationV2RenderOptions,
 > extends HandlebarsApplicationMixin(ApplicationV2)<RenderContext, Configuration, RenderOptions> {
   // placeholder private member to help subclassing
   #compendiumArtConfig: true;
@@ -29,8 +29,9 @@ declare class CompendiumArtConfig<
   /*  Rendering                                   */
   /* -------------------------------------------- */
 
-  /** @override */
-  override _prepareContext(_options: DeepPartial<ApplicationV2.RenderOptions>): Promise<RenderContext>;
+  override _prepareContext(
+    _options: DeepPartial<HandlebarsApplicationMixin.ApplicationV2RenderOptions>,
+  ): Promise<RenderContext>;
 }
 
 declare namespace CompendiumArtConfig {

package/src/foundry/client-esm/applications/apps/document-ownership.d.mts

@@ -0,0 +1,21 @@
+import type HandlebarsApplicationMixin from "../api/handlebars-application.d.mts";
+import type DocumentSheetV2 from "../api/document-sheet.d.mts";
+
+/**
+ * A generic application for configuring permissions for various Document types.
+ * @remarks TODO: Stub
+ */
+declare class DocumentOwnershipConfig<
+  Document extends foundry.abstract.Document.Any = foundry.abstract.Document.Any,
+  RenderContext extends object = DocumentOwnershipConfig.RenderContext<Document>,
+  Configuration extends DocumentSheetV2.Configuration<Document> = DocumentSheetV2.Configuration<Document>,
+  RenderOptions extends
+    HandlebarsApplicationMixin.DocumentSheetV2RenderOptions = HandlebarsApplicationMixin.DocumentSheetV2RenderOptions,
+> extends HandlebarsApplicationMixin(DocumentSheetV2)<Document, RenderContext, Configuration, RenderOptions> {}
+
+declare namespace DocumentOwnershipConfig {
+  interface RenderContext<Document extends foundry.abstract.Document.Any = foundry.abstract.Document.Any>
+    extends DocumentSheetV2.RenderContext<Document> {}
+}
+
+export default DocumentOwnershipConfig;

package/src/foundry/client-esm/applications/apps/document-sheet-config.d.mts

@@ -0,0 +1,24 @@
+import type DocumentSheetV2 from "../api/document-sheet.d.mts";
+import type HandlebarsApplicationMixin from "../api/handlebars-application.d.mts";
+
+/**
+ * An Application for configuring Document sheet settings.
+ * @remarks TODO: Stub
+ */
+declare class DocumentSheetConfig<
+  Document extends foundry.abstract.Document.Any = foundry.abstract.Document.Any,
+  RenderContext extends DocumentSheetConfig.RenderContext<Document> = DocumentSheetConfig.RenderContext<Document>,
+  Configuration extends DocumentSheetConfig.Configuration<Document> = DocumentSheetConfig.Configuration<Document>,
+  RenderOptions extends
+    HandlebarsApplicationMixin.DocumentSheetV2RenderOptions = HandlebarsApplicationMixin.DocumentSheetV2RenderOptions,
+> extends HandlebarsApplicationMixin(DocumentSheetV2)<Document, RenderContext, Configuration, RenderOptions> {}
+
+declare namespace DocumentSheetConfig {
+  interface RenderContext<Document extends foundry.abstract.Document.Any>
+    extends DocumentSheetV2.RenderContext<Document> {}
+
+  interface Configuration<Document extends foundry.abstract.Document.Any>
+    extends DocumentSheetV2.Configuration<Document> {}
+}
+
+export default DocumentSheetConfig;