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

package/src/foundry/client/pixi/placeables/primary-canvas-objects/primary-graphics.d.mts

@@ -1,4 +1,4 @@
-import type { InexactPartial } from "../../../../../types/utils.d.mts";
+import type { NullishProps } from "fvtt-types/utils";
 
 declare global {
   /**
@@ -9,16 +9,10 @@ declare global {
      * @param options - A config object
      */
     constructor(
-      options?: InexactPartial<{
-        /** A geometry passed to the graphics. */
-        geometry: PIXI.GraphicsGeometry;
-
-        /** The name of the PCO. */
-        name: string;
-
-        /** Any object that owns this PCO. */
-        object: PlaceableObject;
-      }>,
+      /**
+       * @remarks Passing `null`, or an object where the `geometry` property is either missing or nullish, will result in an effective default of `new PIXI.GraphicsGeometry()`
+       */
+      options?: PIXI.GraphicsGeometry | PrimaryGraphics.ConstructorOptions | null,
     );
 
     override _calculateCanvasBounds(): void;
@@ -27,4 +21,40 @@ declare global {
 
     override containsCanvasPoint(point: PIXI.IPointData): boolean;
   }
+
+  namespace PrimaryGraphics {
+    interface Any extends AnyPrimaryGraphics {}
+    type AnyConstructor = typeof AnyPrimaryGraphics;
+
+    /** @internal */
+    type _ConstructorOptions = NullishProps<{
+      /**
+       * A geometry passed to the graphics.
+       * @defaultValue `new PIXI.GraphicsGeometry()`
+       * @remarks Default via calling `super(geometry)` with a falsey value
+       */
+      geometry: PIXI.GraphicsGeometry;
+
+      /**
+       * The name of the PCO.
+       * @defaultValue `null`
+       * @remarks Default via `?? null` in function body
+       * */
+      name: string;
+
+      /**
+       * Any object that owns this PCO.
+       * @defaultValue `null`
+       * @remarks Default via `?? null` in function body
+       * @privateRemarks Foundry types as `*`, but the only place they use this class is for `Drawing`s
+       */
+      object: PlaceableObject.Any;
+    }>;
+
+    interface ConstructorOptions extends _ConstructorOptions {}
+  }
+}
+
+declare abstract class AnyPrimaryGraphics extends PrimaryGraphics {
+  constructor(arg0: never, ...args: never[]);
 }

package/src/foundry/client/pixi/placeables/primary-canvas-objects/primary-occludable-object.d.mts

@@ -1,4 +1,4 @@
-import type { InexactPartial, Mixin } from "../../../../../types/utils.d.mts";
+import type { FixedInstanceType, Mixin, NullishProps } from "fvtt-types/utils";
 
 declare class PrimaryOccludableObject {
   /** @privateRemarks All mixin classses should accept anything for its constructor. */
@@ -20,7 +20,7 @@ declare class PrimaryOccludableObject {
    * The occlusion mode of this occludable object.
    * @defaultValue `CONST.OCCLUSION_MODES.NONE`
    */
-  occlusionMode: typeof CONST.OCCLUSION_MODES;
+  occlusionMode: CONST.OCCLUSION_MODES;
 
   /**
    * The unoccluded alpha of this object.
@@ -44,18 +44,40 @@ declare class PrimaryOccludableObject {
 
   /**
    * The amount of rendered FADE, RADIAL, and VISION occlusion.
+   * @defaultValue
+   * ```js
+   * {
+   *   fade: 0.0,
+   *   radial: 0.0,
+   *   vision: 0.0
+   * }
+   * ```
+   * @privateRemarks Foundry marked `@internal`
    */
-  protected _occlusionState: PrimaryOccludableObjectMixin.OcclusionState;
+  _occlusionState: PrimaryOccludableObjectMixin.OcclusionState;
 
   /**
    * The state of hover-fading.
-   */
-  protected _hoverFadeState: PrimaryOccludableObjectMixin.HoverFadeState;
+   * @defaultValue
+   * ```js
+   * {
+   *   hovered: false,
+   *   hoveredTime: 0,
+   *   faded: false,
+   *   fading: false,
+   *   fadingTime: 0,
+   *   occlusion: 0.0
+   * }
+   * ```
+   * @privateRemarks Foundry marked `@internal`
+   */
+  _hoverFadeState: PrimaryOccludableObjectMixin.HoverFadeState;
 
   /**
    * Get the blocking option bitmask value.
+   * @privateRemarks Foundry marked `@internal`
    */
-  protected get _restrictionState(): number;
+  get _restrictionState(): number;
 
   /**
    * Is this object blocking light?
@@ -81,12 +103,13 @@ declare class PrimaryOccludableObject {
    * change PCO appearance.
    * Uses a 50ms debounce threshold.
    * Objects which are in the hovered state remain occluded until their hovered state ends.
+   * @remarks Actually the return value of an arrow function passed to `foundry.utils.debounce` with a timeout of 50ms
    */
-  debounceSetOcclusion: (occluded: boolean) => void;
+  debounceSetOcclusion: (occluded: boolean) => boolean;
 
   updateCanvasTransform(): void;
 
-  _shouldRenderDepth: boolean;
+  _shouldRenderDepth(): boolean;
 
   /**
    * Test whether a specific Token occludes this PCO.
@@ -95,37 +118,55 @@ declare class PrimaryOccludableObject {
    * @param options - Additional options that affect testing
    * @returns Is the Token occluded by the PCO?
    */
-  testOcclusion(
-    token: Token,
-    options?: InexactPartial<{
-      /** Test corners of the hit-box in addition to the token center? */
-      corners: boolean;
-    }>,
-  ): boolean;
+  testOcclusion(token: Token.ConfiguredInstance, options?: PrimaryOccludableObjectMixin.TestOcclusionOptions): boolean;
 
   /**
    * @deprecated since v12, will be removed in v14
+   * @remarks "`#roof` is deprecated in favor of more granular options: `#restrictsLight` and `#restrictsWeather`"
    */
   get roof(): boolean;
 
+  /**
+   * @deprecated since v12, until v14
+   * @remarks "#roof is deprecated in favor of more granular options: #restrictsLight and #restrictsWeather"
+   */
+  set roof(enabled);
+
   /**
    * @deprecated since v12, will be removed in v14
+   * @remarks "#containsPixel is deprecated. Use #containsCanvasPoint instead."
    */
-  containsPixel(x: number, y: number, alphaThreshold: number): boolean;
+  containsPixel(x: number, y: number, alphaThreshold?: number): boolean;
 
   /**
    * @deprecated since v11, will be removed in v13
+   * @remarks "PrimaryCanvasObject#renderOcclusion is deprecated in favor of PrimaryCanvasObject#renderDepth"
    */
   renderOcclusion(renderer: PIXI.Renderer): void;
 }
 
 declare global {
-  function PrimaryOccludableObjectMixin<BaseClass extends PIXI.DisplayObject.AnyConstructor>(
+  function PrimaryOccludableObjectMixin<BaseClass extends PrimaryOccludableObjectMixin.BaseClass>(
     DisplayObject: BaseClass,
   ): Mixin<typeof PrimaryOccludableObject, ReturnType<typeof PrimaryCanvasObjectMixin<BaseClass>>>;
 
   namespace PrimaryOccludableObjectMixin {
-    type MixinClass = typeof PrimaryOccludableObject;
+    type AnyMixedConstructor = ReturnType<typeof PrimaryOccludableObjectMixin<BaseClass>>;
+    interface AnyMixed extends FixedInstanceType<AnyMixedConstructor> {}
+
+    type BaseClass = PIXI.Container.AnyConstructor;
+
+    /** @internal */
+    type _TestOcclusionOptions = NullishProps<{
+      /**
+       * Test corners of the hit-box in addition to the token center?
+       * @defaultValue `0`
+       */
+      corners: boolean;
+    }>;
+
+    /** Additional options that affect testing */
+    interface TestOcclusionOptions extends _TestOcclusionOptions {}
 
     interface OcclusionState {
       /** The amount of FADE occlusion */

package/src/foundry/client/pixi/placeables/primary-canvas-objects/primary-sprite-mesh.d.mts

@@ -1,11 +1,4 @@
-import type { InexactPartial } from "../../../../../types/utils.d.mts";
-
-// TODO: Remove when #2570 is completed
-declare const PrimaryBaseSamplerShader: BaseSamplerShader;
-
-declare namespace PrimaryBaseSamplerShader {
-  type AnyConstructor = unknown;
-}
+import type { InexactPartial, NullishProps } from "fvtt-types/utils";
 
 declare global {
   /**
@@ -13,30 +6,31 @@ declare global {
    */
   class PrimarySpriteMesh extends PrimaryOccludableObjectMixin(SpriteMesh) {
     constructor(
-      options?:
-        | InexactPartial<{
-            /** Texture passed to the SpriteMesh. */
-            texture: PIXI.Texture;
-
-            /** The shader class used to render this sprite. */
-            shaderClass: PrimaryBaseSamplerShader.AnyConstructor;
-
-            /** The name of this sprite. */
-            name: string;
-          }>
-        | PIXI.Texture,
-      shaderClass?: PrimaryBaseSamplerShader.AnyConstructor,
+      /**
+       * The constructor options.
+       * @defaultValue `{}`
+       * @remarks Default is applied if `options` is `instanceof PIXI.Texture`, or neither that nor `instanceof Object`
+       */
+      options?: PrimarySpriteMesh.ConstructorOptions | PIXI.Texture | null,
+      /**
+       * The shader class used to render this sprite.
+       * @defaultValue `PrimaryBaseSamplerShader`
+       * @remarks If `options` is an object, `options.shaderClass` takes precedence. If omitted,
+       * or if `options` is a `PIXI.Texture`, default is provided by `??` in function body.
+       */
+      shaderClass?: PrimaryBaseSamplerShader.AnyConstructor | null,
     );
 
     /**
      * The texture alpha data.
      */
-    _textureAlphaData: TextureLoader.TextureAlphaData | null;
+    protected _textureAlphaData: TextureLoader.TextureAlphaData | null;
 
     /**
      * The texture alpha threshold used for point containment tests.
      * If set to a value larger than 0, the texture alpha data is
      * extracted from the texture at 25% resolution.
+     * @defaultValue `0`
      */
     textureAlphaThreshold: number;
 
@@ -67,21 +61,9 @@ declare global {
      * @param baseWidth  - The base width used for computations.
      * @param baseHeight - The base height used for computations.
      * @param options    - The options.
+     * @throws If either `baseWidth` or `baseHeight` are less than 0, or if `options.fit` is not a FitType
      */
-    resize(
-      baseWidth: number,
-      baseHeight: number,
-      options?: InexactPartial<{
-        /** The fit type. */
-        fit: "fill" | "cover" | "contain" | "width" | "height";
-
-        /** The scale on X axis. */
-        scaleX: number;
-
-        /** The scale on Y axis. */
-        scaleY: number;
-      }>,
-    ): void;
+    resize(baseWidth: number, baseHeight: number, options?: PrimarySpriteMesh.ResizeOptions): void;
 
     protected override _updateBatchData(): void;
 
@@ -92,7 +74,22 @@ declare global {
      * @param point                 - The point in canvas space
      * @param textureAlphaThreshold - The minimum texture alpha required for containment
      */
-    containsCanvasPoint(point: PIXI.IPointData, textureAlphaThreshold?: number): boolean;
+    containsCanvasPoint(
+      point: PIXI.IPointData,
+      /** @defaultValue `this.textureAlphaThreshold` */
+      textureAlphaThreshold?: number,
+    ): boolean;
+
+    /**
+     * Is the given point in world space contained in this object?
+     * @param point                 - The point in world space
+     * @param textureAlphaThreshold - The minimum texture alpha required for containment
+     */
+    containsPoint(
+      point: PIXI.IPointData,
+      /** @defaultValue `this.textureAlphaThreshold` */
+      textureAlphaThreshold?: number,
+    ): boolean;
 
     override renderDepthData(renderer: PIXI.Renderer): void;
 
@@ -105,7 +102,93 @@ declare global {
 
     /**
      * @deprecated since v12, will be removed in v14
+     * @remarks "#getPixelAlpha is deprecated without replacement."
      */
     getPixelAlpha(x: number, y: number): number;
+
+    /**
+     * @deprecated since v12, until v14
+     * @remarks "#_getAlphaBounds is deprecated without replacement."
+     */
+    _getAlphaBounds(): PIXI.Rectangle;
+
+    /**
+     * @deprecated since v12, until v14
+     * @remarks "#_getTextureCoordinate is deprecated without replacement."
+     */
+    _getTextureCoordinate(testX: number, testY: number): PIXI.IPointData;
   }
+
+  namespace PrimarySpriteMesh {
+    interface Any extends AnyPrimarySpriteMesh {}
+    type AnyConstructor = typeof AnyPrimarySpriteMesh;
+
+    type FitType = "fill" | "cover" | "contain" | "width" | "height";
+
+    /** @internal */
+    type _ConstructorOptions = NullishProps<{
+      /**
+       * Texture passed to the SpriteMesh.
+       * @defaultValue `null`
+       * @remarks Default ultimately provided by the `SpriteMesh` constructor
+       */
+      texture: PIXI.Texture;
+
+      /**
+       * The shader class used to render this sprite.
+       * @defaultValue `PrimaryBaseSamplerShader`
+       * @remarks Default provided by `??=` in function body
+       */
+      shaderClass: PrimaryBaseSamplerShader.AnyConstructor;
+
+      /**
+       * The name of this sprite.
+       * @defaultValue `null`
+       * @remarks Default provided by `?? null` in function body
+       */
+      name: string;
+
+      /**
+       * Any object that owns this PCO.
+       * @defaultValue `null`
+       * @remarks Default via `?? null` in function body
+       * @privateRemarks Foundry types as `*`, but the only things passed in practice are `Tile`s, `Token`s, and the `PrimaryCanvasGroup`
+       */
+      //TODO: (esheyw) Revisit the "any canvas group" type when groups are done
+      object: PlaceableObject.Any | CanvasGroupMixin.AnyMixed;
+    }>;
+
+    /** The constructor options */
+    interface ConstructorOptions extends _ConstructorOptions {}
+
+    /** @internal */
+    type _ResizeOptions = InexactPartial<{
+      /**
+       * The fit type.
+       * @defaultValue `"fill"`
+       * @remarks Can't be `null` because it only has a parameter default, and is then fed into a switch statement where the default is throw
+       * */
+      fit: FitType;
+
+      /**
+       * The scale on X axis.
+       * @defaultValue `1`
+       * @remarks Can't be `null` because it only has a parameter default and a width scale of 0 is, if not nonsensical, not to be done by accident.
+       */
+      scaleX: number;
+
+      /**
+       * The scale on Y axis.
+       * @defaultValue `1`
+       * @remarks Can't be `null` because it only has a parameter default and a height scale of 0 is, if not nonsensical, not to be done by accident.
+       */
+      scaleY: number;
+    }>;
+
+    interface ResizeOptions extends _ResizeOptions {}
+  }
+}
+
+declare abstract class AnyPrimarySpriteMesh extends PrimarySpriteMesh {
+  constructor(arg0: never, ...args: never[]);
 }

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

@@ -0,0 +1,177 @@
+import type { ConfiguredObjectClassOrDefault } from "../../config.d.mts";
+import type { Brand, FixedInstanceType } from "fvtt-types/utils";
+import type RegionShape from "../../../client-esm/canvas/regions/shape.d.mts";
+import type RegionPolygonTree from "../../../client-esm/canvas/regions/polygon-tree.d.mts";
+import type RegionGeometry from "../../../client-esm/canvas/regions/geometry.d.mts";
+import type { Point } from "../../../common/_types.d.mts";
+
+declare global {
+  namespace Region {
+    type ConfiguredClass = ConfiguredObjectClassOrDefault<typeof Region>;
+    type ConfiguredInstance = FixedInstanceType<ConfiguredClass>;
+
+    interface RenderFlags extends PlaceableObject.RenderFlags {}
+
+    interface RegionMovementWaypoint {
+      /** The x-coordinates in pixels (integer) */
+      x: number;
+
+      /** The y-coordinates in pixels (integer) */
+      y: number;
+
+      /** The elevation in grid units. */
+      elevation: number;
+    }
+
+    interface RegionMovementSegment {
+      /** The type of htis segment (see {@link Region.MovementSegmentTypes}) */
+      type: number;
+
+      /** The waypoint that this segment starts from */
+      from: RegionMovementWaypoint;
+
+      /** The waypoint that this segment goes to */
+      to: RegionMovementWaypoint;
+    }
+
+    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;
+      }> {}
+  }
+
+  class Region extends PlaceableObject<RegionDocument.ConfiguredInstance> {
+    #region: true;
+
+    constructor(document: RegionDocument.ConfiguredInstance);
+
+    static override embeddedName: "Region";
+
+    static override RENDER_FLAGS: {
+      /** @defaultValue `{ propagate: ["refresh"] }` */
+      redraw: RenderFlag<Region.RenderFlags>;
+
+      /** @defaultValue `{ propagate: ["refreshState", "refreshBorder"], alias: true }` */
+      refresh: RenderFlag<Region.RenderFlags>;
+
+      /** @defaultValue `{}` */
+      refreshState: RenderFlag<Region.RenderFlags>;
+
+      /** @defaultValue `{}` */
+      refreshBorder: RenderFlag<Region.RenderFlags>;
+    };
+
+    static CLIPPER_SCALING_FACTOR: number;
+    static MOVEMENT_SEGMENT_TYPES: Region.MOVEMENT_SEGMENT_TYPES;
+
+    get shapes(): ReadonlyArray<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. */
+    get polygons(): ReadonlyArray<PIXI.Polygon>;
+
+    /** The polygon tree of this Region. */
+    get polygonTree(): RegionPolygonTree;
+
+    /** The Clipper paths of this Region. */
+    get clipperPaths(): ReadonlyArray<ReadonlyArray<ClipperLib.IntPoint>>;
+
+    /** The triangulation of this Region */
+    get triangulation(): ReadonlyArray<{ vertices: Float32Array; indices: Uint16Array | Uint32Array }>;
+
+    /** 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?: Canvas.Point): never;
+
+    protected override _draw(options?: Record<string, unknown>): Promise<void>;
+
+    protected override _applyRenderFlags(flags: PlaceableObject.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.ConfiguredInstance, event?: PIXI.FederatedEvent | null): boolean;
+
+    protected override _canHUD(user: User.ConfiguredInstance, event?: PIXI.FederatedEvent | null): boolean;
+
+    protected override _onControl(options?: PlaceableObject.ControlOptions | null): void;
+
+    protected override _onRelease(options?: PlaceableObject.ReleaseOptions | null): void;
+
+    /** @remarks options cannot accept null because defaults are provided with `options={}` in the parameters  */
+    protected override _onHoverIn(event: PIXI.FederatedEvent, options?: PlaceableObject.HoverInOptions): false | void;
+
+    protected override _onHoverOut(event: PIXI.FederatedEvent): boolean | 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 elevation cannot be null because it is explicitly checked against undefined (===) in function body.
+     */
+    testPoint(point: 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.
+     * @returns                             - The movement split into its segments.
+     */
+    segmentizeMovement(
+      waypoints: Region.RegionMovementWaypoint[],
+      samples: Point[],
+      options?: {
+        /**
+         * Is it teleportation?
+         * @remarks options cannot accept null because defaults are provided with `options={}` in the parameters.
+         * @defaultValue `false`
+         */
+        teleport?: boolean | undefined;
+      },
+    ): Region.RegionMovementSegment[];
+
+    /**
+     * @privateRemarks _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.
+     */
+  }
+}

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

@@ -1,10 +1,11 @@
 import type Sound from "../../../client-esm/audio/sound.d.mts";
 import type { ConfiguredObjectClassOrDefault } from "../../config.d.mts";
+import type { FixedInstanceType } from "fvtt-types/utils";
 
 declare global {
   namespace AmbientSound {
     type ConfiguredClass = ConfiguredObjectClassOrDefault<typeof AmbientSound>;
-    type ConfiguredInstance = InstanceType<ConfiguredClass>;
+    type ConfiguredInstance = FixedInstanceType<ConfiguredClass>;
 
     interface RenderFlags extends PlaceableObject.RenderFlags {
       refreshField: boolean;
@@ -57,19 +58,19 @@ declare global {
 
     static override RENDER_FLAGS: {
       /** @defaultValue `{ propagate: ["refresh"] }` */
-      redraw: RenderFlag<Partial<AmbientSound.RenderFlags>>;
+      redraw: RenderFlag<AmbientSound.RenderFlags>;
 
       /** @defaultValue `{ propagate: ["refreshField"], alias: true }` */
-      refresh: RenderFlag<Partial<AmbientSound.RenderFlags>>;
+      refresh: RenderFlag<AmbientSound.RenderFlags>;
 
       /** @defaultValue `{ propagate: ["refreshPosition", "refreshState"] }` */
-      refreshField: RenderFlag<Partial<AmbientSound.RenderFlags>>;
+      refreshField: RenderFlag<AmbientSound.RenderFlags>;
 
       /** @defaultValue `{}` */
-      refreshPosition: RenderFlag<Partial<AmbientSound.RenderFlags>>;
+      refreshPosition: RenderFlag<AmbientSound.RenderFlags>;
 
       /** @defaultValue `{}` */
-      refreshState: RenderFlag<Partial<AmbientSound.RenderFlags>>;
+      refreshState: RenderFlag<AmbientSound.RenderFlags>;
     };
 
     /**

package/src/foundry/client/pixi/placeables/template.d.mts

@@ -1,10 +1,10 @@
-import type { RequiredProps } from "../../../../types/utils.d.mts";
+import type { RequiredProps, FixedInstanceType } from "fvtt-types/utils";
 import type { ConfiguredObjectClassOrDefault } from "../../config.d.mts";
 
 declare global {
   namespace MeasuredTemplate {
     type ConfiguredClass = ConfiguredObjectClassOrDefault<typeof MeasuredTemplate>;
-    type ConfiguredInstance = InstanceType<ConfiguredClass>;
+    type ConfiguredInstance = FixedInstanceType<ConfiguredClass>;
 
     interface RenderFlags extends PlaceableObject.RenderFlags {
       refreshShape: boolean;
@@ -77,28 +77,28 @@ declare global {
 
     static override RENDER_FLAGS: {
       /** @defaultValue `{ propagate: ["refresh"] }` */
-      redraw: RenderFlag<Partial<MeasuredTemplate.RenderFlags>>;
+      redraw: RenderFlag<MeasuredTemplate.RenderFlags>;
 
       /** @defaultValue `{ propagate: ["refreshState", "refreshShape"], alias: true }` */
-      refresh: RenderFlag<Partial<MeasuredTemplate.RenderFlags>>;
+      refresh: RenderFlag<MeasuredTemplate.RenderFlags>;
 
       /** @defaultValue `{}` */
-      refreshState: RenderFlag<Partial<MeasuredTemplate.RenderFlags>>;
+      refreshState: RenderFlag<MeasuredTemplate.RenderFlags>;
 
       /** @defaultValue `{ propagate: ["refreshPosition", "refreshGrid", "refreshText", "refreshTemplate"] }` */
-      refreshShape: RenderFlag<Partial<MeasuredTemplate.RenderFlags>>;
+      refreshShape: RenderFlag<MeasuredTemplate.RenderFlags>;
 
       /** @defaultValue `{}` */
-      refreshTemplate: RenderFlag<Partial<MeasuredTemplate.RenderFlags>>;
+      refreshTemplate: RenderFlag<MeasuredTemplate.RenderFlags>;
 
       /** @defaultValue `{ propagate: ["refreshGrid"] }` */
-      refreshPosition: RenderFlag<Partial<MeasuredTemplate.RenderFlags>>;
+      refreshPosition: RenderFlag<MeasuredTemplate.RenderFlags>;
 
       /** @defaultValue `{}` */
-      refreshGrid: RenderFlag<Partial<MeasuredTemplate.RenderFlags>>;
+      refreshGrid: RenderFlag<MeasuredTemplate.RenderFlags>;
 
       /** @defaultValue `{}` */
-      refreshText: RenderFlag<Partial<MeasuredTemplate.RenderFlags>>;
+      refreshText: RenderFlag<MeasuredTemplate.RenderFlags>;
     };
 
     override get bounds(): PIXI.Rectangle;