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

package/src/foundry/client-esm/nue/tours-collection.d.mts

@@ -0,0 +1,25 @@
+import type Tour from "./tour.d.mts";
+
+/**
+ * A singleton Tour Collection class responsible for registering and activating Tours, accessible as game.tours.
+ */
+declare class ToursCollection extends Collection<Tour> {
+  constructor();
+
+  /**
+   * Register a new Tour.
+   * @param namespace - The namespace of the Tour
+   * @param id        - The machine-readable id of the Tour
+   * @param tour      - The constructed Tour
+   */
+  register(namespace: string, id: string, tour: Tour): void;
+
+  /**
+   * Set a Tour to the collection.
+   */
+  set(key: string, tour: Tour): this;
+}
+
+declare namespace ToursCollection {}
+
+export default ToursCollection;

package/src/foundry/client-esm/packages/_module.d.mts

@@ -0,0 +1,22 @@
+// 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-x/no-unresolved` from erroring `.mjs` is used.
+/* eslint-disable import-x/extensions */
+
+import Module from "./module.mjs";
+import System from "./system.mjs";
+import World from "./world.mjs";
+
+export * as types from "./_types.mjs";
+// export * from "@common/packages/_module.mjs";
+export { default as ClientPackageMixin } from "./client-package.mjs";
+export { Module, System, World };
+
+/**
+ * A mapping of allowed package types and the classes which implement them.
+ */
+export const PACKAGE_TYPES: {
+  world: typeof World;
+  system: typeof System;
+  module: typeof Module;
+};

package/src/foundry/client-esm/packages/_types.d.mts

@@ -0,0 +1,11 @@
+// After seeing that none of these types add anything or are even exported a
+// very reasonable question may be: Why on earth does this file exist?
+//
+// Well this is the file in which Foundry defines these types. We don't house
+// them here because it has poor discoverability. The names Foundry has chosen
+// also overlaps with other existing names, such as SettingConfig vs. ClientSetting.SettingConfig
+
+// TODO: Stubs
+export {};
+
+type PackageCompatibilityBadge = unknown;

package/src/foundry/client-esm/packages/client-package.d.mts

@@ -0,0 +1,11 @@
+/**
+ * A client-side mixin used for all Package types.
+ * @param BasePackage - The parent BasePackage class being mixed
+ * @returns A BasePackage subclass mixed with ClientPackage features
+ * @remarks TODO: Stub
+ */
+declare function ClientPackageMixin(): void;
+
+declare namespace ClientPackageMixin {}
+
+export default ClientPackageMixin;

package/src/foundry/client-esm/packages/module.d.mts

@@ -0,0 +1,8 @@
+/**
+ * @remarks TODO: Stub
+ */
+declare class Module {}
+
+declare namespace Module {}
+
+export default Module;

package/src/foundry/client-esm/packages/system.d.mts

@@ -0,0 +1,8 @@
+/**
+ * @remarks TODO: Stub
+ */
+declare class System {}
+
+declare namespace System {}
+
+export default System;

package/src/foundry/client-esm/packages/world.d.mts

@@ -0,0 +1,8 @@
+/**
+ * @remarks TODO: Stub
+ */
+declare class World {}
+
+declare namespace World {}
+
+export default World;

package/src/foundry/client-esm/ui.d.mts

@@ -0,0 +1 @@
+// TODO: This is a set of global UI properties accessible even before `init` as undefined or null

package/src/foundry/client-esm/utils/_module.d.mts

@@ -0,0 +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-x/no-unresolved` from erroring `.mjs` is used.
+/* eslint-disable import-x/extensions */
+
+export * from "@common/utils/_module.mjs";
+export * from "./helpers.mjs";

package/src/foundry/client-esm/utils/_types.d.mts

@@ -0,0 +1,2 @@
+// Only exists to re-export these types
+export * from "@common/utils/_types.mjs";

package/src/foundry/client-esm/utils/helpers.d.mts

@@ -0,0 +1,6 @@
+/**
+ * Clean a provided HTML fragment, closing unbalanced tags and stripping some undesirable properties
+ * @param raw - A raw HTML string
+ * @returns The cleaned HTML content
+ */
+export function cleanHTML(raw: string): string;

package/src/foundry/common/{types.d.mts → _types.d.mts}

@@ -1,5 +1,5 @@
-import type { AnyConcreteConstructor, AnyConstructor, AnyFunction } from "../../types/utils.d.mts";
-import type { Document } from "./abstract/module.d.mts";
+import type { AnyConcreteConstructor, AnyConstructor, AnyFunction } from "fvtt-types/utils";
+import type { Document } from "./abstract/_module.d.mts";
 
 // After seeing that none of these types add anything or are even exported a
 // very reasonable question may be: Why on earth does this file exist?
@@ -45,7 +45,7 @@ type Constructor = new (...args: any[]) => any;
 
 type Point = Canvas.Point;
 
-type PointArray = Canvas.PointArray;
+type PointArray = Canvas.PointTuple;
 
 type Rectangle = Canvas.Rectangle;
 

package/src/foundry/common/abstract/{module.d.mts → _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 DataModel } from "./data.mjs";
 export { default as TypeDataModel } from "./type-data.mjs";

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

@@ -1,5 +1,4 @@
-import type { ConstructorOf, InexactPartial } from "../../../types/utils.d.mts";
-import type BaseUser from "../documents/user.d.mts";
+import type { InexactPartial, FixedInstanceType, LoggingLevels } from "fvtt-types/utils";
 import type Document from "./document.d.mts";
 import type {
   DatabaseCreateOperation,
@@ -8,7 +7,6 @@ import type {
   DatabaseOperation,
   DatabaseUpdateOperation,
 } from "./_types.d.mts";
-import type { LoggingLevels } from "../../../types/helperTypes.d.mts";
 
 /**
  * An abstract base class extended on both the client and server which defines how Documents are retrieved, created,
@@ -22,11 +20,11 @@ declare abstract class DatabaseBackend {
    * @param user          - The requesting User
    * @returns An array of retrieved Document instances or index objects
    */
-  get<T extends Document.Any>(
-    documentClass: ConstructorOf<T>,
+  get<T extends Document.AnyConstructor>(
+    documentClass: T,
     operation: DatabaseGetOperation,
-    user?: BaseUser,
-  ): Promise<T>[];
+    user?: User,
+  ): Promise<FixedInstanceType<T>>[];
 
   /**
    * Retrieve Document instances using the specified operation parameters.
@@ -35,11 +33,11 @@ declare abstract class DatabaseBackend {
    * @param user           - The requesting User
    * @returns An array of retrieved Document instances or index objects
    */
-  protected abstract _getDocuments<T extends Document.Any>(
-    documentClass: ConstructorOf<T>,
+  protected abstract _getDocuments<T extends Document.AnyConstructor>(
+    documentClass: T,
     operation: DatabaseGetOperation,
-    user?: BaseUser,
-  ): Promise<T[]>;
+    user?: User,
+  ): Promise<FixedInstanceType<T>[]>;
 
   /**
    * Create new Documents using provided data and context.
@@ -50,11 +48,11 @@ declare abstract class DatabaseBackend {
    * @param user          - The requesting User
    * @returns An array of created Document instances
    */
-  create<T extends Document.Any>(
-    documentClass: ConstructorOf<T>,
-    operation: DatabaseCreateOperation<T>,
-    user?: BaseUser,
-  ): Promise<T[]>;
+  create<T extends Document.AnyConstructor>(
+    documentClass: T,
+    operation: DatabaseCreateOperation<FixedInstanceType<T>>,
+    user?: User,
+  ): Promise<FixedInstanceType<T>[]>;
 
   /**
    * Create Document instances using provided data and operation parameters.
@@ -63,11 +61,11 @@ declare abstract class DatabaseBackend {
    * @param user          - The requesting User
    * @returns An array of created Document instances
    */
-  protected abstract _createDocuments<T extends Document.Any>(
-    documentClass: ConstructorOf<T>,
-    operation: DatabaseCreateOperation<T>,
-    user?: BaseUser,
-  ): Promise<T[]>;
+  protected abstract _createDocuments<T extends Document.AnyConstructor>(
+    documentClass: T,
+    operation: DatabaseCreateOperation<FixedInstanceType<T>>,
+    user?: User,
+  ): Promise<FixedInstanceType<T>[]>;
 
   /**
    * Update Documents using provided data and context.
@@ -78,11 +76,11 @@ declare abstract class DatabaseBackend {
    * @param user          - The requesting User
    * @returns  An array of updated Document instances
    */
-  update<T extends Document.Any>(
-    documentClass: ConstructorOf<T>,
-    operation: DatabaseUpdateOperation<T>,
-    user?: BaseUser,
-  ): Promise<T[]>;
+  update<T extends Document.AnyConstructor>(
+    documentClass: T,
+    operation: DatabaseUpdateOperation<FixedInstanceType<T>>,
+    user?: User,
+  ): Promise<FixedInstanceType<T>[]>;
 
   /**
    * Update Document instances using provided data and operation parameters.
@@ -91,11 +89,11 @@ declare abstract class DatabaseBackend {
    * @param user          - The requesting User
    * @returns  An array of updated Document instances
    */
-  protected abstract _updateDocuments<T extends Document.Any>(
-    documentClass: ConstructorOf<T>,
-    operation: DatabaseUpdateOperation<T>,
-    user: BaseUser,
-  ): Promise<T[]>;
+  protected abstract _updateDocuments<T extends Document.AnyConstructor>(
+    documentClass: T,
+    operation: DatabaseUpdateOperation<FixedInstanceType<T>>,
+    user: User,
+  ): Promise<FixedInstanceType<T>[]>;
 
   /**
    * Delete Documents using provided ids and context.
@@ -106,11 +104,11 @@ declare abstract class DatabaseBackend {
    * @param user          - The requesting User
    * @returns The deleted Document instances
    */
-  delete<T extends Document.Any>(
-    documentClass: ConstructorOf<T>,
+  delete<T extends Document.AnyConstructor>(
+    documentClass: T,
     operation: DatabaseDeleteOperation,
-    user?: BaseUser,
-  ): Promise<T[]>;
+    user?: User,
+  ): Promise<FixedInstanceType<T>[]>;
 
   /**
    * Delete Document instances using provided ids and operation parameters.
@@ -118,11 +116,11 @@ declare abstract class DatabaseBackend {
    * @param operation     - Parameters of the delete operation
    * @param user          - The requesting User
    */
-  protected abstract _deleteDocuments<T extends Document.Any>(
-    documentClass: ConstructorOf<T>,
+  protected abstract _deleteDocuments<T extends Document.AnyConstructor>(
+    documentClass: T,
     operation: DatabaseDeleteOperation,
-    user: BaseUser,
-  ): Promise<T[]>;
+    user: User,
+  ): Promise<FixedInstanceType<T>[]>;
 
   /**
    * Get the parent Document (if any) associated with a request context.
@@ -180,11 +178,7 @@ declare abstract class DatabaseBackend {
   /**
    * Construct a standardized error message given the context of an attempted operation
    */
-  protected _logError(
-    user: BaseUser,
-    action: string,
-    { parent, pack }?: { parent?: Document.Any; pack?: string },
-  ): string;
+  protected _logError(user: User, action: string, { parent, pack }?: { parent?: Document.Any; pack?: string }): string;
 }
 
 export default DatabaseBackend;

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

@@ -1,39 +1,9 @@
-import type { AnyObject, EmptyObject } from "../../../types/utils.d.mts";
+import type { AnyMutableObject, AnyObject, EmptyObject } from "fvtt-types/utils";
 import type { DataField, SchemaField } from "../data/fields.d.mts";
-import type { fields } from "../data/module.d.mts";
+import type { fields } from "../data/_module.d.mts";
 import type { DataModelValidationFailure } from "../data/validation-failure.d.mts";
 
-declare global {
-  type DataSchema = Record<string, DataField.Any>;
-
-  interface DataValidationOptions {
-    /**
-     * Throw an error if validation fails.
-     * @defaultValue `true`
-     */
-    strict?: boolean | undefined;
-
-    /**
-     * Attempt to replace invalid values with valid defaults?
-     * @defaultValue `false`
-     */
-    fallback?: boolean | undefined;
-
-    /**
-     * Allow partial source data, ignoring absent fields?
-     * @defaultValue `false`
-     */
-    partial?: boolean | undefined;
-
-    /**
-     * If true, invalid embedded documents will emit a warning and be
-     * placed in the invalidDocuments collection rather than causing the
-     * parent to be considered invalid.
-     * @defaultValue `false`
-     */
-    dropInvalidEmbedded?: boolean | undefined;
-  }
-}
+type DataSchema = foundry.data.fields.DataSchema;
 
 declare const DynamicClass: new <_Computed extends object>(arg0: never, ...args: never[]) => _Computed;
 
@@ -52,7 +22,6 @@ export default DataModel;
 declare abstract class DataModel<
   Schema extends DataSchema,
   Parent extends DataModel.Any | null = null,
-
   // eslint-disable-next-line @typescript-eslint/no-empty-object-type
   ExtraConstructorOptions extends AnyObject = {},
 > extends _InternalDataModel<Schema> {
@@ -170,10 +139,7 @@ declare abstract class DataModel<
    * @param context - Context options passed to the data model constructor
    * @returns The cloned Document instance
    */
-  clone(
-    data?: fields.SchemaField.InnerAssignmentType<Schema>,
-    context?: DataModel.ConstructorOptions<Parent>,
-  ): this | Promise<this>;
+  clone(data?: fields.SchemaField.InnerAssignmentType<Schema>, context?: DataModel.DataValidationOptions<Parent>): this;
 
   /**
    * Validate the data contained in the document to check for type and content
@@ -310,14 +276,14 @@ declare abstract class DataModel<
    *                 (default: `true`)
    * @returns The extracted primitive object
    */
-  toObject(source: true): this["_source"];
+  toObject(source: true): fields.SchemaField.InnerPersistedType<Schema>;
   toObject(source?: boolean): ReturnType<this["schema"]["toObject"]>;
 
   /**
    * Extract the source data for the DataModel into a simple object format that can be serialized.
    * @returns The document source data expressed as a plain object
    */
-  toJSON(): this["_source"];
+  toJSON(): fields.SchemaField.InnerPersistedType<Schema>;
 
   /**
    * Create a new instance of this DataModel from a source record.
@@ -331,7 +297,7 @@ declare abstract class DataModel<
     {
       strict,
       ...context
-    }?: DataModel.ConstructorOptions & {
+    }?: DataModel.DataValidationOptions & {
       /**
        * Models created from trusted source data are validated non-strictly
        * @defaultValue `false`
@@ -352,14 +318,14 @@ declare abstract class DataModel<
    * @param source - The candidate source data from which the model will be constructed
    * @returns Migrated source data, if necessary
    */
-  static migrateData(source: AnyObject): AnyObject;
+  static migrateData(source: AnyMutableObject): AnyMutableObject;
 
   /**
    * Wrap data migration in a try/catch which attempts it safely
    * @param source - The candidate source data from which the model will be constructed
    * @returns Migrated source data, if necessary
    */
-  static migrateDataSafe(source: AnyObject): AnyObject;
+  static migrateDataSafe(source: AnyMutableObject): AnyMutableObject;
 
   /**
    * Take data which conforms to the current data schema and add backwards-compatible accessors to it in order to
@@ -387,11 +353,6 @@ declare namespace DataModel {
 
   type ConstructorDataFor<ConcreteDataModel extends DataModel.Any> = ConstructorData<SchemaOf<ConcreteDataModel>>;
 
-  /**
-   * @deprecated {@link DataModel.DataValidationOptions | `DataModel.DataValidationOptions`}
-   */
-  type ConstructorOptions<Parent extends Any | null = null> = DataValidationOptions<Parent>;
-
   interface DataValidationOptions<Parent extends Any | null = null> {
     /**
      * Throw an error if validation fails.
@@ -429,7 +390,7 @@ declare namespace DataModel {
     parent?: Parent | null | undefined;
   }
 
-  type Any = DataModel<DataSchema, any>;
+  type Any = DataModel<DataSchema, DataModel.Any | null, AnyObject>;
 
   type AnyConstructor = typeof AnyDataModel;
 
@@ -439,7 +400,16 @@ declare namespace DataModel {
    */
   type SchemaOf<ModelType extends DataModel.Any> = ModelType["schema"]["fields"];
 
-  type SchemaOfClass<ConcreteClass extends DataModel.AnyConstructor> = SchemaOf<InstanceType<ConcreteClass>>;
+  // Note(LukeAbby): This avoids writing `SchemaOf<InstanceType<ConcreteClass>>` to be robust to an issue with this snippet:
+  // ```ts
+  // EmbeddedDataField<typeof DataModel<{}>> extends SchemaField<infer SubSchema> ? SubSchema : never
+  // ```
+  type SchemaOfClass<ConcreteClass extends DataModel.AnyConstructor> = ConcreteClass extends abstract new (
+    arg0: never,
+    ...args: never[]
+  ) => { schema: { fields: infer Fields extends DataSchema } }
+    ? Fields
+    : never;
 
   interface UpdateOptions {
     dryRun?: boolean;
@@ -453,7 +423,8 @@ declare namespace DataModel {
   }
 }
 
-declare abstract class AnyDataModel extends DataModel<any, any> {
+// This uses `any` because `Schema` and `Parent` are invariant
+declare abstract class AnyDataModel extends DataModel<any, any, AnyObject> {
   constructor(arg0: never, ...args: never[]);
 }