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

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

@@ -0,0 +1,130 @@
+import type Document from "../abstract/document.mts";
+import type * as fields from "../data/fields.d.mts";
+import type * as documents from "./_module.mts";
+
+/**
+ * The Combat Document.
+ * Defines the DataSchema and common behaviors for a Combat 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 BaseCombat extends Document<"Combat", BaseCombat.Schema, any> {
+  /**
+   * @param data    - Initial data from which to construct the Combat
+   * @param context - Construction context options
+   */
+  // TODO(LukeAbby): This constructor is a symptom of a circular error.
+  // constructor(data?: BaseCombat.ConstructorData, context?: Document.ConstructionContext<BaseCombat.Parent>);
+
+  override parent: BaseCombat.Parent;
+
+  static override metadata: BaseCombat.Metadata;
+
+  static override defineSchema(): BaseCombat.Schema;
+
+  /**
+   * Is a user able to update an existing Combat?
+   * @internal
+   */
+  static #canUpdate(user: documents.BaseUser, doc: BaseCombat, data: BaseCombat.UpdateData): boolean;
+
+  /**
+   * Can a certain User change the Combat round?
+   * @param user - The user attempting to change the round
+   * @returns Is the user allowed to change the round?
+   */
+  protected _canChangeRound(user: User.ConfiguredInstance): boolean;
+
+  /**
+   * Can a certain User change the Combat turn?
+   * @param user - The user attempting to change the turn
+   * @returns Is the user allowed to change the turn?
+   */
+  protected _canChangeTurn(user: User.ConfiguredInstance): boolean;
+
+  // BaseCombat implements _preUpdate but leaving out here for type computation reasons
+}
+
+export default BaseCombat;
+
+declare namespace BaseCombat {
+  type Parent = null;
+
+  type TypeNames = Game.Model.TypeNames<"Combat">;
+
+  type Metadata = Document.MetadataFor<BaseCombat>;
+
+  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 Combat document
+     * @defaultValue `null`
+     */
+    _id: fields.DocumentIdField;
+
+    type: fields.DocumentTypeField<typeof BaseCombat, { initial: typeof foundry.CONST.BASE_DOCUMENT_TYPE }>;
+
+    system: fields.TypeDataField<typeof BaseCombat>;
+
+    /**
+     * The _id of a Scene within which this Combat occurs
+     * @defaultValue `null`
+     */
+    scene: fields.ForeignDocumentField<typeof documents.BaseScene>;
+
+    /**
+     * A Collection of Combatant embedded Documents
+     * @defaultValue `[]`
+     */
+    combatants: fields.EmbeddedCollectionField<typeof documents.BaseCombatant, Combat.ConfiguredInstance>;
+
+    /**
+     * Is the Combat encounter currently active?
+     * @defaultValue `false`
+     */
+    active: fields.BooleanField;
+
+    /**
+     * The current round of the Combat encounter
+     * @defaultValue `0`
+     */
+    round: fields.NumberField<{
+      required: true;
+      nullable: false;
+      integer: true;
+      min: 0;
+      initial: 0;
+      label: "COMBAT.Round";
+    }>;
+
+    /**
+     * The current turn in the Combat round
+     * @defaultValue `null`
+     */
+    turn: fields.NumberField<{ required: true; integer: true; min: 0; initial: null; label: "COMBAT.Turn" }>;
+
+    /**
+     * The current sort order of this Combat relative to others in the same Scene
+     * @defaultValue `0`
+     */
+    sort: fields.IntegerSortField;
+
+    /**
+     * An object of optional key/value flags
+     * @defaultValue `{}`
+     */
+    flags: fields.ObjectField.FlagsField<"Combat">;
+
+    /**
+     * An object of creation and access information
+     * @defaultValue see {@link fields.DocumentStatsField}
+     */
+    _stats: fields.DocumentStatsField;
+  }
+}

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

@@ -0,0 +1,123 @@
+import type Document from "../abstract/document.mts";
+import type { DOCUMENT_OWNERSHIP_LEVELS } from "../constants.d.mts";
+import type * as fields from "../data/fields.d.mts";
+import type * as documents from "./_module.mts";
+
+/**
+ * The Combatant Document.
+ * Defines the DataSchema and common behaviors for a Combatant 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 BaseCombatant extends Document<"Combatant", BaseCombatant.Schema, any> {
+  /**
+   * @param data    - Initial data from which to construct the Combatant
+   * @param context - Construction context options
+   */
+  // TODO(LukeAbby): This constructor is a symptom of a circular error.
+  // constructor(data?: BaseCombatant.ConstructorData, context?: Document.ConstructionContext<BaseCombatant.Parent>);
+
+  override parent: BaseCombatant.Parent;
+
+  static override metadata: BaseCombatant.Metadata;
+
+  static override defineSchema(): BaseCombatant.Schema;
+
+  /**
+   * Is a user able to update an existing Combatant?
+   * @internal
+   */
+  static #canUpdate(user: documents.BaseUser, doc: BaseCombatant, data: BaseCombatant.UpdateData): boolean;
+
+  /**
+   * Is a user able to create this Combatant?
+   * @internal
+   */
+  static #canCreate(user: documents.BaseUser, doc: BaseCombatant, data: BaseCombatant.ConstructorData): boolean;
+
+  override getUserLevel(user?: documents.BaseUser): DOCUMENT_OWNERSHIP_LEVELS | null;
+}
+
+export default BaseCombatant;
+
+declare namespace BaseCombatant {
+  type Parent = Combat.ConfiguredInstance | null;
+
+  type TypeNames = Game.Model.TypeNames<"Combatant">;
+
+  type Metadata = Document.MetadataFor<BaseCombatant>;
+
+  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 Combatant embedded document
+     * @defaultValue `null`
+     */
+    _id: fields.DocumentIdField;
+
+    type: fields.DocumentTypeField<typeof BaseCombatant, { initial: typeof foundry.CONST.BASE_DOCUMENT_TYPE }>;
+
+    system: fields.TypeDataField<typeof BaseCombatant>;
+
+    /**
+     * The _id of an Actor associated with this Combatant
+     * @defaultValue `null`
+     */
+    actorId: fields.ForeignDocumentField<typeof documents.BaseActor, { label: "COMBAT.CombatantActor"; idOnly: true }>;
+
+    /**
+     * The _id of a Token associated with this Combatant
+     * @defaultValue `null`
+     */
+    tokenId: fields.ForeignDocumentField<typeof documents.BaseToken, { label: "COMBAT.CombatantToken"; idOnly: true }>;
+
+    /**
+     * @defaultValue `null`
+     */
+    sceneId: fields.ForeignDocumentField<typeof documents.BaseScene, { label: "COMBAT.CombatantScene"; idOnly: true }>;
+
+    /**
+     * A customized name which replaces the name of the Token in the tracker
+     * @defaultValue `""`
+     */
+    name: fields.StringField<{ label: "COMBAT.CombatantName"; textSearch: true }>;
+
+    /**
+     * A customized image which replaces the Token image in the tracker
+     * @defaultValue `null`
+     */
+    img: fields.FilePathField<{ categories: "IMAGE"[]; label: "COMBAT.CombatantImage" }>;
+
+    /**
+     * The initiative score for the Combatant which determines its turn order
+     * @defaultValue `null`
+     */
+    initiative: fields.NumberField<{ label: "COMBAT.CombatantInitiative" }>;
+
+    /**
+     * Is this Combatant currently hidden?
+     * @defaultValue `false`
+     */
+    hidden: fields.BooleanField<{ label: "COMBAT.CombatantHidden" }>;
+
+    /**
+     * Has this Combatant been defeated?
+     * @defaultValue `false`
+     */
+    defeated: fields.BooleanField<{ label: "COMBAT.CombatantDefeated" }>;
+
+    /**
+     * An object of optional key/value flags
+     * @defaultValue `{}`
+     */
+    flags: fields.ObjectField.FlagsField<"Combatant">;
+
+    _stats: fields.DocumentStatsField;
+  }
+}

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

@@ -0,0 +1,240 @@
+import type { AnyObject, InexactPartial } 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<"Drawing", BaseDrawing.Schema, 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: 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 = Document.MetadataFor<BaseDrawing>;
+
+  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<typeof documents.BaseUser, { nullable: false; initial: () => string }>;
+
+    /**
+     * The geometric shape of the drawing
+     * @defaultValue see {@link ShapeData.Schema}
+     */
+    shape: fields.EmbeddedDataField<typeof 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,95 @@
+import type Document from "../abstract/document.mts";
+import type * as fields from "../data/fields.d.mts";
+import type * as documents from "./_module.mts";
+
+/**
+ * The FogExploration Document.
+ * 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<"FogExploration", BaseFogExploration.Schema, 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: 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 = Document.MetadataFor<BaseFogExploration>;
+
+  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`
+     */
+    scene: fields.ForeignDocumentField<typeof documents.BaseScene, { initial: () => string | undefined }>;
+
+    /**
+     * The _id of the User document to which this fog applies
+     * @defaultValue `null`
+     */
+    user: fields.ForeignDocumentField<typeof 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">;
+
+    _stats: fields.DocumentStatsField;
+  }
+}

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

@@ -0,0 +1,113 @@
+import type Document from "../abstract/document.mts";
+import type * as fields from "../data/fields.d.mts";
+
+/**
+ * The Folder Document.
+ * 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<"Folder", BaseFolder.Schema, any> {
+  /**
+   * @privateRemarks Manual override of the return due to TS limitations with static `this`
+   */
+  static get TYPES(): BaseFolder.TypeNames[];
+
+  /**
+   * @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: 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")[];
+
+  // Doesn't affect type, "Return Type circularly references itself"
+  // static override get(documentId: string, options: NullishProps<{ pack: string }>): Folder.ConfiguredInstance | null;
+}
+
+export default BaseFolder;
+
+declare namespace BaseFolder {
+  type Parent = null;
+
+  type TypeNames = Game.Model.TypeNames<"Folder">;
+
+  type Metadata = Document.MetadataFor<BaseFolder>;
+
+  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.DocumentTypeField<typeof BaseFolder>;
+
+    /**
+     * An HTML description of the contents of this folder
+     * @defaultValue `""`
+     */
+    description: fields.HTMLField<{ textSearch: true }>;
+
+    /**
+     * The _id of a parent Folder which contains this Folder
+     * @defaultValue `null`
+     */
+    folder: fields.ForeignDocumentField<typeof 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;
+  }
+}