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

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@league-of-foundry-developers/foundry-vtt-types",
-  "version": "13.345.1-beta.20250704.94554",
+  "version": "13.346.0-beta.20250704112939",
   "description": "TypeScript type definitions for Foundry VTT",
   "type": "module",
   "types": "./src/index.d.mts",

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

@@ -1,7 +1,9 @@
-import type { DeepPartial, EmptyObject, Identity, InexactPartial } from "#utils";
+import type { DeepPartial, Identity } from "#utils";
 import type ApplicationV2 from "../api/application.d.mts";
 import type HandlebarsApplicationMixin from "../api/handlebars-application.d.mts";
 
+import DiceTerm = foundry.dice.terms.DiceTerm;
+
 declare module "#configuration" {
   namespace Hooks {
     interface ApplicationV2Config {
@@ -14,7 +16,7 @@ declare module "#configuration" {
  * An application responsible for handling unfulfilled dice terms in a roll.
  */
 declare class RollResolver<
-  RenderContext extends RollResolver.RenderContext = EmptyObject,
+  RenderContext extends RollResolver.RenderContext = RollResolver.RenderContext,
   Configuration extends RollResolver.Configuration = RollResolver.Configuration,
   RenderOptions extends RollResolver.RenderOptions = RollResolver.RenderOptions,
 > extends HandlebarsApplicationMixin(ApplicationV2)<RenderContext, Configuration, RenderOptions> {
@@ -58,13 +60,7 @@ declare class RollResolver<
   resolveResult(
     term: foundry.dice.terms.DiceTerm,
     method: string,
-    options?: InexactPartial<{
-      /** @defaultValue `false` */
-      reroll: boolean;
-
-      /** @defaultValue `false` */
-      explode: boolean;
-    }>,
+    options?: RollResolver.ResolveResultOptions,
   ): Promise<number | void>;
 
   /**
@@ -102,16 +98,50 @@ declare namespace RollResolver {
   interface Any extends AnyRollResolver {}
   interface AnyConstructor extends Identity<typeof AnyRollResolver> {}
 
-  interface RenderContext extends HandlebarsApplicationMixin.RenderContext, ApplicationV2.RenderContext {}
+  interface RenderContext {
+    formula: string;
+    groups: Record<string, Group>;
+  }
+
   interface Configuration extends HandlebarsApplicationMixin.Configuration, ApplicationV2.Configuration {}
   interface RenderOptions extends HandlebarsApplicationMixin.RenderOptions, ApplicationV2.RenderOptions {}
 
+  interface Group {
+    results: Result[];
+    label: string;
+    icon: string;
+    tooltip: string;
+  }
+
+  interface Result {
+    denomination: DiceTerm.Any;
+    faces: DiceTerm.Any;
+    id: string;
+    method: string;
+    icon: string;
+    exploded: boolean | undefined;
+    rerolled: boolean | undefined;
+    isNew: boolean | undefined;
+    // Note(LukeAbby): The logic here is a bit suspicious.
+    value: string | number;
+    readonly: boolean;
+    disabled: boolean;
+  }
+
   interface DiceTermFulfillmentDescriptor {
     id: string;
-    term: foundry.dice.terms.DiceTerm;
+    term: DiceTerm;
     method: string;
     isNew?: boolean | undefined;
   }
+
+  interface ResolveResultOptions {
+    /** @defaultValue `false` */
+    reroll?: boolean | undefined;
+
+    /** @defaultValue `false` */
+    explode?: boolean | undefined;
+  }
 }
 
 declare abstract class AnyRollResolver extends RollResolver<

package/src/foundry/client/applications/ux/context-menu.d.mts

@@ -48,7 +48,7 @@ declare class ContextMenu<UsesJQuery extends boolean = true> {
     html: HTMLElement | JQuery,
     selector: string,
     menuItems: ContextMenu.Entry<ContextMenu.JQueryOrHTML<UsesJQuery>>[],
-    options: Omit<ContextMenu.CreateOptions<never>, "jQuery"> & { jQuery?: false | undefined },
+    options?: Omit<ContextMenu.CreateOptions<boolean>, "jQuery"> & { jQuery?: boolean | undefined },
   ): ContextMenu<Coalesce<UsesJQuery, true>>;
 
   /**

package/src/foundry/client/documents/active-effect.d.mts

@@ -625,14 +625,12 @@ declare namespace ActiveEffect {
     /**
      * The modification mode with which the change is applied
      * @defaultValue `CONST.ACTIVE_EFFECT_MODES.ADD`
-     * @privateRemarks `undefined` is not actually a possible value, included here due to fvtt-types handling of `initial` values
      */
-    mode: CONST.ACTIVE_EFFECT_MODES | null | undefined;
+    mode: CONST.ACTIVE_EFFECT_MODES;
 
     /**
      * The priority level with which this change is applied
      * @defaultValue `null`
-     * @privateRemarks `undefined` is not actually a possible value, included here due to fvtt-types handling of `initial` values
      */
     priority: number | null | undefined;
   }

package/src/foundry/client/documents/card.d.mts

@@ -508,19 +508,37 @@ declare namespace Card {
   interface CreateDialogOptions extends Document.CreateDialogOptions<Name> {}
 
   /**
-   * @remarks {@link Card.pass | `Card#pass`} calls {@link Cards.pass | `this.parent.pass`} with `action: "pass"` provided
+   * @remarks {@link Card.pass | `Card#pass`} calls {@link Cards.pass | `this.parent.pass`} with `action: "pass"` provided by default.
    */
-  interface PassOptions extends Omit<Cards.PassOptions, "action"> {}
+  interface PassOptions extends Cards.PassOptions {
+    /**
+     * @deprecated While passing `action` is technically valid, it's unclear why this would ever be done.
+     * If you need to do this call `this.parent.pass` directly.
+     */
+    action?: never;
+  }
 
   /**
-   * @remarks {@link Card.play | `Card#play`} calls {@link Cards.pass | `this.parent.pass`} with `action: "play"` provided
+   * @remarks {@link Card.play | `Card#play`} calls {@link Cards.pass | `this.parent.pass`} with `action: "play"` provided by default.
    */
-  interface PlayOptions extends PassOptions {}
+  interface PlayOptions extends Cards.PassOptions {
+    /**
+     * @deprecated While passing `action` is technically valid, it's unclear why this would ever be done.
+     * If you need to do this call `this.parent.pass` directly.
+     */
+    action?: never;
+  }
 
   /**
-   * @remarks {@link Card.discard | `Card#discard`} calls {@link Cards.pass | `this.parent.pass`} with `action: "discard"` provided
+   * @remarks {@link Card.discard | `Card#discard`} calls {@link Cards.pass | `this.parent.pass`} with `action: "discard"` provided by default.
    */
-  interface DiscardOptions extends PassOptions {}
+  interface DiscardOptions extends Cards.PassOptions {
+    /**
+     * @deprecated While passing `action` is technically valid, it's unclear why this would ever be done.
+     * If you need to do this call `this.parent.pass` directly.
+     */
+    action?: never;
+  }
 
   /**
    * The arguments to construct the document.

package/src/foundry/client/documents/macro.d.mts

@@ -502,6 +502,7 @@ declare namespace Macro {
   // just to return `undefined`.
   type ExecuteReturn<SubType extends Macro.SubType> =
     | (SubType extends "chat" ? Promise<ChatMessage.Implementation | undefined | void> : never)
+    // Note(LukeAbby): As of 13.346 this `| void` is only possible if there's a syntax error in the function.
     | (SubType extends "script" ? Promise<unknown> | void : never);
 
   /**

package/src/foundry/common/data/data.d.mts

@@ -452,7 +452,9 @@ declare namespace TextureData {
   /** The parameter defaults for `srcOptions` in the {@link TextureData} constructor */
   interface DefaultOptions {
     categories: ["IMAGE", "VIDEO"];
-    initial: EmptyObject;
+    // Avoid using `EmptyObject` as that creates a broken index signature.
+    // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+    initial: {};
     wildcard: false;
     label: "";
   }

package/src/foundry/common/data/fields.d.mts

@@ -658,7 +658,7 @@ declare namespace DataField {
         : // when not required, undefined can safely be passed
           undefined)
     | ("initial" extends keyof Options
-        ? _Has<Options["initial"], null | undefined> extends true
+        ? _Has<Options["initial"], null | undefined | ((...args: never) => null | undefined)> extends true
           ? never
           : null | undefined // when initial is not `undefined` then `null | undefined` are valid.
         : never);
@@ -673,8 +673,19 @@ declare namespace DataField {
    */
   type DerivedInitializedType<BaseInitializedType, Options extends DataField.Options.Any> =
     | Exclude<BaseInitializedType, null | undefined>
-    | (Options["nullable"] extends true ? null : never)
-    | (Options["required"] extends true ? never : undefined);
+    | _DerivedUndefined<GetKey<Options, "initial", undefined>, GetKey<Options, "required", undefined>>
+    | (Options["nullable"] extends true ? null : never);
+
+  /** @internal */
+  type _DerivedUndefined<Initial, Required extends boolean | undefined> = Required extends true
+    ? never // If `required: true` then `undefined` is not possible.
+    : Initial extends undefined
+      ? undefined // If `required: false` and `initial: undefined` then it passes through.
+      : Initial extends (...args: never) => infer Result
+        ? Result extends undefined
+          ? undefined // Passes through `undefined` if the function returns `undefined`. Should this match the case of `() => unknown`?
+          : never
+        : never;
 
   /**
    * A shorthand for the assignment type of a DataField class.
@@ -1828,7 +1839,10 @@ declare namespace StringField {
    * A helper type for the given options type merged into the default options of the StringField class.
    * @template Options - the options that override the default options
    */
-  type MergedOptions<Options extends StringField.Options<unknown>> = SimpleMerge<
+  type MergedOptions<Options extends StringField.Options<unknown>> = SimpleMerge<DefaultOptions, Options>;
+
+  /** @internal */
+  type _EffectiveOptions<Options extends StringField.Options<unknown>> = SimpleMerge<
     _OptionsForInitial<_OptionsForChoices<Options["choices"]>>,
     Options
   >;
@@ -1877,7 +1891,7 @@ declare namespace StringField {
   // eslint-disable-next-line @typescript-eslint/no-deprecated
   type AssignmentType<Options extends StringField.Options<unknown>> = DataField.DerivedAssignmentType<
     ValidChoice<Options>,
-    MergedOptions<Options>
+    _EffectiveOptions<Options>
   >;
 
   /**
@@ -1887,7 +1901,7 @@ declare namespace StringField {
   type InitializedType<Options extends StringField.Options<unknown>> = DataField.DerivedInitializedType<
     // TODO(LukeAbby): This is a workaround for how `ValidChoice` is defined ignorant of the `StringField`/`NumberField` divide.
     ValidChoice<Options> & (string | null | undefined),
-    MergedOptions<Options>
+    _EffectiveOptions<Options>
   >;
 
   type BaseChoices =

package/src/foundry/common/documents/drawing.d.mts

@@ -24,6 +24,8 @@ declare abstract class BaseDrawing extends Document<"Drawing", BaseDrawing.Schem
    * You should use {@link DrawingDocument.implementation | `new DrawingDocument.implementation(...)`} instead which will give you
    * a system specific implementation of `DrawingDocument`.
    */
+  // Note(LukeAbby): Required because while `DrawingDocument` has no directly required schema
+  // properties the `validateJoint` method will fail.
   constructor(data: DrawingDocument.CreateData, context?: DrawingDocument.ConstructionContext);
 
   /**

package/src/foundry/common/documents/fog-exploration.d.mts

@@ -23,7 +23,7 @@ declare abstract class BaseFogExploration extends Document<"FogExploration", Bas
    * You should use {@link FogExploration.implementation | `new FogExploration.implementation(...)`} instead which will give you
    * a system specific implementation of `FogExploration`.
    */
-  constructor(data: FogExploration.CreateData, context?: FogExploration.ConstructionContext);
+  constructor(data?: FogExploration.CreateData, context?: FogExploration.ConstructionContext);
 
   /**
    * @defaultValue