@league-of-foundry-developers/foundry-vtt-types 13.340.0 → 13.345.1-beta.20250704.94554

package/src/foundry/client/canvas/placeables/region.d.mts

@@ -0,0 +1,275 @@
+import type { ConfiguredObjectClassOrDefault } from "../../config.d.mts";
+import type { Brand, FixedInstanceType, HandleEmptyObject, NullishProps } from "#utils";
+import type { Canvas } from "#client/canvas/_module.d.mts";
+import type { PlaceableObject } from "#client/canvas/placeables/_module.d.mts";
+import type { RegionShape, RegionPolygonTree } from "#client/data/region-shapes/_module.d.mts";
+import type { RegionGeometry } from "#client/canvas/placeables/regions/_module.d.mts";
+import { RenderFlagsMixin, RenderFlags, RenderFlag } from "#client/canvas/interaction/_module.mjs";
+
+declare module "#configuration" {
+  namespace Hooks {
+    interface PlaceableObjectConfig {
+      Region: Region.Implementation;
+    }
+  }
+}
+
+/**
+ * A Region is an implementation of PlaceableObject which represents a Region document
+ * within a viewed Scene on the game canvas.
+ * @see {@linkcode RegionDocument}
+ * @see {@linkcode RegionLayer}
+ */
+declare class Region extends PlaceableObject<RegionDocument.Implementation> {
+  constructor(document: RegionDocument.Implementation);
+
+  // fake override; super has to type as if this could be a ControlIcon, but Regions don't use one
+  override controlIcon: null;
+
+  static override embeddedName: "Region";
+
+  static override RENDER_FLAGS: Region.RENDER_FLAGS;
+
+  // Note: This isn't a "real" override but `renderFlags` is set corresponding to the
+  // `RENDER_FLAGS` and so it has to be adjusted here.
+  renderFlags: RenderFlags<Region.RENDER_FLAGS>;
+
+  /**
+   * The scaling factor used for Clipper paths.
+   * @defaultValue `100`
+   * @remarks Defined using `Object.defineProperty` in a static initialization block
+   */
+  static readonly CLIPPER_SCALING_FACTOR: 100;
+
+  /**
+   * The three movement segment types: ENTER, MOVE, and EXIT.
+   * @remarks Defined using `Object.defineProperty` in a static initialization block
+   */
+  static readonly MOVEMENT_SEGMENT_TYPES: Region.MovementSegmentTypes;
+
+  /**
+   * The shapes of this Region in draw order.
+   * @privateRemarks Foundry types this as `ReadonlyArray<>`, but does nothing to that effect at runtime.
+   * Not reported, as this is deprecated and thus untyped in v13
+   */
+  get shapes(): RegionShape.Any[];
+
+  /** The bottom elevation of this Region. */
+  get bottom(): number;
+
+  /** The top elevation of this Region. */
+  get top(): number;
+
+  /**
+   * The polygons of this Region.
+   * @privateRemarks Foundry types this as `ReadonlyArray<>`, but does nothing to that effect at runtime.
+   * Not reported, as this is deprecated and thus untyped in v13
+   */
+  get polygons(): PIXI.Polygon[];
+
+  /** The polygon tree of this Region. */
+  get polygonTree(): RegionPolygonTree;
+
+  /**
+   * The Clipper paths of this Region.
+   * @privateRemarks Foundry types this as `ReadonlyArray<>`, but does nothing to that effect at runtime.
+   * Not reported, as this is deprecated and thus untyped in v13
+   */
+  get clipperPaths(): ClipperLib.Paths;
+
+  /**
+   * The triangulation of this Region
+   * @privateRemarks Foundry types this as `Readonly<>`, but does nothing to that effect at runtime.
+   * Not reported, as this is deprecated and thus untyped in v13
+   */
+  get triangulation(): Region.TriangulationData;
+
+  /** The geometry of this Region */
+  get geometry(): RegionGeometry;
+
+  override get bounds(): PIXI.Rectangle;
+
+  override get center(): PIXI.Point;
+
+  /** Is this Region currently visible on the Canvas? */
+  get isVisible(): boolean;
+
+  /**
+   * @throws "`Region#getSnappedPosition` is not supported: `RegionDocument` does not have a (x, y) position"
+   */
+  override getSnappedPosition(position?: never): never;
+
+  protected override _draw(options: HandleEmptyObject<Region.DrawOptions>): Promise<void>;
+
+  // fake override; super has to account for misbehaving siblings returning void
+  override clear(): this;
+
+  protected override _applyRenderFlags(flags: Region.RenderFlags): void;
+
+  /** Refresh the state of the Region. */
+  protected _refreshState(): void;
+
+  /** Refreshes the border of the Region. */
+  protected _refreshBorder(): void;
+
+  protected override _canDrag(user: User.Implementation, event?: Canvas.Event.Pointer): boolean;
+
+  protected override _canHUD(user: User.Implementation, event?: Canvas.Event.Pointer): boolean;
+
+  protected override _onControl(options: Region.ControlOptions): void;
+
+  protected override _onRelease(options: HandleEmptyObject<Region.ReleaseOptions>): void;
+
+  // options: not null (destructured)
+  protected override _onHoverIn(event: Canvas.Event.Pointer, options?: Region.HoverInOptions): void;
+
+  // options: not null (destructured)
+  protected override _onHoverOut(event: Canvas.Event.Pointer, options?: Region.HoverOutOptions): void;
+
+  protected override _overlapsSelection(rectangle: PIXI.Rectangle): boolean;
+
+  /**
+   * Test whether the given point (at the given elevation) is inside this Region.
+   * @param point       - The point.
+   * @param elevation   - The elevation of the point.
+   * @returns Is the point (at the given elevation) inside this Region?
+   * @remarks Only tests elevation if provided, always forwards `position` to {@link RegionPolygonTree.testPoint | `RegionPolygonTree#testPoint`}
+   */
+  // elevation: not null (`=== undefined` check)
+  testPoint(point: Canvas.Point, elevation?: number): boolean;
+
+  /**
+   * Split the movement into its segments.
+   * @param waypoints - The waypoints of movement.
+   * @param samples   - The points relative to the waypoints that are tested. Whenever one of them is inside the region, the moved object is considered to be inside the region.
+   * @param options   - Additional options
+   * @returns The movement split into its segments.
+   */
+  // options: not null (destructured)
+  segmentizeMovement(
+    waypoints: Region.MovementWaypoint[],
+    samples: Canvas.Point[],
+    options?: Region.SegmentizeMovementOptions,
+  ): Region.MovementSegment[];
+
+  // _onUpdate is overridden but with no signature changes.
+  // For type simplicity it is left off. These methods historically have been the source of a large amount of computation from tsc.
+
+  // fake override to narrow the type from super, which had to account for this class's misbehaving siblings
+  protected override _prepareDragLeftDropUpdates(event: Canvas.Event.Pointer): PlaceableObject.DragLeftDropUpdate[];
+}
+
+declare namespace Region {
+  /**
+   * The implementation of the `Region` placeable configured through `CONFIG.Region.objectClass`
+   * in Foundry and {@linkcode PlaceableObjectClassConfig} in fvtt-types.
+   *
+   * Not to be confused with {@linkcode RegionDocument.Implementation}
+   * which refers to the implementation for the region document.
+   */
+  type Implementation = FixedInstanceType<ImplementationClass>;
+
+  /**
+   * The implementation of the `Region` placeable configured through `CONFIG.Region.objectClass`
+   * in Foundry and {@linkcode PlaceableObjectClassConfig} in fvtt-types.
+   *
+   * Not to be confused with {@linkcode RegionDocument.ImplementationClass}
+   * which refers to the implementation for the region document.
+   */
+  // eslint-disable-next-line no-restricted-syntax
+  type ImplementationClass = ConfiguredObjectClassOrDefault<typeof Region>;
+
+  interface RENDER_FLAGS {
+    /** @defaultValue `{ propagate: ["refresh"] }` */
+    redraw: RenderFlag<this, "redraw">;
+
+    /** @defaultValue `{ propagate: ["refreshState", "refreshBorder"], alias: true }` */
+    refresh: RenderFlag<this, "refresh">;
+
+    /** @defaultValue `{}` */
+    refreshState: RenderFlag<this, "refreshState">;
+
+    /** @defaultValue `{}` */
+    refreshBorder: RenderFlag<this, "refreshBorder">;
+  }
+
+  interface RenderFlags extends RenderFlagsMixin.ToBooleanFlags<RENDER_FLAGS> {}
+
+  interface TriangulationData {
+    vertices: Float32Array;
+    indices: Uint16Array | Uint32Array;
+  }
+
+  interface DrawOptions extends PlaceableObject.DrawOptions {}
+
+  interface RefreshOptions extends PlaceableObject.RefreshOptions {}
+
+  interface ControlOptions extends PlaceableObject.ControlOptions {}
+
+  interface ReleaseOptions extends PlaceableObject.ReleaseOptions {}
+
+  type _HoverInOptions = NullishProps<{
+    /** @defaultValue `true` */
+    updateLegend: boolean;
+  }>;
+
+  interface HoverInOptions extends _HoverInOptions, PlaceableObject.HoverInOptions {}
+
+  interface HoverOutOptions extends _HoverInOptions {}
+
+  interface MovementWaypoint {
+    /** The x-coordinates in pixels (integer) */
+    x: number;
+
+    /** The y-coordinates in pixels (integer) */
+    y: number;
+
+    /** The elevation in grid units. */
+    elevation: number;
+  }
+
+  interface MovementSegment {
+    /** The type of this segment (see {@linkcode Region.MovementSegmentTypes}) */
+    type: MOVEMENT_SEGMENT_TYPES;
+
+    /** The waypoint that this segment starts from */
+    from: MovementWaypoint;
+
+    /** The waypoint that this segment goes to */
+    to: MovementWaypoint;
+  }
+
+  type MOVEMENT_SEGMENT_TYPES = Brand<number, "Region.MOVEMENT_SEGMENT_TYPES">;
+
+  interface MovementSegmentTypes
+    extends Readonly<{
+      /**
+       * The segment crosses the boundary of the region and exits it.
+       */
+      EXIT: -1 & MOVEMENT_SEGMENT_TYPES;
+
+      /**
+       * The segment does not cross the boundary of the region and is contained within it.
+       */
+      MOVE: 0 & MOVEMENT_SEGMENT_TYPES;
+
+      /**
+       * The segment crosses the boundary of the region and enters it.
+       */
+      ENTER: 1 & MOVEMENT_SEGMENT_TYPES;
+    }> {}
+
+  /** @internal */
+  type _SegmentizeMovementOptions = NullishProps<{
+    /**
+     * Is it teleportation?
+     * @defaultValue `false`
+     * @remarks Can't be `null` because it only has a parameter default
+     */
+    teleport: boolean;
+  }>;
+
+  interface SegmentizeMovementOptions extends _SegmentizeMovementOptions {}
+}
+
+export default Region;

package/src/foundry/client/canvas/placeables/regions/_module.d.mts

@@ -0,0 +1,7 @@
+// 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-x/no-unresolved` from erroring `.mjs` is used.
+/* eslint-disable import-x/extensions */
+
+export { default as RegionGeometry } from "./geometry.mjs";
+export { default as RegionMesh } from "./mesh.mjs";

package/src/foundry/client/canvas/placeables/regions/geometry.d.mts

@@ -0,0 +1,40 @@
+import type { Region } from "#client/canvas/placeables/_module.d.mts";
+
+/**
+ * The geometry of a {@linkcode Region}.
+ * - Vertex Attribute: `aVertexPosition` (`vec2`)
+ * - Draw Mode: `PIXI.DRAW_MODES.TRIANGLES`
+ */
+declare class RegionGeometry extends PIXI.Geometry {
+  /**
+   * Create a RegionGeometry
+   * @remarks Foundry marked `@internal`
+   */
+  constructor(region: Region.Implementation);
+
+  /** The Region this geometry belongs to */
+  get region(): Region.Implementation;
+
+  /**
+   * Update the buffers
+   * @remarks Foundry marked `@internal`, is exclusively called externally in `Region##updateShapes`
+   */
+  protected _clearBuffers(): void;
+
+  /**
+   * Update the buffers
+   * @remarks Foundry marked `@internal`, is exclusively called externally in `Region##updateShapes`
+   */
+  protected _updateBuffers(): void;
+}
+
+declare namespace RegionGeometry {
+  interface Any extends AnyRegionGeometry {}
+  type AnyConstructor = typeof AnyRegionGeometry;
+}
+
+declare abstract class AnyRegionGeometry extends RegionGeometry {
+  constructor(...args: never);
+}
+
+export default RegionGeometry;

package/src/foundry/client/canvas/placeables/regions/mesh.d.mts

@@ -0,0 +1,75 @@
+import type { AbstractBaseShader } from "#client/canvas/rendering/shaders/_module.d.mts";
+import type { Region } from "#client/canvas/placeables/_module.d.mts";
+
+/** A mesh of a {@linkcode Region} */
+declare class RegionMesh extends PIXI.Container {
+  /**
+   * Create a RegionMesh
+   * @param region        - The Region to create the RegionMesh from.
+   * @param shaderClass   - The shader class to use. (default: `RegionShader`)
+   */
+  // shaderClass: not null (parameter default only)
+  constructor(region: Region.Implementation, shaderClass?: AbstractBaseShader.AnyConstructor);
+
+  /** The Region of this RegionMesh */
+  get region(): Region.Implementation;
+
+  /** The shader bound to this RegionMesh */
+  get shader(): AbstractBaseShader;
+
+  /** The blend mode assigned tot his RegionMesh */
+  get blendMode(): PIXI.BLEND_MODES;
+  set blendMode(value);
+
+  /**
+   * The tint applied to the mesh. This is a hex value.
+   *
+   * A value of 0xFFFFFF will remove any tint effect.
+   * @defaultValue `0xFFFFFF`
+   */
+  get tint(): number;
+  set tint(value);
+
+  /** The tint applied to the mesh. This is a hex value. A value of 0xFFFFFF will remove any tint effect. */
+  protected _tintColor: PIXI.Color;
+
+  /**
+   * Cached tint value for the shader uniforms
+   * @remarks Foundry marked `@internal`
+   */
+  protected _cachedTint: Color.RGBAColorVector;
+
+  /** Used to track a tint or alpha change to execute a recomputation of _cachedTint. */
+  protected _tintAlphaDirty: boolean;
+
+  /**
+   * Initialize shader based on the shader class type.
+   * @param shaderClass - The shader class, which must inherit from {@linkcode AbstractBaseShader}.
+   */
+  setShaderClass(shaderClass: AbstractBaseShader.AnyConstructor): void;
+
+  override updateTransform(): void;
+
+  protected override _render(renderer: PIXI.Renderer): void;
+
+  protected override _calculateBounds(): void;
+
+  /**
+   * Tests if a point is inside this RegionMesh.
+   * @privateRemarks The rare instance of Foundry using the PIXI interface in *their* types
+   */
+  containsPoint(point: PIXI.IPointData): boolean;
+
+  override destroy(options?: PIXI.IDestroyOptions | boolean): void;
+}
+
+declare namespace RegionMesh {
+  interface Any extends AnyRegionMesh {}
+  type AnyConstructor = typeof AnyRegionMesh;
+}
+
+declare abstract class AnyRegionMesh extends RegionMesh {
+  constructor(...args: never);
+}
+
+export default RegionMesh;

package/src/foundry/client/canvas/placeables/sound.d.mts

@@ -0,0 +1,271 @@
+import type Sound from "#client/audio/sound.d.mts";
+import type { ConfiguredObjectClassOrDefault } from "../../config.d.mts";
+import type {
+  FixedInstanceType,
+  HandleEmptyObject,
+  InexactPartial,
+  IntentionalPartial,
+  NullishProps,
+  RequiredProps,
+} from "#utils";
+import type { PlaceableObject } from "#client/canvas/placeables/_module.d.mts";
+import { RenderFlagsMixin, RenderFlags, RenderFlag } from "#client/canvas/interaction/_module.mjs";
+
+import Canvas = foundry.canvas.Canvas;
+
+declare module "#configuration" {
+  namespace Hooks {
+    interface PlaceableObjectConfig {
+      AmbientSound: AmbientSound.Implementation;
+    }
+  }
+}
+
+/**
+ * An AmbientSound is an implementation of PlaceableObject which represents a dynamic audio source within the Scene.
+ * @see {@linkcode AmbientSoundDocument}
+ * @see {@linkcode SoundsLayer}
+ */
+declare class AmbientSound extends PlaceableObject<AmbientSoundDocument.Implementation> {
+  constructor(document: AmbientSoundDocument.Implementation);
+
+  /**
+   * The Sound which manages playback for this AmbientSound effect
+   * @defaultValue `undefined`
+   * @remarks Only `undefined` prior to {@link AmbientSound.sync | `AmbientSound#sync`}
+   * or {@link AmbientSound._onUpdate | `AmbientSound#_onUpdate`} being called (the
+   * former likely via {@link SoundsLayer._syncPositions | `SoundsLayer#_syncPositions`})
+   *
+   * Set `null` if this sound's document has either no `path` or no `id` (e.g if its a preview, for the latter)
+   */
+  sound: Sound | null | undefined;
+
+  /**
+   * A SoundSource object which manages the area of effect for this ambient sound
+   * @remarks Not initialized to a value in the class body, but {@link AmbientSound._onCreate | `AmbientSound#_onCreate`}
+   * calls {@linkcode AmbientSound.initializeSoundSource}.
+   *
+   * Set `undefined` by {@link AmbientSound._destroy | `AmbientSound#_destroy`}.
+   */
+  source: foundry.canvas.sources.PointSoundSource.Implementation | undefined;
+
+  /**
+   * The area that is affected by this ambient sound.
+   * @defaultValue `undefined`
+   * @remarks Only `undefined` prior to first draw
+   */
+  field: PIXI.Graphics | undefined;
+
+  static override embeddedName: "AmbientSound";
+
+  static override RENDER_FLAGS: AmbientSound.RENDER_FLAGS;
+
+  // Note: This isn't a "real" override but `renderFlags` is set corresponding to the
+  // `RENDER_FLAGS` and so it has to be adjusted here.
+  renderFlags: RenderFlags<AmbientSound.RENDER_FLAGS>;
+
+  /**
+   * Create a Sound used to play this AmbientSound object
+   */
+  protected _createSound(): Sound | null;
+
+  /**
+   * Update the set of effects which are applied to the managed Sound.
+   */
+  // options: not null (destructured)
+  applyEffects(options?: AmbientSound.ApplyEffectsOptions): void;
+
+  /**
+   * Is this ambient sound is currently audible based on its hidden state and the darkness level of the Scene?
+   */
+  get isAudible(): boolean;
+
+  override get bounds(): PIXI.Rectangle;
+
+  /**
+   * A convenience accessor for the sound radius in pixels
+   */
+  get radius(): number;
+
+  /**
+   * Toggle playback of the sound depending on whether or not it is audible
+   * @param isAudible - Is the sound audible?
+   * @param volume    - The target playback volume
+   * @param options   - Additional options which affect sound synchronization
+   */
+  // options: not null (destructured)
+  sync(isAudible: boolean, volume: number, options?: AmbientSound.SyncOptions): void;
+
+  override clear(): this;
+
+  protected override _draw(options: HandleEmptyObject<AmbientSound.DrawOptions>): Promise<void>;
+
+  protected override _destroy(options: PIXI.IDestroyOptions | boolean | undefined): void;
+
+  protected _applyRenderFlags(flags: AmbientSound.RenderFlags): void;
+
+  /**
+   * Refresh the shape of the sound field-of-effect. This is refreshed when the SoundSource fov polygon changes.
+   */
+  protected _refreshField(): void;
+
+  /**
+   * Refresh the position of the AmbientSound. Called with the coordinates change.
+   */
+  protected _refreshPosition(): void;
+
+  /**
+   * Refresh the state of the light. Called when the disabled state or darkness conditions change.
+   */
+  protected _refreshState(): void;
+
+  /**
+   * Refresh the display of the ControlIcon for this AmbientSound source
+   */
+  refreshControl(): void;
+
+  /**
+   * Refresh the elevation of the control icon.
+   */
+  protected _refreshElevation(): void;
+
+  /**
+   * Compute the field-of-vision for an object, determining its effective line-of-sight and field-of-vision polygons
+   * @param options - Options which modify how the audio source is updated
+   */
+  // options: not null (destructured)
+  initializeSoundSource(options?: AmbientSound.InitializeSoundSourceOptions): void;
+
+  /**
+   * Get the sound source data.
+   */
+  protected _getSoundSourceData(): AmbientSound.SoundSourceData;
+
+  // _onCreate, _onUpdate, and _onDelete are all 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.
+
+  protected override _canHUD(user: User.Implementation, event?: Canvas.Event.Pointer): boolean;
+
+  /** @remarks Always returns `false` ("Double-right does nothing") */
+  protected override _canConfigure(user: User.Implementation, event?: Canvas.Event.Pointer): boolean;
+
+  // fake override to narrow the type from super, which had to account for this class's misbehaving siblings
+  // options: not null (destructured)
+  protected override _onHoverIn(event: Canvas.Event.Pointer, options?: PlaceableObject.HoverInOptions): void;
+
+  protected override _onClickRight(event: Canvas.Event.Pointer): void;
+
+  protected override _onDragLeftMove(event: Canvas.Event.Pointer): void;
+
+  protected override _onDragEnd(): void;
+
+  // fake override to narrow the type from super, which had to account for this class's misbehaving siblings
+  protected override _prepareDragLeftDropUpdates(event: Canvas.Event.Pointer): PlaceableObject.DragLeftDropUpdate[];
+
+  /**
+   * @deprecated since v12, until v14
+   * @remarks "`AmbientSound#updateSource` has been deprecated in favor of {@link AmbientSound.initializeSoundSource | `AmbientSound#initializeSoundSource`}"
+   *
+   * @privateRemarks The `defer` parameter exists in this signature but is not used by `#initializeSoundSource`, so we can just reuse that method's options interface
+   */
+  updateSource(options?: AmbientSound.InitializeSoundSourceOptions): void;
+}
+
+declare namespace AmbientSound {
+  /**
+   * The implementation of the `AmbientSound` placeable configured through `CONFIG.AmbientSound.objectClass`
+   * in Foundry and {@linkcode PlaceableObjectClassConfig} in fvtt-types.
+   *
+   * Not to be confused with {@linkcode AmbientSoundDocument.Implementation}
+   * which refers to the implementation for the ambientSound document.
+   */
+  type Implementation = FixedInstanceType<ImplementationClass>;
+
+  /**
+   * The implementation of the `AmbientSound` placeable configured through `CONFIG.AmbientSound.objectClass`
+   * in Foundry and {@linkcode PlaceableObjectClassConfig} in fvtt-types.
+   *
+   * Not to be confused with {@linkcode AmbientSoundDocument.ImplementationClass}
+   * which refers to the implementation for the ambientSound document.
+   */
+  // eslint-disable-next-line no-restricted-syntax
+  type ImplementationClass = ConfiguredObjectClassOrDefault<typeof AmbientSound>;
+
+  interface RENDER_FLAGS {
+    /** @defaultValue `{ propagate: ["refresh"] }` */
+    redraw: RenderFlag<this, "redraw">;
+
+    /** @defaultValue `{ propagate: ["refreshState", "refreshField", "refreshElevation"], alias: true }` */
+    refresh: RenderFlag<this, "refresh">;
+
+    /** @defaultValue `{ propagate: ["refreshPosition"] }` */
+    refreshField: RenderFlag<this, "refreshField">;
+
+    /** @defaultValue `{}` */
+    refreshPosition: RenderFlag<this, "refreshPosition">;
+
+    /** @defaultValue `{}` */
+    refreshState: RenderFlag<this, "refreshState">;
+
+    /** @defaultValue `{}` */
+    refreshElevation: RenderFlag<this, "refreshElevation">;
+  }
+
+  interface RenderFlags extends RenderFlagsMixin.ToBooleanFlags<RENDER_FLAGS> {}
+
+  /** @internal */
+  type _ApplyEffectsOptions = NullishProps<{
+    /**
+     * Is the sound currently muffled?
+     * @defaultValue `false`
+     */
+    muffled: boolean;
+  }>;
+
+  interface ApplyEffectsOptions extends _ApplyEffectsOptions {}
+
+  /** @internal */
+  type _SyncOptions = InexactPartial<{
+    /**
+     * A duration in milliseconds to fade volume transition
+     * @defaultValue `250`
+     * @remarks Can't be `null` as it only has a parameter default
+     */
+    fade: number;
+  }>;
+
+  interface SyncOptions extends _SyncOptions, _ApplyEffectsOptions {}
+
+  interface DrawOptions extends PlaceableObject.DrawOptions {}
+
+  interface RefreshOptions extends PlaceableObject.RefreshOptions {}
+
+  interface ControlOptions extends PlaceableObject.ControlOptions {}
+
+  interface ReleaseOptions extends PlaceableObject.ReleaseOptions {}
+
+  /**
+   * @internal
+   */
+  type _InitializeSoundSourceOptions = NullishProps<{
+    /**
+     * Indicate that this SoundSource has been deleted.
+     * @defaultValue `false`
+     */
+    deleted: boolean;
+  }>;
+
+  interface InitializeSoundSourceOptions extends _InitializeSoundSourceOptions {}
+
+  /**
+   * @remarks The return of {@link AmbientSound._getSoundSourceData | `AmbientSound#_getSoundSourceData`}, which gets passed
+   * to {@link foundry.canvas.sources.PointSoundSource.initialize | `AmbientSound#source#initialize()`}, so this is a
+   * `RequiredProps<IntentionalPartial<>>` rather than a `Pick<>`
+   */
+  type SoundSourceData = RequiredProps<
+    IntentionalPartial<foundry.canvas.sources.PointSoundSource.SourceData>,
+    "x" | "y" | "elevation" | "radius" | "walls" | "disabled"
+  >;
+}
+
+export default AmbientSound;