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

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,
   ): 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: FieldFilter[];
+      /**
+       * An array of document IDs to exclude from search results
+       * @defaultValue `[]`
+       */
+      exclude: string[];
+    }>,
+  ): ContainedDocument[];
 }
 
 export default EmbeddedCollection;

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,27 @@ import type {
   Merge,
   RemoveIndexSignatures,
   SimpleMerge,
-} from "../../../types/utils.d.mts";
+} from "../../../utils/index.d.mts";
 import type { SchemaField } from "../data/fields.d.mts";
-import type BaseUser from "../documents/user.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;
+
+declare class AnyDataModel extends DataModel<any, any, any> {
+  constructor(...args: any[]);
+}
+
+type StaticDataModel = typeof AnyDataModel;
 
 interface _InternalTypeDataModelInterface extends StaticDataModel {
   new <Schema extends DataSchema, Parent extends Document.Any, _ComputedInstance extends DataModel<Schema, Parent>>(
     ...args: ConstructorParameters<typeof DataModel<Schema, Parent>>
-  ): _ComputedInstance;
+
+    // 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;
@@ -106,6 +115,10 @@ type InnerMerge<U, K extends keyof U, T> = T extends { readonly [_ in K]?: infer
 
 declare namespace TypeDataModel {
   type Any = TypeDataModel<any, any, any, any>;
+  type AnyConstructor = typeof AnyTypeDataModel;
+
+  type ConfigurationFailureInstance = ConfigurationFailure;
+  type ConfigurationFailureClass = typeof ConfigurationFailure;
 
   // Documented at https://gist.github.com/LukeAbby/c7420b053d881db4a4d4496b95995c98
   namespace Internal {
@@ -136,29 +149,30 @@ declare namespace TypeDataModel {
   }
 
   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.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>;
+    }
+  >;
+}
+
+declare abstract class AnyTypeDataModel extends TypeDataModel<any, any, any, any> {
+  constructor(arg0: never, ...args: never[]);
 }
 
 /**
@@ -277,9 +291,9 @@ declare abstract class TypeDataModel<
    * @returns Return false to exclude this Document from the creation operation
    */
   protected _preCreate(
-    data: TypeDataModel.ParentAssignmentType<this>,
+    data: TypeDataModel.ParentAssignmentType<Schema, Parent>,
     options: Document.PreCreateOptions<any>,
-    user: BaseUser,
+    user: User,
   ): Promise<boolean | void>;
 
   /**
@@ -290,7 +304,7 @@ declare abstract class TypeDataModel<
    * @param userId  - The id of the User requesting the document update
    */
   protected _onCreate(
-    data: TypeDataModel.ParentAssignmentType<this>,
+    data: TypeDataModel.ParentAssignmentType<Schema, Parent>,
     options: Document.OnCreateOptions<any>,
     userId: string,
   ): void;
@@ -304,7 +318,7 @@ declare abstract class TypeDataModel<
    * @returns A return value of false indicates the update operation should be cancelled.
    */
   protected _preUpdate(
-    changes: DeepPartial<TypeDataModel.ParentAssignmentType<this>>,
+    changes: DeepPartial<TypeDataModel.ParentAssignmentType<Schema, Parent>>,
     options: Document.PreUpdateOptions<any>,
     userId: string,
   ): Promise<boolean | void>;
@@ -317,7 +331,7 @@ declare abstract class TypeDataModel<
    * @param userId  - The id of the User requesting the document update
    */
   protected _onUpdate(
-    changed: DeepPartial<TypeDataModel.ParentAssignmentType<this>>,
+    changed: DeepPartial<TypeDataModel.ParentAssignmentType<Schema, Parent>>,
     options: Document.OnUpdateOptions<any>,
     userId: string,
   ): void;
@@ -329,7 +343,7 @@ declare abstract class TypeDataModel<
    * @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.PreDeleteOptions<any>, user: User): Promise<boolean | void>;
 
   /**
    * Called by {@link ClientDocument#_onDelete}.
@@ -340,4 +354,6 @@ declare abstract class TypeDataModel<
   protected _onDelete(options: Document.OnDeleteOptions<any>, userId: string): void;
 }
 
+declare class ConfigurationFailure extends TypeDataModel<any, any, any, any> {}
+
 export default TypeDataModel;

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 { AnyObject } from "fvtt-types/utils";
+
+type DataSchema = foundry.data.fields.DataSchema;
 
 declare namespace ApplicationConfiguration {
   interface Schema extends DataSchema {