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

package/src/foundry/client/canvas/sources/global-light-source.d.mts

@@ -0,0 +1,141 @@
+import type { FixedInstanceType, Identity, InexactPartial, Override } from "#utils";
+import type BaseLightSource from "./base-light-source.d.mts";
+import type RenderedEffectSource from "./rendered-effect-source.d.mts";
+import type { AbstractBaseShader } from "#client/canvas/rendering/shaders/_module.d.mts";
+import type BaseEffectSource from "./base-effect-source.d.mts";
+
+/**
+ * A specialized subclass of the BaseLightSource which is used to render global light source linked to the scene.
+ */
+declare class GlobalLightSource<
+  SourceData extends GlobalLightSource.SourceData = GlobalLightSource.SourceData,
+  SourceShape extends PIXI.Polygon = PIXI.Polygon,
+  RenderingLayers extends Record<string, RenderedEffectSource.LayerConfig> = BaseLightSource.Layers,
+> extends BaseLightSource<SourceData, SourceShape, RenderingLayers> {
+  static override sourceType: "GlobalLight";
+
+  /** @defaultValue `"lightSources"` */
+  static override effectsCollection: string;
+
+  /**
+   * @defaultValue
+   * ```js
+   * {
+   *   ...super.defaultData,
+   *   rotation: 0,
+   *   angle: 360,
+   *   attenuation: 0,
+   *   priority: -Infinity,
+   *   vision: false,
+   *   walls: false,
+   *   elevation: Infinity,
+   *   darkness: {min: 0, max: 0}
+   * }
+   * ```
+   * @remarks See {@linkcode BaseLightSource.defaultData}
+   */
+  static override defaultData: GlobalLightSource.SourceData;
+
+  /**
+   * Name of this global light source.
+   * @defaultValue {@linkcode GlobalLightSource.sourceType | this.constructor.sourceType}
+   */
+  name: string;
+
+  /**
+   * A custom polygon placeholder.
+   * @defaultValue `null`
+   * @remarks This is not set anywhere in Foundry code, so will always be `null` barring system/module/user action
+   */
+  customPolygon: PIXI.Polygon | number[] | null;
+
+  /** @privateRemarks Fake override to specify Initialized return type */
+  override initialize(
+    data?: InexactPartial<SourceData>,
+    options?: BaseEffectSource.InitializeOptions,
+  ): GlobalLightSource.Initialized<SourceData, SourceShape, RenderingLayers>;
+
+  protected override _createShapes(): void;
+
+  protected override _initializeSoftEdges(): void;
+
+  protected override _updateGeometry(): void;
+
+  protected override _updateCommonUniforms(shader: AbstractBaseShader): void;
+}
+
+declare namespace GlobalLightSource {
+  interface Any extends AnyGlobalLightSource {}
+  interface AnyConstructor extends Identity<typeof AnyGlobalLightSource> {}
+
+  type Initialized<
+    SourceData extends GlobalLightSource.SourceData = GlobalLightSource.SourceData,
+    SourceShape extends PIXI.Polygon = PIXI.Polygon,
+    RenderingLayers extends Record<string, RenderedEffectSource.LayerConfig> = BaseLightSource.Layers,
+  > = Override<
+    GlobalLightSource<SourceData, SourceShape, RenderingLayers>,
+    {
+      /**
+       * The geometric shape of the effect source which is generated later.
+       * @remarks This is the initialized type, the shape has been generated if you're accessing this
+       */
+      shape: SourceShape | number[];
+    }
+  >;
+
+  /**
+   * @privateRemarks `attenuation`, `priority`, and `elevation` exist in the parent interface,
+   * but are here for defaultValue overrides
+   */
+  interface SourceData extends BaseLightSource.SourceData {
+    /**
+     * @defaultValue `0`
+     * @remarks Seemingly unused here, since `GlobalLightSource` does not inherit from `PointEffectSourceMixin`
+     */
+    rotation: number;
+
+    /**
+     * @defaultValue `360`
+     * @remarks Seemingly unused here, since `GlobalLightSource` does not inherit from `PointEffectSourceMixin`
+     */
+    angle: number;
+
+    /** @defaultValue `0` */
+    attenuation: number;
+
+    /**
+     * @defaultValue `-Infinity`
+     * @remarks Seemingly unused here, since `GlobalLightSource` does not inherit from `PointEffectSourceMixin`
+     */
+    priority: number;
+
+    // `vision` override omitted as it doesn't change the default
+
+    /**
+     * @defaultValue `false`
+     * @remarks Seemingly unused here, since `GlobalLightSource` does not inherit from `PointEffectSourceMixin`
+     */
+    walls: boolean;
+
+    /** @defaultValue `Infinity` */
+    elevation: number;
+
+    /** @remarks Threshold values for what darkness level the global light should be enabled for */
+    darkness: {
+      /** @defaultValue `0` */
+      min: number;
+
+      /** @defaultValue `0` */
+      max: number;
+    };
+  }
+
+  type ConfiguredClass = CONFIG["Canvas"]["globalLightSourceClass"];
+  type ConfiguredInstance = FixedInstanceType<ConfiguredClass>;
+}
+
+declare abstract class AnyGlobalLightSource extends GlobalLightSource {
+  constructor(...args: never);
+}
+
+export default GlobalLightSource;

package/src/foundry/client/canvas/sources/point-darkness-source.d.mts

@@ -0,0 +1,160 @@
+import type { FixedInstanceType, Identity, InexactPartial, IntentionalPartial, Override, RequiredProps } from "#utils";
+import type BaseLightSource from "./base-light-source.d.mts";
+import type PointEffectSourceMixin from "./point-effect-source.d.mts";
+import type RenderedEffectSource from "./rendered-effect-source.d.mts";
+import type { PointSourceMesh } from "../containers/_module.d.mts";
+import type { ClockwiseSweepPolygon } from "#client/canvas/geometry/_module.d.mts";
+import type { Canvas } from "#client/canvas/_module.d.mts";
+import type BaseEffectSource from "./base-effect-source.d.mts";
+
+/**
+ * A specialized subclass of the BaseLightSource which renders a source of darkness as a point-based effect.
+ */
+declare class PointDarknessSource<
+  SourceData extends PointDarknessSource.SourceData = PointDarknessSource.SourceData,
+  SourceShape extends ClockwiseSweepPolygon = PointDarknessSource.ImplementationPolygon,
+  RenderingLayers extends Record<string, RenderedEffectSource.LayerConfig> = PointDarknessSource.Layers,
+> extends PointEffectSourceMixin(BaseLightSource)<SourceData, SourceShape, RenderingLayers> {
+  static override sourceType: "darkness";
+
+  /** @defaultValue `"darknessSources"` */
+  static override effectsCollection: string;
+
+  /** @defaultValue `foundry.CONST.LIGHTING_LEVELS.HALFDARK` */
+  protected static override _dimLightingLevel: CONST.LIGHTING_LEVELS;
+
+  /** @defaultValue `foundry.CONST.LIGHTING_LEVELS.DARKNESS` */
+  protected static override _brightLightingLevel: CONST.LIGHTING_LEVELS;
+
+  protected static get ANIMATIONS(): typeof CONFIG.Canvas.darknessAnimations;
+
+  /**
+   * @defaultValue
+   * ```js
+   * {
+   *   darkness: {
+   *     defaultShader: AdaptiveDarknessShader,
+   *     blendMode: "MAX_COLOR"
+   *   }
+   * }
+   * ```
+   */
+  protected static override get _layers(): Record<string, RenderedEffectSource.LayerConfig>;
+
+  /**
+   * @remarks See {@linkcode BaseLightSource.defaultData}, {@linkcode PointEffectSourceMixin.AnyMixedConstructor.defaultData | PointEffectSourceMixin.defaultData}
+   * @privateRemarks Fake override to allow merging to this interface but not its parents
+   */
+  static override defaultData: PointDarknessSource.SourceData;
+
+  /** @privateRemarks Fake override to remove `number[]` */
+  override shape: SourceShape | undefined;
+
+  /**
+   * The optional geometric shape is solely utilized for visual representation regarding darkness sources.
+   * Used only when an additional radius is added for visuals.
+   * @remarks Is `undefined` prior to initialization.
+   *
+   * Not included in the {@linkcode PointDarknessSource.Initialized} overrides,
+   * because it being protected makes overriding messy, and it will still include `| null`; removing the `| undefined` doesn't
+   * meaningfully change the ergonomics
+   */
+  protected _visualShape: SourceShape | null | undefined;
+
+  /**
+   * Padding applied on the darkness source shape for visual appearance only.
+   * Note: for now, padding is increased radius. It might evolve in a future release.
+   * @defaultValue `(CONFIG.Canvas.darknessSourcePaddingMultiplier ?? 0) * canvas.grid.size`
+   */
+  protected _padding: number;
+
+  /** @privateRemarks Fake override to specify Initialized return type */
+  override initialize(
+    data?: InexactPartial<SourceData>,
+    options?: BaseEffectSource.InitializeOptions,
+  ): PointDarknessSource.Initialized<SourceData, SourceShape, RenderingLayers>;
+
+  /** @remarks Unconditionally returns `true` for darkness sources */
+  override get requiresEdges(): boolean;
+
+  /**
+   * A convenience accessor to the darkness layer mesh.
+   * @privateRemarks Unlike the other three layer getters inherited from {@linkcode RenderedEffectSource}, this is never undefined
+   */
+  get darkness(): PointSourceMesh;
+
+  override testPoint(point: Canvas.ElevatedPoint): boolean;
+
+  protected override _initialize(data: IntentionalPartial<SourceData>): void;
+
+  protected override _createShapes(): void;
+
+  protected override _getPolygonConfiguration(): PointDarknessSource.PolygonConfig;
+
+  protected override _drawMesh(layerId: keyof RenderingLayers): PointSourceMesh | null;
+
+  protected override _updateGeometry(): void;
+
+  /**
+   * Update the uniforms of the shader on the darkness layer.
+   */
+  protected _updateDarknessUniforms(): void;
+
+  /**
+   * @deprecated "`BaseLightSource#isDarkness` is now obsolete. Use {@linkcode foundry.canvas.sources.PointDarknessSource | PointDarknessSource} instead." (since v12, until v14)
+   * @remarks Always returns `true`
+   */
+  get isDarkness(): true;
+
+  #PointDarknessSource: true;
+}
+
+declare namespace PointDarknessSource {
+  interface Any extends AnyPointDarknessSource {}
+  interface AnyConstructor extends Identity<typeof AnyPointDarknessSource> {}
+
+  type Initialized<
+    SourceData extends PointDarknessSource.SourceData = PointDarknessSource.SourceData,
+    SourceShape extends ClockwiseSweepPolygon = PointDarknessSource.ImplementationPolygon,
+    RenderingLayers extends Record<string, RenderedEffectSource.LayerConfig> = PointDarknessSource.Layers,
+  > = Override<
+    PointDarknessSource<SourceData, SourceShape, RenderingLayers>,
+    {
+      /**
+       * The geometric shape of the effect source which is generated later.
+       * @remarks This is the initialized type, the shape has been generated if you're accessing this
+       */
+      shape: SourceShape;
+
+      // `protected _visualShape` not overridden because it being protected makes overriding messy, and it will
+      // still include `| null`; removing the `| undefined` doesn't meaningfully change the ergonomics
+    }
+  >;
+
+  interface SourceData extends BaseLightSource.SourceData, PointEffectSourceMixin.SourceData {}
+
+  interface PolygonConfig extends RequiredProps<PointEffectSourceMixin.PolygonConfig, "useThreshold" | "radius"> {}
+
+  /** @remarks See {@linkcode PointDarknessSource._layers} */
+  // Interface would require `RenderingLayers extends ... = InterfaceToObject<Layers>` in every subclass signature
+  // eslint-disable-next-line @typescript-eslint/consistent-type-definitions
+  type Layers = {
+    darkness: RenderedEffectSource.SourceLayer;
+  };
+
+  interface ImplementationClass extends Identity<CONFIG["Canvas"]["darknessSourceClass"]> {}
+  interface Implementation extends FixedInstanceType<ImplementationClass> {}
+
+  interface ImplementationPolygonClass extends Identity<CONFIG["Canvas"]["polygonBackends"]["darkness"]> {}
+  interface ImplementationPolygon extends FixedInstanceType<ImplementationPolygonClass> {}
+}
+
+export default PointDarknessSource;
+
+declare abstract class AnyPointDarknessSource extends PointDarknessSource<
+  PointDarknessSource.SourceData,
+  ClockwiseSweepPolygon,
+  PointDarknessSource.Layers
+> {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/sources/point-effect-source.d.mts

@@ -0,0 +1,190 @@
+import type {
+  Mixin,
+  IntentionalPartial,
+  FixedInstanceType,
+  RequiredProps,
+  AnyObject,
+  InexactPartial,
+  Override,
+} from "#utils";
+import type BaseEffectSource from "./base-effect-source.d.mts";
+import type { PointSourcePolygon, ClockwiseSweepPolygon, edges } from "#client/canvas/geometry/_module.d.mts";
+import type { PointSourceMesh } from "#client/canvas/containers/_module.d.mts";
+import type { Canvas } from "#client/canvas/_module.d.mts";
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+declare class PointEffectSource {
+  /** @privateRemarks All mixin classes should accept anything for its constructor. */
+  constructor(...args: any[]);
+
+  /**
+   * @defaultValue
+   * ```js
+   * {
+   *   ...super.defaultData,
+   *   radius: 0,
+   *   externalRadius: 0,
+   *   rotation: 0,
+   *   angle: 360,
+   *   walls: true
+   * }
+   * ```
+   * @remarks `...super.defaultData` will depend on the mixed class; See {@linkcode foundry.canvas.sources.BaseLightSource.defaultData | BaseLightSource.defaultData},
+   * {@linkcode foundry.canvas.sources.RenderedEffectSource.defaultData | RenderedEffectSource.defaultData}, or {@linkcode BaseEffectSource.defaultData}
+   */
+  static defaultData: PointEffectSourceMixin.MixedSourceData;
+
+  /**
+   * @defaultValue `CONFIG.Canvas.polygonBackends[this.constructor.sourceType].create(origin, config)`
+   * @remarks `undefined` prior to initialization
+   * @privateRemarks This is not in Foundry's code, but the mixin class loses access to the type parameter that would
+   * otherwise be here, and per the default above this is always a {@linkcode PointSourcePolygon} subclass, always
+   * {@linkcode foundry.canvas.geometry.ClockwiseSweepPolygon | ClockwiseSweepPolygon} in core
+   */
+  shape: PointSourcePolygon.Any | undefined;
+
+  /**
+   * The Edge instances added by this source.
+   * @defaultValue `[]`
+   */
+  edges: edges.Edge[];
+
+  /**
+   * Whether this Point Effect source can create edges or not.
+   * Overriding classes can define dynamic behavior if needed.
+   * Default to false so that typical point sources do not create edges.
+   */
+  get requiresEdges(): boolean;
+
+  /**
+   * A convenience reference to the radius of the source.
+   */
+  get radius(): number;
+
+  /**
+   * The (elevated) origin of this point effect source.
+   */
+  get origin(): Canvas.ElevatedPoint;
+
+  /**
+   * The priority of this point effect source.
+   */
+  get priority(): number;
+
+  // TODO: Flatten<IntentionalPartial<SourceData>>
+  protected _configure(changes: AnyObject): void;
+
+  /**
+   * @privateRemarks Fake override to account for losing the ability to return `this` in {@linkcode sources.BaseEffectSource.initialize | BaseEffectSource} and
+   * still have Initialized overrides.
+   */
+  initialize(
+    data?: InexactPartial<PointEffectSourceMixin.MixedSourceData>,
+    options?: BaseEffectSource.InitializeOptions,
+  ): PointEffectSourceMixin.Initialized;
+
+  protected _initialize(data: IntentionalPartial<PointEffectSourceMixin.MixedSourceData>): void;
+
+  protected _initializeSoftEdges(): void;
+
+  /**
+   * Configure the parameters of the polygon that is generated for this source.
+   */
+  protected _getPolygonConfiguration(): PointEffectSourceMixin.PolygonConfig;
+
+  protected _createShapes(): void;
+
+  protected _destroy(): void;
+
+  protected _drawMesh(layerId: string): PointSourceMesh | null;
+
+  protected _updateGeometry(): void;
+
+  /**
+   * Create the Edge instances that correspond to this source.
+   */
+  protected _createEdges(): void;
+
+  /**
+   * Remove edges from the active Edges collection.
+   */
+  protected _deleteEdges(): void;
+
+  #PointEffectSource: true;
+}
+
+/**
+ * Provides a common framework for effect sources that emanate from a central point and extend within a specific radius.
+ * This mixin can be used to manage any effect with a point-based origin, such as light, darkness, or other effects.
+ * @param BaseSource - The base source class to extend
+ */
+declare function PointEffectSourceMixin<BaseClass extends PointEffectSourceMixin.BaseClass>(
+  BaseSource: BaseClass,
+): Mixin<typeof PointEffectSource, BaseClass>;
+
+declare namespace PointEffectSourceMixin {
+  interface AnyMixedConstructor extends ReturnType<typeof PointEffectSourceMixin<BaseClass>> {}
+  interface AnyMixed extends FixedInstanceType<AnyMixedConstructor> {}
+
+  type BaseClass = BaseEffectSource.AnyConstructor;
+
+  type Initialized = Override<
+    PointEffectSourceMixin.AnyMixed,
+    {
+      /**
+       * The geometric shape of the effect source which is generated later.
+       * @remarks This is the initialized type, the shape has been generated if you're accessing this
+       */
+      shape: PointSourcePolygon.Any;
+    }
+  >;
+
+  interface MixedSourceData extends SourceData, BaseEffectSource.SourceData {}
+
+  /** @remarks This mixin guarantees certain keys in the return type beyond the base required `type` */
+  interface PolygonConfig
+    extends RequiredProps<
+      ClockwiseSweepPolygon.Config,
+      "radius" | "edgeOptions" | "externalRadius" | "angle" | "rotation" | "priority" | "source"
+    > {}
+
+  interface SourceData {
+    /**
+     * The radius of the source
+     * @defaultValue `0`
+     */
+    radius: number;
+
+    /**
+     * A secondary radius used for limited angles
+     * @defaultValue `0`
+     */
+    externalRadius: number;
+
+    /**
+     * The angle of rotation for this point source
+     * @defaultValue `0`
+     */
+    rotation: number;
+
+    /**
+     * The angle of emission for this point source
+     * @defaultValue `360`
+     */
+    angle: number;
+
+    /**
+     * Whether or not the source is constrained by walls
+     * @defaultValue `true`
+     */
+    walls: boolean;
+
+    /**
+     * Strength of this source to beat or not negative/positive sources
+     * @defaultValue `0`
+     */
+    priority: number;
+  }
+}
+
+export default PointEffectSourceMixin;

package/src/foundry/client/canvas/sources/point-light-source.d.mts

@@ -0,0 +1,131 @@
+import type {
+  AnyObject,
+  FixedInstanceType,
+  Identity,
+  InexactPartial,
+  IntentionalPartial,
+  Override,
+  RequiredProps,
+} from "#utils";
+import type {
+  BaseEffectSource,
+  BaseLightSource,
+  PointEffectSourceMixin,
+  RenderedEffectSource,
+} from "#client/canvas/sources/_module.d.mts";
+import type { ClockwiseSweepPolygon } from "#client/canvas/geometry/_module.d.mts";
+import type { PlaceableObject } from "#client/canvas/placeables/_module.d.mts";
+import type { CanvasVisibility } from "#client/canvas/groups/_module.d.mts";
+import type { PointSourceMesh } from "#client/canvas/containers/_module.d.mts";
+
+/**
+ * A specialized subclass of the BaseLightSource which renders a source of light as a point-based effect.
+ */
+declare class PointLightSource<
+  SourceData extends PointLightSource.SourceData = PointLightSource.SourceData,
+  SourceShape extends ClockwiseSweepPolygon = PointLightSource.ImplementationPolygon,
+  RenderingLayers extends Record<string, RenderedEffectSource.LayerConfig> = BaseLightSource.Layers,
+> extends PointEffectSourceMixin(BaseLightSource)<SourceData, SourceShape, RenderingLayers> {
+  /** @privateRemarks Actually inherited from {@linkcode BaseLightSource} */
+  static override sourceType: "light";
+
+  /** @defaultValue `"lightSources"` */
+  static override effectsCollection: string;
+
+  /** @privateRemarks Fake override to remove darknessAnimations */
+  protected static get ANIMATIONS(): typeof CONFIG.Canvas.lightAnimations;
+
+  /**
+   * @remarks See {@linkcode BaseLightSource.defaultData}, {@linkcode PointEffectSourceMixin.AnyMixedConstructor.defaultData | PointEffectSourceMixin.defaultData}
+   * @privateRemarks Fake override to allow merging to this interface but not its parents
+   */
+  static override defaultData: PointLightSource.SourceData;
+
+  /** @privateRemarks Fake override to remove `number[]` */
+  override shape: SourceShape | undefined;
+
+  override get requiresEdges(): boolean;
+
+  /** @privateRemarks Fake override to specify Initialized return type */
+  override initialize(
+    data?: InexactPartial<SourceData>,
+    options?: BaseEffectSource.InitializeOptions,
+  ): PointLightSource.Initialized<SourceData, SourceShape, RenderingLayers>;
+
+  /** @privateRemarks Fake override to reinstate the keyof constraint we lost in the mixin */
+  protected _drawMesh(layerId: keyof RenderingLayers): PointSourceMesh | null;
+
+  protected override _initialize(data: IntentionalPartial<SourceData>): void;
+
+  protected override _createShapes(): void;
+
+  // TODO: Flatten<IntentionalPartial<SourceData>>
+  protected override _configure(changes: AnyObject): void;
+
+  protected override _getPolygonConfiguration(): PointLightSource.PolygonConfig;
+
+  /**
+   * Test whether this LightSource provides visibility to see a certain target object.
+   * @param config - The visibility test configuration
+   * @returns Is the target object visible to this source?
+   */
+  testVisibility(config: CanvasVisibility.TestConfig): boolean;
+
+  /**
+   * Can this LightSource theoretically detect a certain object based on its properties?
+   * This check should not consider the relative positions of either object, only their state.
+   * @param target - The target object being tested
+   * @returns Can the target object theoretically be detected by this vision source?
+   */
+  protected _canDetectObject(target?: PlaceableObject.Any | null): boolean;
+
+  /**
+   * @deprecated "`BaseLightSource#isDarkness` is now obsolete. Use {@linkcode foundry.canvas.sources.PointDarknessSource | PointDarknessSource} instead." (since v12, until v14)
+   * @remarks Always returns `false`
+   * @privateRemarks This isn't actually overridden here; {@linkcode BaseLightSource.isDarkness | BaseLightSource#isDarkness} always returns false, but it's typed as `boolean`
+   * there since {@linkcode foundry.canvas.sources.PointDarknessSource | PointDarknessSource#isDarkness} returns true.
+   */
+  get isDarkness(): false;
+
+  #PointLightSource: true;
+}
+
+declare namespace PointLightSource {
+  interface Any extends AnyPointLightSource {}
+  interface AnyConstructor extends Identity<typeof AnyPointLightSource> {}
+
+  type Initialized<
+    SourceData extends PointLightSource.SourceData = PointLightSource.SourceData,
+    SourceShape extends ClockwiseSweepPolygon = PointLightSource.ImplementationPolygon,
+    RenderingLayers extends Record<string, RenderedEffectSource.LayerConfig> = BaseLightSource.Layers,
+  > = Override<
+    PointLightSource<SourceData, SourceShape, RenderingLayers>,
+    {
+      /**
+       * The geometric shape of the effect source which is generated later.
+       * @remarks This is the initialized type, the shape has been generated if you're accessing this
+       */
+      shape: SourceShape;
+    }
+  >;
+
+  interface SourceData extends PointEffectSourceMixin.SourceData, BaseLightSource.SourceData {}
+
+  interface PolygonConfig extends RequiredProps<PointEffectSourceMixin.PolygonConfig, "useThreshold"> {}
+
+  interface ImplementationClass extends Identity<CONFIG["Canvas"]["lightSourceClass"]> {}
+  interface Implementation extends FixedInstanceType<ImplementationClass> {}
+
+  interface ImplementationPolygonClass extends Identity<CONFIG["Canvas"]["polygonBackends"]["light"]> {}
+  interface ImplementationPolygon extends FixedInstanceType<ImplementationPolygonClass> {}
+}
+
+export default PointLightSource;
+
+declare abstract class AnyPointLightSource extends PointLightSource<
+  PointLightSource.SourceData,
+  ClockwiseSweepPolygon,
+  BaseLightSource.Layers
+> {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/sources/point-movement-source.d.mts

@@ -0,0 +1,65 @@
+import type { FixedInstanceType, Identity, InexactPartial, Override } from "#utils";
+import type BaseEffectSource from "./base-effect-source.d.mts";
+import type PointEffectSourceMixin from "./point-effect-source.d.mts";
+import type { ClockwiseSweepPolygon } from "#client/canvas/geometry/_module.d.mts";
+
+/**
+ * A specialized subclass of the BaseEffectSource which describes a movement-based source.
+ */
+declare class PointMovementSource<
+  SourceData extends PointMovementSource.SourceData = PointMovementSource.SourceData,
+  SourceShape extends ClockwiseSweepPolygon = PointMovementSource.ImplementationPolygon,
+> extends PointEffectSourceMixin(BaseEffectSource)<SourceData, SourceShape> {
+  static override sourceType: "move";
+
+  /**
+   * @remarks See {@linkcode PointEffectSourceMixin.AnyMixedConstructor.defaultData | PointEffectSourceMixin.defaultData}
+   * @privateRemarks Fake override to allow merging to this interface but not its parents
+   */
+  static override defaultData: PointMovementSource.SourceData;
+
+  /** @privateRemarks Fake override to remove `number[]` */
+  override shape: SourceShape | undefined;
+
+  /** @privateRemarks Fake override to specify Initialized return type */
+  override initialize(
+    data?: InexactPartial<SourceData>,
+    options?: BaseEffectSource.InitializeOptions,
+  ): PointMovementSource.Initialized<SourceData, SourceShape>;
+}
+
+declare namespace PointMovementSource {
+  interface Any extends AnyPointMovementSource {}
+  interface AnyConstructor extends Identity<typeof AnyPointMovementSource> {}
+
+  type Initialized<
+    SourceData extends PointMovementSource.SourceData = PointMovementSource.SourceData,
+    SourceShape extends ClockwiseSweepPolygon = PointMovementSource.ImplementationPolygon,
+  > = Override<
+    PointMovementSource<SourceData, SourceShape>,
+    {
+      /**
+       * The geometric shape of the effect source which is generated later.
+       * @remarks This is the initialized type, the shape has been generated if you're accessing this
+       */
+      shape: SourceShape;
+    }
+  >;
+
+  interface SourceData extends PointEffectSourceMixin.MixedSourceData {}
+
+  // This is the only core Point*Source class that isn't configurable, `Token##getMovementSource`
+  // references this class directly, there is no `CONFIG.Canvas.movementSourceClass` or equivalent
+
+  interface ImplementationPolygonClass extends Identity<CONFIG["Canvas"]["polygonBackends"]["move"]> {}
+  interface ImplementationPolygon extends FixedInstanceType<ImplementationPolygonClass> {}
+}
+
+export default PointMovementSource;
+
+declare abstract class AnyPointMovementSource extends PointMovementSource<
+  PointMovementSource.SourceData,
+  ClockwiseSweepPolygon
+> {
+  constructor(...args: never);
+}