@league-of-foundry-developers/foundry-vtt-types 0.8.9-9 → 9.238.0

package/src/foundry/common/data/data.mjs/activeEffectData.d.ts

@@ -6,24 +6,24 @@ import { EffectChangeData, EffectChangeDataConstructorData } from './effectChang
 import { EffectDurationData, EffectDurationDataConstructorData } from './effectDurationData';
 
 interface ActiveEffectDataSchema extends DocumentSchema {
-  _id: typeof fields.DOCUMENT_ID;
+  _id: fields.DocumentId;
   changes: DocumentField<EffectChangeData[]> & {
-    default: [];
-    required: true;
     type: [typeof EffectChangeData];
+    required: true;
+    default: [];
   };
-  disabled: typeof fields.BOOLEAN_FIELD;
+  disabled: fields.BooleanField;
   duration: DocumentField<EffectDurationData> & {
-    default: {};
-    required: true;
     type: typeof EffectDurationData;
+    required: true;
+    default: Record<string, never>;
   };
-  icon: typeof fields.IMAGE_FIELD;
-  label: typeof fields.BLANK_STRING;
-  origin: typeof fields.STRING_FIELD;
-  tint: typeof fields.COLOR_FIELD;
-  transfer: FieldReturnType<typeof fields.BOOLEAN_FIELD, { default: true }>;
-  flags: typeof fields.OBJECT_FIELD; // TODO: add more concrete object type
+  icon: fields.ImageField;
+  label: fields.BlankString;
+  origin: fields.StringField;
+  tint: fields.ColorField;
+  transfer: FieldReturnType<fields.BooleanField, { default: true }>;
+  flags: fields.ObjectField;
 }
 
 interface CoreFlags {
@@ -33,11 +33,13 @@ interface CoreFlags {
 interface ActiveEffectDataProperties {
   /**
    * The _id which uniquely identifies the ActiveEffect within a parent Actor or Item
+   * @defaultValue `null`
    */
   _id: string | null;
 
   /**
    * The array of EffectChangeData objects which the ActiveEffect applies
+   * @defaultValue `[]`
    */
   changes: EffectChangeData[];
 
@@ -49,29 +51,30 @@ interface ActiveEffectDataProperties {
 
   /**
    * An EffectDurationData object which describes the duration of the ActiveEffect
+   * @defaultValue `new EffectDurationData({})`
    */
   duration: EffectDurationData;
 
   /**
    * An icon image path used to depict the ActiveEffect
    */
-  icon?: string | null;
+  icon: string | null | undefined;
 
   /**
    * A text label which describes the name of the ActiveEffect
-   * @defaultValue `''`
+   * @defaultValue `""`
    */
   label: string;
 
   /**
    * A UUID reference to the document from which this ActiveEffect originated
    */
-  origin?: string;
+  origin: string | undefined;
 
   /**
    * A color string which applies a tint to the ActiveEffect icon
    */
-  tint?: string | null;
+  tint: string | null | undefined;
 
   /**
    * Does this ActiveEffect automatically transfer from an Item to an Actor?
@@ -89,72 +92,76 @@ interface ActiveEffectDataProperties {
 interface ActiveEffectDataConstructorData {
   /**
    * The _id which uniquely identifies the ActiveEffect within a parent Actor or Item
+   * @defaultValue `null`
    */
-  _id?: string | null;
+  _id?: string | null | undefined;
 
   /**
    * The array of EffectChangeData objects which the ActiveEffect applies
+   * @defaultValue `[]`
    */
-  changes?: EffectChangeDataConstructorData[] | null;
+  changes?: EffectChangeDataConstructorData[] | null | undefined;
 
   /**
    * Is this ActiveEffect currently disabled?
    * @defaultValue `false`
    */
-  disabled?: boolean | null;
+  disabled?: boolean | null | undefined;
 
   /**
    * An EffectDurationData object which describes the duration of the ActiveEffect
+   * @defaultValue `new EffectDurationData({})`
    */
-  duration?: EffectDurationDataConstructorData | null;
+  duration?: EffectDurationDataConstructorData | null | undefined;
 
   /**
    * An icon image path used to depict the ActiveEffect
    */
-  icon?: string | null;
+  icon?: string | null | undefined;
 
   /**
    * A text label which describes the name of the ActiveEffect
-   * @defaultValue `''`
+   * @defaultValue `""`
    */
-  label?: string | null;
+  label?: string | null | undefined;
 
   /**
    * A UUID reference to the document from which this ActiveEffect originated
    */
-  origin?: string | null;
+  origin?: string | null | undefined;
 
   /**
    * A color string which applies a tint to the ActiveEffect icon
    */
-  tint?: string | null;
+  tint?: string | null | undefined;
 
   /**
    * Does this ActiveEffect automatically transfer from an Item to an Actor?
    * @defaultValue `true`
    */
-  transfer?: boolean | null;
+  transfer?: boolean | null | undefined;
 
   /**
    * An object of optional key/value flags
    * @defaultValue `{}`
    */
-  flags?: (ConfiguredFlags<'ActiveEffect'> & CoreFlags) | null;
+  flags?: (ConfiguredFlags<'ActiveEffect'> & CoreFlags) | null | undefined;
 }
 
 /**
  * The data schema for an ActiveEffect document.
  * @see BaseActiveEffect
  */
-export declare class ActiveEffectData extends DocumentData<
+export class ActiveEffectData extends DocumentData<
   ActiveEffectDataSchema,
   ActiveEffectDataProperties,
   PropertiesToSource<ActiveEffectDataProperties>,
   ActiveEffectDataConstructorData,
   documents.BaseActiveEffect
 > {
+  /** @override */
   static defineSchema(): ActiveEffectDataSchema;
 }
 
 // eslint-disable-next-line @typescript-eslint/no-empty-interface
-export declare interface ActiveEffectData extends ActiveEffectDataProperties {}
+export interface ActiveEffectData extends ActiveEffectDataProperties {}

package/src/foundry/common/data/data.mjs/actorData.d.ts

@@ -1,4 +1,3 @@
-import EmbeddedCollection from '../../abstract/embedded-collection.mjs';
 import {
   ConfiguredData,
   ConfiguredDocumentClass,
@@ -7,23 +6,24 @@ import {
   FieldReturnType,
   PropertiesToSource
 } from '../../../../types/helperTypes';
+import EmbeddedCollection from '../../abstract/embedded-collection.mjs';
 import { DocumentData } from '../../abstract/module.mjs';
 import * as documents from '../../documents.mjs';
-import * as fields from '../fields.mjs';
 import { PrototypeTokenData } from '../data.mjs';
+import * as fields from '../fields.mjs';
 import { PrototypeTokenDataConstructorData } from './prototypeTokenData.js';
 
 interface ActorDataSchema extends DocumentSchema {
-  _id: typeof fields.DOCUMENT_ID;
-  name: typeof fields.REQUIRED_STRING;
+  _id: fields.DocumentId;
+  name: fields.RequiredString;
   type: DocumentField<string> & {
     type: typeof String;
     required: true;
     validate: (t: unknown) => boolean;
     validationError: 'The provided Actor type must be in the array of types defined by the game system';
   };
-  img: FieldReturnType<typeof fields.IMAGE_FIELD, { default: () => string }>;
-  data: FieldReturnType<typeof fields.OBJECT_FIELD, { default: (data: { type: string }) => any }>; // TODO
+  img: FieldReturnType<fields.ImageField, { default: () => string }>;
+  data: fields.SystemDataField;
   token: DocumentField<PrototypeTokenData> & {
     type: typeof PrototypeTokenData;
     required: true;
@@ -32,9 +32,9 @@ interface ActorDataSchema extends DocumentSchema {
   items: fields.EmbeddedCollectionField<typeof documents.BaseItem>;
   effects: fields.EmbeddedCollectionField<typeof documents.BaseActiveEffect>;
   folder: fields.ForeignDocumentField<{ type: typeof documents.BaseFolder }>;
-  sort: typeof fields.INTEGER_SORT_FIELD;
-  permission: typeof fields.DOCUMENT_PERMISSIONS;
-  flags: typeof fields.OBJECT_FIELD;
+  sort: fields.IntegerSortField;
+  permission: fields.DocumentPermissions;
+  flags: fields.ObjectField;
 }
 
 interface ActorDataBaseProperties {
@@ -62,21 +62,25 @@ interface ActorDataBaseProperties {
 
   /**
    * The system data object which is defined by the system template.json model
+   * @defaultValue template from template.json for type or `{}`
    */
   data: object;
 
   /**
    * Default Token settings which are used for Tokens created from this Actor
+   * @defaultValue `new PrototypeTokenData({ this.data.name, this.data.img })`
    */
   token: PrototypeTokenData;
 
   /**
    * A Collection of Item embedded Documents
+   * @defaultValue `new EmbeddedCollection(ItemData, [], BaseItem.implementation)`
    */
   items: EmbeddedCollection<ConfiguredDocumentClass<typeof documents.BaseItem>, ActorData>;
 
   /**
    * A collection of ActiveEffect embedded Documents
+   * @defaultValue `new EmbeddedCollection(ActiveEffectData, [], BaseActiveEffect.implementation)`
    */
   effects: EmbeddedCollection<ConfiguredDocumentClass<typeof documents.BaseActiveEffect>, ActorData>;
 
@@ -96,7 +100,7 @@ interface ActorDataBaseProperties {
    * An object which configures user permissions to this Actor
    * @defaultValue `{ default: CONST.ENTITY_PERMISSIONS.NONE }`
    */
-  permission: Partial<Record<string, foundry.CONST.EntityPermission>>;
+  permission: Partial<Record<string, foundry.CONST.DOCUMENT_PERMISSION_LEVELS>>;
 
   /**
    * An object of optional key/value flags
@@ -110,7 +114,7 @@ interface ActorDataConstructorData {
    * The _id which uniquely identifies this Actor document
    * @defaultValue `null`
    */
-  _id?: string | null;
+  _id?: string | null | undefined;
 
   /**
    * The name of this Actor
@@ -126,51 +130,55 @@ interface ActorDataConstructorData {
    * An image file path which provides the artwork for this Actor
    * @defaultValue `ActorDataConstructor.DEFAULT_ICON`
    */
-  img?: string | null;
+  img?: string | null | undefined;
 
   /**
    * The system data object which is defined by the system template.json model
+   * @defaultValue template from template.json for type or `{}`
    */
-  data?: DeepPartial<ActorDataSource['data']> | null;
+  data?: DeepPartial<ActorDataSource['data']> | null | undefined;
 
   /**
    * Default Token settings which are used for Tokens created from this Actor
+   * @defaultValue `new PrototypeTokenData({ this.data.name, this.data.img })`
    */
-  token?: PrototypeTokenDataConstructorData | null;
+  token?: PrototypeTokenDataConstructorData | null | undefined;
 
   /**
    * A Collection of Item embedded Documents
+   * @defaultValue `new EmbeddedCollection(ItemData, [], BaseItem.implementation)`
    */
-  items?: ConstructorParameters<ConfiguredDocumentClass<typeof documents.BaseItem>>[0][] | null;
+  items?: ConstructorParameters<ConfiguredDocumentClass<typeof documents.BaseItem>>[0][] | null | undefined;
 
   /**
    * A collection of ActiveEffect embedded Documents
+   * @defaultValue `new EmbeddedCollection(ActiveEffectData, [], BaseActiveEffect.implementation)`
    */
-  effects?: ConstructorParameters<ConfiguredDocumentClass<typeof documents.BaseActiveEffect>>[0][] | null;
+  effects?: ConstructorParameters<ConfiguredDocumentClass<typeof documents.BaseActiveEffect>>[0][] | null | undefined;
 
   /**
    * The _id of a Folder which contains this Actor
    * @defaultValue `null`
    */
-  folder?: string | null;
+  folder?: InstanceType<ConfiguredDocumentClass<typeof documents.BaseFolder>> | string | null | undefined;
 
   /**
    * The numeric sort value which orders this Actor relative to its siblings
    * @defaultValue `0`
    */
-  sort?: number | null;
+  sort?: number | null | undefined;
 
   /**
    * An object which configures user permissions to this Actor
    * @defaultValue `{ default: CONST.ENTITY_PERMISSIONS.NONE }`
    */
-  permission?: Partial<Record<string, foundry.CONST.EntityPermission>> | null;
+  permission?: Partial<Record<string, foundry.CONST.DOCUMENT_PERMISSION_LEVELS>> | null | undefined;
 
   /**
    * An object of optional key/value flags
    * @defaultValue `{}`
    */
-  flags?: ConfiguredFlags<'Actor'> | null;
+  flags?: ConfiguredFlags<'Actor'> | null | undefined;
 }
 
 type ActorDataBaseSource = PropertiesToSource<ActorDataBaseProperties>;
@@ -182,6 +190,7 @@ type DocumentDataConstructor = Pick<typeof DocumentData, keyof typeof DocumentDa
 interface ActorDataConstructor extends DocumentDataConstructor {
   new (data: ActorDataConstructorData, document?: documents.BaseActor | null): ActorData;
 
+  /** @override */
   defineSchema(): ActorDataSchema;
 
   /**
@@ -203,9 +212,11 @@ export type ActorData = DocumentData<
   documents.BaseActor
 > &
   ActorDataProperties & {
+    /** @override */
     _initializeSource(data: ActorDataConstructorData): ActorDataSource;
 
+    /** @override */
     _initialize(): void;
   };
 
-export declare const ActorData: ActorDataConstructor;
+export const ActorData: ActorDataConstructor;

package/src/foundry/common/data/data.mjs/adventureData.d.ts

@@ -0,0 +1,165 @@
+import type { PropertiesToSource } from '../../../../types/helperTypes.js';
+import type DocumentData from '../../abstract/data.mjs';
+import { AnyDocumentData } from '../../abstract/data.mjs';
+import * as fields from '../fields.mjs';
+import type { ActorData } from './actorData.js';
+import type { CardsData } from './cardsData.js';
+import type { CombatData } from './combatData.js';
+import type { FolderData } from './folderData.js';
+import type { ItemData } from './itemData.js';
+import type { JournalEntryData } from './journalEntryData.js';
+import type { MacroData } from './macroData.js';
+import type { PlaylistData } from './playlistData.js';
+import type { RollTableData } from './rollTableData.js';
+import type { SceneData } from './sceneData.js';
+
+interface AdventureDataSchema extends DocumentSchema {
+  _id: fields.DocumentId;
+  name: fields.RequiredString;
+  img: fields.ImageField;
+  description: fields.BlankString;
+  actors: AdventureDocumentsField<typeof ActorData>;
+  combats: AdventureDocumentsField<typeof CombatData>;
+  items: AdventureDocumentsField<typeof ItemData>;
+  scenes: AdventureDocumentsField<typeof SceneData>;
+  journal: AdventureDocumentsField<typeof JournalEntryData>;
+  tables: AdventureDocumentsField<typeof RollTableData>;
+  macros: AdventureDocumentsField<typeof MacroData>;
+  cards: AdventureDocumentsField<typeof CardsData>;
+  playlists: AdventureDocumentsField<typeof PlaylistData>;
+  folders: AdventureDocumentsField<typeof FolderData>;
+  sort: fields.IntegerSortField;
+  flags: fields.ObjectField;
+}
+
+interface AdventureDataProperties {
+  /** @defaultValue `null` */
+  _id: string | null;
+
+  name: string;
+
+  img: string | null | undefined;
+
+  /** @defaultValue `""` */
+  description: string;
+
+  /** @defaultValue `[]` */
+  actors: ActorData[];
+
+  /** @defaultValue `[]` */
+  combats: CombatData[];
+
+  /** @defaultValue `[]` */
+  items: ItemData[];
+
+  /** @defaultValue `[]` */
+  scenes: SceneData[];
+
+  /** @defaultValue `[]` */
+  journal: JournalEntryData[];
+
+  /** @defaultValue `[]` */
+  tables: RollTableData[];
+
+  /** @defaultValue `[]` */
+  macros: MacroData[];
+
+  /** @defaultValue `[]` */
+  cards: CardsData[];
+
+  /** @defaultValue `[]` */
+  playlists: PlaylistData[];
+
+  /** @defaultValue `[]` */
+  folders: FolderData[];
+
+  /** @defaultValue `0` */
+  sort: number;
+
+  /** @defaultValue `{}` */
+  flags: Record<string, unknown>;
+}
+
+interface AdventureDataConstructorData {
+  /** @defaultValue `null` */
+  _id?: string | null | undefined;
+
+  name: string;
+
+  img?: string | null | undefined;
+
+  /** @defaultValue `""` */
+  description?: string | null | undefined;
+
+  /** @defaultValue `[]` */
+  actors?: ActorData[] | null | undefined;
+
+  /** @defaultValue `[]` */
+  combats?: CombatData[] | null | undefined;
+
+  /** @defaultValue `[]` */
+  items?: ItemData[] | null | undefined;
+
+  /** @defaultValue `[]` */
+  scenes?: SceneData[] | null | undefined;
+
+  /** @defaultValue `[]` */
+  journal?: JournalEntryData[] | null | undefined;
+
+  /** @defaultValue `[]` */
+  tables?: RollTableData[] | null | undefined;
+
+  /** @defaultValue `[]` */
+  macros?: MacroData[] | null | undefined;
+
+  /** @defaultValue `[]` */
+  cards?: CardsData[] | null | undefined;
+
+  /** @defaultValue `[]` */
+  playlists?: PlaylistData[] | null | undefined;
+
+  /** @defaultValue `[]` */
+  folders?: FolderData[] | null | undefined;
+
+  /** @defaultValue `0` */
+  sort?: number | null | undefined;
+
+  /** @defaultValue `{}` */
+  flags?: Record<string, unknown> | null | undefined;
+}
+
+/**
+ * A data schema which encompasses a collection of base Documents which comprise an adventure module.
+ *
+ * WARNING: This data schema is an early prototype which will be fully implemented in V10.
+ * Until then it is for internal use only. Use this at your own risk.
+ * @internal
+ *
+ * @see BaseAdventure
+ */
+export class AdventureData extends DocumentData<
+  AdventureDataSchema,
+  AdventureDataProperties,
+  PropertiesToSource<AdventureDataProperties>,
+  AdventureDataConstructorData
+> {
+  /** @override */
+  static defineSchema(): AdventureDataSchema;
+
+  /**
+   * A type of data field which stores a collection of document data objects
+   * @typeParam D - the type of the DocumentData constructor
+   */
+  static ADVENTURE_DOCUMENTS_FIELD<D extends ConstructorOf<AnyDocumentData>>(dataCls: D): AdventureDocumentsField<D>;
+}
+
+/**
+ * Property type: `D[]`
+ * Constructor type: `D[] | null | undefined`
+ * Default: `[]`
+ */
+type AdventureDocumentsField<D extends ConstructorOf<AnyDocumentData>> = DocumentField<D> & {
+  type: [D];
+  required: true;
+  default: [];
+};