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

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

@@ -0,0 +1,393 @@
+import type { FixedInstanceType, HandleEmptyObject, NullishProps } from "#utils";
+import type { ConfiguredObjectClassOrDefault } from "../../config.d.mts";
+import type { Canvas } from "#client/canvas/_module.d.mts";
+import type { PlaceableObject } from "#client/canvas/placeables/_module.d.mts";
+import type { DoorControl } from "#client/canvas/containers/_module.d.mts";
+import type { Ray } from "#client/canvas/geometry/_module.d.mts";
+import Edge = foundry.canvas.geometry.edges.Edge;
+import { RenderFlagsMixin, RenderFlags, RenderFlag } from "#client/canvas/interaction/_module.mjs";
+
+declare module "#configuration" {
+  namespace Hooks {
+    interface PlaceableObjectConfig {
+      Wall: Wall.Implementation;
+    }
+  }
+}
+
+/**
+ * A Wall is an implementation of PlaceableObject which represents a physical or visual barrier within the Scene.
+ * Walls are used to restrict Token movement or visibility as well as to define the areas of effect for ambient lights
+ * and sounds.
+ *
+ * @see {@linkcode WallDocument}
+ * @see {@linkcode WallsLayer}
+ */
+declare class Wall extends PlaceableObject<WallDocument.Implementation> {
+  static override embeddedName: "Wall";
+
+  static override RENDER_FLAGS: Wall.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<Wall.RENDER_FLAGS>;
+
+  // fake override; super has to type as if this could be a ControlIcon, but Walls don't use one
+  override controlIcon: null;
+
+  /**
+   * A reference the Door Control icon associated with this Wall, if any
+   * @defaultValue `undefined`
+   * @remarks Only `undefined` prior to first draw. {@link Wall.clearDoorControl | `Wall#clearDoorControl`} sets it `null`.
+   */
+  doorControl: DoorControl.ConfiguredInstance | null | undefined;
+
+  /**
+   * The line segment that represents the Wall.
+   */
+  line: PIXI.Graphics | undefined;
+
+  /**
+   * The endpoints of the Wall line segment.
+   * @defaultValue `undefined`
+   * @remarks Only `undefined` prior to first draw.
+   */
+  endpoints: PIXI.Graphics | undefined;
+
+  /**
+   * The icon that indicates the direction of the Wall.
+   * @defaultValue `undefined`
+   * @remarks Only `undefined` prior to first draw.
+   * @privateRemarks Foundry types this as `| null` as well, but it is never set that in practice
+   */
+  directionIcon: PIXI.Sprite | undefined;
+
+  /**
+   * A Graphics object used to highlight this wall segment. Only used when the wall is controlled.
+   * @defaultValue `undefined`
+   * @remarks This is both not initialized to a value at construction *and* conditionally set
+   * explicitly `undefined` in {@link Wall._refreshHighlight | `Wall#_refreshHighlight`}
+   */
+  highlight: PIXI.Graphics | undefined;
+
+  /**
+   * A convenience reference to the coordinates Array for the Wall endpoints, [x0,y0,x1,y1].
+   */
+  get coords(): Wall.Coordinates;
+
+  /**
+   * The Edge instance which represents this Wall.
+   * The Edge is re-created when data for the Wall changes.
+   */
+  get edge(): Edge;
+
+  override get bounds(): PIXI.Rectangle;
+
+  /**
+   * A boolean for whether this wall contains a door
+   */
+  get isDoor(): boolean;
+
+  /**
+   * A boolean for whether the wall contains an open door
+   */
+  get isOpen(): boolean;
+
+  /**
+   * Return the coordinates [x,y] at the midpoint of the wall segment
+   */
+  get midpoint(): Canvas.PointTuple;
+
+  override get center(): PIXI.Point;
+
+  /**
+   * Get the direction of effect for a directional Wall
+   * @returns The angle of wall effect
+   * @remarks In radians. Returns `null` if the document's `dir` is falsey/not set
+   */
+  get direction(): number | null;
+
+  /**
+   * @throws "`Wall#getSnappedPosition` is not supported: WallDocument does not have a (x, y) position"
+   */
+  override getSnappedPosition(position: never): never;
+
+  /**
+   * Initialize the edge which represents this Wall.
+   * @param options - Options which modify how the edge is initialized
+   */
+  // options: not null (destructured)
+  initializeEdge(options?: Wall.InitializeEdgeOptions): void;
+
+  /**
+   * This helper converts the wall segment to a Ray
+   * @returns The wall in Ray representation
+   */
+  toRay(): Ray;
+
+  protected override _draw(options: HandleEmptyObject<Wall.DrawOptions>): Promise<void>;
+
+  override clear(): this;
+
+  /**
+   * Draw a control icon that is used to manipulate the door's open/closed state
+   */
+  createDoorControl(): DoorControl.ConfiguredInstance;
+
+  /**
+   * Clear the door control if it exists.
+   */
+  clearDoorControl(): void;
+
+  // options: not null (destructured)
+  override control(options?: Wall.ControlOptions): boolean;
+
+  protected override _destroy(options: PIXI.IDestroyOptions | boolean | undefined): void;
+
+  /**
+   * Test whether the Wall direction lies between two provided angles
+   * This test is used for collision and vision checks against one-directional walls
+   * @param lower - The lower-bound limiting angle in radians
+   * @param upper - The upper-bound limiting angle in radians
+   */
+  isDirectionBetweenAngles(lower: number, upper: number): boolean;
+
+  /**
+   * A simple test for whether a Ray can intersect a directional wall
+   * @param ray - The ray to test
+   * @returns Can an intersection occur?
+   */
+  canRayIntersect(ray: Ray): boolean;
+
+  /**
+   * Get an Array of Wall objects which are linked by a common coordinate
+   * @returns An object reporting ids and endpoints of the linked segments
+   */
+  getLinkedSegments(): Wall.GetLinkedSegmentsReturn;
+
+  protected override _applyRenderFlags(flags: Wall.RenderFlags): void;
+
+  /**
+   * Refresh the displayed position of the wall which refreshes when the wall coordinates or type changes.
+   */
+  protected _refreshLine(): void;
+
+  /**
+   * Refresh the display of wall endpoints which refreshes when the wall position or state changes.
+   */
+  protected _refreshEndpoints(): void;
+
+  /**
+   * Draw a directional prompt icon for one-way walls to illustrate their direction of effect.
+   */
+  protected _refreshDirection(): void;
+
+  /**
+   * Refresh the appearance of the wall control highlight graphic. Occurs when wall control or position changes.
+   */
+  protected _refreshHighlight(): void;
+
+  /**
+   * Refresh the displayed state of the Wall.
+   */
+  protected _refreshState(): void;
+
+  /**
+   * Given the properties of the wall - decide upon a color to render the wall for display on the WallsLayer
+   */
+  protected _getWallColor(): number;
+
+  // _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.
+
+  /**
+   * Play a door interaction sound.
+   * This plays locally, each client independently applies this workflow.
+   * @param interaction - The door interaction: "open", "close", "lock", "unlock", or "test".
+   * @remarks Foundry marked `@internal`
+   */
+  protected _playDoorSound(interaction: Wall.DoorInteraction): void;
+
+  /**
+   * Customize the audible radius of sounds emitted by this wall, for example when a door opens or closes.
+   * @defaultValue `canvas.dimensions.distance * 12; // 60 feet on a 5ft grid`
+   */
+  get soundRadius(): number;
+
+  protected override _canControl(user: User.Implementation, event?: Canvas.Event.Pointer): boolean;
+
+  // options: not null (destructured in super)
+  protected override _onHoverIn(event: Canvas.Event.Pointer, options?: PlaceableObject.HoverInOptions): false | void;
+
+  protected override _onHoverOut(event: Canvas.Event.Pointer): void;
+
+  protected override _overlapsSelection(rectangle: PIXI.Rectangle): boolean;
+
+  protected override _onClickLeft(event: Canvas.Event.Pointer): boolean;
+
+  protected override _onClickLeft2(event: Canvas.Event.Pointer): void;
+
+  protected override _onClickRight2(event: Canvas.Event.Pointer): void;
+
+  protected override _onDragLeftStart(event: Canvas.Event.Pointer): void;
+
+  protected override _onDragLeftMove(event: Canvas.Event.Pointer): void;
+
+  protected override _prepareDragLeftDropUpdates(event: Canvas.Event.Pointer): Wall.DragLeftDropUpdate[] | null;
+
+  /**
+   * @deprecated since v12, until v14
+   * @remarks "`Wall#roof` has been deprecated. There's no replacement"
+   */
+  get roof(): null;
+
+  /**
+   * @deprecated since v12, until v14
+   * @remarks "`Wall#hasActiveRoof` has been deprecated. There's no replacement"
+   */
+  get hasActiveRoof(): boolean;
+
+  /**
+   * @deprecated since v12, until v14
+   * @remarks "`Wall#identifyInteriorState` has been deprecated. It has no effect anymore and there's no replacement."
+   */
+  identifyInteriorState(): void;
+
+  /**
+   * Determine the orientation of this wall with respect to a reference point
+   * @param point - Some reference point, relative to which orientation is determined
+   * @returns An orientation in CONST.WALL_DIRECTIONS which indicates whether the Point is left, right, or collinear (both) with the Wall
+   * @deprecated since v12, until v14
+   * @remarks "`Wall#orientPoint` has been moved to {@link Edge.orientPoint | `foundry.canvas.geometry.edges.Edge#orientPoint`}"
+   */
+  orientPoint(point: Canvas.Point): CONST.WALL_DIRECTIONS;
+
+  /**
+   * Test whether to apply a configured threshold of this wall.
+   * When the proximity threshold is met, this wall is excluded as an edge in perception calculations.
+   * @param sourceType     - Sense type for the source
+   * @param sourceOrigin   - The origin or position of the source on the canvas
+   * @param externalRadius - The external radius of the source (default: `0`)
+   * @returns `true` if the wall has a threshold greater than 0 for the source type, and the source type is within that distance.
+   * @deprecated since v12, until v14
+   * @remarks "Wall#applyThreshold has been moved to {@link Edge.applyThreshold | `foundry.canvas.geometry.edges.Edge#applyThreshold`}"
+   */
+  applyThreshold(
+    sourceType: Edge.AttenuationTypes,
+    sourceOrigin: Canvas.Point,
+    externalRadius?: number | null,
+  ): boolean;
+
+  /**
+   * @deprecated since v12, until v14
+   * @remarks "`Wall#vertices` is replaced by {@link Wall.edge | `Wall#edge`}"
+   */
+  get vertices(): Edge;
+
+  /**
+   * The initial endpoint of the Wall
+   * @deprecated since v12, until v14
+   * @remarks "`Wall#A` is replaced by {@link Edge.a | `Wall#edge#a`}"
+   */
+  get A(): Edge["a"];
+
+  /**
+   * The second endpoint of the Wall
+   * @deprecated since v12, until v14
+   * @remarks "`Wall#B` is replaced by {@link Edge.b | `Wall#edge#b`}"
+   */
+  get B(): Edge["b"];
+}
+
+declare namespace Wall {
+  /**
+   * The implementation of the `Wall` placeable configured through `CONFIG.Wall.objectClass`
+   * in Foundry and {@linkcode PlaceableObjectClassConfig} in fvtt-types.
+   *
+   * Not to be confused with {@linkcode WallDocument.Implementation}
+   * which refers to the implementation for the Wall document.
+   */
+  type Implementation = FixedInstanceType<ImplementationClass>;
+
+  /**
+   * The implementation of the `Wall` placeable configured through `CONFIG.Wall.objectClass`
+   * in Foundry and {@linkcode PlaceableObjectClassConfig} in fvtt-types.
+   *
+   * Not to be confused with {@linkcode WallDocument.ImplementationClass}
+   * which refers to the implementation for the Wall document.
+   */
+  // eslint-disable-next-line no-restricted-syntax
+  type ImplementationClass = ConfiguredObjectClassOrDefault<typeof Wall>;
+
+  interface RENDER_FLAGS {
+    /** @defaultValue `{ propagate: ["refresh"] }` */
+    redraw: RenderFlag<this, "redraw">;
+
+    /** @defaultValue `{ propagate: ["refreshState", "refreshLine"], alias: true }` */
+    refresh: RenderFlag<this, "refresh">;
+
+    /** @defaultValue `{ propagate: ["refreshEndpoints", "refreshHighlight"] }` */
+    refreshState: RenderFlag<this, "refreshState">;
+
+    /** @defaultValue `{ propagate: ["refreshEndpoints", "refreshHighlight", "refreshDirection"] }` */
+    refreshLine: RenderFlag<this, "refreshLine">;
+
+    /** @defaultValue `{}` */
+    refreshEndpoints: RenderFlag<this, "refreshEndpoints">;
+
+    /** @defaultValue `{}` */
+    refreshDirection: RenderFlag<this, "refreshDirection">;
+
+    /** @defaultValue `{}` */
+    refreshHighlight: RenderFlag<this, "refreshHighlight">;
+  }
+
+  interface RenderFlags extends RenderFlagsMixin.ToBooleanFlags<RENDER_FLAGS> {}
+
+  type Coordinates = WallDocument.Coordinates;
+
+  type DoorInteraction = "open" | "close" | "lock" | "unlock" | "test";
+
+  interface DrawOptions extends PlaceableObject.DrawOptions {}
+
+  interface RefreshOptions extends PlaceableObject.RefreshOptions {}
+
+  /** @internal */
+  type _ControlOptions = NullishProps<{
+    /** @defaultValue `false` */
+    chain: boolean;
+  }>;
+
+  interface ControlOptions extends _ControlOptions, PlaceableObject.ControlOptions {}
+
+  interface ReleaseOptions extends PlaceableObject.ReleaseOptions {}
+
+  /** @internal */
+  type _InitializeEdgeOptions = NullishProps<{
+    /**
+     * Has the edge been deleted?
+     * @defaultValue `false`
+     */
+    deleted: boolean;
+  }>;
+
+  interface InitializeEdgeOptions extends _InitializeEdgeOptions {}
+
+  interface GetLinkedSegmentsReturn {
+    /** @remarks IDs of the Walls in `walls` */
+    ids: string[];
+
+    /** @remarks All the Walls connected to this one */
+    walls: Wall.Implementation[];
+
+    /** @remarks `walls.length + 1` endpoints */
+    endpoints: Canvas.PointTuple[];
+  }
+
+  interface DragLeftDropUpdate {
+    _id: string;
+    c: WallDocument.Coordinates;
+  }
+}
+
+export default Wall;

package/src/foundry/client/canvas/primary/_module.d.mts

@@ -0,0 +1,12 @@
+// 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 PrimaryCanvasContainer } from "./primary-canvas-container.mjs";
+export { default as PrimaryGraphics } from "./primary-graphics.mjs";
+export { default as PrimaryParticleEffect } from "./primary-particle-effect.mjs";
+export { default as PrimarySpriteMesh } from "./primary-sprite-mesh.mjs";
+
+export { default as PrimaryOccludableObjectMixin } from "./primary-occludable-object.mjs";
+export { default as PrimaryCanvasObjectMixin, CanvasTransformMixin } from "./primary-canvas-object.mjs";

package/src/foundry/client/canvas/primary/primary-canvas-container.d.mts

@@ -0,0 +1,17 @@
+import type { Identity } from "#utils";
+import type { CanvasTransformMixin } from "./primary-canvas-object.d.mts";
+
+declare class PrimaryCanvasContainer extends CanvasTransformMixin(PIXI.Container) {
+  #PrimaryCanvasContainer: true;
+}
+
+declare namespace PrimaryCanvasContainer {
+  interface Any extends AnyPrimaryCanvasContainer {}
+  interface AnyConstructor extends Identity<typeof AnyPrimaryCanvasContainer> {}
+}
+
+export default PrimaryCanvasContainer;
+
+declare abstract class AnyPrimaryCanvasContainer extends PrimaryCanvasContainer {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/primary/primary-canvas-object.d.mts

@@ -0,0 +1,201 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import type { FixedInstanceType, Mixin } from "#utils";
+import type Document from "#common/abstract/document.d.mts";
+import type { CanvasGroupMixin } from "#client/canvas/groups/_module.d.mts";
+import type { PlaceableObject } from "#client/canvas/placeables/_module.d.mts";
+
+declare class PrimaryCanvasObject {
+  /** @privateRemarks All mixin classes should accept anything for its constructor. */
+  constructor(...args: any[]);
+
+  /**
+   * @defaultValue `true`
+   * @privateRemarks Actually an override of the property on `PIXI.DisplayObject`
+   */
+  cullable: boolean;
+
+  /**
+   * An optional reference to the object that owns this PCO.
+   * This property does not affect the behavior of the PCO itself.
+   * @defaultValue `null`
+   * @privateRemarks Foundry types as `*`, but in practice, it will only ever be a `Drawing` (via `PrimaryGraphics`),
+   * or a `Token`, `Tile`, or the `PrimaryCanvasGroup` (via `PrimarySpriteMesh`), or its default value `null`
+   */
+  // TODO: (esheyw) Revisit the "any canvas group" type when groups are done
+  object: PlaceableObject.Any | CanvasGroupMixin.AnyMixed | null;
+
+  /**
+   * The elevation of this object.
+   * @defaultValue `0`
+   */
+  get elevation(): number;
+
+  set elevation(value);
+
+  /**
+   * A key which resolves ties amongst objects at the same elevation within the same layer.
+   */
+  get sort(): number;
+
+  set sort(value);
+
+  /**
+   * A key which resolves ties amongst objects at the same elevation of different layers.
+   */
+  get sortLayer(): number;
+
+  set sortLayer(value);
+
+  /**
+   * A key which resolves ties amongst objects at the same elevation within the same layer and same sort.
+   */
+  get zIndex(): number;
+
+  set zIndex(value);
+
+  /**
+   * Event fired when this display object is added to a parent.
+   * @param parent - The new parent container.
+   * @throws If `parent` is not `=== canvas.primary`
+   */
+  protected _onAdded(parent: PIXI.Container): void;
+
+  /**
+   * Event fired when this display object is removed from its parent.
+   * @param parent - Parent from which the PCO is removed.
+   */
+  protected _onRemoved(parent: PIXI.Container): void;
+
+  /** @see {@link CanvasTransformMixinClass.updateCanvasTransform | `CanvasTransformMixinClass#updateCanvasTransform`} */
+  updateCanvasTransform(): void;
+
+  /** @see {@link CanvasTransformMixinClass._onCanvasBoundsUpdate | `CanvasTransformMixinClass#_onCanvasBoundsUpdate`} */
+  protected _onCanvasBoundsUpdate(): void;
+
+  /**
+   * Does this object render to the depth buffer?
+   */
+  get shouldRenderDepth(): boolean;
+
+  /**
+   * Does this object render to the depth buffer?
+   */
+  protected _shouldRenderDepth(): boolean;
+
+  /**
+   * Render the depth of this object.
+   */
+  renderDepthData(renderer: PIXI.Renderer): void;
+
+  /**
+   * @deprecated since v11, will be removed in v13
+   * @remarks `"PrimaryCanvasObject#renderOcclusion is deprecated in favor of PrimaryCanvasObject#renderDepthData"`
+   */
+  renderOcclusion(renderer: PIXI.Renderer): void;
+
+  /**
+   * @deprecated since v12, will be removed in v14
+   * @remarks `"PrimaryCanvasObject#document is deprecated."`
+   */
+  get document(): Document.Any | null;
+
+  /**
+   * @deprecated since v12, will be removed in v14
+   * @remarks `"PrimaryCanvasObject#updateBounds is deprecated and has no effect."`
+   */
+  updateBounds(): void;
+}
+
+declare class CanvasTransformMixinClass {
+  /** @privateRemarks All mixin classses should accept anything for its constructor. */
+  constructor(...args: any[]);
+
+  /**
+   * The transform matrix from local space to canvas space.
+   */
+  canvasTransform: PIXI.Matrix;
+
+  /**
+   * The update ID of canvas transform matrix.
+   * @privateRemarks Foundry marked `@internal`, technically accessed externally via `this.parent._convasTranformID` in `updateCanvasTransform`
+   */
+  protected _canvasTransformID: number;
+
+  /**
+   * The canvas bounds of this object.
+   */
+  canvasBounds: PIXI.Rectangle;
+
+  /**
+   * The canvas bounds of this object.
+   */
+  protected _canvasBounds: PIXI.Bounds;
+
+  /**
+   * The update ID of the canvas bounds.
+   * Increment to force recalculation.
+   */
+  protected _canvasBoundsID: number;
+
+  /**
+   * Calculate the canvas bounds of this object.
+   */
+  protected _calculateCanvasBounds(): void;
+
+  /**
+   * Recalculate the canvas transform and bounds of this object and its children, if necessary.
+   */
+  updateCanvasTransform(): void;
+
+  /**
+   * Called when the canvas transform changed.
+   */
+  protected _onCanvasTransformUpdate(): void;
+
+  /**
+   * Called when the canvas bounds changed.
+   */
+  protected _onCanvasBoundsUpdate(): void;
+
+  /**
+   * Is the given point in canvas space contained in this object?
+   * @param point - The point in canvas space.
+   */
+  containsCanvasPoint(point: PIXI.IPointData): boolean;
+}
+
+/**
+ * A mixin which decorates a DisplayObject with additional properties expected for rendering in the PrimaryCanvasGroup.
+ * @param DisplayObject - The parent DisplayObject class being mixed
+ * @returns A DisplayObject subclass mixed with PrimaryCanvasObject features
+ * @privateRemarks Despite naming the argument "DisplayObject", it's typed as only taking `PIXI.Container`s, which matches core's usage
+ */
+declare function PrimaryCanvasObjectMixin<BaseClass extends PrimaryCanvasObjectMixin.BaseClass>(
+  DisplayObject: BaseClass,
+): Mixin<typeof PrimaryCanvasObject, ReturnType<typeof CanvasTransformMixin<BaseClass>>>;
+
+declare namespace PrimaryCanvasObjectMixin {
+  interface AnyMixedConstructor
+    extends ReturnType<typeof PrimaryCanvasObjectMixin<PrimaryCanvasObjectMixin.BaseClass>> {}
+  interface AnyMixed extends FixedInstanceType<AnyMixedConstructor> {}
+
+  type BaseClass = PIXI.Container.AnyConstructor;
+}
+
+/**
+ * A mixin which decorates a DisplayObject with additional properties for canvas transforms and bounds.
+ * @param DisplayObject - The parent DisplayObject class being mixed
+ * @returns A DisplayObject subclass mixed with CanvasTransformMixin features
+ * @privateRemarks Despite naming the argument "DisplayObject", it's typed as only taking `PIXI.Container`s, which matches core's usage
+ */
+declare function CanvasTransformMixin<BaseClass extends CanvasTransformMixin.BaseClass>(
+  DisplayObject: BaseClass,
+): Mixin<typeof CanvasTransformMixinClass, BaseClass>;
+
+declare namespace CanvasTransformMixin {
+  interface AnyMixedConstructor extends ReturnType<typeof CanvasTransformMixin<CanvasTransformMixin.BaseClass>> {}
+  interface AnyMixed extends FixedInstanceType<AnyMixedConstructor> {}
+
+  type BaseClass = PIXI.Container.AnyConstructor;
+}
+export { PrimaryCanvasObjectMixin as default, CanvasTransformMixin };

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

@@ -0,0 +1,62 @@
+import type { Identity, NullishProps } from "#utils";
+import type { PrimaryCanvasObjectMixin } from "./_module.d.mts";
+import type { PlaceableObject } from "#client/canvas/placeables/_module.d.mts";
+
+/**
+ * A basic PCO which is handling drawings of any shape.
+ */
+declare class PrimaryGraphics extends PrimaryCanvasObjectMixin(PIXI.Graphics) {
+  /**
+   * @param options - A config object
+   */
+  constructor(
+    /**
+     * @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;
+
+  override updateCanvasTransform(): void;
+
+  override containsCanvasPoint(point: PIXI.IPointData): boolean;
+}
+
+declare namespace PrimaryGraphics {
+  interface Any extends AnyPrimaryGraphics {}
+  interface AnyConstructor extends Identity<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 {}
+}
+
+export default PrimaryGraphics;
+
+declare abstract class AnyPrimaryGraphics extends PrimaryGraphics {
+  constructor(...args: never);
+}