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

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

@@ -1,4 +1,4 @@
-import type { AnyFunction, DeepPartial, EmptyObject } from "../../../../types/utils.d.mts";
+import type { AnyFunction, DeepPartial, EmptyObject, MaybePromise } from "#utils";
 import type ApplicationV2 from "./application.d.mts";
 
 /**
@@ -66,7 +66,7 @@ declare class DialogV2 extends ApplicationV2<EmptyObject, DialogV2.Configuration
 
   protected override _initializeApplicationOptions(
     options: DeepPartial<DialogV2.Configuration>,
-  ): DeepPartial<DialogV2.Configuration>;
+  ): DialogV2.Configuration;
 
   protected override _renderHTML(_context: unknown, _options: ApplicationV2.RenderOptions): Promise<HTMLFormElement>;
 
@@ -125,10 +125,10 @@ declare class DialogV2 extends ApplicationV2<EmptyObject, DialogV2.Configuration
    *             or the value returned by that button's callback. If the dialog was
    *             dismissed, and rejectClose is false, the Promise resolves to null.
    */
-  static prompt<Options extends Partial<DialogV2.WaitOptions>, OKReturn = string>(
+  static prompt<Options extends DeepPartial<DialogV2.WaitOptions>, OKReturn = string>(
     options?: Options & {
       /** Options to overwrite the default confirmation button configuration. */
-      ok?: Partial<DialogV2.Button<OKReturn>>;
+      ok?: DeepPartial<DialogV2.Button<OKReturn>>;
     },
   ): Promise<OKReturn | InferButtonReturnTypes<Options> | InferDismissType<Options>>;
 
@@ -156,7 +156,7 @@ declare class DialogV2 extends ApplicationV2<EmptyObject, DialogV2.Configuration
 }
 
 declare namespace DialogV2 {
-  export interface Button<CallBackReturn> {
+  interface Button<CallbackReturn> {
     /**
      * The button action identifier.
      */
@@ -189,16 +189,16 @@ declare namespace DialogV2 {
      * from this function will be used as the dialog's submitted value.
      * Otherwise, the button's identifier is used.
      */
-    callback?: ButtonCallback<CallBackReturn>;
+    callback?: ButtonCallback<CallbackReturn>;
   }
 
-  export type ButtonCallback<T> = (
+  type ButtonCallback<T> = (
     event: PointerEvent | SubmitEvent,
     button: HTMLButtonElement,
     dialog: HTMLDialogElement,
-  ) => Promise<T>;
+  ) => MaybePromise<T>;
 
-  export interface Configuration extends ApplicationV2.Configuration {
+  interface Configuration extends ApplicationV2.Configuration {
     /**
      * Modal dialogs prevent interaction with the rest of the UI until they
      * are dismissed or submitted.
@@ -208,7 +208,7 @@ declare namespace DialogV2 {
     /**
      * Button configuration.
      */
-    buttons: Button<any>[];
+    buttons: Button<unknown>[];
 
     /**
      * The dialog content.
@@ -224,13 +224,13 @@ declare namespace DialogV2 {
 
   // TODO(LukeAbby): I moved these types over from `_types.d.mts` mostly as-is. However this usage of `any` is suspicious and needs auditing.
 
-  export type RenderCallback = (event: Event, dialog: HTMLDialogElement) => any;
+  type RenderCallback = (event: Event, dialog: HTMLDialogElement) => any;
 
-  export type CloseCallback = (event: Event, dialog: DialogV2) => any;
+  type CloseCallback = (event: Event, dialog: DialogV2) => any;
 
-  export type SubmitCallback = (result: any) => Promise<void>;
+  type SubmitCallback = (result: any) => Promise<void>;
 
-  export interface WaitOptions extends Configuration {
+  interface WaitOptions extends Configuration {
     /**
      * A synchronous function to invoke whenever the dialog is rendered.
      */
@@ -250,19 +250,17 @@ declare namespace DialogV2 {
   }
 }
 
-type InferDismissType<Options extends Partial<DialogV2.WaitOptions>> = Options["rejectClose"] extends boolean
+type InferDismissType<Options extends DeepPartial<DialogV2.WaitOptions>> = Options["rejectClose"] extends boolean
   ? Options["rejectClose"] extends true
     ? never
     : null
   : never;
 
-type InferButtonReturnTypes<Options extends Partial<DialogV2.WaitOptions>> =
-  Options["buttons"] extends Array<infer Button>
-    ? Button extends DialogV2.Button<infer Callback>
-      ? Button["callback"] extends AnyFunction
-        ? Callback
-        : string
-      : never
+type InferButtonReturnTypes<Options extends DeepPartial<DialogV2.WaitOptions>> =
+  Options["buttons"] extends ReadonlyArray<DialogV2.Button<infer Callback>>
+    ? Callback extends AnyFunction
+      ? Callback
+      : string
     : never;
 
 export default DialogV2;

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

@@ -1,17 +1,18 @@
-import type { AnyObject, DeepPartial, EmptyObject } from "../../../../types/utils.d.mts";
+import type { AnyObject, Brand, DeepPartial, EmptyObject, Identity } from "#utils";
 import type ApplicationV2 from "./application.d.mts";
 
 declare namespace DocumentSheetV2 {
-  type Any = DocumentSheetV2<any, any, any, any>;
+  interface Any extends AnyDocumentSheetV2 {}
+  interface AnyConstructor extends Identity<typeof AnyDocumentSheetV2> {}
 
-  type AnyConstructor = typeof AnyDocumentSheetV2;
+  type UnsetDocument = Brand<string, "DocumentSheetV2.UnsetDocument">;
 
-  interface Configuration<Document extends foundry.abstract.Document.Any = foundry.abstract.Document.Any>
+  interface Configuration<Document extends foundry.abstract.Document.Any | UnsetDocument = UnsetDocument>
     extends ApplicationV2.Configuration {
     /**
      * The Document instance associated with this sheet
      */
-    document: Document;
+    document: Document extends foundry.abstract.Document.Any ? Document : foundry.abstract.Document.Any;
 
     /**
      * A permission level in CONST.DOCUMENT_OWNERSHIP_LEVELS
@@ -29,6 +30,18 @@ declare namespace DocumentSheetV2 {
     sheetConfig: boolean;
   }
 
+  type PartialConfiguration<
+    Configuration extends DocumentSheetV2.Configuration<foundry.abstract.Document.Any | UnsetDocument>,
+  > = DeepPartial<Omit<Configuration, "document">> &
+    (Configuration extends DocumentSheetV2.Configuration<infer _ extends foundry.abstract.Document.Any>
+      ? // If a document is already specified in the config, don't allow it to be set in subclasses
+        // because `Object.apply(new Item(...), new Actor(...))` is clearly nonsensical
+        {
+          /** @deprecated Document is not an allowed property in this DocumentSheetV2 subclass */
+          document?: never;
+        }
+      : { document?: foundry.abstract.Document.Any | undefined });
+
   interface RenderOptions extends ApplicationV2.RenderOptions {
     /** A string with the format "\{operation\}\{documentName\}" providing context */
     renderContext: string;
@@ -42,14 +55,17 @@ declare namespace DocumentSheetV2 {
  * The Application class is responsible for rendering an HTMLElement into the Foundry Virtual Tabletop user interface.
  */
 declare class DocumentSheetV2<
-  Document extends foundry.abstract.Document.Any,
+  Document extends foundry.abstract.Document.Any | DocumentSheetV2.UnsetDocument,
   RenderContext extends AnyObject = EmptyObject,
   Configuration extends DocumentSheetV2.Configuration<Document> = DocumentSheetV2.Configuration<Document>,
   RenderOptions extends DocumentSheetV2.RenderOptions = DocumentSheetV2.RenderOptions,
 > extends ApplicationV2<RenderContext, Configuration, RenderOptions> {
-  constructor(options: DeepPartial<Configuration> & { document: Document });
+  // Note(LukeAbby): This is a fix for https://github.com/microsoft/TypeScript/issues/60927
+  constructor(options: DocumentSheetV2.PartialConfiguration<Configuration>);
 
-  static DEFAULT_OPTIONS: DeepPartial<DocumentSheetV2.Configuration>;
+  // 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.
+  static DEFAULT_OPTIONS: DocumentSheetV2.PartialConfiguration<DocumentSheetV2.Configuration> & object;
 
   get document(): Document;
 
@@ -67,9 +83,7 @@ declare class DocumentSheetV2<
    */
   get isEditable(): boolean;
 
-  protected _initializeApplicationOptions(
-    options: DeepPartial<Configuration>,
-  ): DeepPartial<Configuration> & Record<string, unknown>;
+  protected _initializeApplicationOptions(options: DocumentSheetV2.PartialConfiguration<Configuration>): Configuration;
 
   protected override _headerControlsButtons(): Generator<ApplicationV2.HeaderControlsEntry>;
 
@@ -123,5 +137,5 @@ declare class DocumentSheetV2<
 export default DocumentSheetV2;
 
 declare abstract class AnyDocumentSheetV2 extends DocumentSheetV2<any, any, any, any> {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

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 "#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 {
+  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;
   }
 
-  // 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 {
     /**
@@ -168,13 +55,142 @@ declare namespace HandlebarsApplicationMixin {
      * 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[];
 
     /**
      * A registry of forms selectors and submission handlers.
      */
     forms?: Record<string, ApplicationV2.FormConfiguration>;
   }
+
+  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;
+
+    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;
+
+    /**
+     * 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;
+  }
 }
 
 export default HandlebarsApplicationMixin;

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

@@ -1,7 +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/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 { default as CompendiumArtConfig } from "./compendium-art-config.mjs";
 export { default as PermissionConfig } from "./permission-config.mjs";

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

@@ -1,10 +1,7 @@
-import type { ConformRecord, InterfaceToObject, MustConform } from "../../../../types/helperTypes.d.mts";
-import type { DeepPartial } from "../../../../types/utils.d.mts";
-import type { CompendiumArtDescriptor } from "../../helpers/_types.d.mts";
+import type { ConformRecord, InterfaceToObject, MustConform, DeepPartial } from "#utils";
 import type ApplicationV2 from "../api/application.d.mts";
 import type HandlebarsApplicationMixin from "../api/handlebars-application.d.mts";
-
-type CompendiumArtConfigRenderContext = InterfaceToObject<CompendiumArtConfig.RenderContext>;
+import type CompendiumArt from "../../helpers/compendium-art.d.mts";
 
 type CompendiumArtConfigParts = ConformRecord<
   CompendiumArtConfig.Parts,
@@ -15,9 +12,11 @@ type CompendiumArtConfigParts = ConformRecord<
  * An application for configuring compendium art priorities.
  */
 declare class CompendiumArtConfig<
-  RenderContext extends CompendiumArtConfigRenderContext = CompendiumArtConfigRenderContext,
+  RenderContext extends
+    InterfaceToObject<CompendiumArtConfig.RenderContext> = InterfaceToObject<CompendiumArtConfig.RenderContext>,
   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,13 +28,14 @@ declare class CompendiumArtConfig<
   /*  Rendering                                   */
   /* -------------------------------------------- */
 
-  /** @override */
-  override _prepareContext(_options: DeepPartial<ApplicationV2.RenderOptions>): Promise<RenderContext>;
+  override _prepareContext(
+    _options: DeepPartial<HandlebarsApplicationMixin.ApplicationV2RenderOptions>,
+  ): Promise<RenderContext>;
 }
 
 declare namespace CompendiumArtConfig {
   interface RenderContext {
-    config: CompendiumArtDescriptor[];
+    config: CompendiumArt.Descriptor[];
     buttons: ApplicationV2.FormFooterButton[];
   }
 

package/src/foundry/client-esm/applications/apps/permission-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 "#utils";
 import type { UserPermission } from "../../../common/constants.d.mts";
 import type { CONST } from "../../client.d.mts";
 import type ApplicationV2 from "../api/application.d.mts";
@@ -15,7 +14,8 @@ type PermissionConfigParts = ConformRecord<PermissionConfig.Parts, HandlebarsApp
 declare class PermissionConfig<
   RenderContext extends PermissionConfigRenderContext = PermissionConfigRenderContext,
   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
   #permissionConfig: true;

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

@@ -1,6 +1,6 @@
 // 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 { default as RollResolver } from "./roll-resolver.mjs";

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

@@ -1,4 +1,4 @@
-import type { AnyObject, DeepPartial, EmptyObject, InexactPartial } from "../../../../types/utils.d.mts";
+import type { AnyObject, DeepPartial, EmptyObject, Identity, InexactPartial } from "#utils";
 import type ApplicationV2 from "../api/application.d.mts";
 import type HandlebarsApplicationMixin from "../api/handlebars-application.d.mts";
 
@@ -9,7 +9,8 @@ import type HandlebarsApplicationMixin from "../api/handlebars-application.d.mts
 declare class RollResolver<
   RenderContext extends AnyObject = EmptyObject,
   Configuration extends ApplicationV2.Configuration = ApplicationV2.Configuration,
-  RenderOptions extends ApplicationV2.RenderOptions = ApplicationV2.RenderOptions,
+  RenderOptions extends
+    HandlebarsApplicationMixin.ApplicationV2RenderOptions = HandlebarsApplicationMixin.ApplicationV2RenderOptions,
 > extends HandlebarsApplicationMixin(ApplicationV2)<RenderContext, Configuration, RenderOptions> {
   constructor(roll: Roll, options?: DeepPartial<Configuration>);
 
@@ -87,6 +88,9 @@ declare class RollResolver<
 }
 
 declare namespace RollResolver {
+  interface Any extends AnyRollResolver {}
+  interface AnyConstructor extends Identity<typeof AnyRollResolver> {}
+
   interface DiceTermFulfillmentDescriptor {
     id: string;
     term: foundry.dice.terms.DiceTerm;
@@ -95,4 +99,12 @@ declare namespace RollResolver {
   }
 }
 
+declare abstract class AnyRollResolver extends RollResolver<
+  AnyObject,
+  ApplicationV2.Configuration,
+  ApplicationV2.RenderOptions
+> {
+  constructor(...args: never);
+}
+
 export default RollResolver;

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

@@ -1,7 +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/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 { default as AbstractFormInputElement } from "./form-element.mjs";
 export { default as HTMLColorPickerElement } from "./color-picker.mjs";

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

@@ -7,6 +7,8 @@ import type AbstractFormInputElement from "./form-element.d.mts";
 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);

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

@@ -26,7 +26,7 @@ declare class HTMLFilePickerElement extends AbstractFormInputElement<string> {
 
   /**
    * A type of file which can be selected in this field.
-   * @see {@link FilePicker.FILE_TYPES}
+   * @see {@link FilePicker.FILE_TYPES | `FilePicker.FILE_TYPES`}
    */
   get type(): FilePicker.Type;
   set type(value: FilePicker.Type);