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

package/src/foundry/common/packages/base-package.d.mts

@@ -1,6 +1,4 @@
-import type { GetKey } from "../../../types/helperTypes.d.mts";
-import type { AnyObject, InexactPartial } from "../../../types/utils.d.mts";
-// eslint-disable-next-line import/no-named-as-default
+import type { GetKey, AnyObject, InexactPartial, AnyMutableObject, Identity, AnyArray, NullishProps } from "#utils";
 import type DataModel from "../abstract/data.d.mts";
 import type { ReleaseData } from "../config.d.mts";
 import type * as fields from "../data/fields.d.mts";
@@ -8,28 +6,31 @@ import type { DataModelValidationFailure } from "../data/validation-failure.d.mt
 import type { BaseFolder } from "../documents/_module.d.mts";
 import type { LogCompatibilityWarningOptions } from "../utils/logging.d.mts";
 
+type DataSchema = foundry.data.fields.DataSchema;
+
 declare const __BasePackageBrand: unique symbol;
 
 declare const __PackageSchema: unique symbol;
 
 declare namespace BasePackage {
-  type Any = BasePackage<any>;
-
-  type AnyConstructor = typeof AnyBasePackage;
+  interface Any extends AnyBasePackage {}
+  interface AnyConstructor extends Identity<typeof AnyBasePackage> {}
 
   // Documented at https://gist.github.com/LukeAbby/c7420b053d881db4a4d4496b95995c98
   namespace Internal {
-    type Constructor = (abstract new (arg0: never, ...args: never[]) => Instance.Any) & {
+    type Constructor = (abstract new (...args: never) => Instance.Any) & {
       [__BasePackageBrand]: never;
     };
 
-    interface Instance<PackageSchema extends Omit<BasePackage.Schema, "version"> = BasePackage.Schema> {
+    interface Instance<PackageSchema extends BasePackage.Internal.Schema> {
       [__PackageSchema]: PackageSchema;
     }
 
     namespace Instance {
-      type Any = Instance<any>;
+      interface Any extends Instance<BasePackage.Internal.Schema> {}
     }
+
+    interface Schema extends Omit<BasePackage.Schema, "version"> {}
   }
 
   interface OptionalString {
@@ -225,7 +226,8 @@ declare namespace BasePackage {
     reason: fields.StringField<{ required: false; blank: false; initial: undefined }>;
   }
 
-  interface PackageCompendiumFolderSchemaHelper extends DataSchema {
+  /** @internal */
+  interface _PackageCompendiumFolderSchema extends DataSchema {
     name: fields.StringField<{ required: true; blank: false }>;
     sorting: fields.StringField<{
       required: false;
@@ -241,12 +243,12 @@ declare namespace BasePackage {
   type FolderRecursion = [never, 2, 3];
 
   type PackageCompendiumFolderSchema<Depth> = Depth extends number
-    ? PackageCompendiumFolderSchemaHelper & {
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-ignore The recursion works correctly due to helper array. The in-file checker doesn't pick up on this so using ts-ignore
+    ? _PackageCompendiumFolderSchema & {
         folders: fields.SetField<fields.SchemaField<PackageCompendiumFolderSchema<FolderRecursion[Depth]>>>;
       }
-    : PackageCompendiumFolderSchemaHelper;
+    : _PackageCompendiumFolderSchema;
+
+  interface CreateData extends fields.SchemaField.CreateData<Schema> {}
 
   interface Schema extends DataSchema {
     /**
@@ -379,9 +381,22 @@ declare namespace BasePackage {
     hasStorage: boolean;
   }
 
-  interface LogOptions extends InexactPartial<LogCompatibilityWarningOptions> {
+  /** @internal */
+  type _Installed = NullishProps<{
     /** Is the package installed? */
-    installed?: unknown | undefined;
+    installed: boolean;
+  }>;
+
+  interface LogOptions extends _Installed, InexactPartial<LogCompatibilityWarningOptions> {}
+
+  interface MigrateDataOptions extends _Installed {}
+
+  interface CleanDataOptions extends fields.DataField.CleanOptions {
+    /**
+     * Is the package installed?
+     * @remarks Only used to pass on to {@link BasePackage._logWarning | `BasePackage#_logWarning`}
+     */
+    installed?: boolean | null | undefined;
   }
 }
 
@@ -399,7 +414,7 @@ export class PackageRelationships extends fields.SchemaField<BasePackage.Package
   constructor(options: fields.SchemaField.Options<BasePackage.PackageRelationshipsSchema>);
 }
 
-// ommitted private class PackageRelationshipField
+// omitted private class PackageRelationshipField
 
 /**
  * A custom SchemaField for defining a related Package.
@@ -452,9 +467,10 @@ export class CompendiumOwnershipField extends fields.ObjectField<
     validationError: string;
   };
 
+  /** @remarks `options` is unused in `CompendiumOwnershipField` */
   protected override _validateType(
     value: Record<keyof typeof foundry.CONST.USER_ROLES, keyof typeof foundry.CONST.DOCUMENT_OWNERSHIP_LEVELS>,
-    options?: any,
+    options?: fields.DataField.ValidateOptions<this> | null,
   ): boolean | void;
 }
 
@@ -469,23 +485,25 @@ export class PackageCompendiumPacks<
     options?: fields.DataField.CleanOptions,
   ): Set<fields.ArrayField.InitializedElementType<ElementFieldType>>;
 
+  // options: not null (parameter default only)
   override initialize(
     value: fields.ArrayField.PersistedElementType<ElementFieldType>[],
     // In Foundry itself, this field is only used in `BasePackage`, however it should be able to accept any model.
     // NOTE(LukeAbby): This also has been seen in a circularity `Type of property 'packs' circularly references itself in mapped type ...`.
     model: DataModel.Any,
+    options?: fields.DataField.InitializeOptions,
   ):
     | Set<fields.ArrayField.InitializedElementType<ElementFieldType>>
     | (() => Set<fields.ArrayField.InitializedElementType<ElementFieldType>> | null);
 
   protected override _validateElements(
-    value: any[],
-    options?: fields.DataField.ValidationOptions<fields.DataField.Any>,
+    value: AnyArray,
+    options?: fields.DataField.ValidateOptions<fields.DataField.Any>,
   ): void | DataModelValidationFailure;
 
   protected override _validateElement(
-    value: any,
-    options: fields.DataField.ValidationOptions<fields.DataField.Any>,
+    value: unknown,
+    options: fields.DataField.ValidateOptions<fields.DataField.Any>,
   ): void | DataModelValidationFailure;
 }
 
@@ -495,7 +513,7 @@ export class PackageCompendiumPacks<
  */
 declare class BasePackage<
   // BaseWorld alters the definition of `version`
-  PackageSchema extends Omit<BasePackage.Schema, "version"> = BasePackage.Schema,
+  PackageSchema extends BasePackage.Internal.Schema = BasePackage.Schema,
 > extends DataModel<PackageSchema, null> {
   static [__BasePackageBrand]: never;
 
@@ -603,7 +621,7 @@ declare class BasePackage<
    */
   static testDependencyCompatibility(compatibility: PackageCompatibility, dependency: BasePackage): boolean;
 
-  static cleanData(source?: AnyObject, options?: fields.DataField.CleanOptions): AnyObject;
+  static cleanData(source?: AnyObject, options?: BasePackage.CleanDataOptions): AnyMutableObject;
 
   /**
    * Validate that a Package ID is allowed.
@@ -625,12 +643,19 @@ declare class BasePackage<
    */
   static migratedKeys: Set<string>;
 
-  static migrateData(
-    data: AnyObject,
-    logOptions?: InexactPartial<{
-      installed: boolean;
-    }>,
-  ): AnyObject;
+  /**
+   * @remarks
+   * Migrations:
+   * - `name` to `id`, both at root and for any `dependencies` (since v10 until v13)
+   * - `dependencies` to `relationships` (structural change) (since v10 until v13)
+   * - `minimumCoreVersion` and `compatibleCoreVersion` to `compatibility.minimum` and `.verified`, respectively (since v10 until v13)
+   * - Inside `media` entries, `link` to `url` (since v11 until v13)
+   * - Inside `packs` entries:
+   *   - `private` to an `ownership` object with `{PLAYER: "LIMITED", ASSISTANT: "OWNER"}` (since v11 until v13)
+   *   - Slugifies the `name` if not already a valid slug (since v12, until v14)
+   *   - `entity` to `type` (since v9, no specified end)
+   */
+  static override migrateData(data: AnyMutableObject, options?: BasePackage.MigrateDataOptions): AnyMutableObject;
 
   protected static _migrateNameToId(data: AnyObject, logOptions: BasePackage.LogOptions): void;
 
@@ -671,7 +696,7 @@ declare class BasePackage<
 }
 
 declare abstract class AnyBasePackage extends foundry.packages.BasePackage<any> {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }
 
 export default BasePackage;

package/src/foundry/common/packages/base-system.d.mts

@@ -1,69 +1,14 @@
+import type { AnyMutableObject } from "../../../utils/index.d.mts";
+import type DataModel from "../abstract/data.d.mts";
 import type BasePackage from "./base-package.d.mts";
-import type * as fields from "../data/fields.d.mts";
-import type AdditionalTypesField from "./sub-types.d.mts";
 
 declare namespace BaseSystem {
-  interface Schema extends ReturnType<typeof BasePackage.defineSchema> {
-    /**
-     * The current package version
-     * @remarks Actually defined in BasePackage but defined here to avoid conflict with BaseWorld
-     */
-    version: fields.StringField<{ required: true; blank: false; initial: "0" }>;
-
-    /**
-     * Additional document subtypes provided by this system.
-     */
-    documentTypes: AdditionalTypesField;
-
-    /**
-     * A web URL or local file path which provides a default background banner for worlds which are created using this system
-     */
-    background: fields.StringField<{ required: false; blank: false }>;
-
-    /**
-     * A default initiative formula used for this system
-     */
-    initiative: fields.StringField;
-
-    /**
-     * The default grid settings to use for Scenes in this system
-     */
-    grid: fields.SchemaField<{
-      /** A default grid type to use for Scenes in this system */
-      type: fields.NumberField;
-
-      /** A default distance measurement to use for Scenes in this system */
-      distance: fields.NumberField;
-
-      /** A default unit of measure to use for distance measurement in this system */
-      units: fields.StringField;
-
-      /** The default rule used by this system for diagonal measurement on square grids */
-      diagonals: fields.NumberField;
-    }>;
-
-    /**
-     * An Actor data attribute path to use for Token primary resource bars
-     */
-    primaryTokenAttribute: fields.StringField;
-
-    /**
-     * An Actor data attribute path to use for Token secondary resource bars
-     */
-    secondaryTokenAttribute: fields.StringField;
-
-    /**
-     * A default distance measurement to use for Scenes in this system
-     * @deprecated since v12
-     */
-    gridDistance: fields.NumberField;
-
-    /**
-     * A default unit of measure to use for distance measurement in this system
-     * @deprecated since v12
-     */
-    gridUnits: fields.NumberField;
-  }
+  export import Source = System.Source;
+  export import PersistedData = System.Source;
+  export import CreateData = System.CreateData;
+  export import InitializedData = System.InitializedData;
+  export import UpdateData = System.UpdateData;
+  export import Schema = System.Schema;
 }
 
 /**
@@ -85,6 +30,43 @@ declare class BaseSystem extends BasePackage<BaseSystem.Schema> {
    * Does the system template request strict type checking of data compared to template.json inferred types.
    */
   strictDataCleaning: boolean;
+
+  /**
+   * @deprecated since v12, until v14
+   * @remarks "You are accessing `BaseSystem#gridDistance` which has been migrated to {@link BaseSystem.grid | `BaseSystem#grid`}`#distance`"
+   */
+  get gridDistance(): number;
+
+  set gridDistance(number);
+
+  /**
+   * @deprecated since v12, until v14
+   * @remarks "You are accessing `BaseSystem#gridUnits` which has been migrated to {@link BaseSystem.grid | `BaseSystem#grid`}`#units`"
+   */
+  get gridUnits(): number;
+
+  set gridUnits(number);
+
+  /** @remarks Adds `gridDistance` and `gridUnits` to super's */
+  static override migratedKeys: Set<string>;
+
+  /**
+   * @remarks
+   * Migrations:
+   * - {@link BasePackage.migrateData | `BasePackage`}'s
+   * - `gridDistance` to `grid.distance` (since v12, until v14)
+   * - `gridUnits` to `grid.units` (since v12, until v14)
+   */
+  static override migrateData(data: AnyMutableObject, options?: BasePackage.MigrateDataOptions): AnyMutableObject;
+
+  /**
+   * @remarks
+   * Shims:
+   * - `gridDistance` to `grid.distance` (since v12, until v14)
+   * - `gridUnits` to `grid.units` (since v12, until v14)
+   */
+  // options: not null (destructured)
+  static override shimData(data: AnyMutableObject, options?: DataModel.ShimDataOptions): AnyMutableObject;
 }
 
 export default BaseSystem;

package/src/foundry/common/packages/base-world.d.mts

@@ -1,67 +1,14 @@
 import type BasePackage from "./base-package.d.mts";
-import type * as fields from "../data/fields.d.mts";
-import type { AnyObject, InexactPartial, Merge } from "../../../types/utils.d.mts";
+import type { AnyMutableObject, InexactPartial } from "#utils";
 import type { ReleaseData } from "../config.d.mts";
 
-type BaseWorldSchema = Merge<
-  ReturnType<typeof BasePackage.defineSchema>,
-  {
-    /**
-     * The game system name which this world relies upon
-     */
-    system: fields.StringField<{ required: true; blank: false }>;
-
-    /**
-     * A web URL or local file path which provides a background banner image
-     */
-    background: fields.StringField<{ required: false; blank: false }>;
-
-    /**
-     * The theme to use for this world's join page.
-     */
-    joinTheme: fields.StringField<{
-      required: false;
-      initial: undefined;
-      nullable: false;
-      blank: false;
-      choices: typeof foundry.CONST.WORLD_JOIN_THEMES;
-    }>;
-
-    /**
-     * The version of the core software for which this world has been migrated
-     */
-    coreVersion: fields.StringField<{ required: true; blank: false }>;
-
-    /**
-     * The version of the game system for which this world has been migrated
-     */
-    systemVersion: fields.StringField<{ required: true; blank: false; initial: "0" }>;
-
-    lastPlayed: fields.StringField;
-
-    playtime: fields.NumberField<{ integer: true; min: 0; initial: 0 }>;
-
-    /**
-     * An ISO datetime string when the next game session is scheduled to occur
-     */
-    nextSession: fields.StringField<{ blank: false; nullable: true; initial: null }>;
-
-    /**
-     * Should user access keys be reset as part of the next launch?
-     */
-    resetKeys: fields.BooleanField<{ required: false; initial: undefined }>;
-
-    /**
-     * Should the world launch in safe mode?
-     */
-    safeMode: fields.BooleanField<{ required: false; initial: undefined }>;
-
-    version: fields.StringField<{ required: true; blank: false; nullable: true; initial: null }>;
-  }
->;
-
 declare namespace BaseWorld {
-  interface Schema extends BaseWorldSchema {}
+  export import Source = World.Source;
+  export import PersistedData = World.Source;
+  export import CreateData = World.CreateData;
+  export import InitializedData = World.InitializedData;
+  export import UpdateData = World.UpdateData;
+  export import Schema = World.Schema;
 }
 
 /**
@@ -80,7 +27,14 @@ declare class BaseWorld extends BasePackage<BaseWorld.Schema> {
    */
   static icon: string;
 
-  static migrateData(data: AnyObject): AnyObject;
+  /**
+   * @remarks
+   * Migrations:
+   * - Enforces `compatibility` being an object
+   * - `compatibility.maximum === "1.0.0"` to `undefined`
+   * - If `coreVersion` but no `compatibility.verified`, sets both `compatibility.verified` and `.minimum` to `coreVersion`
+   */
+  static migrateData(data: AnyMutableObject): AnyMutableObject;
 
   static testAvailability(
     data: InexactPartial<PackageManifestData>,

package/src/foundry/common/packages/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 */
 
 import type { SchemaField } from "../data/fields.d.mts";
 
@@ -12,17 +12,17 @@ export { default as BaseModule } from "./base-module.mjs";
 export { PackageCompatibility, RelatedPackage } from "./base-package.mjs";
 
 declare global {
-  type PackageAuthorData = SchemaField.InnerAssignmentType<foundry.packages.BasePackage.PackageAuthorSchema>;
+  type PackageAuthorData = SchemaField.AssignmentData<foundry.packages.BasePackage.PackageAuthorSchema>;
 
-  type PackageCompendiumData = SchemaField.InnerAssignmentType<foundry.packages.BasePackage.PackageCompendiumSchema>;
+  type PackageCompendiumData = SchemaField.AssignmentData<foundry.packages.BasePackage.PackageCompendiumSchema>;
 
-  type PackageLanguageData = SchemaField.InnerAssignmentType<foundry.packages.BasePackage.PackageLanguageSchema>;
+  type PackageLanguageData = SchemaField.AssignmentData<foundry.packages.BasePackage.PackageLanguageSchema>;
 
-  type RelatedPackage = SchemaField.InnerAssignmentType<foundry.packages.BasePackage.RelatedPackageSchema>;
+  type RelatedPackage = SchemaField.AssignmentData<foundry.packages.BasePackage.RelatedPackageSchema>;
 
   /*
    * The data structure of a package manifest. This data structure is extended by BasePackage subclasses to add additional
    * type-specific fields.
    */
-  interface PackageManifestData extends SchemaField.InnerAssignmentType<foundry.packages.BasePackage.Schema> {}
+  interface PackageManifestData extends SchemaField.AssignmentData<foundry.packages.BasePackage.Schema> {}
 }

package/src/foundry/common/packages/sub-types.d.mts

@@ -1,11 +1,11 @@
-import type { AnyObject, Merge } from "../../../types/utils.d.mts";
+import type { AnyObject, Merge } from "#utils";
 import type Document from "../abstract/document.d.mts";
 import type { DataField, ObjectField } from "../data/fields.d.mts";
 
 export type DocumentTypesConfiguration = Record<string, Record<string, AnyObject>>;
 
 /**
- * A special [ObjectField]{@link ObjectField} available to packages which configures any additional Document subtypes
+ * A special {@link ObjectField | `ObjectField`} available to packages which configures any additional Document subtypes
  * provided by the package.
  */
 declare class AdditionalTypesField<
@@ -18,9 +18,10 @@ declare class AdditionalTypesField<
 > {
   static get _defaults(): AdditionalTypesField.DefaultOptions;
 
+  // options: not null (parameter default only, despite being unused)
   protected _validateType(
     value: ObjectField.InitializedType<Options>,
-    options?: DataField.ValidationOptions<DataField.Any>,
+    options?: DataField.ValidateOptions<AdditionalTypesField>,
   ): boolean | void;
 }
 
@@ -30,9 +31,6 @@ declare namespace AdditionalTypesField {
   type DefaultOptions = Merge<
     ObjectField.DefaultOptions,
     {
-      // Required is set as false BUT this doesn't work correctly in v11
-      // TODO: Re-enable in v12
-      // required: false;
       readonly: true;
       validationError: "is not a valid sub-types configuration";
     }

package/src/foundry/common/primitives/array.d.mts

@@ -1,4 +1,4 @@
-import type { OverlapsWith } from "../../../types/helperTypes.d.mts";
+import type { OverlapsWith } from "#utils";
 
 declare global {
   namespace Array {
@@ -25,8 +25,8 @@ declare global {
      * @param rule - The rule to partition by
      * @returns An Array of length two whose elements are the partitioned pieces of the original
      */
-    partition<S extends T>(rule: (val: T) => val is S): [Exclude<T, S>[], S[]];
-    partition(rule: (val: T) => boolean): [T[], T[]];
+    partition<S extends T>(/** @immediate */ rule: (val: T) => val is S): [Exclude<T, S>[], S[]];
+    partition(/** @immediate */ rule: (val: T) => boolean): [T[], T[]];
 
     /**
      * Join an Array using a string separator, first filtering out any parts which return a false-y value
@@ -41,7 +41,7 @@ declare global {
      * @param replace - A replacement for the spliced element
      * @returns The replacement element, the removed element, or null if no element was found.
      */
-    findSplice(find: (value: T, index: number, obj: T[]) => boolean, replace?: T): T | null;
+    findSplice(/** @immediate */ find: (value: T, index: number, obj: T[]) => boolean, replace?: T): T | null;
   }
 
   interface ArrayConstructor {

package/src/foundry/common/primitives/math.d.mts

@@ -98,6 +98,12 @@ declare global {
      *                  Its period must be 2π
      * @returns The oscillation according to t. `((maxValue - minValue) * (f(2π * t / p) + 1) / 2) + minValue`
      */
-    oscillation(minVal: number, maxVal: number, t: number, p?: number, func?: (radians: number) => number): number;
+    oscillation(
+      minVal: number,
+      maxVal: number,
+      t: number,
+      p?: number,
+      /** @immediate */ func?: (radians: number) => number,
+    ): number;
   }
 }

package/src/foundry/common/primitives/number.d.mts

@@ -69,7 +69,7 @@ declare global {
 
   interface NumberConstructor {
     /**
-     * @see {@link Number#between}
+     * @see {@link NumberInstance.between | `Number#between`}
      */
     between(num: number, a: number, b: number, inclusive?: boolean): boolean;
 
@@ -86,6 +86,6 @@ declare global {
      * @param n - The value to convert; typically a string, but may already be a number.
      * @returns The number that the string represents, or NaN if no number could be determined.
      */
-    fromString(str: string | number): number;
+    fromString(str: string | number): Number;
   }
 }

package/src/foundry/common/primitives/set.d.mts

@@ -53,53 +53,56 @@ declare global {
 
     /**
      * Test whether every element in this Set satisfies a certain test criterion.
-     * @see {@link Array#every}
+     * @see {@link Array.every | `Array#every`}
      * @param test - The test criterion to apply. Positional arguments are the value, the index of iteration, and the set being tested.
      * @returns Does every element in the set satisfy the test criterion?
      */
-    every(test: (value: T, index: number, set: Set<T>) => boolean): boolean;
+    every(/** @immediate */ test: (value: T, index: number, set: Set<T>) => boolean): boolean;
 
     /**
      * Filter this set to create a subset of elements which satisfy a certain test criterion.
-     * @see {@link Array#filter}
+     * @see {@link Array.filter | `Array#filter`}
      * @param test - The test criterion to apply. Positional arguments are the value, the index of iteration, and the set being filtered.
      * @returns A new Set containing only elements which satisfy the test criterion.
      */
-    filter<F extends T>(test: (value: T, index: number, set: Set<T>) => value is F): Set<F>;
-    filter(test: (value: T, index: number, set: Set<T>) => boolean): Set<T>;
+    filter<F extends T>(/** @immediate */ test: (value: T, index: number, set: Set<T>) => value is F): Set<F>;
+    filter(/** @immediate */ test: (value: T, index: number, set: Set<T>) => boolean): Set<T>;
 
     /**
      * Find the first element in this set which satisfies a certain test criterion.
-     * @see {@link Array#find}
+     * @see {@link Array.find | `Array#find`}
      * @param test - The test criterion to apply. Positional arguments are the value, the index of iteration, and the set being searched.
      * @returns The first element in the set which satisfies the test criterion, or undefined.
      */
-    find<F extends T>(test: (value: T, index: number, set: Set<T>) => value is F): F | undefined;
-    find(test: (value: T, index: number, set: Set<T>) => boolean): T | undefined;
+    find<F extends T>(/** @immediate */ test: (value: T, index: number, set: Set<T>) => value is F): F | undefined;
+    find(/** @immediate */ test: (value: T, index: number, set: Set<T>) => boolean): T | undefined;
 
     /**
      * Create a new Set where every element is modified by a provided transformation function.
-     * @see {@link Array#map}
+     * @see {@link Array.map | `Array#map`}
      * @param transform - The transformation function to apply.Positional arguments are the value, the index of iteration, and the set being transformed.
      * @returns A new Set of equal size containing transformed elements.
      */
-    map<V>(transform: (value: T, index: number, set: Set<T>) => V): Set<V>;
+    map<V>(/** @immediate */ transform: (value: T, index: number, set: Set<T>) => V): Set<V>;
 
     /**
      * Create a new Set with elements that are filtered and transformed by a provided reducer function.
-     * @see {@link Array#reduce}
+     * @see {@link Array.reduce | `Array#reduce`}
      * @param reducer - A reducer function applied to each value. Positional arguments are the accumulator, the value, the index of iteration, and the set being reduced.
      * @param accumulator - The initial value of the returned accumulator.
      * @returns The final value of the accumulator.
      */
-    reduce<V>(reducer: (accumulator: V, value: T, index: number, set: Set<T>) => V, accumulator: V): V;
+    reduce<V>(
+      /** @immediate */ reducer: (accumulator: V, value: T, index: number, set: Set<T>) => V,
+      accumulator: V,
+    ): V;
 
     /**
      * Test whether any element in this Set satisfies a certain test criterion.
-     * @see {@link Array#some}
+     * @see {@link Array.some | `Array#some`}
      * @param test - The test criterion to apply. Positional arguments are the value, the index of iteration, and the set being tested.
      * @returns Does any element in the set satisfy the test criterion?
      */
-    some(test: (value: T, index: number, set: Set<T>) => boolean): boolean;
+    some(/** @immediate */ test: (value: T, index: number, set: Set<T>) => boolean): boolean;
   }
 }

package/src/foundry/common/primitives/string.d.mts

@@ -1,4 +1,4 @@
-import type { Titlecase } from "../../../types/utils.d.mts";
+import type { Titlecase } from "#utils";
 
 declare global {
   interface String {

package/src/foundry/common/prosemirror/_module.d.mts

@@ -1,28 +1,28 @@
 import { EditorState, AllSelection, TextSelection, Plugin, PluginKey } from "prosemirror-state";
 import { EditorView } from "prosemirror-view";
 import { Schema, DOMSerializer } from "prosemirror-model";
-// eslint-disable-next-line import/no-named-as-default
-import type ProseMirrorInputRules from "./input-rules.d.mts";
 import { keymap } from "prosemirror-keymap";
-// eslint-disable-next-line import/no-named-as-default
-import type ProseMirrorKeyMaps from "./keymaps.d.mts";
-// eslint-disable-next-line import/no-named-as-default
-import type ProseMirrorMenu from "./menu.d.mts";
 import "./extensions.d.mts";
 import * as collab from "prosemirror-collab";
-import type { Step } from "prosemirror-transform";
 import type { parseHTMLString, serializeHTMLString } from "./util.d.mts";
 
 // A const is being imported here. It can't be `import type`.
-// eslint-disable-next-line import/extensions
+/* eslint-disable import-x/extensions */
 import { schema as defaultSchema } from "./schema.mjs";
-import type ProseMirrorPlugin from "./plugin.d.mts";
-import type ProseMirrorImagePlugin from "./image-plugin.d.mts";
-import type ProseMirrorDirtyPlugin from "./dirty-plugin.d.mts";
-import type ProseMirrorContentLinkPlugin from "./content-link-plugin.d.mts";
-import type ProseMirrorHighlightMatchesPlugin from "./highlight-matches-plugin.d.mts";
-import type ProseMirrorClickHandler from "./click-handler.d.mts";
-import type DOMParser from "./dom-parser.d.mts";
+
+// and these are classes that are available as properties of ProseMirror
+import ProseMirrorPlugin from "./plugin.mjs";
+import ProseMirrorImagePlugin from "./image-plugin.mjs";
+import ProseMirrorDirtyPlugin from "./dirty-plugin.mjs";
+import ProseMirrorContentLinkPlugin from "./content-link-plugin.mjs";
+import ProseMirrorHighlightMatchesPlugin from "./highlight-matches-plugin.mjs";
+import ProseMirrorClickHandler from "./click-handler.mjs";
+import DOMParser from "./dom-parser.mjs";
+import ProseMirrorInputRules from "./input-rules.mjs";
+import ProseMirrorKeyMaps from "./keymaps.mjs";
+import ProseMirrorMenu from "./menu.mjs";
+import { Step } from "prosemirror-transform";
+/* eslint-enable */
 
 declare const dom: {
   parser: DOMParser;