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

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

@@ -1,39 +1,49 @@
-import { ConfiguredFlags, FieldReturnType, PropertiesToSource } from '../../../../types/helperTypes';
+import {
+  ConfiguredDocumentClass,
+  ConfiguredFlags,
+  FieldReturnType,
+  PropertiesToSource
+} from '../../../../types/helperTypes';
 import { DocumentData } from '../../abstract/module.mjs';
-import { CONST, documents } from '../../module.mjs';
+import { documents } from '../../module.mjs';
 import * as fields from '../fields.mjs';
 import { ChatSpeakerData, ChatSpeakerDataConstructorData } from './chatSpeakerData';
 
 interface ChatMessageDataSchema extends DocumentSchema {
-  _id: typeof fields.DOCUMENT_ID;
-  type: DocumentField<CONST.ChatMessageType> & {
+  _id: fields.DocumentId;
+  type: DocumentField<foundry.CONST.CHAT_MESSAGE_TYPES> & {
     type: typeof Number;
     required: true;
-    default: typeof CONST.CHAT_MESSAGE_TYPES.OTHER;
+    default: typeof foundry.CONST.CHAT_MESSAGE_TYPES.OTHER;
     validate: typeof _validateChatMessageType;
     validationError: 'The provided ChatMessage type must be in CONST.CHAT_MESSAGE_TYPES';
   };
   user: fields.ForeignDocumentField<{ type: typeof documents.BaseUser; required: true }>;
-  timestamp: FieldReturnType<typeof fields.TIMESTAMP_FIELD, { required: true }>;
-  flavor: typeof fields.STRING_FIELD;
-  content: typeof fields.BLANK_STRING;
-  speaker: DocumentField<ChatSpeakerData> & { type: typeof ChatSpeakerData; required: true; default: {} };
+  timestamp: FieldReturnType<fields.TimestampField, { required: true }>;
+  flavor: fields.StringField;
+  content: fields.BlankString;
+  speaker: DocumentField<ChatSpeakerData> & {
+    type: typeof ChatSpeakerData;
+    required: true;
+    default: Record<string, never>;
+  };
   whisper: DocumentField<string[]> & {
-    type: typeof String[];
+    type: [typeof String];
     clean: (users: Array<{ id: string } | string>) => string[];
     required: true;
     default: string[];
   };
-  blind: typeof fields.BOOLEAN_FIELD;
-  roll: typeof fields.JSON_FIELD;
-  sound: typeof fields.AUDIO_FIELD;
-  emote: typeof fields.BOOLEAN_FIELD;
-  flags: typeof fields.OBJECT_FIELD;
+  blind: fields.BooleanField;
+  roll: fields.JsonField;
+  sound: fields.AudioField;
+  emote: fields.BooleanField;
+  flags: fields.ObjectField;
 }
 
 interface ChatMessageDataProperties {
   /**
    * The _id which uniquely identifies this ChatMessage document
+   * @defaultValue `null`
    */
   _id: string | null;
 
@@ -41,10 +51,11 @@ interface ChatMessageDataProperties {
    * The message type from CONST.CHAT_MESSAGE_TYPES
    * @defaultValue `CONST.CHAT_MESSAGE_TYPES.OTHER`
    */
-  type: CONST.ChatMessageType;
+  type: foundry.CONST.CHAT_MESSAGE_TYPES;
 
   /**
    * The _id of the User document who generated this message
+   * @defaultValue `null`
    */
   user: string | null;
 
@@ -57,7 +68,7 @@ interface ChatMessageDataProperties {
   /**
    * An optional flavor text message which summarizes this message
    */
-  flavor?: string;
+  flavor: string | undefined;
 
   /**
    * The HTML content of this chat message
@@ -67,6 +78,7 @@ interface ChatMessageDataProperties {
 
   /**
    * A ChatSpeakerData object which describes the origin of the ChatMessage
+   * @defaultValue `new ChatSpeakerData({})`
    */
   speaker: ChatSpeakerData;
 
@@ -84,15 +96,13 @@ interface ChatMessageDataProperties {
 
   /**
    * The serialized content of a Roll instance which belongs to the ChatMessage
-   * @defaultValue `undefined`
    */
-  roll?: string;
+  roll: string | undefined;
 
   /**
    * The URL of an audio file which plays when this message is received
-   * @defaultValue `undefined`
    */
-  sound?: string | null;
+  sound: string | null | undefined;
 
   /**
    * Is this message styled as an emote?
@@ -107,97 +117,99 @@ interface ChatMessageDataProperties {
   flags: ConfiguredFlags<'ChatMessage'>;
 }
 
-export interface ChatMessageDataConstructorData {
+interface ChatMessageDataConstructorData {
   /**
    * The _id which uniquely identifies this ChatMessage document
+   * @defaultValue `null`
    */
-  _id?: string | null;
+  _id?: string | null | undefined;
 
   /**
    * The message type from CONST.CHAT_MESSAGE_TYPES
    * @defaultValue `CONST.CHAT_MESSAGE_TYPES.OTHER`
    */
-  type?: CONST.ChatMessageType | null;
+  type?: foundry.CONST.CHAT_MESSAGE_TYPES | null | undefined;
 
   /**
    * The _id of the User document who generated this message
+   * @defaultValue `null`
    */
-  user?: string | null;
+  user?: InstanceType<ConfiguredDocumentClass<typeof documents.BaseUser>> | string | null | undefined;
 
   /**
    * The timestamp at which point this message was generated
    * @defaultValue `Date.now()`
    */
-  timestamp?: number | null;
+  timestamp?: number | null | undefined;
 
   /**
    * An optional flavor text message which summarizes this message
    */
-  flavor?: string | null;
+  flavor?: string | null | undefined;
 
   /**
    * The HTML content of this chat message
    * @defaultValue `""`
    */
-  content?: string | null;
+  content?: string | null | undefined;
 
   /**
    * A ChatSpeakerData object which describes the origin of the ChatMessage
+   * @defaultValue `new ChatSpeakerData({})`
    */
-  speaker?: ChatSpeakerDataConstructorData | null;
+  speaker?: ChatSpeakerDataConstructorData | null | undefined;
 
   /**
    * An array of User _id values to whom this message is privately whispered
    * @defaultValue `[]`
    */
-  whisper?: Array<{ id: string } | string> | null;
+  whisper?: Array<{ id: string } | string> | null | undefined;
 
   /**
    * Is this message sent blindly where the creating User cannot see it?
    * @defaultValue `false`
    */
-  blind?: boolean | null;
+  blind?: boolean | null | undefined;
 
   /**
    * The serialized content of a Roll instance which belongs to the ChatMessage
-   * @defaultValue `undefined`
    */
-  roll?: string | null;
+  roll?: string | object | null | undefined;
 
   /**
    * The URL of an audio file which plays when this message is received
-   * @defaultValue `undefined`
    */
-  sound?: string | null;
+  sound?: string | null | undefined;
 
   /**
    * Is this message styled as an emote?
    * @defaultValue `false`
    */
-  emote?: boolean | null;
+  emote?: boolean | null | undefined;
 
   /**
    * An object of optional key/value flags
    * @defaultValue `{}`
    */
-  flags?: ConfiguredFlags<'ChatMessage'> | null;
+  flags?: ConfiguredFlags<'ChatMessage'> | null | undefined;
 }
 
 /**
  * An embedded data object which defines the properties of a light source animation
  */
-export declare class ChatMessageData extends DocumentData<
+export class ChatMessageData extends DocumentData<
   ChatMessageDataSchema,
   ChatMessageDataProperties,
   PropertiesToSource<ChatMessageDataProperties>,
   ChatMessageDataConstructorData,
   documents.BaseChatMessage
 > {
+  /** @override */
   static defineSchema(): ChatMessageDataSchema;
 }
 
 // eslint-disable-next-line @typescript-eslint/no-empty-interface
-export declare interface ChatMessageData extends ChatMessageDataProperties {}
+export interface ChatMessageData extends ChatMessageDataProperties {}
 
 /**
  * Validate that a ChatMessage has a valid type

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

@@ -1,72 +1,79 @@
-import { FieldReturnType, PropertiesToSource } from '../../../../types/helperTypes';
+import { ConfiguredDocumentClass, FieldReturnType, PropertiesToSource } from '../../../../types/helperTypes';
 import { DocumentData } from '../../abstract/module.mjs';
 import { BaseActor, BaseChatMessage, BaseScene } from '../../documents.mjs';
-import { ForeignDocumentField } from '../fields.mjs';
 import * as fields from '../fields.mjs';
+import { ForeignDocumentField } from '../fields.mjs';
 
 interface ChatSpeakerDataSchema extends DocumentSchema {
   scene: ForeignDocumentField<{ type: typeof BaseScene; required: false }>;
   actor: ForeignDocumentField<{ type: typeof BaseActor; required: false }>;
-  token: FieldReturnType<typeof fields.DOCUMENT_ID, { required: false }>;
-  alias: typeof fields.STRING_FIELD;
+  token: FieldReturnType<fields.DocumentId, { required: false }>;
+  alias: fields.StringField;
 }
 
 interface ChatSpeakerDataProperties {
   /**
    * The _id of the Scene where this message was created
+   * @defaultValue `null`
    */
   scene: string | null;
 
   /**
    * The _id of the Actor who generated this message
+   * @defaultValue `null`
    */
   actor: string | null;
 
   /**
    * The _id of the Token who generated this message
+   * @defaultValue `null`
    */
   token: string | null;
 
   /**
    * An overridden alias name used instead of the Actor or Token name
    */
-  alias?: string;
+  alias: string | undefined;
 }
 
 interface ChatSpeakerDataConstructorData {
   /**
    * The _id of the Scene where this message was created
+   * @defaultValue `null`
    */
-  scene?: string | null;
+  scene?: InstanceType<ConfiguredDocumentClass<typeof foundry.documents.BaseScene>> | string | null | undefined;
 
   /**
    * The _id of the Actor who generated this message
+   * @defaultValue `null`
    */
-  actor?: string | null;
+  actor?: InstanceType<ConfiguredDocumentClass<typeof foundry.documents.BaseActor>> | string | null | undefined;
 
   /**
    * The _id of the Token who generated this message
+   * @defaultValue `null`
    */
-  token?: string | null;
+  token?: string | null | undefined;
 
   /**
    * An overridden alias name used instead of the Actor or Token name
    */
-  alias?: string | null;
+  alias?: string | null | undefined;
 }
 
 /**
  * An embedded data object which defines the properties of a light source animation
  */
-export declare class ChatSpeakerData extends DocumentData<
+export class ChatSpeakerData extends DocumentData<
   ChatSpeakerDataSchema,
   ChatSpeakerDataProperties,
   PropertiesToSource<ChatSpeakerDataProperties>,
   ChatSpeakerDataConstructorData,
   BaseChatMessage
 > {
+  /** @override */
   static defineSchema(): ChatSpeakerDataSchema;
 }
 
 // eslint-disable-next-line @typescript-eslint/no-empty-interface
-export declare interface ChatSpeakerData extends ChatSpeakerDataProperties {}
+export interface ChatSpeakerData extends ChatSpeakerDataProperties {}

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

@@ -1,7 +1,6 @@
 import {
   ConfiguredDocumentClass,
   ConfiguredFlags,
-  ConstructorDataType,
   FieldReturnType,
   PropertiesToSource
 } from '../../../../types/helperTypes';
@@ -9,27 +8,44 @@ 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 { CombatantData } from './combatantData';
+import { CombatantDataConstructorData } from './combatantData';
 
 interface CombatDataSchema extends DocumentSchema {
-  _id: typeof fields.DOCUMENT_ID;
+  _id: fields.DocumentId;
   scene: fields.ForeignDocumentField<{ type: typeof documents.BaseScene }>;
   combatants: fields.EmbeddedCollectionField<typeof documents.BaseCombatant>;
-  active: typeof fields.BOOLEAN_FIELD;
-  round: FieldReturnType<typeof fields.NONNEGATIVE_INTEGER_FIELD, { default: 0; required: true }>;
-  turn: FieldReturnType<typeof fields.NONNEGATIVE_INTEGER_FIELD, { default: 0; required: true }>;
-  sort: typeof fields.INTEGER_SORT_FIELD;
-  flags: typeof fields.OBJECT_FIELD;
+  active: fields.BooleanField;
+  round: FieldReturnType<fields.NonnegativeIntegerField, { default: 0; required: true }>;
+  turn: FieldReturnType<
+    fields.NonnegativeIntegerField,
+    {
+      default: 0;
+      required: true;
+      nullable: true;
+      validate: (n: unknown) => boolean;
+    }
+  >;
+  sort: fields.IntegerSortField;
+  flags: fields.ObjectField;
 }
 
 interface CombatDataProperties {
-  /** The _id which uniquely identifies this Combat document */
+  /**
+   * The _id which uniquely identifies this Combat document
+   * @defaultValue `null`
+   */
   _id: string | null;
 
-  /** The _id of a Scene within which this Combat occurs */
+  /**
+   * The _id of a Scene within which this Combat occurs
+   * @defaultValue `null`
+   */
   scene: string | null;
 
-  /** A Collection of Combatant embedded Documents */
+  /**
+   * A Collection of Combatant embedded Documents
+   * @defaultValue `new EmbeddedCollection(CombatantData, [], BaseCombatant.implementation)`
+   */
   combatants: EmbeddedCollection<ConfiguredDocumentClass<typeof documents.BaseCombatant>, CombatData>;
 
   /**
@@ -48,7 +64,7 @@ interface CombatDataProperties {
    * The current turn in the Combat round
    * @defaultValue `0`
    */
-  turn: number;
+  turn: number | null;
 
   /**
    * The current sort order of this Combat relative to others in the same Scene
@@ -64,59 +80,69 @@ interface CombatDataProperties {
 }
 
 interface CombatDataConstructorData {
-  /** The _id which uniquely identifies this Combat document */
-  _id?: string | null;
+  /**
+   * The _id which uniquely identifies this Combat document
+   * @defaultValue `null`
+   */
+  _id?: string | null | undefined;
 
-  /** The _id of a Scene within which this Combat occurs */
-  scene?: string | null;
+  /**
+   * The _id of a Scene within which this Combat occurs
+   * @defaultValue `null`
+   */
+  scene?: InstanceType<ConfiguredDocumentClass<typeof documents.BaseScene>> | string | null | undefined;
 
-  /** A Collection of Combatant embedded Documents */
-  combatants?: ConstructorDataType<CombatantData>[] | null;
+  /**
+   * A Collection of Combatant embedded Documents
+   * @defaultValue `new EmbeddedCollection(CombatantData, [], BaseCombatant.implementation)`
+   */
+  combatants?: CombatantDataConstructorData[] | null | undefined;
 
   /**
    * Is the Combat encounter currently active?
    * @defaultValue `false`
    */
-  active?: boolean | null;
+  active?: boolean | null | undefined;
 
   /**
    * The current round of the Combat encounter
    * @defaultValue `0`
    */
-  round?: number | null;
+  round?: number | null | undefined;
 
   /**
    * The current turn in the Combat round
    * @defaultValue `0`
    */
-  turn?: number | null;
+  turn?: number | null | undefined;
 
   /**
    * The current sort order of this Combat relative to others in the same Scene
    * @defaultValue `0`
    */
-  sort?: number | null;
+  sort?: number | null | undefined;
 
   /**
    * An object of optional key/value flags
    * @defaultValue `{}`
    */
-  flags?: ConfiguredFlags<'Combat'> | null;
+  flags?: ConfiguredFlags<'Combat'> | null | undefined;
 }
 
 /**
  * The data schema for an Combat document.
  * @see BaseCombat
  */
-export declare class CombatData extends DocumentData<
+export class CombatData extends DocumentData<
   CombatDataSchema,
   CombatDataProperties,
   PropertiesToSource<CombatDataProperties>,
   CombatDataConstructorData,
   documents.BaseCombat
 > {
+  /** @override */
   static defineSchema(): CombatDataSchema;
 }
 
 // eslint-disable-next-line @typescript-eslint/no-empty-interface
-export declare interface CombatData extends CombatDataProperties {}
+export interface CombatData extends CombatDataProperties {}

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

@@ -1,40 +1,51 @@
-import { ConfiguredFlags, PropertiesToSource } from '../../../../types/helperTypes';
+import { ConfiguredDocumentClass, ConfiguredFlags, PropertiesToSource } from '../../../../types/helperTypes';
 import { DocumentData } from '../../abstract/module.mjs';
 import * as documents from '../../documents.mjs';
 import * as fields from '../fields.mjs';
 
 interface CombatantDataSchema extends DocumentSchema {
-  _id: typeof fields.DOCUMENT_ID;
+  _id: fields.DocumentId;
   actorId: fields.ForeignDocumentField<{ type: typeof documents.BaseActor }>;
   tokenId: fields.ForeignDocumentField<{ type: typeof documents.BaseToken }>;
-  name: typeof fields.STRING_FIELD;
-  img: typeof fields.IMAGE_FIELD;
-  initiative: typeof fields.NUMERIC_FIELD;
-  hidden: typeof fields.BOOLEAN_FIELD;
-  defeated: typeof fields.BOOLEAN_FIELD;
-  flags: typeof fields.OBJECT_FIELD;
+  sceneId: fields.ForeignDocumentField<{ type: typeof documents.BaseScene }>;
+  name: fields.StringField;
+  img: fields.ImageField;
+  initiative: fields.NumericField;
+  hidden: fields.BooleanField;
+  defeated: fields.BooleanField;
+  flags: fields.ObjectField;
 }
 
 interface CombatantDataProperties {
-  /** The _id which uniquely identifies this Combatant embedded document */
+  /**
+   * The _id which uniquely identifies this Combatant embedded document
+   * @defaultValue `null`
+   */
   _id: string | null;
 
   /**
    * The _id of an Actor associated with this Combatant
+   * @defaultValue `null`
    */
   actorId: string | null;
 
-  /** The _id of a Token associated with this Combatant */
+  /**
+   * The _id of a Token associated with this Combatant
+   * @defaultValue `null`
+   */
   tokenId: string | null;
 
+  /** @defaultValue `null` */
+  sceneId: string | null;
+
   /** A customized name which replaces the name of the Token in the tracker */
   name: string | undefined;
 
   /** A customized image which replaces the Token image in the tracker */
-  img: string | undefined | null;
+  img: string | null | undefined;
 
   /** The initiative score for the Combatant which determines its turn order */
-  initiative: number | undefined | null;
+  initiative: number | null | undefined;
 
   /**
    * Is this Combatant currently hidden?
@@ -55,63 +66,70 @@ interface CombatantDataProperties {
   flags: ConfiguredFlags<'Combatant'>;
 }
 
-export interface CombatantDataConstructorData {
-  /** The _id which uniquely identifies this Combatant embedded document */
-  _id?: string | null;
+interface CombatantDataConstructorData {
+  /**
+   * The _id which uniquely identifies this Combatant embedded document
+   * @defaultValue `null`
+   */
+  _id?: string | null | undefined;
 
   /**
    * The _id of an Actor associated with this Combatant
+   * @defaultValue `null`
+   */
+  actorId?: InstanceType<ConfiguredDocumentClass<typeof documents.BaseActor>> | string | null | undefined;
+
+  /**
+   * The _id of a Token associated with this Combatant
+   * @defaultValue `null`
    */
-  actorId?: string | null;
+  tokenId?: InstanceType<ConfiguredDocumentClass<typeof documents.BaseToken>> | string | null | undefined;
 
-  /** The _id of a Token associated with this Combatant */
-  tokenId?: string | null;
+  /** @defaultValue `null` */
+  sceneId?: InstanceType<ConfiguredDocumentClass<typeof documents.BaseScene>> | string | null | undefined;
 
   /** A customized name which replaces the name of the Token in the tracker */
-  name?: string | null;
+  name?: string | null | undefined;
 
   /** A customized image which replaces the Token image in the tracker */
-  img?: string | null;
+  img?: string | null | undefined;
 
   /** The initiative score for the Combatant which determines its turn order */
-  initiative?: number | null;
+  initiative?: number | null | undefined;
 
   /**
    * Is this Combatant currently hidden?
    * @defaultValue `false`
    */
-  hidden?: boolean | null;
+  hidden?: boolean | null | undefined;
 
   /**
    * Has this Combatant been defeated?
    * @defaultValue `false`
    */
-  defeated?: boolean | null;
+  defeated?: boolean | null | undefined;
 
   /**
    * An object of optional key/value flags
    * @defaultValue `{}`
    */
-  flags?: ConfiguredFlags<'Combatant'> | null;
+  flags?: ConfiguredFlags<'Combatant'> | null | undefined;
 }
 
 /**
  * The data schema for a Combatant embedded document within a CombatEncounter document.
  * @see CombatantData
  */
-export declare class CombatantData extends DocumentData<
+export class CombatantData extends DocumentData<
   CombatantDataSchema,
   CombatantDataProperties,
   PropertiesToSource<CombatantDataProperties>,
   CombatantDataConstructorData,
   documents.BaseCombatant
 > {
-  /**
-   *  @remarks
-   *  This constructor only exists to restrict the type
-   */
+  /** @override */
   static defineSchema(): CombatantDataSchema;
 }
 
 // eslint-disable-next-line @typescript-eslint/no-empty-interface
-export declare interface CombatantData extends CombatantDataProperties {}
+export interface CombatantData extends CombatantDataProperties {}

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

@@ -4,8 +4,8 @@ import { BaseAmbientLight } from '../../documents.mjs';
 import * as fields from '../fields.mjs';
 
 interface DarknessActivationSchema extends DocumentSchema {
-  min: FieldReturnType<typeof fields.ALPHA_FIELD, { default: 0 }>;
-  max: typeof fields.ALPHA_FIELD;
+  min: FieldReturnType<fields.AlphaField, { default: 0 }>;
+  max: fields.AlphaField;
 }
 
 interface DarknessActivationProperties {
@@ -22,32 +22,33 @@ interface DarknessActivationProperties {
   max: number;
 }
 
-export interface DarknessActivationConstructorData {
+interface DarknessActivationConstructorData {
   /**
    * The minimum darkness level for which activation occurs
    * @defaultValue `0`
    */
-  min?: number | null;
+  min?: number | null | undefined;
 
   /**
    * The maximum darkness level for which activation occurs
    * @defaultValue `1`
    */
-  max?: number | null;
+  max?: number | null | undefined;
 }
 
 /**
  * An embedded data object which defines the darkness range during which some attribute is active
  */
-export declare class DarknessActivation extends DocumentData<
+export class DarknessActivation extends DocumentData<
   DarknessActivationSchema,
   DarknessActivationProperties,
   PropertiesToSource<DarknessActivationProperties>,
   DarknessActivationConstructorData,
   BaseAmbientLight
 > {
+  /** @override */
   static defineSchema(): DarknessActivationSchema;
 }
 
 // eslint-disable-next-line @typescript-eslint/no-empty-interface
-export declare interface DarknessActivation extends DarknessActivationProperties {}
+export interface DarknessActivation extends DarknessActivationProperties {}