@league-of-foundry-developers/foundry-vtt-types 9.280.0 → 12.331.1-beta

package/src/foundry/common/documents/actor-delta.d.mts

@@ -0,0 +1,132 @@
+import type { AnyObject, InexactPartial, Merge } from "../../../types/utils.d.mts";
+import type Document from "../abstract/document.mts";
+import type { fields } from "../data/module.d.mts";
+import type { CONST, documents } from "../../client-esm/client.d.mts";
+
+/**
+ * The Document definition for an ActorDelta.
+ * Defines the DataSchema and common behaviors for an ActorDelta which are shared between both client and server.
+ * ActorDeltas store a delta that can be applied to a particular Actor in order to produce a new Actor.
+ */
+// Note(LukeAbby): You may wonder why documents don't simply pass the `Parent` generic parameter.
+// This pattern evolved from trying to avoid circular loops and even internal tsc errors.
+// See: https://gist.github.com/LukeAbby/0d01b6e20ef19ebc304d7d18cef9cc21
+declare class BaseActorDelta extends Document<BaseActorDelta.Schema, BaseActorDelta.Metadata, any> {
+  // TODO(LukeAbby): This constructor is a symptom of a circular error.
+  // constructor(data?: BaseActorDelta.ConstructorData, context?: Document.ConstructionContext<BaseActorDelta.Parent>);
+
+  override parent: BaseActorDelta.Parent;
+
+  override _source: BaseActorDelta.Source;
+
+  static override metadata: Readonly<BaseActorDelta.Metadata>;
+
+  static override defineSchema(): BaseActorDelta.Schema;
+
+  override canUserModify(user: documents.BaseUser, action: "create" | "update" | "delete", data?: AnyObject): boolean;
+
+  override testUserPermission(
+    user: documents.BaseUser,
+    permission: keyof typeof CONST.DOCUMENT_OWNERSHIP_LEVELS | CONST.DOCUMENT_OWNERSHIP_LEVELS,
+    options?: InexactPartial<{
+      /**
+       * Require the exact permission level requested?
+       * @defaultValue `false`
+       */
+      exact: boolean;
+    }>,
+  ): boolean;
+
+  /**
+   * Retrieve the base actor's collection, if it exists.
+   * @param collectionName - The collection name.
+   */
+  getBaseCollection(collectionName: string): Collection<Actor> | undefined;
+
+  static applyDelta(
+    delta: BaseActorDelta,
+    baseActor: documents.BaseActor,
+    context: unknown,
+  ): Document.ConfiguredClassForName<"Actor"> | null;
+
+  //TODO: Figure out if this override still applies
+  toObject(source: true): this["_source"];
+  toObject(source?: boolean): ReturnType<this["schema"]["toObject"]>;
+}
+
+export default BaseActorDelta;
+
+declare namespace BaseActorDelta {
+  type Parent = TokenDocument.ConfiguredInstance | null;
+
+  // Note that in places like CONFIG the only eligible type is "base"
+  type TypeNames = fields.TypeDataField.TypeNames<typeof documents.BaseActor>;
+  type SchemaField = fields.SchemaField<Schema>;
+  type ConstructorData = fields.SchemaField.InnerConstructorType<Schema>;
+  type UpdateData = fields.SchemaField.InnerAssignmentType<Schema>;
+  type Properties = fields.SchemaField.InnerInitializedType<Schema>;
+  type Source = fields.SchemaField.InnerPersistedType<Schema>;
+
+  type Metadata = Merge<
+    Document.Metadata.Default,
+    {
+      name: "ActorDelta";
+      collection: "delta";
+      label: string;
+      labelPlural: string;
+      isEmbedded: true;
+      embedded: {
+        Item: "items";
+        ActiveEffect: "effects";
+      };
+      schemaVersion: string;
+    }
+  >;
+
+  interface Schema<TypeName extends TypeNames = TypeNames> extends DataSchema {
+    /**
+     * The _id which uniquely identifies this ActorDelta document.
+     */
+    _id: fields.DocumentIdField;
+
+    /**
+     * The name override, if any.
+     */
+    name: fields.StringField<{ required: false; nullable: true; initial: null }>;
+
+    /**
+     * The type override, if any.
+     */
+    type: fields.StringField<{ required: false; nullable: true; initial: null }, TypeName, TypeName, TypeName>;
+
+    /**
+     * The image override, if any.
+     */
+    img: fields.FilePathField<{ categories: ["IMAGE"]; nullable: true; initial: null; required: false }>;
+
+    /**
+     * The system data model override.
+     */
+    system: fields.ObjectField;
+
+    /**
+     * An array of embedded item data overrides.
+     */
+    items: fields.EmbeddedCollectionDeltaField<typeof documents.BaseItem, ActorDelta.ConfiguredInstance>;
+
+    /**
+     * An array of embedded active effect data overrides.
+     */
+    effects: fields.EmbeddedCollectionDeltaField<typeof documents.BaseActiveEffect, ActorDelta.ConfiguredInstance>;
+
+    /**
+     * Ownership overrides.
+     */
+    ownership: fields.DocumentOwnershipField<{ required: false; nullable: true; initial: null }>;
+
+    /**
+     * An object of actor flag overrides.
+     */
+    flags: fields.ObjectField.FlagsField<"Actor">;
+  }
+}

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

@@ -0,0 +1,209 @@
+import type { AnyObject, Merge } from "../../../types/utils.mts";
+import type Document from "../abstract/document.mts";
+import type { PrototypeToken } from "../data/data.mts";
+import type * as fields from "../data/fields.d.mts";
+import type * as documents from "./_module.d.mts";
+
+declare namespace BaseActor {
+  type Parent = null;
+
+  type TypeNames = fields.TypeDataField.TypeNames<typeof BaseActor>;
+
+  type Metadata = Merge<
+    Document.Metadata.Default,
+    {
+      name: "Actor";
+      collection: "actors";
+      indexed: true;
+      compendiumIndexFields: ["_id", "name", "img", "type", "sort", "folder"];
+      embedded: { ActiveEffect: "effects"; Item: "items" };
+      label: string;
+      labelPlural: string;
+      permissions: {
+        create: (user: documents.BaseUser, doc: Document.Any) => boolean;
+        update: (user: documents.BaseUser, doc: Document.Any, data: UpdateData) => boolean;
+      };
+      schemaVersion: string;
+
+      /**
+       * @deprecated since v10, BaseActor.metadata.types is deprecated since v10 in favor of BaseActor.TYPES.
+       */
+      types: typeof BaseActor.TYPES;
+    }
+  >;
+
+  type SchemaField = fields.SchemaField<Schema>;
+  type ConstructorData = fields.SchemaField.InnerConstructorType<Schema>;
+  type UpdateData = fields.SchemaField.InnerAssignmentType<Schema>;
+  type Properties = fields.SchemaField.InnerInitializedType<Schema>;
+  type Source = fields.SchemaField.InnerPersistedType<Schema>;
+
+  interface Schema<TypeName extends TypeNames = TypeNames> extends DataSchema {
+    /**
+     * The _id which uniquely identifies this Actor document
+     * @defaultValue `null`
+     */
+    _id: fields.DocumentIdField;
+
+    /** The name of this Actor */
+    name: fields.StringField<{ required: true; blank: false; textSearch: true }>;
+
+    /** An Actor subtype which configures the system data model applied */
+    type: fields.StringField<
+      {
+        required: true;
+        choices: () => typeof BaseActor.TYPES;
+        validationError: "must be in the array of Actor types defined by the game system";
+      },
+      TypeName,
+      TypeName,
+      TypeName
+    >;
+
+    /**
+     * An image file path which provides the artwork for this Actor
+     * @defaultValue `null`
+     */
+    img: fields.FilePathField<{ categories: "IMAGE"[]; initial: () => typeof BaseActor.DEFAULT_ICON }>;
+
+    /**
+     * The system data object which is defined by the system template.json model
+     * @defaultValue `{}`
+     */
+    system: fields.TypeDataField<typeof BaseActor>;
+
+    /**
+     * Default Token settings which are used for Tokens created from this Actor
+     * @defaultValue see {@link PrototypeToken}
+     */
+    prototypeToken: fields.EmbeddedDataField<PrototypeToken>;
+
+    /**
+     * A Collection of Item embedded Documents
+     * @defaultValue `[]`
+     */
+    items: fields.EmbeddedCollectionField<typeof documents.BaseItem, Actor.ConfiguredInstance>;
+
+    /**
+     * A Collection of ActiveEffect embedded Documents
+     * @defaultValue `[]`
+     */
+    effects: fields.EmbeddedCollectionField<typeof documents.BaseActiveEffect, Actor.ConfiguredInstance>;
+
+    /**
+     * The _id of a Folder which contains this Actor
+     * @defaultValue `null`
+     */
+    folder: fields.ForeignDocumentField<documents.BaseFolder>;
+
+    /**
+     * The numeric sort value which orders this Actor relative to its siblings
+     * @defaultValue `0`
+     */
+    sort: fields.IntegerSortField;
+
+    /**
+     * An object which configures ownership of this Actor
+     * @defaultValue `{ default: DOCUMENT_OWNERSHIP_LEVELS.NONE }`
+     */
+    ownership: fields.DocumentOwnershipField;
+
+    /**
+     * An object of optional key/value flags
+     * @defaultValue `{}`
+     */
+    flags: fields.ObjectField.FlagsField<"Actor">;
+
+    /**
+     * An object of creation and access information
+     * @defaultValue see {@link fields.DocumentStatsField}
+     */
+    _stats: fields.DocumentStatsField;
+  }
+}
+
+/**
+ * The Document definition for an Actor.
+ * Defines the DataSchema and common behaviors for an Actor which are shared between both client and server.
+ */
+// Note(LukeAbby): You may wonder why documents don't simply pass the `Parent` generic parameter.
+// This pattern evolved from trying to avoid circular loops and even internal tsc errors.
+// See: https://gist.github.com/LukeAbby/0d01b6e20ef19ebc304d7d18cef9cc21
+declare class BaseActor extends Document<BaseActor.Schema, BaseActor.Metadata, any> {
+  /**
+   * @param data    - Initial data from which to construct the Actor
+   * @param context - Construction context options
+   */
+  // TODO(LukeAbby): This constructor is causing a circular error.
+  // constructor(data: BaseActor.ConstructorData, context?: Document.ConstructionContext<BaseActor.Parent>);
+
+  override parent: BaseActor.Parent;
+
+  static override metadata: Readonly<BaseActor.Metadata>;
+
+  static override defineSchema(): BaseActor.Schema;
+
+  /**
+   * The default icon used for newly created Actor documents.
+   * @defaultValue `CONST.DEFAULT_TOKEN`
+   */
+  static DEFAULT_ICON: string;
+
+  /**
+   * Determine default artwork based on the provided actor data
+   * @param actorData - The source actor data
+   */
+  static getDefaultArtwork(actorData: BaseActor.ConstructorData): {
+    img: string;
+    texture: { src: string };
+  };
+
+  /**
+   * The allowed set of Actor types which may exist.
+   */
+  static get TYPES(): BaseActor.TypeNames[];
+
+  protected override _initializeSource(
+    data: fields.SchemaField.InnerAssignmentType<documents.BaseActor.Schema> | this,
+    options?: any,
+  ): fields.SchemaField.InnerPersistedType<documents.BaseActor.Schema>;
+
+  static override canUserCreate(user: documents.BaseUser): boolean;
+
+  /**
+   * Is a user able to create this actor?
+   * @param user - The user attempting the creation operation.
+   * @param doc  - The Actor being created.
+   * @internal
+   */
+  static #canCreate(user: documents.BaseUser, doc: BaseActor): boolean;
+
+  /**
+   * Is a user able to update an existing actor?
+   * @param user - The user attempting the update operation.
+   * @param doc  - The Actor being updated.
+   * @param data - The update delta being applied.
+   * @internal
+   */
+  static #canUpdate(user: documents.BaseUser, doc: BaseActor, data: BaseActor.UpdateData): boolean;
+
+  /**
+   * @privateRemarks _preCreate and _preUpdate are overridden but with no signature changes.
+   * For type simplicity they are left off. These methods historically have been the source of a large amount of computation from tsc.
+   */
+
+  static override migrateData(source: AnyObject): AnyObject;
+
+  static override shimData(
+    data: AnyObject,
+    options?: {
+      /**
+       * Apply shims to embedded models?
+       * @defaultValue `true`
+       */
+      embedded?: boolean;
+    },
+  ): AnyObject;
+}
+
+export default BaseActor;

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

@@ -0,0 +1,212 @@
+import type { AnyObject, Merge } from "../../../types/utils.mts";
+import type { DataModel } from "../abstract/data.mts";
+import type Document from "../abstract/document.mts";
+import type * as fields from "../data/fields.d.mts";
+
+/**
+ * The Document definition for an Adventure.
+ * Defines the DataSchema and common behaviors for an Adventure which are shared between both client and server.
+ */
+// Note(LukeAbby): You may wonder why documents don't simply pass the `Parent` generic parameter.
+// This pattern evolved from trying to avoid circular loops and even internal tsc errors.
+// See: https://gist.github.com/LukeAbby/0d01b6e20ef19ebc304d7d18cef9cc21
+declare class BaseAdventure extends Document<BaseAdventure.Schema, BaseAdventure.Metadata, any> {
+  /**
+   * @param data    - Initial data from which to construct the Actor
+   * @param context - Construction context options
+   */
+  // TODO(LukeAbby): This constructor is a symptom of a circular error.
+  // constructor(data: BaseAdventure.ConstructorData, context?: Document.ConstructionContext<BaseAdventure.Parent>);
+
+  override parent: BaseAdventure.Parent;
+
+  static override metadata: Readonly<BaseAdventure.Metadata>;
+
+  static override defineSchema(): BaseAdventure.Schema;
+
+  /**
+   * An array of the fields which provide imported content from the Adventure.
+   */
+  static get contentFields(): BaseAdventure.ContentFields;
+
+  /**
+   * Provide a thumbnail image path used to represent the Adventure document.
+   */
+  get thumbnail(): string;
+
+  static override fromSource<Schema extends DataSchema>(
+    source: fields.SchemaField.InnerAssignmentType<Schema>,
+    {
+      strict,
+      ...context
+    }?: DataModel.ConstructorOptions<null> & {
+      /**
+       * Models created from trusted source data are validated non-strictly
+       * @defaultValue `false`
+       */
+      strict?: boolean;
+    },
+  ): foundry.abstract.DataModel<Schema, DataModel.Any | null>;
+
+  static override migrateData(source: AnyObject): AnyObject;
+}
+
+export default BaseAdventure;
+
+declare namespace BaseAdventure {
+  type Parent = null;
+
+  type Metadata = Merge<
+    Document.Metadata.Default,
+    {
+      name: "Adventure";
+      collection: "adventures";
+      compendiumIndexFields: ["_id", "name", "img", "sort", "folder"];
+      label: string;
+      labelPlural: string;
+      schemaVersion: string;
+    }
+  >;
+
+  type SchemaField = fields.SchemaField<Schema>;
+  type ConstructorData = fields.SchemaField.InnerConstructorType<Schema>;
+  type UpdateData = fields.SchemaField.InnerAssignmentType<Schema>;
+  type Properties = fields.SchemaField.InnerInitializedType<Schema>;
+  type Source = fields.SchemaField.InnerPersistedType<Schema>;
+
+  interface Schema extends DataSchema {
+    /**
+     * The _id which uniquely identifies this Adventure document
+     * @defaultValue `null`
+     */
+    _id: fields.DocumentIdField;
+
+    /**
+     * The human-readable name of the Adventure
+     */
+    name: fields.StringField<{
+      required: true;
+      blank: false;
+      label: "ADVENTURE.Name";
+      hint: "ADVENTURE.NameHint";
+      textSearch: true;
+    }>;
+
+    /**
+     * The file path for the primary image of the adventure
+     * @defaultValue `null`
+     */
+    img: fields.FilePathField<{ categories: ["IMAGE"]; label: "ADVENTURE.Image"; hint: "ADVENTURE.ImageHint" }>;
+
+    /**
+     * A string caption displayed under the primary image banner
+     * @defaultValue `""`
+     */
+    caption: fields.HTMLField<{ label: "ADVENTURE.Caption"; hint: "ADVENTURE.CaptionHint" }>;
+
+    /**
+     * An HTML text description for the adventure
+     * @defaultValue `""`
+     */
+    description: fields.HTMLField<{
+      label: "ADVENTURE.Description";
+      hint: "ADVENTURE.DescriptionHint";
+      textSearch: true;
+    }>;
+
+    /**
+     * An array of Actor documents which are included in the adventure
+     * @defaultValue `new Set()`
+     */
+    actors: fields.SetField<fields.EmbeddedDataField<Actor.ConfiguredInstance>>;
+
+    /**
+     * An array of Combat documents which are included in the adventure
+     * @defaultValue `new Set()`
+     */
+    combats: fields.SetField<fields.EmbeddedDataField<Combat.ConfiguredInstance>>;
+
+    /**
+     * An array of Item documents which are included in the adventure
+     * @defaultValue `new Set()`
+     */
+    items: fields.SetField<fields.EmbeddedDataField<Item.ConfiguredInstance>>;
+
+    /**
+     * An array of JournalEntry documents which are included in the adventure
+     * @defaultValue `new Set()`
+     */
+    journal: fields.SetField<fields.EmbeddedDataField<JournalEntry.ConfiguredInstance>>;
+
+    /**
+     * An array of Scene documents which are included in the adventure
+     * @defaultValue `new Set()`
+     */
+    scenes: fields.SetField<fields.EmbeddedDataField<Scene.ConfiguredInstance>>;
+
+    /**
+     * An array of RollTable documents which are included in the adventure
+     * @defaultValue `new Set()`
+     */
+    tables: fields.SetField<fields.EmbeddedDataField<RollTable.ConfiguredInstance>>;
+
+    /**
+     * An array of Macro documents which are included in the adventure
+     * @defaultValue `new Set()`
+     */
+    macros: fields.SetField<fields.EmbeddedDataField<Macro.ConfiguredInstance>>;
+
+    /**
+     * An array of Cards documents which are included in the adventure
+     * @defaultValue `new Set()`
+     */
+    cards: fields.SetField<fields.EmbeddedDataField<Cards.ConfiguredInstance>>;
+
+    /**
+     * An array of Playlist documents which are included in the adventure
+     * @defaultValue `new Set()`
+     */
+    playlists: fields.SetField<fields.EmbeddedDataField<Playlist.ConfiguredInstance>>;
+
+    /**
+     * An array of Folder documents which are included in the adventure
+     * @defaultValue `new Set()`
+     */
+    folders: fields.SetField<fields.EmbeddedDataField<Folder.ConfiguredInstance>>;
+
+    folder: fields.ForeignDocumentField<Folder.ConfiguredInstance>;
+
+    /**
+     * The sort order of this adventure relative to its siblings
+     * @defaultValue `0`
+     */
+    sort: fields.IntegerSortField;
+
+    /**
+     * An object of optional key/value flags
+     * @defaultValue `{}`
+     */
+    flags: fields.ObjectField.FlagsField<"Adventure">;
+
+    /**
+     * An object of creation and access information
+     * @defaultValue see {@link fields.DocumentStatsField}
+     */
+    _stats: fields.DocumentStatsField;
+  }
+
+  /**
+   * A helper type to extract the return value for {@link BaseAdventure.contentFields}
+   */
+  type ContentFields = {
+    [Key in keyof BaseAdventure.Schema as BaseAdventure.Schema[Key] extends fields.SetField.Any
+      ? Key
+      : never]: BaseAdventure.Schema[Key] extends fields.SetField<infer ElementType, any, any, any, any, any, any, any>
+      ? ElementType extends fields.EmbeddedDataField<infer ModelType, any, any, any, any>
+        ? ModelType extends typeof Document // TODO: This doesn't seem to quite work to ensure it's the configured class
+          ? ModelType["implementation"]
+          : ModelType
+        : never
+      : never;
+  };
+}

package/src/foundry/common/documents/ambient-light.d.mts

@@ -0,0 +1,107 @@
+import type { AnyObject, Merge } from "../../../types/utils.mts";
+import type Document from "../abstract/document.mts";
+import type { LightData } from "../data/data.mts";
+import type * as fields from "../data/fields.d.mts";
+
+/**
+ * The Document definition for an AmbientLight.
+ * Defines the DataSchema and common behaviors for an AmbientLight which are shared between both client and server.
+ */
+// Note(LukeAbby): You may wonder why documents don't simply pass the `Parent` generic parameter.
+// This pattern evolved from trying to avoid circular loops and even internal tsc errors.
+// See: https://gist.github.com/LukeAbby/0d01b6e20ef19ebc304d7d18cef9cc21
+declare class BaseAmbientLight extends Document<BaseAmbientLight.Schema, BaseAmbientLight.Metadata, any> {
+  /**
+   * @param data    - Initial data from which to construct the AmbientLight
+   * @param context - Construction context options
+   */
+  // TODO(LukeAbby): This constructor is a symptom of a circular error.
+  // constructor(data?: BaseAmbientLight.ConstructorData, context?: Document.ConstructionContext<BaseAmbientLight.Parent>);
+
+  override parent: BaseAmbientLight.Parent;
+
+  static override metadata: Readonly<BaseAmbientLight.Metadata>;
+
+  static override defineSchema(): BaseAmbientLight.Schema;
+
+  static override migrateData(source: AnyObject): AnyObject;
+}
+
+export default BaseAmbientLight;
+
+declare namespace BaseAmbientLight {
+  type Parent = Scene.ConfiguredInstance | null;
+
+  type Metadata = Merge<
+    Document.Metadata.Default,
+    {
+      name: "AmbientLight";
+      collection: "lights";
+      label: string;
+      labelPlural: string;
+      schemaVersion: string;
+    }
+  >;
+
+  type SchemaField = fields.SchemaField<Schema>;
+  type ConstructorData = fields.SchemaField.InnerConstructorType<Schema>;
+  type UpdateData = fields.SchemaField.InnerAssignmentType<Schema>;
+  type Properties = fields.SchemaField.InnerInitializedType<Schema>;
+  type Source = fields.SchemaField.InnerPersistedType<Schema>;
+
+  interface Schema extends DataSchema {
+    /**
+     * The _id which uniquely identifies this BaseAmbientLight embedded document
+     * @defaultValue `null`
+     */
+    _id: fields.DocumentIdField;
+
+    /**
+     * The x-coordinate position of the origin of the light
+     * @defaultValue `0`
+     */
+    x: fields.NumberField<{ required: true; integer: true; nullable: false; initial: 0; label: "XCoord" }>;
+
+    /**
+     * The y-coordinate position of the origin of the light
+     * @defaultValue `0`
+     */
+    y: fields.NumberField<{ required: true; integer: true; nullable: false; initial: 0; label: "YCoord" }>;
+
+    /**
+     * The angle of rotation for the tile between 0 and 360
+     * @defaultValue `0`
+     */
+    rotation: fields.AngleField<{ label: "LIGHT.Rotation" }>;
+
+    /**
+     * Whether or not this light source is constrained by Walls
+     * @defaultValue `true`
+     */
+    walls: fields.BooleanField<{ initial: true; label: "LIGHT.Walls"; hint: "LIGHT.WallsHint" }>;
+
+    /**
+     * Whether or not this light source provides a source of vision
+     * @defaultValue `false`
+     */
+    vision: fields.BooleanField<{ label: "LIGHT.Vision"; hint: "LIGHT.VisionHint" }>;
+
+    /**
+     * Light configuration data
+     * @defaultValue see {@link LightData}
+     */
+    config: fields.EmbeddedDataField<LightData>;
+
+    /**
+     * Is the light source currently hidden?
+     * @defaultValue `false`
+     */
+    hidden: fields.BooleanField<{ label: "Hidden" }>;
+
+    /**
+     * An object of optional key/value flags
+     * @defaultValue `{}`
+     */
+    flags: fields.ObjectField.FlagsField<"AmbientLight">;
+  }
+}