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

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

@@ -1,189 +0,0 @@
-import type { Identity } from "fvtt-types/utils";
-import type { LineIntersection } from "#common/utils/geometry.d.mts";
-
-declare global {
-  /**
-   * @deprecated {@link Ray.Intersection | `Ray.Intersection`}
-   */
-  type RayIntersection = Ray.Intersection;
-
-  /**
-   * 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 {@link foundry.utils.lineLineIntersection | `foundry.utils.lineLineIntersection`}
-     */
-    intersectSegment(coords: Canvas.PairOfPointsTuple): LineIntersection | null;
-  }
-
-  namespace Ray {
-    interface Any extends AnyRay {}
-    interface AnyConstructor extends Identity<typeof AnyRay> {}
-
-    interface Intersection {
-      /** 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;
-    }
-  }
-}
-
-declare abstract class AnyRay extends Ray {
-  constructor(...args: never);
-}

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

@@ -1,344 +0,0 @@
-import type { Brand, Coalesce, Identity, 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 initialize 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 initialized to any value, but immediately set by `PointSourcePolygon#initialize`
-     */
-    origin: Canvas.Point;
-
-    /**
-     * The configuration of this polygon.
-     * @remarks Initialized as `{}` but immediately filled by `PointSourcePolygon#initialize`
-     */
-    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, // not:null (property set on it via `??=`)
-    ): 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
-     * @remarks Despite being an `={}` parameter, `options` is required as it must be a valid
-     * `PointSourcePolygon.Config`, which has a required property (`type`)
-     */
-    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 {}
-    interface AnyConstructor extends Identity<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#initialize` 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#initialize` 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 Overridden `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(...args: never);
-}

package/src/foundry/client/pixi/extensions/circle.d.mts

@@ -1,143 +0,0 @@
-import type { NullishProps } from "fvtt-types/utils";
-import type { LineCircleIntersection } from "#common/utils/geometry.d.mts";
-import * as _PIXI from "pixi.js";
-
-declare global {
-  namespace PIXI {
-    interface Circle {
-      /**
-       * Determine the center of the circle.
-       * Trivial, but used to match center method for other shapes.
-       */
-      get center(): PIXI.Point;
-
-      /**
-       * Determine if a point is on or nearly on this circle.
-       * @param point   - Point to test
-       * @param epsilon - Tolerated margin of error
-       *                  (default: `1e-08`)
-       * @returns Is the point on the circle within the allowed tolerance?
-       */
-      pointIsOn(point: Canvas.Point, epsilon?: number): boolean;
-
-      /**
-       * Get all intersection points on this circle for a segment A|B
-       * Intersections are sorted from A to B.
-       * @param a - The first endpoint on segment A|B
-       * @param b - The second endpoint on segment A|B
-       * @returns Points where the segment A|B intersects the circle
-       */
-      segmentIntersections(a: Canvas.Point, b: Canvas.Point): LineCircleIntersection["intersections"];
-
-      /**
-       * Calculate an x,y point on this circle's circumference given an angle
-       * 0: due east
-       * π / 2: due south
-       * π or -π: due west
-       * -π/2: due north
-       * @param angle - Angle of the point, in radians
-       * @returns The point on the circle at the given angle
-       */
-      pointAtAngle(angle: number): Canvas.Point;
-
-      /**
-       * Get all the points for a polygon approximation of this circle between two points.
-       * The two points can be anywhere in 2d space. The intersection of this circle with the line from this circle center
-       * to the point will be used as the start or end point, respectively.
-       * This is used to draw the portion of the circle (the arc) between two intersection points on this circle.
-       * @param a       - Point in 2d space representing the start point
-       * @param b       - Point in 2d space representing the end point
-       * @param options - Options passed on to the pointsForArc method
-       * @returns An array of points arranged clockwise from start to end
-       */
-      pointsBetween(a: Canvas.Point, b: Canvas.Point, options?: Circle.PointsForArcOptions): Canvas.Point[];
-
-      /**
-       * Get the points that would approximate a circular arc along this circle, given a starting and ending angle.
-       * Points returned are clockwise. If from and to are the same, a full circle will be returned.
-       * @param fromAngle - Starting angle, in radians. π is due north, π/2 is due east
-       * @param toAngle   - Ending angle, in radians
-       * @param options   - Options which affect how the circle is converted
-       * @returns An array of points along the requested arc
-       */
-      pointsForArc(fromAngle: number, toAngle: number, options?: Circle.PointsForArcOptions): Canvas.Point[];
-
-      /**
-       * Approximate this PIXI.Circle as a PIXI.Polygon
-       * @param options - Options forwarded on to the pointsForArc method
-       * @returns The Circle expressed as a PIXI.Polygon
-       */
-      toPolygon(options?: Circle.PointsForArcOptions): PIXI.Polygon;
-
-      /**
-       * Intersect this PIXI.Circle with a PIXI.Polygon.
-       * @param polygon - A PIXI.Polygon
-       * @param options - Options which configure how the intersection is computed
-       * @returns The intersected polygon
-       * @remarks Slightly bugged in v12; if `options.weilerAtherton` is falsey, it will not pass on `options.clipType` to `PIXI.Polygon#intersectPolygon`,
-       * forcing the default of `ClipperLib.ClipTypes.ctIntersection`
-       */
-      intersectPolygon(polygon: PIXI.Polygon, options?: PIXI.Circle.WACIntersectPolygonOptions): PIXI.Polygon;
-      intersectPolygon(polygon: PIXI.Polygon, options?: PIXI.Circle.ClipperLibIntersectPolygonOptions): PIXI.Polygon;
-
-      /**
-       * Intersect this PIXI.Circle with an array of ClipperPoints.
-       * Convert the circle to a Polygon approximation and use intersectPolygon.
-       * In the future we may replace this with more specialized logic which uses the line-circle intersection formula.
-       * @param clipperPoints - Array of ClipperPoints generated by PIXI.Polygon.toClipperPoints()
-       * @param options       - Options which configure how the intersection is computed
-       * @returns The intersected polygon
-       */
-      intersectClipper(
-        clipperPoints: PIXI.Polygon.ClipperPoint[],
-        options?: PIXI.Circle.IntersectClipperOptions,
-      ): PIXI.Polygon;
-    }
-
-    namespace Circle {
-      /** @remarks The options for `intersectPolygon` when `weilerAtherton` is true (or not provided) */
-      interface WACIntersectPolygonOptions extends PIXI.Rectangle.WACIntersectPolygonOptions {}
-
-      /** @remarks The options for `intersectPolygon` when `weilerAtherton` is false. */
-      interface ClipperLibIntersectPolygonOptions
-        extends PIXI.Rectangle.ClipperLibIntersectPolygonOptions,
-          Pick<PIXI.Circle.PointsForArcOptions, "density"> {}
-
-      /** @internal Helper type to simplify use of optionality- and nullish-permissiveness-modifying helpers */
-      type _PointsForArcOptions = NullishProps<{
-        /**
-         * The number of points which defines the density of approximation
-         * @defaultValue `PIXI.Circle.approximateVertexDensity(this.radius)`
-         * @remarks Default provided by `??=` in `pointsForArc` function body
-         */
-        density: number;
-
-        /**
-         * Whether to include points at the circle where the arc starts and ends
-         * @defaultValue `true`
-         */
-        includeEndpoints: boolean;
-      }>;
-
-      interface PointsForArcOptions extends _PointsForArcOptions {}
-
-      interface IntersectClipperOptions
-        extends PIXI.Polygon.IntersectClipperOptions,
-          Pick<PIXI.Circle.PointsForArcOptions, "density"> {}
-    }
-
-    class Circle extends _PIXI.Circle {
-      /**
-       * The recommended vertex density for the regular polygon approximation of a circle of a given radius.
-       * Small radius circles have fewer vertices. The returned value will be rounded up to the nearest integer.
-       * See the formula described at:
-       * https://math.stackexchange.com/questions/4132060/compute-number-of-regular-polgy-sides-to-approximate-circle-to-defined-precision
-       * @param radius  - Circle radius
-       * @param epsilon - The maximum tolerable distance between an approximated line segment and the true radius.
-       *                  A larger epsilon results in fewer points for a given radius. (default: `1`)
-       * @returns The number of points for the approximated polygon
-       */
-      static approximateVertexDensity(radius: number, epsilon?: number): number;
-    }
-  }
-}