@league-of-foundry-developers/foundry-vtt-types 12.331.3-beta → 13.340.0

package/src/foundry/client-esm/data/calendar.d.mts

@@ -0,0 +1,213 @@
+import type DataModel from "@common/abstract/data.d.mts";
+import type * as fields from "@common/data/fields.mjs";
+
+declare namespace CalendarData {
+  interface Schema extends fields.DataSchema {
+    /** The name of the calendar being used. */
+    name: fields.StringField<{ required: true; blank: false }>;
+    /** A text description of the calendar configuration. */
+    description: fields.StringField;
+    /** Configuration of years. */
+    years: fields.SchemaField<ConfigYears.Schema, { required: true; nullable: true; initial: null }>;
+    /** Configuration of months. */
+    months: fields.SchemaField<ConfigMonths.Schema, { required: true; nullable: true; initial: null }>;
+    /** Configuration of days. */
+    days: fields.SchemaField<ConfigDays.Schema>;
+    /** Configuration of seasons. */
+    seasons: fields.SchemaField<ConfigSeasons.Schema, { required: true; nullable: true; initial: null }>;
+  }
+
+  /**
+   * The data put in {@link CalendarData._source | `CalendarData._source`}.
+   *
+   * Both `Source` and `PersistedData` are equivalent.
+   */
+  interface Source extends PersistedData {}
+
+  /**
+   * The data necessary to create a document. Used in places like {@link WallDocument.create | `WallDocument.create`}
+   * and {@link WallDocument | `new WallDocument(...)`}.
+   *
+   * For example a {@link fields.SetField | `SetField`} can accept any {@link Iterable | `Iterable`}
+   * with the right values. This means you can pass a `Set` instance, an array of values,
+   * a generator, or any other iterable.
+   * @remarks Equivalent to how Foundry uses CalendarConfig, this is the type of `CONFIG.calendar`
+   * TODO: Replace with CreateData and convert to interface
+   */
+  type CreateData = fields.SchemaField.AssignmentType<Schema>;
+
+  /**
+   * The data put in {@link CalendarData._source | `CalendarData._source`}.
+   *
+   * Both `Source` and `PersistedData` are equivalent.
+   */
+  interface PersistedData extends fields.SchemaField.PersistedType<Schema> {}
+
+  /**
+   * The data after a {@link DataModel | `DataModel`} has been initialized, for example
+   * {@link CalendarData.name | `CalenderData#name`}.
+   *
+   * This is data transformed from {@link CalendarData.Source | `CalendarData.Source`} and turned into more
+   * convenient runtime data structures. For example a source value of `undefined` will be replaced
+   * by the `initial` value of the field instance.
+   */
+  interface InitializedData extends fields.SchemaField.InitializedType<Schema> {}
+
+  /** A definition of a year within a calendar. */
+  namespace ConfigYears {
+    interface Schema extends fields.DataSchema {
+      /** The year which is considered year 0 in the calendar. */
+      yearZero: fields.NumberField<{ required: true; nullable: false; integer: true }>;
+      /** The day of the week that the first day of year zero falls on. */
+      firstWeekday: fields.NumberField<{ required: true; nullable: false; min: 1; integer: true }>;
+      /** A definition of how leap years work within a calendar. */
+      leapYear: fields.SchemaField<ConfigLeapYear.Schema, { required: true; nullable: true; initial: null }>;
+    }
+
+    interface InitializedData extends fields.SchemaField.InitializedType<Schema> {}
+
+    // TODO: Replace with CreateData and convert to interface
+    type CreateData = fields.SchemaField.AssignmentType<Schema>;
+  }
+
+  /** A definition of how leap years work within a calendar. */
+  namespace ConfigLeapYear {
+    interface Schema extends fields.DataSchema {
+      /** The year number of the first leap year. On or after yearZero. */
+      leapStart: fields.NumberField<{ required: true; nullable: false; integer: true }>;
+      /** The number of years between leap years. */
+      leapInterval: fields.NumberField<{ required: true; nullable: false; min: 1; integer: true }>;
+    }
+
+    interface InitializedData extends fields.SchemaField.InitializedType<Schema> {}
+
+    // TODO: Replace with CreateData and convert to interface
+    type CreateData = fields.SchemaField.AssignmentType<Schema>;
+  }
+
+  /** Month related configuration for a calendar. */
+  namespace ConfigMonths {
+    interface Schema extends fields.DataSchema {
+      /** An array of months in the calendar year. */
+      values: fields.ArrayField<fields.SchemaField<ConfigMonth.Schema>>;
+    }
+
+    interface InitializedData extends fields.SchemaField.InitializedType<Schema> {}
+
+    // TODO: Replace with CreateData and convert to interface
+    type CreateData = fields.SchemaField.AssignmentType<Schema>;
+  }
+
+  /** A definition of a month within a calendar year. */
+  namespace ConfigMonth {
+    interface Schema extends fields.DataSchema {
+      /** The full name of the month. */
+      name: fields.StringField<{ required: true; blank: false }>;
+      /** The abbreviated name of the month. */
+      abbreviation: fields.StringField;
+      /** The ordinal position of this month in the year. */
+      ordinal: fields.NumberField<{ required: true; nullable: false; min: 1; integer: true }>;
+      /** The number of days in the month. */
+      days: fields.NumberField<{ required: true; nullable: false }>;
+      /** The number of days in the month during a leap year. If not defined the value of days is used. */
+      leapDays: fields.NumberField<{ required: false; nullable: true }>;
+      /** The amount to offset day numbers for this month. */
+      dayOffset: fields.NumberField<{ required: true; nullable: true; min: 0; integer: true }>;
+      /** If this month is an intercalary month. */
+      intercalary: fields.BooleanField<{ initial: false }>;
+      /**
+       * The day of the week this month should always start on.
+       * If the value is null the month will start on the next weekday after the previous month.
+       */
+      startingWeekday: fields.NumberField<{ required: false; nullable: true }>;
+    }
+
+    interface InitializedData extends fields.SchemaField.InitializedType<Schema> {}
+
+    // TODO: Replace with CreateData and convert to interface
+    type CreateData = fields.SchemaField.AssignmentType<Schema>;
+  }
+
+  /** Day related configuration for a calendar. */
+  namespace ConfigDays {
+    interface Schema extends fields.DataSchema {
+      /** The configuration of the days of the week. */
+      values: fields.ArrayField<fields.SchemaField<ConfigDay.Schema>, { required: true; nullable: false }>;
+      /** The number of hours in a day. */
+      hoursPerDay: fields.NumberField<{ required: true; nullable: false; positive: true }>;
+      /** The number of minutes in an hour. */
+      minutesPerHour: fields.NumberField<{ required: true; nullable: false; positive: true }>;
+      /** The number of seconds in a minute. */
+      secondsPerMinute: fields.NumberField<{ required: true; nullable: false; positive: true }>;
+    }
+
+    interface InitializedData extends fields.SchemaField.InitializedType<Schema> {}
+
+    // TODO: Replace with CreateData and convert to interface
+    type CreateData = fields.SchemaField.AssignmentType<Schema>;
+  }
+
+  /** A definition of the days of the week within a calendar. */
+  namespace ConfigDay {
+    interface Schema extends fields.DataSchema {
+      /** The full name of the weekday. */
+      name: fields.StringField<{ required: true; blank: false }>;
+      /** The abbreviated name of the weekday. */
+      abbreviation: fields.StringField;
+      /** The ordinal position of this weekday in the week. */
+      ordinal: fields.NumberField<{ required: true; nullable: false; min: 1; integer: true }>;
+      /** Is this weekday considered a rest day (weekend)? */
+      isRestDay: fields.BooleanField<{ required: false; nullable: false; initial: false }>;
+    }
+
+    interface InitializedData extends fields.SchemaField.InitializedType<Schema> {}
+
+    // TODO: Replace with CreateData and convert to interface
+    type CreateData = fields.SchemaField.AssignmentType<Schema>;
+  }
+
+  /** Season related configuration for a calendar. */
+  namespace ConfigSeasons {
+    interface Schema extends fields.DataSchema {
+      /** An array of seasons in the calendar year. */
+      values: fields.ArrayField<fields.SchemaField<ConfigSeason.Schema>>;
+    }
+
+    interface InitializedData extends fields.SchemaField.InitializedType<Schema> {}
+
+    // TODO: Replace with CreateData and convert to interface
+    type CreateData = fields.SchemaField.AssignmentType<Schema>;
+  }
+
+  /** A definition of a season within a calendar year. */
+  namespace ConfigSeason {
+    interface Schema extends fields.DataSchema {
+      /** The full name of the season. */
+      name: fields.StringField<{ required: true; blank: false }>;
+      /** The abbreviated name of the season. */
+      abbreviation: fields.StringField;
+      /** The ordinal month in which the season starts. */
+      startMonth: fields.NumberField<{ required: true; nullable: true; min: 0; integer: true }>;
+      /** The day of the month on which the season starts. */
+      startDay: fields.NumberField<{ required: true; nullable: true; min: 0; integer: true }>;
+      /** The ordinal month in which the season ends. */
+      endMonth: fields.NumberField<{ required: true; nullable: true; min: 0; integer: true }>;
+      /** The day of the month on which the season ends. */
+      endDay: fields.NumberField<{ required: true; nullable: true; min: 0; integer: true }>;
+    }
+
+    interface InitializedData extends fields.SchemaField.InitializedType<Schema> {}
+
+    // TODO: Replace with CreateData and convert to interface
+    type CreateData = fields.SchemaField.AssignmentType<Schema>;
+  }
+}
+
+/**
+ * Game Time Calendar configuration data model.
+ */
+declare class CalendarData extends DataModel<CalendarData.Schema> {}
+
+export const SIMPLIFIED_GREGORIAN_CALENDAR_CONFIG: CalendarData.CreateData;
+
+export default CalendarData;

package/src/foundry/client-esm/data/client-backend.d.mts

@@ -1,40 +1,39 @@
-import type { ConstructorOf } from "../../../types/utils.d.mts";
-import type Document from "../../common/abstract/document.d.mts";
+import type { FixedInstanceType, LoggingLevels } from "fvtt-types/utils";
+import type Document from "@common/abstract/document.d.mts";
 import type {
   DatabaseGetOperation,
   DatabaseCreateOperation,
   DatabaseUpdateOperation,
   DatabaseDeleteOperation,
-} from "../../common/abstract/_types.d.mts";
-import type { LoggingLevels } from "../../../types/helperTypes.d.mts";
+} from "@common/abstract/_types.d.mts";
 
 /**
  * The client-side database backend implementation which handles Document modification operations.
  */
 declare class ClientDatabaseBackend extends foundry.abstract.DatabaseBackend {
-  protected override _getDocuments<T extends Document.Any>(
-    documentClass: ConstructorOf<T>,
+  protected override _getDocuments<T extends Document.AnyConstructor>(
+    documentClass: T,
     request: DatabaseGetOperation,
     user: User.ConfiguredInstance,
-  ): Promise<T[]>;
+  ): Promise<FixedInstanceType<T>[]>;
 
-  protected override _createDocuments<T extends Document.Any>(
-    documentClass: ConstructorOf<T>,
-    request: DatabaseCreateOperation<T>,
+  protected override _createDocuments<T extends Document.AnyConstructor>(
+    documentClass: T,
+    request: DatabaseCreateOperation<FixedInstanceType<T>>,
     user: User.ConfiguredInstance,
-  ): Promise<T[]>;
+  ): Promise<FixedInstanceType<T>[]>;
 
-  protected override _updateDocuments<T extends Document.Any>(
-    documentClass: ConstructorOf<T>,
-    request: DatabaseUpdateOperation<T>,
+  protected override _updateDocuments<T extends Document.AnyConstructor>(
+    documentClass: T,
+    request: DatabaseUpdateOperation<FixedInstanceType<T>>,
     user: User.ConfiguredInstance,
-  ): Promise<T[]>;
+  ): Promise<FixedInstanceType<T>[]>;
 
-  protected override _deleteDocuments<T extends Document.Any>(
-    documentClass: ConstructorOf<T>,
+  protected override _deleteDocuments<T extends Document.AnyConstructor>(
+    documentClass: T,
     request: DatabaseDeleteOperation,
     user: User.ConfiguredInstance,
-  ): Promise<T[]>;
+  ): Promise<FixedInstanceType<T>[]>;
 
   /**
    * Activate the Socket event listeners used to receive responses from events which modify database documents

package/src/foundry/client-esm/data/combat-config.d.mts

@@ -0,0 +1,53 @@
+/**
+ * A configuration class managing the Combat Turn Markers.
+ * @remarks TODO: Stub
+ */
+declare class CombatConfiguration {
+  constructor();
+
+  static #private: true;
+}
+
+declare namespace CombatConfiguration {
+  /** Default combat tracker settings used in Foundry VTT. */
+  interface Data {
+    /**
+     * A resource identifier for the tracker.
+     */
+    resource: string;
+
+    /**
+     * Whether to skip defeated tokens during combat.
+     */
+    skipDefeated: boolean;
+
+    /**
+     * Turn marker configuration.
+     */
+    turnMarker: TurnMarker;
+  }
+
+  interface TurnMarker {
+    /**
+     * Whether the turn marker is enabled.
+     */
+    enabled: boolean;
+
+    /**
+     * The file path for the turn marker icon.
+     */
+    path: string;
+
+    /**
+     * The identifier for the default turn marker animation.
+     */
+    animation: string;
+
+    /**
+     * Tint the turn marker according to token disposition.
+     */
+    disposition: string;
+  }
+}
+
+export default CombatConfiguration;

package/src/foundry/client-esm/data/region-behaviors/_module.d.mts

@@ -1,17 +1,14 @@
 // In Foundry itself this file contains re-exports of these other modules.
 // Therefore it has a runtime effect and uses `.mjs` instead of `.d.mts`.
-// While `.mts` could work, to avoid `import/no-unresolved` from erroring `.mjs` is used.
-/* eslint-disable import/extensions */
+// While `.mts` could work, to avoid `import-x/no-unresolved` from erroring `.mjs` is used.
+/* eslint-disable import-x/extensions */
 
-// This `export {}` can be removed when something is exported.
-export {};
-
-// TODO: Implement these files.
-// export { default as RegionBehaviorType } from "./base.mjs";
-// export { default as AdjustDarknessLevelRegionBehaviorType } from "./adjust-darkness-level.mjs";
-// export { default as ExecuteMacroRegionBehaviorType } from "./execute-macro.mjs";
-// export { default as ExecuteScriptRegionBehaviorType } from "./execute-script.mjs";
-// export { default as PauseGameRegionBehaviorType } from "./pause-game.mjs";
-// export { default as SuppressWeatherRegionBehaviorType } from "./suppress-weather.mjs";
-// export { default as TeleportTokenRegionBehaviorType } from "./teleport-token.mjs";
-// export { default as ToggleBehaviorRegionBehaviorType } from "./toggle-behavior.mjs";
+export { default as RegionBehaviorType } from "./base.mjs";
+export { default as AdjustDarknessLevelRegionBehaviorType } from "./adjust-darkness-level.mjs";
+export { default as DisplayScrollingTextRegionBehaviorType } from "./display-scrolling-text.mjs";
+export { default as ExecuteMacroRegionBehaviorType } from "./execute-macro.mjs";
+export { default as ExecuteScriptRegionBehaviorType } from "./execute-script.mjs";
+export { default as PauseGameRegionBehaviorType } from "./pause-game.mjs";
+export { default as SuppressWeatherRegionBehaviorType } from "./suppress-weather.mjs";
+export { default as TeleportTokenRegionBehaviorType } from "./teleport-token.mjs";
+export { default as ToggleBehaviorRegionBehaviorType } from "./toggle-behavior.mjs";

package/src/foundry/client-esm/data/region-behaviors/adjust-darkness-level.d.mts

@@ -0,0 +1,57 @@
+import type RegionBehaviorType from "./base.d.mts";
+import type { Brand } from "fvtt-types/utils";
+import fields = foundry.data.fields;
+import type { InvertObject } from "@common/utils/helpers.d.mts";
+
+declare namespace AdjustDarknessLevelRegionBehaviorType {
+  type MODES = Brand<number, "AdjustDarknessLevelRegionBehaviorType.MODES">;
+
+  interface Modes
+    extends Readonly<{
+      /**
+       * Override the darkness level with the modifier.
+       */
+      OVERRIDE: 0 & MODES;
+
+      /**
+       * Brighten the darkness level: `darknessLevel * (1 - modifier)`
+       */
+      BRIGHTEN: 1 & MODES;
+
+      /**
+       * Darken the darkness level: `1 - (1 - darknessLevel) * (1 - modifier)`.
+       */
+      DARKEN: 2 & MODES;
+    }> {}
+
+  interface Schema extends foundry.data.fields.DataSchema {
+    mode: fields.NumberField<{
+      required: true;
+      choices: InvertObject<Modes>;
+      initial: typeof AdjustDarknessLevelRegionBehaviorType.MODES.OVERRIDE;
+      validationError: string;
+    }>;
+    modifier: fields.AlphaField<{ initial: number; step: number }>;
+  }
+}
+
+/** The data model for a behavior that allows to suppress weather effects within the Region */
+declare class AdjustDarknessLevelRegionBehaviorType extends RegionBehaviorType<AdjustDarknessLevelRegionBehaviorType.Schema> {
+  #adjustDarknessLevelRegionBehaviorType: true;
+
+  /** @defaultValue `["BEHAVIOR.TYPES.adjustDarknessLevel", "BEHAVIOR.TYPES.base"]` */
+  static override LOCALIZATION_PREFIXES: string[];
+
+  /** Darkness level behavior modes. */
+  static get MODES(): AdjustDarknessLevelRegionBehaviorType.Modes;
+
+  static override defineSchema(): AdjustDarknessLevelRegionBehaviorType.Schema;
+
+  static override events: Record<string, RegionBehaviorType.EventBehaviorStaticHandler>;
+
+  /**
+   * @privateRemarks _onUpdate is overridden but without signature changes.
+   * For type simplicity it is left off. Methods like this historically have been the source of a large amount of computation from tsc.
+   */
+}
+export default AdjustDarknessLevelRegionBehaviorType;

package/src/foundry/client-esm/data/region-behaviors/base.d.mts

@@ -0,0 +1,59 @@
+import type TypeDataModel from "@common/abstract/type-data.d.mts";
+import type { AnyObject, EmptyObject } from "fvtt-types/utils";
+
+import fields = foundry.data.fields;
+
+declare namespace RegionBehaviorType {
+  type EventBehaviorStaticHandler = (event: RegionDocument.RegionEvent) => Promise<void>;
+
+  type EventsField = fields.SetField<
+    fields.StringField<{ required: true; choices: Record<CONST.REGION_EVENTS, string> }>,
+    { label: string; hint: string }
+  >;
+}
+
+/** The data model for a behavior that receives Region events. */
+declare class RegionBehaviorType<
+  Schema extends foundry.data.fields.DataSchema,
+  Parent extends RegionBehavior.ConfiguredInstance = RegionBehavior.ConfiguredInstance,
+  BaseData extends AnyObject = EmptyObject,
+  DerivedData extends AnyObject = EmptyObject,
+> extends TypeDataModel<Schema, Parent, BaseData, DerivedData> {
+  /** Create the events field. */
+  protected static _createEventsField(options?: {
+    /** The event names to restrict to. */
+    events?: string[];
+    /** The initial set of events that should be default for the field */
+    initial?: string[];
+  }): RegionBehaviorType.EventsField;
+
+  /**
+   * A RegionBehaviorType may register to always receive certain events by providing a record of handler functions.
+   * These handlers are called with the behavior instance as its bound scope.
+   */
+  static events: Record<string, RegionBehaviorType.EventBehaviorStaticHandler>;
+
+  /**
+   * The events that are handled by this behavior
+   * @defaultValue `new Set()`
+   */
+  events: Set<string>;
+
+  /** A convenience reference to the RegionBehavior which contains this behavior sub-type */
+  get behavior(): RegionBehavior.ConfiguredInstance | null;
+
+  /** A convenience reference to the RegionDocument which contains this behavior sub-type.*/
+  get region(): RegionDocument.ConfiguredInstance | null;
+
+  /** A convenience reference to the Scene which contains this behavior sub-type. */
+  get scene(): Scene.ConfiguredInstance | null;
+
+  /**
+   * Handle the Region event.
+   * @param event     - The Region event
+   * @internal
+   */
+  protected _handleRegionEvent(event: RegionDocument.RegionEvent): Promise<void>;
+}
+
+export default RegionBehaviorType;

package/src/foundry/client-esm/data/region-behaviors/display-scrolling-text.d.mts

@@ -0,0 +1,64 @@
+import type RegionBehaviorType from "./base.d.mts";
+import type { Brand } from "fvtt-types/utils";
+import fields = foundry.data.fields;
+import type { InvertObject } from "@common/utils/helpers.d.mts";
+
+declare namespace DisplayScrollingTextRegionBehaviorType {
+  type VISIBILITY_MODES = Brand<number, "DisplayScrollingTextRegionBehaviorType.VISIBILITY_MODES">;
+
+  interface VisibilityModes
+    extends Readonly<{
+      /**
+       * Display only for gamemaster users
+       */
+      GAMEMASTER: 0;
+
+      /**
+       * Display only for users with observer permissions on the triggering token (and for the GM)
+       */
+      OBSERVER: 1;
+
+      /**
+       * Display for all users
+       */
+      ANYONE: 2;
+    }> {}
+
+  interface Schema extends foundry.data.fields.DataSchema {
+    events: RegionBehaviorType.EventsField;
+
+    /** The text to display */
+    text: fields.StringField<{ required: true }>;
+
+    /** Optional color setting for the text */
+    color: fields.ColorField<{ required: true; nullable: false; initial: string }>;
+
+    /** Which users the scrolling text will display for (see {@link VISIBILITY_MODES}) */
+    visibility: fields.NumberField<{
+      required: true;
+      choices: InvertObject<VisibilityModes>;
+      initial: typeof DisplayScrollingTextRegionBehaviorType.VISIBILITY_MODES.GAMEMASTER;
+      validationError: string;
+    }>;
+
+    /** Disable the behavior after it triggers once */
+    once: fields.BooleanField;
+  }
+}
+
+/** The data model for a behavior that displays scrolling text above a token when one of the subscribed events occurs. */
+declare class DisplayScrollingTextRegionBehaviorType extends RegionBehaviorType<DisplayScrollingTextRegionBehaviorType.Schema> {
+  #displayScrollingTextRegionBehaviorType: true;
+
+  /** @defaultValue `["BEHAVIOR.TYPES.displayScrollingText", "BEHAVIOR.TYPES.base"]` */
+  static override LOCALIZATION_PREFIXES: string[];
+
+  /** Darkness level behavior modes. */
+  static get VISIBILITY_MODES(): DisplayScrollingTextRegionBehaviorType.VisibilityModes;
+
+  static override defineSchema(): DisplayScrollingTextRegionBehaviorType.Schema;
+
+  protected override _handleRegionEvent(event: RegionDocument.RegionEvent): Promise<void>;
+}
+
+export default DisplayScrollingTextRegionBehaviorType;

package/src/foundry/client-esm/data/region-behaviors/execute-macro.d.mts

@@ -0,0 +1,27 @@
+import type RegionBehaviorType from "./base.d.mts";
+import fields = foundry.data.fields;
+
+declare namespace ExecuteMacroRegionBehaviorType {
+  interface Schema extends foundry.data.fields.DataSchema {
+    events: RegionBehaviorType.EventsField;
+
+    /** The Macro UUID */
+    uuid: fields.DocumentUUIDField<{ type: "Macro" }>;
+
+    everyone: fields.BooleanField;
+  }
+}
+
+/** The data model for a behavior that executes a Macro. */
+declare class ExecuteMacroRegionBehaviorType extends RegionBehaviorType<ExecuteMacroRegionBehaviorType.Schema> {
+  #executeMacroRegionBehaviorType: true;
+
+  /** @defaultValue `["BEHAVIOR.TYPES.executeMacro", "BEHAVIOR.TYPES.base"]` */
+  static override LOCALIZATION_PREFIXES: string[];
+
+  static override defineSchema(): ExecuteMacroRegionBehaviorType.Schema;
+
+  protected override _handleRegionEvent(event: RegionDocument.RegionEvent): Promise<void>;
+}
+
+export default ExecuteMacroRegionBehaviorType;

package/src/foundry/client-esm/data/region-behaviors/execute-script.d.mts

@@ -0,0 +1,23 @@
+import type RegionBehaviorType from "./base.d.mts";
+import fields = foundry.data.fields;
+
+declare namespace ExecuteScriptRegionBehaviorType {
+  interface Schema extends foundry.data.fields.DataSchema {
+    events: RegionBehaviorType.EventsField;
+
+    /** The source code of the script */
+    source: fields.JavaScriptField<{ async: true; gmOnly: true }>;
+  }
+}
+
+/** The data model for a behavior that executes a script. */
+declare class ExecuteScriptRegionBehaviorType extends RegionBehaviorType<ExecuteScriptRegionBehaviorType.Schema> {
+  /** @defaultValue `["BEHAVIOR.TYPES.executeScript", "BEHAVIOR.TYPES.base"]` */
+  static override LOCALIZATION_PREFIXES: string[];
+
+  static override defineSchema(): ExecuteScriptRegionBehaviorType.Schema;
+
+  protected override _handleRegionEvent(event: RegionDocument.RegionEvent): Promise<void>;
+}
+
+export default ExecuteScriptRegionBehaviorType;

package/src/foundry/client-esm/data/region-behaviors/pause-game.d.mts

@@ -0,0 +1,23 @@
+import type RegionBehaviorType from "./base.d.mts";
+import fields = foundry.data.fields;
+
+declare namespace PauseGameRegionBehaviorType {
+  interface Schema extends foundry.data.fields.DataSchema {
+    /** Disable the behavior once a player-controlled Token enters the region? */
+    once: fields.BooleanField;
+  }
+}
+
+/** The data model for a behavior that pauses the game when a player-controlled Token enters the Region. */
+declare class PauseGameRegionBehaviorType extends RegionBehaviorType<PauseGameRegionBehaviorType.Schema> {
+  #pauseGameRegionBehaviorType: true;
+
+  /** @defaultValue `["BEHAVIOR.TYPES.pauseGame", "BEHAVIOR.TYPES.base"]` */
+  static override LOCALIZATION_PREFIXES: string[];
+
+  static override defineSchema(): PauseGameRegionBehaviorType.Schema;
+
+  static override events: Record<string, RegionBehaviorType.EventBehaviorStaticHandler>;
+}
+
+export default PauseGameRegionBehaviorType;

package/src/foundry/client-esm/data/region-behaviors/suppress-weather.d.mts

@@ -0,0 +1,17 @@
+import type RegionBehaviorType from "./base.d.mts";
+
+declare namespace SuppressWeatherRegionBehaviorType {
+  interface Schema extends foundry.data.fields.DataSchema {}
+}
+
+/** The data model for a behavior that allows to suppress weather effects within the Region */
+declare class SuppressWeatherRegionBehaviorType extends RegionBehaviorType<SuppressWeatherRegionBehaviorType.Schema> {
+  #suppressWeatherRegionBehaviorType: true;
+
+  /** @defaultValue `["BEHAVIOR.TYPES.suppressWeather", "BEHAVIOR.TYPES.base"]` */
+  static override LOCALIZATION_PREFIXES: string[];
+
+  static override events: Record<string, RegionBehaviorType.EventBehaviorStaticHandler>;
+}
+
+export default SuppressWeatherRegionBehaviorType;

package/src/foundry/client-esm/data/region-behaviors/teleport-token.d.mts

@@ -0,0 +1,32 @@
+import type RegionBehaviorType from "./base.d.mts";
+import fields = foundry.data.fields;
+
+declare namespace TeleportTokenRegionBehaviorType {
+  interface Schema extends foundry.data.fields.DataSchema {
+    /** The destination Region the Token is teleported to. */
+    destination: fields.DocumentUUIDField<{ type: "Region" }>;
+
+    choice: fields.BooleanField;
+  }
+}
+
+/** The data model for a behavior that teleports Token that enter the Region to a preset destination Region. */
+declare class TeleportTokenRegionBehaviorType extends RegionBehaviorType<TeleportTokenRegionBehaviorType.Schema> {
+  #teleportTokenRegionBehavior: true;
+
+  /** @defaultValue `["BEHAVIOR.TYPES.teleportToken", "BEHAVIOR.TYPES.base"]` */
+  static override LOCALIZATION_PREFIXES: string[];
+
+  static override defineSchema(): TeleportTokenRegionBehaviorType.Schema;
+
+  static override events: Record<string, RegionBehaviorType.EventBehaviorStaticHandler>;
+
+  /**
+   * Activate the Socket event listeners.
+   * @param socket      - The active game socket
+   * @internal
+   */
+  protected static _activateSocketListeners(socket: WebSocket): void;
+}
+
+export default TeleportTokenRegionBehaviorType;