@league-of-foundry-developers/foundry-vtt-types 13.346.0-beta.20250718083608 → 13.346.0-beta.20250720082736

package/src/foundry/client/canvas/containers/elements/door-mesh.d.mts

@@ -1,12 +1,224 @@
-import type { Identity } from "#utils";
+import type { ConcreteKeys, Identity, InexactPartial, ValueOf } from "#utils";
 import type { PrimarySpriteMesh } from "#client/canvas/primary/_module.d.mts";
+import type { CanvasAnimation } from "#client/canvas/animation/_module.d.mts";
+import type { Wall } from "#client/canvas/placeables/_module.d.mts";
 
-// TODO: whole class
-declare class DoorMesh extends PrimarySpriteMesh {}
+/**
+ * A special subclass of {@linkcode PrimarySpriteMesh} used to render an interactive door.
+ */
+declare class DoorMesh extends PrimarySpriteMesh {
+  /**
+   * Construct a DoorMesh by providing {@linkcode PrimarySpriteMesh} constructor options and specific door configuration.
+   * @remarks `options` is required, `texture` and `object` must be passed or construction will throw.
+   *
+   * If no door configuration options are passed, the `"swing"` animation config will be loaded
+   */
+  constructor(options: DoorMesh.ConstructorOptions);
+
+  /**
+   * The possible rendering styles for a door mesh.
+   * @remarks Frozen.
+   */
+  static DOOR_STYLES: Readonly<DoorMesh.DoorStyles>;
+
+  /**
+   * The original position of the door in its resting CLOSED state.
+   * @internal
+   */
+  protected _closedPosition: DoorMesh.StateSnapshot;
+
+  /**
+   * The currently rendered position of the door.
+   * @internal
+   */
+  protected _animatedPosition: DoorMesh.StateSnapshot;
+
+  /**
+   * An amount of pixel padding surrounding the door texture.
+   */
+  texturePadding: number;
+
+  /**
+   * The identifier for this door animation.
+   */
+  get animationId(): string;
+
+  /**
+   * Configure and initialize the DoorMesh.
+   * This is called automatically upon construction, but may be called manually later to update the DoorMesh.
+   * @remarks Despite all properties of {@linkcode DoorMesh.AnimationConfiguration} being optional, `options`
+   * lacks a `={}` default, so you must pass at least an empty object
+   */
+  initialize(animation: DoorMesh.AnimationConfiguration): void;
+
+  /**
+   * Animate the door to its current rendered state.
+   * @param open - Is the door now open or closed? (default: {@linkcode Wall.isOpen | this.object.isOpen})
+   */
+  animate(open?: boolean): Promise<void>;
+
+  /**
+   * Configure the `"swing"` animation.
+   * @remarks A valid {@linkcode CONFIG.Wall.DoorAnimationFunction}
+   */
+  static animateSwing(this: DoorMesh, open: boolean): CanvasAnimation.Attribute[];
+
+  /**
+   * Configure the `"ascend"` animation.
+   * @remarks A valid {@linkcode CONFIG.Wall.DoorAnimationFunction}
+   */
+  static animateAscend(this: DoorMesh, open: boolean): CanvasAnimation.Attribute[];
+
+  /**
+   * Special initialization needed for descending door types.
+   * @remarks A valid {@linkcode CONFIG.Wall.DoorAnimationHook}
+   */
+  static initializeDescend(this: DoorMesh, open: boolean): void;
+
+  /**
+   * When closing a descending door, shift its elevation to the foreground before animation.
+   * @remarks A valid {@linkcode CONFIG.Wall.DoorAnimationHook}
+   */
+  static preAnimateDescend(this: DoorMesh, open: boolean): Promise<void>;
+
+  /**
+   * Configure the `"descend"` animation.
+   * @remarks A valid {@linkcode CONFIG.Wall.DoorAnimationFunction}
+   */
+  static animateDescend(this: DoorMesh, open: boolean): CanvasAnimation.Attribute[];
+
+  /**
+   * When opening a descending door, shift its elevation to the background after animation.
+   * @remarks A valid {@linkcode CONFIG.Wall.DoorAnimationHook}
+   */
+  static postAnimateDescend(this: DoorMesh, open: boolean): Promise<void>;
+
+  /**
+   * Configure the `"slide"` animation.
+   * @remarks A valid {@linkcode CONFIG.Wall.DoorAnimationFunction}
+   */
+  static animateSlide(this: DoorMesh, open: boolean): CanvasAnimation.Attribute[];
+
+  #DoorMesh: true;
+}
 
 declare namespace DoorMesh {
   interface Any extends AnyDoorMesh {}
   interface AnyConstructor extends Identity<typeof AnyDoorMesh> {}
+
+  /**
+   * @remarks Foundry types {@linkcode AnimationConfiguration.style | style} as required at construction, but it gets passed
+   * to `##configure` via {@linkcode DoorMesh.initialize | #initialize}, where it has a default applied
+   */
+  interface ConstructorOptions
+    extends Omit<PrimarySpriteMesh.ConstructorOptions, "object" | "texture">,
+      AnimationConfiguration {
+    /**
+     * Texture passed to the SpriteMesh.
+     * @remarks Required for {@linkcode DoorMesh}, as the constructor calls `##configure` which calls `##getClosedPosition`
+     * which assumes a valid {@linkcode DoorMesh.texture | this.texture}
+     */
+    texture: PIXI.Texture;
+
+    /**
+     * @remarks This is technically inherited from {@linkcode PrimarySpriteMesh.ConstructorOptions.object}, which is much wider,
+     * but by usage this class requires {@linkcode Wall}s. Required because `##configure` assumes it can call its
+     * {@linkcode Wall.isOpen | isOpen} method.
+     *
+     * See {@linkcode foundry.canvas.primary.PrimaryCanvasObjectMixin.AnyMixed.object | PrimaryCanvasObject#object}
+     */
+    object: Wall.Implementation;
+  }
+
+  type ConfiguredAnimationType = ConcreteKeys<typeof CONFIG.Wall.animationTypes>;
+
+  /** @internal */
+  type _AnimationConfiguration = InexactPartial<{
+    /**
+     * @defaultValue `1`
+     * @remarks
+     * - For `swing` and `swivel` this is rotation direction: `1` for clockwise, `-1` counter-clockwise (pivoting from the
+     * {@linkcode Wall.edge.a | a} endpoint of the edge for `swing`, and the midpoint for `swivel`)
+     * - For `slide`, `1` slides towards `a` , `-1` away
+     * - For `ascend` and `descend` it has no effect
+     */
+    direction: -1 | 1;
+
+    /**
+     * @defaultValue `false`
+     * @remarks Is this mesh part of a double door pair?
+     */
+    double: boolean;
+
+    /**
+     * @defaultValue `500`
+     * @remarks Animation time in milliseconds
+     *
+     * The claimed default is the value in the configs for `swivel`, `slide`, and `swing` in {@linkcode CONFIG.Wall.animationTypes},
+     * but the default of the {@linkcode WallDocument.AnimationData.duration | WallDocument#animation#duration} field is `750`
+     */
+    duration: number;
+
+    /**
+     * @defaultValue `false`
+     * @remarks Flip the texture along the axis of the door?
+     */
+    flip: boolean;
+
+    /**
+     * A multiplier between 0 and 2 that modifies how much the door moves when animating.
+     * For example for a swinging door, more strength produces a wider open angle. For a
+     * sliding door, more strength causes the door to slide farther.
+     * @defaultValue `1.0`
+     * @remarks
+     * - For `swing` and `swivel` it's a linear scale from 0 (no movement) to 2 (180 degrees)
+     * - For `slide` it's door-lengths shifted
+     * - For `ascend` and `descend` it affects how much the texture grows/shrinks. For `ascend` there's also code in place that implies it should
+     * affect the texture `alpha` (down to a minimum of `0.6` at strength `2.0`), but it's non-functional as of 13.346: {@link https://github.com/foundryvtt/foundryvtt/issues/13157}
+     */
+    strength: number;
+
+    /**
+     * @defaultValue `"swing"`
+     * @remarks Will also use `"swing"` as fallback if an invalid value is passed at runtime; {@linkcode WallDocument.AnimationData.type | Wall#animation#type}
+     * is not constrained by `choices`, so it will persist currently-invalid `type`s until updated
+     */
+    type: ConfiguredAnimationType;
+
+    /** @remarks Default depends on the value of `double`; `"doubleL"` if truthy, `"single"` otherwise */
+    style: DoorStyle;
+  }>;
+
+  /**
+   * @remarks The Foundry typedef has `config` and `style` as required properties, but that is for the type of `DoorMesh##animation`,
+   * after the object's passed through `##configure` and had defaults applied. Since there's no public access to that property, this
+   * interface is typed for input, with everything optional.
+   *
+   * `config` always gets set to {@linkcode CONFIG.Wall.animationTypes | CONFIG.Wall.animationTypes[type]}, regardless of input, so it
+   * is not included here.
+   *
+   * See {@linkcode WallDocument.AnimationData}
+   */
+  interface AnimationConfiguration extends _AnimationConfiguration {}
+
+  interface DoorStyles {
+    SINGLE: "single";
+    DOUBLE_LEFT: "doubleL";
+    DOUBLE_RIGHT: "doubleR";
+  }
+
+  type DoorStyle = ValueOf<DoorStyles>;
+
+  interface StateSnapshot {
+    x: number;
+    y: number;
+    elevation: number;
+    sort: number;
+    rotation: number;
+    scaleX: number;
+    scaleY: number;
+    tint: number;
+  }
 }
 
 export default DoorMesh;

package/src/foundry/client/canvas/containers/elements/grid-highlight.d.mts

@@ -3,13 +3,13 @@ import type { Identity } from "#utils";
 /**
  * A special Graphics class which handles Grid layer highlighting
  */
-declare class GridHighlight extends PIXI.Graphics {
-  constructor(name: string, ...args: ConstructorParameters<typeof PIXI.Graphics>);
+declare class GridHighlight extends PIXI.smooth.SmoothGraphics {
+  constructor(name: string, ...args: ConstructorParameters<typeof PIXI.smooth.SmoothGraphics>);
 
   /**
    * Track the Grid Highlight name
    */
-  name: string;
+  override name: string;
 
   /**
    * Track distinct positions which have already been highlighted

package/src/foundry/client/canvas/containers/elements/grid-mesh.d.mts

@@ -8,9 +8,9 @@ import { QuadMesh } from "#client/canvas/containers/_module.mjs";
 declare class GridMesh extends QuadMesh {
   /**
    * The grid mesh constructor.
-   * @param shaderClass - The shader class
+   * @param shaderClass - The shader class (default: {@linkcode GridShader})
    */
-  constructor(shaderClass: GridShader.AnyConstructor);
+  constructor(shaderClass?: GridShader.AnyConstructor);
 
   /**
    * The data of this mesh.
@@ -52,9 +52,9 @@ declare namespace GridMesh {
   interface MeshData {
     /**
      * The type of the grid (see {@linkcode CONST.GRID_TYPES})
-     * @defaultValue `CONST.GRID_TYPES.GRIDLESS`
+     * @defaultValue {@linkcode CONST.GRID_TYPES.GRIDLESS}
      */
-    type: foundry.CONST.GRID_TYPES;
+    type: CONST.GRID_TYPES;
 
     /**
      * The width of the grid in pixels

package/src/foundry/client/canvas/containers/elements/particles/leaves.d.mts

@@ -6,9 +6,10 @@ import { ParticleEffect } from "#client/canvas/containers/_module.mjs";
  */
 declare class AutumnLeavesWeatherEffect extends ParticleEffect {
   /**
-   * @remarks `options` is completely unused in this subclass, as it gets passed to `#getParticleEmitters`, which, unlike super's method, takes no arguments
+   * @remarks `options` is completely unused in this subclass, as it gets passed to {@linkcode AutumnLeavesWeatherEffect.getParticleEmitters | #getParticleEmitters},
+   * which, unlike {@linkcode ParticleEffect | super}'s method, takes no arguments
    */
-  constructor(options?: PIXI.particles.EmitterConfigV3 | null);
+  constructor(options?: PIXI.particles.EmitterConfigV3);
 
   /**
    * @defaultValue `"WEATHER.AutumnLeaves"`
@@ -19,13 +20,13 @@ declare class AutumnLeavesWeatherEffect extends ParticleEffect {
 
   /**
    * Configuration for the particle emitter for falling leaves
-   * @remarks Not a complete EmitterConfigV3; the `frequency` and `pos` required keys are omitted. `frequency` is set
-   * up in `#getParticleEmitters`, but `pos` is not; it is erroneously marked as required in the interface,
-   * see https://github.com/pixijs-userland/particle-emitter/issues/219
+   * @remarks Not a complete {@linkcode PIXI.particles.EmitterConfigV3}; the `frequency` and `pos` required keys are omitted. `frequency` is set
+   * up in {@linkcode AutumnLeavesWeatherEffect.getParticleEmitters | #getParticleEmitters}, but `pos` is not; it is erroneously marked as required
+   * in the interface, see https://github.com/pixijs-userland/particle-emitter/issues/219
    */
   static LEAF_CONFIG: AutumnLeavesWeatherEffect.LeafConfig;
 
-  /** @remarks This does not take a config paramater, unlike its parent class; uses `static LEAF_CONFIG` on this class instead */
+  /** @remarks This does not take a config parameter, unlike its parent class; uses {@linkcode AutumnLeavesWeatherEffect.LEAF_CONFIG} instead */
   override getParticleEmitters(): PIXI.particles.Emitter[];
 }
 

package/src/foundry/client/canvas/containers/elements/particles/particle-effect.d.mts

@@ -6,8 +6,7 @@ import { FullCanvasObjectMixin } from "#client/canvas/containers/_module.mjs";
  */
 declare class ParticleEffect extends FullCanvasObjectMixin(PIXI.Container) {
   /**
-   * @param options - Options passed to the getParticleEmitters method which can be used to customize values of the emitter configuration.
-   *                  (default: `{}`)
+   * @param options - Options passed to the getParticleEmitters method which can be used to customize values of the emitter configuration. (default: `{}`)
    * @remarks Despite being an `={}` parameter, construction will throw if it is passed (or defaults to via omission) an empty object
    */
   constructor(options: PIXI.particles.EmitterConfigV3);
@@ -15,7 +14,7 @@ declare class ParticleEffect extends FullCanvasObjectMixin(PIXI.Container) {
   emitters: PIXI.particles.Emitter[];
 
   /**
-   * Create an emitter instance which automatically updates using the shared PIXI.Ticker
+   * Create an emitter instance which automatically updates using the shared {@linkcode PIXI.Ticker}
    * @param config - The emitter configuration
    * @returns The created Emitter instance
    */
@@ -26,9 +25,9 @@ declare class ParticleEffect extends FullCanvasObjectMixin(PIXI.Container) {
    * This base class creates a single emitter using the explicitly provided configuration.
    * Subclasses can override this method for more advanced configurations.
    * @param options - Options provided to the ParticleEffect constructor which can be used to customize
-   *                  configuration values for created emitters. (default: `{}`)
-   * @throws If `options` is passed as (or defaults to via omission) an empty object
+   * configuration values for created emitters. (default: `{}`)
    * @remarks Despite its name, this method only takes a single config object and only returns a single-element array.
+   * @throws If `options` is passed as (or defaults to via omission) an empty object
    */
   getParticleEmitters(options: PIXI.particles.EmitterConfigV3): PIXI.particles.Emitter[];
 

package/src/foundry/client/canvas/containers/elements/point-source-mesh.d.mts

@@ -2,7 +2,7 @@ import type { Identity } from "#utils";
 import type { AdaptiveLightingShader } from "#client/canvas/rendering/shaders/_module.d.mts";
 
 /**
- * Extension of a PIXI.Mesh, with the capabilities to provide a snapshot of the framebuffer.
+ * Extension of a PIXI.Mesh for PointEffectSources.
  * @remarks Foundry only uses this with `AdaptiveLightingShader` subclasses, thus the type param default
  */
 declare class PointSourceMesh<Shader extends PIXI.Shader = AdaptiveLightingShader> extends PIXI.Mesh<Shader> {
@@ -12,40 +12,36 @@ declare class PointSourceMesh<Shader extends PIXI.Shader = AdaptiveLightingShade
   constructor(geometry: PIXI.Geometry, shader: Shader, state?: PIXI.State, drawMode?: PIXI.DRAW_MODES);
 
   /**
-   * To store the previous blend mode of the last renderer PointSourceMesh.
-   * @privateRemarks Despite being `protected`, this is accessed externally in `CanvasIlluminationEffects#render`
+   * @deprecated Removed without replacement in v13 (this warning will be removed in v14)
    */
-  protected static _priorBlendMode: PIXI.BLEND_MODES | undefined;
+  protected static _priorBlendMode: never;
 
-  /**
-   * The current texture used by the mesh.
-   * @privateRemarks Despite being `protected`, this is accessed externally in `CanvasIlluminationEffects#render`
-   */
-  protected static _currentTexture: PIXI.Texture | undefined;
+  protected static _currentTexture: never;
 
   /**
-   * The transform world ID of the bounds.
-   * @defaultValue `-1`
+   * @deprecated Made hard private in v13 (this warning will be removed in v14)
    */
-  _worldID: number;
+  _worldID: never;
 
   /**
-   * The geometry update ID of the bounds.
-   * @defaultValue `-1`
+   * @deprecated Made hard private in v13 (this warning will be removed in v14)
    */
-  _updateID: number;
+  _updateID: never;
 
   override get geometry(): PIXI.Geometry;
 
-  set geometry(value: PIXI.Geometry);
+  override set geometry(value: PIXI.Geometry);
 
-  /** @throws You can't add children to a PointSourceMesh. */
+  /** @throws You can't add children to a {@linkcode PointSourceMesh}. */
   override addChild(): never;
 
-  /** @throws You can't add children to a PointSourceMesh. */
+  /** @throws You can't add children to a {@linkcode PointSourceMesh}. */
   override addChildAt(): never;
 
-  protected override _render(renderer: PIXI.Renderer): void;
+  /**
+   * @deprecated Removed without replacement in v13 (this warning will be removed in v14)
+   */
+  protected override _render(renderer: never): never;
 
   override calculateBounds(): void;
 
@@ -53,12 +49,11 @@ declare class PointSourceMesh<Shader extends PIXI.Shader = AdaptiveLightingShade
 
   /** The local bounds need to be drawn from the underlying geometry. */
   override getLocalBounds(
-    /**
-     * @defaultValue `new PIXI.Rectangle()`
-     * @remarks Default provided by `??=` in function body. `null` would be allowable here but breaks inheritance
-     */
+    /** @defaultValue `new PIXI.Rectangle()` */
     rect?: PIXI.Rectangle,
   ): PIXI.Rectangle;
+
+  #PointSourceMesh: true;
 }
 
 declare namespace PointSourceMesh {

package/src/foundry/client/canvas/containers/elements/precise-text.d.mts

@@ -1,4 +1,4 @@
-import type { Identity, InexactPartial, NullishProps } from "#utils";
+import type { Identity, InexactPartial } from "#utils";
 
 /**
  * An extension of the default PIXI.Text object which forces double resolution.
@@ -15,7 +15,7 @@ declare class PreciseText extends PIXI.Text {
 
   /**
    * Prepare a TextStyle object which merges the canvas defaults with user-provided options
-   * @param anchor  - A text anchor point from CONST.TEXT_ANCHOR_POINTS
+   * @param anchor  - A text anchor point from {@linkcode CONST.TEXT_ANCHOR_POINTS}
    * @param options - Additional options merged with the default TextStyle
    * @returns The prepared TextStyle
    */
@@ -27,16 +27,15 @@ declare namespace PreciseText {
   interface AnyConstructor extends Identity<typeof AnyPreciseText> {}
 
   /** @internal */
-  type _GetTextStyleOptions = NullishProps<{
+  type _GetTextStyleOptions = InexactPartial<{
     /**
-     * A text anchor point from CONST.TEXT_ANCHOR_POINTS
-     * @remarks Only checked againt `.RIGHT` and `.LEFT`, and only if an `align` key is omitted
+     * A text anchor point from {@linkcode CONST.TEXT_ANCHOR_POINTS}
+     * @remarks Only checked against `.RIGHT` and `.LEFT`, and only if an `align` key is omitted
      */
-    anchor: foundry.CONST.TEXT_ANCHOR_POINTS;
-  }> &
-    // Can't be NullishProps because keys are only checked for `!== undefined` in PIXI
-    InexactPartial<PIXI.ITextStyle>;
-  interface GetTextStyleOptions extends _GetTextStyleOptions {}
+    anchor: CONST.TEXT_ANCHOR_POINTS;
+  }>;
+
+  interface GetTextStyleOptions extends _GetTextStyleOptions, InexactPartial<PIXI.ITextStyle> {}
 }
 
 export default PreciseText;

package/src/foundry/client/canvas/containers/elements/quad-mesh.d.mts

@@ -4,7 +4,6 @@ import type { AbstractBaseShader } from "#client/canvas/rendering/shaders/_modul
 /**
  * A basic rectangular mesh with a shader only. Does not natively handle textures (but a bound shader can).
  * Bounds calculations are simplified and the geometry does not need to handle texture coords.
- * @privateRemarks Ideally the `shaderClass` passed to the constructor and `get shader()` could be synced up, but `setShaderClass` removes that option
  */
 declare class QuadMesh extends PIXI.Container {
   /**
@@ -26,7 +25,7 @@ declare class QuadMesh extends PIXI.Container {
 
   /**
    * Initialize shader based on the shader class type.
-   * @param shaderClass - Shader class used. Must inherit from AbstractBaseShader.
+   * @param shaderClass - Shader class used. Must inherit from {@linkcode AbstractBaseShader}.
    */
   setShaderClass(shaderClass: AbstractBaseShader.AnyConstructor): void;
 

package/src/foundry/client/canvas/containers/elements/resize-handle.d.mts

@@ -1,9 +1,13 @@
-import type { Identity, NullishProps } from "#utils";
+import type { Identity, InexactPartial } from "#utils";
 import type { Canvas } from "#client/canvas/_module.d.mts";
 
-declare class ResizeHandle extends PIXI.Graphics {
+/**
+ * A class based on PIXI.Graphics, that allows to create a resize handle in the desired area.
+ */
+declare class ResizeHandle extends PIXI.smooth.SmoothGraphics {
   /**
-   * @param handlers - (default: `{}`)
+   * @param offset   - A two-element array [xFactor, yFactor] which defines the normalized position of this handle relative to the bounding box.
+   * @param handlers - An object of optional handler functions.
    */
   constructor(offset: ResizeHandle.Offsets, handlers?: ResizeHandle.Handlers);
 
@@ -17,18 +21,30 @@ declare class ResizeHandle extends PIXI.Graphics {
    */
   active: boolean;
 
+  /**
+   * Refresh the position and hit area of this handle based on the provided bounding box.
+   * @param bounds - The bounding box in which this handle operates.
+   */
   refresh(bounds: Canvas.Rectangle): void;
 
   /**
-   * @param aspectRatio - (default: `null`)
+   * Compute updated dimensions for an object being resized, respecting optional constraints.
+   * @param current     - The current geometric state of the object
+   * @param origin      - The original position and dimensions used for reference
+   * @param destination - The mouse (or pointer) destination coordinates.
+   * @param options     - Additional options.
+   * @returns An object containing the adjusted `{x, y, width, height}`.
    */
   updateDimensions(
     current: Canvas.Rectangle,
     origin: Canvas.Rectangle,
-    destination: Canvas.Rectangle,
+    destination: ResizeHandle.Destination,
     options?: ResizeHandle.UpdateDimensionsOptions,
   ): Canvas.Rectangle;
 
+  /**
+   * Activate listeners for pointer events, enabling hover and mouse-down behavior on the resize handle.
+   */
   activateListeners(): void;
 
   /**
@@ -44,7 +60,7 @@ declare class ResizeHandle extends PIXI.Graphics {
   protected _onHoverOut(event: PIXI.FederatedEvent<PointerEvent>): void;
 
   /**
-   * When we start a drag event - create a preview copy of the Tile for re-positioning
+   * When we start a drag event - create a preview copy of the `Tile` for re-positioning
    * @param event - The mousedown event
    */
   protected _onMouseDown(event: PIXI.FederatedEvent<PointerEvent>): void;
@@ -57,20 +73,30 @@ declare namespace ResizeHandle {
   type Offsets = [widthOffset: number, heightOffset: number];
 
   /** @internal */
-  type _Handlers = NullishProps<{
-    canDrag: () => boolean | null | void;
+  type _Handlers = InexactPartial<{
+    /** A function determining if this handle can initiate a drag. */
+    canDrag: () => boolean;
   }>;
 
   interface Handlers extends _Handlers {}
 
+  /** @privateRemarks {@linkcode ResizeHandle.updateDimensions | #updateDimensions} is too cool to just use a Point */
+  interface Destination {
+    /** The x-coordinate where the pointer was released. */
+    x: number;
+
+    /** The y-coordinate where the pointer was released. */
+    y: number;
+  }
+
   /** @internal */
-  type _UpdateDimensionsOptions = NullishProps<{
+  type _UpdateDimensionsOptions = InexactPartial<{
     /**
-     * Constrain the aspect ratio
+     * If provided, a numeric aspect ratio to maintain (width/height).
      * @defaultValue `null`
      * @remarks If truthy, will enforce the passed ratio, landscape if `width >= height`, portrait otherwise
      */
-    aspectRatio: number;
+    aspectRatio: number | null;
   }>;
 
   interface UpdateDimensionsOptions extends _UpdateDimensionsOptions {}