@league-of-foundry-developers/foundry-vtt-types 9.280.1 → 12.331.2-beta

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

@@ -0,0 +1,120 @@
+import type { AnyObject, InexactPartial } from "../../../types/utils.d.mts";
+import type Document from "../abstract/document.mts";
+import type { fields } from "../data/module.d.mts";
+import type { CONST, documents } from "../../client-esm/client.d.mts";
+
+/**
+ * The ActorDelta Document.
+ * 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.
+ */
+// Note(LukeAbby): You may wonder why documents don't simply pass the `Parent` generic parameter.
+// This pattern evolved from trying to avoid circular loops and even internal tsc errors.
+// See: https://gist.github.com/LukeAbby/0d01b6e20ef19ebc304d7d18cef9cc21
+declare class BaseActorDelta extends Document<"ActorDelta", BaseActorDelta.Schema, any> {
+  // TODO(LukeAbby): This constructor is a symptom of a circular error.
+  // constructor(data?: BaseActorDelta.ConstructorData, context?: Document.ConstructionContext<BaseActorDelta.Parent>);
+
+  override parent: BaseActorDelta.Parent;
+
+  override _source: BaseActorDelta.Source;
+
+  static override metadata: BaseActorDelta.Metadata;
+
+  static override defineSchema(): BaseActorDelta.Schema;
+
+  override canUserModify(user: documents.BaseUser, action: "create" | "update" | "delete", data?: AnyObject): boolean;
+
+  override testUserPermission(
+    user: documents.BaseUser,
+    permission: keyof typeof CONST.DOCUMENT_OWNERSHIP_LEVELS | CONST.DOCUMENT_OWNERSHIP_LEVELS,
+    options?: InexactPartial<{
+      /**
+       * Require the exact permission level requested?
+       * @defaultValue `false`
+       */
+      exact: boolean;
+    }>,
+  ): boolean;
+
+  /**
+   * Retrieve the base actor's collection, if it exists.
+   * @param collectionName - The collection name.
+   */
+  getBaseCollection(collectionName: string): Collection<Actor> | undefined;
+
+  static applyDelta(
+    delta: BaseActorDelta,
+    baseActor: documents.BaseActor,
+    context: unknown,
+  ): Document.ConfiguredClassForName<"Actor"> | null;
+
+  static migrateData(source: AnyObject): AnyObject;
+
+  //TODO: Figure out if this override still applies
+  toObject(source: true): this["_source"];
+  toObject(source?: boolean): ReturnType<this["schema"]["toObject"]>;
+}
+
+export default BaseActorDelta;
+
+declare namespace BaseActorDelta {
+  type Parent = TokenDocument.ConfiguredInstance | null;
+
+  // Note that in places like CONFIG the only eligible type is "base"
+  type TypeNames = Game.Model.TypeNames<"Actor">;
+  type SchemaField = fields.SchemaField<Schema>;
+  type ConstructorData = fields.SchemaField.InnerConstructorType<Schema>;
+  type UpdateData = fields.SchemaField.InnerAssignmentType<Schema>;
+  type Properties = fields.SchemaField.InnerInitializedType<Schema>;
+  type Source = fields.SchemaField.InnerPersistedType<Schema>;
+
+  type Metadata = Document.MetadataFor<BaseActorDelta>;
+
+  interface Schema<TypeName extends TypeNames = TypeNames> extends DataSchema {
+    /**
+     * The _id which uniquely identifies this ActorDelta document.
+     */
+    _id: fields.DocumentIdField;
+
+    /**
+     * The name override, if any.
+     */
+    name: fields.StringField<{ required: false; nullable: true; initial: null }>;
+
+    /**
+     * The type override, if any.
+     */
+    type: fields.StringField<{ required: false; nullable: true; initial: null }, TypeName, TypeName, TypeName>;
+
+    /**
+     * The image override, if any.
+     */
+    img: fields.FilePathField<{ categories: ["IMAGE"]; nullable: true; initial: null; required: false }>;
+
+    /**
+     * The system data model override.
+     */
+    system: fields.ObjectField;
+
+    /**
+     * An array of embedded item data overrides.
+     */
+    items: fields.EmbeddedCollectionDeltaField<typeof documents.BaseItem, ActorDelta.ConfiguredInstance>;
+
+    /**
+     * An array of embedded active effect data overrides.
+     */
+    effects: fields.EmbeddedCollectionDeltaField<typeof documents.BaseActiveEffect, ActorDelta.ConfiguredInstance>;
+
+    /**
+     * Ownership overrides.
+     */
+    ownership: fields.DocumentOwnershipField<{ required: false; nullable: true; initial: null }>;
+
+    /**
+     * An object of actor flag overrides.
+     */
+    flags: fields.ObjectField.FlagsField<"Actor">;
+  }
+}

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

@@ -0,0 +1,168 @@
+import type { AnyObject } from "../../../types/utils.mts";
+import type Document from "../abstract/document.mts";
+import type { PrototypeToken } from "../data/data.mts";
+import type * as fields from "../data/fields.d.mts";
+import type * as documents from "./_module.d.mts";
+
+/**
+ * The Actor Document.
+ * Defines the DataSchema and common behaviors for an Actor which are shared between both client and server.
+ */
+// Note(LukeAbby): You may wonder why documents don't simply pass the `Parent` generic parameter.
+// This pattern evolved from trying to avoid circular loops and even internal tsc errors.
+// See: https://gist.github.com/LukeAbby/0d01b6e20ef19ebc304d7d18cef9cc21
+declare class BaseActor extends Document<"Actor", BaseActor.Schema, any> {
+  /**
+   * @privateRemarks Manual override of the return due to TS limitations with static `this`
+   */
+  static get TYPES(): BaseActor.TypeNames[];
+
+  /**
+   * @param data    - Initial data from which to construct the Actor
+   * @param context - Construction context options
+   */
+  // TODO(LukeAbby): This constructor is causing a circular error.
+  // constructor(data: BaseActor.ConstructorData, context?: Document.ConstructionContext<BaseActor.Parent>);
+
+  override parent: BaseActor.Parent;
+
+  static override metadata: BaseActor.Metadata;
+
+  static override defineSchema(): BaseActor.Schema;
+
+  /**
+   * The default icon used for newly created Actor documents.
+   * @defaultValue `CONST.DEFAULT_TOKEN`
+   */
+  static DEFAULT_ICON: string;
+
+  /**
+   * Determine default artwork based on the provided actor data
+   * @param actorData - The source actor data
+   */
+  static getDefaultArtwork(actorData: BaseActor.ConstructorData): {
+    img: string;
+    texture: { src: string };
+  };
+
+  protected override _initializeSource(
+    data: BaseActor.ConstructorData | this,
+    options?: Omit<foundry.abstract.DataModel.DataValidationOptions, "parent">,
+  ): BaseActor.Source;
+
+  static override canUserCreate(user: documents.BaseUser): boolean;
+
+  /**
+   * Is a user able to create this actor?
+   * @param user - The user attempting the creation operation.
+   * @param doc  - The Actor being created.
+   * @internal
+   */
+  static #canCreate(user: documents.BaseUser, doc: BaseActor): boolean;
+
+  /**
+   * Is a user able to update an existing actor?
+   * @param user - The user attempting the update operation.
+   * @param doc  - The Actor being updated.
+   * @param data - The update delta being applied.
+   * @internal
+   */
+  static #canUpdate(user: documents.BaseUser, doc: BaseActor, data: BaseActor.UpdateData): boolean;
+
+  /**
+   * @privateRemarks _preCreate and _preUpdate are overridden but with no signature changes.
+   * For type simplicity they are left off. These methods historically have been the source of a large amount of computation from tsc.
+   */
+
+  static override migrateData(source: AnyObject): AnyObject;
+}
+
+declare namespace BaseActor {
+  type Parent = null;
+
+  type TypeNames = Game.Model.TypeNames<"Actor">;
+
+  type Metadata = Document.MetadataFor<BaseActor>;
+
+  type SchemaField = fields.SchemaField<Schema>;
+  type ConstructorData = fields.SchemaField.InnerConstructorType<Schema>;
+  type UpdateData = fields.SchemaField.InnerAssignmentType<Schema>;
+  type Properties = fields.SchemaField.InnerInitializedType<Schema>;
+  type Source = fields.SchemaField.InnerPersistedType<Schema>;
+
+  interface Schema extends DataSchema {
+    /**
+     * The _id which uniquely identifies this Actor document
+     * @defaultValue `null`
+     */
+    _id: fields.DocumentIdField;
+
+    /** The name of this Actor */
+    name: fields.StringField<{ required: true; blank: false; textSearch: true }>;
+
+    /** An Actor subtype which configures the system data model applied */
+    type: fields.DocumentTypeField<typeof BaseActor>;
+
+    /**
+     * An image file path which provides the artwork for this Actor
+     * @defaultValue `null`
+     */
+    img: fields.FilePathField<{ categories: "IMAGE"[]; initial: (data: unknown) => string }>;
+
+    /**
+     * The system data object which is defined by the system template.json model
+     * @defaultValue `{}`
+     */
+    system: fields.TypeDataField<typeof BaseActor>;
+
+    /**
+     * Default Token settings which are used for Tokens created from this Actor
+     * @defaultValue see {@link PrototypeToken}
+     */
+    prototypeToken: fields.EmbeddedDataField<typeof PrototypeToken>;
+
+    /**
+     * A Collection of Item embedded Documents
+     * @defaultValue `[]`
+     */
+    items: fields.EmbeddedCollectionField<typeof documents.BaseItem, Actor.ConfiguredInstance>;
+
+    /**
+     * A Collection of ActiveEffect embedded Documents
+     * @defaultValue `[]`
+     */
+    effects: fields.EmbeddedCollectionField<typeof documents.BaseActiveEffect, Actor.ConfiguredInstance>;
+
+    /**
+     * The _id of a Folder which contains this Actor
+     * @defaultValue `null`
+     */
+    folder: fields.ForeignDocumentField<typeof documents.BaseFolder>;
+
+    /**
+     * The numeric sort value which orders this Actor relative to its siblings
+     * @defaultValue `0`
+     */
+    sort: fields.IntegerSortField;
+
+    /**
+     * An object which configures ownership of this Actor
+     * @defaultValue `{ default: DOCUMENT_OWNERSHIP_LEVELS.NONE }`
+     */
+    ownership: fields.DocumentOwnershipField;
+
+    /**
+     * An object of optional key/value flags
+     * @defaultValue `{}`
+     */
+    flags: fields.ObjectField.FlagsField<"Actor">;
+
+    /**
+     * An object of creation and access information
+     * @defaultValue see {@link fields.DocumentStatsField}
+     */
+    _stats: fields.DocumentStatsField;
+  }
+}
+
+export default BaseActor;

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

@@ -0,0 +1,184 @@
+import type Document from "../abstract/document.mts";
+import type * as fields from "../data/fields.d.mts";
+
+/**
+ * The Adventure Document.
+ * Defines the DataSchema and common behaviors for an Adventure which are shared between both client and server.
+ */
+// Note(LukeAbby): You may wonder why documents don't simply pass the `Parent` generic parameter.
+// This pattern evolved from trying to avoid circular loops and even internal tsc errors.
+// See: https://gist.github.com/LukeAbby/0d01b6e20ef19ebc304d7d18cef9cc21
+declare class BaseAdventure extends Document<"Adventure", BaseAdventure.Schema, any> {
+  /**
+   * @param data    - Initial data from which to construct the Actor
+   * @param context - Construction context options
+   */
+  // TODO(LukeAbby): This constructor is a symptom of a circular error.
+  // constructor(data: BaseAdventure.ConstructorData, context?: Document.ConstructionContext<BaseAdventure.Parent>);
+
+  override parent: BaseAdventure.Parent;
+
+  static override metadata: BaseAdventure.Metadata;
+
+  static override defineSchema(): BaseAdventure.Schema;
+
+  /**
+   * An array of the fields which provide imported content from the Adventure.
+   */
+  static get contentFields(): BaseAdventure.ContentFields;
+
+  /**
+   * Provide a thumbnail image path used to represent the Adventure document.
+   */
+  get thumbnail(): string;
+}
+
+export default BaseAdventure;
+
+declare namespace BaseAdventure {
+  type Parent = null;
+
+  type Metadata = Document.MetadataFor<BaseAdventure>;
+
+  type SchemaField = fields.SchemaField<Schema>;
+  type ConstructorData = fields.SchemaField.InnerConstructorType<Schema>;
+  type UpdateData = fields.SchemaField.InnerAssignmentType<Schema>;
+  type Properties = fields.SchemaField.InnerInitializedType<Schema>;
+  type Source = fields.SchemaField.InnerPersistedType<Schema>;
+
+  interface Schema extends DataSchema {
+    /**
+     * The _id which uniquely identifies this Adventure document
+     * @defaultValue `null`
+     */
+    _id: fields.DocumentIdField;
+
+    /**
+     * The human-readable name of the Adventure
+     */
+    name: fields.StringField<{
+      required: true;
+      blank: false;
+      label: "ADVENTURE.Name";
+      hint: "ADVENTURE.NameHint";
+      textSearch: true;
+    }>;
+
+    /**
+     * The file path for the primary image of the adventure
+     * @defaultValue `null`
+     */
+    img: fields.FilePathField<{ categories: ["IMAGE"]; label: "ADVENTURE.Image"; hint: "ADVENTURE.ImageHint" }>;
+
+    /**
+     * A string caption displayed under the primary image banner
+     * @defaultValue `""`
+     */
+    caption: fields.HTMLField<{ label: "ADVENTURE.Caption"; hint: "ADVENTURE.CaptionHint" }>;
+
+    /**
+     * An HTML text description for the adventure
+     * @defaultValue `""`
+     */
+    description: fields.HTMLField<{
+      label: "ADVENTURE.Description";
+      hint: "ADVENTURE.DescriptionHint";
+      textSearch: true;
+    }>;
+
+    /**
+     * An array of Actor documents which are included in the adventure
+     * @defaultValue `new Set()`
+     */
+    actors: fields.SetField<fields.EmbeddedDataField<Actor.ConfiguredClass>>;
+
+    /**
+     * An array of Combat documents which are included in the adventure
+     * @defaultValue `new Set()`
+     */
+    combats: fields.SetField<fields.EmbeddedDataField<Combat.ConfiguredClass>>;
+
+    /**
+     * An array of Item documents which are included in the adventure
+     * @defaultValue `new Set()`
+     */
+    items: fields.SetField<fields.EmbeddedDataField<Item.ConfiguredClass>>;
+
+    /**
+     * An array of JournalEntry documents which are included in the adventure
+     * @defaultValue `new Set()`
+     */
+    journal: fields.SetField<fields.EmbeddedDataField<JournalEntry.ConfiguredClass>>;
+
+    /**
+     * An array of Scene documents which are included in the adventure
+     * @defaultValue `new Set()`
+     */
+    scenes: fields.SetField<fields.EmbeddedDataField<Scene.ConfiguredClass>>;
+
+    /**
+     * An array of RollTable documents which are included in the adventure
+     * @defaultValue `new Set()`
+     */
+    tables: fields.SetField<fields.EmbeddedDataField<RollTable.ConfiguredClass>>;
+
+    /**
+     * An array of Macro documents which are included in the adventure
+     * @defaultValue `new Set()`
+     */
+    macros: fields.SetField<fields.EmbeddedDataField<Macro.ConfiguredClass>>;
+
+    /**
+     * An array of Cards documents which are included in the adventure
+     * @defaultValue `new Set()`
+     */
+    cards: fields.SetField<fields.EmbeddedDataField<Cards.ConfiguredClass>>;
+
+    /**
+     * An array of Playlist documents which are included in the adventure
+     * @defaultValue `new Set()`
+     */
+    playlists: fields.SetField<fields.EmbeddedDataField<Playlist.ConfiguredClass>>;
+
+    /**
+     * An array of Folder documents which are included in the adventure
+     * @defaultValue `new Set()`
+     */
+    folders: fields.SetField<fields.EmbeddedDataField<Folder.ConfiguredClass>>;
+
+    folder: fields.ForeignDocumentField<Folder.ConfiguredClass>;
+
+    /**
+     * The sort order of this adventure relative to its siblings
+     * @defaultValue `0`
+     */
+    sort: fields.IntegerSortField;
+
+    /**
+     * An object of optional key/value flags
+     * @defaultValue `{}`
+     */
+    flags: fields.ObjectField.FlagsField<"Adventure">;
+
+    /**
+     * An object of creation and access information
+     * @defaultValue see {@link fields.DocumentStatsField}
+     */
+    _stats: fields.DocumentStatsField;
+  }
+
+  /**
+   * A helper type to extract the return value for {@link BaseAdventure.contentFields}
+   */
+  type ContentFields = {
+    [Key in keyof BaseAdventure.Schema as BaseAdventure.Schema[Key] extends fields.SetField.Any
+      ? Key
+      : never]: BaseAdventure.Schema[Key] extends fields.SetField<infer ElementType, any, any, any, any, any, any, any>
+      ? ElementType extends fields.EmbeddedDataField<infer ModelType, any, any, any, any>
+        ? ModelType extends Document.AnyConstructor // TODO: This doesn't seem to quite work to ensure it's the configured class
+          ? ModelType["implementation"]
+          : ModelType
+        : never
+      : never;
+  };
+}

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

@@ -0,0 +1,98 @@
+import type { AnyObject } from "../../../types/utils.mts";
+import type Document from "../abstract/document.mts";
+import type { LightData } from "../data/data.mts";
+import type * as fields from "../data/fields.d.mts";
+
+/**
+ * The Document definition for an AmbientLight.
+ * Defines the DataSchema and common behaviors for an AmbientLight which are shared between both client and server.
+ */
+// Note(LukeAbby): You may wonder why documents don't simply pass the `Parent` generic parameter.
+// This pattern evolved from trying to avoid circular loops and even internal tsc errors.
+// See: https://gist.github.com/LukeAbby/0d01b6e20ef19ebc304d7d18cef9cc21
+declare class BaseAmbientLight extends Document<"AmbientLight", BaseAmbientLight.Schema, any> {
+  /**
+   * @param data    - Initial data from which to construct the AmbientLight
+   * @param context - Construction context options
+   */
+  // TODO(LukeAbby): This constructor is a symptom of a circular error.
+  // constructor(data?: BaseAmbientLight.ConstructorData, context?: Document.ConstructionContext<BaseAmbientLight.Parent>);
+
+  override parent: BaseAmbientLight.Parent;
+
+  static override metadata: BaseAmbientLight.Metadata;
+
+  static override defineSchema(): BaseAmbientLight.Schema;
+
+  static override migrateData(source: AnyObject): AnyObject;
+}
+
+export default BaseAmbientLight;
+
+declare namespace BaseAmbientLight {
+  type Parent = Scene.ConfiguredInstance | null;
+
+  type Metadata = Document.MetadataFor<BaseAmbientLight>;
+
+  type SchemaField = fields.SchemaField<Schema>;
+  type ConstructorData = fields.SchemaField.InnerConstructorType<Schema>;
+  type UpdateData = fields.SchemaField.InnerAssignmentType<Schema>;
+  type Properties = fields.SchemaField.InnerInitializedType<Schema>;
+  type Source = fields.SchemaField.InnerPersistedType<Schema>;
+
+  interface Schema extends DataSchema {
+    /**
+     * The _id which uniquely identifies this BaseAmbientLight embedded document
+     * @defaultValue `null`
+     */
+    _id: fields.DocumentIdField;
+
+    /**
+     * The x-coordinate position of the origin of the light
+     * @defaultValue `0`
+     */
+    x: fields.NumberField<{ required: true; integer: true; nullable: false; initial: 0; label: "XCoord" }>;
+
+    /**
+     * The y-coordinate position of the origin of the light
+     * @defaultValue `0`
+     */
+    y: fields.NumberField<{ required: true; integer: true; nullable: false; initial: 0; label: "YCoord" }>;
+
+    /**
+     * The angle of rotation for the tile between 0 and 360
+     * @defaultValue `0`
+     */
+    rotation: fields.AngleField<{ label: "LIGHT.Rotation" }>;
+
+    /**
+     * Whether or not this light source is constrained by Walls
+     * @defaultValue `true`
+     */
+    walls: fields.BooleanField<{ initial: true; label: "LIGHT.Walls"; hint: "LIGHT.WallsHint" }>;
+
+    /**
+     * Whether or not this light source provides a source of vision
+     * @defaultValue `false`
+     */
+    vision: fields.BooleanField<{ label: "LIGHT.Vision"; hint: "LIGHT.VisionHint" }>;
+
+    /**
+     * Light configuration data
+     * @defaultValue see {@link LightData}
+     */
+    config: fields.EmbeddedDataField<typeof LightData>;
+
+    /**
+     * Is the light source currently hidden?
+     * @defaultValue `false`
+     */
+    hidden: fields.BooleanField<{ label: "Hidden" }>;
+
+    /**
+     * An object of optional key/value flags
+     * @defaultValue `{}`
+     */
+    flags: fields.ObjectField.FlagsField<"AmbientLight">;
+  }
+}

package/src/foundry/common/documents/ambient-sound.d.mts

@@ -0,0 +1,132 @@
+import type { AnyObject } from "../../../types/utils.mts";
+import type Document from "../abstract/document.mts";
+import type * as fields from "../data/fields.d.mts";
+
+/**
+ * The Document definition for an AmbientSound.
+ * Defines the DataSchema and common behaviors for an AmbientSound which are shared between both client and server.
+ */
+// Note(LukeAbby): You may wonder why documents don't simply pass the `Parent` generic parameter.
+// This pattern evolved from trying to avoid circular loops and even internal tsc errors.
+// See: https://gist.github.com/LukeAbby/0d01b6e20ef19ebc304d7d18cef9cc21
+declare class BaseAmbientSound extends Document<"AmbientSound", BaseAmbientSound.Schema, any> {
+  /**
+   * @param data    - Initial data from which to construct the AmbientSound
+   * @param context - Construction context options
+   */
+  // TODO(LukeAbby): This constructor is a symptom of a circular error.
+  // constructor(data?: BaseAmbientSound.ConstructorData, context?: Document.ConstructionContext<BaseAmbientSound.Parent>);
+
+  override parent: BaseAmbientSound.Parent;
+
+  static override metadata: BaseAmbientSound.Metadata;
+
+  static override defineSchema(): BaseAmbientSound.Schema;
+
+  static override migrateData(source: AnyObject): AnyObject;
+}
+
+export default BaseAmbientSound;
+
+declare namespace BaseAmbientSound {
+  type Parent = Scene.ConfiguredInstance | null;
+
+  type Metadata = Document.MetadataFor<BaseAmbientSound>;
+
+  type SchemaField = fields.SchemaField<Schema>;
+  type ConstructorData = fields.SchemaField.InnerConstructorType<Schema>;
+  type UpdateData = fields.SchemaField.InnerAssignmentType<Schema>;
+  type Properties = fields.SchemaField.InnerInitializedType<Schema>;
+  type Source = fields.SchemaField.InnerPersistedType<Schema>;
+
+  interface Schema extends DataSchema {
+    /**
+     * The _id which uniquely identifies this AmbientSound document
+     * @defaultValue `null`
+     */
+    _id: fields.DocumentIdField;
+
+    /**
+     * The x-coordinate position of the origin of the sound.
+     * @defaultValue `0`
+     */
+    x: fields.NumberField<{ required: true; integer: true; nullable: false; initial: 0; label: "XCoord" }>;
+
+    /**
+     * The y-coordinate position of the origin of the sound.
+     * @defaultValue `0`
+     */
+    y: fields.NumberField<{ required: true; integer: true; nullable: false; initial: 0; label: "YCoord" }>;
+
+    /**
+     * The radius of the emitted sound.
+     * @defaultValue `0`
+     */
+    radius: fields.NumberField<{
+      required: true;
+      nullable: false;
+      initial: 0;
+      min: 0;
+      step: 0.01;
+      label: "SOUND.Radius";
+    }>;
+
+    /**
+     * The audio file path that is played by this sound
+     * @defaultValue `null`
+     */
+    path: fields.FilePathField<{ categories: ["AUDIO"]; label: "SOUND.SourcePath" }>;
+
+    /**
+     * Does this sound loop?
+     * @defaultValue `false`
+     */
+    repeat: fields.BooleanField;
+
+    /**
+     * The audio volume of the sound, from 0 to 1
+     * @defaultValue `0.5`
+     */
+    volume: fields.AlphaField<{ initial: 0.5; step: 0.01; label: "SOUND.MaxVol"; hint: "SOUND.MaxVolHint" }>;
+
+    /**
+     * Whether or not this sound source is constrained by Walls.
+     * @defaultValue `true`
+     */
+    walls: fields.BooleanField<{ initial: true; label: "SOUND.Walls"; hint: "SOUND.WallsHint" }>;
+
+    /**
+     * Whether to adjust the volume of the sound heard by the listener based on how
+     * close the listener is to the center of the sound source.
+     * @defaultValue `true`
+     */
+    easing: fields.BooleanField<{ initial: true; label: "SOUND.Easing"; hint: "SOUND.EasingHint" }>;
+
+    /**
+     * Is the sound source currently hidden?
+     * @defaultValue `false`
+     */
+    hidden: fields.BooleanField<{ label: "Hidden" }>;
+
+    /**
+     * A darkness range (min and max) for which the source should be active
+     * @defaultValue see properties
+     */
+    darkness: fields.SchemaField<
+      {
+        /** @defaultValue `0` */
+        min: fields.AlphaField<{ initial: 0 }>;
+
+        /** @defaultValue `1` */
+        max: fields.AlphaField<{ initial: 1 }>;
+      },
+      { label: "SOUND.DarknessRange"; hint: "SOUND.DarknessRangeHint" }
+    >;
+
+    /**
+     * An object of optional key/value flags
+     * @defaultValue `{}`
+     */
+    flags: fields.ObjectField.FlagsField<"AmbientSound">;
+  }
+}