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

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

@@ -0,0 +1,255 @@
+import type { AnyObject, InexactPartial, Merge } from "../../../types/utils.mts";
+import type Document from "../abstract/document.mts";
+import type * as CONST from "../constants.mts";
+import type * as fields from "../data/fields.d.mts";
+import type { ShapeData } from "../data/module.mts";
+import type * as documents from "./_module.mts";
+
+/**
+ * The Document definition for a Drawing.
+ * Defines the DataSchema and common behaviors for a Drawing 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 BaseDrawing extends Document<BaseDrawing.Schema, BaseDrawing.Metadata, any> {
+  /**
+   * @param data    - Initial data from which to construct the Drawing
+   * @param context - Construction context options
+   */
+  // TODO(LukeAbby): This constructor is a symptom of a circular error.
+  // constructor(data?: BaseDrawing.ConstructorData, context?: Document.ConstructionContext<BaseDrawing.Parent>);
+
+  override parent: BaseDrawing.Parent;
+
+  static override metadata: Readonly<BaseDrawing.Metadata>;
+
+  static override defineSchema(): BaseDrawing.Schema;
+
+  /**
+   * Validate whether the drawing has some visible content (as required by validation).
+   */
+  static #validateVisibleContent(data: BaseDrawing.UpdateData): boolean;
+
+  static override validateJoint(data: fields.SchemaField.InnerAssignmentType<documents.BaseDrawing.Schema>): void;
+
+  /**
+   * Is a user able to update or delete an existing Drawing document??
+   * @internal
+   */
+  static #canModify(user: documents.BaseUser, doc: BaseDrawing, data: BaseDrawing.UpdateData): 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;
+
+  static override cleanData(source?: AnyObject, options?: fields.DataField.CleanOptions): AnyObject;
+
+  static override migrateData(source: AnyObject): AnyObject;
+
+  static override shimData(
+    data: AnyObject,
+    options?: {
+      /**
+       * Apply shims to embedded models?
+       * @defaultValue `true`
+       */
+      embedded?: boolean;
+    },
+  ): AnyObject;
+}
+
+export default BaseDrawing;
+
+declare namespace BaseDrawing {
+  type Parent = Scene.ConfiguredInstance | null;
+
+  type Metadata = Merge<
+    Document.Metadata.Default,
+    {
+      name: "Drawing";
+      collection: "drawings";
+      label: string;
+      labelPlural: string;
+      isEmbedded: true;
+      permissions: {
+        create: "DRAWING_CREATE";
+        update: (user: documents.BaseUser, doc: Document.Any, data: UpdateData) => boolean;
+        delete: (user: documents.BaseUser, doc: Document.Any, data: UpdateData) => boolean;
+      };
+      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 BaseDrawing embedded document
+     * @defaultValue `null`
+     */
+    _id: fields.DocumentIdField;
+
+    /**
+     * The _id of the user who created the drawing
+     * @defaultValue `game.user?.id`
+     */
+    author: fields.ForeignDocumentField<documents.BaseUser, { nullable: false; initial: () => string }>;
+
+    /**
+     * The geometric shape of the drawing
+     * @defaultValue see {@link ShapeData.Schema}
+     */
+    shape: fields.EmbeddedDataField<ShapeData>;
+
+    /**
+     * The x-coordinate position of the top-left corner of the drawn shape
+     * @defaultValue `0`
+     */
+    x: fields.NumberField<{ required: true; nullable: false; initial: 0; label: "XCoord" }>;
+
+    /**
+     * The y-coordinate position of the top-left corner of the drawn shape
+     * @defaultValue `0`
+     */
+    y: fields.NumberField<{ required: true; nullable: false; initial: 0; label: "YCoord" }>;
+
+    /**
+     * The z-index of this drawing relative to other siblings
+     * @defaultValue `0`
+     */
+    z: fields.NumberField<{ required: true; integer: true; nullable: false; initial: 0; label: "DRAWING.ZIndex" }>;
+
+    /**
+     * The angle of rotation for the drawing figure
+     * @defaultValue `0`
+     */
+    rotation: fields.AngleField<{ label: "DRAWING.Rotation" }>;
+
+    /**
+     * An amount of bezier smoothing applied, between 0 and 1
+     * @defaultValue `0`
+     */
+    bezierFactor: fields.AlphaField<{
+      initial: 0;
+      label: "DRAWING.SmoothingFactor";
+      max: 0.5;
+      hint: "DRAWING.SmoothingFactorHint";
+    }>;
+
+    /**
+     * The fill type of the drawing shape, a value from CONST.DRAWING_FILL_TYPES
+     * @defaultValue `CONST.DRAWING_FILL_TYPES.NONE`
+     */
+    fillType: fields.NumberField<{
+      required: true;
+      initial: typeof CONST.DRAWING_FILL_TYPES.NONE;
+      choices: CONST.DRAWING_FILL_TYPES[];
+      label: "DRAWING.FillTypes";
+      validationError: "must be a value in CONST.DRAWING_FILL_TYPES";
+    }>;
+
+    /**
+     * An optional color string with which to fill the drawing geometry
+     * @defaultValue `game.user?.color`
+     */
+    fillColor: fields.ColorField<{ initial: () => string; label: "DRAWING.FillColor" }>;
+
+    /**
+     * The opacity of the fill applied to the drawing geometry
+     * @defaultValue `0.5`
+     */
+    fillAlpha: fields.AlphaField<{ initial: 0.5; label: "DRAWING.FillOpacity" }>;
+
+    /**
+     * The width in pixels of the boundary lines of the drawing geometry
+     * @defaultValue `8`
+     */
+    strokeWidth: fields.NumberField<{ integer: true; initial: 8; min: 0; label: "DRAWING.LineWidth" }>;
+
+    /**
+     * The color of the boundary lines of the drawing geometry
+     * @defaultValue `game.user?.color`
+     */
+    strokeColor: fields.ColorField<{ initial: () => string; label: "DRAWING.StrokeColor" }>;
+
+    /**
+     * The opacity of the boundary lines of the drawing geometry
+     * @defaultValue `1`
+     */
+    strokeAlpha: fields.AlphaField<{ initial: 1; label: "DRAWING.LineOpacity" }>;
+
+    /**
+     * The path to a tiling image texture used to fill the drawing geometry
+     * @defaultValue `null`
+     */
+    texture: fields.FilePathField<{ categories: ["IMAGE"]; label: "DRAWING.FillTexture" }>;
+
+    /**
+     * Optional text which is displayed overtop of the drawing
+     * @defaultValue `""`
+     */
+    text: fields.StringField<{ label: "DRAWING.TextLabel" }>;
+
+    /**
+     * The font family used to display text within this drawing, defaults to CONFIG.defaultFontFamily
+     * @defaultValue `globalThis.CONFIG?.defaultFontFamily || "Signika"`
+     */
+    fontFamily: fields.StringField<{ blank: false; label: "DRAWING.FontFamily"; initial: () => string }>;
+
+    /**
+     * The font size used to display text within this drawing
+     * @defaultValue `48`
+     */
+    fontSize: fields.NumberField<{
+      integer: true;
+      min: 8;
+      max: 256;
+      initial: 48;
+      label: "DRAWING.FontSize";
+      validationError: "must be an integer between 8 and 256";
+    }>;
+
+    /**
+     * The color of text displayed within this drawing
+     * @defaultValue `#FFFFFF`
+     */
+    textColor: fields.ColorField<{ initial: "#FFFFFF"; label: "DRAWING.TextColor" }>;
+
+    /**
+     * The opacity of text displayed within this drawing
+     * @defaultValue `1`
+     */
+    textAlpha: fields.AlphaField<{ label: "DRAWING.TextOpacity" }>;
+
+    /**
+     * Is the drawing currently hidden?
+     * @defaultValue `false`
+     */
+    hidden: fields.BooleanField;
+
+    /**
+     * Is the drawing currently locked?
+     * @defaultValue `false`
+     */
+    locked: fields.BooleanField;
+
+    /**
+     * An object of optional key/value flags
+     * @defaultValue `{}`
+     */
+    flags: fields.ObjectField.FlagsField<"Drawing">;
+  }
+}

package/src/foundry/common/documents/fog-exploration.d.mts

@@ -0,0 +1,110 @@
+import type { Merge } from "../../../types/utils.mts";
+import type Document from "../abstract/document.mts";
+import type * as fields from "../data/fields.d.mts";
+import type * as documents from "./_module.mts";
+
+/**
+ * The Document definition for FogExploration.
+ * Defines the DataSchema and common behaviors for FogExploration 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 BaseFogExploration extends Document<BaseFogExploration.Schema, BaseFogExploration.Metadata, any> {
+  /**
+   * @param data    - Initial data from which to construct the FogExploration
+   * @param context - Construction context options
+   */
+  // TODO(LukeAbby): This constructor is a symptom of a circular error.
+  // constructor(
+  //   data?: BaseFogExploration.ConstructorData,
+  //   context?: Document.ConstructionContext<BaseFogExploration.Parent>,
+  // );
+
+  override parent: BaseFogExploration.Parent;
+
+  static override metadata: Readonly<BaseFogExploration.Metadata>;
+
+  static override defineSchema(): BaseFogExploration.Schema;
+
+  static #canModify(user: documents.BaseUser, doc: BaseFogExploration);
+
+  /**
+   * @privateRemarks _preUpdate is overridden but with no signature changes.
+   * For type simplicity it is left off. These methods historically have been the source of a large amount of computation from tsc.
+   */
+}
+
+export default BaseFogExploration;
+
+declare namespace BaseFogExploration {
+  type Parent = null;
+
+  type Metadata = Merge<
+    Document.Metadata.Default,
+    {
+      name: "FogExploration";
+      collection: "fog";
+      label: string;
+      labelPlural: string;
+      isPrimary: true;
+      permissions: {
+        create: "PLAYER";
+        update: (user: documents.BaseUser, doc: Document.Any, data: UpdateData) => boolean;
+        delete: (user: documents.BaseUser, doc: Document.Any, data: UpdateData) => boolean;
+      };
+      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 FogExploration document
+     * @defaultValue `null`
+     */
+    _id: fields.DocumentIdField;
+
+    /**
+     * The _id of the Scene document to which this fog applies
+     * @defaultValue `canvas?.scene?.id`
+     */
+    // FIXME: Initial should be able to return undefined
+    scene: fields.ForeignDocumentField<documents.BaseScene, { initial: () => string }>;
+
+    /**
+     * The _id of the User document to which this fog applies
+     * @defaultValue `null`
+     */
+    user: fields.ForeignDocumentField<documents.BaseUser, { initial: () => string }>;
+
+    /**
+     * The base64 image/jpeg of the explored fog polygon
+     * @defaultValue `null`
+     */
+    explored: fields.FilePathField<{ categories: ["IMAGE"]; required: true; base64: true }>;
+
+    /**
+     * The object of scene positions which have been explored at a certain vision radius
+     * @defaultValue `{}`
+     */
+    positions: fields.ObjectField;
+
+    /**
+     * The timestamp at which this fog exploration was last updated
+     * @defaultValue `Date.now()`
+     */
+    timestamp: fields.NumberField<{ nullable: false; initial: ReturnType<typeof Date.now> }>;
+
+    /**
+     * An object of optional key/value flags
+     * @defaultValue `{}`
+     */
+    flags: fields.ObjectField.FlagsField<"FogExploration">;
+  }
+}

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

@@ -0,0 +1,130 @@
+import type { AnyObject, Merge } from "../../../types/utils.mts";
+import type Document from "../abstract/document.mts";
+import type * as fields from "../data/fields.d.mts";
+
+/**
+ * The Document definition for a Folder.
+ * Defines the DataSchema and common behaviors for a Folder 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 BaseFolder extends Document<BaseFolder.Schema, BaseFolder.Metadata, any> {
+  /**
+   * @param data    - Initial data from which to construct the Folder
+   * @param context - Construction context options
+   */
+  // TODO(LukeAbby): This constructor is a symptom of a circular error.
+  // constructor(data: BaseFolder.ConstructorData, context?: Document.ConstructionContext<BaseFolder.Parent>);
+
+  override parent: BaseFolder.Parent;
+
+  static override metadata: Readonly<BaseFolder.Metadata>;
+
+  static override defineSchema(): BaseFolder.Schema;
+
+  // NOTE(LukeAbby): The `validateJoint` method override was left off because it didn't change the signature and it also seemed to cause a loop.
+  // See: https://gist.github.com/LukeAbby/43ee5c2a39cd33f3fac693d1d4a5653f
+
+  /**
+   * Allow folder sorting modes
+   * @defaultValue `["a", "m"]`
+   */
+  static SORTING_MODES: ("a" | "m")[];
+
+  static override migrateData(source: AnyObject): AnyObject;
+
+  static override shimData(
+    data: AnyObject,
+    options?: {
+      /**
+       * Apply shims to embedded models?
+       * @defaultValue `true`
+       */
+      embedded?: boolean;
+    },
+  ): AnyObject;
+
+  // TODO: `Return type annotation circularly references itself.`
+  // static override get(documentId: string, options: InexactPartial<{ pack: string }>): Folder.ConfiguredInstance | null;
+}
+
+export default BaseFolder;
+
+declare namespace BaseFolder {
+  type Parent = null;
+
+  type Metadata = Merge<
+    Document.Metadata.Default,
+    {
+      name: "Folder";
+      collection: "folders";
+      label: string;
+      labelPlural: string;
+      coreTypes: typeof CONST.FOLDER_DOCUMENT_TYPES;
+      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 Folder document
+     * @defaultValue `null`
+     */
+    _id: fields.DocumentIdField;
+
+    /** The name of this Folder */
+    name: fields.StringField<{ required: true; blank: false; textSearch: true }>;
+
+    /** The document type which this Folder contains, from CONST.FOLDER_DOCUMENT_TYPES */
+    type: fields.StringField<{ required: true; choices: foundry.CONST.FOLDER_DOCUMENT_TYPES[] }>;
+
+    /**
+     * An HTML description of the contents of this folder
+     * @defaultValue `""`
+     */
+    description: fields.StringField<{ textSearch: true }>;
+
+    /**
+     * The _id of a parent Folder which contains this Folder
+     * @defaultValue `null`
+     */
+    folder: fields.ForeignDocumentField<BaseFolder>;
+
+    /**
+     * The sorting mode used to organize documents within this Folder, in ["a", "m"]
+     * @defaultValue `"a"`
+     */
+    sorting: fields.StringField<{ required: true; initial: "a"; choices: typeof BaseFolder.SORTING_MODES }>;
+
+    /**
+     * The numeric sort value which orders this Folder relative to its siblings
+     * @defaultValue `0`
+     */
+    sort: fields.IntegerSortField;
+
+    /**
+     * A color string used for the background color of this Folder
+     * @defaultValue `null`
+     */
+    color: fields.ColorField;
+
+    /**
+     * An object of optional key/value flags
+     * @defaultValue `{}`
+     */
+    flags: fields.ObjectField.FlagsField<"Folder">;
+
+    /**
+     * An object of creation and access information
+     * @defaultValue see {@link fields.DocumentStatsField}
+     */
+    _stats: fields.DocumentStatsField;
+  }
+}

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

@@ -0,0 +1,181 @@
+import type { AnyObject, InexactPartial, Merge } from "../../../types/utils.mts";
+import type Document from "../abstract/document.mts";
+import type * as fields from "../data/fields.d.mts";
+import type * as documents from "./_module.mts";
+
+/**
+ * The Document definition for an Item.
+ * Defines the DataSchema and common behaviors for an Item 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 BaseItem extends Document<BaseItem.Schema, BaseItem.Metadata, any> {
+  /**
+   * @param data    - Initial data from which to construct the Item
+   * @param context - Construction context options
+   */
+  // TODO(LukeAbby): This constructor is causing a circular error.
+  // constructor(data: BaseItem.ConstructorData, context?: Document.ConstructionContext<BaseItem.Parent>);
+
+  override parent: BaseItem.Parent;
+
+  override _source: BaseItem.Source;
+
+  static override metadata: Readonly<BaseItem.Metadata>;
+
+  static override defineSchema(): BaseItem.Schema;
+
+  /**
+   * The default icon used for newly created Item documents
+   * @defaultValue `"icons/svg/item-bag.svg"`
+   */
+  static DEFAULT_ICON: string;
+
+  /**
+   * Determine default artwork based on the provided item data.
+   * @param itemData - The source item data
+   * @returns Candidate item image
+   */
+  static getDefaultArtwork(itemData: BaseItem.ConstructorData): { img: string };
+
+  /**
+   * The allowed set of Item types which may exist.
+   */
+  static get TYPES(): BaseItem.TypeNames[];
+
+  override canUserModify(user: documents.BaseUser, action: "create" | "delete" | "update", data?: AnyObject): boolean;
+
+  override testUserPermission(
+    user: documents.BaseUser,
+    permission: keyof typeof CONST.DOCUMENT_OWNERSHIP_LEVELS | foundry.CONST.DOCUMENT_OWNERSHIP_LEVELS,
+    options?: InexactPartial<{
+      /**
+       * Require the exact permission level requested?
+       * @defaultValue `false`
+       */
+      exact: boolean;
+    }>,
+  ): boolean;
+
+  static override migrateData(source: AnyObject): AnyObject;
+
+  static override shimData(
+    data: AnyObject,
+    options: {
+      /**
+       * Apply shims to embedded models?
+       * @defaultValue `true`
+       */
+      embedded?: boolean;
+    },
+  ): AnyObject;
+}
+
+export default BaseItem;
+
+declare namespace BaseItem {
+  type Parent = Actor.ConfiguredInstance | null;
+
+  type TypeNames = fields.TypeDataField.TypeNames<typeof BaseItem>;
+
+  type Metadata = Merge<
+    Document.Metadata.Default,
+    {
+      name: "Item";
+      collection: "items";
+      indexed: true;
+      compendiumIndexFields: ["_id", "name", "img", "type", "sort", "folder"];
+      embedded: { ActiveEffect: "effects" };
+      label: string;
+      labelPlural: string;
+      permissions: { create: "ITEM_CREATE" };
+      schemaVersion: string;
+
+      /**
+       * @deprecated since v10, BaseItem.metadata.types is deprecated since v10 in favor of BaseItem.TYPES.
+       */
+      types: typeof BaseItem.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 Item document
+     * @defaultValue `null`
+     */
+    _id: fields.DocumentIdField;
+
+    /** The name of this Item */
+    name: fields.StringField<{ required: true; blank: false; textSearch: true }>;
+
+    /** An Item subtype which configures the system data model applied */
+    type: fields.StringField<
+      {
+        required: true;
+        choices: () => typeof BaseItem.TYPES;
+        validationError: "must be in the array of Item types defined by the game system";
+      },
+      TypeName,
+      TypeName,
+      TypeName
+    >;
+
+    /**
+     * An image file path which provides the artwork for this Item
+     * @defaultValue `null`
+     */
+    img: fields.FilePathField<{
+      categories: "IMAGE"[];
+      initial: (data: unknown) => string;
+    }>;
+
+    /**
+     * The system data object which is defined by the system template.json model
+     * @defaultValue `{}`
+     */
+    system: fields.TypeDataField<typeof BaseItem>;
+
+    /**
+     * A collection of ActiveEffect embedded Documents
+     * @defaultValue `[]`
+     */
+    effects: fields.EmbeddedCollectionField<typeof documents.BaseActiveEffect, Item.ConfiguredInstance>;
+
+    /**
+     * The _id of a Folder which contains this Item
+     * @defaultValue `null`
+     */
+    folder: fields.ForeignDocumentField<documents.BaseFolder>;
+
+    /**
+     * The numeric sort value which orders this Item relative to its siblings
+     * @defaultValue `0`
+     */
+    sort: fields.IntegerSortField;
+
+    /**
+     * An object which configures ownership of this Item
+     * @defaultValue see {@link fields.DocumentOwnershipField}
+     */
+    ownership: fields.DocumentOwnershipField;
+
+    /**
+     * An object of optional key/value flags
+     * @defaultValue `{}`
+     */
+    flags: fields.ObjectField.FlagsField<"Item">;
+
+    /**
+     * An object of creation and access information
+     * @defaultValue see {@link fields.DocumentStatsField}
+     */
+    _stats: fields.DocumentStatsField;
+  }
+}