@league-of-foundry-developers/foundry-vtt-types 0.8.9-7 → 9.238.1

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

@@ -4,26 +4,27 @@ import * as documents from '../../documents.mjs';
 import * as fields from '../fields.mjs';
 
 interface SettingDataSchema extends DocumentSchema {
-  _id: typeof fields.DOCUMENT_ID;
+  _id: fields.DocumentId;
   key: DocumentField<string> & {
     type: typeof String;
     required: true;
     validate: typeof _validateKeyFormat;
     validationError: 'Invalid setting key format which should be {scope}.{field}';
   };
-  value: FieldReturnType<typeof fields.JSON_FIELD, { required: true }>;
+  value: FieldReturnType<fields.JsonField, { required: true }>;
 }
 
 interface SettingDataProperties {
   /**
    * The _id which uniquely identifies this Setting document
+   * @defaultValue `null`
    */
   _id: string | null;
 
   /**
    * The setting key, a composite of \{scope\}.\{name\}
    */
-  key: string;
+  key: `${string}.${string}`;
 
   /**
    * The setting value, which may be any type of data
@@ -35,26 +36,27 @@ interface SettingDataProperties {
 interface SettingDataConstructorData {
   /**
    * The _id which uniquely identifies this Setting document
+   * @defaultValue `null`
    */
-  _id?: string | null;
+  _id?: string | null | undefined;
 
   /**
    * The setting key, a composite of \{scope\}.\{name\}
    */
-  key: string;
+  key: `${string}.${string}`;
 
   /**
    * The setting value, which may be any type of data
    * @remarks This is the stringified data
    */
-  value: string;
+  value: string | object;
 }
 
 /**
  * The data schema for a Setting document.
  * @see BaseSetting
  */
-export declare class SettingData extends DocumentData<
+export class SettingData extends DocumentData<
   SettingDataSchema,
   SettingDataProperties,
   PropertiesToSource<SettingDataProperties>,
@@ -68,11 +70,12 @@ export declare class SettingData extends DocumentData<
    */
   constructor(data: SettingDataConstructorData, document?: documents.BaseSetting | null);
 
+  /** @override */
   static defineSchema(): SettingDataSchema;
 }
 
 // eslint-disable-next-line @typescript-eslint/no-empty-interface
-export declare interface SettingData extends SettingDataProperties {}
+export interface SettingData extends SettingDataProperties {}
 
 /**
  * Validate that each setting key matches the expected format

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

@@ -4,27 +4,27 @@ import { BaseTableResult } from '../../documents.mjs';
 import { fields } from '../module.mjs';
 
 interface TableResultDataSchema extends DocumentSchema {
-  _id: typeof fields.DOCUMENT_ID;
-  type: DocumentField<foundry.CONST.TableResultType> & {
+  _id: fields.DocumentId;
+  type: DocumentField<foundry.CONST.TABLE_RESULT_TYPES> & {
     type: typeof Number;
-    default: typeof CONST.TABLE_RESULT_TYPES.TEXT;
-    validate: (t: unknown) => t is foundry.CONST.TableResultType;
+    default: typeof foundry.CONST.TABLE_RESULT_TYPES.TEXT;
+    validate: (t: unknown) => t is foundry.CONST.TABLE_RESULT_TYPES;
     validationError: 'Invalid TableResult type provided';
   };
-  text: typeof fields.BLANK_STRING;
-  img: typeof fields.IMAGE_FIELD;
-  collection: typeof fields.STRING_FIELD;
-  resultId: typeof fields.STRING_FIELD;
-  weight: typeof fields.POSITIVE_INTEGER_FIELD;
-  range: {
+  text: fields.BlankString;
+  img: fields.ImageField;
+  collection: fields.StringField;
+  resultId: fields.StringField;
+  weight: fields.PositiveIntegerField;
+  range: DocumentField<[number, number]> & {
     type: [typeof Number];
     required: true;
     default: [];
     validate: typeof _isValidResultRange;
     validationError: 'Invalid TableResult range which must be a length-2 array of ascending integers';
   };
-  drawn: typeof fields.BOOLEAN_FIELD;
-  flags: typeof fields.OBJECT_FIELD;
+  drawn: fields.BooleanField;
+  flags: fields.ObjectField;
 }
 
 /**
@@ -46,17 +46,18 @@ interface TableResultDataProperties {
    * A result sub-type from CONST.TABLE_RESULT_TYPES
    * @defaultValue `CONST.TABLE_RESULT_TYPES.TEXT`
    */
-  type: foundry.CONST.TableResultType;
+  type: foundry.CONST.TABLE_RESULT_TYPES;
 
   /**
    * The text which describes the table result
+   * @defaultValue `""`
    */
   text: string;
 
   /**
    * An image file url that represents the table result
    */
-  img: string | undefined;
+  img: string | null | undefined;
 
   /**
    * A named collection from which this result is drawn
@@ -70,7 +71,6 @@ interface TableResultDataProperties {
 
   /**
    * The probabilistic weight of this result relative to other results
-   * @defaultValue `1`
    */
   weight: number | undefined;
 
@@ -98,39 +98,39 @@ interface TableResultDataConstructorData {
    * The _id which uniquely identifies this TableResult embedded document
    * @defaultValue `null`
    */
-  _id?: string | null;
+  _id?: string | null | undefined;
 
   /**
    * A result sub-type from CONST.TABLE_RESULT_TYPES
    * @defaultValue `CONST.TABLE_RESULT_TYPES.TEXT`
    */
-  type?: foundry.CONST.TableResultType | null | undefined;
+  type?: foundry.CONST.TABLE_RESULT_TYPES | null | undefined;
 
   /**
    * The text which describes the table result
+   * @defaultValue `""`
    */
-  text?: string | null;
+  text?: string | null | undefined;
 
   /**
    * An image file url that represents the table result
    */
-  img?: string | undefined | null;
+  img?: string | null | undefined;
 
   /**
    * A named collection from which this result is drawn
    */
-  collection?: string | undefined | null;
+  collection?: string | null | undefined;
 
   /**
    * The _id of a Document within the collection this result references
    */
-  resultId?: string | undefined | null;
+  resultId?: string | null | undefined;
 
   /**
    * The probabilistic weight of this result relative to other results
-   * @defaultValue `1`
    */
-  weight?: number | undefined | null;
+  weight?: number | null | undefined;
 
   /**
    * A length 2 array of ascending integers which defines the range of dice roll
@@ -142,21 +142,25 @@ interface TableResultDataConstructorData {
    * Has this result already been drawn (without replacement)
    * @defaultValue `false`
    */
-  drawn?: boolean | undefined | null;
+  drawn?: boolean | null | undefined;
 
   /**
    * An object of optional key/value flags
    * @defaultValue `{}`
    */
-  flags?: ConfiguredFlags<'TableResult'> | undefined | null;
+  flags?: ConfiguredFlags<'TableResult'> | null | undefined;
 }
 
-export declare class TableResultData extends DocumentData<
+export class TableResultData extends DocumentData<
   TableResultDataSchema,
   TableResultDataProperties,
   PropertiesToSource<TableResultDataProperties>,
   TableResultDataConstructorData,
   BaseTableResult
 > {
+  /** @override */
   static defineSchema(): TableResultDataSchema;
 }
+
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export declare interface TableResultData extends TableResultDataProperties {}

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

@@ -1,40 +1,41 @@
-import { TileOcclusion, TileOcclusionConstructorData } from './tileOcclusion';
-import { VideoData, VideoDataConstructorData } from './videoData';
 import { ConfiguredFlags, FieldReturnType, PropertiesToSource } from '../../../../types/helperTypes';
 import DocumentData from '../../abstract/data.mjs';
 import * as documents from '../../documents.mjs';
 import * as fields from '../fields.mjs';
+import { TileOcclusion, TileOcclusionConstructorData } from './tileOcclusion';
+import { VideoData, VideoDataConstructorData } from './videoData';
 
 interface TileDataSchema extends DocumentSchema {
-  _id: typeof fields.DOCUMENT_ID;
-  img: typeof fields.VIDEO_FIELD;
-  width: typeof fields.REQUIRED_NUMBER;
-  height: typeof fields.REQUIRED_NUMBER;
-  x: typeof fields.REQUIRED_NUMBER;
-  y: typeof fields.REQUIRED_NUMBER;
-  z: FieldReturnType<typeof fields.INTEGER_FIELD, { required: true; default: 100 }>;
-  rotation: FieldReturnType<typeof fields.ANGLE_FIELD, { default: 0 }>;
-  alpha: typeof fields.ALPHA_FIELD;
-  tint: typeof fields.COLOR_FIELD;
-  hidden: typeof fields.BOOLEAN_FIELD;
-  locked: typeof fields.BOOLEAN_FIELD;
-  overhead: FieldReturnType<typeof fields.BOOLEAN_FIELD, { default: false }>;
+  _id: fields.DocumentId;
+  img: fields.VideoField;
+  width: fields.RequiredNumber;
+  height: fields.RequiredNumber;
+  x: fields.RequiredNumber;
+  y: fields.RequiredNumber;
+  z: FieldReturnType<fields.IntegerField, { required: true; default: 100 }>;
+  rotation: FieldReturnType<fields.AngleField, { default: 0 }>;
+  alpha: fields.AlphaField;
+  tint: fields.ColorField;
+  hidden: fields.BooleanField;
+  locked: fields.BooleanField;
+  overhead: FieldReturnType<fields.BooleanField, { default: false }>;
   occlusion: DocumentField<TileOcclusion> & {
     type: typeof TileOcclusion;
     required: false;
-    default: {};
+    default: Record<string, never>;
   };
   video: DocumentField<VideoData> & {
     type: typeof VideoData;
     required: false;
-    default: {};
+    default: Record<string, never>;
   };
-  flags: typeof fields.OBJECT_FIELD;
+  flags: fields.ObjectField;
 }
 
 interface TileDataProperties {
   /**
    * The _id which uniquely identifies this Tile embedded document
+   * @defaultValue `null`
    */
   _id: string | null;
 
@@ -110,11 +111,13 @@ interface TileDataProperties {
 
   /**
    * The tile's occlusion settings
+   * @defaultValue `new TileOcclusion({})`
    */
   occlusion: TileOcclusion;
 
   /**
    * The tile's video settings
+   * @defaultValue `new VideoData({})`
    */
   video: VideoData;
 
@@ -128,107 +131,111 @@ interface TileDataProperties {
 interface TileDataConstructorData {
   /**
    * The _id which uniquely identifies this Tile embedded document
+   * @defaultValue `null`
    */
-  _id?: string | null;
+  _id?: string | null | undefined;
 
   /**
    * An image or video file path which this tile displays
    */
-  img?: string | null;
+  img?: string | null | undefined;
 
   /**
    * The pixel width of the tile
    * @defaultValue `0`
    */
-  width?: number | null;
+  width?: number | null | undefined;
 
   /**
    * The pixel height of the tile
    * @defaultValue `0`
    */
-  height?: number | null;
+  height?: number | null | undefined;
 
   /**
    * The x-coordinate position of the top-left corner of the tile
    * @defaultValue `0`
    */
-  x?: number | null;
+  x?: number | null | undefined;
 
   /**
    * The y-coordinate position of the top-left corner of the tile
    * @defaultValue `0`
    */
-  y?: number | null;
+  y?: number | null | undefined;
 
   /**
    * The z-index ordering of this tile relative to its siblings
    * @defaultValue `100`
    */
-  z?: number | null;
+  z?: number | null | undefined;
 
   /**
    * The angle of rotation for the tile between 0 and 360
    * @defaultValue `0`
    */
-  rotation?: number | null;
+  rotation?: number | null | undefined;
 
   /**
    * The tile opacity
    * @defaultValue `1`
    */
-  alpha?: number | null;
+  alpha?: number | null | undefined;
 
   /**
    * A color to tint the tile
    */
-  tint?: string | null;
+  tint?: string | null | undefined;
 
   /**
    * Is the tile currently hidden?
    * @defaultValue `false`
    */
-  hidden?: boolean | null;
+  hidden?: boolean | null | undefined;
 
   /**
    * Is the tile currently locked?
    * @defaultValue `false`
    */
-  locked?: boolean | null;
+  locked?: boolean | null | undefined;
 
   /**
    * Is the tile an overhead tile?
    * @defaultValue `false`
    */
-  overhead?: boolean | null;
+  overhead?: boolean | null | undefined;
 
   /**
    * The tile's occlusion settings
+   * @defaultValue `new TileOcclusion({})`
    */
-  occlusion?: TileOcclusionConstructorData | null;
+  occlusion?: TileOcclusionConstructorData | null | undefined;
 
   /**
    * The tile's video settings
+   * @defaultValue `new VideoData({})`
    */
-  video?: VideoDataConstructorData | null;
+  video?: VideoDataConstructorData | null | undefined;
 
   /**
    * An object of optional key/value flags
    * @defaultValue `{}`
    */
-  flags?: ConfiguredFlags<'Tile'> | null;
+  flags?: ConfiguredFlags<'Tile'> | null | undefined;
 }
 
 /**
  * The data schema for a Tile embedded document.
  * @see BaseTile
  */
-export declare class TileData extends DocumentData<
+export class TileData extends DocumentData<
   TileDataSchema,
   TileDataProperties,
   PropertiesToSource<TileDataProperties>,
   TileDataConstructorData,
   documents.BaseTile
 > {
+  /** @override */
   static defineSchema(): TileDataSchema;
 
   /** @override */
@@ -236,4 +243,4 @@ export declare class TileData extends DocumentData<
 }
 
 // eslint-disable-next-line @typescript-eslint/no-empty-interface
-export declare interface TileData extends TileDataProperties {}
+export interface TileData extends TileDataProperties {}

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

@@ -5,14 +5,14 @@ import * as fields from '../fields.mjs';
 
 interface TileOcclusionSchema extends DocumentSchema {
   mode: FieldReturnType<
-    typeof fields.REQUIRED_NUMBER,
+    fields.RequiredNumber,
     {
-      default: typeof CONST.TILE_OCCLUSION_MODES.FADE;
-      validate: (m: unknown) => m is foundry.CONST.TileOcclusionModes;
+      default: typeof foundry.CONST.TILE_OCCLUSION_MODES.FADE;
+      validate: (m: unknown) => m is foundry.CONST.TILE_OCCLUSION_MODES;
       validationError: 'Invalid {name} {field} which must be a value in CONST.TILE_OCCLUSION_MODES';
     }
   >;
-  alpha: FieldReturnType<typeof fields.ALPHA_FIELD, { default: 0 }>;
+  alpha: FieldReturnType<fields.AlphaField, { default: 0 }>;
 }
 
 interface TileOcclusionProperties {
@@ -20,7 +20,7 @@ interface TileOcclusionProperties {
    * The occlusion mode from CONST.TILE_OCCLUSION_MODES
    * @defaultValue `CONST.TILE_OCCLUSION_MODES.FADE`
    */
-  mode: foundry.CONST.TileOcclusionModes;
+  mode: foundry.CONST.TILE_OCCLUSION_MODES;
 
   /**
    * The occlusion alpha between 0 and 1
@@ -29,30 +29,31 @@ interface TileOcclusionProperties {
   alpha: number;
 }
 
-export interface TileOcclusionConstructorData {
+interface TileOcclusionConstructorData {
   /**
    * The occlusion mode from CONST.TILE_OCCLUSION_MODES
    * @defaultValue `CONST.TILE_OCCLUSION_MODES.FADE`
    */
-  mode?: foundry.CONST.TileOcclusionModes | null;
+  mode?: foundry.CONST.TILE_OCCLUSION_MODES | null | undefined;
 
   /**
    * The occlusion alpha between 0 and 1
    * @defaultValue `0`
    */
-  alpha?: number | null;
+  alpha?: number | null | undefined;
 }
 
 /**
  * An inner-object which defines the schema for how Tile occlusion settings are defined
  */
-export declare class TileOcclusion extends DocumentData<
+export class TileOcclusion extends DocumentData<
   TileOcclusionSchema,
   TileOcclusionProperties,
   PropertiesToSource<TileOcclusionProperties>,
   TileOcclusionConstructorData,
   documents.BaseTile
 > {
+  /** @override */
   static defineSchema(): TileOcclusionSchema;
 }
 

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

@@ -14,28 +14,31 @@ interface TokenBarDataSchema extends DocumentSchema {
 interface TokenBarDataProperties {
   /**
    * The attribute path within the Token's Actor data which should be displayed
+   * @defaultValue `null`
    */
   attribute: string | null;
 }
 
-export interface TokenBarDataConstructorData {
+interface TokenBarDataConstructorData {
   /**
    * The attribute path within the Token's Actor data which should be displayed
+   * @defaultValue `null`
    */
-  attribute?: string | null;
+  attribute?: string | null | undefined;
 }
 
 /**
  * An embedded data structure for the contents of a Token attribute bar.
  * @see TokenData
  */
-export declare class TokenBarData extends DocumentData<
+export class TokenBarData extends DocumentData<
   TokenBarDataSchema,
   TokenBarDataProperties,
   PropertiesToSource<TokenBarDataProperties>,
   TokenBarDataConstructorData,
   documents.BaseToken
 > {
+  /** @override */
   static defineSchema(): TokenBarDataSchema;
 }