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

package/src/foundry/common/abstract/embedded-collection-delta.d.mts

@@ -1,4 +1,4 @@
-import type { InexactPartial } from "../../../types/utils.d.mts";
+import type { InexactPartial } from "fvtt-types/utils";
 import type Document from "./document.d.mts";
 import type EmbeddedCollection from "./embedded-collection.d.mts";
 

package/src/foundry/common/abstract/embedded-collection.d.mts

@@ -1,4 +1,4 @@
-import type { ConstructorOf, InexactPartial } from "../../../types/utils.d.mts";
+import type { InexactPartial } from "fvtt-types/utils";
 import type _Collection from "../utils/collection.d.mts";
 import type { DatabaseAction, DatabaseOperation } from "./_types.d.mts";
 import type Document from "./document.d.mts";
@@ -23,19 +23,21 @@ declare const Collection: CollectionConstructor;
  */
 declare class EmbeddedCollection<
   ContainedDocument extends foundry.abstract.Document.Any,
-  ParentDataModel extends foundry.abstract.Document.Any,
+  ParentDocument extends foundry.abstract.Document.Any,
 > extends Collection<ContainedDocument> {
   /**
    * @param name          - The name of this collection in the parent Document.
-   * @param parent        - The parent DataModel instance to which this collection belongs
+   * @param parent        - The parent Document instance to which this collection belongs
    * @param sourceArray   - The source data array for the collection in the parent Document data
+   *
+   * @remarks Foundry documents parent as being a `DataModel` but it actually has to be a `Document`.
    */
-  constructor(name: string, parent: ParentDataModel, sourceArray: ContainedDocument["_source"][]);
+  constructor(name: string, parent: ParentDocument, sourceArray: ContainedDocument["_source"][]);
 
   /**
    * The Document implementation used to construct instances within this collection
    */
-  readonly documentClass: ConstructorOf<ContainedDocument>;
+  readonly documentClass: abstract new (arg0: never, ...args: never) => ContainedDocument;
 
   /**
    * The name of this collection in the parent Document.
@@ -45,7 +47,7 @@ declare class EmbeddedCollection<
   /**
    * The parent DataModel to which this EmbeddedCollection instance belongs.
    */
-  readonly model: ParentDataModel;
+  readonly model: ParentDocument;
 
   /**
    * Has this embedded collection been initialized as a one-time workflow?
@@ -245,8 +247,36 @@ declare class EmbeddedCollection<
     documents: foundry.abstract.Document.Any[],
     result: unknown,
     operation: DatabaseOperation,
-    user: foundry.documents.BaseUser,
+    user: User.Implementation,
   ): void;
+
+  /**
+   * Find all Documents which match a given search term using a full-text search against their indexed HTML fields and their name.
+   * If filters are provided, results are filtered to only those that match the provided values.
+   * @param search   - An object configuring the search
+   *
+   * @remarks This is added in `Game#setupGame` through monkeypatching; `foundry.abstract.EmbeddedCollection.prototype.search = DocumentCollection.prototype.search;`
+   * this technically means it's not set until right after init.
+   */
+  search(
+    search?: InexactPartial<{
+      /**
+       * A case-insensitive search string
+       * @defaultValue `""`
+       */
+      query: string;
+      /**
+       * An array of filters to apply
+       * @defaultValue `[]`
+       */
+      filters: SearchFilter.FieldFilter[];
+      /**
+       * An array of document IDs to exclude from search results
+       * @defaultValue `[]`
+       */
+      exclude: string[];
+    }>,
+  ): ContainedDocument[];
 }
 
 export default EmbeddedCollection;

package/src/foundry/common/abstract/module.d.mts

@@ -1,8 +1,9 @@
 // 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 types from "./_types.mjs";
 export { default as DataModel } from "./data.mjs";
 export { default as TypeDataModel } from "./type-data.mjs";
 export { default as Document } from "./document.mjs";

package/src/foundry/common/abstract/singleton-collection.d.mts

@@ -1,7 +1,7 @@
 import type EmbeddedCollection from "./embedded-collection.d.mts";
 
 /**
- * This class provides a {@link Collection} wrapper around a singleton embedded Document so that it can be interacted
+ * This class provides a {@link Collection | `Collection`} wrapper around a singleton embedded Document so that it can be interacted
  * with via a common interface.
  */
 export default class SingletonEmbeddedCollection<

package/src/foundry/common/abstract/socket.d.mts

@@ -1,4 +1,4 @@
-import type { AnyObject } from "../../../types/utils.d.mts";
+import type { AnyObject } from "fvtt-types/utils";
 import type { DatabaseAction, DatabaseOperation, DocumentSocketRequest } from "./_types.d.mts";
 
 /**

package/src/foundry/common/abstract/type-data.d.mts

@@ -1,5 +1,5 @@
-import type { MustConform } from "../../../types/helperTypes.d.mts";
 import type {
+  MustConform,
   AnyObject,
   EmptyObject,
   DeepPartial,
@@ -7,18 +7,23 @@ import type {
   Merge,
   RemoveIndexSignatures,
   SimpleMerge,
-} from "../../../types/utils.d.mts";
+  Identity,
+} from "fvtt-types/utils";
 import type { SchemaField } from "../data/fields.d.mts";
-import type BaseUser from "../documents/user.d.mts";
+import type { DatabaseCreateOperation, DatabaseDeleteOperation, DatabaseUpdateOperation } from "./_types.d.mts";
 import type { DataModel } from "./data.d.mts";
 import type Document from "./document.d.mts";
 
-type StaticDataModel = typeof DataModel<DataSchema, Document<any, DataSchema, any>>;
+type DataSchema = foundry.data.fields.DataSchema;
 
-interface _InternalTypeDataModelInterface extends StaticDataModel {
-  new <Schema extends DataSchema, Parent extends Document.Any, _ComputedInstance extends DataModel<Schema, Parent>>(
-    ...args: ConstructorParameters<typeof DataModel<Schema, Parent>>
-  ): _ComputedInstance;
+interface _InternalTypeDataModelInterface extends DataModel.AnyConstructor {
+  new <Schema extends DataSchema, Parent extends Document.Any, _ComputedInstance extends object>(
+    ...args: DataModel.ConstructorArgs<Schema, Parent>
+
+    // Note(LukeAbby): This seemingly redundant `DataModel<Schema, Parent>` is to
+    // Ensure that TypeScript allows overriding `protected` methods in subclasses.
+    // See: https://gist.github.com/LukeAbby/b9fd57eeba778a25297721e88b3e6bdd
+  ): DataModel<Schema, Parent> & _ComputedInstance;
 }
 
 declare const _InternalTypeDataModelConst: _InternalTypeDataModelInterface;
@@ -26,18 +31,11 @@ declare const _InternalTypeDataModelConst: _InternalTypeDataModelInterface;
 // @ts-expect-error Ignore the error, this is a workaround for a dynamic class.
 declare class _InternalTypeDataModel<
   Schema extends DataSchema,
-  Parent extends Document<any, DataSchema, any>,
+  Parent extends Document<Document.Type, DataSchema, Document.Any | null>,
   BaseData extends AnyObject = EmptyObject,
   DerivedData extends AnyObject = EmptyObject,
   // This does not work if inlined. It's weird to put it here but it works.
-  _ComputedInstance extends DataModel<Schema, Parent> = SimpleMerge<
-    Merge<RemoveIndexSignatures<BaseData>, RemoveIndexSignatures<DerivedData>>,
-    // The merge is written this way because properties in the data model _cannot_ be allowed to be overridden by the base or derived data.
-    // In theory this could be allowed but it causes a few difficulties.
-    // The fundamental issue is that allowing this would cause subclasses to no longer guaranteed to be valid subtypes.
-    // A particularly thorny but not fully fundamental issue is that it also causes difficulties with `this` inside of classes generic over `BaseData`.
-    DataModel<Schema, Parent>
-  >,
+  _ComputedInstance extends object = Merge<RemoveIndexSignatures<BaseData>, RemoveIndexSignatures<DerivedData>>,
 > extends _InternalTypeDataModelConst<Schema, Parent, _ComputedInstance> {}
 
 declare const __TypeDataModelBrand: unique symbol;
@@ -105,14 +103,15 @@ type InnerMerge<U, K extends keyof U, T> = T extends { readonly [_ in K]?: infer
   : U[K];
 
 declare namespace TypeDataModel {
-  type Any = TypeDataModel<any, any, any, any>;
+  interface Any extends AnyTypeDataModel {}
+  interface AnyConstructor extends Identity<typeof AnyTypeDataModel> {}
 
-  type ConfigurationFailure = InstanceType<ConfigurationFailureClass>;
+  type ConfigurationFailureInstance = ConfigurationFailure;
   type ConfigurationFailureClass = typeof ConfigurationFailure;
 
   // 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) & {
       [__TypeDataModelBrand]: never;
     };
 
@@ -134,34 +133,35 @@ declare namespace TypeDataModel {
     }
 
     namespace Instance {
-      type Any = Instance<any, any, any, any, any>;
+      interface Any extends Instance<any, any, any, any, any> {}
     }
   }
 
   type PrepareBaseDataThis<BaseThis extends Internal.Instance.Any> =
-    BaseThis extends Internal.Instance<any, any, infer BaseModel, infer BaseData, infer DerivedData>
+    BaseThis extends Internal.Instance<infer _1, infer _2, infer BaseModel, infer BaseData, infer DerivedData>
       ? MergePartial<Omit<RemoveDerived<BaseThis, BaseModel, BaseData, DerivedData>, "prepareBaseData">, BaseData>
       : never;
 
   type PrepareDerivedDataThis<BaseThis extends Internal.Instance.Any> =
-    BaseThis extends Internal.Instance<any, any, infer BaseModel, infer BaseData, infer DerivedData>
+    BaseThis extends Internal.Instance<infer _1, infer _2, infer BaseModel, infer BaseData, infer DerivedData>
       ? MergePartial<
           SimpleMerge<Omit<RemoveDerived<BaseThis, BaseModel, BaseData, DerivedData>, "prepareDerivedData">, BaseData>,
           DerivedData
         >
       : never;
 
-  type ParentAssignmentType<BaseThis extends Internal.Instance.Any> =
-    BaseThis extends Internal.Instance<infer Schema, infer Parent, any, any, any>
-      ? SimpleMerge<
-          SchemaField.InitializedType<Document.SchemaFor<Parent>>,
-          {
-            // FIXME(LukeAbby): Callers handle making this partial when obvious.
-            // However also should make system partial using the regular rules: if `initial` is assignable to the field or if `required` is false etc.
-            system: SchemaField.InitializedType<Schema>;
-          }
-        >
-      : never;
+  type ParentAssignmentType<Schema extends DataSchema, Parent extends Document.Internal.Instance.Any> = SimpleMerge<
+    SchemaField.InitializedData<Document.SchemaFor<Parent>>,
+    {
+      // FIXME(LukeAbby): Callers handle making this partial when obvious.
+      // However also should make system partial using the regular rules: if `initial` is assignable to the field or if `required` is false etc.
+      system: SchemaField.InitializedData<Schema>;
+    }
+  >;
+}
+
+declare abstract class AnyTypeDataModel extends TypeDataModel<any, any, any, any> {
+  constructor(...args: never);
 }
 
 /**
@@ -244,15 +244,15 @@ declare abstract class TypeDataModel<
   /**
    * Prepare data related to this DataModel itself, before any derived data is computed.
    *
-   * Called before {@link ClientDocument#prepareBaseData} in {@link ClientDocument#prepareData}.
-   * */
+   * Called before {@link ClientDocument.prepareBaseData | `ClientDocument#prepareBaseData`} in {@link ClientDocument.prepareData | `ClientDocument#prepareData`}.
+   */
   prepareBaseData(this: TypeDataModel.PrepareBaseDataThis<this>): void;
 
   /**
    * Apply transformations of derivations to the values of the source data object.
    * Compute data fields whose values are not stored to the database.
    *
-   * Called before {@link ClientDocument#prepareDerivedData} in {@link ClientDocument#prepareData}.
+   * Called before {@link ClientDocument.prepareDerivedData | `ClientDocument#prepareDerivedData`} in {@link ClientDocument.prepareData | `ClientDocument#prepareData`}.
    */
   prepareDerivedData(this: TypeDataModel.PrepareDerivedDataThis<this>): void;
 
@@ -272,7 +272,7 @@ declare abstract class TypeDataModel<
   /* -------------------------------------------- */
 
   /**
-   * Called by {@link ClientDocument#_preCreate}.
+   * Called by {@link ClientDocument._preCreate | `ClientDocument#_preCreate`}.
    *
    * @param data    - The initial data object provided to the document creation request
    * @param options - Additional options which modify the creation request
@@ -280,26 +280,26 @@ declare abstract class TypeDataModel<
    * @returns Return false to exclude this Document from the creation operation
    */
   protected _preCreate(
-    data: TypeDataModel.ParentAssignmentType<this>,
-    options: Document.PreCreateOptions<any>,
-    user: BaseUser,
+    data: TypeDataModel.ParentAssignmentType<Schema, Parent>,
+    options: Document.Database.PreCreateOptions<DatabaseCreateOperation>,
+    user: User.Implementation,
   ): Promise<boolean | void>;
 
   /**
-   * Called by {@link ClientDocument#_onCreate}.
+   * Called by {@link ClientDocument._onCreate | `ClientDocument#_onCreate`}.
    *
    * @param data    - The initial data object provided to the document creation request
    * @param options - Additional options which modify the creation request
    * @param userId  - The id of the User requesting the document update
    */
   protected _onCreate(
-    data: TypeDataModel.ParentAssignmentType<this>,
-    options: Document.OnCreateOptions<any>,
+    data: TypeDataModel.ParentAssignmentType<Schema, Parent>,
+    options: Document.Database.CreateOptions<DatabaseCreateOperation>,
     userId: string,
   ): void;
 
   /**
-   * Called by {@link ClientDocument#_preUpdate}.
+   * Called by {@link ClientDocument._preUpdate | `ClientDocument#_preUpdate`}.
    *
    * @param changes - The candidate changes to the Document
    * @param options - Additional options which modify the update request
@@ -307,40 +307,43 @@ declare abstract class TypeDataModel<
    * @returns A return value of false indicates the update operation should be cancelled.
    */
   protected _preUpdate(
-    changes: DeepPartial<TypeDataModel.ParentAssignmentType<this>>,
-    options: Document.PreUpdateOptions<any>,
-    userId: string,
+    changes: DeepPartial<TypeDataModel.ParentAssignmentType<Schema, Parent>>,
+    options: Document.Database.PreUpdateOptions<DatabaseUpdateOperation>,
+    user: User.Implementation,
   ): Promise<boolean | void>;
 
   /**
-   * Called by {@link ClientDocument#_onUpdate}.
+   * Called by {@link ClientDocument._onUpdate | `ClientDocument#_onUpdate`}.
    *
    * @param changed - The differential data that was changed relative to the documents prior values
    * @param options - Additional options which modify the update request
    * @param userId  - The id of the User requesting the document update
    */
   protected _onUpdate(
-    changed: DeepPartial<TypeDataModel.ParentAssignmentType<this>>,
-    options: Document.OnUpdateOptions<any>,
+    changed: DeepPartial<TypeDataModel.ParentAssignmentType<Schema, Parent>>,
+    options: Document.Database.UpdateOptions<DatabaseUpdateOperation>,
     userId: string,
   ): void;
 
   /**
-   * Called by {@link ClientDocument#_preDelete}.
+   * Called by {@link ClientDocument._preDelete | `ClientDocument#_preDelete`}.
    *
    * @param options - Additional options which modify the deletion request
    * @param user    - The User requesting the document deletion
    * @returns A return value of false indicates the deletion operation should be cancelled.
    */
-  protected _preDelete(options: Document.PreDeleteOptions<any>, user: BaseUser): Promise<boolean | void>;
+  protected _preDelete(
+    options: Document.Database.PreDeleteOperationInstance<DatabaseDeleteOperation>,
+    user: User.Implementation,
+  ): Promise<boolean | void>;
 
   /**
-   * Called by {@link ClientDocument#_onDelete}.
+   * Called by {@link ClientDocument._onDelete | `ClientDocument#_onDelete`}.
    *
    * @param options - Additional options which modify the deletion request
    * @param userId  - The id of the User requesting the document update
    */
-  protected _onDelete(options: Document.OnDeleteOptions<any>, userId: string): void;
+  protected _onDelete(options: Document.Database.DeleteOptions<DatabaseDeleteOperation>, userId: string): void;
 }
 
 declare class ConfigurationFailure extends TypeDataModel<any, any, any, any> {}

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

@@ -1,7 +1,9 @@
 import type { DataModel } from "./abstract/data.d.mts";
 import type * as fields from "./data/fields.d.mts";
 import type { SOFTWARE_UPDATE_CHANNELS } from "./constants.d.mts";
-import type { AnyObject } from "../../types/utils.d.mts";
+import type { AnyMutableObject } from "fvtt-types/utils";
+
+type DataSchema = foundry.data.fields.DataSchema;
 
 declare namespace ApplicationConfiguration {
   interface Schema extends DataSchema {
@@ -191,7 +193,7 @@ declare namespace ApplicationConfiguration {
 declare class ApplicationConfiguration extends DataModel<ApplicationConfiguration.Schema> {
   static defineSchema(): ApplicationConfiguration.Schema;
 
-  static override migrateData(source: AnyObject): AnyObject;
+  static override migrateData(source: AnyMutableObject): AnyMutableObject;
 
   /**
    * Validate a port assignment.
@@ -222,7 +224,7 @@ declare namespace ReleaseData {
       nullable: false;
       integer: true;
       min: 1;
-      // initial: () => fields.SchemaField.InnerInitializedType<Schema["generation"]>;
+      // initial: () => fields.SchemaField.InitializedData<Schema["generation"]>;
     }>;
 
     /**