@7h3laughingman/foundry-types 13.351.0

package/src/common/data/validation-failure.d.mts

@@ -0,0 +1,127 @@
+import { ElementValidationFailure } from "./_types.mjs";
+
+/** A class responsible for recording information about a validation failure. */
+export class DataModelValidationFailure {
+    /**
+     * @param [invalidValue]   The value that failed validation for this field.
+     * @param [fallback]       The value it was replaced by, if any.
+     * @param [dropped]        Whether the value was dropped from some parent collection.
+     * @param [message]        The validation error message.
+     * @param [unresolved]     Whether this failure was unresolved
+     */
+    constructor({
+        invalidValue,
+        fallback,
+        dropped,
+        message,
+        unresolved,
+    }?: {
+        invalidValue?: unknown;
+        fallback?: boolean;
+        dropped?: boolean;
+        message?: string;
+        unresolved?: boolean;
+    });
+
+    /** The value that failed validation for this field. */
+    invalidValue: unknown;
+
+    /** The value it was replaced by, if any. */
+    fallback: unknown;
+
+    /** Whether the value was dropped from some parent collection. */
+    dropped: boolean;
+
+    /** The validation error message. */
+    message?: string;
+
+    /** If this field contains other fields that are validated as part of its validation, their results are recorded here. */
+    fields: Record<string, DataModelValidationFailure>;
+
+    /**
+     * If this field contains a list of elements that are validated as part of its validation, their results are recorded
+     * here.
+     */
+    elements: ElementValidationFailure[];
+
+    /**
+     * Record whether a validation failure is unresolved.
+     * This reports as true if validation for this field or any hierarchically contained field is unresolved.
+     * A failure is unresolved if the value was invalid and there was no valid fallback value available.
+     */
+    unresolved: boolean;
+
+    /** Return this validation failure as an Error object. */
+    asError(): DataModelValidationError;
+
+    /** Whether this failure contains other sub-failures. */
+    isEmpty(): boolean;
+
+    /** Return the base properties of this failure, omitting any nested failures. */
+    toObject(): {
+        invalidValue: unknown;
+        fallback: unknown;
+        dropped: boolean;
+        message: string;
+    };
+
+    /** Represent the DataModelValidationFailure as a string. */
+    toString(): string;
+}
+
+/** A specialised Error to indicate a model validation failure. */
+export class DataModelValidationError extends Error {
+    /**
+     * @param failure    The failure that triggered this error or an error message
+     * @param [params]   Additional Error constructor parameters
+     */
+    constructor(failure: DataModelValidationFailure | string, params?: ErrorOptions);
+
+    /**
+     * Retrieve the root failure that caused this error, or a specific sub-failure via a path.
+     * @param path  The property path to the failure.
+     *
+     * @example Retrieving a failure.
+     * ```js
+     * const changes = {
+     *   "foo.bar": "validValue",
+     *   "foo.baz": "invalidValue"
+     * };
+     * try {
+     *   doc.validate(expandObject(changes));
+     * } catch ( err ) {
+     *   const failure = err.getFailure("foo.baz");
+     *   console.log(failure.invalidValue); // "invalidValue"
+     * }
+     * ```
+     */
+    getFailure(path?: string): DataModelValidationFailure;
+
+    /**
+     * Retrieve a flattened object of all the properties that failed validation as part of this error.
+     *
+     * @example Removing invalid changes from an update delta.
+     * ```js
+     * const changes = {
+     *   "foo.bar": "validValue",
+     *   "foo.baz": "invalidValue"
+     * };
+     * try {
+     *   doc.validate(expandObject(changes));
+     * } catch ( err ) {
+     *   const failures = err.getAllFailures();
+     *   if ( failures ) {
+     *     for ( const prop in failures ) delete changes[prop];
+     *     doc.validate(expandObject(changes));
+     *   }
+     * }
+     * ```
+     */
+    getAllFailures(): Record<string, DataModelValidationFailure>;
+
+    /** Log the validation error as a table. */
+    logAsTable(): void;
+
+    /** Generate a nested tree view of the error as an HTML string. */
+    asHTML(): string;
+}

package/src/common/data/validators.d.mts

@@ -0,0 +1,35 @@
+import { HexColorString } from "./../constants.mjs";
+
+/**
+ * Test whether a string is a valid 16 character UID
+ * @param id
+ */
+export function isValidId(id: string): boolean;
+
+/**
+ * Test whether a file path has an extension in a list of provided extensions
+ * @param path
+ * @param extensions
+ */
+export function hasFileExtension(path: string, extensions: string[]): path is `${string}.${string}`;
+
+/**
+ * Test whether a string data blob contains base64 data, optionally of a specific type or types
+ * @param data   The candidate string data
+ * @param [types] An array of allowed mime types to test
+ */
+export function isBase64Data(data: string, types?: string[]): boolean;
+
+/**
+ * Test whether an input represents a valid 6-character color string
+ * @param color The input string to test
+ * @return Is the string a valid color?
+ */
+export function isColorString(color: string): color is HexColorString;
+
+/**
+ * Assert that the given value parses as a valid JSON string
+ * @param val The value to test
+ * @return Is the String valid JSON?
+ */
+export function isJSON(val: string): boolean;

package/src/common/documents/_module.d.mts

@@ -0,0 +1,64 @@
+import { WorldDocumentType } from "./../constants.mjs";
+
+export { ActiveEffectSource, default as BaseActiveEffect } from "./active-effect.mjs";
+export { default as BaseActorDelta } from "./actor-delta.mjs";
+export { ActorSource, default as BaseActor } from "./actor.mjs";
+export { AdventureSource, default as BaseAdventure } from "./adventure.mjs";
+export { default as BaseAmbientLight } from "./ambient-light.mjs";
+export { AmbientSoundSource, default as BaseAmbientSound } from "./ambient-sound.mjs";
+export { default as BaseCard, CardFaceData } from "./card.mjs";
+export { default as BaseCards } from "./cards.mjs";
+export { default as BaseChatMessage, ChatMessageFlags, ChatMessageSource, ChatSpeakerData } from "./chat-message.mjs";
+export { default as BaseCombat, CombatSource } from "./combat.mjs";
+export { default as BaseCombatantGroup } from "./combatant-group.mjs";
+export { default as BaseCombatant, CombatantSource } from "./combatant.mjs";
+export { default as BaseDrawing, DrawingSource } from "./drawing.mjs";
+export { default as BaseFogExploration, FogExplorationSource } from "./fog-exploration.mjs";
+export { default as BaseFolder, FolderSource } from "./folder.mjs";
+export { default as BaseItem, ItemSchema, ItemSource } from "./item.mjs";
+export { default as BaseJournalEntryCategory, JournalEntryCategorySource } from "./journal-entry-category.mjs";
+export { default as BaseJournalEntryPage } from "./journal-entry-page.mjs";
+export { default as BaseJournalEntry, JournalEntrySource } from "./journal-entry.mjs";
+export { default as BaseMacro, MacroSource } from "./macro.mjs";
+export { default as BaseMeasuredTemplate, MeasuredTemplateSource } from "./measured-template.mjs";
+export { default as BaseNote, NoteSource } from "./note.mjs";
+export { default as BasePlaylistSound, PlaylistSoundSource } from "./playlist-sound.mjs";
+export { default as BasePlaylist } from "./playlist.mjs";
+export { default as BaseRegionBehavior } from "./region-behavior.mjs";
+export { default as BaseRegion, RegionSource } from "./region.mjs";
+export { default as BaseRollTable, RollTableSource } from "./roll-table.mjs";
+export { default as BaseScene, SceneSource } from "./scene.mjs";
+export { default as BaseSetting } from "./setting.mjs";
+export { default as BaseTableResult, TableResultSource } from "./table-result.mjs";
+export { default as BaseTile, TileSource } from "./tile.mjs";
+export { default as BaseToken, TokenSource } from "./token.mjs";
+export { default as BaseUser, UserSource } from "./user.mjs";
+export { default as BaseWall, WallSource } from "./wall.mjs";
+
+export type ActorUUID = `Actor.${string}` | `${TokenDocumentUUID}.Actor.${string}` | CompendiumActorUUID;
+export type CardsUUID = `Cards.${string}`;
+export type ChatMessageUUID = `ChatMessage.${string}`;
+export type CombatUUID = `Combat.${string}`;
+export type CompendiumActorUUID = `Compendium.${string}.Actor.${string}`;
+export type CompendiumAdventureUUID = `Compendium.${string}.Adventure.${string}`;
+export type CompendiumCardsUUID = `Compendium.${string}.Cards.${string}`;
+export type CompendiumItemUUID = `Compendium.${string}.Item.${string}`;
+export type CompendiumJournalEntryUUID = `Compendium.${string}.JournalEntry.${string}`;
+export type CompendiumMacroUUID = `Compendium.${string}.Macro.${string}`;
+export type CompendiumPlaylistUUID = `Compendium.${string}.Playlist.${string}`;
+export type CompendiumRollTableUUID = `Compendium.${string}.RollTable.${string}`;
+export type CompendiumSceneUUID = `Compendium.${string}.Scene.${string}`;
+export type EmbeddedItemUUID = `${ActorUUID}.Item.${string}`;
+export type FogExplorationUUID = `FogExploration.${string}`;
+export type FolderUUID = `Folder.${string}`;
+export type ItemUUID = WorldItemUUID | EmbeddedItemUUID | CompendiumItemUUID;
+export type JournalEntryUUID = `JournalEntry.${string}`;
+export type MacroUUID = `Macro.${string}`;
+export type PlaylistUUID = `Playlist.${string}`;
+export type RollTableUUID = `RollTable.${string}`;
+export type SceneUUID = `Scene.${string}`;
+export type SettingUUID = `Setting.${string}`;
+export type TokenDocumentUUID = `Scene.${string}.Token.${string}`;
+export type UserUUID = `User.${string}`;
+export type WorldDocumentUUID = `${WorldDocumentType}.${string}`;
+export type WorldItemUUID = `Item.${string}`;

package/src/common/documents/_types.d.mts

@@ -0,0 +1 @@
+export {};

package/src/common/documents/active-effect.d.mts

@@ -0,0 +1,87 @@
+import { Document, DocumentMetadata } from "../abstract/_module.mjs";
+import * as fields from "../data/fields.mjs";
+import { DatabaseCreateCallbackOptions } from "./../abstract/_types.mjs";
+import { ActiveEffectChangeMode, DocumentOwnershipLevel, DocumentOwnershipString, ImageFilePath, UserAction } from "./../constants.mjs";
+import { ActorUUID, BaseActor, BaseItem, BaseUser, ItemUUID } from "./_module.mjs";
+
+/**
+ * The ActiveEffect document model.
+ * @param data    Initial data from which to construct the document.
+ * @param context Construction context options
+ */
+export default class BaseActiveEffect<TParent extends BaseActor | BaseItem<BaseActor | null> | null> extends Document<TParent, ActiveEffectSchema> {
+    /* -------------------------------------------- */
+    /*  Model Configuration                         */
+    /* -------------------------------------------- */
+
+    static override get metadata(): ActiveEffectMetadata;
+
+    static override defineSchema(): ActiveEffectSchema;
+
+    /* -------------------------------------------- */
+    /*  Model Methods                               */
+    /* -------------------------------------------- */
+
+    override canUserModify(user: BaseUser, action: UserAction, data?: object): boolean;
+
+    override testUserPermission(user: BaseUser, permission: DocumentOwnershipString | DocumentOwnershipLevel, { exact }?: { exact?: boolean }): boolean;
+
+    /* -------------------------------------------- */
+    /*  Database Event Handlers                     */
+    /* -------------------------------------------- */
+
+    protected override _preCreate(data: DeepPartial<this["_source"]>, options: DatabaseCreateCallbackOptions, user: BaseUser): Promise<boolean | void>;
+}
+
+export default interface BaseActiveEffect<TParent extends BaseActor | BaseItem<BaseActor | null> | null>
+    extends Document<TParent, ActiveEffectSchema>, fields.ModelPropsFromSchema<ActiveEffectSchema> {
+    get documentName(): ActiveEffectMetadata["name"];
+}
+
+export interface ActiveEffectMetadata extends DocumentMetadata {
+    name: "ActiveEffect";
+    collection: "effects";
+    label: "DOCUMENT.ActiveEffect";
+    isEmbedded: true;
+}
+
+type ActiveEffectSchema = {
+    _id: fields.DocumentIdField;
+    name: fields.StringField<string, string, true, false, false>;
+    changes: fields.ArrayField<fields.SchemaField<EffectChangeSchema>>;
+    system: fields.TypeDataField;
+    type: fields.StringField<string, string, false, true, true>;
+    disabled: fields.BooleanField;
+    duration: fields.SchemaField<EffectDurationSchema>;
+    description: fields.HTMLField;
+    img: fields.FilePathField<ImageFilePath>;
+    origin: fields.StringField<ActorUUID | ItemUUID, ActorUUID | ItemUUID, false, true, true>;
+    tint: fields.ColorField;
+    transfer: fields.BooleanField;
+    statuses: fields.SetField<fields.StringField<string, string, true, false, false>>;
+    flags: fields.DocumentFlagsField;
+    _stats: fields.DocumentStatsField;
+};
+
+type EffectChangeSchema = {
+    key: fields.StringField<string, string, true, false, false>;
+    value: fields.StringField<string, string, true, false, false>;
+    mode: fields.NumberField<ActiveEffectChangeMode, ActiveEffectChangeMode, false, false, true>;
+    priority: fields.NumberField;
+};
+
+type EffectDurationSchema = {
+    startTime: fields.NumberField<number, number, false, true, true>;
+    seconds: fields.NumberField;
+    combat: fields.ForeignDocumentField;
+    rounds: fields.NumberField;
+    turns: fields.NumberField;
+    startRound: fields.NumberField;
+    startTurn: fields.NumberField;
+};
+
+export type ActiveEffectSource = fields.SourceFromSchema<ActiveEffectSchema>;
+
+export type EffectChangeData = fields.SourceFromSchema<EffectChangeSchema>;
+export type EffectDurationSource = fields.SourceFromSchema<EffectDurationSchema>;
+export type EffectDurationData = BaseActiveEffect<null>["duration"];

package/src/common/documents/actor-delta.d.mts

@@ -0,0 +1,81 @@
+import { DocumentConstructionContext } from "../_types.mjs";
+import * as abstract from "../abstract/_module.mjs";
+import { TombstoneDataSchema } from "../data/data.mjs";
+import * as fields from "../data/fields.mjs";
+import Collection from "../utils/collection.mjs";
+import { DocumentOwnershipLevel, DocumentOwnershipString, ImageFilePath, UserAction } from "./../constants.mjs";
+import { BaseActiveEffect, BaseActor, BaseItem, BaseToken, BaseUser } from "./_module.mjs";
+import { ItemSchema } from "./item.mjs";
+
+/**
+ * The Document definition for an ActorDelta.
+ * Defines the DataSchema and common behaviors for an ActorDelta which are shared between both client and server.
+ * ActorDeltas store a delta that can be applied to a particular Actor in order to produce a new Actor.
+ *
+ * @param data    Initial data used to construct the ActorDelta.
+ * @param context Construction context options.
+ */
+export default class BaseActorDelta<TParent extends BaseToken | null> extends abstract.Document<TParent, ActorDeltaSchema> {
+    /* -------------------------------------------- */
+    /*  Model Configuration                         */
+    /* -------------------------------------------- */
+
+    static override readonly metadata: ActorDeltaMetadata;
+
+    static override defineSchema(): ActorDeltaSchema;
+
+    override canUserModify(user: BaseUser, action: UserAction, data?: Record<string, unknown>): boolean;
+
+    override testUserPermission(user: BaseUser, permission: DocumentOwnershipString | DocumentOwnershipLevel, { exact }?: { exact?: boolean }): boolean;
+
+    /* -------------------------------------------- */
+    /*  Methods                                     */
+    /* -------------------------------------------- */
+
+    /**
+     * Retrieve the base actor's collection, if it exists.
+     * @param collectionName  The collection name.
+     */
+    getBaseCollection(collectionName: string): Collection<string, BaseActor> | undefined;
+
+    /**
+     * Apply an ActorDelta to an Actor and return the resultant synthetic Actor.
+     * @param {ActorDelta} delta  The ActorDelta.
+     * @param {Actor} baseActor   The base Actor.
+     * @param {object} [context]  Context to supply to synthetic Actor instantiation.
+     * @returns {Actor|null}
+     */
+    static applyDelta(delta: BaseActorDelta<BaseToken | null>, baseActor: BaseActor, context?: DocumentConstructionContext<BaseToken | null>): BaseActor;
+}
+
+export default interface BaseActorDelta<TParent extends BaseToken | null>
+    extends abstract.Document<TParent, ActorDeltaSchema>, fields.ModelPropsFromSchema<ActorDeltaSchema> {}
+
+interface ActorDeltaMetadata extends abstract.DocumentMetadata {
+    name: "ActorDelta";
+    collection: "delta";
+    label: "DOCUMENT.ActorDelta";
+    labelPlural: "DOCUMENT.ActorDeltas";
+    isEmbedded: true;
+    embedded: {
+        Item: "items";
+        ActiveEffect: "effects";
+    };
+}
+
+type ActorDeltaSchema = {
+    _id: fields.DocumentIdField;
+    name: fields.StringField<string, string, false, true, true>;
+    type: fields.StringField<string, string, false, true, true>;
+    img: fields.FilePathField<ImageFilePath, ImageFilePath, false, true, true>;
+    system: fields.ObjectField<object, object, true, true, true>;
+    items: fields.EmbeddedCollectionDeltaField<
+        BaseItem<BaseActor>,
+        (fields.DocumentSourceFromSchema<ItemSchema, true> | fields.SourceFromSchema<TombstoneDataSchema>)[]
+    >;
+    effects: fields.EmbeddedCollectionDeltaField<BaseActiveEffect<BaseActor>>;
+    ownership: fields.DocumentOwnershipField;
+    flags: fields.DocumentFlagsField;
+};
+
+export type ActorDeltaSource = fields.SourceFromSchema<ActorDeltaSchema>;

package/src/common/documents/actor.d.mts

@@ -0,0 +1,105 @@
+import { DocumentConstructionContext } from "../_types.mjs";
+import { DatabaseCreateCallbackOptions, DatabaseUpdateCallbackOptions, Document, DocumentMetadata, EmbeddedCollection } from "../abstract/_module.mjs";
+import * as data from "../data/data.mjs";
+import * as fields from "../data/fields.mjs";
+import { ImageFilePath, VideoFilePath } from "./../constants.mjs";
+import { ActorUUID, BaseActiveEffect, BaseFolder, BaseItem, BaseToken, BaseUser, ItemSource } from "./_module.mjs";
+
+/**
+ * The Document definition for an Actor.
+ * Defines the DataSchema and common behaviors for an Actor which are shared between both client and server.
+ * @memberof documents
+ *
+ * @param data    Initial data from which to construct the Actor
+ * @param context Construction context options
+ */
+export default class BaseActor<TParent extends BaseToken | null = BaseToken | null> extends Document<TParent, ActorSchema> {
+    /* -------------------------------------------- */
+    /*  Model Configuration                         */
+    /* -------------------------------------------- */
+
+    static override get metadata(): ActorMetadata;
+
+    static override defineSchema(): ActorSchema;
+
+    /** The default icon used for newly created Actor documents */
+    static DEFAULT_ICON: ImageFilePath;
+
+    /**
+     * Determine default artwork based on the provided actor data.
+     * @param actorData The source actor data.
+     * @returns Candidate actor image and prototype token artwork.
+     */
+    static getDefaultArtwork(actorData: ActorSource): {
+        img: ImageFilePath;
+        texture: { src: ImageFilePath | VideoFilePath };
+    };
+
+    /** The allowed set of Actor types which may exist. */
+    static get TYPES(): string[];
+
+    protected override _initializeSource(data: Record<string, unknown>, options?: DocumentConstructionContext<TParent>): this["_source"];
+
+    static override canUserCreate(user: BaseUser): boolean;
+
+    protected override _preCreate(data: DeepPartial<this["_source"]>, options: DatabaseCreateCallbackOptions, user: BaseUser): Promise<boolean | void>;
+
+    protected override _preUpdate(changed: DeepPartial<this["_source"]>, options: DatabaseUpdateCallbackOptions, user: BaseUser): Promise<boolean | void>;
+}
+
+export default interface BaseActor<TParent extends BaseToken | null = BaseToken | null>
+    extends Document<TParent, ActorSchema>, fields.ModelPropsFromSchema<ActorSchema> {
+    readonly items: EmbeddedCollection<BaseItem<this>>;
+    readonly effects: EmbeddedCollection<BaseActiveEffect<this>>;
+
+    prototypeToken: data.PrototypeToken<this>;
+
+    get documentName(): ActorMetadata["name"];
+
+    get folder(): BaseFolder | null;
+}
+
+export interface ActorMetadata extends DocumentMetadata {
+    name: "Actor";
+    collection: "actors";
+    indexed: true;
+    compendiumIndexFields: ["_id", "name", "img", "type", "sort", "folder"];
+    embedded: { ActiveEffect: "effects"; Item: "items" };
+    label: "DOCUMENT.Actor";
+    labelPlural: "DOCUMENT.Actors";
+}
+
+type ActorSchema<TType extends string = string, TSystemSource extends object = object, TItemSource extends ItemSource = ItemSource> = {
+    /** The _id which uniquely identifies this Actor document */
+    _id: fields.DocumentIdField;
+    /** The name of this Actor */
+    name: fields.StringField<string, string, true, false, false>;
+    /** An Actor subtype which configures the system data model applied */
+    type: fields.StringField<TType, TType, true, false, false>;
+    /** An image file path which provides the artwork for this Actor */
+    img: fields.FilePathField<ImageFilePath, ImageFilePath, false, false, true>;
+    /** The system data object which is defined by the system template.json model */
+    system: fields.TypeDataField<TSystemSource>;
+    /** Default Token settings which are used for Tokens created from this Actor */
+    prototypeToken: fields.EmbeddedDataField<data.PrototypeToken<BaseActor>>;
+    /** A Collection of Item embedded Documents */
+    items: fields.EmbeddedCollectionField<BaseItem<BaseActor<BaseToken | null>>, TItemSource[]>;
+    /** A Collection of ActiveEffect embedded Documents */
+    effects: fields.EmbeddedCollectionField<BaseActiveEffect<BaseActor<BaseToken | null>>>;
+    /** The _id of a Folder which contains this Actor */
+    folder: fields.ForeignDocumentField<BaseFolder>;
+    /** The numeric sort value which orders this Actor relative to its siblings */
+    sort: fields.IntegerSortField;
+    /** An object which configures ownership of this Actor */
+    ownership: fields.DocumentOwnershipField;
+    /** An object of optional key/value flags */
+    flags: fields.DocumentFlagsField;
+    /** An object of creation and access information. */
+    _stats: fields.DocumentStatsField<ActorUUID>;
+};
+
+export type ActorSource<
+    TType extends string = string,
+    TSystemSource extends object = object,
+    TItemSource extends foundry.documents.ItemSource = foundry.documents.ItemSource,
+> = fields.SourceFromSchema<ActorSchema<TType, TSystemSource, TItemSource>>;

package/src/common/documents/adventure.d.mts

@@ -0,0 +1,105 @@
+import { Document, DocumentMetadata } from "../abstract/_module.mjs";
+import * as fields from "../data/fields.mjs";
+import { DocumentOwnershipLevel, ImageFilePath, UserAction, UserPermission, UserRole, UserRoleName } from "./../constants.mjs";
+import * as documents from "./_module.mjs";
+
+/**
+ * The Document definition for an Adventure.
+ * Defines the DataSchema and common behaviors for an Adventure which are shared between both client and server.
+ * @memberof documents
+ *
+ * @param data    Initial data from which to construct the Actor
+ * @param context Construction context options
+ */
+export default class BaseAdventure extends Document<null, AdventureSchema> {
+    static override get metadata(): AdventureMetadata;
+
+    static override defineSchema(): AdventureSchema;
+
+    /* ---------------------------------------- */
+    /*  Permissions                             */
+    /* ---------------------------------------- */
+
+    /** Test whether the User has a GAMEMASTER or ASSISTANT role in this World? */
+    get isGM(): boolean;
+
+    /**
+     * Test whether the User is able to perform a certain permission action.
+     * The provided permission string may pertain to an explicit permission setting or a named user role.
+     * Alternatively, Gamemaster users are assumed to be allowed to take all actions.
+     *
+     * @param action The action to test
+     * @return Does the user have the ability to perform this action?
+     */
+    can(action: UserAction): boolean;
+
+    getUserLevel(user: documents.BaseUser): DocumentOwnershipLevel;
+
+    /**
+     * Test whether the User has at least a specific permission
+     * @param permission The permission name from USER_PERMISSIONS to test
+     * @return Does the user have at least this permission
+     */
+    hasPermission(permission: UserPermission): boolean;
+
+    /**
+     * Test whether the User has at least the permission level of a certain role
+     * @param role The role name from USER_ROLES to test
+     * @param [exact] Require the role match to be exact
+     * @return Does the user have at this role level (or greater)?
+     */
+    hasRole(role: UserRole | UserRoleName, { exact }?: { exact: boolean }): boolean;
+}
+
+export default interface BaseAdventure extends Document<null, AdventureSchema>, fields.ModelPropsFromSchema<AdventureSchema> {
+    get documentName(): AdventureMetadata["name"];
+}
+
+interface AdventureMetadata extends DocumentMetadata {
+    name: "Adventure";
+    collection: "Adventures";
+    label: "DOCUMENT.Adventure";
+    isPrimary: true;
+}
+
+type AdventureSchema = {
+    /** The _id which uniquely identifies this Adventure document */
+    _id: fields.DocumentIdField;
+    /** The human-readable name of the Adventure */
+    name: fields.StringField<string, string, true, false, false>;
+    /** The human-readable name of the Adventure*/
+    img: fields.FilePathField<ImageFilePath>;
+    /** A string caption displayed under the primary image banner */
+    caption: fields.HTMLField;
+    /** An HTML text description for the adventure */
+    description: fields.HTMLField;
+    /** An array of Actor documents which are included in the adventure */
+    actors: fields.SetField<fields.EmbeddedDataField<documents.BaseActor<null>>>;
+    /** An array of Combat documents which are included in the adventure */
+    combats: fields.SetField<fields.EmbeddedDataField<documents.BaseCombat>>;
+    /** An array of Item documents which are included in the adventure */
+    items: fields.SetField<fields.EmbeddedDataField<documents.BaseItem<null>>>;
+    /** An array of JournalEntry documents which are included in the adventure */
+    journal: fields.SetField<fields.EmbeddedDataField<documents.BaseJournalEntry>>;
+    /** An array of Scene documents which are included in the adventure */
+    scenes: fields.SetField<fields.EmbeddedDataField<documents.BaseScene>>;
+    /** An array of RollTable documents which are included in the adventure */
+    tables: fields.SetField<fields.EmbeddedDataField<documents.BaseRollTable>>;
+    /** An array of Macro documents which are included in the adventure */
+    macros: fields.SetField<fields.EmbeddedDataField<documents.BaseMacro>>;
+    /** An array of Cards documents which are included in the adventure */
+    cards: fields.SetField<fields.EmbeddedDataField<documents.BaseCards>>;
+    /** An array of Playlist documents which are included in the adventure */
+    playlists: fields.SetField<fields.EmbeddedDataField<documents.BasePlaylist>>;
+    /** An array of Folder documents which are included in the adventure */
+    folders: fields.SetField<fields.EmbeddedDataField<documents.BaseFolder>>;
+    folder: fields.ForeignDocumentField<documents.BaseFolder>;
+    /** The sort order of this adventure relative to its siblings */
+    sort: fields.IntegerSortField;
+    /** An object of optional key/value flags */
+    flags: fields.DocumentFlagsField;
+    /** An object of creation and access information */
+    _stats: fields.DocumentStatsField;
+};
+
+export type AdventureSource = fields.SourceFromSchema<AdventureSchema>;

package/src/common/documents/ambient-light.d.mts

@@ -0,0 +1,49 @@
+import { Document, DocumentMetadata } from "../abstract/_module.mjs";
+import * as data from "../data/data.mjs";
+import * as fields from "../data/fields.mjs";
+import BaseScene from "./scene.mjs";
+
+/** The AmbientLight embedded document model. */
+export default class BaseAmbientLight<TParent extends BaseScene | null> extends Document<TParent, AmbientLightSchema> {
+    static override get metadata(): AmbientLightMetadata;
+
+    static override defineSchema(): AmbientLightSchema;
+
+    protected override _initialize(): void;
+}
+
+export default interface BaseAmbientLight<TParent extends BaseScene | null>
+    extends Document<TParent, AmbientLightSchema>, fields.ModelPropsFromSchema<AmbientLightSchema> {}
+
+interface AmbientLightMetadata extends DocumentMetadata {
+    name: "AmbientLight";
+    collection: "lights";
+    label: "DOCUMENT.AmbientLight";
+    isEmbedded: true;
+}
+
+export type AmbientLightSchema = {
+    /** The _id which uniquely identifies this BaseAmbientLight embedded document */
+    _id: fields.DocumentIdField;
+    /** The x-coordinate position of the origin of the light */
+    x: fields.NumberField<number, number, true, false, true>;
+    /** The y-coordinate position of the origin of the light */
+    y: fields.NumberField<number, number, true, false, true>;
+    elevation: fields.NumberField<number, number, true, false, true>;
+    /** The angle of rotation for the tile between 0 and 360 */
+    rotation: fields.AngleField;
+    /** Whether or not this light source is constrained by Walls */
+    walls: fields.BooleanField;
+    /** Whether or not this light source provides a source of vision */
+    vision: fields.BooleanField;
+    /** Light configuration data */
+    config: fields.EmbeddedDataField<data.LightData<BaseAmbientLight<BaseScene | null>>>;
+    /** Is the light source currently hidden? */
+    hidden: fields.BooleanField;
+    /** An object of optional key/value flags */
+    flags: fields.DocumentFlagsField;
+};
+
+export type AmbientLightSource = fields.SourceFromSchema<AmbientLightSchema>;
+
+export {};