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

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

@@ -1,132 +1,143 @@
-import type { InexactPartial } from "../../../../types/utils.d.mts";
-
-declare module "pixi.js" {
-  interface Circle {
-    /**
-     * Determine the center of the circle.
-     * Trivial, but used to match center method for other shapes.
-     */
-    get circle(): 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): [Canvas.Point?, Canvas.Point?];
-
-    /**
-     * 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;
-
-    /**
-     * 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.
-     * @returns The number of points for the approximated polygon
-     */
-    approximateVertexDensity(radius: number, epsilon?: number): number;
-
-    /**
-     * 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
-     */
-    intersectPolygon(
-      polygon: PIXI.Polygon,
-      options?: InexactPartial<{
-        /** The number of points which defines the density of approximation */
-        density: number;
+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;
 
-        /** The clipper clip type */
-        clipType: number;
+      /**
+       * 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<{
         /**
-         * Use the Weiler-Atherton algorithm. Otherwise, use Clipper.
-         * (default: `true`)
-         * */
-        weilerAtherton: boolean;
-      }>,
-    ): 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;
-  }
+         * 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;
+      }>;
 
-  namespace Circle {
-    interface PointsForArcOptions {
-      /** The number of points which defines the density of approximation */
-      density: number;
+      interface PointsForArcOptions extends _PointsForArcOptions {}
 
-      /** Whether to include points at the circle where the arc starts and ends */
-      includeEndpoints: boolean;
+      interface IntersectClipperOptions
+        extends PIXI.Polygon.IntersectClipperOptions,
+          Pick<PIXI.Circle.PointsForArcOptions, "density"> {}
     }
 
-    interface IntersectClipperOptions extends PIXI.Polygon.IntersectClipperOptions {
-          /** The number of points which defines the density of approximation */
-          density?: number | undefined;
+    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;
     }
   }
 }

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

@@ -3,7 +3,9 @@ export {};
 declare global {
   namespace PIXI {
     namespace Graphics {
-      type Path = [number[] | PIXI.IPointData[] | PIXI.Polygon] | Array<number | PIXI.IPointData>;
+      type Path =
+        | [points: number[] | PIXI.IPointData[] | PIXI.Polygon, smoothingFactor?: number]
+        | Array<number | PIXI.IPointData>;
     }
   }
 }

package/src/foundry/client/pixi/extensions/observable-transform.d.mts

@@ -1,11 +1,11 @@
-import type { AnyObject } from "../../../../types/utils.d.mts";
+export {};
 
 declare global {
   /**
    * A custom Transform class allowing to observe changes with a callback.
    * @privateRemarks Scope extends object is intentional; `"The scope bound to an ObservableTransform class must be a valid object/class."`
    */
-  class ObservableTransform<Scope extends AnyObject, CB extends (this: Scope) => unknown> extends PIXI.Transform {
+  class ObservableTransform<CB extends (this: Scope) => unknown, Scope extends object> extends PIXI.Transform {
     /**
      *
      * @param callback - The callback called to observe changes.
@@ -27,4 +27,12 @@ declare global {
 
     protected override updateSkew(): void;
   }
+  namespace ObservableTransform {
+    interface Any extends AnyObservableTransform {}
+    type AnyConstructor = typeof AnyObservableTransform;
+  }
+}
+
+declare abstract class AnyObservableTransform extends ObservableTransform<any, any> {
+  constructor(arg0: never, ...args: never[]);
 }

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

@@ -1,142 +1,163 @@
-import type { InexactPartial } from "../../../../types/utils.d.mts";
-
-declare module "pixi.js" {
-  interface Polygon {
-    /**
-     * Test whether the polygon is has a positive signed area.
-     * Using a y-down axis orientation, this means that the polygon is "clockwise".
-     */
-    get isPositive(): boolean;
-
-    /**
-     * @remarks Non enumerable
-     */
-    _isPositive?: boolean;
-
-    /**
-     * Clear the cached signed orientation.
-     */
-    clearCache(): void;
-
-    /**
-     * Compute the signed area of polygon using an approach similar to ClipperLib.Clipper.Area.
-     * The math behind this is based on the Shoelace formula. https://en.wikipedia.org/wiki/Shoelace_formula.
-     * The area is positive if the orientation of the polygon is positive.
-     * @returns The signed area of the polygon
-     */
-    signedArea(): number;
-
-    /**
-     * Reverse the order of the polygon points in-place, replacing the points array into the polygon.
-     * Note: references to the old points array will not be affected.
-     * @returns This polygon with its orientation reversed
-     */
-    reverseOrientation(): PIXI.Polygon;
-
-    /**
-     * Add a de-duplicated point to the Polygon.
-     * @param point - The point to add to the Polygon
-     * @returns A reference to the polygon for method chaining
-     */
-    addPoint(point: Canvas.Point): this;
-
-    /**
-     * Return the bounding box for a PIXI.Polygon.
-     * The bounding rectangle is normalized such that the width and height are non-negative.
-     * @returns The bounding PIXI.Rectangle
-     */
-    getBounds(): PIXI.Rectangle;
-
-    /**
-     * Construct a PIXI.Polygon instance from an array of clipper points [\{X,Y\}, ...].
-     * @param points  - An array of points returned by clipper
-     * @param options - Options which affect how canvas points are generated
-     * @param scalingFactor -
-     * @returns The resulting PIXI.Polygon
-     */
-    fromClipperPoints(
-      points: PIXI.Polygon.ClipperPoint[],
-      options?: InexactPartial<{
+import type { InexactPartial, NullishProps } from "fvtt-types/utils";
+import * as _PIXI from "pixi.js";
+
+declare global {
+  namespace PIXI {
+    interface Polygon {
+      /**
+       * Test whether the polygon is has a positive signed area.
+       * Using a y-down axis orientation, this means that the polygon is "clockwise".
+       */
+      get isPositive(): boolean;
+
+      /**
+       * @remarks Non enumerable
+       */
+      _isPositive?: boolean;
+
+      /**
+       * Clear the cached signed orientation.
+       */
+      clearCache(): void;
+
+      /**
+       * Compute the signed area of polygon using an approach similar to ClipperLib.Clipper.Area.
+       * The math behind this is based on the Shoelace formula. https://en.wikipedia.org/wiki/Shoelace_formula.
+       * The area is positive if the orientation of the polygon is positive.
+       * @returns The signed area of the polygon
+       */
+      signedArea(): number;
+
+      /**
+       * Reverse the order of the polygon points in-place, replacing the points array into the polygon.
+       * Note: references to the old points array will not be affected.
+       * @returns This polygon with its orientation reversed
+       */
+      reverseOrientation(): this;
+
+      /**
+       * Add a de-duplicated point to the Polygon.
+       * @param point - The point to add to the Polygon
+       * @returns A reference to the polygon for method chaining
+       */
+      addPoint(point: Canvas.Point): this;
+
+      /**
+       * Return the bounding box for a PIXI.Polygon.
+       * The bounding rectangle is normalized such that the width and height are non-negative.
+       * @returns The bounding PIXI.Rectangle
+       */
+      getBounds(): PIXI.Rectangle;
+
+      /**
+       * Convert a PIXI.Polygon into an array of clipper points [\{X,Y\}, ...].
+       * Note that clipper points must be rounded to integers.
+       * In order to preserve some amount of floating point precision, an optional scaling factor may be provided.
+       * @param options - Options which affect how clipper points are generated
+       * @returns An array of points to be used by clipper
+       */
+      toClipperPoints(options?: PIXI.Polygon.ClipperPointsOptions): PIXI.Polygon.ClipperPoint[];
+
+      /**
+       * Determine whether the PIXI.Polygon is closed, defined by having the same starting and ending point.
+       * @remarks Non-enumerable
+       */
+      get isClosed(): boolean;
+
+      /**
+       * Intersect this PIXI.Polygon with another PIXI.Polygon using the clipper library.
+       * @param other   - Another PIXI.Polygon
+       * @param options - Options which configure how the intersection is computed
+       * @returns The intersected polygon
+       */
+      intersectPolygon(other: PIXI.Polygon, options?: PIXI.Polygon.IntersectPolygonOptions): PIXI.Polygon;
+
+      /**
+       * Intersect this PIXI.Polygon with an array of ClipperPoints.
+       * @param clipperPoints - Array of clipper points generated by PIXI.Polygon.toClipperPoints()
+       * @param options       - Options which configure how the intersection is computed
+       */
+      intersectClipper(
+        clipperPoints: PIXI.Polygon.ClipperPoint[],
+        options?: PIXI.Polygon.IntersectClipperOptions,
+      ): PIXI.Polygon.ClipperPoint[];
+
+      /**
+       * Intersect this PIXI.Polygon with a PIXI.Circle.
+       * For now, 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 circle  - A PIXI.Circle
+       * @param options - Options which configure how the intersection is computed
+       * @returns The intersected polygon
+       */
+      intersectCircle(circle: PIXI.Circle, options?: PIXI.Circle.IntersectClipperOptions): PIXI.Polygon;
+
+      /**
+       * Intersect this PIXI.Polygon with a PIXI.Rectangle.
+       * For now, convert the rectangle to a Polygon and use intersectPolygon.
+       * In the future we may replace this with more specialized logic which uses the line-line intersection formula.
+       * @param rect    - A PIXI.Rectangle
+       * @param options - Options which configure how the intersection is computed
+       * @returns The intersected polygon
+       */
+      intersectRectangle(rect: PIXI.Rectangle, options?: PIXI.Rectangle.WACIntersectPolygonOptions): PIXI.Polygon;
+      intersectRectangle(
+        rect: PIXI.Rectangle,
+        options?: PIXI.Rectangle.ClipperLibIntersectPolygonOptions,
+      ): PIXI.Polygon;
+    }
+
+    namespace Polygon {
+      type OrPointsFlat = number[] | PIXI.Polygon;
+      type OrPoints = OrPointsFlat | PIXI.IPointData[];
+
+      /** @privateRemarks Foundry uses this type instead of full `ClipperLib.IntPoint` objects */
+      interface ClipperPoint {
+        X: number;
+        Y: number;
+      }
+
+      /** @internal  */
+      type _IntersectClipperOptions = InexactPartial<{
         /**
-         * A scaling factor used to preserve floating point precision
+         * A scaling factor passed to Polygon#toClipperPoints to preserve precision
+         * @remarks Can't be `null` as, where it has any, it only has parameter defaults
          * @defaultValue `1`
          */
         scalingFactor: number;
-      }>,
-    ): PIXI.Polygon;
-
-    /**
-     * Convert a PIXI.Polygon into an array of clipper points [\{X,Y\}, ...].
-     * Note that clipper points must be rounded to integers.
-     * In order to preserve some amount of floating point precision, an optional scaling factor may be provided.
-     * @param options - Options which affect how clipper points are generated
-     * @returns An array of points to be used by clipper
-     */
-    toClipperPoints(options?: {
-      /** A scaling factor used to preserve floating point precision
-       *  (default: `1`) */
-      scalingFactor: number;
-    }): PIXI.Polygon.ClipperPoint[];
-
-    /**
-     * Determine whether the PIXI.Polygon is closed, defined by having the same starting and ending point.
-     */
-    get isClosed(): boolean;
-
-    /**
-     * Intersect this PIXI.Polygon with another PIXI.Polygon using the clipper library.
-     * @param other   - Another PIXI.Polygon
-     * @param options - Options which configure how the intersection is computed
-     * @returns The intersected polygon
-     */
-    intersectPolygon(other: PIXI.Polygon, options: PIXI.Polygon.IntersectClipperOptions): PIXI.Polygon;
-
-    /**
-     * Intersect this PIXI.Polygon with an array of ClipperPoints.
-     * @param clipperPoints - Array of clipper points generated by PIXI.Polygon.toClipperPoints()
-     * @param options       - Options which configure how the intersection is computed
-     */
-    intersectClipper(
-      clipperPoints: PIXI.Polygon.ClipperPoint[],
-      options?: PIXI.Polygon.IntersectClipperOptions,
-    ): PIXI.Polygon.ClipperPoint[];
-
-    /**
-     * Intersect this PIXI.Polygon with a PIXI.Circle.
-     * For now, 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 circle  - A PIXI.Circle
-     * @param options - Options which configure how the intersection is computed
-     * @returns The intersected polygon
-     */
-    intersectCircle(circle: PIXI.Circle, options?: PIXI.Circle.IntersectClipperOptions): PIXI.Polygon;
-
-    /**
-     * Intersect this PIXI.Polygon with a PIXI.Rectangle.
-     * For now, convert the rectangle to a Polygon and use intersectPolygon.
-     * In the future we may replace this with more specialized logic which uses the line-line intersection formula.
-     * @param rect    - A PIXI.Rectangle
-     * @param options - Options which configure how the intersection is computed
-     * @returns The intersected polygon
-     */
-    intersectRectangle(rect: PIXI.Rectangle, options?: PIXI.Rectangle.IntersectPolygonOptions): PIXI.Polygon;
-  }
-
-  namespace Polygon {
-    interface ClipperPoint {
-      X: number;
-      Y: number;
+      }> &
+        NullishProps<{
+          /**
+           * The clipper clip type
+           * @defaultValue `ClipperLib.ClipType.ctIntersection`
+           * @remarks ClipperLib functions require a non-nullish `ClipperLib.ClipType` value, but the Foundry functions have `??=` guards for this.
+           */
+          clipType: ClipperLib.ClipType;
+        }>;
+
+      interface IntersectClipperOptions extends _IntersectClipperOptions {}
+
+      /**
+       * @privateRemarks Separate interface despite identical keys for purposes of declaration merging
+       * and just having an expected name for external reference
+       */
+      interface IntersectPolygonOptions extends _IntersectClipperOptions {}
+
+      interface ClipperPointsOptions extends Pick<PIXI.Polygon.IntersectClipperOptions, "scalingFactor"> {}
     }
 
-    /** @internal Helper type for interface to simplify InexactPartial usage */
-    type _IntersectClipperOptions = InexactPartial<{
-      /** The clipper clip type */
-      clipType: number;
-
-      /** A scaling factor passed to Polygon#toClipperPoints to preserve precision */
-      scalingFactor: number;
-    }>;
-
-    interface IntersectClipperOptions extends _IntersectClipperOptions {}
+    class Polygon extends _PIXI.Polygon {
+      /**
+       * Construct a PIXI.Polygon instance from an array of clipper points [\{X,Y\}, ...].
+       * @param points  - An array of points returned by clipper
+       * @param options - Options which affect how canvas points are generated
+       * @param scalingFactor -
+       * @returns The resulting PIXI.Polygon
+       */
+      static fromClipperPoints(
+        points: PIXI.Polygon.ClipperPoint[],
+        options?: PIXI.Polygon.ClipperPointsOptions,
+      ): PIXI.Polygon;
+    }
   }
 }