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

package/src/foundry/client/pixi/core/shapes/polygon-mesher.d.mts

@@ -1,138 +0,0 @@
-import type { IntentionalPartial } from "fvtt-types/utils";
-
-declare global {
-  /**
-   * A helper class used to construct triangulated polygon meshes
-   * Allow to add padding and a specific depth value.
-   */
-  class PolygonMesher {
-    /**
-     * @param poly    - Closed polygon to be processed and converted to a mesh
-     *                  (array of points or PIXI Polygon)
-     * @param options - Various options : normalizing, offsetting, add depth, ...
-     * @remarks `options` is `IntentionalPartial`'d because the constructor immediately does
-     * `this.options = {...this.constructor._defaultOptions, ...options}`, so explicit `undefined` would break things
-     */
-    constructor(poly: PIXI.Polygon.OrPointsFlat, options?: IntentionalPartial<PolygonMesher.Options>);
-
-    /** Default options values */
-    static _defaultOptions: PolygonMesher.Options;
-
-    /**
-     * Polygon mesh vertices
-     */
-    vertices: number[];
-
-    /**
-     * Polygon mesh indices
-     */
-    indices: number[];
-
-    /** Contains options to apply during the meshing process */
-    options: PolygonMesher.Options;
-
-    /**
-     * Convert a flat points array into a 2 dimensional ClipperLib path
-     * @param poly      - PIXI.Polygon or points flat array.
-     * @param dimension - Dimension.
-     *                    (default 2)
-     * @returns The clipper lib path.
-     * @throws If `dimension < 2`
-     * @privateRemarks Foundry types this return as `number[] | undefined`, but it cannot return either of those;
-     * Either it will throw or return a (possibly empty) `ClipperLib.Path` (an array-like of `ClipperLib.IntPoint`s)
-     */
-    static getClipperPathFromPoints(poly: PIXI.Polygon.OrPointsFlat, dimension?: number): ClipperLib.Path;
-
-    /**
-     * Execute the triangulation to create indices
-     * @param geometry - A geometry to update
-     * @returns The resulting geometry
-     */
-    triangulate(geometry: PIXI.Geometry): PIXI.Geometry;
-  }
-
-  namespace PolygonMesher {
-    interface Any extends AnyPolygonMesher {}
-    type AnyConstructor = typeof AnyPolygonMesher;
-
-    /**
-     *  @remarks These properties all have non-nullish values in `_defaultOptions`, and explicit `undefined` breaks
-     * things that aren't `boolean` due to math and object spread syntax in the constructor. `null` has been allowed
-     * where its casting to `0` or `false` doesn't break things.
-     */
-    interface Options {
-      /**
-       * The position value in pixels
-       * @defaultValue `0`
-       * @remarks Can't be `undefined` because the default is provided by spread operator and the value is used directly in math
-       */
-      offset: number | null;
-
-      /**
-       * Should the vertices be normalized?
-       * @defaultValue `false`
-       */
-      normalize: boolean | undefined | null;
-
-      /**
-       * The x origin
-       * @defaultValue `0`
-       * @remarks Can't be `undefined` because the default is provided by spread operator and the value is used directly in math
-       */
-      x: number | null;
-
-      /**
-       * The y origin
-       * @defaultValue `0`
-       * @remarks Can't be `undefined` because the default is provided by spread operator and the value is used directly in math
-       */
-      y: number | null;
-
-      /**
-       * The radius
-       * @defaultValue `0`
-       * @remarks Can't be `null` because of an `=== 0` check, nor `undefined` because the default is provided by spread operator and the value is used directly in math
-       */
-      radius: number;
-
-      /**
-       * The depth value on the outer polygon
-       * @defaultValue `0`
-       * @remarks Can't be `null` as it can be pushed directly into a `number[]`, nor `undefined` because the default is provided by spread operator and the value is used directly in math
-       */
-      depthOuter: number;
-
-      /**
-       * The depth value on the inner polygon
-       * @defaultValue `1`
-       * @remarks Can't be `undefined` because the default is provided by spread operator and the value is used directly in math
-       */
-      depthInner: number | null;
-
-      /**
-       * Constant multiplier to avoid floating point imprecision with ClipperLib
-       * @defaultValue `10e8`
-       * @remarks Not allowing `null` because a zero value here defeats the purpose, and `undefined` because the default is provided by spread operator and the value is used directly in math
-       */
-      scale: number;
-
-      /**
-       * Distance of the miter limit, when sharp angles are cut during offsetting.
-       * @defaultValue `7`
-       * @remarks Allowed to be `undefined` but not `null` because it is passed to
-       * `new ClipperLib.ClipperOffset()`, which provides its own default if `=== undefined`
-       */
-      miterLimit: number | undefined;
-
-      /**
-       * Should the vertex data be interleaved into one VBO?
-       * @defaultValue `false`
-       */
-      interleaved: boolean | undefined | null;
-    }
-  }
-}
-
-declare abstract class AnyPolygonMesher extends PolygonMesher {
-  constructor(arg0: never, ...args: never[]);
-}

package/src/foundry/client/pixi/core/shapes/precise-text.d.mts

@@ -1,45 +0,0 @@
-import type { InexactPartial, NullishProps } from "fvtt-types/utils";
-
-declare global {
-  /**
-   * An extension of the default PIXI.Text object which forces double resolution.
-   * At default resolution Text often looks blurry or fuzzy.
-   */
-  class PreciseText extends PIXI.Text {
-    constructor(...args: ConstructorParameters<typeof PIXI.Text>);
-
-    /** @defaultValue `false` */
-    override _autoResolution: boolean;
-
-    /** @defaultValue `2` */
-    override _resolution: number;
-    /**
-     * 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 options - Additional options merged with the default TextStyle
-     * @returns The prepared TextStyle
-     */
-    static getTextStyle({ anchor, ...options }?: PreciseText.GetTextStyleOptions): PIXI.TextStyle;
-  }
-
-  namespace PreciseText {
-    interface Any extends AnyPreciseText {}
-    type AnyConstructor = typeof AnyPreciseText;
-
-    /** @internal */
-    type _GetTextStyleOptions = NullishProps<{
-      /**
-       * A text anchor point from CONST.TEXT_ANCHOR_POINTS
-       * @remarks Only checked againt `.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 {}
-  }
-}
-
-declare abstract class AnyPreciseText extends PreciseText {
-  constructor(arg0: never, ...args: never[]);
-}

package/src/foundry/client/pixi/core/shapes/ray.d.mts

@@ -1,183 +0,0 @@
-import type { LineIntersection } from "../../../../common/utils/geometry.d.mts";
-
-declare global {
-  interface RayIntersection {
-    /** The x-coordinate of intersection */
-    x: number;
-
-    /** The y-coordinate of intersection */
-    y: number;
-
-    /** The proximity to the Ray origin, as a ratio of distance */
-    t0: number;
-
-    /** The proximity to the Ray destination, as a ratio of distance */
-    t1: number;
-  }
-
-  /**
-   * A ray for the purposes of computing sight and collision
-   * Given points A[x,y] and B[x,y]
-   *
-   * Slope-Intercept form:
-   * y = a + bx
-   * y = A.y + ((B.y - A.Y) / (B.x - A.x))x
-   *
-   * Parametric form:
-   * R(t) = (1-t)A + tB
-   */
-  class Ray {
-    /**
-     * @param A - The origin of the Ray
-     * @param B - The destination of the Ray
-     */
-    constructor(A: Canvas.Point, B: Canvas.Point);
-
-    /**
-     * The origin point, `{x, y}`
-     */
-    A: Canvas.Point;
-
-    /**
-     * The destination point, `{x, y}`
-     */
-    B: Canvas.Point;
-
-    /**
-     * The origin y-coordinate
-     */
-    y0: number;
-
-    /**
-     * The origin x-coordinate
-     */
-    x0: number;
-
-    /**
-     * The horizontal distance of the ray, x1 - x0
-     */
-    dx: number;
-
-    /**
-     * The vertical distance of the ray, y1 - y0
-     */
-    dy: number;
-
-    /**
-     * The slope of the ray, dy over dx
-     */
-    slope: number;
-
-    /**
-     * The cached angle, computed lazily in Ray#angle
-     * @defaultValue `undefined`
-     * @privateRemarks Foundry marked `@private` and doesn't type the `| undefined`
-     */
-    protected _angle: number | undefined;
-
-    /**
-     * The cached distance, computed lazily in Ray#distance
-     * @defaultValue `undefined`
-     * @privateRemarks Foundry marked `@private` and doesn't type the `| undefined`
-     */
-    protected _distance: number | undefined;
-
-    /**
-     * The normalized angle of the ray in radians on the range (-PI, PI).
-     * The angle is computed lazily (only if required) and cached.
-     */
-    get angle(): number;
-
-    set angle(value);
-
-    /**
-     * A normalized bounding rectangle that encompasses the Ray
-     */
-    get bounds(): PIXI.Rectangle;
-
-    /**
-     * The distance (length) of the Ray in pixels.
-     * The distance is computed lazily (only if required) and cached.
-     */
-    get distance(): number;
-
-    set distance(value);
-
-    /**
-     * A factory method to construct a Ray from an origin point, an angle, and a distance
-     * @param x        - The origin x-coordinate
-     * @param y        - The origin y-coordinate
-     * @param radians  - The ray angle in radians
-     * @param distance - The distance of the ray in pixels
-     * @returns The constructed Ray instance
-     */
-    static fromAngle(x: number, y: number, radians: number, distance: number): Ray;
-
-    /**
-     * A factory method to construct a Ray from points in array format.
-     * @param A - The origin point [x,y]
-     * @param B - The destination point [x,y]
-     * @returns The constructed Ray instance
-     */
-    static fromArrays(A: Canvas.PointTuple, B: Canvas.PointTuple): Ray;
-
-    /**
-     * Project the Array by some proportion of it's initial distance.
-     * Return the coordinates of that point along the path.
-     * @param t - The distance along the Ray
-     * @returns The coordinates of the projected point
-     */
-    project(t: number): PIXI.IPointData;
-
-    /**
-     * Create a Ray by projecting a certain distance towards a known point.
-     * @param origin   - The origin of the Ray
-     * @param point    - The point towards which to project
-     * @param distance - The distance of projection
-     */
-    static towardsPoint(origin: Canvas.Point, point: Canvas.Point, distance: number): Ray;
-
-    /**
-     * Create a Ray by projecting a certain squared-distance towards a known point.
-     * @param origin    - The origin of the Ray
-     * @param point     - The point towards which to project
-     * @param distance2 - The squared distance of projection
-     */
-    static towardsPointSquared(origin: Canvas.Point, point: Canvas.Point, distance2: number): Ray;
-
-    /**
-     * Reverse the direction of the Ray, returning a second Ray
-     */
-    reverse(): Ray;
-
-    /**
-     * Create a new ray which uses the same origin point, but a slightly offset angle and distance
-     * @param offset   - An offset in radians which modifies the angle of the original Ray
-     * @param distance - A distance the new ray should project, otherwise uses the same distance.
-     * @returns A new Ray with an offset angle
-     */
-    shiftAngle(
-      offset: number,
-      /**
-       * @defaultValue `this.distance`
-       * @remarks Default provided by `||`, so `0` is effectively `this.distance`
-       */
-      distance?: number | null,
-    ): Ray;
-
-    /**
-     * Find the point I[x,y] and distance t* on ray R(t) which intersects another ray
-     * @see foundry.utils.lineLineIntersection
-     */
-    intersectSegment(coords: Canvas.PairOfPointsTuple): LineIntersection | null;
-  }
-
-  namespace Ray {
-    interface Any extends AnyRay {}
-    type AnyConstructor = typeof AnyRay;
-  }
-}
-
-declare abstract class AnyRay extends Ray {
-  constructor(arg0: never, ...args: never[]);
-}

package/src/foundry/client/pixi/core/shapes/source-polygon.d.mts

@@ -1,339 +0,0 @@
-import type { Brand, Coalesce, InexactPartial, NullishProps } from "fvtt-types/utils";
-import type PointEffectSourceMixin from "../../../../client-esm/canvas/sources/point-effect-source.d.mts";
-
-declare global {
-  /**
-   * An extension of the default PIXI.Polygon which is used to represent the line of sight for a point source.
-   */
-  abstract class PointSourcePolygon extends PIXI.Polygon {
-    /**
-     * @remarks This is protected because `new PointSourcePolygon` does not sufficiently initalize the class; Use the static `create` method instead.
-     */
-    protected constructor(...args: ConstructorParameters<typeof PIXI.Polygon>);
-
-    /**
-     * Customize how wall direction of one-way walls is applied
-     */
-    static WALL_DIRECTION_MODES: PointSourcePolygon.WallDirectionModes;
-
-    /**
-     * The rectangular bounds of this polygon
-     * @defaultValue `new PIXI.Rectangle(0, 0, 0, 0)`
-     */
-    bounds: PIXI.Rectangle;
-
-    /**
-     * The origin point of the source polygon.
-     * @remarks Not initalized to any value, but immediately set by `PointSourcePolygon#initalize`
-     */
-    origin: Canvas.Point;
-
-    /**
-     * The configuration of this polygon.
-     * @remarks Initialized as `{}` but immediately filled by `PointSourcePolygon#initalize`
-     */
-    config: PointSourcePolygon.StoredConfig;
-
-    /**
-     * An indicator for whether this polygon is constrained by some boundary shape?
-     */
-    get isConstrained(): boolean;
-
-    /**
-     * Benchmark the performance of polygon computation for this source
-     * @param iterations - The number of test iterations to perform
-     * @param origin     - The origin point to benchmark
-     * @param config     - The polygon configuration to benchmark
-     */
-    static benchmark(iterations: number, origin: Canvas.Point, config: PointSourcePolygon.Config): Promise<void>;
-
-    /**
-     * Compute the polygon given a point origin and radius
-     * @param origin - The origin source point
-     * @param config - Configuration options which customize the polygon computation
-     * @returns The computed polygon instance
-     * @remarks Subclasses must implement a `.create` override to accurately type the return.
-     *
-     * Despite being a `={}` parameter, a `config` object with a valid `type` property must be passed
-     */
-    static create(origin: Canvas.Point, config: PointSourcePolygon.Config): unknown;
-
-    /**
-     * Create a clone of this polygon.
-     * This overrides the default PIXI.Polygon#clone behavior.
-     * @returns A cloned instance
-     */
-    override clone(): this;
-
-    /**
-     * Compute the polygon using the origin and configuration options.
-     * @returns The computed polygon
-     */
-    compute(): this;
-
-    /**
-     * Perform the implementation-specific computation
-     */
-    protected abstract _compute(): void;
-
-    /**
-     * Customize the provided configuration object for this polygon type.
-     * @param origin - The provided polygon origin
-     * @param config - The provided configuration object
-     */
-    initialize(origin: Canvas.Point, config: PointSourcePolygon.Config): void;
-
-    /**
-     * Apply a constraining boundary shape to an existing PointSourcePolygon.
-     * Return a new instance of the polygon with the constraint applied.
-     * The new instance is only a "shallow clone", as it shares references to component properties with the original.
-     * @param constraint          - The constraining boundary shape
-     * @param intersectionOptions - Options passed to the shape intersection method
-     * @returns A new constrained polygon
-     */
-    applyConstraint(constraint: PIXI.Polygon, intersectionOptions?: PIXI.Polygon.IntersectPolygonOptions): this;
-    applyConstraint(constraint: PIXI.Circle, intersectionOptions?: PIXI.Circle.WACIntersectPolygonOptions): this;
-    applyConstraint(constraint: PIXI.Circle, intersectionOptions?: PIXI.Circle.ClipperLibIntersectPolygonOptions): this;
-    applyConstraint(constraint: PIXI.Rectangle, intersectionOptions?: PIXI.Rectangle.WACIntersectPolygonOptions): this;
-    applyConstraint(
-      constraint: PIXI.Rectangle,
-      intersectionOptions?: PIXI.Rectangle.ClipperLibIntersectPolygonOptions,
-    ): this;
-
-    override contains(x: number, y: number): boolean;
-
-    /**
-     * Constrain polygon points by applying boundary shapes.
-     */
-    protected _constrainBoundaryShapes(): void;
-
-    /**
-     * Test whether a Ray between the origin and destination points would collide with a boundary of this Polygon.
-     * A valid wall restriction type is compulsory and must be passed into the config options.
-     * @param origin      - An origin point
-     * @param destination - A destination point
-     * @param config      - The configuration that defines a certain Polygon type
-     * @param mode        - The collision mode to test: "any", "all", or "closest"
-     *                      (default: "all")
-     * @returns The collision result depends on the mode of the test:
-     *          * any: returns a boolean for whether any collision occurred
-     *          * all: returns a sorted array of PolygonVertex instances
-     *          * closest: returns a PolygonVertex instance or null
-     */
-    static testCollision<Mode extends PointSourcePolygon.CollisionModes | undefined = undefined>(
-      origin: Canvas.Point,
-      destination: Canvas.Point,
-      { mode, ...config }: PointSourcePolygon.TestCollisionConfig<Mode>,
-    ): PointSourcePolygon.TestCollision<Coalesce<Mode, "all">>;
-
-    /**
-     * Determine the set of collisions which occurs for a Ray.
-     * @param ray  - The Ray to test
-     * @param mode - The collision mode being tested
-     * @returns The collision test result
-     */
-    protected abstract _testCollision<Mode extends PointSourcePolygon.CollisionModes>(
-      ray: Ray,
-      mode: Mode,
-    ): PointSourcePolygon.TestCollision<Mode>;
-
-    /**
-     * Visualize the polygon, displaying its computed area, rays, and collision points
-     * @returns The rendered debugging shape
-     */
-    visualize(): PIXI.Graphics | undefined;
-
-    /**
-     * Determine if the shape is a complete circle.
-     * The config object must have an angle and a radius properties.
-     */
-    isCompleteCircle(): boolean;
-
-    /**
-     * Augment a PointSourcePolygon by adding additional coverage for shapes permitted by threshold walls.
-     * @param polygon - The computed polygon
-     * @returns The augmented polygon
-     * @remarks Mutates and returns the same reference it's passed, not a new polygon
-     */
-    static applyThresholdAttenuation<PolyType extends PointSourcePolygon>(polygon: PolyType): PolyType;
-
-    /**
-     * @deprecated since v11, will be removed in v13
-     * @remarks You are referencing PointSourcePolygon#rays which is no longer a required property of that interface.
-     *          If your subclass uses the rays property it should be explicitly defined by the subclass which requires it.
-     */
-    get rays(): Ray[];
-
-    set rays(rays);
-  }
-
-  namespace PointSourcePolygon {
-    interface Any extends AnyPointSourcePolygon {}
-    type AnyConstructor = typeof AnyPointSourcePolygon;
-
-    type WALL_DIRECTION_MODES = Brand<number, "PointSourcePolygon.WALL_DIRECTION_MODES">;
-
-    interface WallDirectionModes {
-      readonly NORMAL: 0 & WALL_DIRECTION_MODES;
-      readonly REVERSED: 1 & WALL_DIRECTION_MODES;
-      readonly BOTH: 2 & WALL_DIRECTION_MODES;
-    }
-
-    /** @internal */
-    type _TestCollisionConfig<Mode> = InexactPartial<{
-      /**
-       * The collision mode to test: "any", "all", or "closest"
-       * @defaultValue `"all"`
-       * @remarks Can't be `null` as it only has a parameter default
-       */
-      mode: Mode;
-    }>;
-
-    interface TestCollisionConfig<Mode> extends _TestCollisionConfig<Mode>, Config {}
-
-    /**
-     * @internal
-     * @privateRemarks Properties of the config that get set in `#initialize` or elsewhere with no respect to their passed value
-     */
-    interface _ComputedConfig {
-      /**
-       * Does this polygon have a limited radius?
-       * @remarks `true` if `(cfg.radius > 0) && (cfg.radius < canvas.dimensions.maxR)`
-       */
-      hasLimitedRadius: boolean;
-
-      /**
-       * Does this polygon have a limited angle?
-       * @remarks `true` if `cfg.angle !== 360`
-       */
-      hasLimitedAngle: boolean;
-    }
-
-    /**
-     * @internal
-     * @privateRemarks Properties of the config that might be omitted but can't be explicitly `undefined`
-     */
-    interface _OptionalOnlyConfig {
-      /**
-       * The object (if any) that spawned this polygon.
-       * @remarks Not guaranteed by `PointSourcePolygon#initalize` but will exist in all configs created by `PointEffectSourceMixin` subclasses. No default provided
-       * @privateRemarks Foundry types this as `PointSource` which is neither a typedef nor a class, not even a mixin class name. The type here matches usage and tracks with what they probably meant.
-       */
-      source?: PointEffectSourceMixin.AnyMixed;
-
-      /**
-       * The external radius of the source
-       * @remarks Can't be `undefined` or `null` or its use in math would produce `NaN`s.
-       *
-       * Not guaranteed by `PointSourcePolygon#initalize` but will exist in all configs created by `PointEffectSourceMixin` subclasses.
-       */
-      externalRadius?: number;
-    }
-
-    /**
-     * @internal
-     * @privateRemarks Properties of the config that have defaults for nullish values in `#initialize`, and thus are guaranteed in the stored config
-     */
-    interface _BaseConfig {
-      /**
-       * A limited radius of the resulting polygon
-       * @defaultValue `canvas.dimensions.maxR`
-       */
-      radius: number;
-
-      /**
-       * The desired density of padding rays, a number per PI
-       * @defaultValue `PIXI.Circle.approximateVertexDensity(cfg.radius)`
-       */
-      density: number;
-
-      /**
-       * The angle of emission, if limited
-       * @defaultValue `360`
-       */
-      angle: number;
-
-      /**
-       * The direction of facing, required if the angle is limited
-       * @defaultValue `0`
-       */
-      rotation: number;
-
-      /**
-       * Does this polygon use the Scene inner or outer bounding rectangle
-       * @defaultValue `true` if `type === "sight"` and the origin point is inside `canvas.dimensions.sceneRect` else `false`
-       * @remarks Computed if not provided or passed nullish.
-       */
-      useInnerBounds: boolean;
-
-      /**
-       * Customize how wall direction of one-way walls is applied
-       * @defaultValue `PointSourcePolygon.WALL_DIRECTION_MODES.NORMAL`
-       */
-      wallDirectionMode: PointSourcePolygon.WALL_DIRECTION_MODES;
-
-      /**
-       * Compute the polygon with threshold wall constraints applied
-       * @defaultValue `false`
-       */
-      useThreshold: boolean;
-
-      /**
-       * Include edges coming from darkness sources
-       * @defaultValue `false`
-       */
-      includeDarkness: boolean;
-
-      /**
-       * Limiting polygon boundary shapes
-       * @defaultValue `[]`
-       * @remarks Never passed in Foundry practice
-       */
-      boundaryShapes: Array<BoundaryShapes>;
-
-      /**
-       * Display debugging visualization and logging for the polygon
-       * @remarks Overriden `true` if `CONFIG.debug.polygons` is truthy
-       */
-      debug?: boolean;
-
-      /**
-       * Priority when it comes to ignore edges from darkness sources
-       * @remarks This is listed in the typedef, but is not in use by Foundry in 12.331
-       */
-      priority?: number;
-    }
-
-    /**
-     * @internal
-     * @privateRemarks The only property required in all configs
-     */
-    interface _RequiredConfig {
-      /** The type of polygon being computed */
-      type: PolygonType;
-    }
-
-    interface StoredConfig extends _RequiredConfig, _BaseConfig, _OptionalOnlyConfig, _ComputedConfig {}
-
-    interface Config extends _RequiredConfig, NullishProps<_BaseConfig>, _OptionalOnlyConfig {}
-
-    type BoundaryShapes = PIXI.Rectangle | PIXI.Circle | PIXI.Polygon;
-
-    type PolygonType = "light" | "sight" | "sound" | "move" | "universal";
-
-    type CollisionModes = "any" | "all" | "closest";
-
-    /** @internal */
-    interface _CollisionTypesReturnMap {
-      any: boolean;
-      closest: foundry.canvas.edges.PolygonVertex | null;
-      all: foundry.canvas.edges.PolygonVertex[];
-    }
-
-    type TestCollision<Mode extends CollisionModes> = _CollisionTypesReturnMap[Mode];
-  }
-}
-
-declare abstract class AnyPointSourcePolygon extends PointSourcePolygon {
-  constructor(arg0: never, ...args: never[]);
-}